המורה שלנו הטיל עלינו פרויקט

והייתי רוצה לשמוע עצות וטיפים על איך לעשות וכו'...

המטלה:

סימולציה של זבובים על המסך בעזרת X ו- Y

וכל מיני פקודות שקשורים לכמות של הזבובים , פגישה של הזבובים (יצירת זבוב חדש) וכו'..

בבקשה עזרו ותנו טיפים

עידכון:

הנה הפרטים

אני משתמש בC/C++

יש צורך ברשימות מקושרות (אחת הדרכים ליצור את התרגיל)

הפרטים של זבוב:

*זבוב הוא זכר או נקבה (ומיוצג על ידי X Y בהתאם)

*לזבוב אורך חיים מוגבל

*מפגש בין X ל Y יוצר זבוב חדש

* כל מפגש מקצר את חיו של X ב 10%

* כל מפגש מקצר את חיו של Y ב 5%

*כאחר יחס X+Y לשטח = 80% תוחלת חיים קטנה ב50%

// flyWorld.cpp //
// A simulation of fly's by using X's and Y's //

//** ספריות מוכללות **//
//#include <alloc.h>
#include <stdio.h>  
#include <graph.h>
#include <conio.h>
#include <stdlib.h>
#include <time.h>
#include <iostream.h>
//#include <windows.h>
//** משתנים קבועים **//
#define START 20	//מספר הזבובים ההתחלתיים
#define X_LIMIT 80		//גבולות הזבוב
#define Y_LIMIT 80		//
#define MAX_AGE  16		// גיל מקסימלי של זבוב
#define LOOPS 20		// מספר הלולאות של הסימולציה

//** הרשימה **//
typedef struct list_info_type{
	int age;
	int x,y;
	char gender;
}list_info_type;
typedef struct link_type *pos_type;
typedef struct link_type {
	list_info_type info;
	pos_type next;
}link_type ;
typedef struct list_type{
	pos_type anchor;
}list_type;

//**//
/*void gotoxy(int xpos, int ypos)
{
  COORD scrn;    

  HANDLE hOuput = GetStdHandle(STD_OUTPUT_HANDLE); 

  scrn.X = xpos; scrn.Y = ypos;

  SetConsoleCursorPosition(hOuput,scrn);
}*/

/*---------------------------------------------------------------------------------*/
//** פונקציות בסיסיות על רשימה **//

// אתחל-רשימה: פעולה המחזירה רשימה ריקה //
void list_init(list_type *l)
{
	//pos_type p;
	l->anchor=(link_type *)malloc(sizeof(link_type));
	l->anchor->next=NULL;
}

// L פעולה המחזירה את המקום עוגן רשימה ברשימה :(L)עוגן-רשימה 
pos_type  list_anchor(list_type *l)
{
	return l->anchor;
}

// L פעולה המחזירה את המקום סוף רשימה ברשימה :(L)סוף-רשימה 
pos_type list_end(list_type *l)
{
	return NULL;
}

// L ברשימה P,פעולה המחזירה את המקום העוקב למקום :(L,p)עוקב-ברשימה 
pos_type  list_next(list_type *l,pos_type p)
{
	return p->next;
}

// L ברשימה P פעולה המחזירה את המקום הקודם למקום :(L,p)קודם-ברשימה 
pos_type  list_prev(list_type *l,pos_type p)
{
	pos_type q;
	q=list_anchor(l);
	while (list_next(l,q)!=p)
	{
		q=list_next(l,q);
	}
	return q;
}

// P מקום אחד אחרי המקום x את האיבר.L פעולה המכניסה לרשימה :(L,P,x)הכנס-לרשימה 
void list_insert(list_type *l,pos_type p ,list_info_type x)
{
	pos_type q;
	q=(link_type *)malloc(sizeof(link_type));
	q->info=x;
	q->next=list_next(l,p);
	p->next=q;
}

