public override string ToString()
{
var builder = new StringBuilder(1024);
builder.AppendLine("MyProceduralConstructionSeed[");
builder.Append("\tName=\"").Append(Name).AppendLine("\"");
builder.Append("\tSeed=").AppendLine(Seed.ToString());
builder.Append("\tLocation=").AppendLine(Location.ToString());
builder.Append("\tOrientation=").AppendLine(Orientation.ToString());
builder.Append("\tSpeciality=").AppendLine(Speciality.ToString());
builder.Append("\tPopulation=").Append(Population).AppendLine();
builder.Append("\tSpecialityExport=");
builder.AppendLine(SpecialityExport?.ToString() ?? "None");
builder.Append("\tFaction=").AppendLine(Faction.ToString().Replace("\n", "\n\t"));
builder.AppendLine("\tExports=[");
foreach (var kv in m_exports)
{
builder.Append("\t\t").Append(kv.Key).Append("=").AppendLine(kv.Value.ToString());
}
builder.AppendLine("\t]");
builder.AppendLine("\tImports=[");
foreach (var kv in m_imports)
{
builder.Append("\t\t").Append(kv.Key).Append("=").AppendLine(kv.Value.ToString());
}
builder.AppendLine("\t]");
builder.AppendLine("\tLocal Storage=[");
foreach (var kv in m_localStorage)
{
builder.Append("\t\t").Append(kv.Key).Append("=").AppendLine(kv.Value.ToString());
}
builder.AppendLine("\t]");
builder.AppendLine("\tBlock Counts=[");
foreach (var kv in m_blockCountRequirements)
{
builder.Append("\t\t").Append(kv.Key).Append("=").AppendLine(kv.Value.ToString());
}
builder.AppendLine("\t]");
builder.AppendLine("]");
return(builder.ToString());
}
public void Postprocess()
{
bool valid = true;
int max = 0;
foreach (var component in m_postprocessBuilder.Components)
{
if (component.Amount > max)
max = component.Amount;
}
for (int i = 0; i < max; ++i)
{
m_components.Add(null);
}
foreach (var component in m_postprocessBuilder.Components)
{
MyComponentDefinition componentDef;
var compoDefId = new MyDefinitionId(typeof(MyObjectBuilder_Component), component.SubtypeId);
MyDefinitionManager.Static.TryGetDefinition<MyComponentDefinition>(compoDefId, out componentDef);
MyDebug.AssertDebug(componentDef != null, "Cannot find component " + compoDefId.ToString());
if (componentDef == null)
valid = false;
SetComponentDefinition(component.Amount, componentDef);
}
for (int i = 0; i < m_components.Count; ++i)
{
MyDebug.AssertDebug(m_components[i] != null, "Missing component definition for amount "+(i+1).ToString()+" in component group "+this.Id.ToString());
if (m_components[i] == null)
valid = false;
}
if (valid == false)
{
m_components.Clear();
}
}
private long SpawnInventoryContainer(MyDefinitionId bagDefinition, MyInventory inventory, bool spawnAboveCharacter = true)
{
//TODO: this should not be here but we have to know if session is being closed if so then no new entity will be created.
// Entity closing method and event should have parameter with sessionIsClosing.
if (Sandbox.Game.World.MySession.Static == null || !Sandbox.Game.World.MySession.Static.Ready)
return 0;
MyEntity builder = Character;
var worldMatrix = Character.WorldMatrix;
if (spawnAboveCharacter)
{
worldMatrix.Translation += worldMatrix.Up + worldMatrix.Forward;
}
else
{
Vector3 modelCenter = Character.Render.GetModel().BoundingBox.Center;
Vector3 translationToCenter = Vector3.Transform(modelCenter, worldMatrix);
worldMatrix.Translation = translationToCenter;
}
MyContainerDefinition containerDefinition;
if (!MyComponentContainerExtension.TryGetContainerDefinition(bagDefinition.TypeId, bagDefinition.SubtypeId, out containerDefinition))
{
System.Diagnostics.Debug.Fail("Entity container definition: " + bagDefinition.ToString() + " was not found!");
return 0;
}
MyEntity entity = MyEntities.CreateFromComponentContainerDefinitionAndAdd(containerDefinition.Id);
System.Diagnostics.Debug.Assert(entity != null);
if (entity == null)
return 0;
entity.PositionComp.SetWorldMatrix(worldMatrix);
entity.Physics.LinearVelocity = builder.Physics.LinearVelocity;
entity.Physics.AngularVelocity = builder.Physics.AngularVelocity;
inventory.RemoveEntityOnEmpty = true;
entity.Components.Add<MyInventoryBase>(inventory);
return entity.EntityId;
}
public static void AddToInventory(string entityname, MyDefinitionId itemId, int amount = 1)
{
var entity = GetEntityByName(entityname);
if (entity == null)
{
Debug.Fail("Entity of name: " + entityname + " was not found.");
return;
}
var inventory = entity.GetInventoryBase();
if (inventory == null)
{
Debug.Fail("Entity of name: " + entityname + " has no inventory.");
return;
}
var ob = (MyObjectBuilder_PhysicalObject)MyObjectBuilderSerializer.CreateNewObject(itemId);
var amountInFixedPoint = new MyFixedPoint();
amountInFixedPoint = amount;
if (!inventory.AddItems(amountInFixedPoint, ob))
Debug.Fail("Item: " + itemId.ToString() + " Amount: " + amount + " Adding to inventory failed. (Probably not enough space.)");
}
public static void AddToPlayersInventory(long playerId, MyDefinitionId itemId, int amount = 1)
{
var identity = MySession.Static.Players.TryGetIdentity(playerId);
if (identity != null)
{
var inventory = identity.Character.GetInventory();
if (inventory != null)
{
var ob = (MyObjectBuilder_PhysicalObject)MyObjectBuilderSerializer.CreateNewObject(itemId);
var amountInFixedPoint = new MyFixedPoint();
amountInFixedPoint = amount;
if (!inventory.AddItems(amountInFixedPoint, ob))
Debug.Fail("Item: " + itemId.ToString() + " Amount: " + amount + " Adding to inventory failed. (Probably not enough space.)");
}
}
}
public bool SpawnInventoryContainer(bool spawnAboveEntity = true)
{
//TODO: this should not be here but we have to know if session is being closed if so then no new entity will be created.
// Entity closing method and event should have parameter with sessionIsClosing.
if (Sandbox.Game.World.MySession.Static == null || !Sandbox.Game.World.MySession.Static.Ready)
{
return(false);
}
var ownerEntity = Entity as MyEntity;
for (int i = 0; i < ownerEntity.InventoryCount; ++i)
{
var inventory = ownerEntity.GetInventory(i);
if (inventory != null && inventory.GetItemsCount() > 0)
{
MyEntity inventoryOwner = Entity as MyEntity;
var worldMatrix = inventoryOwner.WorldMatrix;
if (spawnAboveEntity)
{
Vector3 upDir = -Sandbox.Game.GameSystems.MyGravityProviderSystem.CalculateNaturalGravityInPoint(inventoryOwner.PositionComp.GetPosition());
if (upDir == Vector3.Zero)
{
upDir = Vector3.Up;
}
upDir.Normalize();
Vector3 forwardDir = Vector3.CalculatePerpendicularVector(upDir);
var ownerPosition = worldMatrix.Translation;
var ownerAabb = inventoryOwner.PositionComp.WorldAABB;
for (int moveIter = 0; moveIter < 20; ++moveIter)
{
var newPosition = ownerPosition + 0.1f * moveIter * upDir + 0.1f * moveIter * forwardDir;
var aabb = new BoundingBoxD(newPosition - 0.25 * Vector3D.One, newPosition + 0.25 * Vector3D.One);
if (!aabb.Intersects(ref ownerAabb))
{
// Move newPosition a little to avoid collision with fractured pieces.
worldMatrix.Translation = newPosition + 0.25f * upDir;
break;
}
}
if (worldMatrix.Translation == ownerPosition)
{
worldMatrix.Translation += upDir + forwardDir;
}
}
else
{
var model = (inventoryOwner.Render.ModelStorage as MyModel);
if (model != null)
{
Vector3 modelCenter = model.BoundingBox.Center;
Vector3 translationToCenter = Vector3.Transform(modelCenter, worldMatrix);
worldMatrix.Translation = translationToCenter;
}
}
MyContainerDefinition entityDefinition;
if (!MyComponentContainerExtension.TryGetContainerDefinition(m_containerDefinition.TypeId, m_containerDefinition.SubtypeId, out entityDefinition))
{
System.Diagnostics.Debug.Fail("Container Definition: " + m_containerDefinition.ToString() + " was not found!");
return(false);
}
MyEntity entity = MyEntities.CreateFromComponentContainerDefinitionAndAdd(entityDefinition.Id);
System.Diagnostics.Debug.Assert(entity != null);
if (entity == null)
{
return(false);
}
entity.PositionComp.SetWorldMatrix(worldMatrix);
System.Diagnostics.Debug.Assert(inventoryOwner != null, "Owner is not set!");
if (inventoryOwner.InventoryCount == 1)
{
inventoryOwner.Components.Remove <MyInventoryBase>();
}
else
{
var aggregate = inventoryOwner.GetInventoryBase() as MyInventoryAggregate;
if (aggregate != null)
{
aggregate.RemoveComponent(inventory);
}
else
{
System.Diagnostics.Debug.Fail("Inventory owners indicates that it owns more inventories, but doesn't have aggregate?");
return(false);
}
}
// Replaces bag default inventory with existing one.
entity.Components.Add <MyInventoryBase>(inventory);
inventory.RemoveEntityOnEmpty = true;
entity.Physics.LinearVelocity = Vector3.Zero;
entity.Physics.AngularVelocity = Vector3.Zero;
if (ownerEntity.Physics != null)
{
entity.Physics.LinearVelocity = ownerEntity.Physics.LinearVelocity;
entity.Physics.AngularVelocity = ownerEntity.Physics.AngularVelocity;
}
else if (ownerEntity is MyCubeBlock)
{
var grid = (ownerEntity as MyCubeBlock).CubeGrid;
if (grid.Physics != null)
{
entity.Physics.LinearVelocity = grid.Physics.LinearVelocity;
entity.Physics.AngularVelocity = grid.Physics.AngularVelocity;
}
}
return(true);
}
}
return(false);
}
public WeaponCoreProfile(IMyRemoteControl remoteControl, IMyTerminalBlock block, WeaponDefinition definition, int id) : base(remoteControl, block)
{
IsWeaponCore = true;
_weaponCoreDefinition = definition;
_weaponIndex = id;
if (_weaponCoreDefinition.Ammos.Length > 0)
{
int index = 0;
for (int i = 0; i < _weaponCoreDefinition.Ammos.Length; i++)
{
var definitionId = new MyDefinitionId(typeof(MyObjectBuilder_AmmoMagazine), _weaponCoreDefinition.Ammos[i].AmmoMagazine);
try {
var ammoDef = MyDefinitionManager.Static.GetAmmoMagazineDefinition(definitionId);
if (!_allAmmoMagazines.Contains(ammoDef))
{
_allAmmoMagazines.Add(ammoDef);
}
} catch (Exception e) {
Logger.MsgDebug("Could Not Get AmmoMagazine Definition From ID: " + definitionId.ToString(), DebugTypeEnum.Weapon);
}
}
if (_allAmmoMagazines.Count == 0)
{
_weaponDefinitionHasNoAmmo = true;
_weaponValid = false;
return;
}
else
{
Logger.MsgDebug("Total MyAmmoMagazineDefinition counts: " + _allAmmoMagazines.Count.ToString(), DebugTypeEnum.WeaponCore);
}
}
else
{
_weaponDefinitionHasNoAmmo = true;
_weaponValid = false;
return;
}
OwnershipCheck(_weaponBlock);
}
public static int CalculateItemMinimalPrice(MyDefinitionId itemId, float baseCostProductionSpeedMultiplier)
{
try {
int minimalPrice = -1;
//First, try to see if item definition has a minimum price already (for ore,ingot,component)
MyPhysicalItemDefinition definition = null;
if (MyDefinitionManager.Static.TryGetDefinition(itemId, out definition) && definition.MinimalPricePerUnit != -1)
{
//Has minimal price, so just use that.
minimalPrice += definition.MinimalPricePerUnit;
return(minimalPrice);
}
MyBlueprintDefinitionBase definition2 = null;
//Try to get a blueprint where the result is the item we are checking
if (!MyDefinitionManager.Static.TryGetBlueprintDefinitionByResultId(itemId, out definition2))
{
if (ItemsWithBadValue.Contains(itemId) == false)
{
ItemsWithBadValue.Add(itemId);
}
return(minimalPrice);
}
if (UsedBlueprints.Contains(definition2) == true)
{
//Logger.AddMsg("Cannot Create Economy Value For Item: " + itemId.ToString() + " - Blueprint Already Used Or Gets Stuck In Loop.");
return(minimalPrice);
}
UsedBlueprints.Add(definition2);
float num = definition.IsIngot ? 1f : MyAPIGateway.Session.AssemblerEfficiencyMultiplier;
int num2 = 0;
MyBlueprintDefinitionBase.Item[] prerequisites = definition2.Prerequisites;
bool hasBadValue = false;
foreach (MyBlueprintDefinitionBase.Item item in prerequisites)
{
int minimalPrice2 = CalculateItemMinimalPrice(item.Id, baseCostProductionSpeedMultiplier);
float num3 = (float)item.Amount / num;
num2 += (int)((float)minimalPrice2 * num3);
if (minimalPrice2 <= 0)
{
hasBadValue = true;
if (ItemsWithBadValue.Contains(item.Id) == false)
{
ItemsWithBadValue.Add(item.Id);
}
}
}
if (hasBadValue == true)
{
if (ItemsWithBadValue.Contains(itemId) == false)
{
ItemsWithBadValue.Add(itemId);
}
}
float num4 = definition.IsIngot ? MyAPIGateway.Session.RefinerySpeedMultiplier : MyAPIGateway.Session.AssemblerSpeedMultiplier;
int num5 = 0;
MyBlueprintDefinitionBase.Item item2;
while (true)
{
if (num5 < definition2.Results.Length)
{
item2 = definition2.Results[num5];
if (item2.Id == itemId)
{
break;
}
num5++;
continue;
}
return(minimalPrice);
}
float num6 = (float)item2.Amount;
float num7 = 1f + (float)Math.Log(definition2.BaseProductionTimeInSeconds + 1f) * baseCostProductionSpeedMultiplier / num4;
minimalPrice += (int)((float)num2 * (1f / num6) * num7);
return(minimalPrice);
} catch (Exception e) {
Logger.AddMsg("Caught Exception While Processing Economy Price For Item ID " + itemId.ToString());
Logger.AddMsg(e.ToString());
}
return(-1);
}
public void Main(string argument, UpdateType updateSource)
{
// for each item:
// find total in inventory
// find total queued
// find missing based on limits
// prioritize based on %missing
// enqueue work unit if total < total desired and < max work units
// check setup...
bool exit = false;
IMyBlockGroup assemblerGroup = GridTerminalSystem.GetBlockGroupWithName(assemblerGroupName);
if (assemblerGroup == null)
{
exit = true;
Echo($"Assembler Group {assemblerGroupName} not found.");
}
IMyBlockGroup containerGroup = GridTerminalSystem.GetBlockGroupWithName(partsContainersGroupName);
if (containerGroup == null)
{
exit = true;
Echo($"Container Group {partsContainersGroupName} not found.");
}
List <IMyAssembler> assemblers = new List <IMyAssembler>();
List <IMyEntity> containers = new List <IMyEntity>();
List <IMyAssembler> primaries = new List <IMyAssembler>();
assemblerGroup.GetBlocksOfType(assemblers);
assemblerGroup.GetBlocksOfType(primaries, a => !a.CooperativeMode && a.Enabled && a.Mode == MyAssemblerMode.Assembly);
if (primaries.Count == 0)
{
exit = true;
Echo($"No primary assembler found");
}
if (exit)
{
return;
}
// we at least have an assembler that can queue and a container to count.
containerGroup.GetBlocksOfType(containers);
// assemblers are also containers so add them in. Use a HashSet for deduping
HashSet <IMyEntity> allContainers = new HashSet <IMyEntity>();
allContainers.UnionWith(containers);
allContainers.UnionWith(assemblers);
// sum it all up!
Dictionary <MyDefinitionId, MyFixedPoint> allQueued = SumQueued(assemblers);
Dictionary <MyItemType, MyFixedPoint> allStored = SumStored(allContainers);
// used for round robin balancing of work
int queueStep = 0;
// queue up work for every component we want built.
foreach (KeyValuePair <MyItemType, MyFixedPoint> kv in AllComponents)
{
Echo($"Checking queue for {kv.Key.ToString()}");
MyFixedPoint queued;
MyFixedPoint stored;
allQueued.TryGetValue(ToBlueprintDefinition(kv.Key), out queued);
allStored.TryGetValue(kv.Key, out stored);
MyFixedPoint total = queued + stored;
MyFixedPoint gap = kv.Value - total;
Echo($"Found total {total}, queued {queued}, requested {kv.Value}");
while (gap >= workUnit && queued <= workUnit * (maxWorkUnits - 1))
{
++queueStep;
MyDefinitionId blueprint = ToBlueprintDefinition(kv.Key);
// load balance between all assemblers that can build the blueprint
List <IMyAssembler> buildable = primaries.FindAll(a => a.CanUseBlueprint(blueprint));
if (buildable.Count() == 0)
{
Echo($"Warning no Assembler found for {blueprint.ToString()}");
break;
}
IMyAssembler assembler = buildable[queueStep % buildable.Count()];
Echo($"Queuing {workUnit} of {kv.Key.ToString()} to {assembler.CustomName} as {blueprint.ToString()}");
assembler.AddQueueItem(ToBlueprintDefinition(kv.Key), workUnit);
gap += workUnit;
queued += workUnit;
}
}
}
//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);
}
//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);
}
