public void ImmediateSave(int tick = -100)
{
if (tick == -100)
{
tick = Timekeeper.getInstance().getTick();
}
memComponent.hashtable[tick] = memComponent.memory;
}
// Update is called once per frame
void FixedUpdate()
{
int tick = Timekeeper.getInstance().getTick();
// If it's before or after the active period, byebye
if ((tick < memComponent.firstActiveTick) ||
(tick > memComponent.lastActiveTick))
{
transform.position = new Vector3(-100, -100, -10);
return;
}
// Else we have to update the position and opacity etc.
switch (memComponent.state)
{
case Memory.MemoryEvent.reposition:
if (memComponent.position == memComponent.destPosition)
{
// Staying still;
transform.position =
MapGenerator.PositionFor(memComponent.position, -1);
}
else // Need to tween movement
{
transform.position =
MapGenerator.PositionFor(memComponent.position,
memComponent.destPosition,
memComponent.progress);
}
// Update sprite for rotation
int rotation = memComponent.position.third;
if (animator != null)
{
animator.SetInteger("Direction", memComponent.position.third);
animator.transform.rotation = Quaternion.identity;
}
transform.rotation = directions[rotation];
break;
case Memory.MemoryEvent.appearing:
spriteRenderer.color = new Color(1, 1, 1, memComponent.progress);
break;
case Memory.MemoryEvent.disappearing:
spriteRenderer.color = new Color(1, 1, 1, 1.0f - memComponent.progress);
break;
case Memory.MemoryEvent.inactive:
spriteRenderer.color = Color.clear;
break;
}
}
void OnTriggerEnter2D(Collider2D other)
{
// Check the provided Collider2D parameter other to see if it is tagged
// "PickUp", if it is...
if (other.gameObject.CompareTag("Player"))
{
timekeeper = Timekeeper.getInstance();
startTime = timekeeper.getTime();
hasEntered = true;
}
}
void generatePath()
{
Timekeeper timekeeper = Timekeeper.getInstance();
Tuple3I position = memComponent.position;
int startTick = timekeeper.getTick();
int moveTick = timekeeper.GetTickIn(fadeTime);
float tickIncrement = 1.0f / (moveTick - startTick);
float progress = 0;
Memory memory;
// Add first reposition memory
memory = new Memory(Memory.MemoryEvent.reposition,
position);
memComponent.hashtable[moveTick] = memory;
// Create appearing animation
for (int tick = startTick + 1; tick <= moveTick; tick++)
{
memory = new Memory(Memory.MemoryEvent.appearing,
progress += tickIncrement);
memComponent.hashtable[tick] = memory;
}
int speedTicks = timekeeper.GetTickIn(speed) - timekeeper.getTick();
moveTick++;
// Add subsequent reposition memories
while (MapGenerator.GetPathValueFor(position) != 1)
{
moveTick += speedTicks;
if ((moveTick - startTick) / speedTicks > 1000) // more than 1000 steps
{
Debug.Log("Path taking too long!");
return;
}
position = NextPathFor(position);
memory = new Memory(Memory.MemoryEvent.reposition,
position);
memComponent.hashtable[moveTick] = memory;
}
// Add animation for climbing the ladder
position.third = 1;
Tuple3I newPosition = position + new Tuple3I(1, 0, 0);
for (int i = 0; i < 16; i++)
{
memory = new Memory(Memory.MemoryEvent.reposition, position, newPosition, i * 1.0f / 16);
memComponent.hashtable[moveTick + i] = memory;
}
}
// Update is called once per frame
void Update()
{
if (spriteRenderer == null)
{
return;
}
if (MapGenerator.GetPathValueFor(memComponent.position) <= 5 && MapGenerator.GetPathValueFor(memComponent.position) != 1)
{
alertObj.SetActive(true);
}
else
{
alertObj.SetActive(false);
}
if (observed.first == observed.second)
{
spriteRenderer.color = new Color(1, 1, 1, 1.0f);
int tick = Timekeeper.getInstance().getTick();
if ((tick <= memComponent.firstActiveTick) ||
(tick >= memComponent.lastActiveTick))
{
return;
}
memComponent.lastActiveTick = tick;
memComponent.SetInactive();
GetComponent <MemorySystem>().ImmediateSave();
memComponent.enabled = false;
GetComponent <MovementSystem>().enabled = false;
this.enabled = false;
GetComponent <AudioSource>().Play();
GetComponent <AnimatorChildComponent>().animator.runtimeAnimatorController =
disappearAnimation;
spriteRenderer.sprite = disappearSprite;
chargeComponent.Increment();
}
else
{
spriteRenderer.color = new Color(1,
1,
1, 1.0f -
(float)observed.first / observed.second);
}
}
public void Spawn(int[] enemies)
{
Timekeeper timekeeper = Timekeeper.getInstance();
foreach (GameObject enemy in currentEnemies)
{
Destroy(enemy, 1.0f);
}
currentEnemies.Clear();
int spritesLength = enemyAnimators.Length;
int spriteIndex = Random.Range(0, spritesLength);
// Spawn for each entangled group
for (int i = 0; i < enemies.Length; i++)
{
GameObject[] twins = new GameObject[enemies[i]];
TupleI observed = new TupleI(0, enemies[i]);
for (int j = 0; j < enemies[i]; j++)
{
GameObject newEnemy = Instantiate(enemyPrefab,
Vector3.zero,
Quaternion.identity);
twins[j] = newEnemy;
newEnemy.name = "Enemy-" + wave + "-" + i + "-" + j;
currentEnemies.Add(newEnemy);
newEnemy.GetComponent <MemoryComponent>().position =
randomValidPosition();
newEnemy.GetComponent <MemoryComponent>().firstActiveTick =
timekeeper.getTick();
newEnemy.GetComponent <AnimatorChildComponent>().animator.
runtimeAnimatorController = enemyAnimators[spriteIndex];
EnemyObservingSystem observer =
newEnemy.GetComponent <EnemyObservingSystem>();
observer.twins = twins;
observer.observed = observed;
observer.spawnSystem = this;
observer.chargeComponent = GetComponent <ChargeComponent>();
}
spriteIndex = (spriteIndex + 1) % spritesLength;
}
}
// Update is called once per frame
void Update()
{
int tick = Timekeeper.getInstance().getTick();
if ((tick < memComponent.firstActiveTick) ||
(tick > memComponent.lastActiveTick))
{
return;
}
if (memComponent.hashtable.ContainsKey(tick))
{
memComponent.memory = (Memory)memComponent.hashtable[tick];
}
else if (memComponent.memory != null)
{
memComponent.hashtable[tick] = memComponent.memory;
}
}
public bool IsActive()
{
int time = Timekeeper.getInstance().getTick();
return(time > firstActiveTick && time < lastActiveTick);
}
void Start()
{
spawnSystem = GetComponent <EnemySpawnSystem>();
timekeeper = Timekeeper.getInstance();
}
// FixedUpdate is called at a fixed interval and is independent of frame rate.
// Put physics code here.
void FixedUpdate()
{
if (timekeeper == null)
{
timekeeper = Timekeeper.getInstance();
}
if (!underControl)
{
return;
}
bool travel = Input.GetKeyUp("space");
switch (state)
{
case State.walking:
if (travel && (chargeComponent.chargesLeft >= 1))
{
lastPressTime = timekeeper.getTime();
willStartTraveling();
}
// only accept input after a cooldown
if ((timekeeper.getTime() - lastPressTime) < cooldown)
{
// walking.progress
memComponent.advance(Time.deltaTime / cooldown);
return;
}
memComponent.position = memComponent.destPosition;
memComponent.progress = 0;
// Store the current horizontal input in the float moveHorizontal.
float horizontalAxis = Input.GetAxis("Horizontal");
// Store the current vertical input in the float moveVertical.
float verticalAxis = Input.GetAxis("Vertical");
if (horizontalAxis != 0)
{
int moveHorizontal = (horizontalAxis > 0) ? 1 : -1;
memComponent.turnTowards(1 - moveHorizontal);
if ((horizontalAxis >= 1.0f) || (horizontalAxis <= -1.0f))
{
lastPressTime = timekeeper.getTime();
// direction = 1 if right (moveHorizontal =1)
// direction = 3 if left (moveHorizontal = -1)
memComponent.deltaPosition(0, moveHorizontal, 1 - moveHorizontal);
}
}
else if (verticalAxis != 0)
{
int moveVertical = (verticalAxis > 0) ? 1 : -1;
memComponent.turnTowards(2 - moveVertical);
if ((verticalAxis >= 1.0f) || (verticalAxis <= -1.0f))
{
// direction = 2 if up (moveVertical =1)
// direction = 4 if down (moveVertical = -1)
lastPressTime = timekeeper.getTime();
memComponent.deltaPosition(moveVertical, 0, 2 - moveVertical);
}
}
break;
// Handle transitions
case State.transitioning:
memComponent.progress += Time.deltaTime / transitionTime;
if (memComponent.progress < 1)
{
return;
}
// Finished transition
if (memComponent.state == Memory.MemoryEvent.appearing)
{
startWalking();
return;
}
else if (memComponent.state == Memory.MemoryEvent.disappearing)
{
startTraveling();
return;
}
else
{
Debug.Log("Invalid state in PlayerControllerSystem");
}
break;
}
}
void Start()
{
controllerSystem = GetComponent <PlayerControllerSystem>();
timekeeper = Timekeeper.getInstance();
waveController = GetComponent <WaveControllerSystem>();
}
