diff options
Diffstat (limited to 'src/parsec/net_rmev.cpp')
| -rw-r--r-- | src/parsec/net_rmev.cpp | 1284 |
1 files changed, 1284 insertions, 0 deletions
diff --git a/src/parsec/net_rmev.cpp b/src/parsec/net_rmev.cpp new file mode 100644 index 0000000..db18794 --- /dev/null +++ b/src/parsec/net_rmev.cpp @@ -0,0 +1,1284 @@ +/* + * PARSEC - Remote Events + * + * $Author: uberlinuxguy $ - $Date: 2004/09/26 03:43:40 $ + * + * Orginally written by: + * Copyright (c) Clemens Beer <cbx@parsec.org> 2001-2002 + * Copyright (c) Markus Hadwiger <msh@parsec.org> 1996-2000 + * + * 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 + */ + +// C library +#include <stddef.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +// compilation flags/debug support +#include "config.h" +#include "linkinfo.h" +#include "debug.h" + +// general definitions +#include "general.h" +#include "objstruc.h" +#include "od_class.h" + +// global externals +#include "globals.h" + +// subsystem headers +#include "aud_defs.h" +#include "net_defs.h" +#include "sys_defs.h" + +// network code config +#include "net_conf.h" + +// local module header +#include "net_rmev.h" + +// proprietary module headers +#include "con_aux.h" +#include "con_say.h" +#include "h_supp.h" +#include "net_game.h" +#include "obj_creg.h" +#include "obj_ctrl.h" +#include "obj_xtra.h" +#include "g_sfx.h" +#include "g_wfx.h" +#include "g_emp.h" +#include "g_swarm.h" + + + +// string scratchpad +#define PASTE_STR_LEN 1023 +static char paste_str[ PASTE_STR_LEN + 1 ]; + +// external flag +int name_change_notification = TRUE; + + + +// table of remote event sizes ------------------------------------------------ +// +static size_t re_sizes[] = { + + sizeof( RE_Header ), + sizeof( RE_Header ), + sizeof( RE_CreateObject ), + sizeof( RE_CreateLaser ), + sizeof( RE_CreateMissile ), + sizeof( RE_CreateExtra ), + sizeof( RE_KillObject ), + sizeof( RE_SendText ), + sizeof( RE_PlayerName ), + sizeof( RE_ParticleObject ), + sizeof( RE_PlayerList ), + sizeof( RE_ConnectQueue ), + sizeof( RE_WeaponState ), + sizeof( RE_StateSync ), + sizeof( RE_CreateSwarm ), + sizeof( RE_CreateEmp ), + sizeof( RE_OwnerSection ), + sizeof( RE_PlayerStatus ), + sizeof( RE_PlayerAndShipStatus ), + sizeof( RE_KillStats ), + sizeof( RE_GameState ), + sizeof( RE_CommandInfo ), + sizeof( RE_ClientInfo ), + sizeof( RE_CreateExtra2 ), + sizeof( RE_IPv4ServerInfo ), + sizeof( RE_ServerLinkInfo ), + sizeof( RE_MapObject ), + sizeof( RE_Stargate ), + sizeof( RE_CreateMine ), +}; + + +// check if enough space in RE_List for specified remote event ---------------- +// +int NET_RmEvAllowed( int re_type ) +{ + if ( NetConnected != NETWORK_GAME_ON ) + return TRUE; + + ASSERT( re_type > RE_DELETED ); + ASSERT( re_type < RE_NUMEVENTS ); + ASSERT( re_type != RE_SENDTEXT ); + ASSERT( re_type != RE_PLAYERLIST ); + ASSERT( re_type != RE_CONNECTQUEUE ); + ASSERT( re_type != RE_OWNERSECTION ); + + if ( NetConnected && ( (size_t)RE_List_Avail < re_sizes[ re_type ] ) ) + return FALSE; + + //NOTE: + // if the connection is down the check need not be performed since + // all insertion functions will skip the insertion in that case. + + return TRUE; +} + + +// determine size of remote event --------------------------------------------- +// +size_t NET_RmEvGetSize( RE_Header *relist ) +{ + ASSERT( relist != NULL ); + byte retype = relist->RE_Type; + + // use stored size for remote-events of variable size + if ( ( retype == RE_DELETED ) || ( retype == RE_SENDTEXT ) || ( retype == RE_COMMANDINFO ) ) { + ASSERT( relist->RE_BlockSize != RE_BLOCKSIZE_INVALID ); + return relist->RE_BlockSize; + } + + ASSERT( retype > RE_DELETED ); + ASSERT( retype < RE_NUMEVENTS ); + + return re_sizes[ retype ]; +} + + +// insert playername into RE_List --------------------------------------------- +// +int NET_RmEvPlayerName( const char *name ) +{ + //NOTE: + // calling NET_RmEvAllowed() is NOT mandatory + // before calling this function. + + ASSERT( name != NULL ); + + if ( NetConnected == NETWORK_GAME_ON ) { + + // this is no fault condition + if ( (size_t)RE_List_Avail < sizeof( RE_PlayerName ) ) + return 0; + + RE_PlayerName *re_playername = (RE_PlayerName *) RE_List_CurPos; + re_playername->RE_Type = RE_PLAYERNAME; + re_playername->RE_BlockSize = sizeof( RE_PlayerName ); + CopyRemoteName( re_playername->PlayerName, name ); + + re_playername++; + re_playername->RE_Type = RE_EMPTY; + + RE_List_CurPos = (char *) re_playername; + RE_List_Avail -= sizeof( RE_PlayerName ); + + // this has to be done here although it is also done + // by NET_UTIL::NET_SetPlayerName() later on, because + // NET_ServerUpdateName() already needs the new name. + strcpy( Player_Name[ LocalPlayerId ], name ); + + // update name on server if playing with a server-based protocol + if ( !NETs_UpdateName() ) { + + // restore old name if name change on server + // not possible or forbidden. PlayerName has + // not been altered by NETs_UpdateName()! + strcpy( Player_Name[ LocalPlayerId ], LocalPlayerName ); + return 0; + } + } + + return 1; +} + + +// insert text to send into RE_List ------------------------------------------- +// +int NET_RmEvSendText( const char *text ) +{ + //NOTE: + // calling NET_RmEvAllowed() is NOT mandatory + // before calling this function. + + //NOTE: + // the maximum transmitted text-length is 252. + // (excluding the terminating zero-byte.) + + ASSERT( text != NULL ); + if(strlen(text) == 0) + return 1; + if ( NetConnected == NETWORK_GAME_ON ) { + + // make copy of text + strncpy( paste_str, LocalPlayerName, MAX_PLAYER_NAME); + strncat( paste_str," ",1); + strncat( paste_str, text, (PASTE_STR_LEN - MAX_PLAYER_NAME - 1)); + paste_str[ PASTE_STR_LEN ] = 0; + + int textlen = strlen( text ) + strlen(LocalPlayerName) + 1; //Name + space(1) + text + int blocksiz = sizeof( RE_SendText ) + textlen; + // terminating zero-byte is included in sizeof( RE_SendText ) + + // this is no fault condition + if ( RE_List_Avail < blocksiz ) + return 0; + + // cut text if blocksize doesn't fit in one byte + ASSERT( blocksiz > 2 ); + if ( blocksiz > 255 ) { + blocksiz = 255; + paste_str[ 255 - sizeof( RE_SendText ) ] = 0; + } + + RE_SendText *re_sendtext = (RE_SendText *) RE_List_CurPos; + re_sendtext->RE_Type = RE_SENDTEXT; + re_sendtext->RE_BlockSize = blocksiz; + strcpy( re_sendtext->TextStart, paste_str ); + + re_sendtext = (RE_SendText *) ( (char *)re_sendtext + blocksiz ); + re_sendtext->RE_Type = RE_EMPTY; + RE_List_CurPos = (char *) re_sendtext; + RE_List_Avail -= blocksiz; + } + + return 1; +} + + +// insert generic object into RE_List ----------------------------------------- +// +int NET_RmEvObject( const GenObject *objpo ) +{ + //NOTE: + // calling NET_RmEvAllowed() is mandatory + // before calling this function. + + ASSERT( objpo != NULL ); + + if ( NetConnected == NETWORK_GAME_ON ) { + + if ( (size_t)RE_List_Avail < sizeof( RE_CreateObject ) ) { + ASSERT( 0 ); + return 0; + } + + RE_CreateObject *re_createobject = (RE_CreateObject *) RE_List_CurPos; + re_createobject->RE_Type = RE_CREATEOBJECT; + re_createobject->RE_BlockSize = sizeof( RE_CreateObject ); + re_createobject->ObjectClass = objpo->ObjectClass; + re_createobject->HostObjId = objpo->HostObjNumber; + memcpy( &re_createobject->ObjPosition, &objpo->ObjPosition, sizeof( Xmatrx ) ); + re_createobject->Flags = 0x00000000; + + re_createobject++; + re_createobject->RE_Type = RE_EMPTY; + + RE_List_CurPos = (char *) re_createobject; + RE_List_Avail -= sizeof( RE_CreateObject ); + } + + return 1; +} + + +// insert laser into RE_List -------------------------------------------------- +// +int NET_RmEvLaser( const LaserObject *laserpo ) +{ + //NOTE: + // calling NET_RmEvAllowed() is mandatory + // before calling this function. + + ASSERT( laserpo != NULL ); + + if ( NetConnected == NETWORK_GAME_ON ) { + + if ( (size_t)RE_List_Avail < sizeof( RE_CreateLaser ) ) { + ASSERT( 0 ); + return 0; + } + + RE_CreateLaser *re_createlaser = (RE_CreateLaser *) RE_List_CurPos; + re_createlaser->RE_Type = RE_CREATELASER; + re_createlaser->RE_BlockSize = sizeof( RE_CreateLaser ); + re_createlaser->ObjectClass = laserpo->ObjectClass; + re_createlaser->HostObjId = laserpo->HostObjNumber; + memcpy( &re_createlaser->ObjPosition, &laserpo->ObjPosition, sizeof( Xmatrx ) ); + re_createlaser->DirectionVec = laserpo->DirectionVec; + + re_createlaser++; + re_createlaser->RE_Type = RE_EMPTY; + + RE_List_CurPos = (char *) re_createlaser; + RE_List_Avail -= sizeof( RE_CreateLaser ); + } + + return 1; +} + + +// insert missile into RE_List ------------------------------------------------ +// +int NET_RmEvMissile( const MissileObject *missilepo, dword targetobjid ) +{ + //NOTE: + // calling NET_RmEvAllowed() is mandatory + // before calling this function. + + ASSERT( missilepo != NULL ); + + if ( NetConnected == NETWORK_GAME_ON ) { + + if ( (size_t)RE_List_Avail < sizeof( RE_CreateMissile ) ) { + ASSERT( 0 ); + return 0; + } + + RE_CreateMissile *re_createmissl = (RE_CreateMissile *) RE_List_CurPos; + re_createmissl->RE_Type = RE_CREATEMISSILE; + re_createmissl->RE_BlockSize = sizeof( RE_CreateMissile ); + re_createmissl->ObjectClass = missilepo->ObjectClass; + re_createmissl->HostObjId = missilepo->HostObjNumber; + re_createmissl->TargetHostObjId = targetobjid; + memcpy( &re_createmissl->ObjPosition, &missilepo->ObjPosition, sizeof( Xmatrx ) ); + re_createmissl->DirectionVec = missilepo->DirectionVec; + + re_createmissl++; + re_createmissl->RE_Type = RE_EMPTY; + + RE_List_CurPos = (char *) re_createmissl; + RE_List_Avail -= sizeof( RE_CreateMissile ); + } + + return 1; +} + +// insert extra into RE_List -------------------------------------------------- +// +int NET_RmEvMine( const ExtraObject *extrapo ) +{ + //NOTE: + // calling NET_RmEvAllowed() is mandatory + // before calling this function. + + ASSERT( extrapo != NULL ); + + // DSEXC( return 1 ); + + if ( NetConnected == NETWORK_GAME_ON ) { + + if ( (size_t)RE_List_Avail < sizeof( RE_CreateExtra ) ) { + ASSERT( 0 ); + return 0; + } + + int extraindex = ObjClassExtraIndex[ extrapo->ObjectClass ]; + ASSERT( extraindex != EXTRAINDEX_NO_EXTRA ); + + RE_CreateExtra *re_createextra = (RE_CreateExtra *) RE_List_CurPos; + re_createextra->RE_Type = RE_CREATEMINE; + re_createextra->RE_BlockSize = sizeof( RE_CreateExtra ); + re_createextra->ExtraIndex = extraindex; + re_createextra->HostObjId = extrapo->HostObjNumber; + memcpy( &re_createextra->ObjPosition, &extrapo->ObjPosition, sizeof( Xmatrx ) ); + + re_createextra++; + re_createextra->RE_Type = RE_EMPTY; + + RE_List_CurPos = (char *) re_createextra; + RE_List_Avail -= sizeof( RE_CreateExtra ); + } + + return 1; +} + +// insert extra into RE_List -------------------------------------------------- +// +int NET_RmEvExtra( const ExtraObject *extrapo ) +{ + //NOTE: + // calling NET_RmEvAllowed() is mandatory + // before calling this function. + + ASSERT( extrapo != NULL ); + +// DSEXC( return 1 ); + + if ( NetConnected == NETWORK_GAME_ON ) { + + if ( (size_t)RE_List_Avail < sizeof( RE_CreateExtra ) ) { + ASSERT( 0 ); + return 0; + } + + int extraindex = ObjClassExtraIndex[ extrapo->ObjectClass ]; + ASSERT( extraindex != EXTRAINDEX_NO_EXTRA ); + + RE_CreateExtra *re_createextra = (RE_CreateExtra *) RE_List_CurPos; + re_createextra->RE_Type = RE_CREATEEXTRA; + re_createextra->RE_BlockSize = sizeof( RE_CreateExtra ); + re_createextra->ExtraIndex = extraindex; + re_createextra->HostObjId = extrapo->HostObjNumber; + memcpy( &re_createextra->ObjPosition, &extrapo->ObjPosition, sizeof( Xmatrx ) ); + + re_createextra++; + re_createextra->RE_Type = RE_EMPTY; + + RE_List_CurPos = (char *) re_createextra; + RE_List_Avail -= sizeof( RE_CreateExtra ); + } + + return 1; +} + +// insert particle object into RE_List ---------------------------------------- +// +int NET_RmEvParticleObject( int type, const Vertex3& origin ) +{ + //NOTE: + // calling NET_RmEvAllowed() is mandatory + // before calling this function. + +// DSEXC( return 1 ); + + if ( NetConnected == NETWORK_GAME_ON ) { + + if ( (size_t)RE_List_Avail < sizeof( RE_ParticleObject ) ) { + ASSERT( 0 ); + return 0; + } + + RE_ParticleObject *re_particleobject = (RE_ParticleObject *) RE_List_CurPos; + re_particleobject->RE_Type = RE_PARTICLEOBJECT; + re_particleobject->RE_BlockSize = sizeof( RE_ParticleObject ); + re_particleobject->ObjectType = type; + re_particleobject->Origin = origin; + + re_particleobject++; + re_particleobject->RE_Type = RE_EMPTY; + + RE_List_CurPos = (char *) re_particleobject; + RE_List_Avail -= sizeof( RE_ParticleObject ); + } + + return 1; +} + + +// insert weapon state update into RE_List ------------------------------------ +// +int NET_RmEvWeaponState( dword weapon, byte state, int energy, dword specials ) +{ + //NOTE: + // calling NET_RmEvAllowed() is mandatory + // before calling this function. + + if ( NetConnected == NETWORK_GAME_ON ) { + + if ( (size_t)RE_List_Avail < sizeof( RE_WeaponState ) ) { + ASSERT( 0 ); + return 0; + } + + RE_WeaponState *re_weaponstate = (RE_WeaponState *) RE_List_CurPos; + re_weaponstate->RE_Type = RE_WEAPONSTATE; + re_weaponstate->RE_BlockSize = sizeof( RE_WeaponState ); + re_weaponstate->State = state; + re_weaponstate->WeaponMask = weapon; + // re_weaponstate->Specials = specials; //CrazySpence changed this, this comment is so he knows to change it back if it bites him in the ass + re_weaponstate->CurEnergy = energy; + re_weaponstate->SenderId = LocalPlayerId; + re_weaponstate++; + re_weaponstate->RE_Type = RE_EMPTY; + + RE_List_CurPos = (char *) re_weaponstate; + RE_List_Avail -= sizeof( RE_WeaponState ); + } + + return 1; +} + + +// insert state sync into RE_List --------------------------------------------- +// +int NET_RmEvStateSync( dword statekey, dword stateval ) +{ + //NOTE: + // calling NET_RmEvAllowed() is mandatory + // before calling this function. + + if ( NetConnected == NETWORK_GAME_ON ) { + + if ( (size_t)RE_List_Avail < sizeof( RE_StateSync ) ) { + ASSERT( 0 ); + return 0; + } + + RE_StateSync *re_statesync = (RE_StateSync *) RE_List_CurPos; + re_statesync->RE_Type = RE_STATESYNC; + re_statesync->RE_BlockSize = sizeof( RE_StateSync ); + re_statesync->StateKey = (word)statekey; + re_statesync->StateValue = stateval; + + re_statesync++; + re_statesync->RE_Type = RE_EMPTY; + + RE_List_CurPos = (char *) re_statesync; + RE_List_Avail -= sizeof( RE_StateSync ); + } + + return 1; +} + + +// insert swarm into RE_List -------------------------------------------------- +// +int NET_RmEvCreateSwarm( Vertex3 *origin, dword targetobjid, dword seed ) +{ + //NOTE: + // calling NET_RmEvAllowed() is mandatory + // before calling this function. + + if ( NetConnected == NETWORK_GAME_ON ) { + + if ( (size_t)RE_List_Avail < sizeof( RE_CreateSwarm ) ) { + ASSERT( 0 ); + return 0; + } + + RE_CreateSwarm *re_createswarm = (RE_CreateSwarm *) RE_List_CurPos; + re_createswarm->RE_Type = RE_CREATESWARM; + re_createswarm->RE_BlockSize = sizeof( RE_CreateSwarm ); + re_createswarm->Origin = *origin; + re_createswarm->TargetHostObjId = targetobjid; + re_createswarm->RandSeed = seed; + re_createswarm->SenderId = LocalPlayerId; + re_createswarm++; + re_createswarm->RE_Type = RE_EMPTY; + + RE_List_CurPos = (char *) re_createswarm; + RE_List_Avail -= sizeof( RE_CreateSwarm ); + } + + return 1; +} + + +// insert emp into RE_List ---------------------------------------------------- +// +int NET_RmEvCreateEmp( int upgradelevel ) +{ + //NOTE: + // calling NET_RmEvAllowed() is mandatory + // before calling this function. + + if ( NetConnected == NETWORK_GAME_ON ) { + + if ( (size_t)RE_List_Avail < sizeof( RE_CreateEmp ) ) { + ASSERT( 0 ); + return 0; + } + + RE_CreateEmp *re_createemp = (RE_CreateEmp *) RE_List_CurPos; + re_createemp->RE_Type = RE_CREATEEMP; + re_createemp->RE_BlockSize = sizeof( RE_CreateEmp ); + re_createemp->Upgradelevel = upgradelevel; + re_createemp->SenderId = LocalPlayerId; + + re_createemp++; + re_createemp->RE_Type = RE_EMPTY; + + RE_List_CurPos = (char *) re_createemp; + RE_List_Avail -= sizeof( RE_CreateEmp ); + } + + return 1; +} + + +// insert object kill event into RE_List -------------------------------------- +// +int NET_RmEvKillObject( dword objid, byte listno ) +{ + //NOTE: + // calling NET_RmEvAllowed() is NOT mandatory + // before calling this function. + +#ifdef NO_PROJECTILE_KILL_MESSAGES + + // for projectiles depend on local client lifetime expiration + if ( ( listno == LASER_LIST ) || ( listno == MISSL_LIST ) ) { + return 1; + } + ASSERT( listno == EXTRA_LIST ); + +#endif + +#ifdef SEND_KILL_MESSAGES + + if ( NetConnected == NETWORK_GAME_ON ) { + + if ( (size_t)RE_List_Avail < sizeof( RE_KillObject ) ) + return 0; + + RE_KillObject *re_killobject = (RE_KillObject *) RE_List_CurPos; + re_killobject->RE_Type = RE_KILLOBJECT; + re_killobject->RE_BlockSize = sizeof( RE_KillObject ); + re_killobject->HostObjId = objid; + re_killobject->ListId = listno; + + re_killobject++; + re_killobject->RE_Type = RE_EMPTY; + + RE_List_CurPos = (char *) re_killobject; + RE_List_Avail -= sizeof( RE_KillObject ); + } + +#endif + + return 1; +} + +// insert RE_PlayerStatus event into RE_List ---------------------------------- +// +RE_PlayerStatus* NET_RmEvPlayerStatus( byte last_unjoin_flag ) +{ + //NOTE: + // calling NET_RmEvAllowed() is mandatory + // before calling this function. + + if ( NetConnected == NETWORK_GAME_ON ) { + + if ( (size_t)RE_List_Avail < sizeof( RE_PlayerStatus ) ) { + ASSERT( 0 ); + return NULL; + } + + RE_PlayerStatus* re_playerstatus = (RE_PlayerStatus*) RE_List_CurPos; + re_playerstatus->RE_Type = RE_PLAYERSTATUS; + re_playerstatus->RE_BlockSize = sizeof( RE_PlayerStatus ); + + re_playerstatus->senderid = LocalPlayerId; + re_playerstatus->objectindex = ObjClassShipIndex[ MyShip->ObjectClass ]; + + // set desired player status + re_playerstatus->player_status = Player_Status[ LocalPlayerId ]; + + //FIXME: only send "normal" unjoin to server + // send last unjoin to server ( include killer ) + if ( Player_Status[ LocalPlayerId ] == PLAYER_CONNECTED ) { + + // store reason for last unjoin + re_playerstatus->params[ 0 ] = last_unjoin_flag; + + // enable remote player to determine who killed us if ( param1 == SHIP_DOWNED ) + if ( last_unjoin_flag == SHIP_DOWNED ) { + ASSERT( ( CurKiller >= KILLERID_UNKNOWN ) && ( CurKiller < MAX_NET_PROTO_PLAYERS + KILLERID_BIAS ) ); + ASSERT( ( CurKiller >= 0 ) && ( CurKiller < 128 ) ); + re_playerstatus->params[ 3 ] = CurKiller; + } + } + + // store the refframe for serverside movement checks + re_playerstatus->RefFrame = SYSs_GetRefFrameCount(); + + RE_PlayerStatus* re = re_playerstatus; + + re_playerstatus++; + re_playerstatus->RE_Type = RE_EMPTY; + + RE_List_CurPos = (char *) re_playerstatus; + RE_List_Avail -= sizeof( RE_PlayerStatus ); + + // return the remote event added + return re; + } + + return NULL; +} + + +// insert PlayerAndShipStatus event into RE_List ------------------------------ +// +RE_PlayerAndShipStatus* NET_RmEvPlayerAndShipStatus ( byte last_unjoin_flag ) +{ + //NOTE: + // calling NET_RmEvAllowed() is mandatory + // before calling this function. + + if ( NetConnected == NETWORK_GAME_ON ) { + + if ( (size_t)RE_List_Avail < sizeof( RE_PlayerAndShipStatus ) ) { + ASSERT( 0 ); + return NULL; + } + + RE_PlayerAndShipStatus* re_pas_status = (RE_PlayerAndShipStatus*) RE_List_CurPos; + re_pas_status->RE_Type = RE_PLAYERANDSHIPSTATUS; + re_pas_status->RE_BlockSize = sizeof( RE_PlayerAndShipStatus ); + + re_pas_status->senderid = LocalPlayerId; + re_pas_status->objectindex = ObjClassShipIndex[ MyShip->ObjectClass ]; + + // set remote player's damage and speed from ship-object structure + re_pas_status->CurDamage = MyShip->CurDamage; + re_pas_status->CurShield = MyShip->CurShield; + re_pas_status->CurSpeed = MyShip->CurSpeed; + + // store current position of player + memcpy( &re_pas_status->ObjPosition, &MyShip->ObjPosition, sizeof( Xmatrx ) ); + + // store speeds for interpolation + re_pas_status->CurYaw = CurYaw; + re_pas_status->CurPitch = CurPitch; + re_pas_status->CurRoll = CurRoll; + re_pas_status->CurSlideHorz = CurSlideHorz; + re_pas_status->CurSlideVert = CurSlideVert; + + // set desired player status + re_pas_status->player_status = Player_Status[ LocalPlayerId ]; + + //FIXME: only send "normal" unjoin to server + // send last unjoin to server ( include killer ) + if ( Player_Status[ LocalPlayerId ] == PLAYER_CONNECTED ) { + + // store reason for last unjoin + re_pas_status->params[ 0 ] = last_unjoin_flag; + + // enable remote player to determine who killed us if ( param1 == SHIP_DOWNED ) + if ( last_unjoin_flag == SHIP_DOWNED ) { + ASSERT( ( CurKiller >= KILLERID_UNKNOWN ) && ( CurKiller < MAX_NET_PROTO_PLAYERS + KILLERID_BIAS ) ); + ASSERT( ( CurKiller >= 0 ) && ( CurKiller < 128 ) ); + re_pas_status->params[ 3 ] = CurKiller; + } + } + + // store the refframe for serverside movement checks + re_pas_status->RefFrame = SYSs_GetRefFrameCount(); + + RE_PlayerAndShipStatus* re = re_pas_status; + + re_pas_status++; + re_pas_status->RE_Type = RE_EMPTY; + + RE_List_CurPos = (char *) re_pas_status; + RE_List_Avail -= sizeof( RE_PlayerAndShipStatus ); + + // return the remote event added + return re; + } + + return NULL; +} + + +// execute received remote event: create object ------------------------------- +// +void NET_ExecRmEvCreateObject( RE_Header *rmev, int ownerid ) +{ + ASSERT( rmev != NULL ); + ASSERT( rmev->RE_Type == RE_CREATEOBJECT ); + ASSERT( ( ownerid >= 0 ) && ( ownerid < MAX_NET_PROTO_PLAYERS ) ); + + RE_CreateObject *re_co = (RE_CreateObject *) rmev; + + GenObject *objpo = CreateObject( re_co->ObjectClass, re_co->ObjPosition ); + ASSERT( objpo != NULL ); + objpo->HostObjNumber = re_co->HostObjId; + //TODO: + // re_co->Flags + + RMEVTXT( MSGOUT( "--executing RE_CREATEOBJECT: %d (%d).", re_co->ObjectClass, ownerid ); ); +} + + +// execute received remote event: create laser -------------------------------- +// +void NET_ExecRmEvCreateLaser( RE_Header *rmev, int ownerid ) +{ + // get owner from RE + if ( NET_ProtocolGMSV() ) { + ownerid = GetOwnerFromHostOjbNumber( ( (RE_CreateLaser*)rmev )->HostObjId ); + } + + ASSERT( rmev != NULL ); + ASSERT( rmev->RE_Type == RE_CREATELASER ); + ASSERT( ( ownerid >= 0 ) && ( ownerid < MAX_NET_PROTO_PLAYERS ) ); + ASSERT( (dword)ownerid == GetOwnerFromHostOjbNumber( ( (RE_CreateLaser*)rmev )->HostObjId ) ); + + RE_CreateLaser *re_cl = (RE_CreateLaser *) rmev; + + LaserObject *laserpo = (LaserObject *) CreateObject( re_cl->ObjectClass, re_cl->ObjPosition ); + ASSERT( laserpo != NULL ); + laserpo->HostObjNumber = re_cl->HostObjId; + laserpo->DirectionVec = re_cl->DirectionVec; + laserpo->Owner = ownerid; + + AUD_Laser( laserpo ); + + RMEVTXT( MSGOUT( "--executing RE_CREATELASER: %d (%d).", re_cl->ObjectClass, ownerid ); ); +} + + +// execute received remote event: create missile ------------------------------ +// +void NET_ExecRmEvCreateMissile( RE_Header *rmev, int ownerid ) +{ + // get owner from RE + if ( NET_ProtocolGMSV() ) { + ownerid = GetOwnerFromHostOjbNumber( ( (RE_CreateMissile*)rmev )->HostObjId ); + } + + ASSERT( rmev != NULL ); + ASSERT( rmev->RE_Type == RE_CREATEMISSILE ); + ASSERT( ( ownerid >= 0 ) && ( ownerid < MAX_NET_PROTO_PLAYERS ) ); + + RE_CreateMissile *re_cm = (RE_CreateMissile *) rmev; + + MissileObject *missilepo = (MissileObject *) CreateObject( re_cm->ObjectClass, re_cm->ObjPosition ); + ASSERT( missilepo != NULL ); + missilepo->HostObjNumber = re_cm->HostObjId; + missilepo->DirectionVec = re_cm->DirectionVec; + missilepo->Owner = ownerid; + + if ( re_cm->ObjectClass == GUIDE_CLASS_1 ) { + TargetMissileObject *targetmisspo = (TargetMissileObject *) missilepo; + targetmisspo->TargetObjNumber = re_cm->TargetHostObjId; + } + + AUD_Missile( missilepo ); + + RMEVTXT( MSGOUT( "--executing RE_CREATEMISSILE: %d (%d).", re_cm->ObjectClass, ownerid ); ); +} + + +// execute received remote event: create particle object ---------------------- +// +void NET_ExecRmEvParticleObject( RE_Header *rmev, int ownerid ) +{ + ASSERT( rmev != NULL ); + ASSERT( rmev->RE_Type == RE_PARTICLEOBJECT ); + ASSERT( ( ownerid >= 0 ) && ( ownerid < MAX_NET_PROTO_PLAYERS ) ); + + RE_ParticleObject *re_po = (RE_ParticleObject *) rmev; + + switch ( re_po->ObjectType ) { + + case POBJ_ENERGYFIELD: + SFX_CreateEnergyField( re_po->Origin ); + break; + + case POBJ_MEGASHIELD: + SFX_RemoteEnableInvulnerabilityShield( ownerid ); + break; + + case POBJ_SPREADFIRE: + WFX_RemoteShootSpreadfire( ownerid ); + break; + } + + RMEVTXT( MSGOUT( "--executing RE_PARTICLEOBJECT: %d (%d).", re_po->ObjectType, ownerid ); ); +} + + +// execute received remote event: create extra -------------------------------- +// +void NET_ExecRmEvCreateExtra( RE_Header *rmev, int ownerid ) +{ + // get owner from RE + if ( NET_ProtocolGMSV() ) { + ownerid = GetOwnerFromHostOjbNumber( ( (RE_CreateExtra*)rmev )->HostObjId ); + } + + ASSERT( rmev != NULL ); + ASSERT( rmev->RE_Type == RE_CREATEEXTRA ); + ASSERT( ( ( ownerid >= 0 ) && ( ownerid < MAX_NET_PROTO_PLAYERS ) ) || ( ownerid == PLAYERID_SERVER ) ); + + RE_CreateExtra *re_ce = (RE_CreateExtra *) rmev; + + // resolve to class id + ASSERT( re_ce->ExtraIndex < NumExtraClasses ); + dword classid = ExtraClasses[ re_ce->ExtraIndex ]; + + // create object if extra available on this client + if ( classid != CLASS_ID_INVALID ) { + + ExtraObject *extrapo = (ExtraObject *) CreateObject( classid, re_ce->ObjPosition ); + ASSERT( extrapo != NULL ); + extrapo->HostObjNumber = re_ce->HostObjId; + if ( extrapo->ObjectType == MINE1TYPE ) { + ASSERT( ownerid != PLAYERID_SERVER ); + ((MineObject*)extrapo)->Owner = ownerid; + AUD_Mine( extrapo ); + } else { + OBJ_FillExtraMemberVars( extrapo ); + } + } + + RMEVTXT( MSGOUT( "--executing RE_CREATEEXTRA: %d (%d).", classid, ownerid ); ); +} + + +// execute received remote event: kill object --------------------------------- +// +void NET_ExecRmEvKillObject( RE_Header *rmev ) +{ + ASSERT( rmev != NULL ); + ASSERT( rmev->RE_Type == RE_KILLOBJECT ); + + RE_KillObject *re_ko = (RE_KillObject *) rmev; + + GenObject *objlistpo = NULL; + switch ( re_ko->ListId ) { + case LASER_LIST: + objlistpo = LaserObjects; + break; + case MISSL_LIST: + objlistpo = MisslObjects; + break; + case EXTRA_LIST: + objlistpo = ExtraObjects; + break; + case CUSTM_LIST: + objlistpo = CustmObjects; + break; + default: + ASSERT( FALSE ); + break; + } + if ( objlistpo != NULL ) { + KillSpecificHostObject( re_ko->HostObjId, objlistpo ); + } + + RMEVTXT( MSGOUT( "--executing RE_KILLOBJECT: obj %d, list %d.", re_ko->HostObjId, re_ko->ListId ); ); +} + + +// execute received remote event: send text ----------------------------------- +// +void NET_ExecRmEvSendText( RE_Header *rmev, int ownerid ) +{ + + ASSERT( rmev != NULL ); + ASSERT( rmev->RE_Type == RE_SENDTEXT ); + ASSERT( ( ownerid >= 0 ) && ( ownerid < MAX_NET_PROTO_PLAYERS ) ); + + RE_SendText *re_st = (RE_SendText *) rmev; + + char *s, *name, *brk; + s = strtok_r(re_st->TextStart," ",&brk); + name = s; + s = strtok_r(NULL,"\0",&brk); + char *textpo = s; + size_t textlen = strlen( textpo ); + if ( textlen <= ( MAX_MESSAGELEN - strlen( name ) - 3 ) ) { + ASSERT( ( 3 + strlen( name ) + textlen ) <= PASTE_STR_LEN ); + sprintf( paste_str, "-%s- %s", + name, textpo ); + ShowMessage( paste_str ); + } + ShowSentText( name, textpo, TALK_PUBLIC ); + + RMEVTXT( MSGOUT( "--executing RE_SENDTEXT: \"%s\" (%d).", textpo, ownerid ); ); +} + + +// execute received remote event: player name --------------------------------- +// +void NET_ExecRmEvPlayerName( RE_Header *rmev, int ownerid ) +{ + ASSERT( rmev != NULL ); + ASSERT( rmev->RE_Type == RE_PLAYERNAME ); + ASSERT( ( ownerid >= 0 ) && ( ownerid < MAX_NET_PROTO_PLAYERS ) ); + + RE_PlayerName *re_pn = (RE_PlayerName *) rmev; + + if ( name_change_notification ) { + ASSERT( ( 8 + strlen( Player_Name[ ownerid ] ) + strlen( re_pn->PlayerName ) ) <= PASTE_STR_LEN ); + sprintf( paste_str, "%s is now %s", + Player_Name[ ownerid ], re_pn->PlayerName ); + if ( strlen( paste_str ) <= MAX_MESSAGELEN ) + ShowMessage( paste_str ); + } + CopyRemoteName( Player_Name[ ownerid ], re_pn->PlayerName ); + + RMEVTXT( MSGOUT( "--executing RE_PLAYERNAME: \"%s\" (%d).", re_pn->PlayerName, ownerid ); ); +} + + +// execute received remote event: weapon state -------------------------------- +// +void NET_ExecRmEvWeaponState( RE_Header *rmev, int ownerid ) +{ + ASSERT( rmev != NULL ); + ASSERT( rmev->RE_Type == RE_WEAPONSTATE ); + //ASSERT( ( ownerid >= 0 ) && ( ownerid < MAX_NET_PROTO_PLAYERS ) ); + + //NOTE: + // if new duration weapons are added this function should be updated. + + RE_WeaponState *re_ws = (RE_WeaponState *) rmev; + + // must only change state of single weapon + ASSERT( ( re_ws->WeaponMask & ( re_ws->WeaponMask - 1 ) ) == 0 ); + + // fetch pointer to remote player's ship + ShipObject *shippo = NET_FetchOwnersShip( re_ws->SenderId ); + ASSERT( shippo != NULL ); + ASSERT( shippo != MyShip ); + + // update energy + shippo->CurEnergy = re_ws->CurEnergy; +// shippo->Specials = re_ws->Specials; + + // do weapon specific stuff + switch ( re_ws->WeaponMask ) { + + case WPMASK_CANNON_LIGHTNING: + if ( re_ws->State == WPSTATE_ON ) + WFX_RemoteActivateLightning( re_ws->SenderId ); + else + WFX_RemoteDeactivateLightning( re_ws->SenderId ); + break; + + case WPMASK_CANNON_HELIX: + if ( re_ws->State == WPSTATE_ON ) + WFX_RemoteActivateHelix( re_ws->SenderId ); + else + WFX_RemoteDeactivateHelix( re_ws->SenderId ); + break; + + case WPMASK_CANNON_PHOTON: + if ( re_ws->State == WPSTATE_ON ) + WFX_RemoteActivatePhoton( re_ws->SenderId ); + else + WFX_RemoteDeactivatePhoton(re_ws->SenderId ); + break; + + case WPMASK_DEVICE_EMP: + if ( re_ws->State == WPSTATE_ON ) + WFX_RemoteActivateEmp( re_ws->SenderId ); + else + WFX_RemoteDeactivateEmp( re_ws->SenderId ); + break; + + default: + // simply set/reset active flag + if ( re_ws->State == WPSTATE_ON ) + shippo->WeaponsActive |= re_ws->WeaponMask; + else + shippo->WeaponsActive &= ~re_ws->WeaponMask; + break; + } + + RMEVTXT( MSGOUT( "--executing RE_WEAPONSTATE: 0x%X, %d, %d (%d).", re_ws->WeaponMask, re_ws->State, re_ws->CurEnergy, re_ws->SenderId ); ); +} + + +// list of syncable remote states --------------------------------------------- +// +static dword *rmev_sync_states[ RMEVSTATE_NUMSTATES ] = { + + (dword*)&AUXDATA_BACKGROUND_NEBULA_ID, + (dword*)&ExtraProbability, + (dword*)&ProbHelixCannon, + (dword*)&ProbLightningDevice, + (dword*)&ProbPhotonCannon, + (dword*)&ProbProximityMine, + (dword*)&ProbRepairExtra, + (dword*)&ProbAfterburner, + (dword*)&ProbHoloDecoy, + (dword*)&ProbInvisibility, + (dword*)&ProbInvulnerability, + (dword*)&ProbEnergyField, + (dword*)&ProbLaserUpgrade, + (dword*)&ProbLaserUpgrade1, + (dword*)&ProbLaserUpgrade2, + (dword*)&ProbMissilePack, + (dword*)&ProbDumbMissPack, + (dword*)&ProbHomMissPack, + (dword*)&ProbSwarmMissPack, + (dword*)&ProbEmpUpgrade1, + (dword*)&ProbEmpUpgrade2, + (dword*)&AUXDATA_SKILL_AMAZING_TIME, + (dword*)&AUXDATA_SKILL_BRILLIANT_TIME, + (dword*)&AUX_KILL_LIMIT_FOR_GAME_END, + (dword*)&EnergyExtraBoost, + (dword*)&RepairExtraBoost, + (dword*)&DumbPackNumMissls, + (dword*)&HomPackNumMissls, + (dword*)&SwarmPackNumMissls, + (dword*)&ProxPackNumMines, +}; + +/* + int EnergyExtraBoost = ENERGY_EXTRA_BOOST; + int RepairExtraBoost = 0; + + int DumbPackNumMissls = DUMB_PACK_NUMMISSLS; + int HomPackNumMissls = HOM_PACK_NUMMISSLS; + int SwarmPackNumMissls = SWARM_PACK_NUMMISSLS; + int ProxPackNumMines = PROX_PACK_NUMMINES; + */ + +// execute received remote event: state sync ---------------------------------- +// +void NET_ExecRmEvStateSync( RE_Header *rmev, int ownerid ) +{ + ASSERT( rmev != NULL ); + ASSERT( rmev->RE_Type == RE_STATESYNC ); + //ASSERT( ( ownerid >= 0 ) && ( ownerid < MAX_NET_PROTO_PLAYERS ) ); + + RE_StateSync *re_ss = (RE_StateSync *) rmev; + + // sync state without checking the value + if ( re_ss->StateKey < RMEVSTATE_NUMSTATES ) { + + *rmev_sync_states[ re_ss->StateKey ] = re_ss->StateValue; + + // always display a sync message + MSGOUT( "state sync: %d=%d.", re_ss->StateKey, re_ss->StateValue ); + } + + RMEVTXT( MSGOUT( "--executing RE_STATESYNC: %d=%d (%d).", re_ss->StateKey, re_ss->StateValue, ownerid ); ); +} + + +// execute received remote event: swarm missile ------------------------------- +// +void NET_ExecRmEvCreateSwarm( RE_Header *rmev, int ownerid ) +{ + ASSERT( rmev != NULL ); + ASSERT( rmev->RE_Type == RE_CREATESWARM ); + ASSERT( ( ownerid >= 0 ) && ( ownerid < MAX_NET_PROTO_PLAYERS ) ); + + RE_CreateSwarm *re_cs = (RE_CreateSwarm *) rmev; + + // determine target ship via id + ShipObject *targetpo = MyShip; + if ( re_cs->TargetHostObjId != ShipHostObjId( LocalPlayerId ) ) { + // same as ?: +// targetpo = FetchSpecificHostObject( re_cs->TargetHostObjID, PShipObjects ); +// if ( targetpo == NULL ) return; + targetpo = (ShipObject *) FetchFirstShip(); + while ( targetpo && ( re_cs->TargetHostObjId != targetpo->HostObjNumber ) ) + targetpo = (ShipObject *) targetpo->NextObj; + if ( targetpo == NULL ) { + return; + } + } + + GenObject *dummyobj = SWARM_Init( re_cs->SenderId, &re_cs->Origin, targetpo, re_cs->RandSeed ); + + AUD_SwarmMissiles( &re_cs->Origin, dummyobj ); + + RMEVTXT( MSGOUT( "--executing RE_CREATESWARM: %d (%d).", re_cs->RandSeed, ownerid ); ); +} + + +// execute received remote event: create emp ---------------------------------- +// +void NET_ExecRmEvCreateEmp( RE_Header *rmev, int ownerid ) +{ + ASSERT( rmev != NULL ); + ASSERT( rmev->RE_Type == RE_CREATEEMP ); + ASSERT( ( ownerid >= 0 ) && ( ownerid < MAX_NET_PROTO_PLAYERS ) ); + // get owner from RE + RE_CreateEmp *re_ce = (RE_CreateEmp *) rmev; + if ( NET_ProtocolGMSV() ) { + ownerid = re_ce->SenderId; //GetOwnerFromHostOjbNumber( ( (RE_CreateLaser*)rmev )->HostObjId ); + } + + + // fetch pointer to remote player's ship + ShipObject *shippo = NET_FetchOwnersShip( ownerid ); + // ASSERT( shippo != NULL ); + //ASSERT( shippo != MyShip ); + // well,this happens sometimes... + if ( shippo == NULL ) { + return; + } + + WFX_RemoteEmpBlast( shippo, re_ce->Upgradelevel ); + + RMEVTXT( MSGOUT( "--executing RE_CREATEEMP: %d (%d).", re_ce->Upgradelevel, ownerid ); ); +} + +// execute RE that describes the current gamestate ( time, game running, etc. ) +// +void NET_ExecRmEvGameState( RE_GameState* gamestate ) +{ + ASSERT( gamestate != NULL ); + ASSERT( gamestate->RE_Type == RE_GAMESTATE ); + ASSERT( CurGameTime != GAME_PEERTOPEER ); + + // server sends RE_GameState to transmit current game state/time + CurGameTime = gamestate->GameTime; +} + +// execute RE containing latest killstats ------------------------------------- +// +void NET_ExecRmEvKillStats( RE_KillStats* killstats ) +{ + ASSERT( killstats != NULL ); + ASSERT( killstats->RE_Type == RE_KILLSTATS ); + + // handled different in PEER/GMSV mode + NETs_UpdateKillStats( killstats ); +} + + + +// determine total size of remote event list (including termination dword ) --- +// +size_t NET_RmEvList_GetSize( RE_Header* relist ) +{ + ASSERT( relist != NULL ); + + size_t relistsize = 0; + + // process remote event list + while ( relist->RE_Type != RE_EMPTY ) { + + // sum up size of all remote events + size_t resize = NET_RmEvGetSize( relist ); + relistsize += resize; + + // advance to next event + ASSERT( ( relist->RE_BlockSize == RE_BLOCKSIZE_INVALID ) || ( relist->RE_BlockSize == resize ) ); + relist = (RE_Header *) ( (char *) relist + resize ); + } + + // include size of remote event list termination + relistsize += sizeof( dword ); + + return relistsize; +} + +// check integrity of remote event list ( known types, type checks, length check ) +// +int NET_RmEvList_IsWellFormed( RE_Header* relist ) +{ + ASSERT( relist != NULL ); + + //FIXME: [1/30/2002] implement + //FIXME: check SVG_REList::IsWellFormed + + //RE_LIST_MAXAVAIL + + //ASSERT( FALSE ); + return TRUE; +} + |