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); }
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)); } }
// 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; }
// 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 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 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; }