added endless mode support to the wave viewer

Scripts/game.gd

@@ -87,6 +87,30 @@ func networked_set_wave(wave_number: int) -> void:
 		connected_players_nodes[player].hud.set_wave_count(wave_number)
 	wave = wave_number
 	set_upcoming_wave()
+	
+	
+
+
+##wave_count is number of upcoming waves this function should return
+func get_upcoming_waves(wave_count: int) -> Array[Wave]:
+	var waves: Array[Wave] = []
+	var i: int = -1
+	for wave_config: WaveConfig in level_specs.waves.slice(wave - 1):
+		i += 1
+		var new_wave: Wave = Wave.new()
+		for enemy: Enemy in level_specs.waves[wave - 1 + i].enemies.keys():
+			var enemy_card: EnemyCard = EnemyCard.new()
+			enemy_card.enemy = enemy
+			enemy_card.count = level_specs.waves[wave - 1 + i].enemies[enemy]
+			new_wave.enemy_groups.append(enemy_card)
+		waves.append(new_wave)
+	if waves.size() < wave_count:
+		var starting_wave: int = wave
+		for x: int in wave_count - waves.size():
+			var spawn_power: int = WaveManager.calculate_spawn_power(starting_wave + x, connected_players_nodes.size())
+			var new_wave: Wave = WaveManager.generate_wave(spawn_power, level.enemy_pool)
+			waves.append(new_wave)
+	return waves
 
 
 func spawn_level(scene: PackedScene) -> void:
@@ -154,15 +178,11 @@ func ready_player(player_ready_true: bool) -> void:
 
 
 func spawn_enemy_wave() -> void:
-	#level.shop.close()
-	#wave += 1
 	level.disable_all_tower_frames()
 	level.flow_field.calculate()
 	for spawn: EnemySpawner in level.enemy_spawns:
 		spawn.visible = false
 		spawn.spawn_wave()
-	#for tower_base: TowerBase in level.walls.values():
-		#tower_base.disable_duration_sprites()
 	wave_started.emit()
 
 
@@ -215,18 +235,8 @@ func set_upcoming_wave() -> void:
 
 func temp_set_upcoming_wave(new_wave: Wave, coins: int) -> void:
 	pot = coins
-	#connected_players_nodes[multiplayer.get_unique_id()].hud.show_wave_generation_anim(new_wave)
 	connected_players_nodes[multiplayer.get_unique_id()].hud.set_upcoming_wave(new_wave.to_dict())
 
-#TODO: You'll probably have to write a to_dict function for the new wave system 
-#before any of this shit works in multiplayer
-#@rpc("reliable", "call_local")
-#func networked_set_upcoming_wave(wave_dict: Dictionary, coins: int) -> void:
-	#upcoming_wave = wave_dict
-	#pot = coins
-	#for key: int in connected_players_nodes:
-		#connected_players_nodes[key].hud.set_upcoming_wave(upcoming_wave)
-
 
 @rpc("reliable", "call_local")
 func networked_set_endless(value: bool) -> void:
@@ -299,7 +309,7 @@ func end_wave() -> void:
 		#else:
 			#shop_chance += 0.09
 	wave_finished.emit()
-	if wave < wave_limit:
+	if wave <= wave_limit:
 		set_upcoming_wave()
 
 
@@ -383,13 +393,25 @@ func end(outcome: bool) -> void:
 			menu.set_outcome_message("You lost...")
 			lost_game.emit()
 		true:
+			menu.won_game()
 			menu.set_outcome_message("You win!")
 			won_game.emit()
+			menu.pressed_continue.connect(continue_with_game)
 	UILayer.add_child(menu)
 	Input.mouse_mode = Input.MOUSE_MODE_VISIBLE
 	connected_players_nodes[multiplayer.get_unique_id()].pause()
 
 
+func continue_with_game() -> void:
+	game_active = true
+	gamemode.endless = true
+	Input.mouse_mode = Input.MOUSE_MODE_CAPTURED
+	connected_players_nodes[multiplayer.get_unique_id()].unpause()
+	#TODO: This shouldn't happen. instead, the wave generator should generate level_specs waves
+	level_specs.waves = []
+	set_upcoming_wave()
+
+
 func quit_to_desktop() -> void:
 	multiplayer.multiplayer_peer.close()
 	multiplayer.multiplayer_peer = null

Scripts/wave_manager.gd

