g_events.cpp

Go to the documentation of this file.

 
/*
Copyright (C) 2002-2025 UFO: Alien Invasion.
 
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
See the GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
*/
 
#include "g_local.h"    /* also includes g_event.h */
#include "g_actor.h"
#include "g_client.h"
#include "g_edicts.h"
#include "g_inventory.h"

void G_EventSpawnSound (playermask_t playerMask, const Edict& ent, const vec3_t origin, const char* sound)
{
    G_EventAdd(playerMask, EV_SOUND, ent.getIdNum());
 
    /* use the entity origin unless it is a bmodel or explicitly specified */
    if (!origin) {
        if (ent.solid == SOLID_BSP) {
            vec3_t origin_v;
            ent.entBox.getCenter(origin_v);
            VectorAdd(ent.origin, origin_v, origin_v);
            gi.WritePos(origin);
        } else {
            gi.WritePos(vec3_origin);
        }
    } else {
        gi.WritePos(origin);
    }
    gi.WriteByte(0xFF);
    gi.WriteString(sound);
    G_EventEnd();
}
 
void G_EventSpawnFootstepSound (const Edict& ent, const char* sound)
{
    const playermask_t playerMask = ~G_VisToPM(ent.visflags);
    gi.QueueEvent(playerMask, EV_SOUND, ent.getIdNum());
    gi.QueueWritePos(ent.origin);
    gi.QueueWriteByte(ent.moveinfo.steps);
    gi.QueueWriteString(sound);
}

void G_EventActorTurn (const Edict& ent)
{
    G_EventAdd(G_VisToPM(ent.visflags), EV_ACTOR_TURN, ent.getIdNum());
    gi.WriteByte(ent.dir);
    G_EventEnd();
}

void G_EventActorDie (const Edict& ent, bool attacker)
{
    G_EventAdd(G_VisToPM(ent.visflags), EV_ACTOR_DIE, ent.getIdNum());
    gi.WriteShort(ent.state);
    gi.WriteByte(ent.getPlayerNum());
    gi.WriteByte(attacker);
    G_EventEnd();
}

void G_EventActorRevitalise (const Edict& ent)
{
    G_EventAdd(G_VisToPM(ent.visflags), EV_ACTOR_REVITALISED, ent.getIdNum());
    gi.WriteShort(ent.state);
    G_EventEnd();
}

void G_EventActorSendReservations (const Edict& ent)
{
    G_EventAdd(G_PlayerToPM(ent.getPlayer()), EV_ACTOR_RESERVATIONCHANGE, ent.getIdNum());
    const chrReservations_t& reservedTUs = ent.chr.reservedTus;
    gi.WriteShort(reservedTUs.reaction);
    gi.WriteShort(reservedTUs.shot);
    gi.WriteShort(reservedTUs.crouch);
 
    G_EventEnd();
}

void G_EventInventoryDelete (const Edict& ent, playermask_t playerMask, const containerIndex_t containerId, int x, int y)
{
    G_EventAdd(playerMask, EV_INV_DEL, ent.getIdNum());
    gi.WriteByte(containerId);
    gi.WriteByte(x);
    gi.WriteByte(y);
    G_EventEnd();
}

void G_EventInventoryAdd (const Edict& ent, playermask_t playerMask, int itemAmount)
{
    G_EventAdd(playerMask, EV_INV_ADD, ent.getIdNum());
    gi.WriteShort(itemAmount);
    /* do not end the pending events here - this is just a header, the items are following */
}

void G_EventPerish (const Edict& ent)
{
    G_EventEdictPerish(G_VisToPM(ent.visflags), ent);
}

void G_EventDestroyEdict (const Edict& ent)
{
    assert(ent.inuse);
    G_EventAdd(PM_ALL, EV_ENT_DESTROY, ent.getIdNum());
    G_EventEnd();
}

void G_EventInventoryAmmo (const Edict& ent, const objDef_t* ammo, int amount, shoot_types_t shootType)
{
    G_EventAdd(G_VisToPM(ent.visflags), EV_INV_AMMO, ent.getIdNum());
    gi.WriteByte(amount);
    gi.WriteByte(ammo->idx);
    if (IS_SHOT_RIGHT(shootType))
        gi.WriteByte(CID_RIGHT);
    else
        gi.WriteByte(CID_LEFT);
    /* x and y value */
    gi.WriteByte(0);
    gi.WriteByte(0);
    G_EventEnd();
}

