public List <SpawnTableDetails> getTable(LevelStage diff)
{
switch (diff)
{
case LevelStage.Starter:
return(StarterTable);
case LevelStage.Easy:
return(EasyTable);
case LevelStage.Medium:
return(MediumTable);
case LevelStage.Hard:
return(HardTable);
case LevelStage.VeryHard:
return(VeryHardTable);
case LevelStage.Nightmare:
return(NightmareTable);
default:
return(null);
}
}
void Update()
{
if (paused)
{
return;
}
if (levelActive && !allLevelsComplete && currentLevelIndex < levels.Count && currentStageIndex < levels[currentLevelIndex].Stages.Count)
{
currentStageTimePassed += Time.deltaTime;
LevelStage currentStage = levels[currentLevelIndex].Stages[currentStageIndex];
for (int i = currentStageEnemyNumber; i < currentStage.Enemies.Count; i++)
{
if (currentStage.SpawnTimings[i] <= currentStageTimePassed)
{
SpawnEnemy(currentStage.Enemies[i], currentStage.SpawnLocations[i] + baseArenaSpawnLocation);
currentStageEnemyNumber++;
}
else
{
break;
}
}
}
}
public static EnemyStats calcStats(EnemyMaxStats max, LevelStage diff, float time)
{
float health = max.minHealth + (int)(time / 30) * max.healthMod;
if (health > max.maxHealth)
{
health = max.maxHealth;
}
float speed = Random.Range(max.minSpeed, max.minSpeed + (time / 20) * max.speedMod);
if (speed > max.maxSpeed)
{
speed = max.maxSpeed;
}
Spell attack = null;
if (max.attacks != null && max.attacks.Count > 0)
{
int attackType = Random.Range(0, max.attacks.Count);
attack = max.attacks[attackType];
}
SpellAttr attr = max.attackModifiers;
SpellMod modifiers = new SpellMod();
modifiers.damage = Random.Range(attr.minDamage, attr.minDamage + attr.minDamage * time / 90);
if (modifiers.damage > attr.maxDamage)
{
modifiers.damage = attr.maxDamage;
}
modifiers.damagePercent = 1;
int dotChance = Random.Range(0, 101);
bool dot = (15 * (int)diff) >= dotChance;
if (dot)
{
modifiers.dot = true;
modifiers.dotTick = Random.Range(attr.minDot, attr.minDot + attr.minDot * time / 180);
if (modifiers.dotTick > attr.maxDot)
{
modifiers.dotTick = attr.maxDot;
}
modifiers.dotLength = Random.Range(attr.minFireRate, attr.maxFireRate);
}
modifiers.TTL = Random.Range(attr.minTTL, attr.maxTTL);
modifiers.fireRate = Random.Range(attr.minFireRate, attr.minFireRate + attr.minFireRate * time / 180);
if (modifiers.fireRate > attr.maxFireRate)
{
modifiers.fireRate = attr.maxFireRate;
}
//TODO: Do range for some enemies after adding wind weapon
return(new EnemyStats(health, attack, modifiers, max.sightRange, max.sightAngle, speed));
}
public void Update()
{
scroll += Time.DeltaTime;
LevelStage stage = stages.Peek();
if (scroll >= stages.Peek().scroll)
{
if (stage.DoStage(this))
{
stages.Dequeue();
}
}
foreach (Entity e in entities)
{
if (!e.removed)
{
e.Update();
}
}
foreach (Entity e in entititesToAdd)
{
entities.Add(e);
}
entititesToAdd.Clear();
}
public static string getStageText(LevelStage ls)
{
string s = "";
switch (ls)
{
case LevelStage.AIMING:
s = "Left click on cannon: aim\n" +
"Right click on cannon: adjust power\n" +
"Space: fire";
break;
case LevelStage.FIRING:
s = "Space: make platform\n" +
"R: aim again";
break;
case LevelStage.WAITING:
s = "Space: confirm\n" +
"R: aim again";
break;
case LevelStage.PLATFORMING:
s = "Space: jump\n" +
"R: aim again\n" +
"E: reset Cannonboy";
break;
}
return(s);
}
void SetCurrentStageLevel()
{
currentLevelStage = levelStages[idOfStage];
currentObjectRotation = currentLevelStage.rotationObject;
ResetTargetPosition(currentLevelStage.firstYPosition);
SetPlayerPosition(currentLevelStage.playerSpawnPoint.position);
}
private static LevelStage ParseLevelStage(XElement stageRoot)
{
LevelStage stage = new LevelStage();
stage.Enemies = new List <EnemyType>();
stage.SpawnLocations = new List <Vector2>();
stage.SpawnTimings = new List <float>();
IEnumerable <XElement> spawnElements = stageRoot.Elements("EnemySpawn");
if (spawnElements != null && spawnElements.Any())
{
foreach (XElement spawn in spawnElements)
{
EnemyType type = (EnemyType)Enum.Parse(typeof(EnemyType), spawn.Element("EnemyType").Value);
stage.Enemies.Add(type);
float spawnX = float.Parse(spawn.Element("SpawnLocation").Element("X").Value);
float spawnY = float.Parse(spawn.Element("SpawnLocation").Element("Y").Value);
stage.SpawnLocations.Add(new Vector2(spawnX, spawnY));
float spawnTime = float.Parse(spawn.Element("SpawnTiming").Value);
stage.SpawnTimings.Add(spawnTime);
}
}
return(stage);
}
//TODO better error output when xml parsing fails
private static Level ParseLevel(XElement root)
{
Level level = new Level();
level.ArenaName = root.Element("Arena").Value;
level.CompletionPoints = int.Parse(root.Element("CompletionPoints").Value);
level.LevelNumber = int.Parse(root.Element("LevelNumber").Value);
level.ItemSelection = new string[3];
int i = 0;
foreach (XElement itemElement in root.Element("VictoryItems").Elements("Item"))
{
level.ItemSelection[i] = itemElement.Value;
i++;
}
level.Stages = new List <LevelStage>();
IEnumerable <XElement> stageElements = root.Elements("Stage");
if (stageElements != null && stageElements.Any())
{
foreach (XElement stage in stageElements)
{
LevelStage newStage = ParseLevelStage(stage);
level.Stages.Add(newStage);
}
}
return(level);
}
public GameObject spawnNewEnemy(LevelStage diff, float time)
{
if (diff != lastSpawnStage)
{
lastSpawnStage = diff;
if (spawnTable != null)
{
completeSpawnTable.AddRange(spawnTable.getTable(diff));
}
}
if (cooldownCounter >= spawnCooldown && completeSpawnTable.Count > 0 && spawnedEnemies.Count < maxEnemies)
{
cooldownCounter = 0;
int randIndex = Random.Range(0, completeSpawnTable.Count);
if (diff == LevelStage.Medium)
{
randIndex = Random.Range(randIndex, completeSpawnTable.Count);
}
if (diff == LevelStage.VeryHard)
{
randIndex = Random.Range(randIndex, completeSpawnTable.Count);
}
SpawnTableDetails entry = completeSpawnTable[randIndex];
GameObject newEnemy = Instantiate(entry.enemyType, transform.position, transform.rotation);
Enemy enClass = newEnemy.GetComponent <Enemy>();
enClass.stats = calcStats(entry.maxStats, diff, time);
float hue = (360 * enClass.stats.maxHealth / entry.maxStats.maxHealth) + 60;
if (hue > 360)
{
hue = 0;
}
float sat = enClass.stats.maxHealth == entry.maxStats.minHealth ? 0 : 100;
if (newEnemy.name.StartsWith("GroundEnemy"))
{
newEnemy.GetComponentInChildren <Renderer>().materials[1].color = Color.HSVToRGB(hue / 360, sat / 100, 1);
}
else
{
newEnemy.GetComponentInChildren <Renderer>().material.color = Color.HSVToRGB(hue / 360, sat / 100, 1);
}
spawnedEnemies.Add(newEnemy);
Instantiate(particleEffect, transform.position, transform.rotation);
return(newEnemy);
}
else
{
return(null);
}
}
void Update()
{
timeElapsed += Time.deltaTime;
timePoints += Time.deltaTime;
System.TimeSpan timeElapsedSpan = System.TimeSpan.FromSeconds(timeElapsed);
string timeElapsedString = string.Format("{0:D2}:{1:D2}:{2:D2}", timeElapsedSpan.Hours, timeElapsedSpan.Minutes, timeElapsedSpan.Seconds);
timerText.text = timeElapsedString;
float timeMins = timeElapsed / 60;
if (stage == LevelStage.Starter && timeMins >= 1)
{
stage = LevelStage.Easy;
updateSpawnTable();
}
if (stage == LevelStage.Easy && timeMins >= 3)
{
stage = LevelStage.Medium;
updateSpawnTable();
}
if (stage == LevelStage.Medium && timeMins >= 5)
{
stage = LevelStage.Hard;
updateSpawnTable();
}
if (stage == LevelStage.Hard && timeMins >= 7)
{
stage = LevelStage.VeryHard;
updateSpawnTable();
}
if (stage == LevelStage.VeryHard && timeMins >= 10)
{
stage = LevelStage.Nightmare;
updateSpawnTable();
}
cleanEnemyList();
spawnEnemiesNearPlayer();
}
public static void changeLevelStage(LevelStage ls)
{
levelStage = ls;
modeText.GetComponent <Text>().text = getStageText(ls);
}
