static void Main(string[] args)
{
Console.WriteLine($"Process ID: {Process.GetCurrentProcess().Id}");
Console.Write("Working, press Ctrl+C to stop...");
var resourceA = new SharedResource {
Name = "ResourceA"
};
var resourceB = new SharedResource {
Name = "ResourceB"
};
var consumerA = new ResourceConsumer
{
Name = "ConsumerA",
First = resourceA,
Second = resourceB
};
var consumerB = new ResourceConsumer
{
Name = "ConsumerB",
First = resourceB,
Second = resourceA
};
var t1 = Task.Run(() => consumerA.DoWork());
var t2 = Task.Run(() => consumerB.DoWork());
Task.WaitAll(t1, t2);
}
private static void Run(string cmd)
{
using (var b = new ResourceConsumer("Second"))
{
b.ApplyAll(int.Parse(cmd)); //Consumers.ApplyAll(b, ...)
}
}
public static void Main(string[] args)
{
var a = new ResourceConsumer("First");
Run();
GC.Collect(); //forcing garbage-collection
a.Consume(101);
AppDomain dom = AppDomain.CreateDomain("secondary");
dom.DoCallBack(delegate()
{
var c = new ResourceConsumer("Third");
c.Consume(103);
var d = new ResourceConsumer("Fourth");
d.Consume(104);
d.Dispose();
});
AppDomain.Unload(dom);
try
{
Run(args[0]);
}
catch {}
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
public void Tick()
{
var constructorObjects = GameObject.FindGameObjectsWithTag("Constructor");
foreach (var constructorObject in constructorObjects)
{
if (ResourceConsumer.isFunctioning(constructorObject))
{
var constructorStorage = constructorObject.GetComponent <ResourceStorage>();
resources[ResourceType.Materials] += constructorStorage.resources[ResourceType.Materials];
}
}
resources[ResourceType.People] = 0;
foreach (var houseObject in GameObject.FindGameObjectsWithTag("House"))
{
if (ResourceConsumer.isFunctioning(houseObject))
{
var houseStorage = houseObject.GetComponent <ResourceStorage>();
resources[ResourceType.People] += houseStorage.resources[ResourceType.People];
}
}
if (resources[ResourceType.People] > goalQuantity)
{
win();
}
}
public string RegisterUser()
{
X509Certificate2 cer = GetCertificate();
ResourceConsumer resCon = new ResourceConsumer();
bool exist;
exist = resCon.UserExist(cer);
return("fun");
}
public void CheckType(ResourceConsumer toCheck)
{
if (toCheck.type == type)
{
if (toCheck.Consume(this))
{
Destroy(gameObject);
}
}
}
public static void Main(string[] args)
{
var a = new ResourceConsumer("First");
a.Apply(23);
a.Dispose();
try
{
Run(args[0]);
}
catch {}
}
public override void flowFrom(ResourceType resourceType, float quantity, int sourceFlowIteration)
{
if (filterList.Contains(resourceType))
{
return;
}
storage.resources[resourceType] += quantity;
if (!ResourceConsumer.isFunctioning(gameObject))
{
return;
}
}
private static void Run(string arg)
{
/*
* var e = new ResourceConsumer("Fifth");
* try
* {
* e.Consume(int.Parse(arg));
* }
* finally
* {
* e.Dispose();
* }
*/
using (var e = new ResourceConsumer("Fifth"))
{
e.Consume(int.Parse(arg));
}
}
public override void flowFrom(ResourceType resourceType, float quantity, int sourceFlowIteration)
{
if (sourceFlowIteration <= flowIteration)
{
return;
}
flowIteration = sourceFlowIteration;
storage.resources[resourceType] += quantity;
var falloff = resourceFalloff[resourceType];
var nextQuantity = quantity * falloff;
if (!ResourceConsumer.isFunctioning(gameObject))
{
return;
}
foreach (var conduit in Placeable.FindConnectedTo <ResourceReceiver>(GetComponent <Placeable>()))
{
conduit.flowFrom(resourceType, nextQuantity, flowIteration);
}
}
public void Link(ResourceConsumer <T> consumer)
{
// A consuming node is basically a pipeline
lock (this.consumers) {
var firstNode = this.consumers.First;
if (null == firstNode)
{
// If we don't have a first node, set the buffer as the source for this consumer
consumer.AddSource(this.Buffer);
this.consumers.AddFirst(consumer);
}
else
{
// If we do have nodes in the list, set the provided consumer as the next consumer in the pipeline
this.consumers.Last.Value.ExchangeNext(consumer.Target);
this.consumers.AddLast(consumer);
}
// Set the waste block as the next consumer of the provided consumer, to keep the waste block last in the pipeline
consumer.ExchangeNext(this.wasteBlock);
}
}
private static void InitResourceConsumer(object state)
{
try
{
LoggingUtilities.LogEvent(ClientsEventLogConstants.Tuple_LiveAssetReaderInitResourceConsumerStarted, new object[0]);
ResourceConsumer.Init((HttpApplication)state, ResourceConsumer.ReadConfigData(LiveAssetReader.configPath));
LiveAssetReader.isInitialized = true;
LoggingUtilities.LogEvent(ClientsEventLogConstants.Tuple_LiveAssetReaderInitResourceConsumerSucceeded, new object[0]);
}
catch (Exception ex)
{
LiveAssetReader.isInitialized = false;
LoggingUtilities.LogEvent(ClientsEventLogConstants.Tuple_LiveAssetReaderInitResourceConsumerError, new object[]
{
ex.ToString()
});
}
finally
{
LiveAssetReader.initResourceConsumerCompleteEvent.Set();
LiveAssetReader.isInitializing = false;
}
}
public void DeliveringResourceCarrierStuck(RetryData retryData)//ATTENTION: RetryData peut valoir null (si on essaie de se rendre à qqch de détruit)
{
RoadRouteManager roadRouteManager = GetComponent <RoadRouteManager>();
if (destination != null)//destination peut valoir null si le bâtiment a été détruit
{
ResourceConsumer consumer = destination.freightAreaData.parentStock.GetComponent <ResourceConsumer>();
if (shipment != null && consumer != null && origin.freightAreaData.freightAreaIn != destination)//Donc: si le transporteur est en livraison vers un ResourceConsumer et qu'il n'est pas déjà en cours de mouvement d'annulation de livraison
{
consumer.CancelResourceOrder(shipment);
}
}
if (origin != null)
{
destination = origin;
roadRouteManager.MoveTo(destination.freightAreaData.freightAreaIn.road, Random.Range(0.5f, 3.0f), null);
}
else
{
StartCoroutine(GoHome());
}
}
public void Tick()
{
if (!ResourceConsumer.isFunctioning(gameObject))
{
return;
}
var storage = GetComponent <ResourceStorage>();
var placeable = GetComponent <Placeable>();
foreach (var pair in resourceGeneration)
{
if (pair.Value <= 0)
{
continue;
}
storage.resources[pair.Key] = pair.Value;
foreach (var conduit in Placeable.FindConnectedTo <ResourceReceiver>(placeable))
{
Debug.Log("Flowing " + pair.Key + " to " + conduit.gameObject.name);
conduit.flowFrom(pair.Key, pair.Value, Ticker.FindTicker().NextFlow());
}
}
}
private static void Run()
{
var b = new ResourceConsumer("Second");
b.Consume(102);
}
protected void Start()
{
ResourceConsumer test = GetComponent <ResourceConsumer>();
Debug.Log("TEST " + (test == null)); //==> Donc, il trouve bien le ResourceProducer (classe fille) attaché, c'est super :)
}
