game.tscn

[gd_scene load_steps=14 format=1]

[ext_resource path="res://levels/level1.tscn" type="PackedScene" id=1]
[ext_resource path="res://entity.tscn" type="PackedScene" id=2]
[ext_resource path="res://blur.tscn" type="PackedScene" id=3]
[ext_resource path="res://old_film.tscn" type="PackedScene" id=4]
[ext_resource path="res://gui.tscn" type="PackedScene" id=5]
[ext_resource path="res://war_room.tscn" type="PackedScene" id=6]
[ext_resource path="res://sounds/audio-library.tres" type="SampleLibrary" id=7]
[ext_resource path="res://music.tscn" type="PackedScene" id=8]
[ext_resource path="res://sounds/game.ogg" type="AudioStream" id=9]

[sub_resource type="GDScript" id=1]

script/source = "extends Node2D

var game_is_running = false
var player
var player_bag
var score = 0
var shrooms = 0
var fails = 0

var gui
var gui_anim
var gui_score
var gui_shrooms
var gui_hi
var gui_last
var gui_speed
var gui_fails

var at_war = false
var war_room

var dirty = false
var terrain
var entities
var anim
var game_anim
var triggers = []
var audio

var timer
var timers = []
var time_last = 0
var time_hi = 9999

const SHIFT_X = 10
const SHIFT_Y = 13
const GROUP_LETTER = \"letter\"
const GROUP_SNAKES = \"snakes\"
const GROUP_SHROOMS = \"shrooms\"

const POINTS_PERFECT = 1000
const POINTS_DIRTY = 100
const POINTS_ROAD = 10
const POINTS_SHROOM = 100
const POINTS_FAIL = -250
const POINTS_NO_FAIL_RATIO = 4
const POINTS_HI = 10