void G_EventStartShoot (const Edict& ent, teammask_t teamMask, shoot_types_t shootType, const pos3_t at)
{
    G_EventAdd(G_VisToPM(teamMask), EV_ACTOR_START_SHOOT, ent.getIdNum());
    gi.WriteByte(shootType);
    gi.WriteGPos(ent.pos);
    gi.WriteGPos(at);
    G_EventEnd();
}

void G_EventEndShoot (const Edict &ent, teammask_t teamMask)
{
    G_EventAdd(G_VisToPM(teamMask), EV_ACTOR_END_SHOOT, ent.getIdNum());
    G_EventEnd();
}

void G_EventShootHidden (teammask_t teamMask, const fireDef_t* fd, bool firstShoot, const vec3_t impact, int flags, const Edict* targetEdict)
{
    G_EventAdd(~G_VisToPM(teamMask), EV_ACTOR_SHOOT_HIDDEN, -1);
    if (targetEdict && G_IsBreakable(targetEdict))
        gi.WriteShort(targetEdict->getIdNum());
    else
        gi.WriteShort(SKIP_LOCAL_ENTITY);
    gi.WriteByte(firstShoot);
    gi.WriteShort(fd->obj->idx);
    gi.WriteByte(fd->weapFdsIdx);
    gi.WriteByte(fd->fdIdx);
    gi.WritePos(impact);
    gi.WriteByte(flags);
    G_EventEnd();
}

void G_EventShoot (const Edict& ent, teammask_t teamMask, const fireDef_t* fd, bool firstShoot, shoot_types_t shootType, int flags, const trace_t* trace, const vec3_t from, const vec3_t impact)
{
    const Edict* targetEdict = G_EdictsGetByNum(trace->entNum); /* the ent possibly hit by the trace */
 
    G_EventAdd(G_VisToPM(teamMask), EV_ACTOR_SHOOT, ent.getIdNum());
    if (targetEdict && G_IsBreakable(targetEdict))
        gi.WriteShort(targetEdict->getIdNum());
    else
        gi.WriteShort(SKIP_LOCAL_ENTITY);
    gi.WriteByte(firstShoot ? 1 : 0);
    gi.WriteShort(fd->obj->idx);
    gi.WriteByte(fd->weapFdsIdx);
    gi.WriteByte(fd->fdIdx);
    gi.WriteByte(shootType);
    gi.WriteByte(flags);
    gi.WriteByte(trace->contentFlags);
    gi.WritePos(from);
    gi.WritePos(impact);
    gi.WriteDir(trace->plane.normal);
    G_EventEnd();
}
 
void G_EventReactionFireChange (const Edict& ent)
{
    const FiremodeSettings& fireMode = ent.chr.RFmode;
    const objDef_t* od = fireMode.getWeapon();
 
    G_EventAdd(G_PlayerToPM(ent.getPlayer()), EV_ACTOR_REACTIONFIRECHANGE, ent.getIdNum());
    gi.WriteByte(fireMode.getFmIdx());
    gi.WriteByte(fireMode.getHand());
    gi.WriteShort(od ? od->idx : NONE);
 
    G_EventEnd();
}
 
void G_EventReactionFireAddTarget (const Edict& shooter, const Edict& target, int tus, int step)
{
    gi.QueueEvent(G_PlayerToPM(shooter.getPlayer()), EV_ACTOR_REACTIONFIREADDTARGET, shooter.getIdNum());
    gi.QueueWriteShort(target.getIdNum());
    gi.QueueWriteByte(tus);
    gi.QueueWriteByte(step);
}
 
void G_EventReactionFireRemoveTarget (const Edict& shooter, const Edict& target, int step)
{
    gi.QueueEvent(G_PlayerToPM(shooter.getPlayer()), EV_ACTOR_REACTIONFIREREMOVETARGET, shooter.getIdNum());
    gi.QueueWriteShort(target.getIdNum());
    gi.QueueWriteByte(step);
}
 
void G_EventReactionFireTargetUpdate (const Edict& shooter, const Edict& target, int tus, int step)
{
    gi.QueueEvent(G_PlayerToPM(shooter.getPlayer()), EV_ACTOR_REACTIONFIRETARGETUPDATE, shooter.getIdNum());
    gi.QueueWriteShort(target.getIdNum());
    gi.QueueWriteByte(tus);
    gi.QueueWriteByte(step);
}
 
