void Patch::applyForces(){
int i, x, y, z, x1, y1, z1;
// if all forces are received, then it must recompute particles location
if (forceCount == numNbrs) {
CkVec<Particle> *outgoing = new CkVec<Particle>[numNbrs];
// Received all it's forces from the interactions.
forceCount = 0;
// Update properties on own particles
updateProperties();
// sending particles to neighboring cells
x = thisIndex.x;
y = thisIndex.y;
z = thisIndex.z;
if (stepCount > 0 && (stepCount % migrateStepCount) == 0){
for(i=0; i<particles.length(); i++) {
migrateToPatch(particles[i], x1, y1, z1);
if(x1 !=0 || y1!=0 || z1 !=0) {
//CkPrintf("PARTICLE MIGRATING!\n");
outgoing[(x1+1)*nbrsY*nbrsZ + (y1+1)*nbrsZ + (z1+1)].push_back(wrapAround(particles[i]));
particles.remove(i);
}
}
for(int num=0; num<numNbrs; num++) {
x1 = num / (nbrsY * nbrsZ) - nbrsX/2;
y1 = (num % (nbrsY * nbrsZ)) / nbrsZ - nbrsY/2;
z1 = num % nbrsZ - nbrsZ/2;
patchArray(WRAP_X(x+x1), WRAP_Y(y+y1), WRAP_Z(z+z1)).receiveParticles(outgoing[num]);
}
}
else
incomingFlag = true;
updateFlag = true;
// checking whether to proceed with next step
thisProxy(x, y, z).checkNextStep();
//checkNextStep();
delete [] outgoing;
// thisProxy(x, y, z).checkNextStep();
//checkNextStep();
}
// else { CkPrintf("forcecount = %d/%d on patch %d %d %d\n", forceCount, numNbrs, thisIndex.x, thisIndex.y, thisIndex.z); }
}
void
spawn_planet (void)
{
HELEMENT hPlanetElement;
hPlanetElement = AllocElement ();
if (hPlanetElement)
{
ELEMENT *PlanetElementPtr;
extern FRAME planet[];
LockElement (hPlanetElement, &PlanetElementPtr);
PlanetElementPtr->playerNr = NEUTRAL_PLAYER_NUM;
PlanetElementPtr->hit_points = 200;
PlanetElementPtr->state_flags = APPEARING;
PlanetElementPtr->life_span = NORMAL_LIFE + 1;
SetPrimType (&DisplayArray[PlanetElementPtr->PrimIndex], STAMP_PRIM);
PlanetElementPtr->current.image.farray = planet;
PlanetElementPtr->current.image.frame =
PlanetElementPtr->current.image.farray[0];
PlanetElementPtr->collision_func = collision;
PlanetElementPtr->postprocess_func =
(void (*) (struct element *ElementPtr))CalculateGravity;
ZeroVelocityComponents (&PlanetElementPtr->velocity);
do
{
PlanetElementPtr->current.location.x =
WRAP_X (DISPLAY_ALIGN_X (TFB_Random ()));
PlanetElementPtr->current.location.y =
WRAP_Y (DISPLAY_ALIGN_Y (TFB_Random ()));
} while (CalculateGravity (PlanetElementPtr)
|| Overlap (PlanetElementPtr));
PlanetElementPtr->mass_points = PlanetElementPtr->hit_points;
PlanetElementPtr->triggers_teleport_safety = TRUE;
UnlockElement (hPlanetElement);
PutElement (hPlanetElement);
}
}
void Patch::createComputes() {
//double d1 = CmiWallTimer();
int num;
int x = thisIndex.x;
int y = thisIndex.y;
int z = thisIndex.z;
int px1, py1, pz1, dx, dy, dz, px2, py2, pz2;
// For Round Robin insertion
int numPes = CkNumPes();
int currPe = CkMyPe();
computesList = new int*[numNbrs];
for (int i =0; i < numNbrs; i++){
computesList[i] = new int[6];
}
/* The computes X are inserted by a given patch:
*
* ^ X X X
* | 0 X X
* y 0 0 0
* x ---->
*/
// these computes will be created by other patches
for (num=0; num<numNbrs; num++) {
dx = num / (nbrsY * nbrsZ) - nbrsX/2;
dy = (num % (nbrsY * nbrsZ)) / nbrsZ - nbrsY/2;
dz = num % nbrsZ - nbrsZ/2;
if (num >= numNbrs/2){
px1 = x + 2;
px2 = x+dx+2;
py1 = y + 2;
py2 = y+dy+2;
pz1 = z + 2;
pz2 = z+dz+2;
computeArray(px1, py1, pz1, px2, py2, pz2).insert((++currPe)%numPes);
computesList[num][0] = px1; computesList[num][1] = py1; computesList[num][2] = pz1;
computesList[num][3] = px2; computesList[num][4] = py2; computesList[num][5] = pz2;
}
else {
px2 = WRAP_X(x+dx);
py2 = WRAP_Y(y+dy);
pz2 = WRAP_Z(z+dz);
px1 = x;
py1 = y;
pz1 = z;
px1 = px2 - dx + 2;
px2 = px2+2;
py1 = py2 - dy + 2;
py2 = py2+2;
pz1 = pz2 - dz + 2;
pz2 = pz2+2;
computesList[num][0] = px2; computesList[num][1] = py2; computesList[num][2] = pz2;
computesList[num][3] = px1; computesList[num][4] = py1; computesList[num][5] = pz1;
}
//insert only the upper right half computes
} // end of for loop
contribute(CkCallback(CkIndex_Main::startUpDone(), mainProxy));
//loadTime += CmiWallTimer()-d1;
}
static void
arilou_preprocess (ELEMENT *ElementPtr)
{
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr, &StarShipPtr);
if (!(ElementPtr->state_flags & NONSOLID))
{
if (ElementPtr->thrust_wait == 0)
{
ZeroVelocityComponents (&ElementPtr->velocity);
StarShipPtr->cur_status_flags &= ~SHIP_AT_MAX_SPEED;
}
if ((StarShipPtr->cur_status_flags & SPECIAL)
&& StarShipPtr->special_counter == 0
&& DeltaEnergy (ElementPtr, -SPECIAL_ENERGY_COST))
{
/* Special key is pressed; start teleport */
#define HYPER_LIFE 5
ZeroVelocityComponents (&ElementPtr->velocity);
StarShipPtr->cur_status_flags &=
~(SHIP_AT_MAX_SPEED | LEFT | RIGHT | THRUST | WEAPON);
ElementPtr->state_flags |= NONSOLID | FINITE_LIFE | CHANGING;
ElementPtr->life_span = HYPER_LIFE;
ElementPtr->next.image.farray =
StarShipPtr->RaceDescPtr->ship_data.special;
ElementPtr->next.image.frame =
StarShipPtr->RaceDescPtr->ship_data.special[0];
ProcessSound (SetAbsSoundIndex (
/* HYPERJUMP */
StarShipPtr->RaceDescPtr->ship_data.ship_sounds, 1), ElementPtr);
StarShipPtr->special_counter =
StarShipPtr->RaceDescPtr->characteristics.special_wait;
}
}
else if (ElementPtr->next.image.farray == StarShipPtr->RaceDescPtr->ship_data.special)
{
COUNT life_span;
StarShipPtr->cur_status_flags =
(StarShipPtr->cur_status_flags
& ~(LEFT | RIGHT | THRUST | WEAPON | SPECIAL))
| (StarShipPtr->old_status_flags
& (LEFT | RIGHT | THRUST | WEAPON | SPECIAL));
++StarShipPtr->weapon_counter;
++StarShipPtr->special_counter;
++StarShipPtr->energy_counter;
++ElementPtr->turn_wait;
++ElementPtr->thrust_wait;
if ((life_span = ElementPtr->life_span) == NORMAL_LIFE)
{
/* Ending teleport */
ElementPtr->state_flags &= ~(NONSOLID | FINITE_LIFE);
ElementPtr->state_flags |= APPEARING;
ElementPtr->current.image.farray =
ElementPtr->next.image.farray =
StarShipPtr->RaceDescPtr->ship_data.ship;
ElementPtr->current.image.frame =
ElementPtr->next.image.frame =
SetAbsFrameIndex (StarShipPtr->RaceDescPtr->ship_data.ship[0],
StarShipPtr->ShipFacing);
InitIntersectStartPoint (ElementPtr);
}
else
{
/* Teleporting in progress */
--life_span;
if (life_span != 2)
{
if (life_span < 2)
ElementPtr->next.image.frame =
DecFrameIndex (ElementPtr->next.image.frame);
else
ElementPtr->next.image.frame =
IncFrameIndex (ElementPtr->next.image.frame);
}
else
{
ElementPtr->next.location.x =
WRAP_X (DISPLAY_ALIGN_X (TFB_Random ()));
ElementPtr->next.location.y =
WRAP_Y (DISPLAY_ALIGN_Y (TFB_Random ()));
}
}
ElementPtr->state_flags |= CHANGING;
}
}
// Preprocess function for spawning a ship into or out of battle.
// Used when a new ship warps in, or a ship escapes by warping out, but not
// when a Pkunk ship is reborn.
void
ship_transition (ELEMENT *ElementPtr)
{
if (ElementPtr->state_flags & PLAYER_SHIP)
{
if (ElementPtr->state_flags & APPEARING)
{
ElementPtr->life_span = HYPERJUMP_LIFE;
ElementPtr->preprocess_func = ship_transition;
ElementPtr->postprocess_func = NULL;
SetPrimType (&DisplayArray[ElementPtr->PrimIndex], NO_PRIM);
ElementPtr->state_flags |= NONSOLID | FINITE_LIFE | CHANGING;
}
else if (ElementPtr->life_span < HYPERJUMP_LIFE)
{
if (ElementPtr->life_span == NORMAL_LIFE
&& ElementPtr->crew_level)
{
ElementPtr->current.image.frame =
ElementPtr->next.image.frame =
SetEquFrameIndex (
ElementPtr->current.image.farray[0],
ElementPtr->current.image.frame);
SetPrimType (&DisplayArray[ElementPtr->PrimIndex], STAMP_PRIM);
InitIntersectStartPoint (ElementPtr);
InitIntersectEndPoint (ElementPtr);
InitIntersectFrame (ElementPtr);
ZeroVelocityComponents (&ElementPtr->velocity);
ElementPtr->state_flags &= ~(NONSOLID | FINITE_LIFE);
ElementPtr->state_flags |= CHANGING;
ElementPtr->preprocess_func = ship_preprocess;
ElementPtr->postprocess_func = ship_postprocess;
}
return;
}
}
{
HELEMENT hShipImage;
ELEMENT *ShipImagePtr;
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr, &StarShipPtr);
LockElement (StarShipPtr->hShip, &ShipImagePtr);
if (!(ShipImagePtr->state_flags & NONSOLID))
{
ElementPtr->preprocess_func = NULL;
}
else if ((hShipImage = AllocElement ()))
{
#define TRANSITION_SPEED DISPLAY_TO_WORLD (40 << RESOLUTION_FACTOR) // JMS_GFX
#define TRANSITION_LIFE 1
COUNT angle;
PutElement (hShipImage);
angle = FACING_TO_ANGLE (StarShipPtr->ShipFacing);
LockElement (hShipImage, &ShipImagePtr);
ShipImagePtr->playerNr = NEUTRAL_PLAYER_NUM;
ShipImagePtr->state_flags = APPEARING | FINITE_LIFE | NONSOLID;
ShipImagePtr->thrust_wait = TRANSITION_LIFE;
ShipImagePtr->life_span = ShipImagePtr->thrust_wait;
// When the element "dies", in the death_func
// 'cycle_ion_trail', it is given new life a number of
// times, by setting life_span to thrust_wait.
SetPrimType (&DisplayArray[ShipImagePtr->PrimIndex],
STAMPFILL_PRIM);
SetPrimColor (&DisplayArray[ShipImagePtr->PrimIndex],
START_ION_COLOR);
ShipImagePtr->colorCycleIndex = 0;
ShipImagePtr->current.image = ElementPtr->current.image;
ShipImagePtr->current.location = ElementPtr->current.location;
if (!(ElementPtr->state_flags & PLAYER_SHIP))
{
ShipImagePtr->current.location.x +=
COSINE (angle, TRANSITION_SPEED);
ShipImagePtr->current.location.y +=
SINE (angle, TRANSITION_SPEED);
ElementPtr->preprocess_func = NULL;
}
else if (ElementPtr->crew_level)
{
ShipImagePtr->current.location.x -=
COSINE (angle, TRANSITION_SPEED)
* (ElementPtr->life_span - 1);
ShipImagePtr->current.location.y -=
SINE (angle, TRANSITION_SPEED)
* (ElementPtr->life_span - 1);
ShipImagePtr->current.location.x =
WRAP_X (ShipImagePtr->current.location.x);
ShipImagePtr->current.location.y =
WRAP_Y (ShipImagePtr->current.location.y);
}
ShipImagePtr->preprocess_func = ship_transition;
ShipImagePtr->death_func = cycle_ion_trail;
SetElementStarShip (ShipImagePtr, StarShipPtr);
UnlockElement (hShipImage);
}
UnlockElement (StarShipPtr->hShip);
}
}
static void
phoenix_transition (ELEMENT *ElementPtr)
{
HELEMENT hShipImage;
ELEMENT *ShipImagePtr;
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr, &StarShipPtr);
LockElement (StarShipPtr->hShip, &ShipImagePtr);
if (!(ShipImagePtr->state_flags & NONSOLID))
{
ElementPtr->preprocess_func = NULL;
}
else if ((hShipImage = AllocElement ()))
{
#define TRANSITION_SPEED DISPLAY_TO_WORLD (20)
COUNT angle;
PutElement (hShipImage);
LockElement (hShipImage, &ShipImagePtr);
ShipImagePtr->playerNr = NEUTRAL_PLAYER_NUM;
ShipImagePtr->state_flags = APPEARING | FINITE_LIFE | NONSOLID;
ShipImagePtr->life_span = TRANSITION_LIFE;
SetPrimType (&(GLOBAL (DisplayArray))[ShipImagePtr->PrimIndex],
STAMPFILL_PRIM);
SetPrimColor (
&(GLOBAL (DisplayArray))[ShipImagePtr->PrimIndex],
START_PHOENIX_COLOR);
ShipImagePtr->colorCycleIndex = 0;
ShipImagePtr->current.image = ElementPtr->current.image;
ShipImagePtr->current.location = ElementPtr->current.location;
if (!(ElementPtr->state_flags & PLAYER_SHIP))
{
angle = ElementPtr->mass_points;
ShipImagePtr->current.location.x +=
COSINE (angle, TRANSITION_SPEED);
ShipImagePtr->current.location.y +=
SINE (angle, TRANSITION_SPEED);
ElementPtr->preprocess_func = NULL;
}
else
{
angle = FACING_TO_ANGLE (StarShipPtr->ShipFacing);
ShipImagePtr->current.location.x -=
COSINE (angle, TRANSITION_SPEED)
* (ElementPtr->life_span - 1);
ShipImagePtr->current.location.y -=
SINE (angle, TRANSITION_SPEED)
* (ElementPtr->life_span - 1);
ShipImagePtr->current.location.x =
WRAP_X (ShipImagePtr->current.location.x);
ShipImagePtr->current.location.y =
WRAP_Y (ShipImagePtr->current.location.y);
}
ShipImagePtr->mass_points = (BYTE)angle;
ShipImagePtr->preprocess_func = phoenix_transition;
ShipImagePtr->death_func = spawn_phoenix_trail;
SetElementStarShip (ShipImagePtr, StarShipPtr);
UnlockElement (hShipImage);
}
UnlockElement (StarShipPtr->hShip);
}
static void
new_pkunk (ELEMENT *ElementPtr)
{
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr, &StarShipPtr);
if (!(ElementPtr->state_flags & PLAYER_SHIP))
{
ELEMENT *ShipPtr;
LockElement (StarShipPtr->hShip, &ShipPtr);
ShipPtr->death_func = new_pkunk;
UnlockElement (StarShipPtr->hShip);
}
else
{
ElementPtr->state_flags = APPEARING | PLAYER_SHIP | IGNORE_SIMILAR;
ElementPtr->mass_points = SHIP_MASS;
ElementPtr->preprocess_func = StarShipPtr->RaceDescPtr->preprocess_func;
ElementPtr->postprocess_func = StarShipPtr->RaceDescPtr->postprocess_func;
ElementPtr->death_func =
(void (*) (ELEMENT *ElementPtr))
StarShipPtr->RaceDescPtr->init_weapon_func;
StarShipPtr->RaceDescPtr->preprocess_func = pkunk_preprocess;
StarShipPtr->RaceDescPtr->postprocess_func = pkunk_postprocess;
StarShipPtr->RaceDescPtr->init_weapon_func = initialize_bug_missile;
StarShipPtr->RaceDescPtr->ship_info.crew_level = MAX_CREW;
StarShipPtr->RaceDescPtr->ship_info.energy_level = MAX_ENERGY;
/* fix vux impairment */
StarShipPtr->RaceDescPtr->characteristics.max_thrust = MAX_THRUST;
StarShipPtr->RaceDescPtr->characteristics.thrust_increment = THRUST_INCREMENT;
StarShipPtr->RaceDescPtr->characteristics.turn_wait = TURN_WAIT;
StarShipPtr->RaceDescPtr->characteristics.thrust_wait = THRUST_WAIT;
StarShipPtr->RaceDescPtr->characteristics.special_wait = 0;
StarShipPtr->ship_input_state = 0;
StarShipPtr->cur_status_flags = 0;
StarShipPtr->old_status_flags = 0;
StarShipPtr->energy_counter = 0;
StarShipPtr->weapon_counter = 0;
StarShipPtr->special_counter = 0;
ElementPtr->crew_level = 0;
ElementPtr->turn_wait = 0;
ElementPtr->thrust_wait = 0;
ElementPtr->life_span = NORMAL_LIFE;
StarShipPtr->ShipFacing = NORMALIZE_FACING (TFB_Random ());
ElementPtr->current.image.farray = StarShipPtr->RaceDescPtr->ship_data.ship;
ElementPtr->current.image.frame =
SetAbsFrameIndex (StarShipPtr->RaceDescPtr->ship_data.ship[0],
StarShipPtr->ShipFacing);
SetPrimType (&(GLOBAL (DisplayArray))[
ElementPtr->PrimIndex
], STAMP_PRIM);
do
{
ElementPtr->current.location.x =
WRAP_X (DISPLAY_ALIGN_X (TFB_Random ()));
ElementPtr->current.location.y =
WRAP_Y (DISPLAY_ALIGN_Y (TFB_Random ()));
} while (CalculateGravity (ElementPtr)
|| TimeSpaceMatterConflict (ElementPtr));
ElementPtr->hTarget = StarShipPtr->hShip;
}
}
void
spawn_asteroid (ELEMENT *ElementPtr)
{
HELEMENT hAsteroidElement;
if ((hAsteroidElement = AllocElement ()) == 0)
{
if (ElementPtr != 0)
{
ElementPtr->state_flags &= ~DISAPPEARING;
SetPrimType (&DisplayArray[ElementPtr->PrimIndex], NO_PRIM);
ElementPtr->life_span = 1;
}
}
else
{
ELEMENT *AsteroidElementPtr;
COUNT val;
LockElement (hAsteroidElement, &AsteroidElementPtr);
AsteroidElementPtr->playerNr = NEUTRAL_PLAYER_NUM;
AsteroidElementPtr->hit_points = 1;
AsteroidElementPtr->mass_points = 3;
AsteroidElementPtr->state_flags = APPEARING;
AsteroidElementPtr->life_span = NORMAL_LIFE;
SetPrimType (&DisplayArray[AsteroidElementPtr->PrimIndex], STAMP_PRIM);
if ((val = (COUNT)TFB_Random ()) & (1 << 0))
{
if (!(val & (1 << 1)))
AsteroidElementPtr->current.location.x = 0;
else
AsteroidElementPtr->current.location.x = LOG_SPACE_WIDTH;
AsteroidElementPtr->current.location.y =
WRAP_Y (DISPLAY_ALIGN_Y (TFB_Random ()));
}
else
{
AsteroidElementPtr->current.location.x =
WRAP_X (DISPLAY_ALIGN_X (TFB_Random ()));
if (!(val & (1 << 1)))
AsteroidElementPtr->current.location.y = 0;
else
AsteroidElementPtr->current.location.y = LOG_SPACE_HEIGHT;
}
{
// Using these temporary variables because the execution order
// of function arguments may vary per system, which may break
// synchronisation on network games.
SIZE magnitude =
DISPLAY_TO_WORLD (((SIZE)TFB_Random () & 7) + 4);
COUNT facing = (COUNT)TFB_Random ();
SetVelocityVector (&AsteroidElementPtr->velocity, magnitude,
facing);
}
AsteroidElementPtr->current.image.farray = asteroid;
AsteroidElementPtr->current.image.frame =
SetAbsFrameIndex (asteroid[0],
NORMALIZE_FACING (TFB_Random ()));
AsteroidElementPtr->turn_wait =
AsteroidElementPtr->thrust_wait =
(BYTE)TFB_Random () & (BYTE)((1 << 2) - 1);
AsteroidElementPtr->thrust_wait |=
(BYTE)TFB_Random () & (BYTE)(1 << 7);
AsteroidElementPtr->preprocess_func = asteroid_preprocess;
AsteroidElementPtr->death_func = spawn_rubble;
AsteroidElementPtr->collision_func = collision;
AsteroidElementPtr->triggers_teleport_safety = TRUE;
UnlockElement (hAsteroidElement);
PutElement (hAsteroidElement);
}
}
