/**
* @brief Decides if following events should be delayed
*/
int CL_ActorShootHiddenTime (const eventRegister_t *self, dbuffer *msg, eventTiming_t *eventTiming)
{
int first;
int objIdx;
const objDef_t *obj;
weaponFireDefIndex_t weapFdsIdx;
fireDefIndex_t fireDefIndex;
const int eventTime = eventTiming->shootTime;
NET_ReadFormat(msg, self->formatString, &first, &objIdx, &weapFdsIdx, &fireDefIndex);
obj = INVSH_GetItemByIDX(objIdx);
if (first) {
eventTiming->nextTime += 500;
eventTiming->impactTime = eventTiming->shootTime = eventTiming->nextTime;
} else {
const fireDef_t *fd = FIRESH_GetFiredef(obj, weapFdsIdx, fireDefIndex);
/* impact right away - we don't see it at all
* bouncing is not needed here, too (we still don't see it) */
eventTiming->impactTime = eventTiming->shootTime;
eventTiming->nextTime = CL_GetNextTime(self, eventTiming, eventTiming->shootTime + 1400);
if (fd->delayBetweenShots > 0.0)
eventTiming->shootTime += 1000 / fd->delayBetweenShots;
}
eventTiming->parsedDeath = false;
return eventTime;
}
/**
* @brief Throw item with actor.
* @param[in] self Pointer to the event structure that is currently executed
* @param[in] msg The netchannel message
* @sa EV_ACTOR_THROW
*/
void CL_ActorDoThrow (const eventRegister_t *self, dbuffer *msg)
{
vec3_t muzzle, v0;
int flags;
int dtime;
int objIdx;
weaponFireDefIndex_t weapFdsIdx;
fireDefIndex_t fdIdx;
/* read data */
NET_ReadFormat(msg, self->formatString, &dtime, &objIdx, &weapFdsIdx, &fdIdx, &flags, &muzzle, &v0);
/* get the fire def */
const objDef_t *obj = INVSH_GetItemByIDX(objIdx);
const fireDef_t *fd = FIRESH_GetFiredef(obj, weapFdsIdx, fdIdx);
/* add effect le (local entity) */
/** @todo add victim support for blood and hurt sounds */
LE_AddGrenade(fd, flags, muzzle, v0, dtime, nullptr);
/* start the sound */
if (fd->fireSound != nullptr && !(flags & SF_BOUNCED)) {
S_LoadAndPlaySample(fd->fireSound, muzzle, SOUND_ATTN_IDLE, SND_VOLUME_DEFAULT);
}
}
/**
* @brief Shoot with weapon but don't bother with animations - actor is hidden.
* @sa CL_ActorShoot
*/
void CL_ActorShootHidden (const eventRegister_t* self, dbuffer* msg)
{
int first;
int objIdx;
weaponFireDefIndex_t weapFdsIdx;
fireDefIndex_t fdIdx;
NET_ReadFormat(msg, self->formatString, &first, &objIdx, &weapFdsIdx, &fdIdx);
/* get the fire def */
const objDef_t* obj = INVSH_GetItemByIDX(objIdx);
const fireDef_t* fd = FIRESH_GetFiredef(obj, weapFdsIdx, fdIdx);
/* start the sound */
if ((first || !fd->soundOnce) && fd->fireSound != nullptr)
S_StartLocalSample(fd->fireSound, SND_VOLUME_WEAPONS);
}
/**
* @brief Decides if following events should be delayed. If the projectile has a speed value assigned, the
* delay is relative to the distance the projectile flies. There are other fire definition related options
* that might delay the execution of further events.
*/
int CL_ActorDoShootTime (const eventRegister_t* self, dbuffer* msg, eventTiming_t* eventTiming)
{
int flags, dummy;
int objIdx, surfaceFlags;
int weap_fds_idx, fd_idx;
shoot_types_t shootType;
vec3_t muzzle, impact;
int eventTime = eventTiming->shootTime;
/* read data */
NET_ReadFormat(msg, self->formatString, &dummy, &dummy, &dummy, &objIdx, &weap_fds_idx, &fd_idx, &shootType, &flags,
&surfaceFlags, &muzzle, &impact, &dummy);
const objDef_t* obj = INVSH_GetItemByIDX(objIdx);
const fireDef_t* fd = FIRESH_GetFiredef(obj, weap_fds_idx, fd_idx);
if (!(flags & SF_BOUNCED)) {
/* shooting */
if (fd->speed > 0.0 && !CL_OutsideMap(impact, UNIT_SIZE * 10)) {
eventTiming->impactTime = eventTiming->shootTime + 1000 * VectorDist(muzzle, impact) / fd->speed;
} else {
eventTiming->impactTime = eventTiming->shootTime;
}
if (!cls.isOurRound())
eventTiming->nextTime = CL_GetNextTime(self, eventTiming, eventTiming->impactTime + 1400);
else
eventTiming->nextTime = CL_GetNextTime(self, eventTiming, eventTiming->impactTime + 400);
if (fd->delayBetweenShots > 0.0)
eventTiming->shootTime += 1000 / fd->delayBetweenShots;
} else {
/* only a bounced shot */
eventTime = eventTiming->impactTime;
if (fd->speed > 0.0) {
eventTiming->impactTime += 1000 * VectorDist(muzzle, impact) / fd->speed;
eventTiming->nextTime = CL_GetNextTime(self, eventTiming, eventTiming->impactTime);
}
}
eventTiming->parsedDeath = false;
return eventTime;
}
/**
* @brief Shoot with weapon.
* @sa CL_ActorShoot
* @sa CL_ActorShootHidden
* @todo Improve detection of left- or right animation.
* @sa EV_ACTOR_SHOOT
*/
void CL_ActorDoShoot (const eventRegister_t* self, dbuffer* msg)
{
vec3_t muzzle, impact;
int flags, normal, shooterEntnum, victimEntnum;
int objIdx;
int first;
weaponFireDefIndex_t weapFdsIdx;
fireDefIndex_t fdIdx;
int surfaceFlags;
shoot_types_t shootType;
/* read data */
NET_ReadFormat(msg, self->formatString, &shooterEntnum, &victimEntnum, &first, &objIdx, &weapFdsIdx, &fdIdx, &shootType, &flags, &surfaceFlags, &muzzle, &impact, &normal);
le_t* leVictim;
if (victimEntnum != SKIP_LOCAL_ENTITY) {
leVictim = LE_Get(victimEntnum);
if (!leVictim)
LE_NotFoundError(victimEntnum);
} else {
leVictim = nullptr;
}
/* get shooter le */
le_t* leShooter = LE_Get(shooterEntnum);
/* get the fire def */
const objDef_t* obj = INVSH_GetItemByIDX(objIdx);
const fireDef_t* fd = FIRESH_GetFiredef(obj, weapFdsIdx, fdIdx);
CL_ActorGetMuzzle(leShooter, muzzle, shootType);
/* add effect le */
LE_AddProjectile(fd, flags, muzzle, impact, normal, leVictim);
/* start the sound */
if ((first || !fd->soundOnce) && fd->fireSound != nullptr && !(flags & SF_BOUNCED))
S_LoadAndPlaySample(fd->fireSound, muzzle, fd->fireAttenuation, SND_VOLUME_WEAPONS);
/* do actor related stuff */
if (!leShooter)
return; /* maybe hidden or inuse is false? */
if (!LE_IsActor(leShooter))
Com_Error(ERR_DROP, "Can't shoot, LE not an actor (type: %i)", leShooter->type);
/* no animations for hidden actors */
if (leShooter->type == ET_ACTORHIDDEN)
return;
if (LE_IsDead(leShooter)) {
Com_DPrintf(DEBUG_CLIENT, "Can't shoot, actor dead or stunned.\n");
return;
}
/* Animate - we have to check if it is right or left weapon usage. */
if (IS_SHOT_RIGHT(shootType)) {
R_AnimChange(&leShooter->as, leShooter->model1, LE_GetAnim("shoot", leShooter->right, leShooter->left, leShooter->state));
R_AnimAppend(&leShooter->as, leShooter->model1, LE_GetAnim("stand", leShooter->right, leShooter->left, leShooter->state));
} else if (IS_SHOT_LEFT(shootType)) {
R_AnimChange(&leShooter->as, leShooter->model1, LE_GetAnim("shoot", leShooter->left, leShooter->right, leShooter->state));
R_AnimAppend(&leShooter->as, leShooter->model1, LE_GetAnim("stand", leShooter->left, leShooter->right, leShooter->state));
} else if (IS_SHOT_HEADGEAR(shootType)) {
if (fd->irgoggles) {
leShooter->state |= RF_IRGOGGLESSHOT;
if (LE_IsSelected(leShooter))
refdef.rendererFlags |= RDF_IRGOGGLES;
}
} else {
/* no animation for headgear (yet) */
Com_Error(ERR_DROP, "CL_ActorDoShoot: Invalid shootType given (entnum: %i, shootType: %i).\n", shootType, shooterEntnum);
}
}
/**
* @brief Calculates the time the event should get executed. If two events return the same time,
* they are going to be executed in the order the were parsed.
* @param[in] eType The event type
* @param[in,out] msg The message buffer that can be modified to get the event time
* @param[in] dt Delta time in msec since the last event was parsed
*/
int CL_GetEventTime (const event_t eType, struct dbuffer *msg, const int dt)
{
const eventRegister_t *eventData = CL_GetEvent(eType);
#ifdef OLDEVENTTIME
/* the time the event should be executed. This value is used to sort the
* event chain to determine which event must be executed at first. This
* value also ensures, that the events are executed in the correct
* order. E.g. @c impactTime is used to delay some events in case the
* projectile needs some time to reach its target. */
int eventTime;
if (eType == EV_RESET) {
parsedDeath = qfalse;
nextTime = 0;
shootTime = 0;
impactTime = 0;
} else if (eType == EV_ACTOR_DIE)
parsedDeath = qtrue;
/* get event time */
if (nextTime < cl.time)
nextTime = cl.time;
if (impactTime < cl.time)
impactTime = cl.time;
if (eType == EV_ACTOR_DIE || eType == EV_MODEL_EXPLODE)
eventTime = impactTime;
else if (eType == EV_ACTOR_SHOOT || eType == EV_ACTOR_SHOOT_HIDDEN)
eventTime = shootTime;
else if (eType == EV_RESULTS)
eventTime = nextTime + 1400;
else
eventTime = nextTime;
if (eType == EV_ENT_APPEAR || eType == EV_INV_ADD || eType == EV_PARTICLE_APPEAR || eType == EV_PARTICLE_SPAWN) {
if (parsedDeath) { /* drop items after death (caused by impact) */
eventTime = impactTime + 400;
/* EV_INV_ADD messages are the last events sent after a death */
if (eType == EV_INV_ADD)
parsedDeath = qfalse;
} else if (impactTime > cl.time) { /* item thrown on the ground */
eventTime = impactTime + 75;
}
}
/* calculate time interval before the next event */
switch (eType) {
case EV_ACTOR_APPEAR:
if (cl.actTeam != cls.team)
nextTime += 600;
break;
case EV_INV_RELOAD:
/* let the reload sound play */
nextTime += 600;
break;
case EV_ACTOR_START_SHOOT:
nextTime += 300;
shootTime = nextTime;
break;
case EV_ACTOR_SHOOT_HIDDEN:
{
int first;
int objIdx;
const objDef_t *obj;
weaponFireDefIndex_t weapFdsIdx;
fireDefIndex_t fireDefIndex;
NET_ReadFormat(msg, eventData->formatString, &first, &objIdx, &weapFdsIdx, &fireDefIndex);
obj = INVSH_GetItemByIDX(objIdx);
if (first) {
nextTime += 500;
impactTime = shootTime = nextTime;
} else {
const fireDef_t *fd = FIRESH_GetFiredef(obj, weapFdsIdx, fireDefIndex);
/* impact right away - we don't see it at all
* bouncing is not needed here, too (we still don't see it) */
impactTime = shootTime;
nextTime = shootTime + 1400;
if (fd->delayBetweenShots > 0.0)
shootTime += 1000 / fd->delayBetweenShots;
}
parsedDeath = qfalse;
}
break;
case EV_ACTOR_MOVE:
{
le_t *le;
int number, i;
int time = 0;
int pathLength;
byte crouchingState;
pos3_t pos, oldPos;
number = NET_ReadShort(msg);
/* get le */
le = LE_Get(number);
if (!le)
LE_NotFoundError(number);
pathLength = NET_ReadByte(msg);
/* Also skip the final position */
NET_ReadByte(msg);
NET_ReadByte(msg);
NET_ReadByte(msg);
VectorCopy(le->pos, pos);
crouchingState = LE_IsCrouched(le) ? 1 : 0;
for (i = 0; i < pathLength; i++) {
const dvec_t dvec = NET_ReadShort(msg);
const byte dir = getDVdir(dvec);
VectorCopy(pos, oldPos);
PosAddDV(pos, crouchingState, dvec);
time += LE_ActorGetStepTime(le, pos, oldPos, dir, NET_ReadShort(msg));
NET_ReadShort(msg);
}
nextTime += time + 400;
}
break;
case EV_ACTOR_SHOOT:
{
const fireDef_t *fd;
int flags, dummy;
int objIdx, surfaceFlags;
objDef_t *obj;
int weap_fds_idx, fd_idx;
shoot_types_t shootType;
vec3_t muzzle, impact;
/* read data */
NET_ReadFormat(msg, eventData->formatString, &dummy, &dummy, &dummy, &objIdx, &weap_fds_idx, &fd_idx, &shootType, &flags, &surfaceFlags, &muzzle, &impact, &dummy);
obj = INVSH_GetItemByIDX(objIdx);
fd = FIRESH_GetFiredef(obj, weap_fds_idx, fd_idx);
if (!(flags & SF_BOUNCED)) {
/* shooting */
if (fd->speed > 0.0 && !CL_OutsideMap(impact, UNIT_SIZE * 10)) {
impactTime = shootTime + 1000 * VectorDist(muzzle, impact) / fd->speed;
} else {
impactTime = shootTime;
}
if (cl.actTeam != cls.team)
nextTime = impactTime + 1400;
else
nextTime = impactTime + 400;
if (fd->delayBetweenShots > 0.0)
shootTime += 1000 / fd->delayBetweenShots;
} else {
/* only a bounced shot */
eventTime = impactTime;
if (fd->speed > 0.0) {
impactTime += 1000 * VectorDist(muzzle, impact) / fd->speed;
nextTime = impactTime;
}
}
parsedDeath = qfalse;
}
break;
case EV_ACTOR_THROW:
nextTime += NET_ReadShort(msg);
impactTime = shootTime = nextTime;
parsedDeath = qfalse;
break;
default:
break;
}
Com_DPrintf(DEBUG_EVENTSYS, "%s => eventTime: %i, nextTime: %i, impactTime: %i, shootTime: %i\n",
eventData->name, eventTime, nextTime, impactTime, shootTime);
return eventTime;
#else
if (!eventData->timeCallback)
return cl.time;
return eventData->timeCallback(eventData, msg, dt);
#endif
}