void G_EventReactionFireAbortShot (const Edict& shooter, const Edict& target, int step)
{
    gi.QueueEvent(G_PlayerToPM(shooter.getPlayer()), EV_ACTOR_REACTIONFIREABORTSHOT, shooter.getIdNum());
    gi.QueueWriteShort(target.getIdNum());
    gi.QueueWriteByte(step);
}

void G_EventParticleSpawn (playermask_t playerMask, const char* name, int levelFlags, const vec3_t s, const vec3_t v, const vec3_t a)
{
    G_EventAdd(playerMask, EV_PARTICLE_SPAWN, -1);
    gi.WriteByte(levelFlags);
    gi.WritePos(s);
    gi.WritePos(v);
    gi.WritePos(a);
    gi.WriteString(name);
    G_EventEnd();
}
 
void G_EventActorFall (const Edict& ent)
{
    G_EventAdd(PM_ALL, EV_ACTOR_MOVE, ent.getIdNum());
    gi.WriteByte(0);
    gi.WriteShort(makeDV(DIRECTION_FALL, ent.pos[2]));
    gi.WriteShort(GRAVITY);
    gi.WriteShort(0);
    G_EventEnd();
}

void G_EventSetClientAction (const Edict& ent)
{
    assert(ent.clientAction);
    assert(ent.clientAction->flags & FL_CLIENTACTION);
 
    /* tell the hud to show the door buttons */
    G_EventAdd(G_TeamToPM(ent.getTeam()), EV_CLIENT_ACTION, ent.getIdNum());
    gi.WriteShort(ent.clientAction->getIdNum());
    G_EventEnd();
}

void G_EventResetClientAction (const Edict& ent)
{
    const int playerMask = G_PlayerToPM(ent.getPlayer());
    G_EventAdd(playerMask, EV_RESET_CLIENT_ACTION, ent.getIdNum());
    G_EventEnd();
}
 
void G_EventActorStats (const Edict& ent, playermask_t playerMask)
{
    G_EventAdd(playerMask, EV_ACTOR_STATS, ent.getIdNum());
    gi.WriteByte(ent.TU);
    gi.WriteShort(ent.HP);
    gi.WriteByte(ent.getStun());
    gi.WriteByte(ent.morale);
    G_EventEnd();
}

void G_EventActorWound (const Edict& ent, const int bodyPart)
{
    const int mask = G_PlayerToPM(ent.getPlayer());
    G_EventAdd(mask, EV_ACTOR_WOUND, ent.getIdNum());
    gi.WriteByte(bodyPart);
    const woundInfo_t& wounds = ent.chr.wounds;
    gi.WriteByte(wounds.woundLevel[bodyPart]);
    gi.WriteByte(wounds.treatmentLevel[bodyPart]);
    G_EventEnd();
}

void G_EventEndRound (void)
{
    G_EventAdd(PM_ALL, EV_ENDROUND, -1);
    gi.WriteByte(level.activeTeam);
    G_EventEnd();
}
 
void G_EventInventoryReload (const Edict& ent, playermask_t playerMask, const Item* item, const invDef_t* invDef, const Item* ic)
{
    G_EventAdd(playerMask, EV_INV_RELOAD, ent.getIdNum());
    gi.WriteByte(item->def()->ammo);
    gi.WriteByte(item->ammoDef()->idx);
    gi.WriteByte(invDef->id);
    gi.WriteByte(ic->getX());
    gi.WriteByte(ic->getY());
    G_EventEnd();
}

void G_EventThrow (teammask_t teamMask, const fireDef_t* fd, float dt, byte flags, const vec3_t position, const vec3_t velocity)
{
    G_EventAdd(G_VisToPM(teamMask), EV_ACTOR_THROW, -1);
    gi.WriteShort(dt * 1000);
    gi.WriteShort(fd->obj->idx);
    gi.WriteByte(fd->weapFdsIdx);
    gi.WriteByte(fd->fdIdx);
    gi.WriteByte(flags);
    gi.WritePos(position);
    gi.WritePos(velocity);
    G_EventEnd();
}

