g_events.c

Go to the documentation of this file.

/*
Copyright (C) 2002-2010 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"

void G_EventSpawnSound (const edict_t* ent, const vec3_t origin, const char *sound)
{
    gi.PositionedSound(PM_ALL, origin, ent, sound);
}

void G_EventActorTurn (const edict_t* ent)
{
    gi.AddEvent(G_VisToPM(ent->visflags), EV_ACTOR_TURN);
    gi.WriteShort(ent->number);
    gi.WriteByte(ent->dir);
}

void G_EventActorDie (const edict_t* ent)
{
    gi.AddEvent(G_VisToPM(ent->visflags), EV_ACTOR_DIE);
    gi.WriteShort(ent->number);
    gi.WriteShort(ent->state);
}

void G_EventActorRevitalise (const edict_t* ent)
{
    gi.AddEvent(G_VisToPM(ent->visflags), EV_ACTOR_REVITALISED);
    gi.WriteShort(ent->number);
    gi.WriteShort(ent->state);
}

void G_EventActorSendReservations (const edict_t *ent)
{
    gi.AddEvent(G_PlayerToPM(G_PLAYER_FROM_ENT(ent)), EV_ACTOR_RESERVATIONCHANGE);

    gi.WriteShort(ent->number);
    gi.WriteShort(ent->chr.reservedTus.reaction);
    gi.WriteShort(ent->chr.reservedTus.shot);
    gi.WriteShort(ent->chr.reservedTus.crouch);

    gi.EndEvents();
}

void G_EventInventoryDelete (const edict_t* ent, int playerMask, const invDef_t* invDef, int x, int y)
{
    gi.AddEvent(playerMask, EV_INV_DEL);
    gi.WriteShort(ent->number);
    gi.WriteByte(invDef->id);
    gi.WriteByte(x);
    gi.WriteByte(y);
}

void G_EventInventoryAdd (const edict_t* ent, int playerMask, int itemAmount)
{
    gi.AddEvent(playerMask, EV_INV_ADD);
    gi.WriteShort(ent->number);
    gi.WriteShort(itemAmount * INV_INVENTORY_BYTES);
}

void G_EventPerish (const edict_t* ent)
{
    gi.AddEvent(G_VisToPM(ent->visflags), EV_ENT_PERISH);
    gi.WriteShort(ent->number);
}

void G_EventDestroyEdict (const edict_t* ent)
{
    gi.AddEvent(PM_ALL, EV_ENT_DESTROY);
    gi.WriteShort(ent->number);
}

void G_EventInventoryAmmo (const edict_t* ent, const objDef_t* ammo, int amount, shoot_types_t shootType)
{
    gi.AddEvent(G_VisToPM(ent->visflags), EV_INV_AMMO);
    gi.WriteShort(ent->number);
    gi.WriteByte(amount);
    gi.WriteByte(ammo->idx);
    if (IS_SHOT_RIGHT(shootType))
        gi.WriteByte(gi.csi->idRight);
    else
        gi.WriteByte(gi.csi->idLeft);
    /* x and y value */
    gi.WriteByte(0);
    gi.WriteByte(0);
}

void G_EventStartShoot (const edict_t* ent, int visMask, shoot_types_t shootType, const pos3_t at)
{
    gi.AddEvent(G_VisToPM(visMask), EV_ACTOR_START_SHOOT);
    gi.WriteShort(ent->number);
    gi.WriteByte(shootType);
    gi.WriteGPos(ent->pos);
    gi.WriteGPos(at);
}

void G_EventShootHidden (int visMask, const fireDef_t* fd, qboolean firstShoot)
{
    gi.AddEvent(~G_VisToPM(visMask), EV_ACTOR_SHOOT_HIDDEN);
    gi.WriteByte(firstShoot);
    gi.WriteShort(fd->obj->idx);
    gi.WriteByte(fd->weapFdsIdx);
    gi.WriteByte(fd->fdIdx);
}

