Cyd
2b8ca921cb
Complete disaster-recovery snapshot: engine/game source, game data assets, VC6 toolchain + DX SDKs, build outputs, deployed game, and _UNUSED archive. Large binaries in Git LFS; text preserved byte-for-byte (core.autocrlf=false, no eol attributes). See RECOVERY.md for the one-clone rebuild procedure.
696 lines
16 KiB
C++
696 lines
16 KiB
C++
#define MW4PRINT
|
|
|
|
#define Check_Pointer(x)
|
|
#define Check_Object(x)
|
|
#define Verify(x)
|
|
#define gosASSERT(x)
|
|
|
|
#define MString CString
|
|
#define GetLengthSafe GetLength
|
|
|
|
#define Scalar float
|
|
|
|
#define Max_Clamp(v,c) if (v>c) v=c; else (void)0
|
|
|
|
class ReplicatorID;
|
|
class MemoryStream;
|
|
class DynamicMemoryStream;
|
|
|
|
namespace Adept
|
|
{
|
|
enum
|
|
{
|
|
BeamDamageType = 0,
|
|
MissileDamageType,
|
|
ProjectileDamageType,
|
|
SplashDamageType,
|
|
HeatDamageType,
|
|
RammingDamageFromAboveType,
|
|
RammingDamageFromBelowType,
|
|
RammingDamageFromLeftType,
|
|
RammingDamageFromRightType,
|
|
RammingDamageFromAheadType,
|
|
RammingDamageFromBehindType,
|
|
HighExplosiveDamageType,
|
|
LavaDamageType,
|
|
AmmoFireDamageType
|
|
|
|
};
|
|
namespace DamageObject
|
|
{
|
|
enum {
|
|
NullZone=-1,
|
|
LeftLegZone = 0, //Mech pieces must follow default zone
|
|
RightLegZone,
|
|
LeftArmZone,
|
|
RightArmZone,
|
|
RightTorsoZone,
|
|
LeftTorsoZone,
|
|
CenterTorsoZone,
|
|
HeadZone,
|
|
SpecialZone1,
|
|
SpecialZone2,
|
|
VehicleHullZone, //All Vehicle and non-mech zones must be after the specials
|
|
VehicleWeaponZone,
|
|
VehicleSpecialZone,
|
|
DefaultZone,
|
|
NextDamageZone
|
|
};
|
|
enum {
|
|
NullArmorZone=-1,
|
|
LeftLegArmorZone = 0,
|
|
RightLegArmorZone,
|
|
LeftArmArmorZone,
|
|
RightArmArmorZone,
|
|
RightTorsoArmorZone,
|
|
LeftTorsoArmorZone,
|
|
CenterTorsoArmorZone,
|
|
CenterRearTorsoArmorZone,
|
|
HeadArmorZone,
|
|
SpecialArmorZone1,
|
|
SpecialArmorZone2,
|
|
DefaultArmorZone
|
|
};
|
|
}
|
|
|
|
class AdeptNetMissionParameters
|
|
{
|
|
public:
|
|
int m_runDedicated;
|
|
int m_closedGame;
|
|
int m_playerLimit;
|
|
|
|
|
|
int m_visibility;
|
|
|
|
|
|
AdeptNetMissionParameters();
|
|
|
|
virtual void ResetParameters(void);
|
|
virtual void SaveParameters(DynamicMemoryStream *stream);
|
|
virtual void LoadParameters(MemoryStream *stream);
|
|
};
|
|
}
|
|
using namespace Adept;
|
|
|
|
namespace NetMissionParameters
|
|
{
|
|
class TeamParameters
|
|
{
|
|
public:
|
|
int m_maxPlayersOnTeam;
|
|
int m_minimumTonnage;
|
|
int m_maximumTonnage;
|
|
int m_maximumTotalTonnage;
|
|
Scalar m_currentTotalTonnage;
|
|
int m_skin;
|
|
int m_alignment;
|
|
|
|
DWORD m_allowedMech[2];
|
|
DWORD m_allowedBeam[2];
|
|
DWORD m_allowedMissile[2];
|
|
DWORD m_allowedProjectile[2];
|
|
DWORD m_allowedSubsystem[2];
|
|
|
|
TeamParameters();
|
|
void ResetParameters(int index);
|
|
void SaveParameters(DynamicMemoryStream *stream);
|
|
void LoadParameters(MemoryStream *stream);
|
|
|
|
};
|
|
|
|
class MWNetMissionParameters : public AdeptNetMissionParameters
|
|
{
|
|
public:
|
|
|
|
int m_joinInProgress;
|
|
int m_joinInProgressCutOff;
|
|
int m_joinInProgressCutOffTime;
|
|
|
|
int m_heatOn;
|
|
int m_killLimit;
|
|
int m_killLimitNumber;
|
|
int m_respawnLimit;
|
|
int m_respawnLimitNumber;
|
|
int m_forceRespawn;
|
|
int m_splashOn;
|
|
int m_weaponjamOn;
|
|
int m_ammobayfireOn;
|
|
// MSL 5.05 Advance Mode
|
|
int m_advancemodeOn;
|
|
// MSL 5.06 Armor Mode
|
|
int m_armormodeOn;
|
|
int m_splashPercentage;
|
|
int m_unlimitedAmmo;
|
|
int m_friendlyFirePercentage;
|
|
int m_allowZoom;
|
|
int m_allow3rdPerson;
|
|
int m_allowAutoAim;
|
|
int m_allowDeadToChat;
|
|
int m_invulnerableDrop;
|
|
int m_isNight;
|
|
|
|
|
|
int m_weather;
|
|
int m_reportStats;
|
|
int m_serverConnection;
|
|
int m_serverBandwidth;
|
|
|
|
int m_radarMode;
|
|
|
|
int m_onlyStockMech;
|
|
int m_minimumTonnage;
|
|
int m_maximumTonnage;
|
|
|
|
int m_gameLength;
|
|
int m_serverRecycle;
|
|
int m_recycleDelay;
|
|
int m_playMissionReview;
|
|
|
|
int m_ruleType;
|
|
int m_deadMechCantSee;
|
|
int m_deadMechCantSeeOtherTeam;
|
|
|
|
int m_allowdecaltransfer;
|
|
int m_useMapCycle;
|
|
int m_pureMapCycle;
|
|
|
|
|
|
|
|
|
|
DWORD m_allowedMech[2];
|
|
DWORD m_allowedBeam[2];
|
|
DWORD m_allowedMissile[2];
|
|
DWORD m_allowedProjectile[2];
|
|
DWORD m_allowedSubsystem[2];
|
|
|
|
// there are always 8 teams,
|
|
// but sometimes a team won't allow players
|
|
int m_teamAllowed;
|
|
int m_teamCount;
|
|
TeamParameters m_teamParams[8];
|
|
|
|
int m_maxPlayers;
|
|
int m_maxBots;
|
|
int m_mapID;
|
|
char m_mapName[128];
|
|
char m_scenarioName[128];
|
|
char m_scenarioPath[128];
|
|
char m_serverName[256];
|
|
char m_serverIP[256];
|
|
char m_serverCPU[256];
|
|
char m_scriptName[256];
|
|
char m_scenarioText[1024];
|
|
|
|
__int64 m_mapClientCRC;
|
|
|
|
MWNetMissionParameters();
|
|
|
|
void ResetParameters(void);
|
|
void SaveParameters(DynamicMemoryStream *stream);
|
|
void LoadParameters(MemoryStream *stream);
|
|
|
|
};
|
|
};
|
|
using namespace NetMissionParameters;
|
|
|
|
namespace CBucketManager
|
|
{
|
|
enum Bucket_Type {
|
|
KILL_LINK = 0, // linked to mission scoring system
|
|
DEATH_LINK = 1, // linked to mission scoring system
|
|
// mods
|
|
KILLS = 2,
|
|
FRIENDLY_KILLS = 3,
|
|
ENEMY_KILLS = 4,
|
|
KILLS_BY_TONNAGE = 5,
|
|
FRIENDLY_KILLS_BY_TONNAGE = 6,
|
|
ENEMY_KILLS_BY_TONNAGE = 7,
|
|
DEATHS = 8,
|
|
SUICIDES = 9,
|
|
DAMAGE_INFLICT = 10,
|
|
FRIENDLY_DAMAGE_INFLICT = 11,
|
|
ENEMY_DAMAGE_INFLICT = 12,
|
|
DAMAGE_RECEIVE = 13,
|
|
FRIENDLY_DAMAGE_RECEIVE = 14,
|
|
ENEMY_DAMAGE_RECEIVE = 15,
|
|
COMPONENT_KILLS = 16,
|
|
COMPONENT_DEATHS = 17,
|
|
FRIENDLY_COMPONENT_KILLS = 18,
|
|
FRIENDLY_COMPONENT_DEATHS = 19,
|
|
ENEMY_COMPONENT_KILLS = 20,
|
|
ENEMY_COMPONENT_DEATHS = 21,
|
|
DFA = 22,
|
|
SHOTS_HIT = 23,
|
|
SHOTS_FIRED = 24,
|
|
HEAD_SHOTS = 25,
|
|
ARM_SHOTS = 26,
|
|
LEG_SHOTS = 27,
|
|
TORSO_SHOTS = 28,
|
|
KILLS_PC = 29,
|
|
KILLS_AI = 30,
|
|
BLANK = 31, // used just to hold values
|
|
// these are automatically checked
|
|
SHUTDOWN_TIMER = 32,
|
|
OBJECTIVE = 33, // mod2 is distance
|
|
OBJECTIVE_CONTESTED = 34,
|
|
OBJECTIVE_UNCONTESTED = 35,
|
|
FLAGS_TAKEN = 36,
|
|
FLAGS_DROPPED = 37,
|
|
FLAGS_CAPTURED = 38,
|
|
FLAG_HOLD_TIME = 39,
|
|
TIME = 40,
|
|
ALIVE_PLAYERS = 41,
|
|
DEAD_PLAYERS = 42,
|
|
CUSTOM = 43,
|
|
// MSL 5.04 bucket
|
|
// MAX_TYPES = 44
|
|
ENEMY_TURRET_KILLS = 44,
|
|
FRIENDLY_TURRET_KILLS = 45,
|
|
ENEMY_BUILDING_KILLS = 46,
|
|
FRIENDLY_BUILDING_KILLS = 47,
|
|
MAX_TYPES = 48
|
|
};
|
|
}
|
|
|
|
using namespace CBucketManager;
|
|
|
|
namespace MWApplication
|
|
{
|
|
enum Bandwidth_Type{
|
|
c_14_4kbps = 0,
|
|
c_28_8kbps,
|
|
c_56_6kbps,
|
|
c_64_kbps,
|
|
c_128_kbps,
|
|
c_384_kbps,
|
|
c_768_kbps,
|
|
c_1500_kbps,
|
|
c_10_Mbps,
|
|
c_100_Mbps
|
|
};
|
|
|
|
enum Connection_Type{
|
|
Modem = 0,
|
|
ISDN,
|
|
xDSL,
|
|
Cable,
|
|
LAN
|
|
};
|
|
}
|
|
using namespace MWApplication;
|
|
|
|
class ReplicatorID
|
|
{
|
|
public:
|
|
ReplicatorID() : connectionID(0), localID(0)
|
|
{Check_Pointer(this);}
|
|
|
|
ReplicatorID(const ReplicatorID& id) : connectionID(id.connectionID), localID(id.localID)
|
|
{Check_Pointer(this); Check_Object(&id);}
|
|
|
|
explicit ReplicatorID(BYTE connection_id) : connectionID(connection_id), localID(0)
|
|
{Check_Pointer(this);}
|
|
|
|
ReplicatorID(BYTE connection_id, WORD local_id) : connectionID(connection_id), localID(local_id)
|
|
{Check_Pointer(this);}
|
|
|
|
public:
|
|
static ReplicatorID Null;
|
|
|
|
bool operator!() const { Check_Object(this); return operator==(Null); }
|
|
|
|
ReplicatorID& operator=(const ReplicatorID& id)
|
|
{
|
|
Check_Pointer(this); Check_Object(&id);
|
|
connectionID = id.connectionID; localID = id.localID;
|
|
return *this;
|
|
}
|
|
|
|
ReplicatorID& operator+=(const ReplicatorID& id)
|
|
{
|
|
Check_Object(this); Check_Object(&id);
|
|
connectionID = static_cast<BYTE>(connectionID + id.connectionID);
|
|
localID = static_cast<WORD>(localID + id.localID);
|
|
return *this;
|
|
}
|
|
|
|
ReplicatorID& operator+=(WORD span)
|
|
{
|
|
Check_Object(this); localID = static_cast<WORD>(localID + span); return *this;
|
|
}
|
|
|
|
ReplicatorID& operator++()
|
|
{Check_Pointer(this); ++localID; return *this;}
|
|
|
|
bool operator<(const ReplicatorID& id) const
|
|
{
|
|
Check_Object(this); Check_Object(&id);
|
|
return
|
|
(connectionID == id.connectionID) ?
|
|
(localID < id.localID) :
|
|
(connectionID < id.connectionID);
|
|
}
|
|
|
|
bool operator<=(const ReplicatorID& id) const
|
|
{
|
|
Check_Object(this); Check_Object(&id);
|
|
return
|
|
(connectionID == id.connectionID) ?
|
|
(localID <= id.localID) :
|
|
(connectionID < id.connectionID);
|
|
}
|
|
|
|
bool operator>(const ReplicatorID& id) const
|
|
{
|
|
Check_Object(this); Check_Object(&id);
|
|
return
|
|
(connectionID == id.connectionID) ?
|
|
(localID > id.localID) :
|
|
(connectionID > id.connectionID);
|
|
}
|
|
|
|
bool operator>=(const ReplicatorID& id) const
|
|
{
|
|
Check_Object(this); Check_Object(&id);
|
|
return
|
|
(connectionID == id.connectionID) ?
|
|
(localID >= id.localID) :
|
|
(connectionID > id.connectionID);
|
|
}
|
|
|
|
bool operator==(const ReplicatorID& id) const
|
|
{
|
|
Check_Object(this); Check_Object(&id);
|
|
return (connectionID == id.connectionID && localID == id.localID);
|
|
}
|
|
|
|
bool operator!=(const ReplicatorID& id) const
|
|
{
|
|
Check_Object(this); Check_Object(&id);
|
|
return
|
|
(connectionID != id.connectionID || localID != id.localID);
|
|
}
|
|
|
|
BYTE connectionID;
|
|
WORD localID;
|
|
};
|
|
|
|
|
|
const int End_Of_Stream=-1;
|
|
|
|
const int Empty_Bit_Buffer=-20;
|
|
|
|
|
|
class MemoryStream
|
|
{
|
|
public:
|
|
MemoryStream(void *stream_start, DWORD stream_size, DWORD initial_offset=0);
|
|
virtual ~MemoryStream();
|
|
|
|
public:
|
|
virtual void* GetPointer() const
|
|
{Check_Object(this); return currentPosition;}
|
|
BYTE* GetStreamStart() const
|
|
{Check_Object(this); return streamStart; }
|
|
DWORD GetIndex() const
|
|
{Check_Object(this); return currentPosition - streamStart;}
|
|
DWORD GetSize() const
|
|
{Check_Object(this); return streamSize;}
|
|
|
|
DWORD GetBufferBytesUsed()
|
|
{Check_Object(this); return highWaterByte - streamStart;}
|
|
|
|
|
|
DWORD GetBytesUsed() const
|
|
{Check_Object(this); return currentPosition - streamStart;}
|
|
virtual DWORD GetBytesRemaining() const
|
|
{Check_Object(this); return streamSize - GetBytesUsed();}
|
|
|
|
|
|
void AdvanceToDwordBoundary()
|
|
{
|
|
Check_Pointer(this);
|
|
|
|
if((int)currentPosition & 0x3)
|
|
{
|
|
AdvancePointer(4-(int)currentPosition & 0x3);
|
|
}
|
|
|
|
Check_Object(this);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Assignment methods
|
|
//
|
|
public:
|
|
virtual void SetPointer(void *new_pointer)
|
|
{
|
|
Check_Pointer(this);
|
|
currentPosition = (BYTE*)new_pointer;
|
|
|
|
if (currentPosition > highWaterByte)
|
|
highWaterByte = currentPosition;
|
|
|
|
Check_Object(this);
|
|
}
|
|
void operator=(void *new_pointer)
|
|
{SetPointer(new_pointer);}
|
|
|
|
virtual void SetPointer(DWORD index)
|
|
{
|
|
Check_Pointer(this);
|
|
currentPosition = streamStart + index;
|
|
|
|
if (currentPosition > highWaterByte)
|
|
highWaterByte = currentPosition;
|
|
|
|
Check_Object(this);
|
|
}
|
|
void operator=(DWORD index)
|
|
{SetPointer(index);}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Stream methods
|
|
//
|
|
public:
|
|
void Rewind()
|
|
{SetPointer((DWORD) 0U);currentBit = Empty_Bit_Buffer;}
|
|
|
|
virtual bool AllocateBytes(DWORD count)
|
|
{return GetBytesRemaining() <= count;}
|
|
virtual MemoryStream& AdvancePointer(DWORD count)
|
|
{
|
|
Check_Object(this);
|
|
currentPosition += count;
|
|
|
|
if (currentPosition > highWaterByte)
|
|
highWaterByte = currentPosition;
|
|
|
|
Verify(currentPosition >= streamStart);
|
|
Verify(currentPosition <= streamStart + streamSize);
|
|
|
|
Check_Object(this);
|
|
return *this;
|
|
}
|
|
MemoryStream& operator+=(DWORD count)
|
|
{return AdvancePointer(count);}
|
|
|
|
virtual MemoryStream& RewindPointer(DWORD count)
|
|
{
|
|
Check_Object(this);
|
|
currentPosition -= count;
|
|
|
|
if (currentPosition > highWaterByte)
|
|
highWaterByte = currentPosition;
|
|
|
|
Verify(currentPosition >= streamStart);
|
|
Verify(currentPosition <= streamStart + streamSize);
|
|
|
|
Check_Object(this);
|
|
return *this;
|
|
}
|
|
MemoryStream& operator-=(DWORD count)
|
|
{return RewindPointer(count);}
|
|
|
|
virtual MemoryStream& ReadBytes(
|
|
void *ptr,
|
|
DWORD number_of_bytes
|
|
);
|
|
virtual MemoryStream& WriteBytes(
|
|
const void *ptr,
|
|
DWORD number_of_bytes
|
|
);
|
|
|
|
MemoryStream& ReadSwappedBytes(
|
|
void *ptr,
|
|
DWORD number_of_bytes
|
|
);
|
|
MemoryStream& WriteSwappedBytes(
|
|
const void *ptr,
|
|
DWORD number_of_bytes
|
|
);
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Bit operators
|
|
//
|
|
// WARNING - DO NOT MIX AND MATCH WITH BYTE METHODS!!!!!
|
|
//
|
|
|
|
private:
|
|
int currentBit;
|
|
|
|
BYTE workingBitBuffer;
|
|
|
|
MemoryStream& ReadUnsafeBits(void *ptr, DWORD number_of_bits);
|
|
|
|
public:
|
|
int GetCurrentBitCount()
|
|
{
|
|
Check_Object(this);
|
|
int current_bit = GetBytesUsed() * 8;
|
|
if (currentBit != Empty_Bit_Buffer)
|
|
{
|
|
current_bit -= (8-currentBit);
|
|
}
|
|
|
|
return current_bit;
|
|
}
|
|
|
|
MemoryStream& ReadBit(bool &bit_value);
|
|
MemoryStream& WriteBit(const bool &bit_value);
|
|
|
|
MemoryStream& ReadBits(__int64 *ptr, DWORD number_of_bits)
|
|
{
|
|
Verify(number_of_bits <= 64);
|
|
Check_Object(this); Check_Pointer(ptr);
|
|
*ptr = 0; return ReadUnsafeBits(ptr, number_of_bits);
|
|
}
|
|
|
|
MemoryStream& ReadBits(int *ptr, DWORD number_of_bits)
|
|
{
|
|
Verify(number_of_bits <= 32);
|
|
Check_Object(this); Check_Pointer(ptr);
|
|
*ptr = 0; return ReadUnsafeBits(ptr, number_of_bits);
|
|
}
|
|
|
|
MemoryStream& ReadBits(BYTE *ptr, DWORD number_of_bits)
|
|
{
|
|
Verify(number_of_bits <= 8);
|
|
Check_Object(this); Check_Pointer(ptr);
|
|
*ptr = 0; return ReadUnsafeBits(ptr, number_of_bits);
|
|
}
|
|
|
|
|
|
MemoryStream& ReadBits(WORD *ptr, DWORD number_of_bits)
|
|
{
|
|
Verify(number_of_bits <= 16);
|
|
Check_Object(this); Check_Pointer(ptr);
|
|
*ptr = 0; return ReadUnsafeBits(ptr, number_of_bits);
|
|
}
|
|
|
|
MemoryStream& ReadBits(DWORD *ptr, DWORD number_of_bits)
|
|
{
|
|
Verify(number_of_bits <= 32);
|
|
Check_Object(this); Check_Pointer(ptr);
|
|
*ptr = 0; return ReadUnsafeBits(ptr, number_of_bits);
|
|
}
|
|
|
|
MemoryStream& ReadBits(float *ptr, DWORD number_of_bits)
|
|
{
|
|
Verify(number_of_bits == 32);
|
|
Check_Object(this); Check_Pointer(ptr);
|
|
*ptr = 0.0; return ReadUnsafeBits(ptr, number_of_bits);
|
|
}
|
|
|
|
|
|
MemoryStream& ReadBits(double *ptr, DWORD number_of_bits)
|
|
{
|
|
Verify(number_of_bits == 64);
|
|
Check_Object(this); Check_Pointer(ptr);
|
|
*ptr = 0.0; return ReadUnsafeBits(ptr, number_of_bits);
|
|
}
|
|
|
|
MemoryStream& WriteBits(const void *ptr, DWORD number_of_bits);
|
|
|
|
MemoryStream& ReadBitsToScaledInt(int &number, int min, int max, DWORD number_of_bits);
|
|
MemoryStream& WriteScaledIntToBits(const int &number, int min, int max, DWORD number_of_bits);
|
|
|
|
MemoryStream& ReadBitsToScaledFloat(float &number, float min, float max, DWORD number_of_bits);
|
|
MemoryStream& WriteScaledFloatToBits(const float &number, float min, float max, DWORD number_of_bits);
|
|
|
|
|
|
void WriteByteAlign();
|
|
|
|
void ReadByteAlign();
|
|
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Protected data
|
|
//
|
|
protected:
|
|
BYTE
|
|
*streamStart,
|
|
*currentPosition,
|
|
*highWaterByte;
|
|
DWORD streamSize;
|
|
};
|
|
|
|
class DynamicMemoryStream:
|
|
public MemoryStream
|
|
{
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Construction, destruction, and testing
|
|
//
|
|
public:
|
|
DynamicMemoryStream(DWORD stream_size=0);
|
|
DynamicMemoryStream(
|
|
void *stream_start,
|
|
DWORD stream_size,
|
|
DWORD initial_offset=0
|
|
);
|
|
DynamicMemoryStream(const DynamicMemoryStream& otherStream);
|
|
~DynamicMemoryStream();
|
|
|
|
void TestInstance() const
|
|
{
|
|
Verify((DWORD)(currentPosition - streamStart) <= streamSize);
|
|
Verify(streamSize <= bufferSize);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Accessors
|
|
//
|
|
public:
|
|
DWORD GetBufferSize()
|
|
{
|
|
Check_Object(this);
|
|
return bufferSize;
|
|
}
|
|
|
|
void SetSize(DWORD stream_length)
|
|
{
|
|
Check_Object(this);
|
|
Verify(stream_length <= bufferSize);
|
|
streamSize = stream_length;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Stream methods
|
|
//
|
|
public:
|
|
MemoryStream& WriteBytes(
|
|
const void *ptr,
|
|
DWORD number_of_bytes
|
|
);
|
|
|
|
bool AllocateBytes(DWORD count);
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Private data
|
|
//
|
|
private:
|
|
DWORD bufferSize;
|
|
bool ownsStream;
|
|
};
|