void G_EventSendEdict (const Edict& ent)
{
    G_EventAdd(PM_ALL, EV_ADD_EDICT, ent.getIdNum());
    gi.WriteByte(ent.type);
    gi.WritePos(ent.absBox.mins);
    gi.WritePos(ent.absBox.maxs);
    G_EventEnd();
}
 
void G_EventSendState (playermask_t playerMask, const Edict& ent)
{
    G_EventActorStateChange(playerMask & G_TeamToPM(ent.getTeam()), ent);
 
    G_EventAdd(playerMask & ~G_TeamToPM(ent.getTeam()), EV_ACTOR_STATECHANGE, ent.getIdNum());
    gi.WriteShort(ent.state & STATE_PUBLIC);
    G_EventEnd();
}

void G_EventCenterView (const Edict& ent)
{
    G_EventCenterViewAt(G_VisToPM(ent.visflags), ent.pos);
}

void G_EventCenterViewAt (playermask_t playerMask, const pos3_t pos)
{
    G_EventAdd(playerMask, EV_CENTERVIEW, -1);
    gi.WriteGPos(pos);
    G_EventEnd();
}

void G_EventMoveCameraTo (playermask_t playerMask, const pos3_t pos)
{
    G_EventAdd(playerMask, EV_MOVECAMERA, -1);
    gi.WriteGPos(pos);
    G_EventEnd();
}

void G_EventActorAdd (playermask_t playerMask, const Edict& ent, const bool instant)
{
    G_EventAdd(playerMask, EV_ACTOR_ADD | (instant ? EVENT_INSTANTLY : 0), ent.getIdNum());
    gi.WriteByte(ent.getTeam());
    gi.WriteByte(ent.chr.teamDef ? ent.chr.teamDef->idx : NONE);
    gi.WriteByte(ent.chr.gender);
    gi.WriteByte(ent.getPlayerNum());
    gi.WriteGPos(ent.pos);
    gi.WriteShort(ent.state & STATE_PUBLIC);
    gi.WriteByte(ent.fieldSize);
    G_EventEnd();
}

void G_EventSendParticle (playermask_t playerMask, const Edict& ent)
{
    G_EventAdd(playerMask, EV_PARTICLE_APPEAR, ent.getIdNum());
    gi.WriteShort(ent.spawnflags);
    gi.WritePos(ent.origin);
    gi.WriteString(ent.particle);
    G_EventEnd();
}

void G_EventCameraAppear (playermask_t playerMask, const Edict& ent)
{
    G_EventAdd(playerMask, EV_CAMERA_APPEAR, ent.getIdNum());
    gi.WritePos(ent.origin);
    gi.WriteByte(ent.getTeam());
    gi.WriteByte(ent.dir);
    gi.WriteByte(ent.camera.cameraType);
    /* strip the higher bits - only send levelflags */
    gi.WriteByte(ent.spawnflags & 0xFF);
    gi.WriteByte(ent.camera.rotate);
    G_EventEnd();
}

void G_EventEdictAppear (playermask_t playerMask, const Edict& ent)
{
    G_EventAdd(playerMask, EV_ENT_APPEAR, ent.getIdNum());
    gi.WriteByte(ent.type);
    gi.WriteGPos(ent.pos);
    G_EventEnd();
}
 
void G_EventActorAppear (playermask_t playerMask, const Actor& check, const Edict* ent)
{
    const int mask = G_TeamToPM(check.getTeam()) & playerMask;
 
    /* parsed in CL_ActorAppear */
    G_EventAdd(playerMask, EV_ACTOR_APPEAR, check.getIdNum());
    gi.WriteShort(ent && ent->getIdNum() > 0 ? ent->getIdNum() : SKIP_LOCAL_ENTITY);
    gi.WriteByte(check.getTeam());
    gi.WriteByte(check.chr.teamDef ? check.chr.teamDef->idx : NONE);
    gi.WriteByte(check.chr.gender);
    gi.WriteShort(check.chr.ucn);
    gi.WriteByte(check.getPlayerNum());
    gi.WriteGPos(check.pos);
    gi.WriteByte(check.dir);
    if (check.getRightHandItem()) {
        gi.WriteShort(check.getRightHandItem()->def()->idx);
    } else {
        gi.WriteShort(NONE);
    }
 
    if (check.getLeftHandItem()) {
        gi.WriteShort(check.getLeftHandItem()->def()->idx);
    } else {
        gi.WriteShort(NONE);
    }
 
    if (check.getBody() == 0 || check.getHead() == 0) {
        gi.Error("invalid body and/or head model indices");
    }
    gi.WriteShort(check.getBody());
    gi.WriteShort(check.getHead());
    gi.WriteByte(check.chr.bodySkin);
    gi.WriteByte(check.chr.headSkin);
    /* strip the server private states */
    gi.WriteShort(check.state & STATE_PUBLIC);
    gi.WriteByte(check.fieldSize);
    /* get the max values for TU and morale */
    gi.WriteByte(G_ActorCalculateMaxTU(&check));
    gi.WriteByte(std::min(MAX_SKILL, GET_MORALE(check.chr.score.skills[ABILITY_MIND])));
    gi.WriteShort(check.chr.maxHP);
    G_EventEnd();
 
    if (mask) {
        G_EventActorStateChange(mask, check);
        G_SendInventory(mask, check);
    }
}

