main.snb

# Naming Convention:
# - <var>: normal variable
# - <_var>: variable for memory address pointer
# - <Class_property>: property offset for Class

include "lib/core.snb"
include "games/utils.snb"
include "games/sound.snb"
include "games/Tower.snb"
include "games/Bullet.snb"
include "games/Enemy.snb"
include "games/Path.snb"
include "memory.snb"
include "ui.snb"

setManualFlush(true)

const STATE_NULL -> 0
const STATE_INITIAL -> 1
const STATE_READY -> 2
const STATE_BATTLE -> 3
const STATE_GAME_OVER -> 4
const STATE_GAME_CLEAR -> 5

const TIME_TO_ENTER_STATE -> 20

const GOLD_INITIAL -> 2
const GOLD_MAX -> 50
const GOLD_NO_TOWER_PENALTY -> 3

const ULTIMATE_GOLD -> 3
const ULTIMATE_INDEX -> LANE_COUNT
const ULTIMATE_DAMAGE_BASE -> 1
const ULTIMATE_DAMAGE_RATE -> 30

const ENEMY_LIFE_TOTAL_INITIAL -> -10
const ENEMY_LIFE_TOTAL_INCREMENT -> 25
const ENEMY_LIFE_TOTAL_MAX -> 50 * LANE_COUNT
const ENEMY_WAVE_MAX -> (ENEMY_LIFE_TOTAL_MAX - ENEMY_LIFE_TOTAL_INITIAL) / ENEMY_LIFE_TOTAL_INCREMENT + 1
const WAVE_NOTICE_TIME -> 120

# light -> dark
# blue -> green -> orange -> red -> purple
memory[_colors] -> rgb(100, 145, 217)
memory[_colors + 1] -> rgb(112, 224, 161)
memory[_colors + 2] -> rgb(227, 189, 107)
memory[_colors + 3] -> rgb(235, 131, 117)
memory[_colors + 4] -> rgb(235, 113, 224)
memory[_colors + 5] -> rgb(15, 82, 189)
memory[_colors + 6] -> rgb(30, 148, 81)
memory[_colors + 7] -> rgb(191, 136, 17)
memory[_colors + 8] -> rgb(168, 42, 25)
memory[_colors + 9] -> rgb(173, 14, 159)

main()

def main()
	initBackground()
	enterInitial()
	while true
		update()
		draw()
		flush()

def update()
	updateBackground()
	tickToEnterState()

	if memory[_state] = STATE_INITIAL
		random(1) # for random seed
		if keyPressed(KEY_SPACE, false)
			enterReady()
			playGameStartSound()

	if memory[_state] = STATE_READY
		random(1) # for random seed
		memory[_waveNoticeTime] -> min(memory[_waveNoticeTime] + 1, WAVE_NOTICE_TIME)
		if WAVE_NOTICE_TIME <= memory[_waveNoticeTime]
			if keyPressed(KEY_LEFT, true)
				memory[_selectedTowerIndex] -> max(memory[_selectedTowerIndex] - 1, 0)
			if keyPressed(KEY_RIGHT, true)
				memory[_selectedTowerIndex] -> min(memory[_selectedTowerIndex] + 1, LANE_COUNT)
			handleTowerLevelAndUltimateChange()
			if keyPressed(KEY_SPACE, false)
				exists -> anyTowerExists()
				if exists
					memory[_stateToEnter] -> STATE_BATTLE

				if exists = false
					playInvalidActionSound()

	if memory[_state] = STATE_BATTLE
		if keyPressed(KEY_SPACE, false)
			if memory[_ultimateAvailable]
				useUltimate()
			if memory[_ultimateAvailable] = false
				playInvalidActionSound()

		updateTowers()
		updateBullets()
		updateEnemies()
		handleEnemiesEnemiesCollision()
		handleEnemiesTowersCollision()
		handleEnemiesBulletsCollision()
		handleBattleStateTransition()
	if or(memory[_state] = STATE_GAME_OVER, memory[_state] = STATE_GAME_CLEAR)
		updateBullets()
		if keyPressed(KEY_SPACE, false)
			init()
			memory[_stateToEnter] -> STATE_READY
			playGameStartSound()

