protected override MyEntity CreateEntity(string hudLabelText, MyMwcObjectBuilder_Base objectBuilder, Matrix matrix, Vector2? screenPosition)
{
MyEntity entity = base.CreateEntity(hudLabelText, objectBuilder, matrix, screenPosition);
// add waypoints
if (entity is MyPrefabBase)
(entity as MyPrefabBase).InitWaypoints();
else if (entity is MyPrefabContainer)
foreach (var prefab in (entity as MyPrefabContainer).GetPrefabs())
(prefab as MyPrefabBase).InitWaypoints();
float distanceFromCamera = entity.WorldVolume.Radius * (entity is MyPrefabBase ? 4 : 2);
Vector3 newPosition;
if (screenPosition.HasValue)
{
Ray ray = MyUtils.ConvertMouseToRay(MyGuiManager.GetScreenCoordinateFromNormalizedCoordinate(screenPosition.Value));
newPosition = ray.Position + ray.Direction * distanceFromCamera;
}
else
{
newPosition = MySpectator.Position + distanceFromCamera * MySpectator.Orientation;
}
entity.MoveAndRotate(newPosition, entity.GetWorldRotation());
return entity;
}
/// <summary>
/// Inits the specified hud label text.
/// </summary>
/// <param name="hudLabelText">The hud label text.</param>
/// <param name="modelLod0Enum">The model lod0 enum.</param>
/// <param name="modelLod1Enum">The model lod1 enum.</param>
/// <param name="parentObject">The parent object.</param>
/// <param name="scale">The scale.</param>
/// <param name="objectBuilder">The object builder.</param>
public override void Init(StringBuilder hudLabelText, MyModelsEnum? modelLod0Enum, MyModelsEnum? modelLod1Enum, MyEntity parentObject, float? scale, MyMwcObjectBuilder_Base objectBuilder, MyModelsEnum? modelCollision = null, Models.MyModelsEnum? modelLod2 = null)
{
Flags |= EntityFlags.EditableInEditor;
NeedsUpdate = true;
base.Init(hudLabelText, modelLod0Enum, modelLod1Enum, null, scale, objectBuilder, modelCollision, modelLod2);
}
public void Start(MyGuiHelperBase guiHelper, MyGameplayProperties itemProperties, MyMwcObjectBuilder_Base objectBuilder, float amount)
{
GuiHelper = guiHelper;
ItemProperties = itemProperties;
ObjectBuilder = objectBuilder;
Amount = Math.Min(amount, MaxAmount);
TemporaryFlags = MyInventoryItemTemporaryFlags.NONE;
}
public virtual void Init(StringBuilder hudLabelText, MyModelsEnum? modelEnum, MyMaterialType materialType,
MyEntity parentObject, Vector3 position, Vector3 forwardVector, Vector3 upVector,
MyMwcObjectBuilder_Base objectBuilder, MyModelsEnum? collisionModelEnum = null)
{
base.Init(hudLabelText, modelEnum, null, parentObject, null, objectBuilder, modelCollision: collisionModelEnum);
this.LocalMatrix = Matrix.CreateWorld(position, forwardVector, upVector);
//NeedsUpdate = true; //Smallship updates weapons manually
CastShadows = false;
PreloadTextures();
}
public float ZOffset; // z-offset from ship's dummy
public void Init(StringBuilder hudLabelText, MyModelsEnum? modelEnum, MyMaterialType materialType,
MySmallShip parent, Vector3 position, Vector3 forwardVector, Vector3 upVector,
MyMwcObjectBuilder_Base objectBuilder)
{
base.Init(hudLabelText, modelEnum, materialType, parent, position, forwardVector, upVector, objectBuilder);
Debug.Assert(objectBuilder is MyMwcObjectBuilder_SmallShip_Weapon);
WeaponType = ((MyMwcObjectBuilder_SmallShip_Weapon)objectBuilder).WeaponType;
// Don't need to check frustum, because it's checked by this gun's parent
m_frustumCheckBeforeDrawEnabled = false;
}
public override void Init(StringBuilder hudLabelText, MyEntity parentObject, Vector3 position, Vector3 forwardVector, Vector3 upVector, MyMwcObjectBuilder_Base objectBuilder)
{
base.Init(hudLabelText, MyModelsEnum.LargeShipAutocannonBase, MyMaterialType.METAL, parentObject, position, forwardVector, upVector, objectBuilder, MyModelsEnum.LargeShipAutocannonBase);
Matrix barrelMatrix = MyMath.NormalizeMatrix(ModelLod0.Dummies["axis"].Matrix);
MyLargeShipAutocannonBarrel barrel = new MyLargeShipAutocannonBarrel();
barrel.Init(hudLabelText, barrelMatrix, MyMwcObjectBuilder_SmallShip_Ammo_TypesEnum.Autocannon_High_Speed, this);
MountBarrel(barrel);
// User settings:
m_predictionIntervalConst_ms = 250;
m_checkTargetIntervalConst_ms = 150;
m_randomStandbyChangeConst_ms = 4000;
m_shootingSound = MySoundCuesEnum.WepAutocanonFire3d;
m_shootingSoundRelease = MySoundCuesEnum.WepAutocanonRel3d;
}
public MyEditorActionWithObjectBuildersBase(MyMwcObjectBuilder_Base actionObjectBuilder, Matrix matrix)
: base((MyEntity)null)
{
this.Init(1);
ActionObjectBuilders.Add(new ObjectBuilderCreate(actionObjectBuilder, matrix));
}
public bool ReadObjectBuilder <T>(ref T objectBuilder)
where T : MyMwcObjectBuilder_Base
{
objectBuilder = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(this.Reader, this.EndPoint) as T;
return(objectBuilder != null && objectBuilder.Read(this.Reader, this.EndPoint, MyMwcFinalBuildConstants.SERVER_PROTOCOL_VERSION));
}
public ObjectBuilderCreate(MyEntity entity, bool getExactCopy = false)
{
Matrix = entity.WorldMatrix;
ObjectBuilder = entity.GetObjectBuilder(getExactCopy);
}
/// <summary>
/// Returns true if inventory contains item
/// </summary>
/// <param name="objectBuilder">Item's objectbuilder</param>
/// <returns></returns>
public bool Contains(MyMwcObjectBuilder_Base objectBuilder)
{
return(Contains(objectBuilder.GetObjectBuilderType(), objectBuilder.GetObjectBuilderId()));
}
void CreateFromObjectBuilder(MyMwcObjectBuilder_Base objectBuilder, Matrix matrix, Vector2? screenPosition)
{
MyEntity actionEntity = CreateEntity(null, objectBuilder, matrix, screenPosition);
if (actionEntity != null)
{
AddEntity(actionEntity);
AddToScene(actionEntity);
}
}
/// <summary>
/// Fills inventory with all items
/// </summary>
/// <param name="maxItems">Max items limit</param>
public void FillInventoryWithAllItems(int?maxItems = null, int?increaseMaxItemsAbout = null, bool loadSmallShips = false)
{
if (maxItems != null)
{
MaxItems = maxItems.Value;
}
MyInventoryItem inventoryItem;
List <MyInventoryItem> inventoryItemsToAdd = new List <MyInventoryItem>();
// ammo
foreach (MyMwcObjectBuilder_SmallShip_Ammo_TypesEnum item in MyGuiSmallShipHelpers.MyMwcObjectBuilder_SmallShip_Ammo_TypesEnumValues)
{
inventoryItem = MyInventory.CreateInventoryItemFromObjectBuilder(new MyMwcObjectBuilder_SmallShip_Ammo(item));
inventoryItem.Amount = inventoryItem.MaxAmount;
inventoryItemsToAdd.Add(inventoryItem);
}
// engines
foreach (MyMwcObjectBuilder_SmallShip_Engine_TypesEnum item in MyGuiSmallShipHelpers.MyMwcObjectBuilder_SmallShip_Engine_TypesEnumValues)
{
inventoryItem = MyInventory.CreateInventoryItemFromObjectBuilder(new MyMwcObjectBuilder_SmallShip_Engine(item));
inventoryItemsToAdd.Add(inventoryItem);
}
// weapons
foreach (MyMwcObjectBuilder_SmallShip_Weapon_TypesEnum item in MyGuiSmallShipHelpers.MyMwcObjectBuilder_SmallShip_Weapon_TypesEnumValues)
{
inventoryItem = MyInventory.CreateInventoryItemFromObjectBuilder(new MyMwcObjectBuilder_SmallShip_Weapon(item));
inventoryItemsToAdd.Add(inventoryItem);
}
// tools
foreach (MyMwcObjectBuilder_SmallShip_Tool_TypesEnum item in MyGuiSmallShipHelpers.MyMwcObjectBuilder_SmallShip_ToolEnumValues)
{
inventoryItem = MyInventory.CreateInventoryItemFromObjectBuilder(new MyMwcObjectBuilder_SmallShip_Tool(item));
inventoryItem.Amount = inventoryItem.MaxAmount;
inventoryItemsToAdd.Add(inventoryItem);
}
// armors
foreach (MyMwcObjectBuilder_SmallShip_Armor_TypesEnum item in Enum.GetValues(typeof(MyMwcObjectBuilder_SmallShip_Armor_TypesEnum)))
{
inventoryItem = MyInventory.CreateInventoryItemFromObjectBuilder(new MyMwcObjectBuilder_SmallShip_Armor(item));
inventoryItemsToAdd.Add(inventoryItem);
}
// radars
foreach (MyMwcObjectBuilder_SmallShip_Radar_TypesEnum item in Enum.GetValues(typeof(MyMwcObjectBuilder_SmallShip_Radar_TypesEnum)))
{
inventoryItem = MyInventory.CreateInventoryItemFromObjectBuilder(new MyMwcObjectBuilder_SmallShip_Radar(item));
inventoryItemsToAdd.Add(inventoryItem);
}
// blueprints
foreach (MyMwcObjectBuilder_Blueprint_TypesEnum item in Enum.GetValues(typeof(MyMwcObjectBuilder_Blueprint_TypesEnum)))
{
inventoryItem = MyInventory.CreateInventoryItemFromObjectBuilder(new MyMwcObjectBuilder_Blueprint(item));
inventoryItemsToAdd.Add(inventoryItem);
}
//ore
foreach (MyMwcObjectBuilder_Ore_TypesEnum item in Enum.GetValues(typeof(MyMwcObjectBuilder_Ore_TypesEnum)))
{
inventoryItem = MyInventory.CreateInventoryItemFromObjectBuilder(new MyMwcObjectBuilder_Ore(item));
inventoryItem.Amount = 1;
inventoryItemsToAdd.Add(inventoryItem);
}
// fakeId
foreach (MyMwcObjectBuilder_FactionEnum item in Enum.GetValues(typeof(MyMwcObjectBuilder_FactionEnum)))
{
inventoryItem = MyInventory.CreateInventoryItemFromObjectBuilder(new MyMwcObjectBuilder_FalseId(item));
inventoryItemsToAdd.Add(inventoryItem);
}
// hacking tool
foreach (MyMwcObjectBuilder_SmallShip_HackingTool_TypesEnum item in Enum.GetValues(typeof(MyMwcObjectBuilder_SmallShip_HackingTool_TypesEnum)))
{
inventoryItem = MyInventory.CreateInventoryItemFromObjectBuilder(new MyMwcObjectBuilder_SmallShip_HackingTool(item));
inventoryItemsToAdd.Add(inventoryItem);
}
// drone
foreach (MyMwcObjectBuilder_Drone_TypesEnum droneType in Enum.GetValues(typeof(MyMwcObjectBuilder_Drone_TypesEnum)))
{
var droneBuilder = new MyMwcObjectBuilder_Drone(droneType);
inventoryItem = CreateInventoryItemFromObjectBuilder(droneBuilder);
inventoryItem.Amount = inventoryItem.MaxAmount;
inventoryItemsToAdd.Add(inventoryItem);
}
// playerships
if (loadSmallShips)
{
foreach (MyMwcObjectBuilder_SmallShip_TypesEnum shipType in Enum.GetValues(typeof(MyMwcObjectBuilder_SmallShip_TypesEnum)))
{
inventoryItem = MyInventory.CreateInventoryItemFromObjectBuilder(MyMwcObjectBuilder_SmallShip_Player.CreateDefaultShip(shipType, MySession.PlayerShip.Faction, MyShipTypeConstants.GetShipTypeProperties(shipType).GamePlay.CargoCapacity));
inventoryItemsToAdd.Add(inventoryItem);
}
}
//// prefabs
//foreach(MyMwcObjectBuilder_Prefab_TypesEnum item in Enum.GetValues(typeof(MyMwcObjectBuilder_Prefab_TypesEnum))) {
// inventoryItem = MyInventory.CreateInventoryItemFromObjectBuilder(new MyMwcObjectBuilder_Prefab(item, new MyMwcVector3Short(0, 0, 0), new Vector3(0, 0, 0), MyGameplayConstants.MAXHEALTH_PREFAB));
// inventoryItemsToAdd.Add(inventoryItem);
//}
//// small debris
//foreach (MyMwcObjectBuilder_SmallDebris_TypesEnum item in Enum.GetValues(typeof(MyMwcObjectBuilder_SmallDebris_TypesEnum)))
//{
// inventoryItem = MyInventory.CreateInventoryItemFromObjectBuilder(new MyMwcObjectBuilder_SmallDebris(item, true));
// inventoryItemsToAdd.Add(inventoryItem);
//}
// foundation factory
inventoryItem = MyInventory.CreateInventoryItemFromObjectBuilder(MyMwcObjectBuilder_Base.CreateNewObject(MyMwcObjectBuilderTypeEnum.PrefabFoundationFactory, (int)MyMwcObjectBuilder_PrefabFoundationFactory_TypesEnum.DEFAULT));
inventoryItemsToAdd.Add(inventoryItem);
if (maxItems != null && !UnlimitedCapacity)
{
while (inventoryItemsToAdd.Count > maxItems.Value)
{
int lastIndex = inventoryItemsToAdd.Count - 1;
inventoryItem = inventoryItemsToAdd[lastIndex];
inventoryItemsToAdd.RemoveAt(lastIndex);
MyInventory.CloseInventoryItem(inventoryItem);
}
}
else
{
if (inventoryItemsToAdd.Count > MaxItems)
{
MaxItems = inventoryItemsToAdd.Count;
}
}
if (increaseMaxItemsAbout != null)
{
MaxItems += increaseMaxItemsAbout.Value;
}
AddInventoryItems(inventoryItemsToAdd);
}
/// <summary>
/// Adds new inventory item from object builder type and id
/// </summary>
/// <param name="objectBuilderType">Objectbuilder type</param>
/// <param name="objectBuilderId">Objectbuilder id</param>
/// <param name="amount">Amount of inventory item</param>
/// <param name="allAmmountAddAsNewInventoryItems">If true, then all amount adds as new inventory items, if false, then try find old inventory items of same type, and add amount to them as first</param>
public float AddInventoryItem(MyMwcObjectBuilderTypeEnum objectBuilderType, int?objectBuilderId, float amount, bool allAmmountAddAsNewInventoryItems, bool increaseCapacityIfIsFull = false)
{
MyMwcObjectBuilder_Base objectBuilder = MyMwcObjectBuilder_Base.CreateNewObject(objectBuilderType, objectBuilderId);
return(AddInventoryItem(objectBuilder, amount, allAmmountAddAsNewInventoryItems, increaseCapacityIfIsFull));
}
public void Start(MyGuiHelperBase guiHelper, MyGameplayProperties itemProperties, MyMwcObjectBuilder_Base objectBuilder)
{
Start(guiHelper, itemProperties, objectBuilder, 1f);
}
public ObjectBuilderCreate(MyMwcObjectBuilder_Base objectBuilder, Matrix matrix)
{
Matrix = matrix;
ObjectBuilder = objectBuilder;
}
/// <summary>
/// Creates new instance of object to build
/// </summary>
/// <param name="objectBuilder">Object builder</param>
/// <param name="buildingSpecification">Building specification</param>
/// <param name="amount">Amount</param>
public MyObjectToBuild(MyMwcObjectBuilder_Base objectBuilder, MyBuildingSpecification buildingSpecification, float amount)
{
ObjectBuilder = objectBuilder;
BuildingSpecification = buildingSpecification;
Amount = amount;
}
private static void StoreCoopPlayer(this MyMwcObjectBuilder_Checkpoint checkpoint, MyMwcObjectBuilder_Player playerBuilder)
{
if (checkpoint != null)
{
if (checkpoint.InventoryObjectBuilder == null)
{
checkpoint.InventoryObjectBuilder = (MyMwcObjectBuilder_Inventory)MyMwcObjectBuilder_Base.CreateNewObject(MyMwcObjectBuilderTypeEnum.Inventory, null);
}
// Remove old and add new
checkpoint.InventoryObjectBuilder.InventoryItems.RemoveAll(new Predicate <MyMwcObjectBuilder_InventoryItem>(s => s.ItemObjectBuilder.Name == playerBuilder.Name));
checkpoint.InventoryObjectBuilder.InventoryItems.Add(new MyMwcObjectBuilder_InventoryItem(playerBuilder, 1));
}
}
private MyEntity CreateFromObjectBuilder(MyMwcObjectBuilder_Base objectBuilder)
{
if (objectBuilder.GetObjectBuilderType() == MyMwcObjectBuilderTypeEnum.VoxelMap)
{
MyMwcObjectBuilder_VoxelMap voxelMapObjectBuilder = objectBuilder as MyMwcObjectBuilder_VoxelMap;
return MyEntities.CreateFromObjectBuilderAndAdd(null, voxelMapObjectBuilder, Matrix.Identity);
}
else if (objectBuilder.GetObjectBuilderType() == MyMwcObjectBuilderTypeEnum.VoxelMap_Neighbour)
{
// Voxel map neighbours are handled in its static classe, so ignore it here
}
else
{
if (objectBuilder is MyMwcObjectBuilder_Object3dBase || objectBuilder is MyMwcObjectBuilder_InfluenceSphere)
{
MyEntity temporaryEntity = null;
Matrix matrix = Matrix.Identity;
if (objectBuilder is MyMwcObjectBuilder_Object3dBase)
{
var object3d = objectBuilder as MyMwcObjectBuilder_Object3dBase;
matrix = Matrix.CreateWorld(object3d.PositionAndOrientation.Position, object3d.PositionAndOrientation.Forward, object3d.PositionAndOrientation.Up);
MyUtils.AssertIsValid(matrix);
}
temporaryEntity = MyEntities.CreateFromObjectBuilderAndAdd(null, objectBuilder, matrix);
MyEntities.TestEntityAfterInsertionForCollision(temporaryEntity);
return temporaryEntity;
}
}
return null;
}
bool Read01089000(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);
}
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);
}
public override void Init(StringBuilder hudLabelText, MyEntity parentObject, Vector3 position, Vector3 forwardVector, Vector3 upVector, MyMwcObjectBuilder_Base objectBuilder)
{
base.Init(hudLabelText, MyModelsEnum.LargeShipAutocannonBase, MyMaterialType.METAL, parentObject, position, forwardVector, upVector, objectBuilder, MyModelsEnum.LargeShipAutocannonBase);
Matrix barrelMatrix = MyMath.NormalizeMatrix(ModelLod0.Dummies["axis"].Matrix);
MyLargeShipAutocannonBarrel barrel = new MyLargeShipAutocannonBarrel();
barrel.Init(hudLabelText, barrelMatrix, MyMwcObjectBuilder_SmallShip_Ammo_TypesEnum.Autocannon_High_Speed, this);
MountBarrel(barrel);
// User settings:
m_predictionIntervalConst_ms = 250;
m_checkTargetIntervalConst_ms = 150;
m_randomStandbyChangeConst_ms = 4000;
m_shootingSound = MySoundCuesEnum.WepAutocanonFire3d;
m_shootingSoundRelease = MySoundCuesEnum.WepAutocanonRel3d;
}
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);
}
public static MyInventoryItem CreateInventoryItemFromObjectBuilder(MyMwcObjectBuilder_Base objectBuilder)
{
return(MyInventory.CreateInventoryItemFromObjectBuilder(objectBuilder, 1f));
}
private void LastCheckpointSectorLoaded(MyMwcObjectBuilder_Checkpoint checkpoint, byte[] sectorData)
{
checkpoint.SectorObjectBuilder = MyMwcObjectBuilder_Base.FromBytes <MyMwcObjectBuilder_Sector>(sectorData);
MyGuiScreenGamePlay.ReloadGameplayScreen(checkpoint, MyMwcStartSessionRequestTypeEnum.LOAD_CHECKPOINT, MyGuiScreenGamePlayType.GAME_STORY);
}
/// <summary>
/// Returns first inventory item from inventory
/// </summary>
/// <param name="objectBuilder">Item's object builder</param>
/// <returns></returns>
public MyInventoryItem GetInventoryItem(MyMwcObjectBuilder_Base objectBuilder)
{
return(GetInventoryItem(objectBuilder.GetObjectBuilderType(), objectBuilder.GetObjectBuilderId()));
}
public static MyGameplayProperties GetGameplayProperties(MyMwcObjectBuilder_Base objectBuilder, MyMwcObjectBuilder_FactionEnum faction)
{
int objectBuilderId = objectBuilder.GetObjectBuilderId() != null
? objectBuilder.GetObjectBuilderId().Value
: 0;
return GetGameplayProperties(objectBuilder.GetObjectBuilderType(), objectBuilderId, faction);
}
/// <summary>
/// Returns total amount of inventory items in inventory
/// </summary>
/// <param name="objectBuilder">Item's object builder</param>
/// <returns></returns>
public float GetTotalAmountOfInventoryItems(MyMwcObjectBuilder_Base objectBuilder)
{
return(GetTotalAmountOfInventoryItems(objectBuilder.GetObjectBuilderType(), objectBuilder.GetObjectBuilderId()));
}
public override void Init(StringBuilder hudLabelText, MyEntity parentObject, Vector3 position, Vector3 forwardVector, Vector3 upVector, MyMwcObjectBuilder_Base objectBuilder)
{
MyModelsEnum modelEnumBase;
MyModelsEnum?modelEnumBaseCollision = null;
MyModelsEnum modelEnumBarrel;
MyMwcObjectBuilder_SmallShip_Ammo_TypesEnum missileType;
switch ((MyMwcObjectBuilder_PrefabLargeWeapon_TypesEnum)objectBuilder.GetObjectBuilderId().Value)
{
case MyMwcObjectBuilder_PrefabLargeWeapon_TypesEnum.P352_A01_LARGESHIP_MISSILE_BASIC4:
case MyMwcObjectBuilder_PrefabLargeWeapon_TypesEnum.P352_A02_LARGESHIP_MISSILE_GUIDED4:
modelEnumBase = MyModelsEnum.LargeShipMissileLauncher4Base;
modelEnumBarrel = MyModelsEnum.LargeShipMissileLauncher4Barrel;
modelEnumBaseCollision = MyModelsEnum.LargeShipMissileLauncher4Base_COL;
Burst = 4;
break;
case MyMwcObjectBuilder_PrefabLargeWeapon_TypesEnum.P352_A01_LARGESHIP_MISSILE_BASIC6:
case MyMwcObjectBuilder_PrefabLargeWeapon_TypesEnum.P352_A02_LARGESHIP_MISSILE_GUIDED6:
modelEnumBase = MyModelsEnum.LargeShipMissileLauncher6Base;
modelEnumBarrel = MyModelsEnum.LargeShipMissileLauncher6Barrel;
modelEnumBaseCollision = MyModelsEnum.LargeShipMissileLauncher6Base_COL;
Burst = 6;
break;
case MyMwcObjectBuilder_PrefabLargeWeapon_TypesEnum.P352_A01_LARGESHIP_MISSILE_BASIC9:
case MyMwcObjectBuilder_PrefabLargeWeapon_TypesEnum.P352_A02_LARGESHIP_MISSILE_GUIDED9:
modelEnumBase = MyModelsEnum.LargeShipMissileLauncher9Base;
modelEnumBarrel = MyModelsEnum.LargeShipMissileLauncher9Barrel;
modelEnumBaseCollision = MyModelsEnum.LargeShipMissileLauncher9Base_COL;
Burst = 9;
break;
default:
throw new MyMwcExceptionApplicationShouldNotGetHere();
break;
}
switch ((MyMwcObjectBuilder_PrefabLargeWeapon_TypesEnum)objectBuilder.GetObjectBuilderId().Value)
{
case MyMwcObjectBuilder_PrefabLargeWeapon_TypesEnum.P352_A01_LARGESHIP_MISSILE_BASIC4:
case MyMwcObjectBuilder_PrefabLargeWeapon_TypesEnum.P352_A01_LARGESHIP_MISSILE_BASIC6:
case MyMwcObjectBuilder_PrefabLargeWeapon_TypesEnum.P352_A01_LARGESHIP_MISSILE_BASIC9:
missileType = MyMwcObjectBuilder_SmallShip_Ammo_TypesEnum.Missile_Basic;
break;
case MyMwcObjectBuilder_PrefabLargeWeapon_TypesEnum.P352_A02_LARGESHIP_MISSILE_GUIDED4:
case MyMwcObjectBuilder_PrefabLargeWeapon_TypesEnum.P352_A02_LARGESHIP_MISSILE_GUIDED6:
case MyMwcObjectBuilder_PrefabLargeWeapon_TypesEnum.P352_A02_LARGESHIP_MISSILE_GUIDED9:
missileType = MyMwcObjectBuilder_SmallShip_Ammo_TypesEnum.Guided_Missile_Radar_Detection;
break;
default:
throw new MyMwcExceptionApplicationShouldNotGetHere();
break;
}
base.Init(hudLabelText, modelEnumBase, MyMaterialType.METAL, parentObject, position, forwardVector, upVector, objectBuilder, modelEnumBaseCollision);
Matrix barrelMatrix = MyMath.NormalizeMatrix(ModelLod0.Dummies["axis"].Matrix);
MyLargeShipMissileLauncherBarrel barrel = new MyLargeShipMissileLauncherBarrel();
barrel.Init(hudLabelText, modelEnumBarrel, Burst, barrelMatrix, missileType, this);
MountBarrel(barrel);
// User settings:
m_predictionIntervalConst_ms = 250;
m_checkTargetIntervalConst_ms = 150;
m_randomStandbyChangeConst_ms = 4000;
}
/// <summary>
/// Adds object builder to current action object builders list
/// </summary>
/// <param name="actionObjectBuilder"></param>
public void AddEntityObjectBuilder(MyMwcObjectBuilder_Base actionObjectBuilder, Matrix matrix)
{
ActionObjectBuilders.Add(new ObjectBuilderCreate(actionObjectBuilder, matrix));
}
public static MyGuiHelperBase GetGuiHelper(MyMwcObjectBuilder_Base objectBuilder)
{
MyMwcObjectBuilderTypeEnum objectBuilderType = objectBuilder.GetObjectBuilderType();
int objectBuilderId = objectBuilder.GetObjectBuilderId() != null ? objectBuilder.GetObjectBuilderId().Value : 0;
return GetGuiHelper(objectBuilderType, objectBuilderId);
}
static void GetObjects(MyMwcObjectBuilder_Base builder, Dictionary<uint, MyMwcObjectBuilder_Base> addToDictionary)
{
if (builder == null)
return;
if (builder.EntityId.HasValue)
{
addToDictionary.Add(builder.EntityId.Value, builder);
}
if (builder is MyMwcObjectBuilder_Checkpoint)
{
GetObjects(((MyMwcObjectBuilder_Checkpoint)builder).SectorObjectBuilder, addToDictionary);
}
var sectorBuilder = builder as MyMwcObjectBuilder_Sector;
if (sectorBuilder != null && sectorBuilder.SectorObjects != null)
{
foreach (var ob in sectorBuilder.SectorObjects)
{
GetObjects(ob, addToDictionary);
}
}
var containerBuilder = builder as MyMwcObjectBuilder_PrefabContainer;
if (containerBuilder != null && containerBuilder.Prefabs != null)
{
foreach (var ob in containerBuilder.Prefabs)
{
GetObjects(ob, addToDictionary);
}
}
}
protected void Init(StringBuilder displayName, MyMwcObjectBuilder_Base objectBuilder)
{
Closed = false;
m_wasDead = false;
m_isExploded = false;
// System.Diagnostics.Debug.Assert(objectBuilder != null);
if (objectBuilder != null)
{
this.EntityId = MyEntityIdentifier.FromNullableInt(objectBuilder.EntityId);
this.m_objectBuilder = objectBuilder.Clone(); // MyMwcUtils.DeepCopy(objectBuilder);
m_gameplayProperties = MyGameplayConstants.GetGameplayProperties(objectBuilder, Faction);
Debug.Assert(m_gameplayProperties != null);
if (m_gameplayProperties != null)
{
MaxHealth = m_gameplayProperties.MaxHealth;
Health = m_gameplayProperties.MaxHealth;
}
PersistentFlags = objectBuilder.PersistentFlags;
this.Name = objectBuilder.Name;
MyEntities.SetEntityName(this, false);
IsGenerated = objectBuilder.Generated;
if (IsGenerated)
{
Flags &= ~EntityFlags.NeedsId;
Flags &= ~EntityFlags.Save;
}
}
else
{
PersistentFlags |= MyMwcObjectBuilder_Base.GetDefaultPersistantFlags();
}
InitRenderObjects();
// When entity needs id and has id, add it to list
if ((Flags & EntityFlags.NeedsId) != 0)
{
// When suspended, id is allocated during link
if (!this.EntityId.HasValue && MyEntityIdentifier.AllocationSuspended == false)
{
this.EntityId = MyEntityIdentifier.AllocateId();
}
if (this.EntityId.HasValue)
{
MyEntityIdentifier.AddEntityWithId(this);
}
}
else
{
this.EntityId = null;
}
this.DisplayName = displayName != null ? displayName.ToString() : null;
UpdateHudMarker();
m_worldMatrix = Matrix.Identity;
//DebugGenerateEntityDisplayName();
if (!MyFakes.MWBUILDER)
{
Debug.Assert(IsActivatedForDifficulty(MyGameplayDifficultyEnum.EASY) || IsActivatedForDifficulty(MyGameplayDifficultyEnum.NORMAL) || IsActivatedForDifficulty(MyGameplayDifficultyEnum.HARD));
}
}
/// <summary>
/// Adds object builder to current action object builders list
/// </summary>
/// <param name="actionObjectBuilder"></param>
public void AddEntityObjectBuilder(MyMwcObjectBuilder_Base actionObjectBuilder, Matrix matrix)
{
ActionObjectBuilders.Add(new ObjectBuilderCreate(actionObjectBuilder, matrix));
}
// This is real initialization of this class!!! Instead of constructor.
protected void Init(StringBuilder hudLabelText, MyMwcObjectBuilder_Base objectBuilder, MyEntity parentObject)
{
Init(hudLabelText, objectBuilder);
if (parentObject != null)
{
parentObject.Children.Add(this);
}
MaterialIndex = 0;
}
public ObjectBuilderCreate(MyMwcObjectBuilder_Base objectBuilder, Matrix matrix)
{
Matrix = matrix;
ObjectBuilder = objectBuilder;
}
// This is real initialization of this class!!! Instead of constructor.
public virtual void Init(StringBuilder displayName, MyModelsEnum? modelLod0Enum, MyModelsEnum? modelLod1Enum,
MyEntity parentObject, float? scale, MyMwcObjectBuilder_Base objectBuilder, MyModelsEnum? modelCollision = null, MyModelsEnum? modelLod2Enum = null)
{
Init(displayName, objectBuilder);
if (modelLod0Enum != null)
{
m_modelLod0 = MyModels.GetModelOnlyData(modelLod0Enum.Value);
LocalVolumeOffset = m_modelLod0.BoundingSphere.Center;
}
if (modelLod1Enum != null)
m_modelLod1 = MyModels.GetModelOnlyData(modelLod1Enum.Value);
if (modelCollision != null)
m_modelCollision = MyModels.GetModelOnlyData(modelCollision.Value);
if (modelLod2Enum != null)
m_modelLod2 = MyModels.GetModelOnlyData(modelLod2Enum.Value);
if (m_modelLod0 != null)
{
if (m_modelLod1 != null)
{
BoundingBox modelLod1Box = m_modelLod1.BoundingBox;
LocalAABB = m_modelLod0.BoundingBox.Include(ref modelLod1Box);
}
else
{
this.LocalAABB = m_modelLod0.BoundingBox;
}
}
else
{ //entities without model has box with side length = 1 by default
float defaultBoxHalfSize = 0.5f;
this.LocalAABB = new BoundingBox(new Vector3(-defaultBoxHalfSize), new Vector3(defaultBoxHalfSize));
}
if (parentObject != null)
{
parentObject.Children.Add(this);
}
this.Scale = scale;
}
// 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);
}
public MyEditorActionEntityAdd(MyMwcObjectBuilder_Base actionObjectBuilder, Matrix matrix, Vector2? screenPosition)
: base(actionObjectBuilder, matrix)
{
ActionObjectBuilders.ForEach(a => a.ScreenPosition = screenPosition);
}
// 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;
}
// Cargo box type
MyMwcObjectBuilder_CargoBox_TypesEnum?cargoBoxType = MyMwcMessageIn.ReadObjectBuilderCargoBoxTypesEnumEx(binaryReader, senderEndPoint);
if (cargoBoxType == null)
{
return(NetworkError());
}
CargoBoxType = cargoBoxType.Value;
MyMwcLog.IfNetVerbose_AddToLog("CargoBoxType: " + CargoBoxType);
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");
Name = null;
}
return(true);
}
public ObjectBuilderCreate(MyEntity entity, bool getExactCopy = false)
{
Matrix = entity.WorldMatrix;
ObjectBuilder = entity.GetObjectBuilder(getExactCopy);
}
//public void RemoveInventoryItemsByType(MyMwcObjectBuilderTypeEnum objectBuilderType, int? objectBuilderId = null)
//{
// for (int i = 0; i < m_inventoryItems.Count; i++)
// {
// MyInventoryItem inventoryItem = m_inventoryItems[i];
// if (inventoryItem.ObjectBuilderType == objectBuilderType && (objectBuilderId == null || inventoryItem.ObjectBuilderId == objectBuilderId))
// {
// RemoveInventoryItem(inventoryItem);
// }
// }
//}
/// <summary>
/// Removes inventory items from inventory
/// </summary>
/// <param name="objectBuilder">Inventory item's object builder</param>
/// <param name="closeInventoryItems">If true, then close inventory item's instance in pool</param>
public void RemoveInventoryItems(MyMwcObjectBuilder_Base objectBuilder, bool closeInventoryItems = false)
{
RemoveInventoryItems(objectBuilder.GetObjectBuilderType(), objectBuilder.GetObjectBuilderId(), closeInventoryItems);
}
/// <summary>
/// Creates new entity based on its object builder
/// </summary>
/// <param name="hudLabelText"></param>
/// <param name="objectBuilder"></param>
/// <returns></returns>
protected virtual MyEntity CreateEntity(string hudLabelText, MyMwcObjectBuilder_Base objectBuilder, Matrix matrix, Vector2? screenPosition)
{
MyEntity entity = null;
if (objectBuilder is MyMwcObjectBuilder_PrefabBase)
{
//When creating prefabs, it will never happen that active container does not exist
entity = m_activeContainer.CreateAndAddPrefab(hudLabelText, objectBuilder as MyMwcObjectBuilder_PrefabBase);
}
else
{
entity = MyEntities.CreateFromObjectBuilder(hudLabelText, objectBuilder, matrix);
}
return entity;
}
/// <summary>
/// Find inventory items from inventory
/// </summary>
/// <param name="inventoryItems">Collection to fill founded inventory items</param>
/// <param name="objectBuilder">Item's object builder</param>
/// <returns></returns>
public void GetInventoryItems(ref List <MyInventoryItem> inventoryItems, MyMwcObjectBuilder_Base objectBuilder)
{
GetInventoryItems(ref inventoryItems, objectBuilder.GetObjectBuilderType(), objectBuilder.GetObjectBuilderId());
}
public MyMinerGame(ServiceContainer services)
{
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartProfilingBlock("MyMinerGame()::constructor");
MyMwcLog.WriteLine("MyMinerGame.Constructor() - START");
MyMwcLog.IncreaseIndent();
Services = services;
// we want check objectbuilders, prefab's configurations, gameplay constants and building specifications
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartProfilingBlock("Checks");
MyMwcObjectBuilder_Base.Check();
MyPrefabConstants.Check();
MyGameplayConstants.Check();
MyBuildingSpecifications.Check();
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("Preallocate");
Preallocate();
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("IsAdmin");
WindowsIdentity windowsIdentity = WindowsIdentity.GetCurrent();
WindowsPrincipal windowsPrincipal = new WindowsPrincipal(windowsIdentity);
bool IsAdmin = windowsPrincipal.IsInRole(WindowsBuiltInRole.Administrator);
MyMwcLog.WriteLine("IsAdmin " + IsAdmin.ToString());
MyMwcLog.WriteLine("Game dir: " + GameDir);
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("MyCustomGraphicsDeviceManagerDX");
#if !DEBUG
try
{
#endif
this.Exiting += MyMinerGame_Exiting;
this.Activated += MyMinerGame_OnActivated;
this.Deactivated += MyMinerGame_OnDeactivated;
this.m_InvokeQueue = new ConcurrentQueue <Tuple <ManualResetEvent, Action> >();
this.m_MainThread = Thread.CurrentThread;
GraphicsDeviceManager = new MyCustomGraphicsDeviceManagerDX(this);
m_isGraphicsSupported = GraphicsDeviceManager.ChangeProfileSupport();
m_isGraphicsSupported = true;
if (m_isGraphicsSupported)
{
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("MyVideoModeManager.HookEventHandlers");
MyVideoModeManager.HookEventHandlers();
//Content = new MyCustomContentManager(Services, ContentDir);
// Content = new SharpDX.Toolkit.Content.ContentManager(Services);
RootDirectory = Path.Combine(GameDir, "Content");
RootDirectoryDebug = Path.GetFullPath(System.IO.Path.Combine(GameDir, "..\\..\\..\\Content"));
RootDirectoryEffects = RootDirectory;
Static = this;
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("InitNumberOfCores");
InitNumberOfCores();
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("MyVideoModeManager.LogApplicationInformation");
MyVideoModeManager.LogApplicationInformation();
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("MyVideoModeManager.LogInformation");
MyVideoModeManager.LogInformation();
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("MyVideoModeManager.LogEnvironmentInformation");
MyVideoModeManager.LogEnvironmentInformation();
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("MyPlugins.LoadContent");
MyPlugins.LoadContent();
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("MyConfig.Load");
MyConfig.Load();
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("MyMath.Init");
MyMath.Init();
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("MyTextsWrapper.Init");
MyTextsWrapper.Init();
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("MyDialoguesWrapper.Init");
MyDialoguesWrapper.Init();
// If I don't set TargetElapsedTime, default value will be used, which is 60 times per second, and it will be more precise than if I calculate
// it like below - SO I MUST BE DOING THE WRONG CALCULATION !!!
// We use fixed timestep. Update() is called at this precise timesteps. If Update or Draw takes more time, Update will be called more time. Draw is called only after Update.
#if RENDER_PROFILING || GPU_PROFILING
IsFixedTimeStep = false;
MyMinerGame.GraphicsDeviceManager.SynchronizeWithVerticalRetrace = false;
#else
IsFixedTimeStep = MyFakes.FIXED_TIMESTEP;
#endif
}
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("InitMultithreading");
InitMultithreading();
#if !DEBUG
}
catch (Exception ex)
{
// We are catching exceptions in constructor, because if error occures here, it app will start unloading
// so we skip to UnloadContent and there we will get another exception (because app wasn't really loaded when unload started)
// So we want original exception in log.
MyMwcLog.WriteLine(ex);
throw;
}
#endif
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().EndProfilingBlock();
MyMwcLog.DecreaseIndent();
MyMwcLog.WriteLine("MyMinerGame.Constructor() - END");
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().EndProfilingBlock();
}
/// <summary>
/// Removes amout of inventory items from inventory.
/// </summary>
/// <param name="objectBuilder">Item's object builder</param>
/// <param name="amount">Amount to remove</param>
public void RemoveInventoryItemAmount(MyMwcObjectBuilder_Base objectBuilder, float amount)
{
RemoveInventoryItemAmount(objectBuilder.GetObjectBuilderType(), objectBuilder.GetObjectBuilderId(), amount);
}
/// <summary>
/// Returns new instance of object to build with max amount from gameplay properties
/// </summary>
/// <param name="objectBuilder">Object builder</param>
/// <returns>New instance of object to build</returns>
public static MyObjectToBuild CreateFromObjectBuilder(MyMwcObjectBuilder_Base objectBuilder)
{
//warning: use default faction for get gameplay properties for creating object to build
float amount = MyGameplayConstants.GetGameplayProperties(objectBuilder, MyMwcObjectBuilder_FactionEnum.Euroamerican).MaxAmount;
return MyObjectToBuild.CreateFromObjectBuilder(objectBuilder, amount);
}
/// <summary>
/// Adds new inventory item from object builder
/// </summary>
/// <param name="objectBuilder">Item object builder</param>
/// <param name="amount">Amount of inventory item</param>
/// <param name="allAmountAddAsNewInventoryItems">If true, then all amount adds as new inventory items, if false, then try find old inventory items of same type, and add amount to them as first</param>
public float AddInventoryItem(MyMwcObjectBuilder_Base objectBuilder, float amount, bool allAmountAddAsNewInventoryItems, bool increaseCapacityIfIsFull = false)
{
bool added = false;
MyMwcObjectBuilderTypeEnum objectBuilderType = objectBuilder.GetObjectBuilderType();
int?objectBuilderId = objectBuilder.GetObjectBuilderId();
m_helperInventoryItemsForAddAndRemove.Clear();
GetInventoryItems(ref m_helperInventoryItemsForAddAndRemove, objectBuilderType, objectBuilderId);
float amountToAddLeft = amount;
if (!allAmountAddAsNewInventoryItems)
{
foreach (MyInventoryItem inventoryItem in m_helperInventoryItemsForAddAndRemove)
{
if (amountToAddLeft <= 0f)
{
break;
}
float amountToAdd = Math.Min(inventoryItem.MaxAmount - inventoryItem.Amount, amountToAddLeft);
if (InventorySynchronizer != null && InventorySynchronizer.MustBeSynchronized())
{
InventorySynchronizer.AddInventoryItemAmountChangeForSynchronization(objectBuilderType, objectBuilderId, inventoryItem.Amount, amountToAdd);
}
else
{
inventoryItem.Amount += amountToAdd;
}
amountToAddLeft -= amountToAdd;
}
}
while (amountToAddLeft > 0f)
{
if (IsFull)
{
if (increaseCapacityIfIsFull)
{
MaxItems++;
}
else
{
break;
}
}
MyInventoryItem newInventoryItem = MyInventory.CreateInventoryItemFromObjectBuilder(objectBuilder);
float amountToAdd = Math.Min(newInventoryItem.MaxAmount, amountToAddLeft);
//AddInventoryItem(newInventoryItem);
AddItemToInventoryPrivate(newInventoryItem);
newInventoryItem.Amount = amountToAdd; //After AddInventoryItem otherwise Amount event is not called
amountToAddLeft -= amountToAdd;
added = true;
}
if (added)
{
CallContentChange();
}
return(amountToAddLeft);
}
public MyMwcObjectBuilder_InventoryItem(MyMwcObjectBuilder_Base itemObjectBuilder, float amount)
{
ItemObjectBuilder = itemObjectBuilder;
Amount = amount;
}
/// <summary>
/// Returns inventory item's count
/// </summary>
/// <param name="objectBuilder">Item's object builder</param>
/// <returns></returns>
public int GetInventoryItemsCount(MyMwcObjectBuilder_Base objectBuilder)
{
return(GetInventoryItemsCount(objectBuilder.GetObjectBuilderType(), objectBuilder.GetObjectBuilderId()));
}
private int CreateInventoryItemAddToRepository(MyMwcObjectBuilder_Base builder, float amount, MyMwcObjectBuilder_Inventory owner)
{
MyInventoryItem item = MyInventory.CreateInventoryItemFromObjectBuilder(builder, amount);
item.Owner = owner;
return m_itemsRepository.AddItem(item);
}
public bool Read(MyMessageReader msg)
{
StatsBuilder = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(msg.Reader, msg.EndPoint) as MyMwcObjectBuilder_PlayerStatistics;
return(StatsBuilder != null && StatsBuilder.Read(msg.Reader, msg.EndPoint, MyMwcFinalBuildConstants.SERVER_PROTOCOL_VERSION));
}
public MyEditorActionWithObjectBuildersBase(MyMwcObjectBuilder_Base actionObjectBuilder, Matrix matrix)
: base((MyEntity)null)
{
this.Init(1);
ActionObjectBuilders.Add(new ObjectBuilderCreate(actionObjectBuilder, matrix));
}
/// <summary>
/// Creates new instance of object to build
/// </summary>
/// <param name="objectBuilder">Object builder</param>
/// <param name="buildingSpecification">Building specification</param>
/// <param name="amount">Amount</param>
public MyObjectToBuild(MyMwcObjectBuilder_Base objectBuilder, MyBuildingSpecification buildingSpecification, float amount)
{
ObjectBuilder = objectBuilder;
BuildingSpecification = buildingSpecification;
Amount = amount;
}
public bool Read(MyMessageReader msg)
{
Checkpoint = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(msg.Reader, msg.EndPoint) as MyMwcObjectBuilder_Checkpoint;
return(Checkpoint != null &&
Checkpoint.Read(msg.Reader, msg.EndPoint, MyMwcFinalBuildConstants.SERVER_PROTOCOL_VERSION));
}
/// <summary>
/// Returns new instance of object to build with specified amount
/// </summary>
/// <param name="objectBuilder">Object builder</param>
/// <param name="amount">Amount</param>
/// <returns>New instance of object to build</returns>
public static MyObjectToBuild CreateFromObjectBuilder(MyMwcObjectBuilder_Base objectBuilder, float amount)
{
MyBuildingSpecification buildingSpecification = MyBuildingSpecifications.GetBuildingSpecification(objectBuilder);
MyObjectToBuild objectToBuild = new MyObjectToBuild(objectBuilder, buildingSpecification, amount);
return objectToBuild;
}
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);
}
public static MyBuildingSpecification GetBuildingSpecification(MyMwcObjectBuilder_Base objectBuilder)
{
int objectBuilderId = objectBuilder.GetObjectBuilderId() != null
? objectBuilder.GetObjectBuilderId().Value
: 0;
return GetBuildingSpecification(objectBuilder.GetObjectBuilderType(), objectBuilderId);
}
public void NewEntity(MyMwcObjectBuilder_Base objectBuilder, Matrix matrix)
{
Debug.Assert(objectBuilder.EntityId.HasValue, "EntityId must be set");
var msg = new MyEventNewEntity();
msg.ObjectBuilder = objectBuilder;
msg.Position = new MyMwcPositionAndOrientation(matrix);
Peers.SendToAll(ref msg, NetDeliveryMethod.ReliableOrdered, 0, DEFAULT_LARGE_MESSAGE_SIZE);
}
private int CreateInventoryItemAddToRepository(MyMwcObjectBuilder_Base builder, MyMwcObjectBuilder_Inventory owner)
{
return CreateInventoryItemAddToRepository(builder, 1f, owner);
}
public MyMwcObjectBuilder_ObjectToBuild(MyMwcObjectBuilder_Base objectBuilder, float amount)
{
ObjectBuilder = objectBuilder;
Amount = amount;
}