var letter = preload(\"res://letter.tscn\")
var snake = preload(\"res://snake.tscn\")
var shroom = preload(\"res://shroom.tscn\")
var shroom_red = preload(\"res://shroom_red.tscn\")

const LETTERS = [
	'a','b','c','d','e','f','g','h','i',
	'j','k','l','m','n','o','p','r',
	's','t','u','w','v','x','y','z']

const NUMBERS = [
	'0','1','2','3','4','5','6','7','8','9'
	]

const MIXED_SAFE = [
	'a','b','c','d','e','f','g','h',
	'j','k','l','m','n','p','r',
	's','t','u','w','v','x','y',
	'3','4','5','6','7','8','9'
]

const MODE_LETTERS = 0
const MODE_NUMBERS = 1
const MODE_HARDCODE = 2
var GAME_MODE = MODE_LETTERS
var GAME_MODE_WIN = MODE_HARDCODE

const TILE_SHROOM = 28
const TILE_SNAKE = 29
const TILE_GRASS = 5
const TILE_TRIGGER = [21,22,23]
const TILE_TRIGGER_EMPTY = 20

const CANT_MOVE = [-1,0,1,2, 6, 7]

func _ready():
	self.terrain = get_node(\"terrain\")
	self.entities = get_node(\"entities\")
	self.player = self.entities.get_node(\"player\")
	self.player_bag = self.player.get_node(\"g\")
	self.gui = self.player.get_node(\"camera/bottom/anchor/gui\")
	self.gui_anim = self.gui.get_node(\"anim\")
	self.gui_score = self.gui.get_node(\"score/val\")
	self.gui_shrooms = self.gui.get_node(\"shrooms/val\")
	self.gui_hi = self.gui.get_node(\"hi/val\")
	self.gui_last = self.gui.get_node(\"last/val\")
	self.gui_speed = self.gui.get_node(\"speed/val\")
	self.gui_fails = self.gui.get_node(\"fails/val\")
	self.timer = reset_timer()
	self.anim = self.player.get_node(\"anim\")
	self.game_anim = self.get_node(\"anim\")
	self.anim.connect(\"finished\", self, \"move_post_anim\")
	self.game_anim.connect(\"finished\", self, \"change_state_from_animation\")
	self.audio = self.get_node(\"audio\")
	self.war_room = self.get_node(\"entities/player/camera/bottom/anchor/war_room\")
	spawn_letters(self.player_bag)
	auto_spawn_entities(self.terrain)
	check_snakes(self.player)
	self.player.raise()
	set_fixed_process(true)
	set_process_input(true)
	
	Globals.set('player_hp', 3)
	Globals.set('snake_hp', 3)
	Globals.set('snake_words', 3)
	
func change_state_from_animation():
	var a = self.game_anim.get_current_animation()
	if a == \"fade-in\":
		self.game_anim.play(\"show_gui\")
		self.game_is_running = true
	if a == \"fade-out\":
		get_tree().change_scene(\"res://game_over.tscn\")
	
func reset_timer():
	return OS.get_ticks_msec()

func auto_spawn_entities(map):
	var cell
	for x in range(-24,24):
		for y in range(-24,24):
			cell = map.get_cell(x,y)
			if cell == self.TILE_SHROOM: spawn_entitie(self.shroom, self.GROUP_SHROOMS, x, y)
			if cell == self.TILE_SNAKE: spawn_entitie(self.snake, self.GROUP_SNAKES, x, y)
			if cell in self.TILE_TRIGGER: register_trigger(x, y, cell)
			
func spawn_entitie(type, group, x, y):
	var ent = type.instance()
	ent.set_position(x, y)
	ent.add_to_group(group)
	self.entities.add_child(ent)
	self.terrain.set_cell(x, y, self.TILE_GRASS)

func register_trigger(x, y, type):
	self.triggers.append([x, y])
	if type == TILE_TRIGGER[0]: self.GAME_MODE_WIN = self.MODE_LETTERS
	if type == TILE_TRIGGER[1]: self.GAME_MODE_WIN = self.MODE_NUMBERS
	if type == TILE_TRIGGER[2]: self.GAME_MODE_WIN = self.MODE_HARDCODE

func check_trigger(x, y):
	for trigger in self.triggers:
		if Vector2(trigger[0], trigger[1]) == Vector2(x,y):
			self.terrain.set_cell(x, y, self.TILE_TRIGGER_EMPTY)
			self.triggers.erase(trigger)
			return true
	return false
	
func spawn_letters(player):
	player.add_child(get_letter(Vector2(-2*SHIFT_X,0), 'a'))
	player.add_child(get_letter(Vector2(2*SHIFT_X,0), 'd'))
	player.add_child(get_letter(Vector2(-SHIFT_X,-SHIFT_Y), 'q'))
	player.add_child(get_letter(Vector2(SHIFT_X,-SHIFT_Y),'e'))
	player.add_child(get_letter(Vector2(-SHIFT_X,SHIFT_Y),'z'))
	player.add_child(get_letter(Vector2(SHIFT_X,SHIFT_Y),'c'))
	randomize_letters(player)
	check_letters(self.player, self.terrain)
	
func get_letter(pos, direction):
	var new_letter = self.letter.instance()
	new_letter.direction = direction
	new_letter.set_pos(pos)
	new_letter.add_to_group(self.GROUP_LETTER)
	return new_letter

func randomize_letters(player):
	var nodes = get_tree().get_nodes_in_group(self.GROUP_LETTER)
	var dictionary
	if self.GAME_MODE == self.MODE_LETTERS:
		dictionary = self.LETTERS
	elif self.GAME_MODE == self.MODE_NUMBERS:
		dictionary = self.NUMBERS
	elif self.GAME_MODE == self.MODE_HARDCODE:
		dictionary = self.MIXED_SAFE
	
	for node in nodes:
		dictionary = node.new_letter(dictionary)

func get_move(x, y, terrain, skip_shift_check = false):
	if not skip_shift_check and (y % 2 == 0): x+=1
	var block = terrain.get_cell(x, y) in self.CANT_MOVE
	if not block:
		var nodes = get_tree().get_nodes_in_group(self.GROUP_SNAKES)
		for node in nodes:
			if Vector2(node.x, node.y) == Vector2(x, y): return true
	return block
	
func check_letters(player, t):
	var x = player.x
	var y = player.y
	var nodes = get_tree().get_nodes_in_group(self.GROUP_LETTER)
	for node in nodes:
		node.show()
		if node.direction == 'a' and get_move(x-1, y, t, true): node.hide()
		if node.direction == 'd' and get_move(x+1, y, t, true): node.hide()
		if node.direction == 'q' and get_move(x-1, y-1, t): node.hide()
		if node.direction == 'e' and get_move(x, y-1, t): node.hide()
		if node.direction == 'z' and get_move(x-1, y+1, t): node.hide()
		if node.direction == 'c' and get_move(x, y+1, t): node.hide()

func get_visible_letters():
	var letters = []
	for node in get_tree().get_nodes_in_group(self.GROUP_LETTER):
		if node.is_visible():
			letters.append(node.letter)
	return letters
	
func get_letter_direction(letter):
	for node in get_tree().get_nodes_in_group(self.GROUP_LETTER):
		if node.is_visible() and node.letter == letter:
			return node.direction
			
func move_player(x, y, xx, yy):
	if not(self.player.y % 2 == 0) and not(y == 0): x+=1
	self.player.x += x
	self.player.y += y
	self.player.set_position()
	if check_trigger(self.player.x, self.player.y):
		if self.GAME_MODE == self.GAME_MODE_WIN:
			self.audio.play(\"win\")
			self.game_over(true)
			return false
		elif self.GAME_MODE == self.MODE_LETTERS:
			self.GAME_MODE = self.MODE_NUMBERS
		elif self.GAME_MODE == self.MODE_NUMBERS:
			self.GAME_MODE = self.MODE_HARDCODE
	randomize_letters(self.player)
	check_letters(self.player, self.terrain)
	check_snakes(self.player)
	check_shrooms(self.player)
	self.timer = reset_timer()
	
func check_shrooms(player):
	for node in get_tree().get_nodes_in_group(self.GROUP_SHROOMS):
		if node.check_near_by(player):
			self.shrooms += 1
			self.audio.play(\"shroom\")
			node.anim.play(\"die\")

func check_snakes(player):
	for node in get_tree().get_nodes_in_group(self.GROUP_SNAKES):
		if node.check_near_by(player):
			show_war_room(node)
			
func show_war_room(node):
	self.audio.play(\"snake\")
	self.game_is_running = false
	self.at_war = true
	self.gui.hide()
	self.war_room.start_war(node)

func hide_war_room():
	var snake = self.war_room.check_close()
	if snake:
		self.at_war = false
		snake.anim.play(\"die\")
		if self.war_room.is_player_alive():
			self.game_is_running = true
			self.gui.show()
		else:
			game_over(false)
	
func _input(event):
	var now = self.anim.get_current_animation()
	var frame = 6
	if(Input.is_key_pressed(KEY_ESCAPE)):
		get_tree().quit()
	
	if self.at_war: 
		hide_war_room()
		return false
	
	if event.type == InputEvent.KEY and event.is_pressed():
		self.gui_anim.play(\"press\")
		var hit = OS.get_scancode_string(event.unicode).to_lower()
		if now == \"idle\":
			if hit in get_visible_letters():
				register_time()
				if not self.dirty:
					self.score += POINTS_PERFECT
				else:
					self.dirty = false
					self.score += POINTS_DIRTY
				self.audio.play(\"jump\")
				if get_letter_direction(hit) in ['q','e']: frame = 7
				elif get_letter_direction(hit) in ['a','d']: frame = 8
				else: frame = 6
				self.player_bag.get_node(\"spr\").set_frame(frame)
				self.anim.play(\"move_\" + get_letter_direction(hit))
			else:
				self.dirty = true
				self.fails += 1
				self.audio.play(\"fail\")
				move_snakes(get_tree().get_nodes_in_group(self.GROUP_SNAKES), self.player)
				
func move_post_anim():
	var move = self.anim.get_current_animation()
	if  move == \"move_a\":
		move_player(-1, 0, -2*SHIFT_X, 0)
	elif  move == \"move_d\":
		move_player(1, 0, 2*SHIFT_X, 0)
	elif  move == \"move_q\":
		move_player(-1, -1, -SHIFT_X, -SHIFT_Y)
	elif  move == \"move_e\":
		move_player(0, -1, SHIFT_X, -SHIFT_Y)
	elif  move == \"move_z\":
		move_player(-1, 1, -SHIFT_X, SHIFT_Y)
	elif  move == \"move_c\":
		move_player(0, 1, SHIFT_X, SHIFT_Y)
	self.anim.play(\"idle\")

func calculate_score():
	if not self.game_is_running: return \"-\"
	var hi = self.time_hi
	var score_hi = 0
	var score_fail = 0
	var score_shrooms = 0
	if hi < 1000: score_hi =  self.POINTS_HI * (1000 - hi)
	score_fail = self.fails * self.POINTS_FAIL
		
	if self.fails == 0: 
		score_shrooms = self.shrooms * self.POINTS_SHROOM * self.POINTS_NO_FAIL_RATIO
	else:
		score_shrooms = self.shrooms * self.POINTS_SHROOM
		
	return self.score + score_hi + score_fail + score_shrooms
	
func game_over(win = false):
	self.score = calculate_score()
	self.game_is_running = false
	Globals.set('last_score', self.score)
	Globals.set('speed', calculate_average())
	Globals.set('shrooms', self.shrooms)
	Globals.set('win', win)
	self.game_anim.play('fade-out')

func get_time(from):
	return OS.get_ticks_msec() - from

func register_time():
	var t = get_time(self.timer)
	self.time_last = t
	if self.time_hi >= t:
		self.time_hi = t
	self.timers.append(t)
	
func update_gui():
	if not self.game_is_running: return
	self.gui_score.set_text(str(calculate_score()))
	self.gui_shrooms.set_text(str(self.shrooms))
	self.gui_speed.set_text(str(get_time(self.timer)) + \" ms\")
	self.gui_last.set_text(str(self.time_last) + \" ms\")
	self.gui_hi.set_text(str(self.time_hi) + \" ms\")
	self.gui_fails.set_text(str(self.fails))
	
func calculate_average():
	var count = 0
	var timers = self.timers.size()
	if timers > 0: 
		for t in range(0, timers-1):
			count += self.timers[t]
		return count / timers
	else: return 0
	
func _fixed_process(delta):
	update_gui()
		
func move_snakes(snakes, player):
	pass"

[sub_resource type="Animation" id=2]

resource/name = "fade-in"
length = 2.0
loop = false
step = 0.1
tracks/0/type = "value"
tracks/0/path = NodePath(".:visibility/opacity")
tracks/0/interp = 1
tracks/0/imported = false
tracks/0/keys = {
"times": FloatArray( 0, 1 ),
"transitions": FloatArray( 1, 1 ),
"update": 0,
"values": [ 0.0, 1.0 ]
}

[sub_resource type="Animation" id=3]

resource/name = "fade-out"
length = 1.5
loop = false
step = 0.1
tracks/0/type = "value"
tracks/0/path = NodePath(".:visibility/opacity")
tracks/0/interp = 1
tracks/0/imported = false
tracks/0/keys = {
"times": FloatArray( 0, 1 ),
"transitions": FloatArray( 1, 1 ),
"update": 0,
"values": [ 1.0, 0.0 ]
}

[sub_resource type="Animation" id=4]

length = 1.0
loop = false
step = 0.1
tracks/0/type = "value"
tracks/0/path = NodePath("entities/player/camera/bottom:visibility/opacity")
tracks/0/interp = 1
tracks/0/imported = false
tracks/0/keys = {
"times": FloatArray( 0, 0.5 ),
"transitions": FloatArray( 1, 1 ),
"update": 0,
"values": [ 0.0, 1.0 ]
}

[node name="main" type="Node2D"]

script/script = SubResource( 1 )
__meta__ = {
"_edit_lock_": true
}

[node name="terrain" parent="." instance=ExtResource( 1 )]

[node name="entities" type="YSort" parent="."]

z/z = 10
z/relative = false
sort/enabled = true

[node name="player" parent="entities" instance=ExtResource( 2 )]

transform/pos = Vector2( 0, -1 )

[node name="g" parent="entities/player"]

editor/display_folded = true

[node name="camera" type="Camera2D" parent="entities/player"]

transform/pos = Vector2( 40, 4 )
transform/scale = Vector2( 0.5, 0.5 )
z/z = 999
z/relative = false
offset = Vector2( -192, -90 )
anchor_mode = 0
rotating = false
current = true
zoom = Vector2( 0.25, 0.25 )
limit/left = -10000000
limit/top = -10000000
limit/right = 10000000
limit/bottom = 10000000
drag_margin/h_enabled = true
drag_margin/v_enabled = true
smoothing/enable = true
smoothing/speed = 4.0
drag_margin/left = 1.0
drag_margin/top = 1.0
drag_margin/right = 1.0
drag_margin/bottom = 1.0

[node name="blur" parent="entities/player/camera" instance=ExtResource( 3 )]

anchor/left = 3
anchor/top = 3
anchor/right = 3
anchor/bottom = 3
rect/min_size = Vector2( 800, 500 )
margin/left = 446.0
margin/top = 298.0
margin/right = -354.0
margin/bottom = -202.0

[node name="old_film" parent="entities/player/camera" instance=ExtResource( 4 )]

margin/left = -447.0
margin/top = -264.0
margin/right = -362.0
margin/bottom = -178.0

[node name="bottom" type="CenterContainer" parent="entities/player/camera"]

anchor/top = 1
anchor/right = 1
anchor/bottom = 1
rect/scale = Vector2( 1.5, 1.5 )
focus/ignore_mouse = false
focus/stop_mouse = true
size_flags/horizontal = 2
size_flags/vertical = 2
margin/left = -36.0
margin/top = -76.0
margin/right = 100.0
margin/bottom = -76.0
use_top_left = false

[node name="anchor" type="Control" parent="entities/player/camera/bottom"]

focus/ignore_mouse = false
focus/stop_mouse = true
size_flags/horizontal = 2
size_flags/vertical = 2
margin/left = 0.0
margin/top = 0.0
margin/right = 0.0
margin/bottom = 0.0

[node name="gui" parent="entities/player/camera/bottom/anchor" instance=ExtResource( 5 )]

editor/display_folded = true

[node name="war_room" parent="entities/player/camera/bottom/anchor" instance=ExtResource( 6 )]

editor/display_folded = true
visibility/visible = false
margin/left = 0.0
margin/top = 63.0
margin/right = 0.0
margin/bottom = 63.0

[node name="audio" type="SamplePlayer2D" parent="."]

params/volume_db = 0.0
params/pitch_scale = 1.0
params/attenuation/min_distance = 1.0
params/attenuation/max_distance = 2048.0
params/attenuation/distance_exp = 1.0
config/polyphony = 1
config/samples = ExtResource( 7 )
config/pitch_random = 0.0

[node name="anim" type="AnimationPlayer" parent="."]

playback/process_mode = 1
playback/default_blend_time = 0.0
root/root = NodePath("..")
anims/fade-in = SubResource( 2 )
anims/fade-out = SubResource( 3 )
anims/show_gui = SubResource( 4 )
playback/active = true
playback/speed = 2.0
blend_times = [  ]
autoplay = "fade-in"

[node name="music" parent="." instance=ExtResource( 8 )]

stream/stream = ExtResource( 9 )
stream/volume_db = -5.0


[editable path="entities/player"]
[editable path="entities/player/camera/bottom/anchor/war_room"]
[editable path="music"]