def handleTowerLevelAndUltimateChange()
	if keyPressed(KEY_UP, true)
		if memory[_selectedTowerIndex] = ULTIMATE_INDEX
			canBuyUltimate -> and(ULTIMATE_GOLD <= memory[_gold], memory[_ultimateAvailable] = false)
			if canBuyUltimate
				memory[_gold] -> memory[_gold] - ULTIMATE_GOLD
				memory[_ultimateAvailable] -> true
				playActionSound()
			if canBuyUltimate = false
				playInvalidActionSound()

		if memory[_selectedTowerIndex] != ULTIMATE_INDEX
			goldEnough -> 0 < memory[_gold]
			if goldEnough
				canLevelUp -> Tower_addLevel(Array_at(_towers, memory[_selectedTowerIndex]), 1)
				if canLevelUp
					memory[_gold] -> memory[_gold] - 1
					playActionSound()
				if canLevelUp = false
					playInvalidActionSound()
			if goldEnough = false
				playInvalidActionSound()
	if keyPressed(KEY_DOWN, true)
		if memory[_selectedTowerIndex] = ULTIMATE_INDEX
			canSellUltimate -> and((memory[_gold] + ULTIMATE_GOLD) <= GOLD_MAX, memory[_ultimateAvailable])
			if canSellUltimate
				memory[_gold] -> memory[_gold] + ULTIMATE_GOLD
				memory[_ultimateAvailable] -> false
				playActionSound()
			if canSellUltimate = false
				playInvalidActionSound()

		if memory[_selectedTowerIndex] != ULTIMATE_INDEX
			goldTooMuch -> GOLD_MAX <= memory[_gold]
			if goldTooMuch = false
				canLevelDown -> Tower_addLevel(Array_at(_towers, memory[_selectedTowerIndex]), -1)
				if canLevelDown
					memory[_gold] -> memory[_gold] + 1
					playActionSound()
				if canLevelDown = false
					playInvalidActionSound()
			if goldTooMuch
				playInvalidActionSound()

def handleBattleStateTransition()
	if and(anyEnemyExists() = false, memory[_stateToEnter] = STATE_NULL)
		if memory[_enemyLifeTotal] = ENEMY_LIFE_TOTAL_MAX
			memory[_stateToEnter] -> STATE_GAME_CLEAR
		if memory[_enemyLifeTotal] != ENEMY_LIFE_TOTAL_MAX
			towerExists -> anyTowerExists()
			if towerExists
				memory[_stateToEnter] -> STATE_READY
			if towerExists = false
				i -> 0
				while i < GOLD_NO_TOWER_PENALTY
					memory[_gold] -> max(memory[_gold] - 1, 0)
					playNoTowerPenaltySound(i)
					draw()
					sleep(20)
					i -> i + 1
				if memory[_gold] <= 0
					memory[_stateToEnter] -> STATE_GAME_OVER
				if 0 < memory[_gold]
					memory[_stateToEnter] -> STATE_READY

def tickToEnterState()
	if memory[_stateToEnter]
		memory[_timeToEnterState] -> memory[_timeToEnterState] + 1
		if memory[_timeToEnterState] = TIME_TO_ENTER_STATE
			memory[_timeToEnterState] -> 0
			if memory[_stateToEnter] = STATE_INITIAL
				enterInitial()
			if memory[_stateToEnter] = STATE_READY
				enterReady()
			if memory[_stateToEnter] = STATE_BATTLE
				enterBattle()
			if memory[_stateToEnter] = STATE_GAME_OVER
				enterGameOver()
			if memory[_stateToEnter] = STATE_GAME_CLEAR
				enterGameClear()
			memory[_stateToEnter] -> STATE_NULL

def updateEnemies()
	i -> 0
	while i < memory[_enemies + Array_length]
		_enemy -> Array_at(_enemies, i)
		if 0 < memory[_enemy + Enemy_life]
			Enemy_update(_enemy)
		i -> i + 1

def updateTowers()
	i -> 0
	while i < memory[_towers + Array_length]
		_tower -> Array_at(_towers, i)
		if 0 < memory[_tower + Tower_level]
			Tower_update(_tower)
		i -> i + 1

def updateBullets()
	i -> 0
	while i < memory[_bulletNextIndex]
		_bullet -> Array_at(_bullets, i)
		if Bullet_isLive(_bullet)
			Bullet_update(_bullet)
		i -> i + 1

def handleEnemiesEnemiesCollision()
	i -> 0
	while i < memory[_enemies + Array_length]
		_enemy -> Array_at(_enemies, i)
		if 0 < memory[_enemy + Enemy_life]
			handleEnemyEnemiesCollision(_enemy, i)
		i -> i + 1

def handleEnemyEnemiesCollision(_enemy, index)
	speedBuff -> 0
	i -> 0
	while i < memory[_enemies + Array_length]
		if i != index
			_otherEnemy -> Array_at(_enemies, i)
			if and(0 < memory[_otherEnemy + Enemy_life], Enemy_collidedWithEnemy(_enemy, _otherEnemy))
				speedBuff -> speedBuff + 1
		i -> i + 1
	Enemy_setSpeedBuff(_enemy, speedBuff)

