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

/** * @brief Actor has been wounded/treated * @param[in] ent The actor whose wound status has changed * @note This event is sent to the player this actor belongs to */void G_EventActorWound (const edict_t *ent, const int bodyPart){	const int mask = G_PlayerToPM(G_PLAYER_FROM_ENT(ent));	G_EventAdd(mask, EV_ACTOR_WOUND, ent->number);	gi.WriteByte(bodyPart);	gi.WriteByte(ent->chr.wounds.woundLevel[bodyPart]);	gi.WriteByte(ent->chr.wounds.treatmentLevel[bodyPart]);	G_EventEnd();}

void G_EventActorStats (const edict_t* ent, int playerMask){	G_EventAdd(playerMask, EV_ACTOR_STATS, ent->number);	gi.WriteByte(ent->TU);	gi.WriteShort(ent->HP);	gi.WriteByte(ent->STUN);	gi.WriteByte(ent->morale);	G_EventEnd();}

/** * @brief Start the shooting event for hidden actors * @param visMask the vis mask to determine the clients from this event is send to * @param fd The firedefinition to use for the shoot * @param firstShoot Is this the first shoot */void G_EventShootHidden (vismask_t visMask, const fireDef_t* fd, bool firstShoot){	G_EventAdd(~G_VisToPM(visMask), EV_ACTOR_SHOOT_HIDDEN, -1);	gi.WriteByte(firstShoot);	gi.WriteShort(fd->obj->idx);	gi.WriteByte(fd->weapFdsIdx);	gi.WriteByte(fd->fdIdx);	G_EventEnd();}

/** * @brief Send info about an actor's wounds to the client. * @param[in] ent The actor whose wound status we are sending. * @param[in] bodyPart The body part index we are sending wound info about. * @note This event is sent to the player this actor belongs to */void G_EventActorWound (const Edict& ent, const int bodyPart){	const int mask = G_PlayerToPM(ent.getPlayer());	G_EventAdd(mask, EV_ACTOR_WOUND, ent.number);	gi.WriteByte(bodyPart);	const woundInfo_t& wounds = ent.chr.wounds;	gi.WriteByte(wounds.woundLevel[bodyPart]);	gi.WriteByte(wounds.treatmentLevel[bodyPart]);	G_EventEnd();}

/** * @brief Spawn a new particle for the client * @param[in] playerMask A bit mask. One bit for each affected player * @param[in] name The id of the particle (see ptl_*.ufo script files in base/ufos) * @param[in] levelFlags Show at which levels * @param[in] s starting/location vector * @param[in] v velocity vector * @param[in] a acceleration vector */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_EventInventoryReload (const Edict& ent, playermask_t playerMask, const Item* item, const invDef_t* invDef, const Item* ic){	G_EventAdd(playerMask, EV_INV_RELOAD, ent.number);	gi.WriteByte(item->def()->ammo);	gi.WriteByte(item->ammoDef()->idx);	gi.WriteByte(invDef->id);	gi.WriteByte(ic->getX());	gi.WriteByte(ic->getY());	G_EventEnd();}

/** * @brief Informs the client that an interaction with the world is possible * @note It's assumed that the clientAction is already set * @param[in] ent The edict that can execute the action (an actor) */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.team), EV_CLIENT_ACTION, ent.number);	gi.WriteShort(ent.clientAction->number);	G_EventEnd();}

/** * @brief Will inform the player about the real TU reservation * @param ent The actors edict. */void G_EventActorSendReservations (const Edict& ent){	G_EventAdd(G_PlayerToPM(ent.getPlayer()), EV_ACTOR_RESERVATIONCHANGE, ent.number);	const chrReservations_t& reservedTUs = ent.chr.reservedTus;	gi.WriteShort(reservedTUs.reaction);	gi.WriteShort(reservedTUs.shot);	gi.WriteShort(reservedTUs.crouch);	G_EventEnd();}

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

void G_EventReactionFireChange (const edict_t* ent){	const objDef_t *od = ent->chr.RFmode.weapon;	G_EventAdd(G_PlayerToPM(G_PLAYER_FROM_ENT(ent)), EV_ACTOR_REACTIONFIRECHANGE, ent->number);	gi.WriteByte(ent->chr.RFmode.fmIdx);	gi.WriteByte(ent->chr.RFmode.getHand());	gi.WriteShort(od ? od->idx : NONE);	G_EventEnd();}

