void ZRUser01(float *myState, float *otherState, float time)
{
//BEGIN::PROC::ZRUser
float opulens[3] = {0.0, -0.6, 0.0};
float Laser[3] = {0.4, 0.0, 0.0};
float shield[3] = {0.0, 0.4, 0.0};
float disrupt[3] = {0.0,0.2,0.0};
float zero[3] = {0.0, 0.0, 0.0};
float difference[3];
float facing[3];
float Asteroid[3] = {0.0, -0.6, 0.0};
int recieved;


switch((int)time)
{
    case 0:
        SphereNumber = !!(myState[0] < 0) + 1;
        Station[0] = (SphereNumber == 1) ? 0.6 : -0.6; //station closer to where you started
        break;
    case 30:
        getUp = (otherState[1] <= 0);
        break;
    case 61:
    case 66:
        Spin = PisRevolving(otherState) ? 1 : 0;
        break;
    case 75: if(PinAsteroid(otherState) == 1) asteroid = 1;
}


Laser[0] = ((SphereNumber == 1) - (PotherHasLaser() == SphereNumber)) ? 0.4 : -0.4;

recieved = (int)PgetMessage();
switch(recieved)
{
    case 6:
        if(!(Station[0] < 0.0) && switchedStation++ < 3)
            Station[0] = -0.6;
        break;
    case 7:
        if(!(Station[0] > 0.0) && switchedStation++ < 3)
            Station[0] = 0.6;
        break;
    case 2:
    case 3:
        if(time < 45)
        asteroid = 1;
        break;
    case 4:
    case 5:
        if(time < 45)
        asteroid = 0;
        break;
}


if(time <= 120)
PsendMessage(4 - 2*asteroid + (Spin == 0));
else
PsendMessage((Station[0] < 0) + 6);

Asteroid[1] = asteroid ? -0.6 : 0.6;


switch(state)
{
    case 0:
        ZRSetPositionTarget(Laser);
        shoot(myState, opulens, 0);
        if(PhaveLaser() || PgetPhase() == 2)
            state = 1;
        break;
        
    case 1:
        if(!getUp) {
            shield[1] = .3;
            disrupt[1] = .3;
        }
        ZRSetPositionTarget(disrupt);
        shoot(myState, opulens, 0);
        if(PotherDisruptorUpgraded() || PdisruptorUpgraded())
            state = 2;
        if(PgetPhase() == 2)
            state = 3;
        break;
        
    case 2:
        ZRSetPositionTarget(shield);
        shoot(myState, opulens, 0);
        if(PotherHasShield() || PhaveShield() || PgetPhase() == 2)
            state = 3;
        break;
    case 3:
        if(PiceHits() < 15 && !asteroid)
            shoot(myState, opulens, (PgetPhase() > 1));
        if(!(PiceMelted()) && asteroid)
        {
            mathVecSubtract(difference, myState, opulens, 3);
            if(mathVecMagnitude(difference, 3) > .8)
                ZRSetPositionTarget(opulens);
            else if(!Spin)
                ZRSetVelocityTarget(zero);
            shoot(myState, opulens, (PgetPhase() > 1));
            return;
        }
        if(Spin){
            ZRSetPositionTarget(Asteroid);
            spin(myState);
        }
        else
            orbit(myState, Asteroid, Station[0] == -0.6);
        if((!Spin && (time + timeToMS(myState, Station) >= 165)) || (Spin && (time >= 156)))
            state = 4;
        break;
    default:
        leaveOrbit(myState, Asteroid, Station);
        mathVecSubtract(facing, otherState, myState, 3);
        mathVecNormalize(facing, 3);
        ZRSetAttitudeTarget(facing);
        if (acos(mathVecInner(&myState[6], facing, 3) / mathVecMagnitude(&myState[6], 3)) < (0.1))
            Ptractor();
        break;
}
//END::PROC::ZRUser
}
Example #2
0
static void revolve (float c[3], float mystate[12], float other[12])
{
//BEGIN::PROC::revolve
/*
 * Revolving function
 */
float v[4];
float q[4];
float a[4];
float a2[4];
float asse[3];
float d;
float b;
float b2;
int dir=sp;

if (PisRevolving (other)) {
	dir = revDir (other,c);
	if (!dir)
		dir=sp;
}

PgetAsteroidNormal(asse);

v[3]=0;

mathVecSubtract (v,c,mystate,3);

d=mathVecMagnitude(v, 3);
if(d >= 0.3f) {
	d=0.2355f/d; // (pi/2)*(0.3/distance)
}
else {
	d= 1.57f - 2.615f*d; // pi - (pi/2)*(distance/0.25)
}

// This creates the quaternion
// (yeah, a quaternion, that's cool right?)
b=d-1.57f;
b2=b*b*b;
q[3]=(-b + b2/6 - b2*b*b/120);
b2=d*d*d;
mathVecMul (q,asse,dir*(d - b2/6 + b2*d*d/120)); 

// v[] is rotated according to the quaternion
funz(a2,q,v);
mathVecMul(q,q,-1);
funz(a,a2,q);

//then it's normalized and converted in velocity
mathVecNormalize(a, 3);
mathVecMul(a,a,0.0232f);
ZRSetVelocityTarget(a);


q[3]=1;
mathVecMul(q,asse,-dir*0.043619f);

funz(a2,q,v);
mathVecMul(q,q,-1);
funz(a,a2,q);

ZRSetAttitudeTarget(a);

//END::PROC::revolve
}
void ZRUser01(float *myState, float *otherState, float time)
{
//BEGIN::PROC::ZRUser
float opulens[3] = {0.0, -0.6, 0.0};
float Laser[3] = {0.4, 0.0, 0.0};
float shield[3] = {0.0, 0.4, 0.0};
float zero[3] = {0.0, 0.0, 0.0};
float difference[3];
float Asteroid[3] = {0.0, -0.6, 0.0};
float Station[3] = {0.0, 0.0, 0.0};


switch((int)time)
{
    case 0:
        SphereNumber = !!(myState[0] < 0) + 1;
        break;
    case 30:
        getShield = (otherState[1] <= 0);
        break;
    case 61:
        asteroid = (PinAsteroid(otherState) == 1) ? 1 : 0;
        break;
    case 90:
        asteroid = (PisRevolving(otherState) == 2 && !asteroid) ? 1 : asteroid;
        break;
}


Station[0] = (SphereNumber == 1) ? 0.6 : -0.6; //station closer to where you started
Asteroid[1] = asteroid ? -0.6 : 0.6;
Laser[0] = ((SphereNumber == 1) - (PotherHasLaser() == SphereNumber)) ? 0.4 : -0.4;


switch(state)
{
    case 0:
        ZRSetPositionTarget(Laser);
        shoot(myState, opulens, 0);
        if(PhaveLaser() || PgetPhase() == 2)
            state = 1;
        break;
        
    case 1:
        if(!getShield)
            shield[1] = .3;
        ZRSetPositionTarget(shield);
        shoot(myState, opulens, 0);
        if(PotherHasShield() || PhaveShield() || PgetPhase() == 2)
            state = 2;
        break;
        
    case 2:
        if(PiceHits() < 14 && !asteroid)
            shoot(myState, opulens, (PgetPhase() > 1));
        if(!(PiceMelted()) && asteroid)
        {
            mathVecSubtract(difference, myState, opulens, 3);
            if(mathVecMagnitude(difference, 3) > .8)
                ZRSetPositionTarget(opulens);
            else
                ZRSetVelocityTarget(zero);
            shoot(myState, opulens, (PgetPhase() > 1));
            return;
        }
        orbit(myState, Asteroid, Station[0] == -0.6);
        if(time + timeToMS(myState, Station) >= 165)
            state = 3;
        break;
        
    default:
        ZRSetPositionTarget(Station);
        break;
}
//END::PROC::ZRUser
}
Example #4
0
void ZRUser01(float *myState, float *otherState, float time)
{
//BEGIN::PROC::ZRUser

// These are just some costants, don't pay to much attention to them :)
#define	 WAIT_TIME	   13	// Seconds to wait before starting spinning

#define	 TIME_OPP_STAT   140	// Will only start considering about going
				// to a station after TIME_OPP_STAT seconds.

#define	 ACCURACY_STAT   1.975f // Number between 1 and 2, the higher it is,
				// the more accurate in deciding whether the 
				// opponent is headed towards the station.

#define	 FUEL_STAT	   25	// The minimum amount of fuel required to go
				// to a mining station (below this value, 
				// the sphere's not going anywhere


// msg  : contains the messages received from the opponent
// tt   : contains a condition used a couple of times (space optimization)
// out  : contains the message we're sending our opponent
unsigned short msg,tt,out=0;
// avoid: is true or false whether the collision avoidance system is activated or not
unsigned char avoid;
// Don't worry about x and v ^^
float x[2];
float v[3];
// stat : these are some coordinates of stuff, like stations, asteroids and
//		a couple of corners of the playground
float stat[6][3] =  {   {-0.5f,+0.31f,-0.55f},
			{+0.5f,-0.31f,+0.55f},
			{0,-0.35f,-0.2f},
			{0,+0.35f,+0.2f},
			{-0.5f,+0.65f,-0.55f},
			{+0.5f,-0.65f,+0.55f}};
msg=PgetMessage();
avoid = PisAvoidingCollision();
tt=(tmp && tmp+WAIT_TIME<time);

/*
 * y0b0tics protocol will be used only when 
 * we're controlling the SPH # 1
 */
if (!time) {
	if (myState[0]>0) { // SPH1
		a=0.4; //  a is the X coordinate of the nearest laser
		out=0x0400; // bit 11
		sp=1;
	}
	else
		a=-0.4;
}

/*
 * If the opponent is willing to work
 * on Indigens, we're going to Indigens
 * as well, but we'll try to revolve.
 * Otherwise we keep sending our
 * opponent a "I'll revolve on Opulens"
 * message.
 */
if (time<60 && time) {
	if ((msg>3 && msg<6) || ast==1) {
		out=5;
		act=2; // Revolve
		ast=1; // Indigens
	}
	else {
		out=3;
	}
}
/*
 * If we're headed to a mining station,
 * we're telling our opponents which one
 * it is
 */
else if (act==4 && st<2)
	out=7-st;
PsendMessage(out);
/*
 * First of all, the Laser is taken
 * (btw, there's a "minor" bug in this
 * condition (&& time<60) is needed
 * (will add that as soon as some space
 * is available)
 */
if (!PhaveLaser()) {
	/*
	 * If the opponent is trying to "steal"
	 * our laser, we will get the other one
	 */
	if (avoid && myState[0]*a>0) 
		a*=-1;
	/* v contains the
	 * laser coordinates
	 */
	v[0]=a;
	v[1]=0;
	v[2]=0;
	ZRSetPositionTarget(v);
}
else {
	if (time>TIME_OPP_STAT && st<2) {
		/*
		 * x[0] is given the value of the distance
		 * between us and our opponent
		 */
		mathVecSubtract (v,myState,otherState,3);
		x[0]=mathVecMagnitude (v,3);
		/*
		 * if our opponent is going to a station
		 * we decide to go to the other one, but
		 * only if we're able to arrive first
		 */
		if (checkTarget(otherState,0)>ACCURACY_STAT) {
			/*
			 * Even if we're headed towards a station,
			 * if our opponent is going to
			 * the same station as us, we stop going
			 * there and, instead, we move to the
			 * closest corner of the playground,
			 * so that, even if we don't gain anything,
			 * at least we won't activate the collision
			 * avoidance system
			 */
			if (!st && x[0]<0.65f) {
					st=4;
			}
			else if (st==-1) {
				/*
				 * We go to the other station only if
				 * we can reach it first
				 */
				if (getInTime(stat[0],otherState,stat[1],myState)) {
					st=1;
					act=4;
				}
				else
					st=-2;
			}
		}
		/*
		 * Same stuff as before, but now
		 * the other station is checked.
		 */
		else if (checkTarget(otherState,1)>ACCURACY_STAT) {
			if (st==1 && x[0]<0.65f) {
					st=5;
			}
			else if (st==-1) {
				if (getInTime(stat[1],otherState,stat[0],myState)) {
					st=0;
					act=4;
				}
				else
					st=-2;
			}
		}
		/*
		 * although our opponent is not going to 
		 * a station, we leave the asteroid we're
		 * working on to go to a station.
		 * The time we're leaving the asteroid is
		 * not fixed, but is calculated every time
		 * in order to leave the asteroid as late as
		 * possible
		 */
		else if (PgetPercentFuelRemaining()>FUEL_STAT && st==-1) {
			/*
			 * x[0] contains the value of time
			 * at which we have to leave the asteroid
			 * to reach a station
			 * 180-(time needed to reach a station)
			 */
			x[0]=timeStation(stat[0],myState);
			x[1]=timeStation(stat[1],myState);
				/*
				 * It is then decided which station is
				 * better, keeping in account that, if
				 * we're spinning, our opponent could be
				 * on our way to the station.
				 */
				if ((time>=x[0]) && (x[0]>x[1]) && !(act==3 && otherState[0]<0 && otherState[1]>0 && otherState[2]<0.2)) {
					act=4;
					st=0;
				}
				if ((x[0]<x[1]) && (time>=x[1]) && !(act==3 && otherState[0]>0 && otherState[1]<0 && otherState[2]>-0.2)) {
					act=4;
					st=1;
				}
		}
	}
	/*
	 * act (action) contains a value
	 * related to the action we're
	 * doing.
	 */
	switch (act) {
		/* act = 1 -> melting ice on Opulens */
		case 1:
			meltIce(myState,otherState,time);
			if (PiceMelted()) 
				act=2;  // if the ice is melted, we start revolving
						// on Opulens
			break;
		/* act = 2 -> revolve */
		case 2:
			/*
			 * if the opponent is revolving as
			 * well, we keep revolving as well
			 * for WAIT_TIME seconds. After that
			 * seconds, if the opponent is 
			 * still revolving, we start spinning
			 */
			if (PisRevolving (otherState)==ast-1) {
				if (!tmp)
					tmp=time;
				if (tt && (checkTarget (otherState,ast)<1.9f) && st!=-2) {
					act=3;
					tmp=0;
				}
			}
			revolve(stat[ast],myState,otherState);
			break;
		/* act = 3 -> spinning */
		case 3:
			/*
			 * if the avoiding collision system
			 * is working, it probably means that
			 * our opponent wants to spin and he's
			 * close to us so, after a few seconds,
			 * we let him spin and we start revolving ^^
			 */
			if (avoid) {
				if (!tmp)
					tmp=time;
				if (tt) {
					tmp=0;
					act=2;
				}
			}
			spin(stat[ast],myState);
			break;
		/* act = 4 -> going somewhere */
		case 4:
			SetPosFaster(stat[st],myState);
			break;
		default:
			break;
	}
	if (tt)
		tmp=0;
}
//END::PROC::ZRUser
}