mirror of
https://github.com/ptitSeb/Serious-Engine
synced 2024-11-27 04:35:52 +01:00
225 lines
8.8 KiB
C++
225 lines
8.8 KiB
C++
/* Copyright (c) 2002-2012 Croteam Ltd.
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of version 2 of the GNU General Public License as published by
|
|
the Free Software Foundation
|
|
|
|
|
|
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.,
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
|
|
|
|
#ifndef SE_INCL_SESSIONSTATE_H
|
|
#define SE_INCL_SESSIONSTATE_H
|
|
#ifdef PRAGMA_ONCE
|
|
#pragma once
|
|
#endif
|
|
|
|
#include <Engine/Base/Synchronization.h>
|
|
#include <Engine/Templates/StaticStackArray.h>
|
|
#include <Engine/Network/NetworkMessage.h>
|
|
#include <Engine/Network/PlayerTarget.h>
|
|
#include <Engine/Network/SessionSocket.h>
|
|
#include <Engine/Base/Timer.h>
|
|
|
|
#define DEBUG_SYNCSTREAMDUMPING 0
|
|
|
|
#if DEBUG_SYNCSTREAMDUMPING
|
|
/*
|
|
* Obtain valid session dump memory stream
|
|
*/
|
|
CTMemoryStream *GetDumpStream(void);
|
|
/*
|
|
* Clear session dump memory stream
|
|
*/
|
|
void ClearDumpStream(void);
|
|
#endif
|
|
|
|
#ifdef NETSTRUCTS_PACKED
|
|
#pragma pack(1)
|
|
#endif
|
|
|
|
// checksum of world snapshot at given point in time - used for sync-checking
|
|
class CSyncCheck {
|
|
public:
|
|
TIME sc_tmTick; // time of snapshot
|
|
INDEX sc_iSequence; // sequence number last processed before this checksum
|
|
ULONG sc_ulCRC; // checksum
|
|
INDEX sc_iLevel; // checksum of level filename
|
|
CSyncCheck(void) { sc_tmTick = -1.0f; sc_iSequence = -1; sc_ulCRC = 0; sc_iLevel = 0; }
|
|
void Clear(void) { sc_tmTick = -1.0f; sc_iSequence = -1; sc_ulCRC = 0; sc_iLevel = 0; }
|
|
};
|
|
|
|
// info about an event that was predicted to happen
|
|
class CPredictedEvent {
|
|
public:
|
|
TIME pe_tmTick;
|
|
ULONG pe_ulEntityID;
|
|
ULONG pe_ulTypeID;
|
|
ULONG pe_ulEventID;
|
|
|
|
CPredictedEvent(void);
|
|
void Clear(void) {};
|
|
};
|
|
|
|
#ifdef NETSTRUCTS_PACKED
|
|
#pragma pack()
|
|
#endif
|
|
|
|
/*
|
|
* Session state, manipulates local copy of the world
|
|
*/
|
|
class ENGINE_API CSessionState {
|
|
public:
|
|
CStaticArray<CPlayerTarget> ses_apltPlayers; // client targets for all players in game
|
|
CStaticStackArray<CPredictedEvent> ses_apeEvents; // for event prediction
|
|
|
|
CTString ses_strMOTD; // MOTD as sent from the server
|
|
INDEX ses_iLevel; // for counting level changes
|
|
INDEX ses_iLastProcessedSequence; // sequence of last processed stream block
|
|
CNetworkStream ses_nsGameStream; // stream of blocks from server
|
|
|
|
// lerp params
|
|
CTimerValue ses_tvInitialization; // exact moment when the session state was started
|
|
TIME ses_tmInitializationTick; // tick when the session state was started
|
|
// secondary lerp params for non-predicted movement
|
|
CTimerValue ses_tvInitialization2; // exact moment when the session state was started
|
|
TIME ses_tmInitializationTick2; // tick when the session state was started
|
|
|
|
TIME ses_tmLastProcessedTick; // last tick when all actions were processed
|
|
TIME ses_tmPredictionHeadTick; // newest tick that was ever predicted
|
|
TIME ses_tmLastSyncCheck; // last time sync-check was generated
|
|
TIME ses_tmLastPredictionProcessed; // for determining when to do a new prediction cycle
|
|
|
|
INDEX ses_iMissingSequence; // first missing sequence
|
|
CTimerValue ses_tvResendTime; // timer for missing sequence retransmission
|
|
TIME ses_tmResendTimeout; // timeout value for increasing the request interval
|
|
CTimerValue ses_tvMessageReceived; // exact moment when the session state was started
|
|
|
|
TIME ses_tmLastDemoSequence; // synchronization timer for demo playing
|
|
ULONG ses_ulRandomSeed; // seed for pseudo-random number generation
|
|
ULONG ses_ulSpawnFlags; // spawn flags for current game
|
|
TIME ses_tmSyncCheckFrequency; // frequency of sync-checking
|
|
BOOL ses_iExtensiveSyncCheck; // set if syncheck should be extensive - for debugging purposes
|
|
|
|
BOOL ses_bKeepingUpWithTime; // set if the session state is keeping up with the time
|
|
TIME ses_tmLastUpdated;
|
|
CListHead ses_lhRememberedLevels; // list of remembered levels
|
|
BOOL ses_bAllowRandom; // set while random number generation is valid
|
|
BOOL ses_bPredicting; // set if the game is currently doing prediction
|
|
|
|
BOOL ses_bPause; // set while game is paused
|
|
BOOL ses_bWantPause; // set while wanting to have paused
|
|
BOOL ses_bGameFinished; // set when game has finished
|
|
BOOL ses_bWaitingForServer; // wait for server after level change
|
|
CTString ses_strDisconnected; // explanation of disconnection or empty string if not disconnected
|
|
|
|
INDEX ses_ctMaxPlayers; // maximum number of players allowed in game
|
|
BOOL ses_bWaitAllPlayers; // if set, wait for all players to join before starting
|
|
FLOAT ses_fRealTimeFactor; // enables slower or faster time for special effects
|
|
CTMemoryStream *ses_pstrm; // debug stream for sync check examination
|
|
|
|
CSessionSocketParams ses_sspParams; // local copy of server-side parameters
|
|
public:
|
|
// network message waiters
|
|
void Start_AtServer_t(void); // throw char *
|
|
void Start_AtClient_t(INDEX ctLocalPlayers); // throw char *
|
|
// Set lerping factor for current frame.
|
|
void SetLerpFactor(CTimerValue tvNow);
|
|
// notify entities of level change
|
|
void SendLevelChangeNotification(class CEntityEvent &ee);
|
|
// wait for a stream to come from server
|
|
void WaitStream_t(CTMemoryStream &strmMessage, const CTString &strName, INDEX iMsgCode);
|
|
// check if disconnected
|
|
BOOL IsDisconnected(void);
|
|
|
|
// print an incoming chat message to console
|
|
void PrintChatMessage(ULONG ulFrom, const CTString &strFrom, const CTString &strMessage);
|
|
public:
|
|
/* Constructor. */
|
|
CSessionState(void);
|
|
/* Destructor. */
|
|
~CSessionState(void);
|
|
|
|
// get a pseudo-random number (safe for network gaming)
|
|
ULONG Rnd(void);
|
|
|
|
/* Stop the session state. */
|
|
void Stop(void);
|
|
/* Start session state. */
|
|
void Start_t(INDEX ctLocalPlayers); // throw char *
|
|
|
|
// do physics for a game tick
|
|
void HandleMovers(void);
|
|
// do thinking for a game tick
|
|
void HandleTimers(TIME tmCurrentTick);
|
|
// do a warm-up run of the world for a few ticks
|
|
void WarmUpWorld(void);
|
|
// reset random number generator (always randomizes to same sequence!)
|
|
void ResetRND(void);
|
|
/* Process a game tick. */
|
|
void ProcessGameTick(CNetworkMessage &nmMessage, TIME tmCurrentTick);
|
|
/* Process a predicted game tick. */
|
|
void ProcessPredictedGameTick(INDEX iPredictionStep, FLOAT fFactor, TIME tmCurrentTick);
|
|
/* Process a gamestream block. */
|
|
void ProcessGameStreamBlock(CNetworkMessage &nmMessage);
|
|
/* Process all eventual avaliable gamestream blocks. */
|
|
void ProcessGameStream(void);
|
|
// flush prediction actions that were already processed
|
|
void FlushProcessedPredictions(void);
|
|
/* Find out how many prediction steps are currently pending. */
|
|
INDEX GetPredictionStepsCount(void);
|
|
/* Process all eventual avaliable prediction actions. */
|
|
void ProcessPrediction(void);
|
|
/* Get number of active players. */
|
|
INDEX GetPlayersCount(void);
|
|
/* Remember predictor positions of all players. */
|
|
void RememberPlayerPredictorPositions(void);
|
|
/* Get player position. */
|
|
const FLOAT3D &GetPlayerPredictorPosition(INDEX iPlayer);
|
|
|
|
// check an event for prediction, returns true if already predicted
|
|
BOOL CheckEventPrediction(CEntity *pen, ULONG ulTypeID, ULONG ulEventID);
|
|
|
|
// make synchronization test message and send it to server (if client), or add to buffer (if server)
|
|
void MakeSynchronisationCheck(void);
|
|
// create a checksum value for sync-check
|
|
void ChecksumForSync(ULONG &ulCRC, INDEX iExtensiveSyncCheck);
|
|
// dump sync data to text file
|
|
void DumpSync_t(CTStream &strm, INDEX iExtensiveSyncCheck); // throw char *
|
|
|
|
/* Read session state information from a stream. */
|
|
void Read_t(CTStream *pstr); // throw char *
|
|
void ReadWorldAndState_t(CTStream *pstr); // throw char *
|
|
void ReadRememberedLevels_t(CTStream *pstr); // throw char *
|
|
/* Write session state information into a stream. */
|
|
void Write_t(CTStream *pstr); // throw char *
|
|
void WriteWorldAndState_t(CTStream *pstr); // throw char *
|
|
void WriteRememberedLevels_t(CTStream *pstr); // throw char *
|
|
|
|
// remember current level
|
|
void RememberCurrentLevel(const CTString &strFileName);
|
|
// find a level if it is remembered
|
|
class CRememberedLevel *FindRememberedLevel(const CTString &strFileName);
|
|
// restore some old level
|
|
void RestoreOldLevel(const CTString &strFileName);
|
|
// forget all remembered levels
|
|
void ForgetOldLevels(void);
|
|
|
|
/* Session state loop. */
|
|
void SessionStateLoop(void);
|
|
/* Session sync dump functions. */
|
|
void DumpSyncToFile_t(CTStream &strm, INDEX iExtensiveSyncCheck); // throw char *
|
|
#if DEBUG_SYNCSTREAMDUMPING
|
|
void DumpSyncToMemory(void);
|
|
#endif
|
|
};
|
|
|
|
|
|
#endif /* include-once check. */
|
|
|