cidade.cpp

3d游戏开发的基础应用,3d场景的真实展现,可以是很好的教材

						 if(r->e->s) return true;
					 if(r->w)
						 if(r->w->s) return true;
					 break;
		case ESTE :  if(r->n)
						 if(r->n->e) return true;
					 if(r->s)
						 if(r->s->e) return true;
					 break;
		case OESTE : if(r->n)
						 if(r->n->w) return true;
					 if(r->s)
						 if(r->s->w) return true;
					 break;
	}
	return false;
}

Direccoes FindDir(float ang) {
	if(ang>=7.0f*D_PI4 || ang<D_PI4) return NORTE;
	if(ang>=D_PI4 && ang<3.0f*D_PI4) return ESTE;
	if(ang>=3.0f*D_PI4 && ang<5.0f*D_PI4) return SUL;
	if(ang>=5.0f*D_PI4 && ang<7.0f*D_PI4) return OESTE;
	return NORTE;
}

rua *NextRua(rua *r, Direccoes d) {
	switch(d) {
		case NORTE : return r->n; break;
		case SUL : return r->s; break;
		case ESTE : return r->e; break;
		case OESTE : return r->w; break;
	}
	return NULL;
}

Direccoes DirEsq(Direccoes d) {
	switch(d) {
		case NORTE : return OESTE; break;
		case SUL : return ESTE; break;
		case ESTE : return NORTE; break;
		case OESTE : return SUL; break;
	}
	return NORTE;
}

Direccoes DirDir(Direccoes d) {
	switch(d) {
		case NORTE : return ESTE; break;
		case SUL : return OESTE; break;
		case ESTE : return SUL; break;
		case OESTE : return NORTE; break;
	}
	return NORTE;
}

void criaLR(ListaRua **rz, rua *r, Direccoes d, int n, int ct) {
ListaRua *t;
	while(r && n) {
		t=(ListaRua *) malloc(sizeof(ListaRua));
		t->r=r;
		t->aux=ct;
		t->nx=*rz;
		*rz=t;
		r=NextRua(r, d);
		n--;
		ct++;
	}
}

int decide(Movel *car) {
int dix=car->r->x-car->rvs->x, diz=car->r->z-car->rvs->z, dax=abs(dix), daz=abs(diz);
        switch(car->dir) {
                case NORTE : if(diz>=Bdiv || (diz>0 && daz>=dax)) return 0;
							 if(car->r->e && dix<=0) return 2;
							 if(car->r->w && dix>=0) return 1;
							 break;
                case SUL : if(diz<=-Bdiv || (diz<0 && daz>=dax)) return 0;
						   if(car->r->e && dix<=0) return 1;
                           if(car->r->w && dix>=0) return 2;
						   break;
                case ESTE : if(dix<=-Bdiv || (dix<0 && dax>=daz)) return 0;
							if(car->r->s && diz<=0) return 2;
							if(car->r->n && diz>=0) return 1;
							break;
                case OESTE : if(dix>=Bdiv || (dix>0 && dax>=daz)) return 0;
							 if(car->r->s && diz<=0) return 1;
							 if(car->r->n && diz>=0) return 2;
							 break;
		}
        return 0;
}

float Dist(Movel *ca, Movel *cb) {
	if(ca->dir!=cb->dir) return MinVizCar;
	switch(ca->dir) {
		case NORTE : return (float)fabs(ca->gz-cb->gz);
		case SUL : return (float)fabs(ca->gz-cb->gz);
		case ESTE : return (float)fabs(ca->gx-cb->gx);
		case OESTE : return (float)fabs(ca->gx-cb->gx);
	}
	return MinVizCar;
}

Movel *VFrente(Movel *car, rua *rd) {
float hs=0, tf;
Movel *tcar, *rcar=NULL;
Clog *cl;
	
	switch(car->dir) {
		case NORTE : hs=VizCar; break;
		case SUL : hs=-VizCar; break;
		case ESTE : hs=-VizCar; break;
		case OESTE : hs=VizCar; break;
	}
	for(cl=rd->rlog;cl;cl=cl->nx) {
		tcar=(Movel *)cl->car;
		if(tcar!=car && tcar->dir==car->dir) 
			switch(car->dir) {
				case NORTE : 
					tf=car->gz-tcar->gz;
					if(tf>0 && tf<hs) {
						rcar=tcar;
						hs=tf;
					}
					if(tf==0) {
						tcar->gz-=0.1f;
						tcar->z-=0.1f;
					}
					break;
				case SUL : 
					tf=car->gz-tcar->gz;
					if(tf<0 && tf>hs) {
						rcar=tcar;
						hs=tf;
					}
					if(tf==0) {
						tcar->gz+=0.1f;
						tcar->z+=0.1f;
					}
					break;
				case ESTE : 
					tf=car->gx-tcar->gx;
					if(tf<0 && tf>hs) {
						rcar=tcar;
						hs=tf;
					}
					if(tf==0) {
						tcar->gx+=0.1f;
						tcar->x+=0.1f;
					}
					break;
				case OESTE : 
					tf=car->gx-tcar->gx;
					if(tf>0 && tf<hs) {
						rcar=tcar;
						hs=tf;
					}
					if(tf==0) {
						tcar->gx-=0.1f;
						tcar->x-=0.1f;
					}
					break;
			}
	}
	return rcar;
}