// P את האיבר בה נמצא במקום L פעולה המוציאה מרשימה  :(L,P)הוצא-מרשימה 
// את האיבר שהיה עוקב לזה שהוצא מהרשימה P לאחר ההוצאה נמצא במקום
void list_delete(list_type *l,pos_type *p)
{
	pos_type q;
	q=list_prev(l,*p);
	q->next=(*p)->next;
	free(*p);
	//*p=list_next(l,q);//or
	*p=q->next;
}

// x להיות P פעולה המעדכנת את האיבר הנמצא במקום:(L,P,x)עדכן-רשימה
void  list_update(list_type *l,pos_type p ,list_info_type x)
{
      p->info=x;
}

// L ברשימה P פעולה המחזירה את האיבר שנמצא במקום :(L,P) אחזר-מרשימה
list_info_type  list_retrieve(list_type *l,pos_type p)
{
	return p->info; 
}

// היא ריקה אחרת שקר L פעולה המחזירה אמת אם הרשימה :(L)?רשימה-ריקה
int  empty_list(list_type *l)
{
	if ( list_next(l,list_anchor(l))==list_end(l))
		return 1  ;
	return 0;
}

/*---------------------------------------------------------------------------------*/
//** פונקציות הסימולטור **//

//** יוצר זבובים **//
list_info_type flyGenerator()
{
	int randTemp;
	list_info_type fly;

	srand( (unsigned)time( NULL ) ); // בשביל הראנדומל

	randTemp = rand()%2;
	switch (randTemp)
	{
		case 0: fly.gender = 'Y';
			break;
		case 1: fly.gender = 'X';
			break;
	}
	fly.x = rand()%X_LIMIT;
	fly.y = rand()%Y_LIMIT;
	fly.age = 0;

	return fly;
}

//** אתחול מתקדם: יוצר את הרשימה ויוצר את הזבובים הראשונים שלה **//
void advInit(list_type *flyWorld)
{   	
	list_init(flyWorld);
	for (int i=0; i<START;i++) // יש בעיה לא רוצה להשתמש בקבוע של מספר הזבובים ההתחלתי
		list_insert(flyWorld,list_anchor(flyWorld),flyGenerator());
}

//** הורג זבובים אם הגיל מעל גיל מותר **//
void deadFly(list_type *l)
{
	list_info_type temp;
	pos_type pos = list_anchor(l);

	while (list_next(l,pos)!=list_end(l))
	{
		temp = list_retrieve(l,pos);
		if (temp.age > 16)
			list_delete(l,&pos);
		pos = list_next(l,pos);
	}
}

//** מעלה את הגיל של הזבוב ב1 **//
void ageFly(list_type *l)
{
	list_info_type temp;
	pos_type pos = list_anchor(l);

	while (list_next(l,pos)!=list_end(l))
	{
		temp = list_retrieve(l,pos);
		temp.age++;
		list_update(l,pos,temp);
		pos = list_next(l,pos);
	}
}