def handleEnemiesTowersCollision()
	i -> 0
	while i < memory[_enemies + Array_length]
		_enemy -> Array_at(_enemies, i)
		if 0 < memory[_enemy + Enemy_life]
			if Enemy_collidedWithTower(_enemy)
				onEnemyCollidedWithTower(_enemy)
		i -> i + 1

def handleEnemiesBulletsCollision()
	i -> 0
	while i < memory[_bulletNextIndex]
		_bullet -> Array_at(_bullets, i)
		if Bullet_isLive(_bullet)
			handleEnemiesBulletCollision(_bullet)
		i -> i + 1

def handleEnemiesBulletCollision(_bullet)
	i -> 0
	while i < memory[_enemies + Array_length]
		_enemy -> Array_at(_enemies, i)
		if and(0 < memory[_enemy + Enemy_life], Enemy_collidedWithBullet(_enemy, _bullet))
			bulletExplode(_bullet)
		i -> i + 1

def enterInitial()
	memory[_state] -> STATE_INITIAL
	init()

def enterReady()
	memory[_state] -> STATE_READY
	memory[_waveNumber] -> memory[_waveNumber] + 1
	memory[_waveNoticeTime] -> 0
	memory[_selectedTowerIndex] -> 0
	memory[_enemyLifeTotal] -> min(memory[_enemyLifeTotal] + ENEMY_LIFE_TOTAL_INCREMENT, ENEMY_LIFE_TOTAL_MAX)
	initPathsAndEnemies()

def enterBattle()
	memory[_state] -> STATE_BATTLE
	initBullets()

def enterGameOver()
	memory[_state] -> STATE_GAME_OVER
	playGameOverSound()

def enterGameClear()
	memory[_state] -> STATE_GAME_CLEAR
	playGameClearSound()

def draw()
	drawBackground()
	drawTowers()
	drawUltimateIcon()
	if memory[_state] = STATE_INITIAL
		if memory[_stateToEnter] = STATE_NULL
			writeGameTitle()
			writeSpaceHint()

	if memory[_state] = STATE_READY
		drawPaths()
		if memory[_waveNoticeTime] < WAVE_NOTICE_TIME
			writeWaveNotice()
		if WAVE_NOTICE_TIME <= memory[_waveNoticeTime]
			drawTowerSelector()

	if memory[_state] = STATE_BATTLE
		if memory[_stateToEnter] = STATE_NULL
			drawPaths()
		drawEnemies()
		drawBullets()

	if or(memory[_state] = STATE_GAME_OVER, memory[_state] = STATE_GAME_CLEAR)
		if memory[_stateToEnter] = STATE_NULL
			if memory[_state] = STATE_GAME_OVER
				writeGameOver()
			if memory[_state] = STATE_GAME_CLEAR
				writeGameClear()
			writeSpaceHint()

	drawUI()

def drawUI()
	drawGoldBar()

def drawTowers()
	i -> 0
	while i < memory[_towers + Array_length]
		Tower_draw(Array_at(_towers, i))
		i -> i + 1

def drawPaths()
	length -> memory[_paths + Array_length]
	if memory[_state] = STATE_READY
		if memory[_waveNoticeTime] < WAVE_NOTICE_TIME
			length -> length * memory[_waveNoticeTime] / WAVE_NOTICE_TIME
	i -> 0
	while i < length
		Path_draw(Array_at(_paths, i))
		i -> i + 1

def drawEnemies()
	i -> 0
	while i < memory[_enemies + Array_length]
		_enemy -> Array_at(_enemies, i)
		if 0 < memory[_enemy + Enemy_life]
			Enemy_draw(_enemy)
		i -> i + 1

def drawBullets()
	i -> 0
	while i < memory[_bulletNextIndex]
		_bullet -> Array_at(_bullets, i)
		if Bullet_isLive(_bullet)
			Bullet_draw(_bullet)
		i -> i + 1

def drawUltimate(y)
	drawLine(0, y, SCREEN_WIDTH - 1 - (yAcrossGoldIndicator(y) * GOLD_BAR_WIDTH), y, ULTIMATE_COLOR_BEAM_BORDER)
	drawLine(0, y + 1, SCREEN_WIDTH - 1 - (yAcrossGoldIndicator(y + 1) * GOLD_BAR_WIDTH), y + 1, ULTIMATE_COLOR_BEAM_MAIN)
	drawLine(0, y + 2, SCREEN_WIDTH - 1 - (yAcrossGoldIndicator(y + 2) * GOLD_BAR_WIDTH), y + 2, ULTIMATE_COLOR_BEAM_BORDER)

def init()
	memory[_waveNumber] -> 0
	memory[_gold] -> GOLD_INITIAL
	memory[_ultimateAvailable] -> true
	memory[_enemyLifeTotal] -> ENEMY_LIFE_TOTAL_INITIAL
	initTowers()