void G_EventEdictPerish (playermask_t playerMask, const Edict& ent)
{
    assert(ent.inuse);
    G_EventAdd(playerMask, EV_ENT_PERISH, ent.getIdNum());
    gi.WriteByte(ent.type);
    G_EventEnd();
}
 
void G_EventActorStateChange (playermask_t playerMask, const Edict& ent)
{
    G_EventAdd(playerMask, EV_ACTOR_STATECHANGE, ent.getIdNum());
    gi.WriteShort(ent.state);
    G_EventEnd();
}
 
void G_EventAddBrushModel (playermask_t playerMask, const Edict& ent)
{
    G_EventAdd(playerMask, EV_ADD_BRUSH_MODEL, ent.getIdNum());
    gi.WriteByte(ent.type);
    gi.WriteShort(ent.modelindex);
    /* strip the higher bits - only send levelflags */
    gi.WriteByte(ent.spawnflags & 0xFF);
    gi.WritePos(ent.origin);
    gi.WritePos(ent.angles);
    gi.WriteShort(ent.speed);
    gi.WriteByte(ent.angle);
    gi.WriteByte(ent.dir);
    G_EventEnd();
}
 
void G_EventEndRoundAnnounce (const Player& player)
{
    G_EventAdd(PM_ALL, EV_ENDROUNDANNOUNCE, -1);
    gi.WriteByte(player.getNum());
    gi.WriteByte(player.getTeam());
    G_EventEnd();
}
 
void G_EventStart (const Player& player, bool teamplay)
{
    G_EventAdd(G_PlayerToPM(player), EV_START | EVENT_INSTANTLY, -1);
    gi.WriteByte(teamplay);
    G_EventEnd();
}
 
void G_EventReset (const Player& player, int activeTeam)
{
    G_EventAdd(G_PlayerToPM(player), EV_RESET | EVENT_INSTANTLY, -1);
    gi.WriteByte(player.getTeam());
    gi.WriteByte(activeTeam);
    G_EventEnd();
}
 
void G_EventDoorOpen (const Edict& door)
{
    G_EventAdd(PM_ALL, EV_DOOR_OPEN, door.getIdNum());
    G_EventEnd();
}
 
void G_EventDoorClose (const Edict& door)
{
    G_EventAdd(PM_ALL, EV_DOOR_CLOSE, door.getIdNum());
    G_EventEnd();
}
 
void G_EventModelExplodeTriggered (const Edict& ent, const char* sound)
{
    assert(ent.inuse);
    G_EventAdd(PM_ALL, EV_MODEL_EXPLODE_TRIGGERED, ent.getIdNum());
    gi.WriteString(sound);
    G_EventEnd();
}
 
void G_EventModelExplode (const Edict& ent, const char* sound)
{
    assert(ent.inuse);
    G_EventAdd(PM_ALL, EV_MODEL_EXPLODE, ent.getIdNum());
    gi.WriteString(sound);
    G_EventEnd();
}
 
void G_EventAdd (playermask_t playerMask, int eType, int entnum)
{
    G_EventEnd();
    gi.AddEvent(playerMask, eType, entnum);
}
 
void G_EventEnd (void)
{
    if (gi.GetEvent() == EV_ACTOR_MOVE) {
        /* mark the end of the steps */
        gi.WriteLong(0);
        const Edict* ent = gi.GetEventEdict();
        assert(ent);
        gi.WriteGPos(ent->pos);
    }
    gi.EndEvents();
}