/** * @brief Send an appear event to the client. * @param playerMask The players to send the event to * @param ent The camera that should appear to the players included in the given mask. */void G_EventCameraAppear (unsigned int playerMask, const edict_t *ent){	G_EventAdd(playerMask, EV_CAMERA_APPEAR, ent->number);	gi.WritePos(ent->origin);	gi.WriteByte(ent->team);	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_EventActorFall (const Edict& ent){	G_EventAdd(G_VisToPM(ent.visflags), EV_ACTOR_MOVE, 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);	G_EventEnd();}

/** * @brief Send an appear event to the client. * @param playerMask The players to send the event to * @param ent The camera that should appear to the players included in the given mask. */void G_EventCameraAppear (playermask_t playerMask, const Edict& ent){	G_EventAdd(playerMask, EV_CAMERA_APPEAR, ent.number);	gi.WritePos(ent.origin);	gi.WriteByte(ent.team);	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_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.number);	gi.WriteByte(fireMode.getFmIdx());	gi.WriteByte(fireMode.getHand());	gi.WriteShort(od ? od->idx : NONE);	G_EventEnd();}

/** * @param[in] teamMask the vis mask to determine the clients from this event is send to * @param[in] fd The firedefinition to use * @param[in] dt Delta time * @param[in] flags bitmask of the following values: @c SF_BODY, @c SF_IMPACT, @c SF_BOUNCING and @c SF_BOUNCED * @param[in] position The current position * @param[in] velocity The velocity of the throw */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();}

/** * @sa CL_ActorAdd */void G_EventActorAdd (unsigned int playerMask, const edict_t *ent){	G_EventAdd(playerMask, EV_ACTOR_ADD, ent->number);	gi.WriteByte(ent->team);	gi.WriteByte(ent->chr.teamDef ? ent->chr.teamDef->idx : NONE);	gi.WriteByte(ent->chr.gender);	gi.WriteByte(ent->pnum);	gi.WriteGPos(ent->pos);	gi.WriteShort(ent->state & STATE_PUBLIC);	gi.WriteByte(ent->fieldSize);	G_EventEnd();}

/** * @sa CL_ActorAdd */void G_EventActorAdd (playermask_t playerMask, const Edict& ent){	G_EventAdd(playerMask, EV_ACTOR_ADD, ent.number);	gi.WriteByte(ent.team);	gi.WriteByte(ent.chr.teamDef ? ent.chr.teamDef->idx : NONE);	gi.WriteByte(ent.chr.gender);	gi.WriteByte(ent.pnum);	gi.WriteGPos(ent.pos);	gi.WriteShort(ent.state & STATE_PUBLIC);	gi.WriteByte(ent.fieldSize);	G_EventEnd();}

/** * @brief Change the amount of available ammo for the given entity * @param ent The entity to change the amount of ammo for * @param ammo The ammo to change * @param amount The new amount of the left ammo * @param shootType The shooting type to determine which container to use */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.number);	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_EventAddBrushModel (unsigned int playerMask, const edict_t *ent){	G_EventAdd(playerMask, EV_ADD_BRUSH_MODEL, ent->number);	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();}

/** * @brief Change the amount of available ammo for the given entity * @param ent The entity to change the amount of ammo for * @param ammo The ammo to change * @param amount The new amount of the left ammo * @param shootType The shooting type to determine which container to use */void G_EventInventoryAmmo (const edict_t* ent, const objDef_t* ammo, int amount, shoot_types_t shootType){	G_EventAdd(G_VisToPM(ent->visflags), EV_INV_AMMO, 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);	G_EventEnd();}

void G_EventAddBrushModel (playermask_t playerMask, const Edict& ent){	G_EventAdd(playerMask, EV_ADD_BRUSH_MODEL, ent.number);	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_EventActorAppear (playermask_t playerMask, const Edict& check, const Edict* ent){	const int mask = G_TeamToPM(check.team) & playerMask;	/* parsed in CL_ActorAppear */	G_EventAdd(playerMask, EV_ACTOR_APPEAR, check.number);	gi.WriteShort(ent && ent->number > 0 ? ent->number : SKIP_LOCAL_ENTITY);	gi.WriteByte(check.team);	gi.WriteByte(check.chr.teamDef ? check.chr.teamDef->idx : NONE);	gi.WriteByte(check.chr.gender);	gi.WriteShort(check.chr.ucn);	gi.WriteByte(check.pnum);	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.body == 0 || check.head == 0) {		gi.Error("invalid body and/or head model indices");	}	gi.WriteShort(check.body);	gi.WriteShort(check.head);	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);	}}