def initTowers()
	Array(_towers, LANE_COUNT, Tower_size)
	i -> 0
	while i < LANE_COUNT
		Tower(Array_at(_towers, i), i, cond(remainder(i, 2) = 1, 1, 0))
		i -> i + 1

const BULLET_MAX_COUNT -> 2000
def initBullets()
	Array(_bullets, BULLET_MAX_COUNT, Bullet_size)
	memory[_bulletNextIndex] -> 0

def initPathsAndEnemies()
	life -> 5
	enemyCount -> memory[_enemyLifeTotal] / life
	smallEnemyLife -> remainder(memory[_enemyLifeTotal], life)
	while LANE_COUNT < (enemyCount + (smallEnemyLife != 0))
		life -> life + 5
		enemyCount -> memory[_enemyLifeTotal] / life
		smallEnemyLife -> remainder(memory[_enemyLifeTotal], life)

	Array(_paths, enemyCount + (smallEnemyLife != 0), Path_size)

	setMemory(_tempArray, memory[_paths + Array_length], false) # true for existence of path in <index>-nd lane
	i -> 0
	while i < memory[_paths + Array_length]
		newPathSet -> false
		while newPathSet = false
			laneIndex -> random(LANE_COUNT)
			if memory[_tempArray + laneIndex] = false
				memory[_tempArray + laneIndex] -> true
				Path(Array_at(_paths, i), laneIndex, random(LANE_COUNT), 0, 2 + random(SPOT_RANGE))
				newPathSet -> true
		i -> i + 1

	Array(_enemies, memory[_paths + Array_length], Enemy_size)
	i -> 0
	while i < enemyCount
		Enemy(Array_at(_enemies, i), life, Array_at(_paths, i))
		i -> i + 1
	if smallEnemyLife != 0
		Enemy(Array_at(_enemies, i), smallEnemyLife, Array_at(_paths, i))

def getUltimateDamage()
	level -> 0
	i -> 0
	while i < LANE_COUNT
		level -> level + memory[Array_at(_towers, i) + Tower_level]
		i -> i + 1
	out -> level / ULTIMATE_DAMAGE_RATE + ULTIMATE_DAMAGE_BASE

const ULTIMATE_Y -> TOWER_Y - 3
def useUltimate()
	memory[_ultimateAvailable] -> false
	damage -> getUltimateDamage()
	y -> ULTIMATE_Y
	while 0 <= y
		drawUltimate(y)
		flush()
		playUltimateSound()
		i -> 0
		while i < memory[_enemies + Array_length]
			_enemy -> Array_at(_enemies, i)
			if and(0 < memory[_enemy + Enemy_life], Enemy_collidedWithUltimate(_enemy, y))
				Enemy_hit(_enemy, damage)
			i -> i + 1
		draw()
		y -> y - 2

def bulletExplode(_bullet)
	i -> 0
	while i < memory[_enemies + Array_length]
		_enemy -> Array_at(_enemies, i)
		if and(0 < memory[_enemy + Enemy_life], Bullet_isEnemyInExplosion(_bullet, _enemy))
			Enemy_hit(_enemy, 1)
		i -> i + 1
	Bullet_remove(_bullet)

def anyTowerExists()
	towerExists -> false
	i -> 0
	while i < memory[_towers + Array_length]
		towerExists -> or(towerExists, 0 < memory[Array_at(_towers, i) + Tower_level])
		i -> i + 1
	out -> towerExists

def anyEnemyExists()
	enemyExists -> false
	i -> 0
	while i < memory[_enemies + Array_length]
		enemyExists -> or(enemyExists, 0 < memory[Array_at(_enemies, i) + Enemy_life])
		i -> i + 1
	out -> enemyExists

def onTowerShoot(index)
	Bullet(Array_at(_bullets, memory[_bulletNextIndex]), index)
	memory[_bulletNextIndex] -> memory[_bulletNextIndex] + 1

def onTowerDestroyed(index)

def onEnemyKilled(_enemy)
	memory[_gold] -> min(memory[_gold] + 1, GOLD_MAX)
	playGoldSound()

def onEnemyCollidedWithTower(_enemy)
	_tower -> Array_at(_towers, Enemy_getToLane(_enemy))
	towerExists -> 0 < memory[_tower + Tower_level]
	if towerExists
		Tower_hit(_tower, _enemy)
		memory[_enemy + Enemy_life] -> 0

def onEnemyExplode(_enemy)
	lane -> Enemy_getToLane(_enemy) - 1
	i -> 0
	while i < 3
		if and(0 <= lane, lane < LANE_COUNT)
			_tower -> Array_at(_towers, lane)
			if 0 < memory[_tower + Tower_level]
				Tower_hit(_tower, _enemy)
		lane -> lane + 1
		i -> i + 1
	memory[_enemy + Enemy_life] -> 0