public void AllocatesWork()
{
var state = new SystemState(staticState);
var worklist = new RefineryWorklist(staticState.OreTypes, staticState.IngotTypes, staticState.RefineryFactory, staticState.Blueprints);
worklist.Initialise(new List <Refinery> {
Refinery.Get(Mocks.MockRefinery(), Constants.REFINERY_TYPES.Single(t => t.BlockDefinitionName.EndsWith("LargeRefinery")), 1),
});
var ingotWorklist = new IngotWorklist(state.Ingots);
var inventoryScanner = new InventoryScanner(staticState.IngotTypes.AllIngotItemTypes, staticState.OreTypes.All);
inventoryScanner.Ore[new ItemType("Ore/Iron")] = new List <OreDonor> {
CreateOreDonor(new ItemType("Ore/Iron"), 4000)
};
state.Ingots.UpdateQuantities(new Dictionary <ItemType, double>()); // No existing ingots.
ingotWorklist.Initialise();
var refineryWorkAllocator = new RefineryWorkAllocator(worklist, inventoryScanner.Ore);
var allocated = refineryWorkAllocator.AllocateSingle(ingotWorklist);
Assert.True(allocated);
}
public void IteratorReturnsOnlyRefineriesAbleToProduceIngotType()
{
var worklist = new RefineryWorklist(staticState.OreTypes, staticState.IngotTypes, staticState.RefineryFactory, staticState.Blueprints);
worklist.Initialise(new List <Refinery> {
Refinery.Get(Mocks.MockRefinery(), Constants.REFINERY_TYPES.Single(t => t.BlockDefinitionName.EndsWith("LargeRefinery")), 1),
Refinery.Get(Mocks.MockRefinery(), Constants.REFINERY_TYPES.Single(t => t.BlockDefinitionName.EndsWith("Blast Furnace")), 1),
Refinery.Get(Mocks.MockRefinery(), Constants.REFINERY_TYPES.Single(t => t.BlockDefinitionName.EndsWith("LargeRefinery")), 1)
});
IRefineryIterator iterator;
Assert.True(worklist.TrySelectIngot(new ItemType("Ingot/Gold"), out iterator));
Assert.True(iterator.CanAllocate());
Assert.That(iterator.Current.BlockDefinitionString, Does.EndWith("LargeRefinery"));
iterator.Next();
Assert.True(iterator.CanAllocate());
Assert.That(iterator.Current.BlockDefinitionString, Does.EndWith("LargeRefinery"));
iterator.Next();
Assert.False(iterator.CanAllocate());
}
protected override void Awake()
{
base.Awake();
nearbyObjects = WorkManager.FindNearbyObjects(transform.position, detectionRange * 2);
List <WorldObject> refineryObjects = new List <WorldObject>();
foreach (WorldObject nearbyObject in nearbyObjects)
{
if (nearbyObject.GetPlayer() != player)
{
continue;
}
Refinery refinery = nearbyObject.GetComponent <Refinery>();
if (refinery)
{
refineryObjects.Add(nearbyObject);
}
}
WorldObject closestObject = WorkManager.FindNearestWorldObjectInListToPosition(refineryObjects, transform.position);
if (closestObject)
{
resourceStore = (Building)closestObject;
}
}
public IDictionary <string, object> Refine(Refinery refinery, Character character, Container sourceContainer, int targetDefinition, int amount)
{
refinery.IsOpen.ThrowIfFalse(ErrorCodes.FacilityClosed);
_productionDescriptions.TryGetValue(targetDefinition, out ProductionDescription productionDescription).ThrowIfFalse(ErrorCodes.DefinitionNotSupported);
return(refinery.Refine(character, sourceContainer, amount, productionDescription));
}
static void Postfix(KilnConfig __instance, ref GameObject go)
{
bool KilnDupeWork = DynamicBuildingsState.StateManager.State.KilnDupe;
Refinery refinery = go.AddOrGet <Refinery>();
refinery.duplicantOperated = KilnDupeWork;
}
public GameObject PlayEff(Refinery refinery)
{
GameObject eff = null;
switch (refinery)
{
case Refinery.Complete:
eff = Eff_Refining_Complete;
break;
case Refinery.Fail:
eff = Eff_Refining_Fail;
break;
case Refinery.Success:
eff = Eff_Refining_Success;
break;
case Refinery.Underway:
eff = Eff_Refining_Underway;
break;
}
if (gLastEff != null)
{
Destroy(gLastEff);
gLastEff = null;
}
gLastEff = (GameObject)Instantiate(eff);
gLastEff.transform.parent = EffEmissionTrans;
gLastEff.transform.localPosition = Vector3.zero;
gLastEff.transform.localScale = eff.transform.localScale;
return(gLastEff);
}
public override void OnStateUndock(Actor self)
{
// If dock animation hasn't played, we didn't actually dock and have to skip the undock anim and notification
if (!dockAnimPlayed)
{
dockingState = DockingState.Complete;
return;
}
dockingState = DockingState.Wait;
wsb.PlayCustomAnimationBackwards(self, wda.DockSequence,
() =>
{
dockingState = DockingState.Complete;
foreach (var trait in self.TraitsImplementing <INotifyHarvesterAction>())
{
trait.Undocked();
}
if (Refinery.IsInWorld && !Refinery.IsDead)
{
foreach (var nd in Refinery.TraitsImplementing <INotifyDocking>())
{
nd.Undocked(Refinery, self);
}
}
});
}
public void AssignedWorkAffectsQuotaFactor()
{
var blueprint = new Blueprint("A", 1, new ItemAndQuantity("Ore/A", 10), new ItemAndQuantity("Ingot/A", 10));
var stockpiles = new IngotStockpiles(new TestIngotDefinitions {
{ "Ingot/A", 100 }
});
var ingotWorklist = new IngotWorklist(stockpiles);
var refinery = Refinery.Get(mockRefinery, new RefineryType("Refinery")
{
SupportedBlueprints = { "A" }
}, 1);
stockpiles.UpdateQuantities(new TestIngotQuantities {
{ "Ingot/A", 50 }
});
ingotWorklist.Initialise();
IngotStockpile preferred;
Assume.That(ingotWorklist.TryGetPreferred(out preferred));
Assume.That(preferred.EstimatedProduction, Is.EqualTo(0));
var initialQuotaFraction = preferred.QuotaFraction;
ingotWorklist.UpdateStockpileEstimates(refinery, blueprint, 5);
IngotStockpile updatedPreferred;
Assume.That(ingotWorklist.TryGetPreferred(out updatedPreferred));
Assert.That(updatedPreferred.QuotaFraction, Is.GreaterThan(initialQuotaFraction));
Assert.That(updatedPreferred.EstimatedProduction, Is.GreaterThan(0));
}
public override void OnStateDock(Actor self)
{
body.Docked = true;
foreach (var trait in self.TraitsImplementing <INotifyHarvesterAction>())
{
trait.Docked();
}
foreach (var nd in Refinery.TraitsImplementing <INotifyDocking>())
{
nd.Docked(Refinery, self);
}
if (spriteOverlay != null && !spriteOverlay.Visible)
{
spriteOverlay.Visible = true;
spriteOverlay.WithOffset.Animation.PlayThen(spriteOverlay.Info.Sequence, () =>
{
dockingState = DockingState.Loop;
spriteOverlay.Visible = false;
});
}
else
{
dockingState = DockingState.Loop;
}
}
public override void _EnterTree()
{
refinery = (Refinery)building;
btnGive = GetNode <Button>("back/BtnGive");
btnTransfer = GetNode <Button>("back/BtnTransfer");
entry = GetNode <LineEdit>("back/LineEdit");
entry.Text = "0";
RefreshBtn();
}
private void registerRefinery(Refinery r)
{
List <Refinery> li = null;
refineries.TryGetValue(r.type, out li);
if (li == null)
{
li = new List <Refinery>();
}
li.Add(r);
refineries[r.type] = li;
refineryCount++;
}
private WorldObject FindNearestRefinery()
{
List <WorldObject> refinerys = new List <WorldObject>();
foreach (WorldObject nearbyObject in nearbyObjects)
{
Refinery refinery = nearbyObject.GetComponent <Refinery>();
if (refinery)
{
refinerys.Add(nearbyObject);
}
}
return(WorkManager.FindNearestWorldObjectInListToPosition(refinerys, transform.position));
}
public void ToleratesBlueprintsWithUnknownIngotTypes()
{
var blueprint = new Blueprint("A", new ItemAndQuantity("Ore/A", 10f), new ItemAndQuantity("Ingot/A", 10f));
var stockpiles = new Stockpiles(
new IngotStockpile[0],
new[] { blueprint });
var refinery = new Refinery(new Mock <IMyRefinery>().Object, new RefineryType("Refinery")
{
SupportedBlueprints = { "A" }
});
stockpiles.UpdateStockpileEstimates(refinery, blueprint, 5f);
}
public override void OnStateUndock(Actor self)
{
// If body.Docked wasn't set, we didn't actually dock and have to skip the undock overlay
if (!body.Docked)
{
dockingState = DockingState.Complete;
}
else if (Refinery.IsInWorld && !Refinery.IsDead && spriteOverlay != null && !spriteOverlay.Visible)
{
dockingState = DockingState.Wait;
spriteOverlay.Visible = true;
spriteOverlay.WithOffset.Animation.PlayBackwardsThen(spriteOverlay.Info.Sequence, () =>
{
dockingState = DockingState.Complete;
body.Docked = false;
spriteOverlay.Visible = false;
foreach (var trait in self.TraitsImplementing <INotifyHarvesterAction>())
{
trait.Undocked();
}
if (Refinery.IsInWorld && !Refinery.IsDead)
{
foreach (var nd in Refinery.TraitsImplementing <INotifyDocking>())
{
nd.Undocked(Refinery, self);
}
}
});
}
else
{
dockingState = DockingState.Complete;
body.Docked = false;
foreach (var trait in self.TraitsImplementing <INotifyHarvesterAction>())
{
trait.Undocked();
}
if (Refinery.IsInWorld && !Refinery.IsDead)
{
foreach (var nd in Refinery.TraitsImplementing <INotifyDocking>())
{
nd.Undocked(Refinery, self);
}
}
}
}
public override void OnStateDock(Actor self)
{
foreach (var trait in self.TraitsImplementing <INotifyHarvesterAction>())
{
trait.Docked();
}
foreach (var nd in Refinery.TraitsImplementing <INotifyDocking>())
{
nd.Docked(Refinery, self);
}
wsb.PlayCustomAnimation(self, wda.DockSequence, () => wsb.PlayCustomAnimationRepeating(self, wda.DockLoopSequence));
dockAnimPlayed = true;
dockingState = DockingState.Loop;
}
public void AssignedWorkAffectsQuotaFactor()
{
var blueprint = new Blueprint("A", new ItemAndQuantity("Ore/A", 10f), new ItemAndQuantity("Ingot/A", 10f));
var stockpiles = new Stockpiles(
new[] { new IngotStockpile { Ingot = new IngotType("Ingot/A", 1, 10), CurrentQuantity = 50, TargetQuantity = 100 } },
new[] { blueprint });
var refinery = new Refinery(new Mock<IMyRefinery>().Object, new RefineryType("Refinery") { SupportedBlueprints = { "A" } });
var initialStockpile = stockpiles.GetStockpiles().Single();
stockpiles.UpdateStockpileEstimates(refinery, blueprint, 5f);
var updatedStockpile = stockpiles.GetStockpiles().Single();
Assert.That(updatedStockpile.QuotaFraction, Is.GreaterThan(initialStockpile.QuotaFraction));
Assert.That(updatedStockpile.EstimatedProduction, Is.GreaterThan(0));
}
void Start()
{
if (GameObject.FindGameObjectWithTag("LevelManager").GetComponent <WorldData>() != null)
{
worldData = GameObject.FindGameObjectWithTag("LevelManager").GetComponent <WorldData>();
}
else
{
Debug.Log("could not locate worldData in sellresourcerefinery");
}
if (GameObject.FindGameObjectWithTag("LevelManager").GetComponent <PlayerInfo>() != null)
{
playerInfo = GameObject.FindGameObjectWithTag("LevelManager").GetComponent <PlayerInfo>();
}
else
{
Debug.Log("could not locate playerInfo in sellresourcerefinery");
}
if (GetComponent <SellPriceRefinery>() != null)
{
sellPriceRefinery = GetComponent <SellPriceRefinery>();
}
else
{
Debug.Log("could not locate sellpricerefinery in sellresourcerefinery");
}
if (GetComponent <Refinery>() != null)
{
refinery = GetComponent <Refinery>();
}
else
{
Debug.Log("could not locate refinery in sellresourcerefinery");
}
GameObject tempObject = GameObject.Find("tradeMenuRefinery");
if (tempObject != null)
{
sellMenu = tempObject.GetComponent <Canvas>();
if (sellMenu == null)
{
Debug.Log("Could not locate Canvas component on " + tempObject.name);
}
}
}
static bool Prefix(Refinery __instance, List <Fabricator.UserOrder> ___userOrders, List <Fabricator.MachineOrder> ___machineOrders)
{
if (!Main.enabled)
{
return(true);
}
if (___userOrders.Count > 1)
{
var machineOrder = ___machineOrders[0];
if (!machineOrder.parentOrder.infinite)
{
___userOrders.Remove(machineOrder.parentOrder);
___userOrders.Insert(0, machineOrder.parentOrder);
}
}
return(true);
}
public static async Task Run()
{
//from https://github.com/tslater2006/AdventOfCode2019 , this one was hurting my brain
var refinery = new Refinery(await File.ReadAllLinesAsync("inputs\\14.txt"));
refinery.ProduceMaterial(new RefineryProduction()
{
Amount = 1, Chemical = "FUEL"
});
Console.WriteLine("Part 1: " + refinery.OreRequired.ToString());
refinery = new Refinery(await File.ReadAllLinesAsync("inputs\\14.txt"));
long fuelCount = 0;
var productionFactor = 10000;
Dictionary <string, int> oldSurplus = null;
long oldOreRequired = 0;
while (productionFactor >= 1)
{
while (refinery.OreRequired < 1000000000000)
{
oldSurplus = new Dictionary <string, int> (refinery.Surplus);
oldOreRequired = refinery.OreRequired;
refinery.ProduceMaterial(new RefineryProduction()
{
Amount = productionFactor, Chemical = "FUEL"
});
fuelCount += productionFactor;
}
/* we've gone over... */
if (productionFactor >= 1)
{
/*reset old state*/
refinery.Surplus = new Dictionary <string, int> (oldSurplus);
refinery.OreRequired = oldOreRequired;
fuelCount -= productionFactor;
productionFactor /= 10;
}
}
Console.WriteLine("Part 2: " + fuelCount.ToString());
}
private void tryMoveOre(string ore, Refinery refinery)
{
//show("Attempting to move "+ore+" into "+refinery.refinery.CustomName);
FoundItem item = findItem(new ItemProfile("ore/" + ore));
if (item == null && ore == "scrap")
{
item = findItem(new ItemProfile("ingot/scrap"));
}
if (item != null)
{
MyFixedPoint amt = min(item.item.Amount, 1000);
moveItem(item.source, refinery.refinery.InputInventory, item.item, amt);
}
else
{
//show("Not found.");
}
}
public void ToleratesBlueprintsWithUnknownIngotTypes()
{
var blueprint = new Blueprint("A", 1, new ItemAndQuantity("Ore/A", 10), new ItemAndQuantity("Ingot/A", 10));
var stockpiles = new IngotStockpiles(new TestIngotDefinitions {
{ "Ingot/B", 100 }
});
var ingotWorklist = new IngotWorklist(stockpiles);
var refinery = Refinery.Get(mockRefinery, new RefineryType("Refinery")
{
SupportedBlueprints = { "A" }
}, 1);
stockpiles.UpdateQuantities(new TestIngotQuantities {
{ "Ingot/B", 20 }
});
ingotWorklist.Initialise();
ingotWorklist.ScoreBlueprint(blueprint);
ingotWorklist.UpdateStockpileEstimates(refinery, blueprint, 5);
}
private static void Postfix(Refinery __instance)
{
Debug.Log(" === AlternateOrdersMod2b Postfix === ");
try
{
FieldInfo userOrders_ = AccessTools.Field(typeof(Refinery), "userOrders");
//FieldInfo operational_ = AccessTools.Field(typeof(Refinery), "operational");
FieldInfo isCancellingOrder_ = AccessTools.Field(typeof(Refinery), "isCancellingOrder");
FieldInfo machineOrders_ = AccessTools.Field(typeof(Refinery), "machineOrders");
//MethodInfo AlreadyMachineQueued = AccessTools.Method(typeof(Refinery), "AlreadyMachineQueued", new Type[] { typeof(Refinery.UserOrder) });
//MethodInfo CompleteOrder = AccessTools.Method(typeof(Refinery), "CompleteOrder", new Type[] { typeof(Refinery.UserOrder) });
//MethodInfo UpdateOrderQueue = AccessTools.Method(typeof(Refinery), "UpdateOrderQueue", new Type[] { typeof(bool) });
//MethodInfo OnCompleteWork = AccessTools.Method(typeof(Workable), "OnCompleteWork", new Type[] { typeof(Worker) });
List <Refinery.UserOrder> userOrders = (List <Refinery.UserOrder>)userOrders_.GetValue(__instance);
//Operational operational = (Operational)operational_.GetValue(__instance);
bool isCancellingOrder = (bool)isCancellingOrder_.GetValue(__instance);
List <Refinery.MachineOrder> machineOrders = (List <Refinery.MachineOrder>)machineOrders_.GetValue(__instance);
if (!isCancellingOrder)
{
if (machineOrders.Count > 0)
{
Refinery.MachineOrder machineOrder = machineOrders[0];
if (machineOrder.parentOrder.infinite)
{
Refinery.UserOrder last = userOrders[0];
userOrders.RemoveAt(0);
userOrders.Add(last);
}
}
}
}
catch (Exception ex)
{
Debug.Log(ex);
Debug.Log(ex.StackTrace);
}
}
/// <summary>
/// Creates a Object3D of given type.
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="z"></param>
/// <param name="type"></param>
/// <returns></returns>
private Object3D CreateObject(double x, double y, double z, string type)
{
switch (type)
{
case "Robot":
Object3D r = new Robot(x, y, z, 0, 0, 0);
worldObjects.Add(r);
return(r);
case "Export":
Object3D e = new ExportVehicle(x, y, z, 0, Math.PI, 0);
worldObjects.Add(e);
return(e);
case "Import":
Object3D i = new ImportVehicle(x, y, z, 0, 0.5 * Math.PI, 0);
worldObjects.Add(i);
return(i);
case "Crate":
Object3D c = new Crate(x, y, z);
worldObjects.Add(c);
return(c);
case "Shelf":
Object3D s = new StationaryObject(x, y, z, 0, 0, 0, "Shelf");
worldObjects.Add(s);
return(s);
case "Refinery":
Object3D refi = new Refinery(x, y, z, 0, 0, 0);
worldObjects.Add(refi);
return(refi);
default:
throw new ArgumentException("there is no model that corresponds with that type");
}
}
public void AssignedWorkAffectsQuotaFactor()
{
var blueprint = new Blueprint("A", new ItemAndQuantity("Ore/A", 10f), new ItemAndQuantity("Ingot/A", 10f));
var stockpiles = new Stockpiles(
new[] { new IngotStockpile {
Ingot = new IngotType("Ingot/A", 1, 10), CurrentQuantity = 50, TargetQuantity = 100
} },
new[] { blueprint });
var refinery = new Refinery(new Mock <IMyRefinery>().Object, new RefineryType("Refinery")
{
SupportedBlueprints = { "A" }
});
var initialStockpile = stockpiles.GetStockpiles().Single();
stockpiles.UpdateStockpileEstimates(refinery, blueprint, 5f);
var updatedStockpile = stockpiles.GetStockpiles().Single();
Assert.That(updatedStockpile.QuotaFraction, Is.GreaterThan(initialStockpile.QuotaFraction));
Assert.That(updatedStockpile.EstimatedProduction, Is.GreaterThan(0));
}
public void Main() //called each cycle
//tick++;
//if (tick%4 != 0)
// return;
{
tick++;
bool cancel = false;
foreach (IMyShipConnector conn in connectors)
{
if (conn.Enabled && conn.Status == MyShipConnectorStatus.Connected)
{
if (shutdownWhenDockedTo(conn.DisplayName, conn.OtherConnector.DisplayName, conn.OtherConnector.CubeGrid.DisplayName))
{
cancel = true;
break;
}
}
}
if (cancel)
{
Echo("Docked to dominant grid; not managing inventories.");
return;
}
Echo("Managing " + refineryCount + " refineries, " + assemblers.Count + " assemblers, " + oxyGenerators.Count + " O2 gens, and " + cargo.Count + " cargo containers.");
if (tick % 50 == 0)
{
cacheSources();
}
if (ENABLE_ORE_SORTING)
{
foreach (var entry in refineries)
{
Refinery r = getRandom <Refinery>(entry.Value);
if (r != null && (r.refinery.Enabled || !SKIP_OFFLINE_REFINERIES))
{
ICollection <string> li = r.validOres;
if (ORE_PRIORITY.Length > 0)
{
li = applyPriorityRules(li);
}
foreach (string ore in li)
{
if (isOreValid(ore, r))
{
tryMoveOre(ore, r);
}
}
empty(r.refinery.OutputInventory);
if (!SKIP_OFFLINE_REFINERIES)
{
r.refinery.Enabled = r.hasWork();
}
}
}
IMyAssembler ass = getRandom <IMyAssembler>(assemblers);
if (ass != null)
{
empty(ass.Mode == MyAssemblerMode.Disassembly ? ass.InputInventory : ass.OutputInventory);
List <MyProductionItem> li = new List <MyProductionItem>();
ass.GetQueue(li);
ass.Enabled = li.Count > 0 || ass.CooperativeMode || ass.BlockDefinition.SubtypeName.ToLowerInvariant().Contains("survivalkit");
}
IMyGasGenerator gas = getRandom <IMyGasGenerator>(oxyGenerators);
if (gas != null && (gas.Enabled || ENABLE_O2_GENS))
{
tryMoveIce(gas);
if (ENABLE_O2_GENS)
{
gas.Enabled = true; // || gas.GetInventory().ItemCount > 0;
}
}
}
if (MOVE_FROM_SMALL_TO_LARGE)
{
IMyCargoContainer box = getRandom <IMyCargoContainer>(cargo);
if (box != null)
{
if (box.GetInventory().ItemCount > 0 && box.BlockDefinition.SubtypeName.ToLowerInvariant().Contains("small"))
{
IMyInventory inv = box.GetInventory();
empty(inv, false);
//break;
}
}
}
if (tick % 5 == 0)
{
bool flag = false;
if (ejectionWatchers.Count > 0 && usedVolume / (float)maxCapacity >= EJECTION_THRESHOLD)
{
foreach (ItemProfile p in ejectionWatchers)
{
float f = getItemFraction(p);
Echo("Item type " + p.ToString() + " represents " + f * 100 + "% of items.");
if (f >= EJECTION_THRESHOLD)
{
Echo("Ejecting excess.");
tryPrepareEjection(p);
flag = true;
}
}
}
if (!flag)
{
Echo("No excess to eject.");
foreach (IMyShipConnector conn in ejectors)
{
conn.ThrowOut = false;
}
} /*
* foreach (IMyShipConnector con in connectors) {
* if (con.Status == MyShipConnectorStatus.Connected) {
* FlowDirection flow = getActiveFlowDirection(con.CustomName, con.OtherConnector.CustomName, con.OtherConnector.CubeGrid.CustomName);
* if (flow != FlowDirection.INERT) {
*
* }
* }
* }*/
}
}
static bool Prefix(Refinery __instance, bool force_update, Operational ___operational, List <Refinery.UserOrder> ___userOrders,
List <Refinery.MachineOrder> ___machineOrders)
{
if (!Main.enabled)
{
return(true);
}
if (!force_update && !___operational.IsOperational)
{
return(false);
}
if (___userOrders.Count <= 1)
{
return(true);
}
foreach (var userOrder in ___userOrders)
{
int count = ___machineOrders.Count(x => x.parentOrder == userOrder);
if (userOrder.infinite && count < 2)
{
for (int i = count; i < 2; i++)
{
___machineOrders.Add(new Refinery.MachineOrder()
{
parentOrder = userOrder
});
}
}
else if (count == 0)
{
___machineOrders.Add(new Refinery.MachineOrder()
{
parentOrder = userOrder
});
}
}
var ingregientsAvailable = new bool[___userOrders.Count];
for (int i = 0, c = ___userOrders.Count; i < c; i++)
{
ingregientsAvailable[i] = true;
var userOrder = ___userOrders[i];
var allIngredients = userOrder.recipe.ingredients;
foreach (var ingredient in allIngredients)
{
if (__instance.inStorage.GetUnitsAvailable(ingredient.material) < ingredient.amount)
{
ingregientsAvailable[i] = false;
break;
}
}
}
Comparison <Refinery.MachineOrder> comparison = delegate(Refinery.MachineOrder x, Refinery.MachineOrder y)
{
if (x.chore != null)
{
return(-1);
}
else if (y.chore != null)
{
return(1);
}
else
{
int idx1 = ___userOrders.FindIndex(n => n == x.parentOrder);
int idx2 = ___userOrders.FindIndex(n => n == y.parentOrder);
if (idx1 != -1 && idx2 != -1)
{
if (ingregientsAvailable[idx1] && !ingregientsAvailable[idx2])
{
return(-1);
}
else if (!ingregientsAvailable[idx1] && ingregientsAvailable[idx2])
{
return(1);
}
}
if (idx1 == idx2)
{
return(0);
}
else
{
return(idx1 < idx2 ? -1 : 1);
}
}
};
___machineOrders.Sort(comparison);
return(true);
}
public IDictionary <string, object> RefineQuery(Refinery refinery, Character character, int targetDefinition, int targetAmount)
{
_productionDescriptions.TryGetValue(targetDefinition, out ProductionDescription productionDescription).ThrowIfFalse(ErrorCodes.DefinitionNotSupported);
return(refinery.RefineQuery(character, targetDefinition, targetAmount, productionDescription));
}
public void ToleratesBlueprintsWithUnknownIngotTypes()
{
var blueprint = new Blueprint("A", new ItemAndQuantity("Ore/A", 10f), new ItemAndQuantity("Ingot/A", 10f));
var stockpiles = new Stockpiles(
new IngotStockpile[0],
new[] { blueprint });
var refinery = new Refinery(new Mock<IMyRefinery>().Object, new RefineryType("Refinery") { SupportedBlueprints = { "A" } });
stockpiles.UpdateStockpileEstimates(refinery, blueprint, 5f);
}
private bool isOreValid(string ore, Refinery refinery)
{
if (NO_PROCESS.Contains(ore))
{
return(false);
}
if (!refinery.validOres.Contains(ore))
{
return(false);
}
if (refinery.type != RefineryType.STONE)
{
if (ore == "stone")
{
List <Refinery> li = null;
refineries.TryGetValue(RefineryType.STONE, out li);
if (SKIP_OFFLINE_REFINERIES)
{
li = filterRefineryList(li);
}
if (li != null && li.Count > 0)
{
return(false);
}
}
}
if (refinery.type != RefineryType.PLATINUM)
{
if (ore == "platinum")
{
List <Refinery> li = null;
refineries.TryGetValue(RefineryType.PLATINUM, out li);
if (SKIP_OFFLINE_REFINERIES)
{
li = filterRefineryList(li);
}
if (li != null && li.Count > 0)
{
return(false);
}
}
}
if (refinery.type != RefineryType.URANIUM)
{
if (ore == "uranium")
{
List <Refinery> li = null;
refineries.TryGetValue(RefineryType.URANIUM, out li);
if (SKIP_OFFLINE_REFINERIES)
{
li = filterRefineryList(li);
}
if (li != null && li.Count > 0)
{
return(false);
}
}
}
if (refinery.type != RefineryType.BLAST)
{
if (ore == "iron" || ore == "nickel" || ore == "silicon" || ore == "cobalt")
{
List <Refinery> li = null;
refineries.TryGetValue(RefineryType.BLAST, out li);
if (SKIP_OFFLINE_REFINERIES)
{
li = filterRefineryList(li);
}
if (li != null && li.Count > 0)
{
return(false);
}
}
}
if (refinery.type == RefineryType.BASIC)
{
List <Refinery> li = null;
refineries.TryGetValue(RefineryType.NORMAL, out li);
if (SKIP_OFFLINE_REFINERIES)
{
li = filterRefineryList(li);
}
return(li == null || li.Count == 0);
}
return(true);
}
public static void LoadServer(bool KnowConfig)
{
Time32 Start = Time32.Now;
RandomSeed = Convert.ToInt32(DateTime.Now.Ticks.ToString().Remove(DateTime.Now.Ticks.ToString().Length / 2));
Console.Title = "Conquord Is Loading...";
Kernel.Random = new FastRandom(RandomSeed);
if (!KnowConfig)
{
ConquordDBName = "test";
ConquordDBPass = "******";
ConquordIP = "149.202.128.35";
}
System.Console.ForegroundColor = ConsoleColor.DarkGray;
IntPtr hWnd = FindWindow(null, Console.Title);
System.Console.WriteLine(@" ` ______ __ ` ` ");
System.Console.WriteLine(@" / ____/___ ____ ____ ___ ______ _________/ / ");
System.Console.WriteLine(@" ` / / / __ \/ __ \/ __ `/ / / / __ \/ ___/ __ / ` ` _ ");
System.Console.WriteLine(@" _/ /___/ /_/ / / / / /_/ / /_/ / /_/ / / / /_/ / | | ");
System.Console.WriteLine(@" ` \____/\____/_/ /_/\__, /\__,_/\____/_/ \__,_/ ` ___| | ");
System.Console.WriteLine(@" ` /_/ ` ` ( .' ");
System.Console.WriteLine(@" __ ... _____ Michael Nashaat _____ ... __ ) ( ");
System.Console.WriteLine();
System.Console.WriteLine(@" Copyright (c) Conquord Project 2015-2016. ");
Console.BackgroundColor = ConsoleColor.Black;
System.Console.ForegroundColor = ConsoleColor.DarkGray;
Database.DataHolder.CreateConnection(ConquordDBName, ConquordDBPass);
Database.EntityTable.EntityUID = new Counter(0);
new MySqlCommand(MySqlCommandType.UPDATE).Update("entities").Set("Online", 0).Execute();
using (MySqlCommand cmd = new MySqlCommand(MySqlCommandType.SELECT))
{
cmd.Select("configuration");
using (MySqlReader r = new MySqlReader(cmd))
{
if (r.Read())
{
if (!KnowConfig)
{
ConquordIP = r.ReadString("ConquordIP");
GamePort = 5816;
AuthPort = r.ReadUInt16("ConquordPort");
}
Database.EntityTable.EntityUID = new Counter(r.ReadUInt32("EntityID"));
if (Database.EntityTable.EntityUID.Now == 0)
{
Database.EntityTable.EntityUID.Now = 1;
}
Union.UnionCounter = new Counter(r.ReadUInt32("UnionID"));
Kernel.ServerKingdom = (r.ReadUInt32("ServerKingdom"));
if (r.ReadByte("LastDailySignReset") != DateTime.Now.Month)
{
MsgSignIn.Reset();
}
Game.ConquerStructures.Society.Guild.GuildCounter = new Conquord.Counter(r.ReadUInt32("GuildID"));
Network.GamePackets.ConquerItem.ItemUID = new Conquord.Counter(r.ReadUInt32("ItemUID"));
Constants.ExtraExperienceRate = r.ReadUInt32("ExperienceRate");
Constants.ExtraSpellRate = r.ReadUInt32("SpellExperienceRate");
Constants.ExtraProficiencyRate = r.ReadUInt32("ProficiencyExperienceRate");
Constants.MoneyDropRate = r.ReadUInt32("MoneyDropRate");
Constants.ConquerPointsDropRate = r.ReadUInt32("ConquerPointsDropRate");
Constants.ItemDropRate = r.ReadUInt32("ItemDropRate");
Constants.ItemDropQualityRates = r.ReadString("ItemDropQualityString").Split('~');
Database.EntityVariableTable.Load(0, out Vars);
}
}
}
using (var cmd = new MySqlCommand(MySqlCommandType.UPDATE).Update("configuration"))
cmd.Set("LastDailySignReset", DateTime.Now.Month).Execute();
Database.JiangHu.LoadStatus();
Database.JiangHu.LoadJiangHu();
Console.WriteLine("JiangHu Loaded.");
Way2Heroes.Load();
QuestInfo.Load();
AuctionBase.Load();
Database.DataHolder.ReadStats();
Conquord.Soul.SoulProtection.Load();
Database.PerfectionTable.Load();
Console.WriteLine("Perfection Loaded.");
Database.LotteryTable.Load();
Database.ConquerItemTable.ClearNulledItems();
Database.ConquerItemInformation.Load();
Console.WriteLine("Items Loaded.");
Database.GameUpdetess.LoadRates();
Database.MonsterInformation.Load();
Database.IPBan.Load();
Database.SpellTable.Load();
Database.ShopFile.Load();
Database.HonorShop.Load();
Database.RacePointShop.Load();
Database.ChampionShop.Load();
Database.EShopFile.Load();
Database.EShopV2File.Load();
Console.WriteLine("Shops Loaded.");
Database.MapsTable.Load();
Database.Flowers.LoadFlowers();
Database.Flowers.SaveFlowers();
Console.WriteLine("Flowers Systems Loaded.");
Database.NobilityTable.Load();
Database.ArenaTable.Load();
Database.TeamArenaTable.Load();
Database.GuildTable.Load();
Database.ChiTable.LoadAllChi();
Console.WriteLine("Social Systems Loaded.");
Refinery.LoadItems();
StorageManager.Load();
UnionTable.Load();
Console.WriteLine("Union Loaded.");
World = new World();
World.Init();
Database.Statue.Load();
Console.WriteLine("Tops And Quests Loaded.");
Database.PoketTables.LoadTables();
Database.InnerPowerTable.LoadDBInformation();
Database.InnerPowerTable.Load();
Console.WriteLine("InnerPower Loaded.");
Map.CreateTimerFactories();
Database.SignInTable.Load();
Database.DMaps.Load();
Console.WriteLine("Maps Loaded.");
Game.Screen.CreateTimerFactories();
World.CreateTournaments();
Game.GuildWar.Initiate();
Game.ClanWar.Initiate();
Game.Tournaments.SkillTournament.LoadSkillTop8();
Game.Tournaments.TeamTournament.LoadTeamTop8();
Clan.LoadClans();
Game.EliteGuildWar.EliteGwint();
Console.WriteLine("Guilds and Clans loaded.");
Booths.Load();
Console.WriteLine("Booths Loaded.");
Database.FloorItemTable.Load();
Database.ReincarnationTable.Load();
new MsgUserAbilityScore().GetRankingList();
new MsgEquipRefineRank().UpdateRanking();
PrestigeRank.LoadRanking();
Console.WriteLine("Ranks Loaded.");
BruteForceProtection.CreatePoll();
Console.WriteLine("Protection System On.");
{
Client.GameClient gc = new Client.GameClient(new ClientWrapper());
gc.Account = new AccountTable("NONE");
gc.Socket.Alive = false;
gc.Entity = new Entity(EntityFlag.Player, false)
{
Name = "NONE"
};
Npcs.GetDialog(new NpcRequest(), gc, true);
}
#region OpenSocket
Network.Cryptography.AuthCryptography.PrepareAuthCryptography();
AuthServer = new ServerSocket();
AuthServer.OnClientConnect += AuthServer_OnClientConnect;
AuthServer.OnClientReceive += AuthServer_OnClientReceive;
AuthServer.OnClientDisconnect += AuthServer_OnClientDisconnect;
AuthServer.Enable(AuthPort, "0.0.0.0");
GameServer = new ServerSocket();
GameServer.OnClientConnect += GameServer_OnClientConnect;
GameServer.OnClientReceive += GameServer_OnClientReceive;
GameServer.OnClientDisconnect += GameServer_OnClientDisconnect;
GameServer.Enable(GamePort, "0.0.0.0");
#endregion
Console.WriteLine("Server loaded iN : " + (Time32.Now - Start) + " MilliSeconds.");
ConquordHandler += ConquordConsole_CloseEvent;
Native.SetConsoleCtrlHandler(ConquordHandler, true);
GC.Collect();
WorkConsole();
}
