自学教程：C++ GetElementStarShip函数代码示例

static voidsyreen_intelligence (ELEMENT *ShipPtr, EVALUATE_DESC *ObjectsOfConcern,		COUNT ConcernCounter){	EVALUATE_DESC *lpEvalDesc;	ship_intelligence (ShipPtr,			ObjectsOfConcern, ConcernCounter);	lpEvalDesc = &ObjectsOfConcern[ENEMY_SHIP_INDEX];	if (lpEvalDesc->ObjectPtr != NULL)	{		STARSHIP *StarShipPtr;		STARSHIP *EnemyStarShipPtr;		GetElementStarShip (ShipPtr, &StarShipPtr);		GetElementStarShip (lpEvalDesc->ObjectPtr, &EnemyStarShipPtr);		if (!(EnemyStarShipPtr->RaceDescPtr->ship_info.ship_flags & CREW_IMMUNE)				&& StarShipPtr->special_counter == 0				&& lpEvalDesc->ObjectPtr->crew_level > 1				&& lpEvalDesc->which_turn <= 14)			StarShipPtr->ship_input_state |= SPECIAL;		else			StarShipPtr->ship_input_state &= ~SPECIAL;	}}

static voidarilou_intelligence (ELEMENT *ShipPtr, EVALUATE_DESC *ObjectsOfConcern,		COUNT ConcernCounter){	STARSHIP *StarShipPtr;	GetElementStarShip (ShipPtr, &StarShipPtr);	StarShipPtr->ship_input_state |= THRUST;	ObjectsOfConcern[ENEMY_SHIP_INDEX].MoveState = ENTICE;	ship_intelligence (ShipPtr, ObjectsOfConcern, ConcernCounter);	if (StarShipPtr->special_counter == 0)	{		EVALUATE_DESC *lpEvalDesc;		StarShipPtr->ship_input_state &= ~SPECIAL;		lpEvalDesc = &ObjectsOfConcern[ENEMY_WEAPON_INDEX];		if (lpEvalDesc->ObjectPtr && lpEvalDesc->which_turn <= 6)		{			BOOLEAN IsTrackingWeapon;			STARSHIP *EnemyStarShipPtr;			GetElementStarShip (lpEvalDesc->ObjectPtr, &EnemyStarShipPtr);			if (((EnemyStarShipPtr->RaceDescPtr->ship_info.ship_flags					& SEEKING_WEAPON) &&					lpEvalDesc->ObjectPtr->next.image.farray ==					EnemyStarShipPtr->RaceDescPtr->ship_data.weapon) ||					((EnemyStarShipPtr->RaceDescPtr->ship_info.ship_flags					& SEEKING_SPECIAL) &&					lpEvalDesc->ObjectPtr->next.image.farray ==					EnemyStarShipPtr->RaceDescPtr->ship_data.special))				IsTrackingWeapon = TRUE;			else				IsTrackingWeapon = FALSE;			// JMS: Added the GASSY_SUBSTANCE clauses to prevent 'long teleport' if Baul gas is sticking to the Arilou ship.			if (((lpEvalDesc->ObjectPtr->state_flags & PLAYER_SHIP) /* means IMMEDIATE WEAPON */					|| (IsTrackingWeapon && (lpEvalDesc->which_turn == 1					|| (lpEvalDesc->ObjectPtr->state_flags & CREW_OBJECT))) /* FIGHTERS!!! */					|| (PlotIntercept (lpEvalDesc->ObjectPtr, ShipPtr, 3, 0)						&& (!(lpEvalDesc->ObjectPtr->state_flags & GASSY_SUBSTANCE) // Ignore stuck gas							|| (lpEvalDesc->ObjectPtr->state_flags & GASSY_SUBSTANCE && EnemyStarShipPtr->ship_input_state & WEAPON								&& ObjectsOfConcern[ENEMY_SHIP_INDEX].which_turn <= 20) // If sticking to gas, teleport when Baul is near&firing primary							|| (lpEvalDesc->ObjectPtr->state_flags & GASSY_SUBSTANCE && lpEvalDesc->ObjectPtr->state_flags & IGNORE_VELOCITY))) // non-stuck gas					)					&& !(TFB_Random () & 3))			{				StarShipPtr->ship_input_state &= ~(LEFT | RIGHT | THRUST | WEAPON);				StarShipPtr->ship_input_state |= SPECIAL;			}		}	}	if (StarShipPtr->RaceDescPtr->ship_info.energy_level <= SPECIAL_ENERGY_COST << 1)		StarShipPtr->ship_input_state &= ~WEAPON;}

static voiddruuge_intelligence (ELEMENT *ShipPtr, EVALUATE_DESC *ObjectsOfConcern,		COUNT ConcernCounter){	UWORD ship_flags;	STARSHIP *StarShipPtr;	STARSHIP *EnemyStarShipPtr;	EVALUATE_DESC *lpEvalDesc;	GetElementStarShip (ShipPtr, &StarShipPtr);	ship_flags = 0;	lpEvalDesc = &ObjectsOfConcern[ENEMY_SHIP_INDEX];	if (StarShipPtr->cur_status_flags & SHIP_BEYOND_MAX_SPEED)		lpEvalDesc->MoveState = ENTICE;	else if (lpEvalDesc->ObjectPtr			&& lpEvalDesc->which_turn <= WORLD_TO_TURN (MISSILE_RANGE * 3 / 4))	{		GetElementStarShip (lpEvalDesc->ObjectPtr, &EnemyStarShipPtr);		ship_flags = EnemyStarShipPtr->RaceDescPtr->ship_info.ship_flags;		EnemyStarShipPtr->RaceDescPtr->ship_info.ship_flags &=				~(FIRES_FORE | FIRES_RIGHT | FIRES_AFT | FIRES_LEFT);		lpEvalDesc->MoveState = PURSUE;		if (ShipPtr->thrust_wait == 0)			++ShipPtr->thrust_wait;	}	ship_intelligence (ShipPtr, ObjectsOfConcern, ConcernCounter);	if (ship_flags)	{		EnemyStarShipPtr->RaceDescPtr->ship_info.ship_flags = ship_flags;	}	if (!(StarShipPtr->cur_status_flags & SHIP_BEYOND_MAX_SPEED)			&& (lpEvalDesc->which_turn <= 12			|| (			ObjectsOfConcern[ENEMY_WEAPON_INDEX].ObjectPtr			&& ObjectsOfConcern[ENEMY_WEAPON_INDEX].which_turn <= 6			)))	{		 StarShipPtr->ship_input_state |= WEAPON;		 if (ShipPtr->thrust_wait < WEAPON_WAIT + 1)			ShipPtr->thrust_wait = WEAPON_WAIT + 1;	}	if ((StarShipPtr->ship_input_state & WEAPON)			&& StarShipPtr->RaceDescPtr->ship_info.energy_level < WEAPON_ENERGY_COST			&& ShipPtr->crew_level > 1)		StarShipPtr->ship_input_state |= SPECIAL;	else		StarShipPtr->ship_input_state &= ~SPECIAL;}

static voidarilou_intelligence (ELEMENT *ShipPtr, EVALUATE_DESC *ObjectsOfConcern,		COUNT ConcernCounter){	STARSHIP *StarShipPtr;	GetElementStarShip (ShipPtr, &StarShipPtr);	StarShipPtr->ship_input_state |= THRUST;	 ObjectsOfConcern[ENEMY_SHIP_INDEX].MoveState = ENTICE;	ship_intelligence (ShipPtr, ObjectsOfConcern, ConcernCounter);	if (StarShipPtr->special_counter == 0)	{		EVALUATE_DESC *lpEvalDesc;		StarShipPtr->ship_input_state &= ~SPECIAL;		lpEvalDesc = &ObjectsOfConcern[ENEMY_WEAPON_INDEX];		if (lpEvalDesc->ObjectPtr && lpEvalDesc->which_turn <= 6)		{			BOOLEAN IsTrackingWeapon;			STARSHIP *EnemyStarShipPtr;			GetElementStarShip (lpEvalDesc->ObjectPtr, &EnemyStarShipPtr);			if (((EnemyStarShipPtr->RaceDescPtr->ship_info.ship_flags					& SEEKING_WEAPON) &&					lpEvalDesc->ObjectPtr->next.image.farray ==					EnemyStarShipPtr->RaceDescPtr->ship_data.weapon) ||					((EnemyStarShipPtr->RaceDescPtr->ship_info.ship_flags					& SEEKING_SPECIAL) &&					lpEvalDesc->ObjectPtr->next.image.farray ==					EnemyStarShipPtr->RaceDescPtr->ship_data.special))				IsTrackingWeapon = TRUE;			else				IsTrackingWeapon = FALSE;			if (((lpEvalDesc->ObjectPtr->state_flags & PLAYER_SHIP) /* means IMMEDIATE WEAPON */					|| (IsTrackingWeapon && (lpEvalDesc->which_turn == 1					|| (lpEvalDesc->ObjectPtr->state_flags & CREW_OBJECT))) /* FIGHTERS!!! */					|| PlotIntercept (lpEvalDesc->ObjectPtr, ShipPtr, 3, 0))					&& !(TFB_Random () & 3))			{				StarShipPtr->ship_input_state &= ~(LEFT | RIGHT | THRUST | WEAPON);				StarShipPtr->ship_input_state |= SPECIAL;			}		}	}	if (StarShipPtr->RaceDescPtr->ship_info.energy_level <= SPECIAL_ENERGY_COST << 1)		StarShipPtr->ship_input_state &= ~WEAPON;}

static voidpkunk_postprocess (ELEMENT *ElementPtr){	STARSHIP *StarShipPtr;	GetElementStarShip (ElementPtr, &StarShipPtr);	if (StarShipPtr->RaceDescPtr->characteristics.special_wait)		--StarShipPtr->RaceDescPtr->characteristics.special_wait;	else if ((StarShipPtr->cur_status_flags & SPECIAL)			&& StarShipPtr->RaceDescPtr->ship_info.energy_level <			StarShipPtr->RaceDescPtr->ship_info.max_energy)	{		COUNT CurSound;		do		{			CurSound =					2 + ((COUNT)TFB_Random ()					% (GetSoundCount (StarShipPtr->RaceDescPtr->ship_data.ship_sounds) - 2));		} while (CurSound == LastSound);		ProcessSound (SetAbsSoundIndex (				StarShipPtr->RaceDescPtr->ship_data.ship_sounds, CurSound				), ElementPtr);		LastSound = CurSound;		DeltaEnergy (ElementPtr, SPECIAL_ENERGY_COST);		StarShipPtr->RaceDescPtr->characteristics.special_wait = SPECIAL_WAIT;	}}

static voidintercept_pkunk_death (ELEMENT *ElementPtr){	STARSHIP *StarShipPtr;	ElementPtr->state_flags &= ~DISAPPEARING;	ElementPtr->life_span = 1;	GetElementStarShip (ElementPtr, &StarShipPtr);	if (StarShipPtr->RaceDescPtr->ship_info.crew_level == 0)	{		ELEMENT *ShipPtr;		LockElement (StarShipPtr->hShip, &ShipPtr);		if (GRAVITY_MASS (ShipPtr->mass_points + 1))		{			ElementPtr->state_flags |= DISAPPEARING;			ElementPtr->life_span = 0;		}		else		{			ShipPtr->mass_points = MAX_SHIP_MASS + 1;			StarShipPtr->RaceDescPtr->preprocess_func = ShipPtr->preprocess_func;			StarShipPtr->RaceDescPtr->postprocess_func = ShipPtr->postprocess_func;			StarShipPtr->RaceDescPtr->init_weapon_func =					(COUNT (*) (ELEMENT *ElementPtr, HELEMENT Weapon[]))							ShipPtr->death_func;			ElementPtr->death_func = new_pkunk;		}		UnlockElement (StarShipPtr->hShip);	}}

static voidpkunk_intelligence (ELEMENT *ShipPtr, EVALUATE_DESC *ObjectsOfConcern,		COUNT ConcernCounter){	STARSHIP *StarShipPtr;	HELEMENT hPhoenix;	GetElementStarShip (ShipPtr, &StarShipPtr);	hPhoenix = (HELEMENT) StarShipPtr->RaceDescPtr->data;	if (hPhoenix && (StarShipPtr->control & STANDARD_RATING))	{		RemoveElement (hPhoenix);		FreeElement (hPhoenix);		StarShipPtr->RaceDescPtr->data = 0;	}	if (StarShipPtr->RaceDescPtr->ship_info.energy_level <			StarShipPtr->RaceDescPtr->ship_info.max_energy			&& (StarShipPtr->special_counter == 0			|| (BYTE)TFB_Random () < 20))		StarShipPtr->ship_input_state |= SPECIAL;	else		StarShipPtr->ship_input_state &= ~SPECIAL;	ship_intelligence (ShipPtr, ObjectsOfConcern, ConcernCounter);}

static COUNTinitialize_test_pump_up (ELEMENT *ShipPtr, HELEMENT PumpUpArray[]){	STARSHIP *StarShipPtr;	MISSILE_BLOCK MissileBlock;	//ELEMENT *PumpUpPtr;	GetElementStarShip (ShipPtr, &StarShipPtr);	MissileBlock.cx = ShipPtr->next.location.x;	MissileBlock.cy = ShipPtr->next.location.y;	MissileBlock.farray = StarShipPtr->RaceDescPtr->ship_data.weapon;	MissileBlock.face = StarShipPtr->ShipFacing;	MissileBlock.index = 0;	MissileBlock.sender = ShipPtr->playerNr;	MissileBlock.flags = IGNORE_SIMILAR;	MissileBlock.pixoffs = MELNORME_OFFSET;	MissileBlock.speed = RES_SCALE(PUMPUP_SPEED);	MissileBlock.hit_points = PUMPUP_DAMAGE;	MissileBlock.damage = PUMPUP_DAMAGE;	MissileBlock.life = PUMPUP_LIFE;	MissileBlock.preprocess_func = 0;	MissileBlock.blast_offs = 0;	PumpUpArray[0] = initialize_missile (&MissileBlock);	return (1);}

static COUNTinitialize_confusion (ELEMENT *ShipPtr, HELEMENT ConfusionArray[]){	STARSHIP *StarShipPtr;	MISSILE_BLOCK ConfusionBlock;	GetElementStarShip (ShipPtr, &StarShipPtr);	ConfusionBlock.cx = ShipPtr->next.location.x;	ConfusionBlock.cy = ShipPtr->next.location.y;	ConfusionBlock.farray = StarShipPtr->RaceDescPtr->ship_data.special;	ConfusionBlock.index = 0;	ConfusionBlock.face = StarShipPtr->ShipFacing;	ConfusionBlock.sender = ShipPtr->playerNr;	ConfusionBlock.flags = IGNORE_SIMILAR;	ConfusionBlock.pixoffs = MELNORME_OFFSET;	ConfusionBlock.speed = CMISSILE_SPEED;	ConfusionBlock.hit_points = CMISSILE_HITS;	ConfusionBlock.damage = CMISSILE_DAMAGE;	ConfusionBlock.life = CMISSILE_LIFE;	ConfusionBlock.preprocess_func = confuse_preprocess;	ConfusionBlock.blast_offs = CMISSILE_OFFSET;	ConfusionArray[0] = initialize_missile (&ConfusionBlock);	if (ConfusionArray[0])	{		ELEMENT *CMissilePtr;		LockElement (ConfusionArray[0], &CMissilePtr);		CMissilePtr->collision_func = confusion_collision;		SetElementStarShip (CMissilePtr, StarShipPtr);		UnlockElement (ConfusionArray[0]);	}	return (1);}

static voiddruuge_preprocess (ELEMENT *ElementPtr){	STARSHIP *StarShipPtr;	GetElementStarShip (ElementPtr, &StarShipPtr);	if (StarShipPtr->cur_status_flags & SPECIAL)	{		if (StarShipPtr->special_counter				|| ElementPtr->crew_level == 1				|| StarShipPtr->RaceDescPtr->ship_info.energy_level				== StarShipPtr->RaceDescPtr->ship_info.max_energy)			StarShipPtr->cur_status_flags &= ~SPECIAL;		else		{			ProcessSound (SetAbsSoundIndex (							/* BURN UP CREW */					StarShipPtr->RaceDescPtr->ship_data.ship_sounds, 1), ElementPtr);			DeltaCrew (ElementPtr, -1);			DeltaEnergy (ElementPtr, SPECIAL_ENERGY_COST);			StarShipPtr->special_counter =					StarShipPtr->RaceDescPtr->characteristics.special_wait;		}	}}

static voidhuman_intelligence (ELEMENT *ShipPtr, EVALUATE_DESC *ObjectsOfConcern,		COUNT ConcernCounter){	STARSHIP *StarShipPtr;	GetElementStarShip (ShipPtr, &StarShipPtr);	if (StarShipPtr->special_counter == 0			&& ((ObjectsOfConcern[ENEMY_WEAPON_INDEX].ObjectPtr != NULL			&& ObjectsOfConcern[ENEMY_WEAPON_INDEX].which_turn <= 2)			|| (ObjectsOfConcern[ENEMY_SHIP_INDEX].ObjectPtr != NULL			&& ObjectsOfConcern[ENEMY_SHIP_INDEX].which_turn <= 4)))		StarShipPtr->ship_input_state |= SPECIAL;	else		StarShipPtr->ship_input_state &= ~SPECIAL;	ObjectsOfConcern[ENEMY_WEAPON_INDEX].ObjectPtr = NULL;	ship_intelligence (ShipPtr,			ObjectsOfConcern, ConcernCounter);	if (StarShipPtr->weapon_counter == 0)	{		if (ObjectsOfConcern[ENEMY_SHIP_INDEX].ObjectPtr				&& (!(StarShipPtr->ship_input_state & (LEFT | RIGHT /* | THRUST */))				|| ObjectsOfConcern[ENEMY_SHIP_INDEX].which_turn <= 12))			StarShipPtr->ship_input_state |= WEAPON;	}}

static voidmelnorme_postprocess (ELEMENT *ElementPtr){    STARSHIP *StarShipPtr;    GetElementStarShip (ElementPtr, &StarShipPtr);    if ((StarShipPtr->cur_status_flags & SPECIAL)            && StarShipPtr->special_counter == 0            && DeltaEnergy (ElementPtr, -SPECIAL_ENERGY_COST))    {        HELEMENT Confusion;        initialize_confusion (ElementPtr, &Confusion);        if (Confusion)        {            ELEMENT *CMissilePtr;            LockElement (Confusion, &CMissilePtr);            ProcessSound (SetAbsSoundIndex (                              StarShipPtr->RaceDescPtr->ship_data.ship_sounds, 1), CMissilePtr);            UnlockElement (Confusion);            PutElement (Confusion);            StarShipPtr->special_counter =                StarShipPtr->RaceDescPtr->characteristics.special_wait;        }    }}

// playerNr should be 0 or 1STARSHIP*findPlayerShip (SIZE playerNr){	HELEMENT hElement, hNextElement;	for (hElement = GetHeadElement (); hElement; hElement = hNextElement)	{		ELEMENT *ElementPtr;		LockElement (hElement, &ElementPtr);		hNextElement = GetSuccElement (ElementPtr);							if ((ElementPtr->state_flags & PLAYER_SHIP)	&&				ElementPtr->playerNr == playerNr)		{			STARSHIP *StarShipPtr;			GetElementStarShip (ElementPtr, &StarShipPtr);			UnlockElement (hElement);			return StarShipPtr;		}				UnlockElement (hElement);	}	return NULL;}

static voidbaul_preprocess (ELEMENT *ElementPtr){	STARSHIP *StarShipPtr;		GetElementStarShip (ElementPtr, &StarShipPtr);}

static voidspin_preprocess (ELEMENT *ElementPtr){	ELEMENT *ShipPtr;	STARSHIP *StarShipPtr;	GetElementStarShip (ElementPtr, &StarShipPtr);	LockElement (StarShipPtr->hShip, &ShipPtr);	if (ShipPtr->crew_level && ++StarShipPtr->RaceDescPtr->characteristics.special_wait > MAX_SAWS)	{		ElementPtr->life_span = 1;		ElementPtr->state_flags |= DISAPPEARING;	}	else	{		++ElementPtr->life_span;		if (ElementPtr->turn_wait)			--ElementPtr->turn_wait;		else		{#define LAST_SPIN_INDEX 1			if (GetFrameIndex (ElementPtr->current.image.frame) < LAST_SPIN_INDEX)				ElementPtr->next.image.frame = IncFrameIndex (ElementPtr->current.image.frame);			else				ElementPtr->next.image.frame = SetAbsFrameIndex (ElementPtr->current.image.frame, 0);						ElementPtr->state_flags |= CHANGING;			ElementPtr->turn_wait = SAW_RATE;		}	}	UnlockElement (StarShipPtr->hShip);}

static COUNTinitialize_dagger (ELEMENT *ShipPtr, HELEMENT DaggerArray[]){#define SYREEN_OFFSET (30 << RESOLUTION_FACTOR) // JMS_GFX#define MISSILE_HITS 1#define MISSILE_DAMAGE 2#define MISSILE_OFFSET (3 << RESOLUTION_FACTOR) // JMS_GFX	STARSHIP *StarShipPtr;	MISSILE_BLOCK MissileBlock;	GetElementStarShip (ShipPtr, &StarShipPtr);	MissileBlock.cx = ShipPtr->next.location.x;	MissileBlock.cy = ShipPtr->next.location.y;	MissileBlock.farray = StarShipPtr->RaceDescPtr->ship_data.weapon;	MissileBlock.face = MissileBlock.index = StarShipPtr->ShipFacing;	MissileBlock.sender = ShipPtr->playerNr;	MissileBlock.flags = IGNORE_SIMILAR;	MissileBlock.pixoffs = SYREEN_OFFSET;	MissileBlock.speed = MISSILE_SPEED << RESOLUTION_FACTOR; // JMS_GFX	MissileBlock.hit_points = MISSILE_HITS;	MissileBlock.damage = MISSILE_DAMAGE;	MissileBlock.life = MISSILE_LIFE;	MissileBlock.preprocess_func = NULL;	MissileBlock.blast_offs = MISSILE_OFFSET;	DaggerArray[0] = initialize_missile (&MissileBlock);	return (1);}

static COUNTinitialize_autoaim_laser (ELEMENT *ShipPtr, HELEMENT LaserArray[]){	COUNT orig_facing;	SIZE delta_facing;	STARSHIP *StarShipPtr;	LASER_BLOCK LaserBlock;	GetElementStarShip (ShipPtr, &StarShipPtr);	LaserBlock.face = orig_facing = StarShipPtr->ShipFacing;	if ((delta_facing = TrackShip (ShipPtr, &LaserBlock.face)) > 0)		LaserBlock.face = NORMALIZE_FACING (orig_facing + delta_facing);	ShipPtr->hTarget = 0;	LaserBlock.cx = ShipPtr->next.location.x;	LaserBlock.cy = ShipPtr->next.location.y;	LaserBlock.ex = COSINE (FACING_TO_ANGLE (LaserBlock.face), LASER_RANGE);	LaserBlock.ey = SINE (FACING_TO_ANGLE (LaserBlock.face), LASER_RANGE);	LaserBlock.sender = ShipPtr->playerNr;	LaserBlock.flags = IGNORE_SIMILAR;	LaserBlock.pixoffs = ARILOU_OFFSET;	LaserBlock.color = BUILD_COLOR (MAKE_RGB15 (0x1F, 0x1F, 0x0A), 0x0E);	LaserArray[0] = initialize_laser (&LaserBlock);	return (1);}

static voiddruuge_postprocess (ELEMENT *ElementPtr){	STARSHIP *StarShipPtr;	GetElementStarShip (ElementPtr, &StarShipPtr);			/* if just fired cannon */	if ((StarShipPtr->cur_status_flags & WEAPON)			&& StarShipPtr->weapon_counter ==			StarShipPtr->RaceDescPtr->characteristics.weapon_wait)	{		COUNT angle;		SIZE cur_delta_x, cur_delta_y;		StarShipPtr->cur_status_flags &= ~SHIP_AT_MAX_SPEED;		angle = FACING_TO_ANGLE (StarShipPtr->ShipFacing) + HALF_CIRCLE;		DeltaVelocityComponents (&ElementPtr->velocity,				COSINE (angle, RECOIL_VELOCITY),				SINE (angle, RECOIL_VELOCITY));		GetCurrentVelocityComponents (&ElementPtr->velocity,				&cur_delta_x, &cur_delta_y);		if ((long)cur_delta_x * (long)cur_delta_x				+ (long)cur_delta_y * (long)cur_delta_y				> (long)MAX_RECOIL_VELOCITY * (long)MAX_RECOIL_VELOCITY)		{			angle = ARCTAN (cur_delta_x, cur_delta_y);			SetVelocityComponents (&ElementPtr->velocity,					COSINE (angle, MAX_RECOIL_VELOCITY),					SINE (angle, MAX_RECOIL_VELOCITY));		}	}}

static COUNTinitialize_cannon (ELEMENT *ShipPtr, HELEMENT CannonArray[]){	STARSHIP *StarShipPtr;	MISSILE_BLOCK MissileBlock;	GetElementStarShip (ShipPtr, &StarShipPtr);	MissileBlock.cx = ShipPtr->next.location.x;	MissileBlock.cy = ShipPtr->next.location.y;	MissileBlock.farray = StarShipPtr->RaceDescPtr->ship_data.weapon;	MissileBlock.face = StarShipPtr->ShipFacing;	MissileBlock.index = MissileBlock.face;	MissileBlock.sender = ShipPtr->playerNr;	MissileBlock.flags = IGNORE_SIMILAR;	MissileBlock.pixoffs = DRUUGE_OFFSET;	MissileBlock.speed = MISSILE_SPEED;	MissileBlock.hit_points = MISSILE_HITS;	MissileBlock.damage = MISSILE_DAMAGE;	MissileBlock.life = MISSILE_LIFE;	MissileBlock.preprocess_func = NULL;	MissileBlock.blast_offs = MISSILE_OFFSET;	CannonArray[0] = initialize_missile (&MissileBlock);	if (CannonArray[0])	{		ELEMENT *CannonPtr;		LockElement (CannonArray[0], &CannonPtr);		CannonPtr->collision_func = cannon_collision;		UnlockElement (CannonArray[0]);	}	return (1);}

// This is used by AI for testing would it hit the enemy ship with gas.static COUNTinitialize_test_gas (ELEMENT *ElementPtr, HELEMENT GasArray[]){	STARSHIP *StarShipPtr;	MISSILE_BLOCK MissileBlock;		GetElementStarShip (ElementPtr, &StarShipPtr);		MissileBlock.cx = ElementPtr->next.location.x;	MissileBlock.cy = ElementPtr->next.location.y;	MissileBlock.farray = StarShipPtr->RaceDescPtr->ship_data.special;	MissileBlock.face = StarShipPtr->ShipFacing;	MissileBlock.index = LAST_DISSOLVE_INDEX;	MissileBlock.sender = ElementPtr->playerNr;	MissileBlock.flags =  GASSY_SUBSTANCE | IGNORE_VELOCITY;	MissileBlock.pixoffs = GAS_OFFSET;	MissileBlock.speed = GAS_INIT_SPEED;	MissileBlock.hit_points = GAS_HITS;	MissileBlock.damage = GAS_DAMAGE;	MissileBlock.life = 20; // Not GAS_LIFE because this test gas doesn't slow down at all -> life has to be short.	MissileBlock.preprocess_func = gas_preprocess;	MissileBlock.blast_offs = 0;	GasArray[0] = initialize_missile (&MissileBlock);		return (1);}

static COUNTinitialize_standard_missile (ELEMENT *ShipPtr, HELEMENT MissileArray[]){#define SPATHI_FORWARD_OFFSET 16#define MISSILE_HITS 1#define MISSILE_DAMAGE 1#define MISSILE_OFFSET 1	STARSHIP *StarShipPtr;	MISSILE_BLOCK MissileBlock;	GetElementStarShip (ShipPtr, &StarShipPtr);	MissileBlock.cx = ShipPtr->next.location.x;	MissileBlock.cy = ShipPtr->next.location.y;	MissileBlock.farray = StarShipPtr->RaceDescPtr->ship_data.weapon;	MissileBlock.face = MissileBlock.index = StarShipPtr->ShipFacing;	MissileBlock.sender = ShipPtr->playerNr;	MissileBlock.flags = IGNORE_SIMILAR;	MissileBlock.pixoffs = SPATHI_FORWARD_OFFSET;	MissileBlock.speed = MISSILE_SPEED;	MissileBlock.hit_points = MISSILE_HITS;	MissileBlock.damage = MISSILE_DAMAGE;	MissileBlock.life = MISSILE_LIFE;	MissileBlock.preprocess_func = NULL;	MissileBlock.blast_offs = MISSILE_OFFSET;	MissileArray[0] = initialize_missile (&MissileBlock);	return (1);}

static COUNTinitialize_horn (ELEMENT *ShipPtr, HELEMENT HornArray[]){#define MISSILE_HITS 1#define MISSILE_DAMAGE 1#define MISSILE_OFFSET 2#define SUPOX_OFFSET 23	STARSHIP *StarShipPtr;	MISSILE_BLOCK MissileBlock;	GetElementStarShip (ShipPtr, &StarShipPtr);	MissileBlock.cx = ShipPtr->next.location.x;	MissileBlock.cy = ShipPtr->next.location.y;	MissileBlock.farray = StarShipPtr->RaceDescPtr->ship_data.weapon;	MissileBlock.face = MissileBlock.index = StarShipPtr->ShipFacing;	MissileBlock.sender = (ShipPtr->state_flags & (GOOD_GUY | BAD_GUY))			| IGNORE_SIMILAR;	MissileBlock.pixoffs = SUPOX_OFFSET;	MissileBlock.speed = MISSILE_SPEED;	MissileBlock.hit_points = MISSILE_HITS;	MissileBlock.damage = MISSILE_DAMAGE;	MissileBlock.life = MISSILE_LIFE;	MissileBlock.preprocess_func = NULL;	MissileBlock.blast_offs = MISSILE_OFFSET;	HornArray[0] = initialize_missile (&MissileBlock);	return (1);}

static COUNTinitialize_turret_missile (PELEMENT ShipPtr, HELEMENT MissileArray[]){#define MISSILE_HITS 2#define MISSILE_DAMAGE 3#define MISSILE_OFFSET 1	ELEMENTPTR TurretPtr;	STARSHIPPTR StarShipPtr;	MISSILE_BLOCK MissileBlock;	GetElementStarShip (ShipPtr, &StarShipPtr);	MissileBlock.cx = ShipPtr->next.location.x;	MissileBlock.cy = ShipPtr->next.location.y;	MissileBlock.farray = StarShipPtr->RaceDescPtr->ship_data.weapon;	LockElement (GetSuccElement (ShipPtr), &TurretPtr);	if (TurretPtr->turn_wait == 0			&& (StarShipPtr->cur_status_flags & SPECIAL)			&& (StarShipPtr->cur_status_flags & (LEFT | RIGHT)))	{		if (StarShipPtr->cur_status_flags & RIGHT)			++TurretPtr->thrust_wait;		else			--TurretPtr->thrust_wait;		TurretPtr->turn_wait = TURRET_WAIT + 1;	}	MissileBlock.face = MissileBlock.index =			NORMALIZE_FACING (StarShipPtr->ShipFacing			+ TurretPtr->thrust_wait);	UnlockElement (GetSuccElement (ShipPtr));	MissileBlock.sender = (ShipPtr->state_flags & (GOOD_GUY | BAD_GUY))			| IGNORE_SIMILAR;	MissileBlock.pixoffs = TURRET_OFFSET;	MissileBlock.speed = MISSILE_SPEED;	MissileBlock.hit_points = MISSILE_HITS;	MissileBlock.damage = MISSILE_DAMAGE;	MissileBlock.life = MISSILE_LIFE;	MissileBlock.preprocess_func = NULL_PTR;	MissileBlock.blast_offs = MISSILE_OFFSET;	MissileArray[0] = initialize_missile (&MissileBlock);	if (MissileArray[0])	{		ELEMENTPTR HowitzerPtr;		LockElement (MissileArray[0], &HowitzerPtr);		HowitzerPtr->collision_func = howitzer_collision;		UnlockElement (MissileArray[0]);	}	return (1);}

static voidbuzzsaw_preprocess (ELEMENT *ElementPtr){	STARSHIP *StarShipPtr;	GetElementStarShip (ElementPtr, &StarShipPtr);	if (!(StarShipPtr->cur_status_flags & WEAPON))	{		ElementPtr->life_span >>= 1;		ElementPtr->preprocess_func = decelerate_preprocess;	}

static COUNTinitialize_bug_missile (ELEMENT *ShipPtr, HELEMENT MissileArray[]){#define PKUNK_OFFSET 15#define MISSILE_HITS 1#define MISSILE_DAMAGE 1#define MISSILE_OFFSET 1	COUNT i;	STARSHIP *StarShipPtr;	MISSILE_BLOCK MissileBlock;	GetElementStarShip (ShipPtr, &StarShipPtr);	MissileBlock.cx = ShipPtr->next.location.x;	MissileBlock.cy = ShipPtr->next.location.y;	MissileBlock.farray = StarShipPtr->RaceDescPtr->ship_data.weapon;	MissileBlock.index = 0;	MissileBlock.sender = ShipPtr->playerNr;	MissileBlock.flags = IGNORE_SIMILAR;	MissileBlock.pixoffs = PKUNK_OFFSET;	MissileBlock.speed = MISSILE_SPEED;	MissileBlock.hit_points = MISSILE_HITS;	MissileBlock.damage = MISSILE_DAMAGE;	MissileBlock.life = MISSILE_LIFE;	MissileBlock.preprocess_func = NULL;	MissileBlock.blast_offs = MISSILE_OFFSET;	for (i = 0; i < 3; ++i)	{		MissileBlock.face =				StarShipPtr->ShipFacing				+ (ANGLE_TO_FACING (QUADRANT) * i);		if (i == 2)			MissileBlock.face += ANGLE_TO_FACING (QUADRANT);		MissileBlock.face = NORMALIZE_FACING (MissileBlock.face);		if ((MissileArray[i] = initialize_missile (&MissileBlock)))		{			SIZE dx, dy;			ELEMENT *MissilePtr;			LockElement (MissileArray[i], &MissilePtr);			GetCurrentVelocityComponents (&ShipPtr->velocity, &dx, &dy);			DeltaVelocityComponents (&MissilePtr->velocity, dx, dy);			MissilePtr->current.location.x -= VELOCITY_TO_WORLD (dx);			MissilePtr->current.location.y -= VELOCITY_TO_WORLD (dy);			MissilePtr->preprocess_func = animate;			UnlockElement (MissileArray[i]);		}	}	return (3);}

static voidhuman_postprocess (ELEMENT *ElementPtr){	STARSHIP *StarShipPtr;	GetElementStarShip (ElementPtr, &StarShipPtr);	if ((StarShipPtr->cur_status_flags & SPECIAL)			&& StarShipPtr->special_counter == 0)	{		spawn_point_defense (ElementPtr);	}}

static voiddoggy_preprocess (ELEMENT *ElementPtr){	STARSHIP *StarShipPtr;	GetElementStarShip (ElementPtr, &StarShipPtr);	++StarShipPtr->special_counter;	if (ElementPtr->thrust_wait > 0) /* could be non-zero after a collision */		--ElementPtr->thrust_wait;	else	{		COUNT facing, orig_facing;		SIZE delta_facing;		facing = orig_facing =				NORMALIZE_FACING (ANGLE_TO_FACING (				GetVelocityTravelAngle (&ElementPtr->velocity)				));		if ((delta_facing = TrackShip (ElementPtr, &facing)) < 0)			facing = NORMALIZE_FACING (TFB_Random ());		else		{			ELEMENT *ShipPtr;			LockElement (ElementPtr->hTarget, &ShipPtr);			facing = NORMALIZE_FACING (ANGLE_TO_FACING (					ARCTAN (ShipPtr->current.location.x -					ElementPtr->current.location.x,					ShipPtr->current.location.y -					ElementPtr->current.location.y)					));			delta_facing = NORMALIZE_FACING (facing -					GetFrameIndex (ShipPtr->current.image.frame));			UnlockElement (ElementPtr->hTarget);			if (delta_facing > ANGLE_TO_FACING (HALF_CIRCLE - OCTANT) &&					delta_facing < ANGLE_TO_FACING (HALF_CIRCLE + OCTANT))			{				if (delta_facing >= ANGLE_TO_FACING (HALF_CIRCLE))					facing -= ANGLE_TO_FACING (QUADRANT);				else					facing += ANGLE_TO_FACING (QUADRANT);			}			facing = NORMALIZE_FACING (facing);		}		if (facing != orig_facing)			SetVelocityVector (&ElementPtr->velocity,					DOGGY_SPEED, facing);	}}

static voidspathi_intelligence (ELEMENT *ShipPtr, EVALUATE_DESC *ObjectsOfConcern,		COUNT ConcernCounter){	STARSHIP *StarShipPtr;	EVALUATE_DESC *lpEvalDesc;	ship_intelligence (ShipPtr, ObjectsOfConcern, ConcernCounter);	GetElementStarShip (ShipPtr, &StarShipPtr);	StarShipPtr->ship_input_state &= ~SPECIAL;	lpEvalDesc = &ObjectsOfConcern[ENEMY_SHIP_INDEX];	if (StarShipPtr->special_counter == 0			&& lpEvalDesc->ObjectPtr			&& lpEvalDesc->which_turn <= 24)	{		COUNT travel_facing, direction_facing;		SIZE delta_x, delta_y;		travel_facing = NORMALIZE_FACING (				ANGLE_TO_FACING (GetVelocityTravelAngle (&ShipPtr->velocity)				+ HALF_CIRCLE)				);		delta_x = lpEvalDesc->ObjectPtr->current.location.x				- ShipPtr->current.location.x;		delta_y = lpEvalDesc->ObjectPtr->current.location.y				- ShipPtr->current.location.y;		direction_facing = NORMALIZE_FACING (				ANGLE_TO_FACING (ARCTAN (delta_x, delta_y))				);		if (NORMALIZE_FACING (direction_facing				- (StarShipPtr->ShipFacing + ANGLE_TO_FACING (HALF_CIRCLE))				+ ANGLE_TO_FACING (QUADRANT))				<= ANGLE_TO_FACING (HALF_CIRCLE)				&& (lpEvalDesc->which_turn <= 8				|| NORMALIZE_FACING (direction_facing				+ ANGLE_TO_FACING (HALF_CIRCLE)				- ANGLE_TO_FACING (GetVelocityTravelAngle (						&lpEvalDesc->ObjectPtr->velocity						))				+ ANGLE_TO_FACING (QUADRANT))				<= ANGLE_TO_FACING (HALF_CIRCLE))				&& (!(StarShipPtr->cur_status_flags &				(SHIP_BEYOND_MAX_SPEED | SHIP_IN_GRAVITY_WELL))				|| NORMALIZE_FACING (direction_facing				- travel_facing + ANGLE_TO_FACING (QUADRANT))				<= ANGLE_TO_FACING (HALF_CIRCLE)))			StarShipPtr->ship_input_state |= SPECIAL;	}}