void Start()
{
Initialise();
clock = GameMap.Instance.tickGenerator;
playerScript = GameMap.Instance.playerGameObject.GetComponent <PlayerScript>();
if (!GameMap.Instance.enemyList.Contains(gameObject))
{
GameMap.Instance.enemyList.Add(gameObject); // !!! Přiřazení se bude provádět odjinud
}
roundSpawned = GameMap.Instance.player.roundsAlive;
}
public async Task MultipleUnRegistrationsTest()
{
var tickGenerator = new TickGenerator(10);
ISequencerUC sequencer =
SequencerUC
.Construct()
.Register(Steps.Notify, new StrategyOneOnOneUC())
;
Action action = () =>
{
sequencer.Point(SeqPointTypeUC.Notify, Steps.Notify);
};
Task t = await tickGenerator.RegisterAsync(action).WrapIntoTask();
Assert.IsTrue(t.IsCompleted);
Assert.IsFalse(t.IsCanceled);
Assert.IsFalse(t.IsFaulted);
for (int i = 0; i < 10; i++)
{
await sequencer.TestPointAsync(Steps.Notify);
}
t = await tickGenerator.UnRegisterAsync(action).WrapIntoTask();
Assert.IsTrue(t.IsCompleted);
Assert.IsFalse(t.IsCanceled);
Assert.IsFalse(t.IsFaulted);
t = await tickGenerator.UnRegisterAsync(action).WrapIntoTask();
Assert.IsTrue(t.IsCompleted);
Assert.IsFalse(t.IsCanceled);
Assert.IsFalse(t.IsFaulted);
await sequencer.WhenAll();
sequencer.TryReThrowException();
}
public async Task DisposeBasicTest()
{
var tickGenerator = new TickGenerator(10);
ISequencerUC sequencer =
SequencerUC
.Construct()
.Register(Steps.Notify, new StrategyOneOnOneUC())
;
Action action = () =>
{
sequencer.Point(SeqPointTypeUC.Notify, Steps.Notify);
};
tickGenerator.Dispose();
Task t = await tickGenerator.Disposed.WrapIntoTask();
Assert.IsTrue(t.IsCompleted);
Assert.IsFalse(t.IsCanceled);
Assert.IsFalse(t.IsFaulted);
Assert.ThrowsAsync <ObjectDisposedException>(async() => t = await tickGenerator.RegisterAsync(action).WrapIntoTask());
Assert.IsTrue(t.IsCompleted);
Assert.IsFalse(t.IsCanceled);
Assert.IsFalse(t.IsFaulted);
Assert.ThrowsAsync <ObjectDisposedException>(async() => t = await tickGenerator.UnRegisterAsync(action).WrapIntoTask());
Assert.IsTrue(t.IsCompleted);
Assert.IsFalse(t.IsCanceled);
Assert.IsFalse(t.IsFaulted);
await sequencer.WhenAll();
sequencer.TryReThrowException();
}
public async Task ConcurrentTest()
{
ISequencerUC sequencer =
SequencerUC
.Construct()
.Register(Steps.Notify, new StrategyOneOnOneUC())
.Register(TickGeneratorSequencer.RegisterStatus, new StrategyOneOnOneUC())
.Register(TickGeneratorSequencer.RegisterActiveProcessing, new StrategyOneOnOneUC())
.Register(TickGeneratorSequencer.UnRegisterStatus, new StrategyOneOnOneUC())
.Register(TickGeneratorSequencer.UnRegisterActiveProcessing, new StrategyOneOnOneUC())
.Register(TickGeneratorSequencer.Processing, new StrategyOneOnOneUC())
.Register(TickGeneratorSequencer.ExclusiveProcessing, new StrategyOneOnOneUC())
.Register(TickGeneratorSequencer.BeginActiveProcessing, new StrategyOneOnOneUC())
.Register(TickGeneratorSequencer.EndActiveProcessing, new StrategyOneOnOneUC())
.Register(TickGeneratorSequencer.ActionsProcessing, new StrategyOneOnOneUC())
.Register(TickGeneratorSequencer.ActionsProcessingCount, new StrategyOneOnOneUC())
.Register(TickGeneratorSequencer.TryUpdateTimerBegin, new StrategyOneOnOneUC())
.Register(TickGeneratorSequencer.TryUpdateTimerEnd, new StrategyOneOnOneUC())
.Register(TickGeneratorSequencer.CallBackProcessing, new StrategyOneOnOneUC())
//.Register(TickGeneratorSequencer.CallBackProcessing, new StrategyOneOnOneUC())
//.Register(TickGeneratorSequencer.CallBackProcessing, new StrategyOneOnOneUC())
//.Register(TickGeneratorSequencer.CallBackProcessing, new StrategyOneOnOneUC())
;
var tickGenerator = new TickGenerator(10, sequencer);
Action action = () =>
{
sequencer.Point(SeqPointTypeUC.Notify, Steps.Notify);
};
Task <Task> tt = Task.Run(() => tickGenerator.RegisterAsync(action).WrapIntoTask());
var rStatus = await sequencer.TestPointAsync(TickGeneratorSequencer.RegisterStatus);
Assert.AreEqual(TickGeneratorStatus.Operating, rStatus.ProductionArg);
var rActiveProcesing = await sequencer.TestPointAsync(TickGeneratorSequencer.RegisterActiveProcessing);
Assert.AreEqual(false, rActiveProcesing.ProductionArg);
var processing = await sequencer.TestPointAsync(TickGeneratorSequencer.Processing);
var processingResult = (TickGenerator.ProcessingResult)processing.ProductionArg;
Assert.AreEqual(TickGenerator.ProcessingResult.Processed, processingResult);
var exclusiveProcessing = await sequencer.TestPointAsync(TickGeneratorSequencer.ExclusiveProcessing);
exclusiveProcessing.Complete();
var beginActiveProcessing = await sequencer.TestPointAsync(TickGeneratorSequencer.BeginActiveProcessing);
beginActiveProcessing.Complete();
var actionProcessing = await sequencer.TestPointAsync(TickGeneratorSequencer.ActionsProcessing);
actionProcessing.Complete();
Assert.AreEqual(false, actionProcessing.ProductionArg);
var updateTimerBegin = await sequencer.TestPointAsync(TickGeneratorSequencer.TryUpdateTimerBegin);
updateTimerBegin.Complete();
Assert.AreEqual(TickGeneratorTimerStatus.None, updateTimerBegin.ProductionArg);
var updateTimerEnd = await sequencer.TestPointAsync(TickGeneratorSequencer.TryUpdateTimerEnd);
updateTimerEnd.Complete();
Assert.AreEqual(TickGeneratorTimerStatus.Activate | TickGeneratorTimerStatus.IsActive | TickGeneratorTimerStatus.Changed, updateTimerEnd.ProductionArg);
var endActiveProcessing = await sequencer.TestPointAsync(TickGeneratorSequencer.EndActiveProcessing);
endActiveProcessing.Complete();
Assert.AreEqual(TickGeneratorStatus.Operating, endActiveProcessing.ProductionArg);
Task t = await tt;
Assert.IsTrue(t.IsCompleted);
Assert.IsFalse(t.IsCanceled);
Assert.IsFalse(t.IsFaulted);
for (int i = 0; i < 10; i++)
{
var callBackProcessing = await sequencer.TestPointAsync(TickGeneratorSequencer.CallBackProcessing);
callBackProcessing.Complete();
var processingCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.Processing);
var processingCycleResult = (TickGenerator.ProcessingResult)processingCycle.ProductionArg;
Assert.AreEqual(TickGenerator.ProcessingResult.Processed, processingCycleResult);
var exclusiveProcessingCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.ExclusiveProcessing);
exclusiveProcessingCycle.Complete();
var beginActiveProcessingCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.BeginActiveProcessing);
beginActiveProcessingCycle.Complete();
var actionProcessingCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.ActionsProcessing);
actionProcessingCycle.Complete();
Assert.AreEqual(true, actionProcessingCycle.ProductionArg);
var actionProcessingCountCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.ActionsProcessingCount);
Assert.AreEqual(1, actionProcessingCountCycle.ProductionArg);
for (int j = 0; j < (int)actionProcessingCountCycle.ProductionArg; j++)
{
await sequencer.TestPointAsync(Steps.Notify);
}
var updateTimerBeginCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.TryUpdateTimerBegin);
updateTimerBeginCycle.Complete();
Assert.AreEqual(TickGeneratorTimerStatus.IsActive, updateTimerBeginCycle.ProductionArg);
var updateTimerEndCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.TryUpdateTimerEnd);
updateTimerEndCycle.Complete();
Assert.AreEqual(TickGeneratorTimerStatus.Activate | TickGeneratorTimerStatus.IsActive, updateTimerEndCycle.ProductionArg);
var endActiveProcessingCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.EndActiveProcessing);
endActiveProcessingCycle.Complete();
Assert.AreEqual(TickGeneratorStatus.Operating, endActiveProcessingCycle.ProductionArg);
}
for (int i = 0; i < 1; i++)
{
var callBackProcessing = await sequencer.TestPointAsync(TickGeneratorSequencer.CallBackProcessing);
callBackProcessing.Complete();
var processingCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.Processing);
var processingCycleResult = (TickGenerator.ProcessingResult)processingCycle.ProductionArg;
Assert.AreEqual(TickGenerator.ProcessingResult.Processed, processingCycleResult);
var exclusiveProcessingCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.ExclusiveProcessing);
exclusiveProcessingCycle.Complete();
var beginActiveProcessingCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.BeginActiveProcessing);
beginActiveProcessingCycle.Complete();
//ActiveProcessing
tt = Task.Run(() => tickGenerator.UnRegisterAsync(action).WrapIntoTask());
var rStatusCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.UnRegisterStatus);
Assert.AreEqual(TickGeneratorStatus.Operating, rStatusCycle.ProductionArg);
var rActiveProcesingCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.UnRegisterActiveProcessing);
Assert.AreEqual(true, rActiveProcesingCycle.ProductionArg);
var actionProcessingCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.ActionsProcessing);
actionProcessingCycle.Complete();
Assert.AreEqual(true, actionProcessingCycle.ProductionArg);
var actionProcessingCountCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.ActionsProcessingCount);
Assert.AreEqual(1, actionProcessingCountCycle.ProductionArg);
for (int j = 0; j < (int)actionProcessingCountCycle.ProductionArg; j++)
{
await sequencer.TestPointAsync(Steps.Notify);
}
var updateTimerBeginCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.TryUpdateTimerBegin);
updateTimerBeginCycle.Complete();
Assert.AreEqual(TickGeneratorTimerStatus.IsActive, updateTimerBeginCycle.ProductionArg);
var updateTimerEndCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.TryUpdateTimerEnd);
updateTimerEndCycle.Complete();
Assert.AreEqual(TickGeneratorTimerStatus.Changed, updateTimerEndCycle.ProductionArg);
var endActiveProcessingCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.EndActiveProcessing);
endActiveProcessingCycle.Complete();
Assert.AreEqual(TickGeneratorStatus.Operating, endActiveProcessingCycle.ProductionArg);
}
t = await tt;
Assert.IsTrue(t.IsCompleted);
Assert.IsFalse(t.IsCanceled);
Assert.IsFalse(t.IsFaulted);
await sequencer.WhenAll();
sequencer.TryReThrowException();
}
void Start()
{
clock = GameMap.Instance.tickGenerator;
clock.PlayerScript = this;
}
void CreateScene()
{
Debug.Log("GameMap: Creating scene for level: " + level);
System.Random rnd = new System.Random();
// Tomuhle nerozumím, v exploreru se mi nějak kupí GameObjecty
//if (Enviroment != null)
//{
// Destroy(Enviroment);
//}
if (Enviroment == null)
{
Enviroment = (GameObject)Instantiate(new GameObject("Enviroment"), Vector3.zero, Quaternion.identity); // Vytvoř GO Enviroment, který slouží spíše jako složka
}
mapa = new MapDungeon(width, height, Random.Range(8, 10), new Vector2(3, 3), new Vector2(9, 9)); // Vygeneruj mapu se zadanými parametry
if (tickGenerator == null) // Zkontroluj, jestli existuje ve scéně tickGenerator
{
if (GameObject.Find("TickGenerator") == null) // Pokud neexistuje, tak ho instancuj
{
GameObject TickGeneratorGameObject = Instantiate(tickGeneratorPrefab) as GameObject;
TickGeneratorGameObject.name = "TickGenerator";
tickGenerator = TickGeneratorGameObject.GetComponent <TickGenerator>();
}
else // Pokud existuje, tak ho najdi
{
tickGenerator = GameObject.Find("TickGenerator").GetComponent <TickGenerator>();
}
}
corridorGroundDictionary = new Dictionary <Vector2, GameObject>(); // Instancuj slovníky
dungeonGroundDictionary = new Dictionary <Vector2, GameObject>();
objectDictionary = new Dictionary <Vector2, GameObject>();
wallDictionary = new Dictionary <Vector2, GameObject>();
for (int x = 0; x < width; x++) // Zde probíhá instancování všech GameObjectů na základě dat z mapy
{ // Objekty se zrovna přidávají do slovníků
for (int y = 0; y < height; y++)
{
switch (mapa.mapArray[x, y])
{
case 0: // floors
GameObject fPrefab = Instantiate(floorPrefab[rnd.Next(0, floorPrefab.Length - 1)], new Vector3(x, y), Quaternion.identity) as GameObject;
fPrefab.transform.parent = Enviroment.transform;
dungeonGroundDictionary.Add(fPrefab.transform.position, fPrefab);
break;
case 2: // corridor
GameObject cPrefab = Instantiate(floorPrefab[rnd.Next(0, floorPrefab.Length - 1)], new Vector3(x, y), Quaternion.identity) as GameObject;
cPrefab.transform.parent = Enviroment.transform;
corridorGroundDictionary.Add(cPrefab.transform.position, cPrefab);
break;
case 1: // wall
int wallToInstantiate = 0;
if (d(100))
{
wallToInstantiate = rnd.Next(0, wallPrefab.Length - 1);
}
GameObject wPrefab = Instantiate(wallPrefab[wallToInstantiate], new Vector3(x, y), Quaternion.identity) as GameObject;
wPrefab.transform.parent = Enviroment.transform;
wallDictionary.Add(wPrefab.transform.position, wPrefab);
break;
case 333: // stairs
GameObject object_stairs = Instantiate(exitPrefab, new Vector2(x, y), Quaternion.identity) as GameObject;
object_stairs.transform.parent = Enviroment.transform;
object_stairs.name = "object_stairs";
objectDictionary.Add(object_stairs.transform.position, object_stairs);
break;
default: // všechno ostatní
Debug.Log("The GameMap is trying to instantiate thing id " + mapa.mapArray[x, y] + " at x: " + x + " y: " + y + " but there is no prefab set.");
break;
}
}
}
for (int x = -4; x < (width + 4); x++) // Nakresli spodní a horní okraje zdí
{
for (int y = -4; y < 0; y++)
{
GameObject wPrefab = Instantiate(wallPrefab[rnd.Next(0, wallPrefab.Length - 1)], new Vector3(x, y), Quaternion.identity) as GameObject;
wPrefab.transform.parent = Enviroment.transform;
wallDictionary.Add(wPrefab.transform.position, wPrefab);
}
for (int y = height; y < (height + 4); y++)
{
GameObject wPrefab = Instantiate(wallPrefab[rnd.Next(0, wallPrefab.Length - 1)], new Vector3(x, y), Quaternion.identity) as GameObject;
wPrefab.transform.parent = Enviroment.transform;
wallDictionary.Add(wPrefab.transform.position, wPrefab);
}
}
for (int y = 0; y < (height); y++) // Levý a pravý okraj
{
for (int x = -4; x < 0; x++)
{
GameObject wPrefab = Instantiate(wallPrefab[rnd.Next(0, wallPrefab.Length - 1)], new Vector3(x, y), Quaternion.identity) as GameObject;
wPrefab.transform.parent = Enviroment.transform;
wallDictionary.Add(wPrefab.transform.position, wPrefab);
}
for (int x = width; x < (width + 4); x++)
{
GameObject wPrefab = Instantiate(wallPrefab[rnd.Next(0, wallPrefab.Length - 1)], new Vector3(x, y), Quaternion.identity) as GameObject;
wPrefab.transform.parent = Enviroment.transform;
wallDictionary.Add(wPrefab.transform.position, wPrefab);
}
}
if (player == null)
{
player = new Player(mapa.entrance); // Spawni hráče, pokud neexistuje
}
playerGameObject = Instantiate(playerPrefab, mapa.entrance, Quaternion.identity) as GameObject; // Instancuj hráčův GameObject
playerGameObject.GetComponent <PlayerScript>().HumanPlayer = player; // Přiřaď reference do hráčova skriptu
player.position = mapa.entrance;
playerGameObject.GetComponent <PlayerScript>().clock = tickGenerator;
playerGameObject.name = "Player"; // Přejmenuj hráče na "Player"
playerGameObject.GetComponent <PlayerScript>().HumanPlayer.PutWeaponInHand(player.equippedWeapon, playerGameObject.transform);
playerGameObject.transform.position = mapa.entrance; // Přesuň hráčův GO na vchod
Camera.main.transform.position = new Vector3(player.position.x, player.position.y, -10);
Camera.main.GetComponent <CameraHandler>().target = playerGameObject.transform;
}