//**של זוג זבובים זהה Y וה Xיוצר זבוב חדש אם ה **//
void bornFly(list_type *l)
{
	list_info_type one;
	list_info_type two;
	pos_type posA = list_anchor(l);
	pos_type posB = list_next(l,posA);
	pos_type anc = list_anchor(l);
	while (list_next(l,posA)!=list_end(l))
	{
		one = list_retrieve(l,posA);
		while (list_next(l,posA)!=list_end(l))
		{
			two = list_retrieve(l,posB);
			if ((one.x == two.x)&&(one.y==two.y)&&(one.gender!=two.gender))
			{
				list_insert(l,anc,flyGenerator());
				if (one.gender == 'X')
					one.age = (int)one.age-(one.age*0.1);
				else
					one.age = (int)one.age-(one.age*0.05);
				if (two.gender == 'X')
					two.age = (int)two.age-(two.age*0.1);
				else
					two.age = (int)two.age-(two.age*0.05);
			}
			list_update(l,posA,one);
			list_update(l,posB,two);
			posB = list_next(l,posB);

		}
		posA= list_next(l,posA);
		posB= list_next(l,posA);
	}
}
//** סופר כמה זבובים יש **//
int howManyFlys(list_type *l)
{
	int flyNum=0;
	pos_type pos = list_anchor(l);

	while (list_next(l,pos)!=list_end(l))
	{
		pos = list_next(l,pos);
		flyNum++;
	}
	return flyNum;
}
//** ויש יותר מ80 אחוז זבובים לשטח חיי הזבוב הבוגר מתקצרים בחצי **// 
void toMuchFlys(list_type *l)
{
	list_info_type data;
	pos_type pos = list_anchor(l);
	int flyNum=howManyFlys(l);

	if (flyNum > (int)X_LIMIT*Y_LIMIT*0.8)
	{
		while (list_next(l,pos)!=list_end(l))
		{
			data = list_retrieve(l,pos);
			if (data.age > 16/2)
			{
				data.age = (int)data.age/2;
				list_update(l,pos,data);
			}
			pos = list_next(l,pos);
		}		
	}
}
//** שינוי המיקום של הזבוב **//
void moveFly(list_type *l)
{
	list_info_type fly;
	pos_type pos = list_anchor(l);
	int randTemp;
	while (list_next(l,pos)!=list_end(l))
	{
		srand( (unsigned)time( NULL ) ); // בשביל הראנדומל
		fly = list_retrieve(l,pos);
		while ((fly.x>X_LIMIT)||(fly.x<0)||(fly.y>Y_LIMIT)||(fly.y<0))
		{
			randTemp = rand()%8;
			switch (randTemp)
			{
				case 0: fly.x++ ; 
					break;
				case 1: fly.x-- ;
					break;
				case 2: fly.y++ ;
					break;
				case 3: fly.y-- ;
					break;
				case 4: fly.x++ ;
						fly.y++ ;
					break;
				case 5: fly.x-- ;
						fly.y-- ;
					break;
				case 6: fly.x++ ;
						fly.y-- ;
					break;
				case 7: fly.x-- ;
						fly.y++ ;
					break;
			}
		}
		list_update(l,pos,fly);
		pos = list_next(l,pos);
	}
}
//** הצגת הזבובים על המסך **//
void simulation(list_type *l)
{
	list_info_type temp;
	pos_type pos = list_anchor(l);

	while (list_next(l,pos)!=list_end(l))
	{
		temp =list_retrieve(l,pos);
		_settextposition(temp.x,temp.y);
		printf("%c",temp.gender);
	}
}

//** 
void startFlySimulation()
{	
	list_type flyWorld;
	int loop = 0;
	advInit(&flyWorld);	
	while ( (loop <= LOOPS ) || (empty_list(&flyWorld)!= 1))
	{
		_clearscreen(_GCLEARSCREEN);
		deadFly(&flyWorld);
		bornFly(&flyWorld);
		toMuchFlys(&flyWorld);
		simulation(&flyWorld);
		moveFly(&flyWorld);
		ageFly(&flyWorld);
		loop++;
		//getch();
	}
}


//** MAIN פונקציית ה **//
void main()
{
	startFlySimulation();
}

לא היה לי כוח לקרוא את הכל, אבל הרנדום שלך לא יעבוד כמו שצריך.

אתה לא אמור לקרוא ל- srand יותר מפעם אחת. אם אתה קורא לו פעמיים באותה שניה, אתה תקבל אותם ערכים (כלומר הזבובים שלך ישנו כיוון רק פעם בשניה)

העניין הוא לא הSRAND

אלא כל התוכנית שלא עובדת

מילא הראנד, אז היו כולם באותו מקום

לא אמרת מה הבעיה...

הקומפיילר נותן לך בעיה? אתה לא רואה כלום על המסך?

טוב, ה- list_delete שלך ממש ממש לא בסדר.

אתה מבלבל בין *p ל- p (אתה אמור להשתמש שם רק ב- p) ובגלל זה הרבה דברים רעים קורים.

שים לב שלDELETE כדאי ואף מחייב לשלוח ** ולא *, במקרה שאתה מוחק את הראשון.

ד.א. C של בית ספר מסבך את החיים.

אתה לא בודק את המקרה ש-P הוא NULL.