Movel *VTras(Movel *car, rua *rd) {
float hs=0, tf;
Movel *tcar, *rcar=NULL;
Clog *cl;
		
	switch(car->dir) {
		case NORTE : hs=-VizCar; break;
		case SUL : hs=VizCar; break;
		case ESTE : hs=VizCar; break;
		case OESTE : hs=-VizCar; break;
	}
	for(cl=rd->rlog;cl;cl=cl->nx) {
		tcar=(Movel *)cl->car;
		if(tcar!=car && tcar->dir==car->dir) 
			switch(car->dir) {
				case NORTE : 
					tf=car->gz-tcar->gz;
					if(tf<0 && tf>hs) {
						rcar=tcar;
						hs=tf;
					}
					break;
				case SUL : 
					tf=car->gz-tcar->gz;
					if(tf>0 && tf<hs) {
						rcar=tcar;
						hs=tf;
					}
					break;
				case ESTE : 
					tf=car->gx-tcar->gx;
					if(tf>0 && tf<hs) {
						rcar=tcar;
						hs=tf;
					}
					break;
				case OESTE : 
					tf=car->gx-tcar->gx;
					if(tf<0 && tf>hs) {
						rcar=tcar;
						hs=tf;
					}
					break;
			}
	}
	return rcar;
}									

void Vizinha(Movel *car) {

	car->nx=VFrente(car, car->r);
	car->pv=VTras(car, car->r);
	
	switch(car->dir) {
		case NORTE : 
			if(!car->nx && car->z<VizCar) 
				if(car->r->n)
					car->nx=VFrente(car, car->r->n);
			if(!car->pv && car->z>EstLmVizCar) 
				if(car->r->s)
					car->pv=VTras(car, car->r->s);
			break;
		case SUL : 
			if(!car->nx && car->z>EstLmVizCar)
				if(car->r->s) 
					car->nx=VFrente(car, car->r->s);
			if(!car->pv && car->z<VizCar)
				if(car->r->n)
					car->pv=VTras(car, car->r->n);
			break;
		case ESTE : 
			if(!car->nx && car->x>EstLmVizCar)
				if(car->r->e)
					car->nx=VFrente(car, car->r->e);
			if(!car->pv && car->x<VizCar)
				if(car->r->w)
					car->pv=VTras(car, car->r->w);
			break;
		case OESTE : 
			if(!car->nx && car->x<VizCar)
				if(car->r->w)
					car->nx=VFrente(car, car->r->w);
			if(!car->pv && car->x>EstLmVizCar)
				if(car->r->e)
					car->pv=VTras(car, car->r->e);
			break;
	}
}

void FindPos(Movel *car, float t) {
	switch(car->dir) {
		case NORTE : car->x=Hd; car->z=t; break;
		case SUL : car->x=He; car->z=t; break;
		case ESTE : car->x=t; car->z=Hd; break;
		case OESTE : car->x=t; car->z=He; break;
	}
}

bool NoCar(Movel *c, int mxi) {
	for(int j=0;j<mxi;j++)
		if(carros[j].r==c->r && carros[j].dir==c->dir && fabs(carros[j].x-c->x)<CarDim && fabs(carros[j].z-c->z)<CarDim)
			return false;
	return true;
}

void CarroInit(Movel *c, int mxi) {
bool v;
int rdm;

	do {
		do c->r=findrua(rand()%Nqx+1, rand()%Nqz+1);
		while(!c->r);
		do c->rvs=findrua(rand()%Nqx+1, rand()%Nqz+1);
		while(!c->rvs || c->rvs==c->r);

		do {
			v=true;
			rdm=rand()%4;
			switch(rdm) {
				case NORTE : if(c->r->n) v=false; c->roty=0; break;
				case SUL : if(c->r->s) v=false; c->roty=D3DX_PI; break;
				case ESTE : if(c->r->e) v=false; c->roty=D_PI2; break;
				case OESTE : if(c->r->w) v=false; c->roty=3.0f*D_PI2; break;
			}
		} while(v);

		c->dir=FindDir(c->roty);
		c->estado=0;
		FindPos(c, EstradaL/2.0f+(rand()%(int)(100*EstradaL/2.0f))/100.0f-EstradaL/4.0f);
	} while(!NoCar(c, mxi));
	c->gx=c->r->x*EstradaL+EstradaL+c->x;
	c->gz=c->r->z*EstradaL+EstradaL+c->z;	
	criaLog(&(c->r->rlog), c);
}	

