public static Dictionary <string, string> ReadStringDictionary(BinaryReader binaryReader, EndPoint senderEndpoint)
{
int?count = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndpoint);
if (!count.HasValue)
{
return(null);
}
var result = new Dictionary <string, string>();
for (int i = 0; i < count; i++)
{
string key = MyMwcMessageIn.ReadStringEx(binaryReader, senderEndpoint);
if (key == null)
{
return(null);
}
string value;
if (!MyMwcMessageIn.ReadNullableStringEx(binaryReader, senderEndpoint, out value))
{
return(null);
}
result.Add(key, value);
}
return(result);
}
// 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());
}
// Entity Detector Type
MyMwcObjectBuilder_EntityDetector_TypesEnum?entityDetectorType = MyMwcMessageIn.ReadObjectBuilderEntityDetectorTypesEnumEx(binaryReader, senderEndPoint);
if (entityDetectorType == null)
{
return(NetworkError());
}
EntityDetectorType = entityDetectorType.Value;
MyMwcLog.IfNetVerbose_AddToLog("EntityDetectorType: " + EntityDetectorType);
// Size
Vector3?size = MyMwcMessageIn.ReadVector3FloatEx(binaryReader, senderEndPoint);
if (size == null)
{
return(NetworkError());
}
Size = size.Value;
MyMwcLog.IfNetVerbose_AddToLog("Size: " + Size.ToString());
return(true);
}
internal override bool Read(BinaryReader binaryReader, EndPoint senderEndPoint, int gameVersion)
{
if (!base.Read(binaryReader, senderEndPoint, gameVersion))
{
return(NetworkError());
}
// Small ship templates
int?countTemplates = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (countTemplates == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("countTemplates: " + countTemplates);
SmallShipTemplates = new List <MyMwcObjectBuilder_SmallShipTemplate>(countTemplates.Value);
for (int i = 0; i < countTemplates; i++)
{
MyMwcObjectBuilder_SmallShipTemplate templateBuilder = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_SmallShipTemplate;
if (templateBuilder == null)
{
return(NetworkError());
}
if (templateBuilder.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
SmallShipTemplates.Add(templateBuilder);
}
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());
}
// Aiming distance
float?aimingDistance = MyMwcMessageIn.ReadFloat(binaryReader);
if (aimingDistance == null)
{
return(NetworkError());
}
AimingDistance = aimingDistance.Value;
MyMwcLog.IfNetVerbose_AddToLog("AimingDistance: " + AimingDistance);
// Searching distance
float?searchingDistance = MyMwcMessageIn.ReadFloat(binaryReader);
if (searchingDistance == null)
{
return(NetworkError());
}
SearchingDistance = searchingDistance.Value;
MyMwcLog.IfNetVerbose_AddToLog("SearchingDistance: " + SearchingDistance);
return(true);
}
internal override bool Read(BinaryReader binaryReader, EndPoint senderEndPoint, int gameVersion)
{
if (!base.Read(binaryReader, senderEndPoint, gameVersion))
{
return(NetworkError());
}
// ObjectList
int?countObjectList = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (countObjectList == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("countObjectList: " + countObjectList);
ObjectList = new List <uint>(countObjectList.Value);
for (int i = 0; i < countObjectList; i++)
{
int?objectId = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (objectId == null)
{
return(NetworkError());
}
ObjectList.Add((uint)objectId.Value);
MyMwcLog.IfNetVerbose_AddToLog(string.Format("ObjectList[{0}]: {1}", i, objectId));
}
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());
}
int?amount = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (amount == null)
{
return(NetworkError());
}
Amount = amount.Value;
MyMwcLog.IfNetVerbose_AddToLog("Amount: " + Amount);
// Ammo Type
MyMwcObjectBuilder_LargeShip_Ammo_TypesEnum?ammoType = MyMwcMessageIn.ReadObjectBuilderLargeShipAmmoTypesEnumEx(binaryReader, senderEndPoint);
if (ammoType == null)
{
return(NetworkError());
}
AmmoType = ammoType.Value;
MyMwcLog.IfNetVerbose_AddToLog("AmmoType: " + AmmoType);
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());
}
// Connected entities
int?countConnectedEntitiesObjects = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (countConnectedEntitiesObjects == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("CountConnectedEntities: " + countConnectedEntitiesObjects);
ConnectedEntities = new List <uint>(countConnectedEntitiesObjects.Value);
for (int i = 0; i < countConnectedEntitiesObjects; i++)
{
// conected entity id id has value - read the value
uint?conecteEntityId = MyMwcMessageIn.ReadUInt32Ex(binaryReader, senderEndPoint);
if (!conecteEntityId.HasValue)
{
return(NetworkError());
}
ConnectedEntities.Add(conecteEntityId.Value);
}
return(true);
}
internal override bool Read(BinaryReader binaryReader, EndPoint senderEndPoint, int gameVersion)
{
if (!base.Read(binaryReader, senderEndPoint, gameVersion))
{
return(NetworkError());
}
int?faction1 = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (!faction1.HasValue)
{
return(NetworkError());
}
Faction1 = (MyMwcObjectBuilder_FactionEnum)faction1.Value;
int?faction2 = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (!faction2.HasValue)
{
return(NetworkError());
}
Faction2 = (MyMwcObjectBuilder_FactionEnum)faction2.Value;
float?relation = MyMwcMessageIn.ReadFloat(binaryReader);
if (!relation.HasValue)
{
return(NetworkError());
}
Relation = relation.Value;
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());
}
// 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);
}
// 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);
}
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());
}
FactionIndex = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint).Value;
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);
}
public static MyVoxelTriangle?ReadVoxelTriangleEx(BinaryReader binaryReader, EndPoint senderEndPoint)
{
try
{
MyVoxelTriangle result;
result.VertexIndex0 = MyMwcMessageIn.ReadInt16(binaryReader);
result.VertexIndex1 = MyMwcMessageIn.ReadInt16(binaryReader);
result.VertexIndex2 = MyMwcMessageIn.ReadInt16(binaryReader);
return(result);
}
catch (Exception)
{
return(null);
}
}
// 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());
}
// Color
Color?color = MyMwcMessageIn.ReadColorEx(binaryReader, senderEndPoint);
if (color == null)
{
return(NetworkError());
}
Color = color.Value;
MyMwcLog.IfNetVerbose_AddToLog("Color: " + Color);
// Size
Vector3?size = MyMwcMessageIn.ReadVector3FloatEx(binaryReader, senderEndPoint);
if (size == null)
{
return(NetworkError());
}
Size = size.Value;
MyMwcLog.IfNetVerbose_AddToLog("Size: " + Size);
// Scanning speed
float?scanningSpeed = MyMwcMessageIn.ReadFloat(binaryReader);
if (scanningSpeed == null)
{
return(NetworkError());
}
ScanningSpeed = scanningSpeed.Value;
MyMwcLog.IfNetVerbose_AddToLog("ScanningSpeed: " + ScanningSpeed);
//// On
//bool? on = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
//if (on == null) return NetworkError();
//On = on.Value;
//MyMwcLog.IfNetVerbose_AddToLog("On: " + On);
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());
}
MyMwcVector3Sbyte?relativeSectorPosition = MyMwcMessageIn.ReadVector3SbyteEx(binaryReader, senderEndPoint);
if (relativeSectorPosition == null)
{
return(NetworkError());
}
RelativeSectorPosition = relativeSectorPosition.Value;
MyMwcLog.IfNetVerbose_AddToLog("RelativeSectorPosition: " + RelativeSectorPosition.ToString());
MyMwcVector3Short?voxelMapPositionInVoxelCoords = MyMwcMessageIn.ReadVector3ShortEx(binaryReader, senderEndPoint);
if (voxelMapPositionInVoxelCoords == null)
{
return(NetworkError());
}
VoxelMapPositionInVoxelCoords = voxelMapPositionInVoxelCoords.Value;
MyMwcLog.IfNetVerbose_AddToLog("VoxelMapPositionInVoxelCoords: " + VoxelMapPositionInVoxelCoords.ToString());
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());
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);
}
private bool ReadLesserThan01087004(BinaryReader binaryReader, EndPoint senderEndPoint, int gameVersion)
{
if (base.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
float?size = MyMwcMessageIn.ReadFloat(binaryReader);
if (size == null)
{
return(NetworkError());
}
Size = size.Value;
MyMwcLog.IfNetVerbose_AddToLog("Size: " + Size.ToString());
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());
}
float?radius = MyMwcMessageIn.ReadFloat(binaryReader);
if (radius == null)
{
return(NetworkError());
}
Radius = radius.Value;
MyMwcLog.IfNetVerbose_AddToLog("Radius: " + Radius.ToString());
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());
}
// Debris Field Type
MyMwcObjectBuilder_LargeDebrisField_TypesEnum?debrisFieldType = MyMwcMessageIn.ReadObjectBuilderLargeDebrisFieldTypesEnumEx(binaryReader, senderEndPoint);
if (debrisFieldType == null)
{
return(NetworkError());
}
DebrisType = debrisFieldType.Value;
MyMwcLog.IfNetVerbose_AddToLog("DebrisType: " + DebrisType);
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;
return(true);
}
internal override bool Read(System.IO.BinaryReader binaryReader, System.Net.EndPoint senderEndPoint, int gameVersion)
{
if (!base.Read(binaryReader, senderEndPoint, gameVersion))
{
return(NetworkError());
}
int?difficulty = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (!difficulty.HasValue)
{
return(NetworkError());
}
Difficulty = (MyGameplayDifficultyEnum)difficulty.Value;
return(true);
}
public bool Read(BinaryReader binaryReader, EndPoint senderEndPoint)
{
// triangles
int?voxelTrianglesCount = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (voxelTrianglesCount == null)
{
return(false);
}
VoxelTrianglesCount = voxelTrianglesCount.Value;
MyMwcLog.IfNetVerbose_AddToLog("voxelTrianglesCount: " + VoxelTrianglesCount);
VoxelTriangles = new MyVoxelTriangle[VoxelTrianglesCount];
for (int i = 0; i < VoxelTrianglesCount; i++)
{
var voxelTriangle = MyDataCellReadWriteHelper.ReadVoxelTriangleEx(binaryReader, senderEndPoint);
if (voxelTriangle == null)
{
return(false);
}
VoxelTriangles[i] = voxelTriangle.Value;
}
// vertices
int?voxelVerticesCount = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (voxelVerticesCount == null)
{
return(false);
}
VoxelVerticesCount = voxelVerticesCount.Value;
MyMwcLog.IfNetVerbose_AddToLog("voxelVerticesCount: " + VoxelVerticesCount);
VoxelVertices = new MyVoxelVertex[VoxelVerticesCount];
for (int i = 0; i < VoxelVerticesCount; i++)
{
var voxelVertex = MyDataCellReadWriteHelper.ReadVoxelVertexEx(binaryReader, senderEndPoint);
if (voxelVertex == null)
{
return(false);
}
VoxelVertices[i] = voxelVertex.Value;
}
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());
}
// Cargo box type
MyMwcObjectBuilder_MysteriousCube_TypesEnum?mysteriousCubeType = MyMwcMessageIn.ReadObjectBuilderMysteriousCubeTypesEnumEx(binaryReader, senderEndPoint);
if (mysteriousCubeType == null)
{
return(NetworkError());
}
MysteriousCubeType = mysteriousCubeType.Value;
MyMwcLog.IfNetVerbose_AddToLog("MysteriousCubeType: " + MysteriousCubeType);
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());
}
// Tool Type
MyMwcObjectBuilder_SmallShip_Tool_TypesEnum?toolType = MyMwcMessageIn.ReadObjectBuilderSmallShipToolTypesEnumEx(binaryReader, senderEndPoint);
if (toolType == null)
{
return(NetworkError());
}
ToolType = toolType.Value;
MyMwcLog.IfNetVerbose_AddToLog("ToolType: " + ToolType);
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);
}
