// 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());
}
// Ship Type
MyMwcObjectBuilder_SmallDebris_TypesEnum?debrisType = MyMwcMessageIn.ReadObjectBuilderSmallDebrisTypesEnumEx(binaryReader, senderEndPoint);
if (debrisType == null)
{
return(NetworkError());
}
DebrisType = debrisType.Value;
MyMwcLog.IfNetVerbose_AddToLog("DebrisType: " + DebrisType);
//Immovable
bool?immovable = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (immovable == null)
{
return(NetworkError());
}
Immovable = immovable.Value;
MyMwcLog.IfNetVerbose_AddToLog("Immovable: " + Immovable);
return(true);
}
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);
}
// 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());
}
// Use Type
int?useType = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (useType == null)
{
return(NetworkError());
}
UseType = useType.Value;
MyMwcLog.IfNetVerbose_AddToLog("UseType: " + UseType);
// Hack Type
int?hackType = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (hackType == null)
{
return(NetworkError());
}
HackType = hackType.Value;
MyMwcLog.IfNetVerbose_AddToLog("HackType: " + HackType);
// Hacking Level
int?hackingLevel = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (hackingLevel == null)
{
return(NetworkError());
}
HackingLevel = hackingLevel.Value;
MyMwcLog.IfNetVerbose_AddToLog("HackingLevel: " + HackingLevel);
// Hacking Time
int?hackingTime = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (hackingTime == null)
{
return(NetworkError());
}
HackingTime = hackingTime.Value;
MyMwcLog.IfNetVerbose_AddToLog("HackingTime: " + HackingTime);
// Is Hacked
bool?isHacked = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (isHacked == null)
{
return(NetworkError());
}
IsHacked = isHacked.Value;
MyMwcLog.IfNetVerbose_AddToLog("IsHacked: " + IsHacked);
return(true);
}
internal override bool Read(BinaryReader binaryReader, EndPoint senderEndPoint, int gameVersion)
{
if (!base.Read(binaryReader, senderEndPoint, gameVersion))
{
return(NetworkError());
}
// ObjectList
int?countLinks = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (countLinks == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("countLinks: " + countLinks);
Links = new List <LinkElement>(countLinks.Value);
for (int i = 0; i < countLinks; i++)
{
int?entityId = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (entityId == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog(string.Format("Links[{0}].EntityId: {1}", i, entityId));
short?index = MyMwcMessageIn.ReadInt16Ex(binaryReader, senderEndPoint);
if (index == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog(string.Format("Links[{0}].Index: {1}", i, index));
bool?hasSnapPointName = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!hasSnapPointName.HasValue)
{
return(NetworkError());
}
if (hasSnapPointName.Value)
{
string snapPointName = MyMwcMessageIn.ReadStringEx(binaryReader, senderEndPoint);
if (snapPointName == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog(string.Format("Links[{0}].SnapPointName: {1}", i, snapPointName));
Links.Add(new LinkElement((uint)entityId.Value, index.Value, snapPointName));
}
else
{
MyMwcLog.IfNetVerbose_AddToLog("Links[{0}].SnapPointName: null");
Links.Add(new LinkElement((uint)entityId.Value, index.Value, 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());
}
// Inventory
bool?isInventory = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (isInventory == null)
{
return(NetworkError());
}
if (isInventory.Value)
{
Inventory = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_Inventory;
if (Inventory == null)
{
return(NetworkError());
}
if (Inventory.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
}
else
{
Inventory = null;
}
Faction = (MyMwcObjectBuilder_FactionEnum)MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
bool?hasDisplayName = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!hasDisplayName.HasValue)
{
return(NetworkError());
}
if (hasDisplayName.Value)
{
string displayName = MyMwcMessageIn.ReadStringEx(binaryReader, senderEndPoint);
if (displayName == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("DisplayName: " + displayName);
DisplayName = displayName;
}
else
{
MyMwcLog.IfNetVerbose_AddToLog("DisplayName: " + "null");
DisplayName = 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());
}
// Amount
float?amount = MyMwcMessageIn.ReadFloat(binaryReader);
if (amount == null)
{
return(NetworkError());
}
Amount = amount.Value;
MyMwcLog.IfNetVerbose_AddToLog("Amount: " + Amount);
if (float.IsNaN(Amount) || float.IsInfinity(Amount))
{
System.Diagnostics.Debug.Fail("Amount is: " + Amount);
Amount = DEFAULT_AMOUNT;
}
// Object builder
bool?isObjectBuilder = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (isObjectBuilder == null)
{
return(NetworkError());
}
if (isObjectBuilder.Value)
{
ObjectBuilder = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint);
if (ObjectBuilder == null)
{
return(NetworkError());
}
if (ObjectBuilder.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
}
else
{
ObjectBuilder = 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());
}
// 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);
}
// 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());
}
MyMwcPositionAndOrientation?objectPositionAndOrientation = MyMwcMessageIn.ReadPositionAndOrientationEx(binaryReader, senderEndPoint);
if (objectPositionAndOrientation == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("objectPositionAndOrientation: " + objectPositionAndOrientation.ToString());
PositionAndOrientation = objectPositionAndOrientation.Value;
MyMwcVoxelHandModeTypeEnum?voxelHandModeType = MyMwcMessageIn.ReadVoxelHandModeTypeEnumEx(binaryReader, senderEndPoint);
if (voxelHandModeType == null)
{
return(NetworkError());
}
VoxelHandModeType = voxelHandModeType.Value;
MyMwcLog.IfNetVerbose_AddToLog("VoxelHandModeType: " + VoxelHandModeType.ToString());
bool?isVoxelMaterial = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (isVoxelMaterial == null)
{
return(NetworkError());
}
if (isVoxelMaterial.Value)
{
VoxelHandMaterial = MyMwcMessageIn.ReadVoxelMaterialsEnumEx(binaryReader, senderEndPoint);
}
else
{
VoxelHandMaterial = 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());
}
// Amount
float?amount = MyMwcMessageIn.ReadFloat(binaryReader);
if (amount == null)
{
return(NetworkError());
}
Amount = amount.Value;
MyMwcLog.IfNetVerbose_AddToLog("Amount: " + Amount);
// Item's objectbuilder
bool?isItemObjectBuilder = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (isItemObjectBuilder == null)
{
return(NetworkError());
}
if (isItemObjectBuilder.Value)
{
ItemObjectBuilder = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_Base;
if (ItemObjectBuilder == null)
{
return(NetworkError());
}
if (ItemObjectBuilder.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
}
else
{
ItemObjectBuilder = null;
}
return(true);
}
internal override bool Read(System.IO.BinaryReader binaryReader, System.Net.EndPoint senderEndPoint, int gameVersion)
{
if (base.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
// Direction
Vector3?direction = MyMwcMessageIn.ReadVector3FloatEx(binaryReader, senderEndPoint);
if (direction == null)
{
return(NetworkError());
}
Direction = direction.Value;
MyMwcLog.IfNetVerbose_AddToLog("Direction: " + Direction);
// Effect ID
bool?hasId = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!hasId.HasValue)
{
return(NetworkError()); // Cannot read bool
}
MyMwcLog.IfNetVerbose_AddToLog("MyMwcObjectBuilder_Meteor.EffectID.HasValue: " + hasId.Value);
// Testing whether Effect ID is null
if (hasId.Value)
{
// effect id has value - read the value
EffectID = MyMwcMessageIn.ReadInt16(binaryReader);
MyMwcLog.IfNetVerbose_AddToLog("MyMwcObjectBuilder_Meteor.EffectID.Value: " + EffectID.Value);
}
else
{
this.EffectID = null;
}
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);
}
internal override bool Read(BinaryReader binaryReader, EndPoint senderEndPoint, int gameVersion)
{
if (!base.Read(binaryReader, senderEndPoint, gameVersion))
{
return(NetworkError());
}
// ID
int?id = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (id == null)
{
return(NetworkError());
}
ID = id.Value;
MyMwcLog.IfNetVerbose_AddToLog("ID: " + ID);
// Name
bool?hasName = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!hasName.HasValue)
{
return(NetworkError());
}
if (hasName.Value)
{
string name = MyMwcMessageIn.ReadStringEx(binaryReader, senderEndPoint);
if (name == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("Name: " + Name);
Name = name;
}
else
{
MyMwcLog.IfNetVerbose_AddToLog("Name: " + "null");
Name = null;
}
// Builder
bool?hasBuilder = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (hasBuilder == null)
{
return(NetworkError());
}
if (hasBuilder.Value)
{
Builder = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_SmallShip;
if (Builder == null)
{
return(NetworkError());
}
if (Builder.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
}
else
{
Builder = 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());
}
// Is building
bool?isBuilding = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (isBuilding == null)
{
return(NetworkError());
}
IsBuilding = isBuilding.Value;
MyMwcLog.IfNetVerbose_AddToLog("IsBuilding: " + IsBuilding);
// Building time from start
int?buildingTimeFromStart = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (buildingTimeFromStart == null)
{
return(NetworkError());
}
BuildingTimeFromStart = buildingTimeFromStart.Value;
MyMwcLog.IfNetVerbose_AddToLog("BuildingTimeFromStart: " + BuildingTimeFromStart);
// Prefab container
bool?isPrefabContainer = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (isPrefabContainer == null)
{
return(NetworkError());
}
if (isPrefabContainer.Value)
{
PrefabContainer = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_PrefabContainer;
if (PrefabContainer == null)
{
return(NetworkError());
}
if (PrefabContainer.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
}
else
{
PrefabContainer = null;
}
// Building queue
int?countBuildingQueueObjects = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (countBuildingQueueObjects == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("CountBuildingQueueObjects: " + countBuildingQueueObjects);
BuildingQueue = new List <MyMwcObjectBuilder_ObjectToBuild>(countBuildingQueueObjects.Value);
for (int i = 0; i < countBuildingQueueObjects; i++)
{
MyMwcObjectBuilder_ObjectToBuild objectToBuild = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_ObjectToBuild;
if (objectToBuild == null)
{
return(NetworkError());
}
if (objectToBuild.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
BuildingQueue.Add(objectToBuild);
}
// Building object
bool?isBuildingObject = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (isBuildingObject == null)
{
return(NetworkError());
}
if (isBuildingObject.Value)
{
BuildingObject = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_ObjectToBuild;
if (BuildingObject == null)
{
return(NetworkError());
}
if (BuildingObject.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
}
else
{
BuildingObject = 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());
}
// TODO: remove
Color?dustColor = MyMwcMessageIn.ReadColorEx(binaryReader, senderEndPoint);
if (dustColor == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("dustColor: " + dustColor.ToString());
int?countSectorObjects = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (countSectorObjects == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("Sector object count: " + countSectorObjects);
SectorObjects = new List <MyMwcObjectBuilder_Base>(countSectorObjects.Value);
for (int i = 0; i < countSectorObjects; i++)
{
MyMwcObjectBuilder_Base sectorObject = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint);
if (sectorObject == null)
{
return(NetworkError());
}
if (sectorObject.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
SectorObjects.Add(sectorObject);
}
MyMwcLog.IfNetVerbose_AddToLog("Sector objects read");
// Read object groups
int?countObjectGroups = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (countObjectGroups == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("Object groups count: " + countObjectGroups);
ObjectGroups = new List <MyMwcObjectBuilder_ObjectGroup>();
for (int i = 0; i < countObjectGroups; i++)
{
MyMwcObjectBuilder_ObjectGroup objectGroup = MyMwcObjectBuilder_ObjectGroup.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_ObjectGroup;
if (objectGroup == null)
{
return(NetworkError());
}
if (objectGroup.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
ObjectGroups.Add(objectGroup);
}
MyMwcLog.IfNetVerbose_AddToLog("Object groups read");
// Read snap point links
int?countSnapPointLinks = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (countSnapPointLinks == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("Snap point links count: " + countSnapPointLinks);
SnapPointLinks = new List <MyMwcObjectBuilder_SnapPointLink>();
for (int i = 0; i < countSnapPointLinks; i++)
{
MyMwcObjectBuilder_SnapPointLink snapPointLink = MyMwcObjectBuilder_SnapPointLink.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_SnapPointLink;
if (snapPointLink == null)
{
return(NetworkError());
}
if (snapPointLink.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
SnapPointLinks.Add(snapPointLink);
}
MyMwcLog.IfNetVerbose_AddToLog("Snap point links read");
bool?fromGenerator = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!fromGenerator.HasValue)
{
return(NetworkError());
}
FromGenerator = fromGenerator.Value;
MyMwcLog.IfNetVerbose_AddToLog("From generator read: " + FromGenerator);
// Version
int?version = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (!version.HasValue)
{
return(NetworkError());
}
this.Version = version.Value;
var position = MyMwcMessageIn.ReadVector3IntEx(binaryReader, senderEndPoint);
if (!position.HasValue)
{
return(NetworkError());
}
Position = position.Value;
MyMwcLog.IfNetVerbose_AddToLog("Position: " + Position);
Dictionary = MyMessageHelper.ReadStringDictionary(binaryReader, senderEndPoint);
if (Dictionary == null)
{
return(NetworkError());
}
return(true);
}
internal override bool Read(System.IO.BinaryReader binaryReader, System.Net.EndPoint senderEndPoint, int gameVersion)
{
if (!base.Read(binaryReader, senderEndPoint, gameVersion))
{
return(NetworkError());
}
// Health
float?health = MyMwcMessageIn.ReadFloat(binaryReader);
if (health == null)
{
return(NetworkError());
}
Health = health.Value;
MyMwcLog.IfNetVerbose_AddToLog("Health: " + Health);
// Money
float?money = MyMwcMessageIn.ReadFloat(binaryReader);
if (money == null)
{
return(NetworkError());
}
Money = money.Value;
MyMwcLog.IfNetVerbose_AddToLog("Money: " + Money);
// Without oxygen
float?withoutOxygen = MyMwcMessageIn.ReadFloat(binaryReader);
if (withoutOxygen == null)
{
return(NetworkError());
}
WithoutOxygen = withoutOxygen.Value;
MyMwcLog.IfNetVerbose_AddToLog("WithoutOxygen: " + WithoutOxygen);
// Player statistic's objectbuilder
bool?isPlayerStatisticsObjectBuilder = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (isPlayerStatisticsObjectBuilder == null)
{
return(NetworkError());
}
if (isPlayerStatisticsObjectBuilder.Value)
{
PlayerStatisticsObjectBuilder = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_PlayerStatistics;
if (PlayerStatisticsObjectBuilder == null)
{
return(NetworkError());
}
if (PlayerStatisticsObjectBuilder.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
}
else
{
PlayerStatisticsObjectBuilder = null;
}
// Ship's objectbuilder
bool?isShipObjectBuilder = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (isShipObjectBuilder == null)
{
return(NetworkError());
}
if (isShipObjectBuilder.Value)
{
ShipObjectBuilder = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_SmallShip;
if (ShipObjectBuilder == null)
{
return(NetworkError());
}
if (ShipObjectBuilder.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
}
else
{
ShipObjectBuilder = null;
}
// ShipConfig's objectbuilder
bool?isShipConfigObjectBuilder = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (isShipConfigObjectBuilder == null)
{
return(NetworkError());
}
if (isShipConfigObjectBuilder.Value)
{
ShipConfigObjectBuilder = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_ShipConfig;
if (ShipConfigObjectBuilder == null)
{
return(NetworkError());
}
if (ShipConfigObjectBuilder.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
}
else
{
ShipConfigObjectBuilder = 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());
}
// Inventory items
int?countInventoryItems = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (countInventoryItems == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("countInventoryItems: " + countInventoryItems);
InventoryItems = new List <MyMwcObjectBuilder_InventoryItem>(countInventoryItems.Value);
for (int i = 0; i < countInventoryItems; i++)
{
MyMwcObjectBuilder_InventoryItem inventoryItem = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_InventoryItem;
if (inventoryItem == null)
{
return(NetworkError());
}
if (inventoryItem.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
if (!MyMwcObjectBuilder_InventoryItem.IsDisabled(inventoryItem))
{
InventoryItems.Add(inventoryItem);
}
}
// Max items
int?maxItems = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (maxItems == null)
{
return(NetworkError());
}
MaxItems = maxItems.Value;
MyMwcLog.IfNetVerbose_AddToLog("MaxItems: " + MaxItems);
// Price coeficient
bool?hasPriceCoeficient = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!hasPriceCoeficient.HasValue)
{
return(NetworkError());
}
if (hasPriceCoeficient.Value)
{
float?priceCoeficient = MyMwcMessageIn.ReadFloat(binaryReader);
if (priceCoeficient == null)
{
return(NetworkError());
}
PriceCoeficient = priceCoeficient.Value;
MyMwcLog.IfNetVerbose_AddToLog("PriceCoeficient: " + PriceCoeficient.Value);
}
else
{
MyMwcLog.IfNetVerbose_AddToLog("PriceCoeficient is: null");
PriceCoeficient = null;
}
// Inventory template type
bool?hasInventoryTemplateType = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!hasInventoryTemplateType.HasValue)
{
return(NetworkError());
}
if (hasInventoryTemplateType.Value)
{
MyMwcInventoryTemplateTypeEnum?inventoryTemplateType = MyMwcMessageIn.ReadObjectBuilderInventoryTemplateTypesEnumEx(binaryReader, senderEndPoint);
if (inventoryTemplateType == null)
{
return(NetworkError());
}
TemplateType = inventoryTemplateType.Value;
MyMwcLog.IfNetVerbose_AddToLog("TemplateType: " + TemplateType.Value);
}
else
{
MyMwcLog.IfNetVerbose_AddToLog("TemplateType is: null");
TemplateType = null;
}
// Unlimited capacity
bool?unlimitedCapacity = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (unlimitedCapacity == null)
{
return(NetworkError());
}
UnlimitedCapacity = unlimitedCapacity.Value;
MyMwcLog.IfNetVerbose_AddToLog("UnlimitedCapacity: " + UnlimitedCapacity);
return(true);
}
private bool Read_01085000(BinaryReader binaryReader, EndPoint senderEndPoint, int gameVersion)
{
// PrefabType
int?prefabObjectBuilderId = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (prefabObjectBuilderId == null)
{
return(NetworkError());
}
PrefabObjectBuilderId = prefabObjectBuilderId.Value;
MyMwcLog.IfNetVerbose_AddToLog("PrefabObjectBuilderId: " + PrefabObjectBuilderId);
// PositionInContainer
MyMwcVector3Short?positionInContainer = MyMwcMessageIn.ReadVector3ShortEx(binaryReader, senderEndPoint);
if (positionInContainer == null)
{
return(NetworkError());
}
PositionInContainer = positionInContainer.Value;
MyMwcLog.IfNetVerbose_AddToLog("PositionInContainer: " + PositionInContainer);
// AnglesInContainer
Vector3?anglesInContainer = MyMwcMessageIn.ReadVector3FloatEx(binaryReader, senderEndPoint);
if (anglesInContainer == null)
{
return(NetworkError());
}
AnglesInContainer = anglesInContainer.Value;
MyMwcLog.IfNetVerbose_AddToLog("AnglesInContainer: " + AnglesInContainer.ToString());
bool?hasMaxHealth = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!hasMaxHealth.HasValue)
{
return(NetworkError());
}
if (hasMaxHealth.Value)
{
// PrefabMaxHealth
float?prefabMaxHealth = MyMwcMessageIn.ReadFloat(binaryReader);
if (prefabMaxHealth == null)
{
return(NetworkError());
}
PrefabMaxHealth = prefabMaxHealth.Value;
MyMwcLog.IfNetVerbose_AddToLog("PrefabMaxHealth: " + PrefabMaxHealth.Value.ToString());
if (float.IsNaN(PrefabMaxHealth.Value) || float.IsInfinity(PrefabMaxHealth.Value))
{
System.Diagnostics.Debug.Fail("PrefabMaxHealth is: " + PrefabMaxHealth.Value);
PrefabMaxHealth = null; // MyGameplayConstants.MAX_HEALTH_MAX;
}
}
else
{
MyMwcLog.IfNetVerbose_AddToLog("PrefabMaxHealth is: null");
PrefabMaxHealth = null;
}
// PrefabHealthRatio
float?prefabHealthRatio = MyMwcMessageIn.ReadFloat(binaryReader);
if (prefabHealthRatio == null)
{
return(NetworkError());
}
PrefabHealthRatio = prefabHealthRatio.Value;
MyMwcLog.IfNetVerbose_AddToLog("PrefabHealth: " + PrefabHealthRatio.ToString());
bool?hasDisplayName = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!hasDisplayName.HasValue)
{
return(NetworkError());
}
if (hasDisplayName.Value)
{
string displayName = MyMwcMessageIn.ReadStringEx(binaryReader, senderEndPoint);
if (displayName == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("DisplayName: " + displayName);
DisplayName = displayName;
}
else
{
MyMwcLog.IfNetVerbose_AddToLog("DisplayName: " + "null");
DisplayName = null;
}
// faction appearance (texture set)
short?factionAppearance = MyMwcMessageIn.ReadInt16Ex(binaryReader, senderEndPoint);
if (!factionAppearance.HasValue)
{
return(NetworkError());
}
FactionAppearance = (MyMwcObjectBuilder_Prefab_AppearanceEnum)factionAppearance.Value;
MyMwcLog.IfNetVerbose_AddToLog("FactionAppearance: " + FactionAppearance);
// Use Properties
bool?hasUseProperties = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (hasUseProperties == null)
{
return(NetworkError());
}
if (hasUseProperties.Value)
{
UseProperties =
MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as
MyMwcObjectBuilder_EntityUseProperties;
if (UseProperties == null)
{
return(NetworkError());
}
if (UseProperties.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
}
else
{
UseProperties = null;
}
// Causes Alarm
bool?hasCausesAlarm = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!hasCausesAlarm.HasValue)
{
return(NetworkError());
}
if (hasCausesAlarm.Value)
{
bool?causesAlarm = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!causesAlarm.HasValue)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("CausesAlarm: " + CausesAlarm);
CausesAlarm = causesAlarm.Value;
}
else
{
MyMwcLog.IfNetVerbose_AddToLog("CausesAlarm: " + "null");
CausesAlarm = null;
}
// Requires Energy
bool?hasRequiresEnergy = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!hasRequiresEnergy.HasValue)
{
return(NetworkError());
}
if (hasRequiresEnergy.Value)
{
bool?requiresEnergy = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!requiresEnergy.HasValue)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("RequiresEnergy: " + RequiresEnergy);
RequiresEnergy = requiresEnergy.Value;
}
else
{
MyMwcLog.IfNetVerbose_AddToLog("RequiresEnergy: " + "null");
RequiresEnergy = null;
}
// Display HUD
bool?hasDisplayHud = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!hasDisplayHud.HasValue)
{
return(NetworkError());
}
if (hasDisplayHud.Value)
{
bool?displayHud = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!displayHud.HasValue)
{
return(NetworkError());
}
if (displayHud.Value)
{
PersistentFlags |= MyPersistentEntityFlags.DisplayOnHud;
}
else
{
PersistentFlags &= ~MyPersistentEntityFlags.DisplayOnHud;
}
MyMwcLog.IfNetVerbose_AddToLog("DisplayHud: " + displayHud.Value);
}
else
{
MyMwcLog.IfNetVerbose_AddToLog("DisplayHud: " + "null");
}
// AI Priority
int?aiPriority = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (aiPriority == null)
{
return(NetworkError());
}
AIPriority = aiPriority.Value;
MyMwcLog.IfNetVerbose_AddToLog("AIPriority: " + AIPriority);
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());
}
// Prefab parts healths and max healths
for (int i = 0; i < MAX_KINEMATIC_PARTS; i++)
{
bool?hasPrefabHealth = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!hasPrefabHealth.HasValue)
{
return(NetworkError());
}
if (hasPrefabHealth.Value)
{
float prefabHealth = MyMwcMessageIn.ReadFloat(binaryReader);
if (prefabHealth == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("PrefabHealth" + (i + 1) + ": " + prefabHealth);
KinematicPartsHealth[i] = prefabHealth;
}
else
{
MyMwcLog.IfNetVerbose_AddToLog("PrefabHealth" + (i + 1) + ": " + "null");
KinematicPartsHealth[i] = null;
}
bool?hasPrefabMaxHealth = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!hasPrefabMaxHealth.HasValue)
{
return(NetworkError());
}
if (hasPrefabMaxHealth.Value)
{
float prefabMaxHealth = MyMwcMessageIn.ReadFloat(binaryReader);
if (prefabMaxHealth == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("PrefabMaxHealth" + (i + 1) + ": " + prefabMaxHealth);
KinematicPartsMaxHealth[i] = prefabMaxHealth;
}
else
{
MyMwcLog.IfNetVerbose_AddToLog("PrefabMaxHealth" + (i + 1) + ": " + "null");
KinematicPartsMaxHealth[i] = null;
}
bool?hasEntityId = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!hasEntityId.HasValue)
{
return(NetworkError());
}
if (hasEntityId.Value)
{
uint?entityId = MyMwcMessageIn.ReadUInt32Ex(binaryReader, senderEndPoint);
if (entityId == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("EntityId" + (i + 1) + ": " + entityId);
KinematicPartsEntityId[i] = entityId;
}
else
{
MyMwcLog.IfNetVerbose_AddToLog("EntityId" + (i + 1) + ": " + "null");
KinematicPartsEntityId[i] = null;
}
}
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);
}
// 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);
}
internal override bool Read(System.IO.BinaryReader binaryReader, System.Net.EndPoint senderEndPoint, int gameVersion)
{
if (!base.Read(binaryReader, senderEndPoint, gameVersion))
{
return(NetworkError());
}
// Sector ob
bool?sectorBuilderExists = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!sectorBuilderExists.HasValue)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("Sector exists " + (SectorObjectBuilder != null));
if (sectorBuilderExists.Value)
{
SectorObjectBuilder = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_Sector;
if (SectorObjectBuilder == null || !SectorObjectBuilder.Read(binaryReader, senderEndPoint, gameVersion))
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("Sector read");
}
// Gametime
DateTime?dateTime = MyMwcMessageIn.ReadDateTimeEx(binaryReader, senderEndPoint);
if (!dateTime.HasValue)
{
return(NetworkError());
}
this.GameTime = dateTime.Value;
MyMwcLog.IfNetVerbose_AddToLog("Gametime: " + this.GameTime);
// Player ob
bool?playerBuilderExists = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!playerBuilderExists.HasValue)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("Player exists " + (PlayerObjectBuilder != null));
if (playerBuilderExists.Value)
{
PlayerObjectBuilder = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_Player;
if (PlayerObjectBuilder == null || !PlayerObjectBuilder.Read(binaryReader, senderEndPoint, gameVersion))
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("Player read");
}
// Session ob
bool?sessionBuilderExists = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!sessionBuilderExists.HasValue)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("Session exists " + (SessionObjectBuilder != null));
if (sessionBuilderExists.Value)
{
SessionObjectBuilder = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_Session;
if (SessionObjectBuilder == null || !SessionObjectBuilder.Read(binaryReader, senderEndPoint, gameVersion))
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("Session read");
}
// Active mission
int?activeMissionID = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (!activeMissionID.HasValue)
{
return(NetworkError());
}
this.ActiveMissionID = activeMissionID.Value;
MyMwcLog.IfNetVerbose_AddToLog("Active Mission ID: " + this.ActiveMissionID);
// Events
int?countEvents = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (countEvents == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("Count Events: " + countEvents);
EventLogObjectBuilder = new List <MyMwcObjectBuilder_Event>(countEvents.Value);
for (int i = 0; i < countEvents; i++)
{
var eventItem = ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_Event;
if (eventItem == null)
{
return(NetworkError());
}
if (eventItem.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
EventLogObjectBuilder.Add(eventItem);
}
// Faction relation changes
int?countFactionRelationChanges = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (countFactionRelationChanges == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("Factoin Relation Changes: " + countFactionRelationChanges);
FactionRelationChangesBuilder = new List <MyMwcObjectBuilder_FactionRelationChange>(countFactionRelationChanges.Value);
for (int i = 0; i < countFactionRelationChanges; i++)
{
var factionRelationChangeItem = ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_FactionRelationChange;
if (factionRelationChangeItem == null)
{
return(NetworkError());
}
if (factionRelationChangeItem.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
FactionRelationChangesBuilder.Add(factionRelationChangeItem);
}
// Inventory
bool?inventoryBuilderExists = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!inventoryBuilderExists.HasValue)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("Inventory exists " + (InventoryObjectBuilder != null));
if (inventoryBuilderExists.Value)
{
InventoryObjectBuilder = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_Inventory;
if (InventoryObjectBuilder == null || !InventoryObjectBuilder.Read(binaryReader, senderEndPoint, gameVersion))
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("Inventory read");
}
// Current sector identifier
MyMwcSectorIdentifier?currentSector = MyMwcMessageIn.ReadSectorIdentifierEx(binaryReader, senderEndPoint);
if (!currentSector.HasValue)
{
return(NetworkError());
}
this.CurrentSector = currentSector.Value;
// Checkpoint name
bool?hasName = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!hasName.HasValue)
{
return(NetworkError());
}
if (hasName.Value)
{
CheckpointName = MyMwcMessageIn.ReadStringEx(binaryReader, senderEndPoint);
if (CheckpointName == null)
{
return(NetworkError()); // Has name set and name null? That's can't happen
}
}
else
{
CheckpointName = null;
}
Dictionary = MyMessageHelper.ReadStringDictionary(binaryReader, senderEndPoint);
if (Dictionary == null)
{
return(NetworkError());
}
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());
}
// TemplateId
bool?isTemplateId = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (isTemplateId == null)
{
return(NetworkError());
}
if (isTemplateId.Value)
{
TemplateId = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
}
else
{
TemplateId = null;
}
// Container Type
MyMwcObjectBuilder_PrefabContainer_TypesEnum?containerType = MyMwcMessageIn.ReadObjectBuilderPrefabContainerTypesEnumEx(binaryReader, senderEndPoint);
if (containerType == null)
{
return(NetworkError());
}
ContainerType = containerType.Value;
MyMwcLog.IfNetVerbose_AddToLog("ContainerType: " + ContainerType);
// Faction
Faction = (MyMwcObjectBuilder_FactionEnum)MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
// Faction must be defined
System.Diagnostics.Debug.Assert(Enum.IsDefined(typeof(MyMwcObjectBuilder_FactionEnum), Faction));
// Prefabs
int?countPrefabs = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (countPrefabs == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("countPrefabs: " + countPrefabs);
Prefabs = new List <MyMwcObjectBuilder_PrefabBase>(countPrefabs.Value);
for (int i = 0; i < countPrefabs; i++)
{
MyMwcObjectBuilder_PrefabBase prefab = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_PrefabBase;
if (prefab == null)
{
return(NetworkError());
}
if (prefab.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
Prefabs.Add(prefab);
}
// Inventory
bool?isInventory = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (isInventory == null)
{
return(NetworkError());
}
if (isInventory.Value)
{
Inventory = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_Inventory;
if (Inventory == null)
{
return(NetworkError());
}
if (Inventory.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
}
else
{
Inventory = null;
}
bool?hasDisplayName = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (!hasDisplayName.HasValue)
{
return(NetworkError());
}
if (hasDisplayName.Value)
{
string displayName = MyMwcMessageIn.ReadStringEx(binaryReader, senderEndPoint);
if (displayName == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("DisplayName: " + displayName);
DisplayName = displayName;
}
else
{
MyMwcLog.IfNetVerbose_AddToLog("DisplayName: " + "null");
DisplayName = null;
}
// Use Properties
bool?hasUseProperties = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (hasUseProperties == null)
{
return(NetworkError());
}
if (hasUseProperties.Value)
{
UseProperties = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_EntityUseProperties;
if (UseProperties == null)
{
return(NetworkError());
}
if (UseProperties.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
}
else
{
UseProperties = null;
}
// Alarm On
bool?alarmOn = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (alarmOn == null)
{
return(NetworkError());
}
AlarmOn = alarmOn.Value;
MyMwcLog.IfNetVerbose_AddToLog("AlarmOn: " + AlarmOn);
// Refill time
bool?refillTime = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (refillTime == null)
{
return(NetworkError());
}
if (refillTime.Value)
{
RefillTime = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
}
else
{
RefillTime = null;
}
return(true);
}
internal override bool Read(BinaryReader binaryReader, EndPoint senderEndPoint, int gameVersion)
{
if (base.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
bool?hasParent = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint); if (!hasParent.HasValue)
{
return(NetworkError());
}
ParentEntityId = null;
if (hasParent.Value)
{
int?id = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint); if (!id.HasValue)
{
return(NetworkError());
}
ParentEntityId = id.Value;
MyMwcLog.IfNetVerbose_AddToLog("Waypoint parent id: " + ParentEntityId.Value.ToString());
}
int?nCount = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint); if (!nCount.HasValue)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("Neighbor count: " + nCount.Value.ToString());
NeighborEntityIds = new List <int>();
for (int i = 0; i < nCount.Value; i++)
{
int?index = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint); if (!index.HasValue)
{
return(NetworkError());
}
NeighborEntityIds.Add(index.Value);
}
int?gCount = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint); if (!nCount.HasValue)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("Group count: " + gCount.Value.ToString());
GroupNames = new List <string>();
GroupPlacings = new List <int>();
for (int i = 0; i < gCount.Value; i++)
{
string name = MyMwcMessageIn.ReadStringEx(binaryReader, senderEndPoint); if (name == null)
{
return(NetworkError());
}
GroupNames.Add(name);
int?placing = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint); if (!placing.HasValue)
{
return(NetworkError());
}
GroupPlacings.Add(placing.Value);
}
return(true);
}