/** * @brief Spawns a sound (that will be spatialized on the client side) * @param ent The edict that is causing the sound * @param origin The origin of the sound * @param sound The sound file, path relative to sounds/. If there is a + at the end the client will * choose a random sound. See the event function for more information. * of the path, a random sound will be taken. */void G_EventSpawnSound (unsigned int playerMask, bool instant, const edict_t* ent, const vec3_t origin, const char *sound){	G_EventAdd(playerMask, EV_SOUND | (instant ? EVENT_INSTANTLY : 0), ent->number);	/* use the entity origin unless it is a bmodel or explicitly specified */	if (!origin) {		if (ent->solid == SOLID_BSP) {			vec3_t origin_v;			VectorCenterFromMinsMaxs(ent->mins, ent->maxs, origin_v);			VectorAdd(ent->origin, origin_v, origin_v);			gi.WritePos(origin);		} else {			gi.WritePos(vec3_origin);		}	} else {		gi.WritePos(origin);	}	gi.WriteString(sound);	G_EventEnd();}

/** * @brief Do the shooting * @param ent The entity that is doing the shooting * @param visMask the vis mask to determine the clients from this event is send to * @param fd The firedefinition to use for the shoot * @param firstShoot Is this the first shoot * @param shootType The type of the shoot * @param flags Define some flags in a bitmask: @c SF_BODY, @c SF_IMPACT, @c SF_BOUNCING and @c SF_BOUNCING * @param trace The trace what was used to determine whether this shot has hit something * @param from The position the entity shoots from * @param impact The impact world vector for the shot */void G_EventShoot (const edict_t* ent, vismask_t visMask, 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_t *targetEdict = trace->ent;	G_EventAdd(G_VisToPM(visMask), EV_ACTOR_SHOOT, 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);	G_EventEnd();}

/** * @brief Do the shooting * @param ent The entity that is doing the shooting * @param teamMask the vis mask to determine the clients from this event is send to * @param fd The firedefinition to use for the shoot * @param firstShoot Is this the first shoot * @param shootType The type of the shoot * @param flags Define some flags in a bitmask: @c SF_BODY, @c SF_IMPACT, @c SF_BOUNCING and @c SF_BOUNCING * @param trace The trace what was used to determine whether this shot has hit something * @param from The position the entity shoots from * @param impact The impact world vector for the shot */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.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);	G_EventEnd();}

/** * @brief Spawns a sound (that will be spatialized on the client side) * @param playerMask A bit mask. One bit for each affected player * @param ent The edict that is causing the sound * @param origin The origin of the sound * @param sound The sound file, path relative to sounds/. If there is a + at the end the client will * choose a random sound. See the event function for more information. * of the path, a random sound will be taken. */void G_EventSpawnSound (playermask_t playerMask, const Edict& ent, const vec3_t origin, const char* sound){	G_EventAdd(playerMask, EV_SOUND, ent.number);	/* 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();}

/** * @brief Writes a step of the move event to the net * @param[in] ent Edict to move * @param[in] stepAmount Pointer to the amount of steps in this move-event * @param[in] dvec The direction vector for the step to be added * @param[in] contentFlags The material we are walking over */static void G_WriteStep (edict_t* ent, byte** stepAmount, const int dvec, const int contentFlags){	/* write move header if not yet done */	if (gi.GetEvent() != EV_ACTOR_MOVE) {		G_EventAdd(G_VisToPM(ent->visflags), EV_ACTOR_MOVE, ent->number);	}	/* the moveinfo stuff is used inside the G_PhysicsStep think function */	if (ent->moveinfo.steps >= MAX_ROUTE) {		ent->moveinfo.steps = 0;		ent->moveinfo.currentStep = 0;	}	ent->moveinfo.contentFlags[ent->moveinfo.steps] = contentFlags;	ent->moveinfo.visflags[ent->moveinfo.steps] = ent->visflags;	ent->moveinfo.steps++;	/* write move header and always one step after another - because the next step	 * might already be the last one due to some stop event */	gi.WriteShort(dvec);	gi.WriteShort(ent->speed);	gi.WriteShort(contentFlags);}

/** * @brief Send the turn event for the given entity * @param ent The entity to send the turn event for * @note Every player that can see this ent will reveive the turn event data * @note Make sure that the direction to turn into is already set */void G_EventActorTurn (const Edict& ent){	G_EventAdd(G_VisToPM(ent.visflags), EV_ACTOR_TURN, ent.number);	gi.WriteByte(ent.dir);	G_EventEnd();}

void G_EventDoorClose (const Edict& door){	G_EventAdd(PM_ALL, EV_DOOR_CLOSE, door.number);	G_EventEnd();}

void G_EventDoorOpen (const Edict& door){	G_EventAdd(PM_ALL, EV_DOOR_OPEN, door.number);	G_EventEnd();}