internal override bool Read(BinaryReader binaryReader, System.Net.EndPoint senderEndPoint, int gameVersion)
{
if (!base.Read(binaryReader, senderEndPoint, gameVersion))
{
return(NetworkError());
}
// Engine
bool?engine = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (engine == null)
{
return(NetworkError());
}
Engine = engine.Value;
MyMwcLog.IfNetVerbose_AddToLog("Engine: " + Engine);
// RadarType
byte?radarType = MyMwcMessageIn.ReadByteEx(binaryReader, senderEndPoint);
if (radarType == null)
{
return(NetworkError());
}
RadarType = radarType.Value;
MyMwcLog.IfNetVerbose_AddToLog("RadarType: " + RadarType);
// BackCamera
bool?backCamera = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (backCamera == null)
{
return(NetworkError());
}
BackCamera = backCamera.Value;
MyMwcLog.IfNetVerbose_AddToLog("BackCamera: " + BackCamera);
// MovementSlowdown
bool?movementSlowdown = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (movementSlowdown == null)
{
return(NetworkError());
}
MovementSlowdown = movementSlowdown.Value;
MyMwcLog.IfNetVerbose_AddToLog("MovementSlowdown: " + MovementSlowdown);
// ViewMode
byte?viewMode = MyMwcMessageIn.ReadByteEx(binaryReader, senderEndPoint);
if (viewMode == null)
{
return(NetworkError());
}
ViewMode = viewMode.Value;
MyMwcLog.IfNetVerbose_AddToLog("ViewMode: " + ViewMode);
return(true);
}
private bool ReadCurrent(BinaryReader binaryReader, EndPoint senderEndPoint, int gameVersion)
{
var droneType = MyMwcMessageIn.ReadByteEx(binaryReader, senderEndPoint);
if (droneType == null)
{
return(false);
}
DroneType = (MyMwcObjectBuilder_Drone_TypesEnum)droneType.Value;
MyMwcLog.IfNetVerbose_AddToLog("DroneType: " + DroneType);
return(true);
}
internal override bool Read(BinaryReader binaryReader, EndPoint senderEndPoint, int gameVersion)
{
if (!base.Read(binaryReader, senderEndPoint, gameVersion))
{
return(NetworkError());
}
// Status
byte?status = MyMwcMessageIn.ReadByteEx(binaryReader, senderEndPoint);
if (status == null)
{
return(NetworkError());
}
Status = status.Value;
MyMwcLog.IfNetVerbose_AddToLog("Status: " + Status);
// EventType
byte?eventType = MyMwcMessageIn.ReadByteEx(binaryReader, senderEndPoint);
if (eventType == null)
{
return(NetworkError());
}
EventType = eventType.Value;
MyMwcLog.IfNetVerbose_AddToLog("EventType: " + EventType);
// Time
DateTime?time = MyMwcMessageIn.ReadDateTimeEx(binaryReader, senderEndPoint);
if (time == null)
{
return(NetworkError());
}
Time = time.Value;
MyMwcLog.IfNetVerbose_AddToLog("Time: " + Time);
// EventTypeID
int?eventTypeID = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (eventTypeID == null)
{
return(NetworkError());
}
EventTypeID = eventTypeID.Value;
MyMwcLog.IfNetVerbose_AddToLog("EventTypeID: " + EventTypeID);
return(true);
}
// Read this object from message-in
internal override bool Read(BinaryReader binaryReader, EndPoint senderEndPoint, int gameVersion)
{
if (base.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
// Asteroid Type
MyMwcObjectBuilder_StaticAsteroid_TypesEnum?asteroidType = MyMwcMessageIn.ReadObjectBuilderStaticAsteroidTypesEnumEx(binaryReader, senderEndPoint);
if (asteroidType == null)
{
return(NetworkError());
}
AsteroidType = asteroidType.Value;
MyMwcLog.IfNetVerbose_AddToLog("AsteroidType: " + AsteroidType);
// Asteroid Material
bool?hasId = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!hasId.HasValue)
{
return(NetworkError()); // Cannot read bool - whether owner asteroid material is null or not
}
MyMwcLog.IfNetVerbose_AddToLog("MyMwcObjectBuilder_StaticAsteroid.AsteroidMaterial.HasValue: " + hasId.Value);
// Testing whether Asteroid Material is null
if (hasId.Value)
{
// asteroid material has value - read the value
byte?asteroidMaterial = MyMwcMessageIn.ReadByteEx(binaryReader, senderEndPoint);
if (!asteroidMaterial.HasValue)
{
return(NetworkError()); // Cannot read asteroid material
}
MyMwcLog.IfNetVerbose_AddToLog("MyMwcObjectBuilder_StaticAsteroid.AsteroidMaterial.Value: " + asteroidMaterial.Value);
this.AsteroidMaterial = (MyMwcVoxelMaterialsEnum)asteroidMaterial.Value;
}
else
{
this.AsteroidMaterial = null;
}
return(true);
}
internal override bool Read(System.IO.BinaryReader binaryReader, System.Net.EndPoint senderEndPoint, int gameVersion)
{
if (!base.Read(binaryReader, senderEndPoint, gameVersion))
{
return(NetworkError());
}
var endpoint = MyMwcMessageIn.ReadEndpointEx(binaryReader, senderEndPoint);
if (endpoint == null)
{
return(NetworkError());
}
Endpoint = endpoint;
var gameUserId = MyMwcMessageIn.ReadByteEx(binaryReader, senderEndPoint);
if (!gameUserId.HasValue)
{
return(NetworkError());
}
GameUserId = gameUserId.Value;
var userId = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (!userId.HasValue)
{
return(NetworkError());
}
UserId = userId.Value;
var smallShipEntityId = MyMwcMessageIn.ReadUInt32Ex(binaryReader, senderEndPoint);
if (!smallShipEntityId.HasValue)
{
return(NetworkError());
}
SmallShipEntityId = smallShipEntityId.Value;
return(true);
}
private bool Read01085002(BinaryReader binaryReader, EndPoint senderEndPoint, int gameVersion)
{
var droneType = MyMwcMessageIn.ReadByteEx(binaryReader, senderEndPoint);
if (droneType == null)
{
return(false);
}
DroneType = (MyMwcObjectBuilder_Drone_TypesEnum)droneType.Value;
MyMwcLog.IfNetVerbose_AddToLog("DroneType: " + DroneType);
// Owner Ship
bool?hasId = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!hasId.HasValue)
{
return(NetworkError()); // Cannot read bool - whether owner entity id is null or not
}
MyMwcLog.IfNetVerbose_AddToLog("MyMwcObjectBuilder_Drone.OwnerEntityId.HasValue: " + hasId.Value);
// Testing whether owner entity id is null
if (hasId.Value)
{
// entity id has value - read the value
uint?ownerEntityID = MyMwcMessageIn.ReadUInt32Ex(binaryReader, senderEndPoint);
if (!ownerEntityID.HasValue)
{
return(NetworkError()); // Cannot read owner entity ID
}
MyMwcLog.IfNetVerbose_AddToLog("MyMwcObjectBuilder_Drone.OwnerEntityId.Value: " + ownerEntityID.Value);
this.OwnerId = ownerEntityID.Value;
}
else
{
this.OwnerId = null;
}
return(true);
}
// Read this object from message-in
internal override bool Read(BinaryReader binaryReader, EndPoint senderEndPoint, int gameVersion)
{
if (base.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
// NumberOfTemplates (why?)
int?tempcount = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (tempcount == null)
{
return(NetworkError());
}
m_numberOfTemplates = tempcount.Value;
MyMwcLog.IfNetVerbose_AddToLog("NumberOfTemplates: " + m_numberOfTemplates);
// Bot Templates
for (int c = 0; c < m_numberOfTemplates; c++)
{
MyMwcObjectBuilder_SmallShip_Bot nb = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_SmallShip_Bot;
if (nb == null || nb.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
ShipTemplates.Add(nb);
}
// WayPointPath
string pWPP = MyMwcMessageIn.ReadStringEx(binaryReader, senderEndPoint);
if (pWPP == null)
{
return(NetworkError());
}
WayPointPath = pWPP;
MyMwcLog.IfNetVerbose_AddToLog("WayPointPath: " + WayPointPath);
// Faction
int?pFaction = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (pFaction == null)
{
return(NetworkError());
}
Faction = (MyMwcObjectBuilder_FactionEnum)pFaction.Value;
MyMwcLog.IfNetVerbose_AddToLog("Faction: " + Faction);
// SpawnInGroups
bool?spawnInGroups = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (spawnInGroups == null)
{
return(NetworkError());
}
SpawnInGroups = spawnInGroups.Value;
MyMwcLog.IfNetVerbose_AddToLog("SpawnInGroups: " + SpawnInGroups);
// SpawnCount
int?spawnCount = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (spawnCount == null)
{
return(NetworkError());
}
SpawnCount = spawnCount.Value;
MyMwcLog.IfNetVerbose_AddToLog("SpawnCount: " + SpawnCount);
// FirstSpawnTimer
float?firstSpawnTimer = MyMwcMessageIn.ReadFloat(binaryReader);
if (firstSpawnTimer == null)
{
return(NetworkError());
}
FirstSpawnTimer = firstSpawnTimer.Value;
MyMwcLog.IfNetVerbose_AddToLog("FirstSpawnTimer: " + FirstSpawnTimer);
// RespawnTimer
float?respawnTimer = MyMwcMessageIn.ReadFloat(binaryReader);
if (respawnTimer == null)
{
return(NetworkError());
}
RespawnTimer = respawnTimer.Value;
MyMwcLog.IfNetVerbose_AddToLog("RespawnTimer: " + RespawnTimer);
// BoundingRadius
float?pBR = MyMwcMessageIn.ReadFloat(binaryReader);
if (pBR == null)
{
return(NetworkError());
}
BoundingRadius = pBR.Value;
MyMwcLog.IfNetVerbose_AddToLog("BoundingRadius: " + BoundingRadius);
// Activated
bool?activated = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (activated == null)
{
return(NetworkError());
}
Activated = activated.Value;
MyMwcLog.IfNetVerbose_AddToLog("Activated: " + Activated);
// Patrol mode
int?patrolMode = MyMwcMessageIn.ReadByteEx(binaryReader, senderEndPoint);
if (patrolMode == null)
{
return(NetworkError());
}
PatrolMode = (MyPatrolMode)patrolMode.Value;
MyMwcLog.IfNetVerbose_AddToLog("PatrolMode: " + PatrolMode);
return(true);
}
private bool Read_01085002(BinaryReader binaryReader, EndPoint senderEndPoint, int gameVersion)
{
// Ship Type
byte?objectBuilderID = MyMwcMessageIn.ReadByteEx(binaryReader, senderEndPoint);
if (objectBuilderID == null)
{
return(NetworkError());
}
SetObjectBuilderId(objectBuilderID.Value);
MyMwcLog.IfNetVerbose_AddToLog("ShipType: " + objectBuilderID.Value);
// Weapons And Devices
int?countWeapons = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (countWeapons == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("countWeaponsAndDevices: " + countWeapons);
Weapons = new List <MyMwcObjectBuilder_SmallShip_Weapon>(countWeapons.Value);
for (int i = 0; i < countWeapons; i++)
{
MyMwcObjectBuilder_SmallShip_Weapon newWAD =
MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as
MyMwcObjectBuilder_SmallShip_Weapon;
if (newWAD == null)
{
return(NetworkError());
}
if (newWAD.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
Weapons.Add(newWAD);
}
// Assignment of ammo
int?countAssignAmmo = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (countAssignAmmo == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("countAssignAmmo: " + countAssignAmmo);
AssignmentOfAmmo = new List <MyMwcObjectBuilder_AssignmentOfAmmo>(countAssignAmmo.Value);
for (int i = 0; i < countAssignAmmo; i++)
{
MyMwcObjectBuilder_AssignmentOfAmmo newAssignAmmo =
MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as
MyMwcObjectBuilder_AssignmentOfAmmo;
if (newAssignAmmo == null)
{
return(NetworkError());
}
if (newAssignAmmo.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
AssignmentOfAmmo.Add(newAssignAmmo);
}
// Engine
bool?isEngine = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (isEngine == null)
{
return(NetworkError());
}
if (isEngine.Value)
{
Engine =
MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as
MyMwcObjectBuilder_SmallShip_Engine;
if (Engine == null)
{
return(NetworkError());
}
if (Engine.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
}
else
{
Engine = null;
}
// Armor
bool?isArmor = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (isArmor == null)
{
return(NetworkError());
}
if (isArmor.Value)
{
Armor =
MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as
MyMwcObjectBuilder_SmallShip_Armor;
if (Armor == null)
{
return(NetworkError());
}
if (Armor.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
}
else
{
Armor = null;
}
// Radar
bool?isRadar = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (isRadar == null)
{
return(NetworkError());
}
if (isRadar.Value)
{
Radar =
MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as
MyMwcObjectBuilder_SmallShip_Radar;
if (Radar == null)
{
return(NetworkError());
}
if (Radar.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
}
else
{
Radar = null;
}
bool?hasMaxHealth = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!hasMaxHealth.HasValue)
{
return(NetworkError());
}
if (hasMaxHealth.Value)
{
// Ship max health
float?shipMaxHealth = MyMwcMessageIn.ReadFloat(binaryReader);
if (shipMaxHealth == null)
{
return(NetworkError());
}
ShipMaxHealth = shipMaxHealth.Value;
MyMwcLog.IfNetVerbose_AddToLog("ShipMaxHealth: " + ShipMaxHealth.Value);
if (float.IsNaN(ShipMaxHealth.Value) || float.IsInfinity(ShipMaxHealth.Value))
{
System.Diagnostics.Debug.Fail("ShipMaxHealth is: " + ShipMaxHealth.Value);
ShipMaxHealth = null; // MyGameplayConstants.MAX_HEALTH_MAX;
}
}
else
{
MyMwcLog.IfNetVerbose_AddToLog("ShipMaxHealth is: null");
ShipMaxHealth = null;
}
// Ship health ratio
float?shipHealthRatio = MyMwcMessageIn.ReadFloat(binaryReader);
if (shipHealthRatio == null)
{
return(NetworkError());
}
ShipHealthRatio = shipHealthRatio.Value;
MyMwcLog.IfNetVerbose_AddToLog("ShipHealthRatio: " + ShipHealthRatio);
// Armor health
float?armorHealth = MyMwcMessageIn.ReadFloat(binaryReader);
if (armorHealth == null)
{
return(NetworkError());
}
ArmorHealth = armorHealth.Value;
MyMwcLog.IfNetVerbose_AddToLog("ArmorHealth: " + ArmorHealth);
// Oxygen
float?oxygen = MyMwcMessageIn.ReadFloat(binaryReader);
if (oxygen == null)
{
return(NetworkError());
}
Oxygen = oxygen.Value;
MyMwcLog.IfNetVerbose_AddToLog("Oxygen: " + Oxygen);
// Fuel
float?fuel = MyMwcMessageIn.ReadFloat(binaryReader);
if (fuel == null)
{
return(NetworkError());
}
Fuel = fuel.Value;
MyMwcLog.IfNetVerbose_AddToLog("Fuel: " + Fuel);
// Reflector light
bool?reflectorLight = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (reflectorLight == null)
{
return(NetworkError());
}
ReflectorLight = reflectorLight.Value;
MyMwcLog.IfNetVerbose_AddToLog("ReflectorLight: " + ReflectorLight);
// Reflector long range
bool?reflectorLongRange = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (reflectorLongRange == null)
{
return(NetworkError());
}
ReflectorLongRange = reflectorLongRange.Value;
MyMwcLog.IfNetVerbose_AddToLog("ReflectorLongRange: " + ReflectorLongRange);
// ReflectorShadowDistance
float?reflectorShadowDistance = MyMwcMessageIn.ReadFloat(binaryReader);
if (reflectorShadowDistance == null)
{
return(NetworkError());
}
ReflectorShadowDistance = reflectorShadowDistance.Value;
MyMwcLog.IfNetVerbose_AddToLog("ReflectorShadowDistance: " + ReflectorShadowDistance);
// AI Priority
int?aiPriority = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (aiPriority == null)
{
return(NetworkError());
}
AIPriority = aiPriority.Value;
MyMwcLog.IfNetVerbose_AddToLog("AIPriority: " + AIPriority);
return(true);
}
private bool Read_01085002(BinaryReader binaryReader, EndPoint senderEndPoint, int gameVersion)
{
MyCommonDebugUtils.AssertDebug(Faction != 0);
// AITemplate
int?aiTemplate = MyMwcMessageIn.ReadByteEx(binaryReader, senderEndPoint);
if (aiTemplate == null)
{
return(NetworkError());
}
AITemplate = (MyAITemplateEnum)aiTemplate.Value;
MyMwcLog.IfNetVerbose_AddToLog("AITemplate: " + AITemplate);
// Aggressivity
float?aggressivity = MyMwcMessageIn.ReadFloat(binaryReader);
if (aggressivity == null)
{
return(NetworkError());
}
Aggressivity = aggressivity.Value;
MyMwcLog.IfNetVerbose_AddToLog("Aggressivity: " + Aggressivity);
// SeeDistance
float?seeDistance = MyMwcMessageIn.ReadFloat(binaryReader);
if (seeDistance == null)
{
return(NetworkError());
}
SeeDistance = seeDistance.Value;
MyMwcLog.IfNetVerbose_AddToLog("SeeDistance: " + SeeDistance);
// SleepDistance
float?sleepDistance = MyMwcMessageIn.ReadFloat(binaryReader);
if (sleepDistance == null)
{
return(NetworkError());
}
SleepDistance = sleepDistance.Value;
MyMwcLog.IfNetVerbose_AddToLog("SleepDistance: " + SleepDistance);
// Patrol mode
int?patrolMode = MyMwcMessageIn.ReadByteEx(binaryReader, senderEndPoint);
if (patrolMode == null)
{
return(NetworkError());
}
PatrolMode = (MyPatrolMode)patrolMode.Value;
MyMwcLog.IfNetVerbose_AddToLog("PatrolMode: " + PatrolMode);
// Ship template ID
bool?hasShipTemplateID = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!hasShipTemplateID.HasValue)
{
return(NetworkError());
}
if (hasShipTemplateID.Value)
{
int?shipTemplateID = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (shipTemplateID == null)
{
return(NetworkError());
}
ShipTemplateID = shipTemplateID.Value;
MyMwcLog.IfNetVerbose_AddToLog("ShipTemplateID: " + ShipTemplateID);
}
else
{
ShipTemplateID = null;
MyMwcLog.IfNetVerbose_AddToLog("ShipTemplateID: null");
}
// Leader
bool?hasLeader = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!hasLeader.HasValue)
{
return(NetworkError());
}
if (hasLeader.Value)
{
int?leader = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (!leader.HasValue)
{
return(NetworkError());
}
Leader = (uint)leader.Value;
MyMwcLog.IfNetVerbose_AddToLog("Leader: " + Leader);
}
else
{
Leader = null;
MyMwcLog.IfNetVerbose_AddToLog("Leader: null");
}
// Idle Behavior
byte?idleBehavior = MyMwcMessageIn.ReadByteEx(binaryReader, senderEndPoint);
if (!idleBehavior.HasValue)
{
NetworkError();
}
IdleBehavior = (BotBehaviorType)idleBehavior.Value;
MyMwcLog.IfNetVerbose_AddToLog("IdleBehavior: " + IdleBehavior);
// Leader Lost Enabled
bool?leaderLostEnabled = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!leaderLostEnabled.HasValue)
{
return(NetworkError());
}
LeaderLostEnabled = leaderLostEnabled.Value;
MyMwcLog.IfNetVerbose_AddToLog("LeaderLostEnabled: " + LeaderLostEnabled);
// Active AI
bool?activeAI = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!activeAI.HasValue)
{
return(NetworkError());
}
ActiveAI = activeAI.Value;
MyMwcLog.IfNetVerbose_AddToLog("ActiveAI: " + ActiveAI);
SlowDown = 1;
return(true);
}
bool ReadCurrent(BinaryReader binaryReader, EndPoint senderEndPoint, int gameVersion)
{
MyMwcVoxelFilesEnum?voxelFile = MyMwcMessageIn.ReadVoxelFileEnumEx(binaryReader, senderEndPoint);
if (voxelFile == null)
{
return(NetworkError());
}
VoxelFile = voxelFile.Value;
MyMwcLog.IfNetVerbose_AddToLog("VoxelFile: " + VoxelFile.ToString());
MyMwcVoxelMaterialsEnum?voxelMaterial = MyMwcMessageIn.ReadVoxelMaterialsEnumEx(binaryReader, senderEndPoint);
if (voxelMaterial == null)
{
return(NetworkError());
}
VoxelMaterial = voxelMaterial.Value;
MyMwcLog.IfNetVerbose_AddToLog("VoxelMaterial: " + VoxelMaterial.ToString());
// Merge Contents
int?countMergeContents = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (countMergeContents == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("countMergeContents: " + countMergeContents);
MergeContents = new List <MyMwcObjectBuilder_VoxelMap_MergeContent>(countMergeContents.Value);
for (int i = 0; i < countMergeContents; i++)
{
MyMwcObjectBuilder_VoxelMap_MergeContent newMC = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_VoxelMap_MergeContent;
if (newMC == null)
{
return(NetworkError());
}
if (newMC.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
MergeContents.Add(newMC);
}
// Merge Materials
int?countMergeMaterials = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (countMergeMaterials == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("countMergeMaterials: " + countMergeMaterials);
MergeMaterials = new List <MyMwcObjectBuilder_VoxelMap_MergeMaterial>(countMergeMaterials.Value);
for (int i = 0; i < countMergeMaterials; i++)
{
MyMwcObjectBuilder_VoxelMap_MergeMaterial newMM = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_VoxelMap_MergeMaterial;
if (newMM == null)
{
return(NetworkError());
}
if (newMM.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
MergeMaterials.Add(newMM);
}
// Voxel Hand Shapes
int?countVoxelHandShapes = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (countVoxelHandShapes == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("countVoxelHandShapes: " + countVoxelHandShapes);
VoxelHandShapes = new List <MyMwcObjectBuilder_VoxelHand_Shape>(countVoxelHandShapes.Value);
for (int i = 0; i < countVoxelHandShapes; i++)
{
MyMwcObjectBuilder_VoxelHand_Shape voxelHandShape = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_VoxelHand_Shape;
if (voxelHandShape == null)
{
return(NetworkError());
}
if (voxelHandShape.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
VoxelHandShapes.Add(voxelHandShape);
}
int?dataLength = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (!dataLength.HasValue)
{
return(NetworkError());
}
if (dataLength.Value > 0)
{
VoxelData = new byte[dataLength.Value];
for (int i = 0; i < dataLength.Value; i++)
{
byte?b = MyMwcMessageIn.ReadByteEx(binaryReader, senderEndPoint);
if (!b.HasValue)
{
return(NetworkError());
}
VoxelData[i] = b.Value;
}
}
return(true);
}
