// Update is called once per frame
void Update()
{
cameraBounds = cam.OrthographicBounds();
if (actorsToDraw.Count > 0)
{
ActorWrapper actorToDraw = actorsToDraw.Dequeue();
if (actorToDraw.Id == Data.CHARACTER_ID)
{
throw new Exception("Something went wrong, it's trying to draw the player as a new character");
}
GameObject obj; //has to be handled on the main thread
if (actorToDraw.Playable)
{
obj = GetDrawnActor(Data.drawnCharacters, actorToDraw);
if (obj != null)
{
HandleNewActorSetup(obj, actorToDraw.XPos, actorToDraw.YPos);
}
}
else
{
Debug.Log("Actor is npc");
obj = GetDrawnActor(Data.drawnNpcs, actorToDraw);
}
}
}
static void Main(string[] args)
{
IRndGenerator <int> rndActor =
ActorWrapper.WrapActor(RndGeneratorFactory.NewSimpleRndGenerator());
Task <int> nextTask = rndActor.GetNextNumber();
// int number = await nextTask;
}
public static void _Main()
{
ICounter pinger = ActorWrapper.WrapActor <ICounter>(() => new CounterActor());
pinger.SetSelf(pinger);
pinger.Start();
Thread.Sleep(1000);
}
public void TestDelegateUsesRightLock()
{
var directActor = ActorWrapper.WrapActor <IDirectActor>(() => new DirectActor());
var indirectActor = ActorWrapper.WrapActor <IIndirectActor>(() => new IndirectActor());
var runningActor = ActorWrapper.WrapActor <IRunningActor>(() => new RunningActor());
directActor.InitialMethod(runningActor, indirectActor);
Thread.Sleep(300);
}
public override void ProcessPacket(BasePacket receivedPacket)
{
if (!isAuthenticated && receivedPacket.isAuthenticated())
{
isAuthenticated = true;
}
List <SubPacket> subPackets = receivedPacket.GetSubpackets();
foreach (SubPacket subPacket in subPackets)
{
DoAuthenticationChecks(receivedPacket, subPacket);
if (!receivedPacket.isAuthenticated())
{
Debug.Log("Not authenticated.. Do something here");
throw new NotImplementedException();
}
else
{
switch (subPacket.gameMessage.opcode)
{
case ((ushort)GamePacketOpCode.NearbyActorsQuery):
PositionPacket pos = new PositionPacket(subPacket.data);
ActorWrapper wrapper = new ActorWrapper(pos.XPos, pos.YPos, pos.Playable, pos.ActorId);
GameEventManager.TriggerActorNeedsDrawing(new GameEventArgs {
Actor = wrapper
});
break;
case ((ushort)GamePacketOpCode.PositionQuery):
PositionPacket otherCharacterPos = new PositionPacket(subPacket.data);
GameEventManager.TriggerPollerResponse(new GameEventArgs {
PollerPositionPacket = otherCharacterPos
});
break;
case ((ushort)GamePacketOpCode.OtherPlayerDisconnected):
DisconnectPacket dc = new DisconnectPacket(subPacket.data);
Character playerToDisconnect;
if (Data.drawnCharacters.TryGetValue(dc.CharacterId, out playerToDisconnect))
{
Data.drawnCharacters.Remove(dc.CharacterId);
destroyer.AddCharacter(playerToDisconnect);
}
break;
}
}
}
}
public void MethodsRunInOrder()
{
ActingCompleteWaiter.Reset();
var setAndCheckActor = ActorWrapper.WrapActor <ISetAndCheckActor>(() => new SetAndCheckActor());
for (int i = 0; i < c_Trials; i++)
{
setAndCheckActor.SetValue(i);
setAndCheckActor.CheckValue(i);
}
ActingCompleteWaiter.WaitForActionsToComplete(1000);
}
public void TimeCountingUp()
{
ActingCompleteWaiter.Reset();
var firstActor = ActorWrapper.WrapActor <ICallAroundActor>(() => new CallAroundActor());
var secondActor = ActorWrapper.WrapActor <ICallAroundActor>(() => new CallAroundActor());
var thirdActor = ActorWrapper.WrapActor <ICallAroundActor>(() => new CallAroundActor());
firstActor.SetNextActor(secondActor);
secondActor.SetNextActor(thirdActor);
thirdActor.SetNextActor(firstActor);
firstActor.CountUp(0, m_Total);
ActingCompleteWaiter.WaitForActionsToComplete(1000);
}
public void DoIt()
{
IDictionaryActor <string, int> d =
ActorWrapper.WrapActor <IDictionaryActor <string, int> >(() => new DictionaryActor <string, int>());
int r = 3;
d["hello"] = 3;
d.Atomically(
dictionary =>
{
dictionary["hello"] = dictionary["hello"] + r;
return(true);
});
}
public static void Main(string[] args)
{
IPonger ponger = ActorWrapper.WrapActor <IPonger>(() => new Ponger());
IPinger pinger = ActorWrapper.WrapActor <IPinger>(() => new Pinger(ponger));
//IPonger ponger = new Ponger();
//IPinger pinger = new Pinger(ponger);
new Thread(delegate(object o)
{
Thread.Sleep(10000);
Console.WriteLine(s_Count);
Thread.Sleep(1000);
}).Start();
pinger.Ping();
}
/// <summary>
/// Gets a GameObject from an Actor derived dictionary.
/// If it doesn't exist will create a new gameobject and add it to the dictionary.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="drawnActors"></param>
/// <param name="actorToDraw"></param>
/// <returns></returns>
private GameObject GetDrawnActor <T>(Dictionary <uint, T> drawnActors, ActorWrapper actorToDraw) where T : Actor
{
if (drawnActors.ContainsKey(actorToDraw.Id))
{
T actor;
drawnActors.TryGetValue(actorToDraw.Id, out actor);
GameObject obj = actor.gameObject;
obj.SetActive(true);
return(null);
}
else
{
Debug.Log("Creating new Actor object!");
GameObject obj = new GameObject("Actor");
obj.transform.parent = actorHolder.transform;
var actor = obj.AddComponent <T>();
actor.Id = actorToDraw.Id;
drawnActors.Add(actor.Id, actor);
return(obj);
}
}
private static async Task RunScriptPipelineOnceFromCommandLine(SqlRunnerOptions opts, CancellationTokenSource cancellationTokenSource)
{
var getterActor = ActorWrapper.GetUserActorSelection(ActorWrapper.ScriptPullActorName);
var storageActor = ActorWrapper.GetUserActorSelection(ActorWrapper.StorageActorName);
var queueResult = await getterActor.Ask(opts);
var msg = queueResult as GetToTheChopperMessage;
if (msg != null)
{
while (!cancellationTokenSource.IsCancellationRequested)
{
var result = await storageActor.Ask(new DbResultRequestMessage { ScriptId = msg.ScriptId });
var yesResult = result as DbResultMessage;
if (yesResult != null)
{
break;
}
await Task.Delay(2000);
}
}
}
private void AddToDrawQueue(GameEventArgs eventArgs)
{
ActorWrapper actor = eventArgs.Actor;
actorsToDraw.Enqueue(actor);
}