void G_EventShoot (const edict_t* ent, int visMask, const fireDef_t* fd, qboolean firstShoot, shoot_types_t shootType, int flags, const trace_t* trace, const vec3_t from, const vec3_t impact)
{
    const edict_t *targetEdict = trace->ent;

    gi.AddEvent(G_VisToPM(visMask), EV_ACTOR_SHOOT);
    gi.WriteShort(ent->number);
    if (targetEdict && G_IsBreakable(targetEdict))
        gi.WriteShort(targetEdict->number);
    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);
}

void G_EventReactionFireChange (const edict_t* ent)
{
    const objDef_t *od = ent->chr.RFmode.weapon;

    gi.AddEvent(G_PlayerToPM(G_PLAYER_FROM_ENT(ent)), EV_ACTOR_REACTIONFIRECHANGE);

    gi.WriteShort(ent->number);
    gi.WriteByte(ent->chr.RFmode.fmIdx);
    gi.WriteByte(ent->chr.RFmode.hand);
    gi.WriteShort(od ? od->idx : NONE);

    gi.EndEvents();
}

void G_EventParticleSpawn (int playerMask, const char *name, int levelFlags, const vec3_t s, const vec3_t v, const vec3_t a)
{
    gi.AddEvent(playerMask, EV_PARTICLE_SPAWN);
    gi.WriteByte(levelFlags);
    gi.WritePos(s);
    gi.WritePos(v);
    gi.WritePos(a);
    gi.WriteString(name);
}

void G_EventActorFall (const edict_t* ent)
{
    gi.AddEvent(G_VisToPM(ent->visflags), EV_ACTOR_MOVE);
    gi.WriteShort(ent->number);
    gi.WriteByte(1);
    gi.WriteByte(ent->pos[0]);
    gi.WriteByte(ent->pos[1]);
    gi.WriteByte(ent->pos[2]);
    gi.WriteByte(makeDV(DIRECTION_FALL, ent->pos[2]));
    gi.WriteShort(GRAVITY);
    gi.WriteShort(0);
}

void G_EventSetClientAction (const edict_t *ent)
{
    assert(ent->clientAction);

    /* tell the hud to show the door buttons */
    gi.AddEvent(G_TeamToPM(ent->team), EV_DOOR_ACTION);
    gi.WriteShort(ent->number);
    gi.WriteShort(ent->clientAction->number);
    gi.EndEvents();
}

void G_EventResetClientAction (const edict_t* ent)
{
    gi.AddEvent(G_PlayerToPM(G_PLAYER_FROM_ENT(ent)), EV_RESET_CLIENT_ACTION);
    gi.WriteShort(ent->number);
}

void G_EventActorStats (const edict_t* ent)
{
    gi.AddEvent(G_TeamToPM(ent->team), EV_ACTOR_STATS);
    gi.WriteShort(ent->number);
    gi.WriteByte(ent->TU);
    gi.WriteShort(ent->HP);
    gi.WriteByte(ent->STUN);
    gi.WriteByte(ent->morale);
}

void G_EventEndRound (void)
{
    gi.AddEvent(PM_ALL, EV_ENDROUND);
    gi.WriteByte(level.activeTeam);
}

void G_EventInventoryReload (const edict_t* ent, int playerMask, const item_t* item, const invDef_t* invDef, const invList_t* ic)
{
    gi.AddEvent(playerMask, EV_INV_RELOAD);
    gi.WriteShort(ent->number);
    gi.WriteByte(item->t->ammo);
    gi.WriteByte(item->m->idx);
    gi.WriteByte(invDef->id);
    gi.WriteByte(ic->x);
    gi.WriteByte(ic->y);
}

void G_EventThrow (int visMask, const fireDef_t *fd, float dt, byte flags, const vec3_t position, const vec3_t velocity)
{
    gi.AddEvent(G_VisToPM(visMask), EV_ACTOR_THROW);
    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);
}

void G_EventSendEdict (const edict_t *ent)
{
    gi.AddEvent(PM_ALL, EV_ADD_EDICT);
    gi.WriteByte(ent->type);
    gi.WriteShort(ent->number);
    gi.WritePos(ent->absmin);
    gi.WritePos(ent->absmax);
}