/**
* @brief Collecting stunned aliens and alien bodies after the mission.
* @param[in] aircraft Pointer to the aircraft with cargo.
* @sa CL_ParseResults
* @sa CL_GameAutoGo
*/
void AL_CollectingAliens (aircraft_t *aircraft)
{
le_t *le = NULL;
while ((le = LE_GetNextInUse(le))) {
if (LE_IsActor(le) && LE_IsAlien(le)) {
assert(le->teamDef);
if (LE_IsStunned(le))
AL_AddAlienTypeToAircraftCargo(aircraft, le->teamDef, 1, qfalse);
else if (LE_IsDead(le))
AL_AddAlienTypeToAircraftCargo(aircraft, le->teamDef, 1, qtrue);
}
}
}
/**
* @brief Starts shooting with actor.
* @param[in] self Pointer to the event structure that is currently executed
* @param[in] msg The netchannel message
* @sa CL_ActorShootHidden
* @sa CL_ActorShoot
* @sa CL_ActorDoShoot
* @todo Improve detection of left- or right animation.
* @sa EV_ACTOR_START_SHOOT
*/
void CL_ActorStartShoot (const eventRegister_t *self, dbuffer *msg)
{
le_t *le;
pos3_t from, target;
int entnum;
shoot_types_t shootType;
NET_ReadFormat(msg, self->formatString, &entnum, &shootType, &from, &target);
/* shooting actor */
le = LE_Get(entnum);
/* center view (if wanted) */
if (cl.actTeam != cls.team)
CL_CameraRoute(from, target);
/* actor dependent stuff following */
if (!le)
/* it's OK, the actor is not visible */
return;
if (!LE_IsLivingActor(le) || LE_IsStunned(le)) {
Com_Printf("CL_ActorStartShoot: LE (%i) not a living actor (type: %i)\n", entnum, le->type);
return;
}
/* ET_ACTORHIDDEN actors don't have a model yet */
if (le->type == ET_ACTORHIDDEN)
return;
/* Animate - we have to check if it is right or left weapon usage. */
if (IS_SHOT_RIGHT(shootType)) {
R_AnimChange(&le->as, le->model1, LE_GetAnim("move", le->right, le->left, le->state));
} else if (IS_SHOT_LEFT(shootType)) {
R_AnimChange(&le->as, le->model1, LE_GetAnim("move", le->left, le->right, le->state));
} else if (!IS_SHOT_HEADGEAR(shootType)) {
/* no animation for headgear (yet) */
Com_Error(ERR_DROP, "CL_ActorStartShoot: Invalid shootType given (entnum: %i, shootType: %i).\n", shootType, entnum);
}
}
/**
* @brief Searches a local entity at the given position.
* @param[in] pos The grid position to search a local entity at
* @param[in] includingStunned Also search for stunned actors if @c true.
* @param[in] actor The current selected actor
*/
le_t* CL_BattlescapeSearchAtGridPos (const pos3_t pos, bool includingStunned, const le_t *actor)
{
le_t *le;
le_t *nonActor = NULL;
/* search for an actor on this field */
le = NULL;
while ((le = LE_GetNextInUse(le))) {
if (actor != NULL && le == actor->clientAction) {
/* if the actor has a client action assigned and we click onto the actor,
* we will trigger this client action */
if (VectorCompare(actor->pos, pos))
nonActor = le;
} else if (le != actor && LE_IsLivingAndVisibleActor(le) && (includingStunned || !LE_IsStunned(le)))
switch (le->fieldSize) {
case ACTOR_SIZE_NORMAL:
if (VectorCompare(le->pos, pos))
return le;
break;
case ACTOR_SIZE_2x2: {
pos3_t actor2x2[3];
VectorSet(actor2x2[0], le->pos[0] + 1, le->pos[1], le->pos[2]);
VectorSet(actor2x2[1], le->pos[0], le->pos[1] + 1, le->pos[2]);
VectorSet(actor2x2[2], le->pos[0] + 1, le->pos[1] + 1, le->pos[2]);
if (VectorCompare(le->pos, pos)
|| VectorCompare(actor2x2[0], pos)
|| VectorCompare(actor2x2[1], pos)
|| VectorCompare(actor2x2[2], pos))
return le;
break;
}
default:
Com_Error(ERR_DROP, "Grid_MoveCalc: unknown actor-size: %i!", le->fieldSize);
}
}
return nonActor;
}
/**
* @brief Plays step sounds and draw particles for different terrain types
* @param[in] le The local entity to play the sound and draw the particle for
* @param[in] textureName The name of the texture the actor is standing on
* @sa LET_PathMove
*/
static void LE_PlaySoundFileAndParticleForSurface (le_t* le, const char* textureName)
{
const terrainType_t* t = Com_GetTerrainType(textureName);
if (!t)
return;
/* origin might not be up-to-date here - but pos should be */
vec3_t origin;
PosToVec(le->pos, origin);
/** @todo use the Grid_Fall method (ACTOR_SIZE_NORMAL) to ensure, that the particle is
* drawn at the ground (if needed - maybe the origin is already ground aligned)*/
if (t->particle) {
/* check whether actor is visible */
if (!LE_IsStunned(le) && LE_IsLivingAndVisibleActor(le))
CL_ParticleSpawn(t->particle, 0, origin);
}
if (t->footstepSound) {
Com_DPrintf(DEBUG_SOUND, "LE_PlaySoundFileAndParticleForSurface: volume %.2f\n", t->footstepVolume);
S_LoadAndPlaySample(t->footstepSound, origin, SOUND_ATTN_STATIC, t->footstepVolume);
}
}
/**
* @brief Revitalizes a stunned actor (all that is needed is the local entity state set).
* @param[in] msg The netchannel message
* @param[in] self Pointer to the event structure that is currently executed
*/
void CL_ActorRevitalised (const eventRegister_t* self, dbuffer* msg)
{
int entnum, state;
NET_ReadFormat(msg, self->formatString, &entnum, &state);
/* get les */
le_t* le = LE_Get(entnum);
if (!le)
LE_NotFoundError(entnum);
if (!LE_IsStunned(le) && !LE_IsLivingActor(le))
Com_Error(ERR_DROP, "CL_ActorRevitalised: Can't revitalise, LE is not a dead or stunned actor");
LE_Lock(le);
/* link any floor container into the actor temp floor container */
le_t* floor = LE_Find(ET_ITEM, le->pos);
if (floor)
le->setFloor(floor);
le->state = state;
/* play animation */
LE_SetThink(le, LET_StartIdle);
/* Print some info. */
if (le->team == cls.team) {
const character_t* chr = CL_ActorGetChr(le);
if (chr) {
char tmpbuf[128];
Com_sprintf(tmpbuf, lengthof(tmpbuf), _("%s was revitalised\n"), chr->name);
HUD_DisplayMessage(tmpbuf);
}
} else {
switch (le->team) {
case (TEAM_CIVILIAN):
HUD_DisplayMessage(_("A civilian was revitalised."));
break;
case (TEAM_ALIEN):
HUD_DisplayMessage(_("An alien was revitalised."));
break;
case (TEAM_PHALANX):
HUD_DisplayMessage(_("A soldier was revitalised."));
break;
default:
HUD_DisplayMessage(va(_("A member of team %i was revitalised."), le->team));
break;
}
}
le->aabb.setMaxs(player_maxs);
if (le->ptl) {
CL_ParticleFree(le->ptl);
le->ptl = nullptr;
}
/* add team members to the actor list */
CL_ActorAddToTeamList(le);
/* update pathing as we maybe not can walk onto this actor anymore */
CL_ActorConditionalMoveCalc(selActor);
LE_Unlock(le);
}
/**
* @brief Kills an actor (all that is needed is the local entity state set to STATE_DEAD).
* @note Also changes the animation to a random death sequence and appends the dead animation
* @param[in] msg The netchannel message
* @param[in] self Pointer to the event structure that is currently executed
*/
void CL_ActorDie (const eventRegister_t *self, dbuffer *msg)
{
le_t *le;
int entnum, state, playerNum;
NET_ReadFormat(msg, self->formatString, &entnum, &state, &playerNum);
/* get les */
le = LE_Get(entnum);
if (!le)
LE_NotFoundError(entnum);
if (!LE_IsLivingActor(le))
Com_Error(ERR_DROP, "CL_ActorDie: Can't kill, LE is not an actor (type: %i)", le->type);
if (!LE_IsStunned(le) && LE_IsDead(le))
Com_Error(ERR_DROP, "CL_ActorDie: Can't kill, actor already dead");
LE_Lock(le);
/* set relevant vars */
FLOOR(le) = NULL;
le->state = state;
/* count spotted aliens */
cl.numEnemiesSpotted = CL_CountVisibleEnemies();
/* play animation */
LE_SetThink(le, NULL);
R_AnimChange(&le->as, le->model1, va("death%i", LE_GetAnimationIndexForDeath(le)));
R_AnimAppend(&le->as, le->model1, va("dead%i", LE_GetAnimationIndexForDeath(le)));
/* Print some info about the death or stun. */
if (le->team == cls.team) {
if (playerNum != le->pnum) {
const char *playerName = CL_PlayerGetName(playerNum);
char tmpbuf[128];
Com_sprintf(tmpbuf, lengthof(tmpbuf), _("%s lost a soldier\n"), playerName);
HUD_DisplayMessage(tmpbuf);
} else {
const character_t *chr = CL_ActorGetChr(le);
if (chr) {
char tmpbuf[128];
if (LE_IsStunned(le)) {
Com_sprintf(tmpbuf, lengthof(tmpbuf), _("%s was stunned\n"), chr->name);
} else {
Com_sprintf(tmpbuf, lengthof(tmpbuf), _("%s was killed\n"), chr->name);
}
HUD_DisplayMessage(tmpbuf);
}
}
} else {
switch (le->team) {
case (TEAM_CIVILIAN):
if (LE_IsStunned(le))
HUD_DisplayMessage(_("A civilian was stunned."));
else
HUD_DisplayMessage(_("A civilian was killed."));
break;
case (TEAM_ALIEN):
if (LE_IsStunned(le))
HUD_DisplayMessage(_("An alien was stunned."));
else
HUD_DisplayMessage(_("An alien was killed."));
break;
case (TEAM_PHALANX):
if (LE_IsStunned(le))
HUD_DisplayMessage(_("A soldier was stunned."));
else
HUD_DisplayMessage(_("A soldier was killed."));
break;
default:
if (LE_IsStunned(le))
HUD_DisplayMessage(va(_("A member of team %i was stunned."), le->team));
else
HUD_DisplayMessage(va(_("A member of team %i was killed."), le->team));
break;
}
}
/**
* @todo CHRSH_IsTeamDefRobot: spawn smoke particles for robots
*/
CL_ActorPlaySound(le, SND_DEATH);
VectorCopy(player_dead_maxs, le->maxs);
if (!LE_IsStunned(le))
le->contents = CONTENTS_DEADACTOR;
CL_ActorRemoveFromTeamList(le);
/* update pathing as we maybe can walk onto the dead actor now */
CL_ActorConditionalMoveCalc(selActor);
LE_Unlock(le);
}
/**
* @sa CL_ActorAddToTeamList
* @sa G_AppearPerishEvent
* @sa CL_ActorAdd
* @note EV_ACTOR_APPEAR
*/
void CL_ActorAppear (const eventRegister_t *self, struct dbuffer *msg)
{
le_t *le, *leResponsible;
int entnum, entnumResponsible, modelnum1, modelnum2;
int teamDefID = -1;
/* check if the actor is already visible */
entnum = NET_ReadShort(msg);
entnumResponsible = NET_ReadShort(msg);
le = LE_Get(entnum);
leResponsible = LE_Get(entnumResponsible);
if (entnumResponsible != SKIP_LOCAL_ENTITY && !leResponsible)
LE_NotFoundError(entnumResponsible);
/* mission start - no actor is spawned yet - so create it */
if (!le)
le = LE_Add(entnum);
/* Locking should be unnecessary if CL_CheckDefault filters this call, since this event starts and
* ends in this function only. Adding lock/unlock just to be sure. */
LE_Lock(le);
/* maybe added via CL_ActorAdd before */
le->invis = false;
/* get the info */
NET_ReadFormat(msg, self->formatString,
&le->team, &teamDefID, &le->gender, &le->ucn, &le->pnum, &le->pos,
&le->angle, &le->right, &le->left,
&modelnum1, &modelnum2, &le->bodySkin, &le->headSkin,
&le->state, &le->fieldSize,
&le->maxTU, &le->maxMorale, &le->maxHP);
if (teamDefID < 0 || teamDefID > csi.numTeamDefs)
Com_Printf("CL_ActorAppear: Invalid teamDef index\n");
else
le->teamDef = &csi.teamDef[teamDefID];
switch (le->fieldSize) {
case ACTOR_SIZE_NORMAL:
le->addFunc = CL_AddActor;
le->type = ET_ACTOR;
break;
case ACTOR_SIZE_2x2:
le->addFunc = CL_AddUGV;
le->type = ET_ACTOR2x2;
break;
default:
Com_Error(ERR_DROP, "Unknown fieldSize for le in CL_ActorAppear (EV_ACTOR_APPEAR)");
}
le->modelnum1 = modelnum1;
le->modelnum2 = modelnum2;
le->model1 = LE_GetDrawModel(modelnum1);
le->model2 = LE_GetDrawModel(modelnum2);
Grid_PosToVec(cl.mapData->map, le->fieldSize, le->pos, le->origin);
le->angles[YAW] = directionAngles[le->angle];
if (LE_IsDead(le) && !LE_IsStunned(le))
le->contents = CONTENTS_DEADACTOR;
else
le->contents = CONTENTS_ACTOR;
VectorCopy(player_mins, le->mins);
if (LE_IsDead(le))
VectorCopy(player_dead_maxs, le->maxs);
else
VectorCopy(player_maxs, le->maxs);
LE_SetThink(le, LET_StartIdle);
/* count spotted aliens (also stunned) */
cl.numEnemiesSpotted = CL_CountVisibleEnemies();
if (LE_IsLivingActor(le)) {
if (cl.actTeam != cls.team) {
/* center view (if wanted) */
LE_CenterView(le);
}
/* draw line of sight */
if (le->team != cls.team) {
if (leResponsible)
CL_DrawLineOfSight(leResponsible, le);
/* message */
if (le->team != TEAM_CIVILIAN) {
if (GAME_TeamIsKnown(le->teamDef)) {
char tmpbuf[128];
Com_sprintf(tmpbuf, sizeof(tmpbuf), _("Enemy spotted: %s!"), _(le->teamDef->name));
HUD_DisplayMessage(tmpbuf);
} else
HUD_DisplayMessage(_("Unknown enemy spotted!"));
} else
HUD_DisplayMessage(_("Civilian spotted."));
/* update pathing as new actor could block path */
CL_ActorConditionalMoveCalc(leResponsible ? leResponsible : selActor);
}
}
/* add team members to the actor list */
CL_ActorAddToTeamList(le);
LE_Unlock(le);
}
/**
* @brief Checks whether the given le is a living actor (but might be hidden)
* @param[in] le The local entity to perform the check for
* @sa G_IsLivingActor
* @sa LE_IsActor
*/
bool LE_IsLivingActor (const le_t* le)
{
assert(le);
return LE_IsActor(le) && (LE_IsStunned(le) || !LE_IsDead(le));
}