void FindPosPeao(Peao *pea, float t) {
	switch(pea->dir) {
		case NORTE : pea->x=Hpd; pea->z=t; break;
		case SUL : pea->x=Hpe; pea->z=t; break;
		case ESTE : pea->x=t; pea->z=Hpd; break;
		case OESTE : pea->x=t; pea->z=Hpe; break;
	}
}

bool NoPea(Peao *p, int mxi) {
	for(int j=0;j<mxi;j++)
		if(peoes[j].r==p->r && peoes[j].dir==p->dir)
			return false;
	return true;
}

void PeaoInit(Peao *p, int mxi) {
bool v;
int rdm;
	
	do {
		do p->r=findrua(rand()%Nqx+1, rand()%Nqz+1); 
		while(!p->r);		
		do {
			v=true;
			rdm=rand()%4;
			switch(rdm) {
				case NORTE : if(p->r->n) v=false; p->roty=0; break;
				case SUL : if(p->r->s) v=false; p->roty=D3DX_PI; break;
				case ESTE : if(p->r->e) v=false; p->roty=D_PI2; break;
				case OESTE : if(p->r->w) v=false; p->roty=D_3PI2; break;
			}
		} while(v);
		p->dir=FindDir(p->roty);
	} while(NextRua(p->r, DirEsq(p->dir)) || !NoPea(p, mxi));
	FindPosPeao(p, EstradaL/2.0f+(rand()%(int)(100*EstradaL/2.0f))/100.0f-EstradaL/4.0f);
	p->estado=0;
	criaPLog(&(p->r->rpea), p);
}	

void PeaoAnim(Membro *mem, float elapsedtm) {
Lanim *la=mem->ranim;
float lsta=0, tmp;
	while(la) {
		if(mem->tanim>=lsta && mem->tanim<la->tmg) {
			mem->tanim+=elapsedtm;
			if(mem->tanim<la->tmg)
				mem->rotx+=elapsedtm*la->pass;
			else {
				tmp=mem->tanim-la->tmg;
				mem->rotx+=(elapsedtm-tmp)*la->pass;
				if(la->nx) mem->rotx+=tmp*la->nx->pass;
				else {
					mem->tanim=tmp;
					mem->rotx=mem->rxini+tmp*mem->ranim->pass;
				}
			}
			return;
		}
		lsta=la->tmg;
		la=la->nx;
	}
	mem->tanim=elapsedtm;
	if(mem->ranim) mem->rotx=mem->rxini+elapsedtm*mem->ranim->pass;
}

void CarroMove(Movel *car) {
	
	switch(car->estado) {
	case 0 : switch(car->dir) {
				case NORTE : car->z-=car->speed;
					 if(car->z<0) {
					    retiraLog(&(car->r->rlog), car);
						car->r=car->r->n;
						criaLog(&(car->r->rlog), car);
						car->z+=EstradaL;
						car->estado=decide(car);
						if(car->estado==ClkW) {
							car->pex=0;
							car->pez=EstradaLim;
							car->tdir=car->dir;
							car->roty=D_2PI;
						}
						if(car->estado==CClkW) {
							car->pex=EstradaLim;
							car->pez=EstradaLim;
							car->tdir=car->dir;
						}
					 }
					break;
				case SUL : car->z+=car->speed;
				   if(car->z>=EstradaL) {
						retiraLog(&(car->r->rlog), car);
						car->r=car->r->s;
						criaLog(&(car->r->rlog), car);
						car->z-=EstradaL;
						car->estado=decide(car);
						if(car->estado==ClkW) {
							car->pex=EstradaLim;
							car->pez=0;
							car->tdir=car->dir;
						}
						if(car->estado==CClkW) {
							car->pex=0;
							car->pez=0;
							car->tdir=car->dir;
						}
				   }
					break;
				case ESTE : car->x+=car->speed;
					if(car->x>=EstradaL) {
						retiraLog(&(car->r->rlog), car);
						car->r=car->r->e;
						criaLog(&(car->r->rlog), car);
						car->x-=EstradaL;