revo-jailbreak/autoloads/game.gd

extends Node

enum Difficulty {
	SWEET,   # slower enemies, infinite lives
	SALTY,   # normal enemies, infinite lives
	SPICY,   # normal enemies, 3 lives, DEFAULT
	PUNGENT, # faster enemies, 3 lives
}

const DIFFICULTY_NAMES = ["Sweet","Salty","Spicy","Pungent"]

var resolution = Vector2(256,192)
var current_sector = Vector2(0,0)
#Onreadys
#Collectibles
var keys = 0
var stars = [false,false,false,false,false]
var shards = 0
var arrows = 0
var score = 0
var high_score = 0
var lives = 2
var deaths = 0
var time = 0.0
#Objects
const block_text = preload("res://objects/hud/blocktext.tscn")
const pause_screen = preload("res://objects/hud/pause_screen.tscn")
#Game info
var respawn_point = Vector2(32,166) #Respawn point
var current_level = 0 #Current level being played
var current_file = 1 #Current save file
var shards_collected = [false,false,false,false,false,false,false,false,false,false]
var is_marathon_mode = false
var difficulty: int = Difficulty.SPICY setget _set_difficulty
var enemy_speed_factor: float = 1.0 # multiplier of enemy speed
var is_easy_mode = false # whether to do easy-specific behaviors
var easy_mode_speed_factor = 0.75 # DEPRECATED: speed enemies go in easy mode
var use_lives = false
var can_pause = true
var current_palette = "default"

func _ready():
	pause_mode = Node.PAUSE_MODE_PROCESS


# stuff to change when setting difficulty
func _set_difficulty(value: int) -> void:
	difficulty = value
	match difficulty:
		Difficulty.SWEET:
			is_easy_mode = true
			enemy_speed_factor = 0.75
			use_lives = false
		Difficulty.SALTY:
			is_easy_mode = false
			enemy_speed_factor = 1.0
			use_lives = false
		Difficulty.SPICY:
			is_easy_mode = false
			enemy_speed_factor = 1.0
			use_lives = true
		Difficulty.PUNGENT:
			is_easy_mode = false
			enemy_speed_factor = 1.25
			use_lives = true

#Instances a node
func instance_node(node:PackedScene,x:float,y:float,parent):
		var Instance = node.instance()
		Instance.global_position = Vector2(x,y)
		parent.add_child(Instance)

#Get position in sectors
func get_sector(pos):
	return (pos / resolution).floor()

#Return the current Map
func get_map():
	return get_tree().get_nodes_in_group("map")[0]

#Go to new map
func change_map(map: PackedScene):
	get_tree().paused = true
	can_pause = false
	Fade.fade_out(0.4)
	yield(Fade, "fade_finished")
	can_pause = true
	# save deaths
	var save_id = LevelData.levels[current_level].save_id
	var save_data: Save.LevelSaveData = Save.current_file.levels[save_id]
	save_data.deaths += deaths
	Save.current_file.save_to_file()
	# clear
	clear_collectibles()
	#Loop is so no more than one level is loaded at a time
	SceneManager.current_scene = map.instance()

#Clear data
func clear_collectibles():
	score = 0
	keys = 0
	stars = [false,false,false,false,false]
	shards = 0
	shards_collected = [false,false,false,false,false,false,false,false,false,false]
	arrows = 0
	lives = 2
	deaths = 0

#Save
func save():
	# get level's save data object
	var save_id = LevelData.levels[current_level].save_id
	var save_data: Save.LevelSaveData = Save.current_file.levels[save_id]
	
	# save score and time depending on completion
	if shards >= 5 && keys >= 50:
		save_data.score_100 = max(save_data.score_100, score)
		save_data.time_100 = min(save_data.time_100, time)
	else:
		save_data.score_any = max(save_data.score_100, score)
		save_data.time_any = min(save_data.time_any, time)
	
	# set shards
	for i in 8:
		if shards_collected[i]:
			save_data.shards_collected[i] = true
	
	# set keys
	save_data.keys_collected = max(save_data.keys_collected, keys)
	
	# add to playtime
	Save.current_file.play_time += time
	
	# save the file
	Save.current_file.save_to_file()


#Convert seconds into M:SS:MS
func timeify(input):
	if input < 600:
		var minutes = str(floor(input / 60))
		var seconds = floor(fmod(input,60))
		var milliseconds := floor(fmod(input, 1) * 100)
		return minutes + ":" + ("%02d" % seconds) + "." + ("%02d" % milliseconds)
	elif input == INF:
		return "-:--.--"
	else:
		return "9:59.99"

#Restart level
func restart_level():
	if score > high_score: high_score = score
	score = 0
	keys = 0
	stars = [false,false,false,false,false]
	shards = 0
	arrows = 0
	lives = 2
	Audio.ac_climb.stop()
	Audio.ac_die.stop()
	Engine.time_scale = 1.0
	for tween in get_tree().get_processed_tweens():
		tween.kill()
	change_map(load(get_map().filename))
	Audio.ac_music.stream_paused = false

#Freeze frame
func freeze_frame(time):
	get_tree().paused = true
	var timer = get_tree().create_timer(time, true)
	timer.connect("timeout", get_tree(), "set_pause", [false])
	return timer

#Check if 100%ed
func has_collection_bonus():
	return shards == 5 && keys == 50

# called when player dies
func _on_player_died() -> void:
	deaths += 1
	if lives <= 0 and use_lives:
		Audio.play_sound(Audio.a_gover, Audio.ac_die)
		get_tree().get_nodes_in_group("player")[0].queue_free()
		var time_tween = create_tween()
		time_tween.tween_property(Engine, "time_scale", 0.1, 0.3)
		Audio.ac_music.stream_paused = true
		yield(time_tween, "finished")
		yield(get_tree().create_timer(1.0 * 0.1), "timeout")
		call_deferred("restart_level")
	else:
		# count death
		lives -= 1
		# play death sound
		Audio.play_sound(Audio.a_die, Audio.ac_die)
		# death score penalty
		if use_lives == false && lives < 0:
				score = max(0, score - 500)
		# freezeframe
		Game.freeze_frame(0.3)