private static void UnlockResearchSuccess(long identityId, SerializableDefinitionId id)
{
MyDefinitionBase definition;
if (!MyDefinitionManager.Static.TryGetDefinition(id, out definition))
{
Debug.Assert(false, "Stooooooopid Definition is not here!");
return;
}
HashSet <MyDefinitionId> unlockedItems;
if (!Static.m_unlockedResearch.TryGetValue(identityId, out unlockedItems) || unlockedItems == null)
{
unlockedItems = new HashSet <MyDefinitionId>();
}
var research = definition as MyResearchDefinition;
if (research != null)
{
foreach (var entry in research.Entries)
{
unlockedItems.Add(entry);
}
}
unlockedItems.Add(definition.Id);
Static.m_unlockedResearch[identityId] = unlockedItems;
if (MySession.Static.LocalCharacter != null && MySession.Static.LocalCharacter.GetPlayerIdentityId() == identityId)
{
Static.m_unlockedResearchNotification.SetTextFormatArguments(definition.DisplayNameText);
MyHud.Notifications.Add(Static.m_unlockedResearchNotification);
}
}
public void AddQueueItemRequest(MyBlueprintDefinitionBase blueprint, MyFixedPoint ammount, int idx = -1)
{
SerializableDefinitionId id = (SerializableDefinitionId)blueprint.Id;
EndpointId targetEndpoint = new EndpointId();
Sandbox.Engine.Multiplayer.MyMultiplayer.RaiseEvent <MyProductionBlock, int, SerializableDefinitionId, MyFixedPoint>(this, x => new Action <int, SerializableDefinitionId, MyFixedPoint>(x.OnAddQueueItemRequest), idx, id, ammount, targetEndpoint);
}
/// <summary>
/// Puts components back
/// </summary>
private void Return()
{
float allowedVolume = maxTransfer; // volume is in m³ not l
foreach (IMyInventory sourceInv in m_destInventory)
{
if (sourceInv.CurrentVolume > MyFixedPoint.Zero)
{
var items = sourceInv.GetItems();
for (int i = 0; i < items.Count; i++)
{
MyObjectBuilderType baseType = items[i].Content.GetType();
if (baseType != typeof(MyObjectBuilder_Component))
{
continue;
}
SerializableDefinitionId defId = new SerializableDefinitionId(baseType, items[i].Content.SubtypeName);
float oneVol = MyDefinitionManager.Static.GetPhysicalItemDefinition(defId).Volume;
foreach (IMyInventory destInv in m_sourceInventory)
{
if (destInv.CurrentVolume < destInv.MaxVolume - 1 && sourceInv.IsConnectedTo(destInv))
{
int allowedAmount = (int)(allowedVolume / oneVol);
if (allowedAmount <= 0)
{
Log.DebugLog("allowedAmount < 0", Logger.severity.FATAL, condition: allowedAmount < 0);
Log.DebugLog("reached max transfer for this update", Logger.severity.DEBUG);
return;
}
int invSpace = (int)((float)(destInv.MaxVolume - destInv.CurrentVolume) / oneVol);
MyFixedPoint transferAmount = Math.Min(allowedAmount, invSpace);
if (transferAmount > items[i].Amount)
{
transferAmount = items[i].Amount;
}
if (transferAmount > invSpace)
{
transferAmount = invSpace;
}
MyFixedPoint volumeBefore = destInv.CurrentVolume;
if (destInv.TransferItemFrom(sourceInv, 0, stackIfPossible: true, amount: transferAmount))
{
//Log.DebugLog("transfered item from " + (sourceInv.Owner as IMyEntity).getBestName() + " to " + (destInv.Owner as IMyEntity).getBestName() +
// ", amount: " + transferAmount + ", volume: " + (destInv.CurrentVolume - volumeBefore), "Return()");
allowedVolume += (float)(volumeBefore - destInv.CurrentVolume);
}
}
}
}
}
}
Log.DebugLog("finished emptying inventories", Logger.severity.INFO);
m_currentTask = Shop;
}
//private void SettingsRequest(ulong steamid)
//{
// NetSettings.SetValue(Settings.Static);
// Tools.Debug(MyAPIGateway.Utilities.SerializeToXML(Settings.Static));
//}
private void Changed(VRage.Game.ModAPI.Interfaces.IMyControllableEntity o, VRage.Game.ModAPI.Interfaces.IMyControllableEntity n)
{
foreach (WeaponBase w in GridWeapons)
{
w.State.Value &= ~WeaponState.ManualShoot;
}
GridWeapons.Clear();
ControlledGridId = 0;
ActiveTurret = n?.Entity as IMyLargeTurretBase;
if (ActiveTurret == null)
{
ActiveShipController = n?.Entity as IMyShipController;
SelectedDefinitionId = Tools.GetSelectedHotbarDefinition(ActiveShipController);
}
MyCubeGrid grid = (n?.Entity as MyCubeBlock)?.CubeGrid;
if (grid != null)
{
ControlledGridId = grid.EntityId;
foreach (MyCubeBlock block in grid.GetFatBlocks())
{
WeaponControlLayer layer = block.GameLogic.GetAs <WeaponControlLayer>();
if (layer != null)
{
GridWeapons.Add(layer.Weapon);
}
}
}
}
private void AddItemToProduce_Implementation(MyFixedPoint amount, SerializableDefinitionId blueprintId)
{
System.Diagnostics.Debug.Assert(amount > 0, "Adding zero or negative amount!");
MyBlueprintDefinitionBase blueprint = MyDefinitionManager.Static.GetBlueprintDefinition(blueprintId);
if (blueprint == null)
{
System.Diagnostics.Debug.Fail("Couldn't find blueprint definition for: " + blueprintId);
return;
}
MyBlueprintToProduce itemToProduce = m_itemsToProduce.Find(x => x.Blueprint == blueprint);
if (itemToProduce != null)
{
itemToProduce.Amount = itemToProduce.Amount + amount;
}
else
{
itemToProduce = new MyBlueprintToProduce(amount, blueprint);
m_itemsToProduce.Add(itemToProduce);
}
var handler = ProductionChanged;
if (handler != null)
{
handler(this, itemToProduce);
}
}
public SerialId(SerializableDefinitionId id)
{
bool isNull = id.IsNull();
TypeId = isNull ? "MyObjectBuilder_TypeGoesHere" : id.TypeIdString;
SubtypeId = isNull ? "SubtypeGoesHere" : id.SubtypeId;
}
private void MissingRequiredItem_Implementation(SerializableDefinitionId blueprintId, SerializableDefinitionId missingItemId)
{
MyBlueprintDefinitionBase.Item missingItem = default(MyBlueprintDefinitionBase.Item);
MyDefinitionId definitionId = missingItemId;
bool found = false;
MyBlueprintDefinitionBase blueprint = MyDefinitionManager.Static.GetBlueprintDefinition(blueprintId);
if (blueprint == null)
{
System.Diagnostics.Debug.Fail("Couldn't find blueprint definition for: " + blueprintId);
return;
}
foreach (var requiredItem in blueprint.Prerequisites)
{
if (requiredItem.Id == definitionId)
{
missingItem = requiredItem;
found = true;
}
}
if (!found)
{
System.Diagnostics.Debug.Fail("Item " + definitionId + " wasn't found in blueprint " + blueprint);
}
var handler = MissingRequiredItem;
if (handler != null && found)
{
handler(this, blueprint, missingItem);
}
}
public static MyDefinitionBase GetItemDefinition(this MyPhysicalInventoryItem thisItem)
{
MyPhysicalItemDefinition definition2;
if (thisItem.Content == null)
{
return(null);
}
MyDefinitionBase base2 = null;
if (thisItem.Content is MyObjectBuilder_BlockItem)
{
SerializableDefinitionId blockDefId = (thisItem.Content as MyObjectBuilder_BlockItem).BlockDefId;
MyCubeBlockDefinition blockDefinition = null;
if (MyDefinitionManager.Static.TryGetCubeBlockDefinition(blockDefId, out blockDefinition))
{
base2 = blockDefinition;
}
}
else
{
base2 = MyDefinitionManager.Static.TryGetComponentBlockDefinition(thisItem.Content.GetId());
}
if ((base2 == null) && MyDefinitionManager.Static.TryGetPhysicalItemDefinition(thisItem.Content.GetId(), out definition2))
{
base2 = definition2;
}
return(base2);
}
public override void ConsumeItem(MyDefinitionId itemId, MyFixedPoint amount, long consumerEntityId = 0L)
{
SerializableDefinitionId id = (SerializableDefinitionId)itemId;
EndpointId targetEndpoint = new EndpointId();
MyMultiplayer.RaiseEvent <MyInventoryAggregate, MyFixedPoint, SerializableDefinitionId, long>(this, x => new Action <MyFixedPoint, SerializableDefinitionId, long>(x.InventoryConsumeItem_Implementation), amount, id, consumerEntityId, targetEndpoint);
}
private static void SpawnIntoContainer_Implementation(long amount, SerializableDefinitionId item, long entityId, long playerId)
{
if (!MyEventContext.Current.IsLocallyInvoked && !MySession.Static.HasPlayerCreativeRights(MyEventContext.Current.Sender.Value))
{
MyEventContext.ValidationFailed();
return;
}
MyEntity entity;
if (!MyEntities.TryGetEntityById(entityId, out entity))
{
return;
}
if (!entity.HasInventory || !((MyTerminalBlock)entity).HasPlayerAccess(playerId))
{
return;
}
MyInventory inventory = entity.GetInventory();
if (!inventory.CheckConstraint(item))
{
return;
}
MyFixedPoint itemAmt = (MyFixedPoint)Math.Min(amount, (decimal)inventory.ComputeAmountThatFits(item));
inventory.AddItems(itemAmt, (MyObjectBuilder_PhysicalObject)MyObjectBuilderSerializer.CreateNewObject(item));
}
private void ReloadIce(MyEntity gun, SerializableDefinitionId ammo)
{
var cGun = gun;
MyInventory inv = cGun.GetInventory(0);
VRage.MyFixedPoint point = inv.GetItemAmount(ammo, MyItemFlags.None | MyItemFlags.Damaged);
if (point.RawValue > 1000000)
{
return;
}
//inv.Clear();
VRage.MyFixedPoint amount = new VRage.MyFixedPoint();
amount.RawValue = 2000000;
MyObjectBuilder_InventoryItem ii = new MyObjectBuilder_InventoryItem()
{
Amount = 100,
Content = new MyObjectBuilder_Ore()
{
SubtypeName = ammo.SubtypeName
}
};
inv.AddItems(amount, ii.Content);
}
private void OnSpawnIntoContainer(MyGuiControlButton myGuiControlButton)
{
if (!IsValidAmount())
{
m_errorLabel.Visible = true;
return;
}
MyCharacterDetectorComponent comp;
if (MySession.Static.LocalCharacter == null || !MySession.Static.LocalCharacter.Components.TryGet(out comp))
{
return;
}
MyTerminalBlock entity = comp.DetectedEntity as MyTerminalBlock;
if (entity == null || !entity.HasInventory)
{
return;
}
SerializableDefinitionId itemId = m_physicalItemDefinitions[(int)m_physicalObjectCombobox.GetSelectedKey()].Id;
if (Sync.IsServer)
{
SpawnIntoContainer_Implementation(m_amount, itemId, entity.EntityId, MySession.Static.LocalPlayerId);
}
else
{
MyMultiplayer.RaiseStaticEvent(x => SpawnIntoContainer_Implementation, m_amount, itemId, entity.EntityId, MySession.Static.LocalPlayerId);
}
}
private static void PaletteUpdateClient(int index, SerializableDefinitionId id, int verifyHash)
{
var mgr = MySession.Static.Components?.Get <ConstructableController>();
if (mgr == null)
{
MySession.Static.Log.Warning($"Requested partial palette update and we don't have a constructable controller");
return;
}
lock (mgr)
{
while (mgr._definitionPalette.Count <= index)
{
mgr._definitionPalette.Add(default(MyDefinitionId));
}
mgr._definitionPalette[index] = id;
mgr._definitionPaletteMap[id] = index;
}
int hash = mgr.HashPalette();
if (hash == verifyHash)
{
return;
}
mgr.GetLogger().Warning($"Palette verification failed, reacquiring");
MyMultiplayerModApi.Static.RaiseStaticEvent(s => PaletteRequestUpdateServer);
}
public ControlAction(
IMyTerminalBlock block,
string internalName,
string name,
string icon)
{
Name = name;
Definition = block.BlockDefinition;
InternalName = internalName + Definition.SubtypeId;
var controls = new List <IMyTerminalAction>();
MyAPIGateway.TerminalControls.GetActions <T>(out controls);
var control = controls.Find((x) => x.Id.ToString() == InternalName);
if (control == null)
{
var action = MyAPIGateway.TerminalControls.CreateAction <T>(InternalName);
action.Action = OnAction;
action.Name = new StringBuilder(Name);
action.Enabled = Visible;
action.Writer = Writer;
action.Icon = icon;
MyAPIGateway.TerminalControls.AddAction <T>(action);
}
}
public void AddResearchGroup(SerializableDefinitionId compDef, List <SerializableDefinitionId> defList)
{
var group = new ResearchGroup(compDef, defList);
ResearchGroups[compDef] = group;
ResearchGroupList.Add(group);
}
public MiningEntry(MyObjectBuilder_VoxelMiningDefinition_MiningDef item)
{
var dictionary = new Dictionary <MyDefinitionId, int>();
if (item.MinedItems != null)
{
foreach (MyObjectBuilder_VoxelMiningDefinition_MinedItem minedItem in item.MinedItems)
{
var sid = new SerializableDefinitionId
{
TypeIdString = minedItem.Type,
SubtypeName = minedItem.Subtype
};
dictionary[sid] = minedItem.Amount;
}
}
MinedItems = dictionary;
var num = item.Volume.HasValue ? Math.Max(item.Volume.Value, 1) : 64;
var materialDefinition = MyDefinitionManager.Get <MyVoxelMaterialDefinition>(item.VoxelMaterial);
if (materialDefinition == null || materialDefinition.Index == byte.MaxValue)
{
MySession.Static.Log.Warning($"Cannot find voxel material {item.VoxelMaterial}");
Material = MyVoxelMaterialDefinition.Default;
Volume = 64;
}
else
{
Material = materialDefinition;
Volume = num;
}
}
private void RemoveItemToProduce_Request(MyFixedPoint amount, SerializableDefinitionId blueprintId, long senderEntityId, int itemId = -1)
{
if (IsLocked && senderEntityId != m_lockedByEntityId)
{
return;
}
MyMultiplayer.RaiseEvent(this, x => x.RemoveItemToProduce_Implementation, amount, blueprintId, itemId);
}
private void AddItemToRepair_Request(MyFixedPoint amount, SerializableDefinitionId blueprintId, long senderEntityId, uint inventoryItemId, MyObjectBuilderType inventoryItemType, MyStringHash inventoryItemSubtypeId)
{
if (IsLocked && senderEntityId != m_lockedByEntityId)
{
return;
}
MyMultiplayer.RaiseEvent(this, x => x.AddItemToRepair_Implementation, amount, blueprintId, inventoryItemId, inventoryItemType, inventoryItemSubtypeId);
}
static void CreateNewPlaceArea(SerializableDefinitionId id, MyPositionAndOrientation positionAndOrientation)
{
MyObjectBuilder_AreaMarker objectBuilder = (MyObjectBuilder_AreaMarker)MyObjectBuilderSerializer.CreateNewObject(id);
objectBuilder.PersistentFlags = MyPersistentEntityFlags2.Enabled | MyPersistentEntityFlags2.InScene;
objectBuilder.PositionAndOrientation = positionAndOrientation;
MyEntities.CreateFromObjectBuilderAndAdd(objectBuilder);
}
public BaseControl(
IMyTerminalBlock block,
string internalName,
string title)
{
Definition = block.BlockDefinition;
InternalName = internalName + Definition.SubtypeId;
Title = title;
}
private void Reload(MyEntity gun, SerializableDefinitionId ammo, bool reactor = false)
{
var cGun = gun;
MyInventory inv = cGun.GetInventory(0);
VRage.MyFixedPoint amount = new VRage.MyFixedPoint();
amount.RawValue = 2000000;
var hasEnough = inv.ContainItems(amount, new MyObjectBuilder_Ingot()
{
SubtypeName = ammo.SubtypeName
});
VRage.MyFixedPoint point = inv.GetItemAmount(ammo, MyItemFlags.None | MyItemFlags.Damaged);
if (hasEnough)
{
return;
}
//inv.Clear();
Logger.Debug(ammo.SubtypeName + " [ReloadGuns] Amount " + amount);
MyObjectBuilder_InventoryItem ii;
if (reactor)
{
Logger.Debug(ammo.SubtypeName + " [ReloadGuns] loading reactor " + point.RawValue);
ii = new MyObjectBuilder_InventoryItem()
{
Amount = 10,
Content = new MyObjectBuilder_Ingot()
{
SubtypeName = ammo.SubtypeName
}
};
Logger.Debug(ammo.SubtypeName + " [ReloadGuns] loading reactor 2 " + point.RawValue);
}
else
{
Logger.Debug(ammo.SubtypeName + " [ReloadGuns] loading guns " + point.RawValue);
ii = new MyObjectBuilder_InventoryItem()
{
Amount = 4,
Content = new MyObjectBuilder_AmmoMagazine()
{
SubtypeName = ammo.SubtypeName
}
};
Logger.Debug(ammo.SubtypeName + " [ReloadGuns] loading guns 2 " + point.RawValue);
}
//inv.
Logger.Debug(amount + " Amount : content " + ii.Content);
inv.AddItems(amount, ii.Content);
point = inv.GetItemAmount(ammo, MyItemFlags.None | MyItemFlags.Damaged);
}
IMyInventoryItem IMyInventory.FindItem(SerializableDefinitionId contentId)
{
MyPhysicalInventoryItem?item = FindItem(contentId);
if (item != null)
{
return(item.Value);
}
return(null);
}
public void RemoveItemToProduce(MyFixedPoint amount, MyBlueprintToProduce blueprintInProduction, long senderEntityId)
{
SerializableDefinitionId blueprintId = blueprintInProduction.Blueprint.Id;
int itemId = m_itemsToProduce.IndexOf(blueprintInProduction);
if (m_itemsToProduce.IsValidIndex(itemId))
{
MyMultiplayer.RaiseEvent(this, x => x.RemoveItemToProduce_Request, amount, blueprintId, senderEntityId, itemId);
}
}
/**
* Handler for multiplayer events.
*
* Depending on the provided module definition the event may be coming from server to clients or from a clientto the server.
*/
public void HandleItemEvent(int logicalItem, SerializableDefinitionId def, object data, bool fromClient)
{
if (typeof(MyObjectBuilder_ProceduralEnvironmentModuleDefinition).IsAssignableFrom(def.TypeId))
{
// If our object builder is for a storage module we must deliver the event to the related module in this end.
var modDef = MyDefinitionManager.Static.GetDefinition <MyProceduralEnvironmentModuleDefinition>(def);
if (modDef == null)
{
MyLog.Default.Error("Received message about unknown logical module {0}", def);
return;
}
ModuleData mod;
if (m_modules.TryGetValue(modDef.ModuleType, out mod))
{
mod.Module.HandleSyncEvent(logicalItem, data, fromClient);
}
}
else
{
// otherwise we must notify all proxy modules in our views if they contain the same item.
var modDef = MyDefinitionManager.Static.GetDefinition <MyEnvironmentModuleProxyDefinition>(def);
if (modDef == null)
{
MyLog.Default.Error("Received message about unknown module proxy {0}", def);
return;
}
foreach (var view in Viewers)
{
if (view.Listener != null)
{
var mod = view.Listener.GetModule(modDef.ModuleType);
// Compute view offset
var sector = view.GetSectorIndex(X, Y);
var offset = view.SectorOffsets[sector];
if (logicalItem < ItemCountForLod[view.Lod])
{
if (mod != null)
{
mod.HandleSyncEvent(logicalItem + offset, data, fromClient);
}
}
}
}
}
}
void ChangeListId(SerializableDefinitionId id, bool wasAdded)
{
if (!Sync.MultiplayerActive)
{
DoChangeListId(id, wasAdded);
}
else
{
m_sync.ChangeListId(id, wasAdded);
}
}
private void OnAddQueueItemRequest(int idx, SerializableDefinitionId defId, MyFixedPoint ammount)
{
var blueprint = MyDefinitionManager.Static.GetBlueprintDefinition(defId);
Debug.Assert(blueprint != null, "Blueprint not present in the dictionary.");
if (blueprint != null)
{
this.InsertQueueItem(idx, blueprint, ammount);
MyMultiplayer.RaiseEvent(this, x => x.OnAddQueueItemSuccess, idx, defId, ammount);
}
}
static bool DoChangeListId(long EntityId, SerializableDefinitionId id, bool add)
{
MyEntity entity;
MyEntities.TryGetEntityById(EntityId, out entity);
if (entity != null)
{
return(((MyConveyorSorter)entity).DoChangeListId(id, add));
}
return(false);
}
//remove item from research list
public void RemoveRequiredResearch(MyDefinitionId itemId)
{
if (itemId.TypeId.IsNull || itemId.SubtypeId == null)
{
Debug.Fail("Provided typeId is invalid: " + itemId.ToString());
return;
}
SerializableDefinitionId serializableId = itemId;
MyMultiplayer.RaiseStaticEvent(x => RemoveRequiredResearchSync, serializableId);
}
private static void RemoveRequiredResearchSync(SerializableDefinitionId itemId)
{
MyDefinitionBase definition;
if (!MyDefinitionManager.Static.TryGetDefinition(itemId, out definition))
{
return;
}
Static.m_requiredResearch.Remove(definition.Id);
}
//unlock player research
public void UnlockResearchDirect(long characterId, MyDefinitionId itemId)
{
if (itemId.TypeId.IsNull || itemId.SubtypeId == null)
{
Debug.Fail("Provided typeId is invalid: " + itemId.ToString());
return;
}
SerializableDefinitionId serializableId = itemId;
MyMultiplayer.RaiseStaticEvent(x => UnlockResearchDirectSync, characterId, serializableId);
}
internal bool DoChangeListId(SerializableDefinitionId id, bool add)
{
if (add)
m_inventoryConstraint.Add(id);
else
m_inventoryConstraint.Remove(id);
if (m_allowCurrentListUpdate)
currentList.UpdateVisual();
return true;
}
void ChangeListId(SerializableDefinitionId id, bool wasAdded)
{
if (!Sync.MultiplayerActive)
DoChangeListId(id, wasAdded);
else
m_sync.ChangeListId(id, wasAdded);
}
private void InventoryConsumeItem_Implementation(MyFixedPoint amount, SerializableDefinitionId itemId, long consumerEntityId)
{
if ((consumerEntityId != 0 && !MyEntities.EntityExists(consumerEntityId)))
{
return;
}
var existingAmount = GetItemAmount(itemId);
if (existingAmount < amount)
amount = existingAmount;
MyEntity entity = null;
if (consumerEntityId != 0)
{
entity = MyEntities.GetEntityById(consumerEntityId);
if (entity == null)
return;
}
if (entity.Components != null)
{
var statComp = entity.Components.Get<MyEntityStatComponent>() as MyCharacterStatComponent;
if (statComp != null)
{
var definition = MyDefinitionManager.Static.GetDefinition(itemId) as MyConsumableItemDefinition;
statComp.Consume(amount, definition);
var character = entity as MyCharacter;
if (character != null)
character.SoundComp.StartSecondarySound(definition.EatingSound, true);
}
}
RemoveItemsOfType(amount, itemId);
}
void SwitchToWeaponMessage(SerializableDefinitionId? weapon, uint? inventoryItemId)
{
if (CanSwitchToWeapon(weapon) == false)
{
return;
}
if (inventoryItemId != null)
{
var inventory = this.GetInventory();
if (inventory != null)
{
var item = inventory.GetItemByID(inventoryItemId.Value);
if (item.HasValue)
{
var itemId = MyDefinitionManager.Static.ItemIdFromWeaponId(weapon.Value);
if (itemId.HasValue && item.Value.Content.GetObjectId() == itemId.Value)
{
long weaponEntityId = MyEntityIdentifier.AllocateId();
SwitchToWeaponSuccess(weapon, inventoryItemId, weaponEntityId);
MyMultiplayer.RaiseEvent(this, x => x.OnSwitchToWeaponSuccess, weapon, inventoryItemId, weaponEntityId);
}
}
}
}
else if (weapon != null)
{
long weaponEntityId = MyEntityIdentifier.AllocateId();
SwitchToWeaponSuccess(weapon, inventoryItemId, weaponEntityId);
MyMultiplayer.RaiseEvent(this, x => x.OnSwitchToWeaponSuccess, weapon, inventoryItemId, weaponEntityId);
}
else
{
MyMultiplayer.RaiseEvent(this, x => x.UnequipWeapon);
}
}
void OnSwitchToWeaponSuccess(SerializableDefinitionId? weapon, uint? inventoryItemId, long weaponEntityId)
{
SwitchToWeaponSuccess(weapon, inventoryItemId, weaponEntityId);
}
void OnRefillFromBottle(SerializableDefinitionId gasId)
{
if (this == MySession.Static.LocalCharacter && OxygenComponent != null)
{
OxygenComponent.ShowRefillFromBottleNotification(gasId);
}
}
void UpdateStoredGas_Implementation(SerializableDefinitionId gasId, float fillLevel)
{
if (OxygenComponent == null)
return;
MyDefinitionId definition = gasId;
OxygenComponent.UpdateStoredGasLevel(ref definition, fillLevel);
}
public void ChangeListId(SerializableDefinitionId id, bool add)
{
ListChangeIdMsg msg=new ListChangeIdMsg();
msg.EntityId=m_Parent.EntityId;
msg.Id=id;
msg.Add=add;
if (!Sync.IsServer)
Sync.Layer.SendMessageToServer(ref msg, MyTransportMessageEnum.Request);
else
if (m_Parent.DoChangeListId(id,add))
Sync.Layer.SendMessageToAll(ref msg, MyTransportMessageEnum.Success);
}
private void InventoryConsumeItem_Implementation(MyFixedPoint amount, SerializableDefinitionId itemId, long consumerEntityId)
{
if ((consumerEntityId != 0 && !MyEntities.EntityExists(consumerEntityId)))
{
return;
}
var existingAmount = GetItemAmount(itemId);
if (existingAmount < amount)
amount = existingAmount;
MyEntity entity = null;
if (consumerEntityId != 0)
{
entity = MyEntities.GetEntityById(consumerEntityId);
if (entity == null)
return;
}
bool removeItem = true;
if (entity.Components != null)
{
var definition = MyDefinitionManager.Static.GetDefinition(itemId) as MyUsableItemDefinition;
if (definition != null)
{
var character = entity as MyCharacter;
if (character != null)
character.SoundComp.StartSecondarySound(definition.UseSound, true);
var consumableDef = definition as MyConsumableItemDefinition;
if (consumableDef != null)
{
var statComp = entity.Components.Get<MyEntityStatComponent>() as MyCharacterStatComponent;
if (statComp != null)
{
statComp.Consume(amount, consumableDef);
}
}
var schematicDef = definition as MySchematicItemDefinition;
if (schematicDef != null)
removeItem &= MySessionComponentResearch.Static.UnlockResearch(character, schematicDef.Research);
}
}
if (removeItem)
RemoveItemsOfType(amount, itemId);
}
static bool DoChangeListId(long EntityId, SerializableDefinitionId id, bool add)
{
MyEntity entity;
MyEntities.TryGetEntityById(EntityId, out entity);
if (entity != null)
{
return ((MyConveyorSorter)entity).DoChangeListId(id,add);
}
return false;
}