@@ -13,7 +13,8 @@ extends Object
 ## Takes in wave number and number of players and returns a spawn power value
 ## intended for passing into the generate_wave method
 static func calculate_spawn_power(wave_number: int, number_of_players: int) -> int:
-	return (20 * number_of_players) + (4 * wave_number)
+	#print("wave number: " + str(wave_number) + ", number of players: " + str(number_of_players))
+	return (11 * number_of_players) + (6 * wave_number)
 
 
 ## Takes in wave number and number of players and returns the amount of coins
@@ -38,9 +39,8 @@ static func get_test_wave(spawn_pool: Array[Enemy]) -> Wave:
 static func generate_wave(spawn_power: int, spawn_pool: Array[Enemy]) -> Wave:
 	var wave: Wave = Wave.new()
 	
-	var points: int = int(spawn_power / 10.0)
 	#print("Generating wave with " + str(points) + " points to spend")
-	while points > 0:
+	while spawn_power > 0:
 		var new_card: EnemyCard = EnemyCard.new()
 		
 		#First, choose an enemy at random
@@ -50,49 +50,33 @@ static func generate_wave(spawn_power: int, spawn_pool: Array[Enemy]) -> Wave:
 		#and, if not, then we have to pick a different enemy, repeat until
 		#we've successfully chosen one we can actually afford
 		var enemy_chosen: bool = false
-		var highest_rarity: Data.Rarity = Data.Rarity.COMMON
+		var most_enemies_afforded: int = 0
+		var first_enemy_id: int = -1
 		while !enemy_chosen:
-			#Next, determine which is the most expensive rarity we can afford
-			if new_card.enemy.legendary_cost <= points:
-				highest_rarity = Data.Rarity.LEGENDARY
-				enemy_chosen = true
-			elif new_card.enemy.epic_cost <= points:
-				highest_rarity = Data.Rarity.EPIC
-				enemy_chosen = true
-			elif new_card.enemy.rare_cost <= points:
-				highest_rarity = Data.Rarity.RARE
-				enemy_chosen = true
-			elif new_card.enemy.uncommon_cost <= points:
-				highest_rarity = Data.Rarity.UNCOMMON
-				enemy_chosen = true
-			elif new_card.enemy.common_cost <= points:
-				highest_rarity = Data.Rarity.COMMON
+			#Next, determine what is the most groups we can afford
+			most_enemies_afforded = int(spawn_power / new_card.enemy.spawn_power)
+			if most_enemies_afforded > 0:
 				enemy_chosen = true
 			else:
-				#Even the common rarity was too expensive, so we have to choose
+				#Even 1 group was too expensive, so we have to choose
 				#a different enemy and try this process again
 				var enemy_id: int = spawn_pool.find(new_card.enemy)
 				enemy_id -= 1
+				if first_enemy_id == -1:
+					first_enemy_id = enemy_id
 				if enemy_id < 0:
 					new_card.enemy = spawn_pool[spawn_pool.size() - 1]
 				else:
 					new_card.enemy = spawn_pool[enemy_id]
-		
-		#Now that we know which rarities we could afford, lets just choose a
-		#random one
-		var chosen_rarity: int = NoiseRandom.randi_in_range(spawn_power, 0, highest_rarity)
-		new_card.rarity = chosen_rarity as Data.Rarity
+				most_enemies_afforded = 0
+				if enemy_id == first_enemy_id:
+					return wave
+		#Now that we know how many we could afford, lets just choose a
+		#random number of groups
+		var chosen_groups: int = NoiseRandom.randi_in_range(spawn_power, 1, most_enemies_afforded)
+		new_card.count = chosen_groups * new_card.enemy.group_size
 		
 		#Add that new enemy to the wave and spend the points!
 		wave.enemy_groups.append(new_card)
-		if chosen_rarity == Data.Rarity.COMMON:
-			points -= new_card.enemy.common_cost
-		elif chosen_rarity == Data.Rarity.UNCOMMON:
-			points -= new_card.enemy.uncommon_cost
-		elif chosen_rarity == Data.Rarity.RARE:
-			points -= new_card.enemy.rare_cost
-		elif chosen_rarity == Data.Rarity.EPIC:
-			points -= new_card.enemy.epic_cost
-		elif chosen_rarity == Data.Rarity.LEGENDARY:
-			points -= new_card.enemy.legendary_cost
+		spawn_power -= chosen_groups * new_card.enemy.spawn_power
 	return wave