diff --git a/microjogos/2022S1/baleia/cenas/baleiaGame.gd b/microjogos/2022S1/baleia/cenas/baleiaGame.gd index 48e7416ef..e0dd30bf3 100644 --- a/microjogos/2022S1/baleia/cenas/baleiaGame.gd +++ b/microjogos/2022S1/baleia/cenas/baleiaGame.gd @@ -1,13 +1,7 @@ extends Node2D -const WIDTH = 1920 -const HEIGHT = 1080 - const MAX_DIFF = 730 func _ready(): $TileMap.position += Vector2(randf_range(0, 730), 0) - - -signal win -signal lose + diff --git a/microjogos/2022S1/baleia/cenas/scripts/main.gd b/microjogos/2022S1/baleia/cenas/scripts/main.gd deleted file mode 100644 index e154b7797..000000000 --- a/microjogos/2022S1/baleia/cenas/scripts/main.gd +++ /dev/null @@ -1,9 +0,0 @@ -extends Node2D - - -signal win -signal lose - - -const WIDTH = 1920 -const HEIGHT = 1080 diff --git a/microjogos/2022S1/baleia/cenas/scripts/main.gd.uid b/microjogos/2022S1/baleia/cenas/scripts/main.gd.uid deleted file mode 100644 index 46a3e27d7..000000000 --- a/microjogos/2022S1/baleia/cenas/scripts/main.gd.uid +++ /dev/null @@ -1 +0,0 @@ -uid://ctviu18pxp7f1 diff --git a/microjogos/2022S1/baleia/cenas/scripts/scripts.txt b/microjogos/2022S1/baleia/cenas/scripts/scripts.txt deleted file mode 100644 index da9d2afec..000000000 --- a/microjogos/2022S1/baleia/cenas/scripts/scripts.txt +++ /dev/null @@ -1 +0,0 @@ -Coloque seus scripts aqui! \ No newline at end of file diff --git a/microjogos/2022S1/gamuturai/cenas/Espada.gd b/microjogos/2022S1/gamuturai/cenas/Espada.gd index 185845f7b..876cd4618 100644 --- a/microjogos/2022S1/gamuturai/cenas/Espada.gd +++ b/microjogos/2022S1/gamuturai/cenas/Espada.gd @@ -21,17 +21,17 @@ func _process(delta): if 880 < position.x and position.x< 1038: gamuturai_animation_player.play("win") - base.emit_signal("win") + Minigames.register_win(self) print("você é um tremendo batutinha") elif 724 <= position.x and position.x <= 880 or 1038 <= position.x and position.x <= 1210: gamuturai_animation_player.play("half") - base.emit_signal("win") + Minigames.register_win(self) print("você é quase um batutinha") else: gamuturai_animation_player.play("lose") - base.emit_signal("lose") + Minigames.register_lose(self) print("você não é um batutinha") diff --git a/microjogos/2022S1/gamuturai/cenas/cenas.txt b/microjogos/2022S1/gamuturai/cenas/cenas.txt index 5452e0e17..dcc9b779d 100644 --- a/microjogos/2022S1/gamuturai/cenas/cenas.txt +++ b/microjogos/2022S1/gamuturai/cenas/cenas.txt @@ -1 +1 @@ -Coloque suas cenas aqui! A cena que vai rodar no jogo deve necessariamente ser a Main.tscn \ No newline at end of file +Coloque suas cenas aqui! A cena que vai rodar no jogo deve necessariamente ser a Main.tscn diff --git a/microjogos/2022S1/gamuturai/cenas/main.tscn b/microjogos/2022S1/gamuturai/cenas/main.tscn index 4245b2225..26d9dd20b 100644 --- a/microjogos/2022S1/gamuturai/cenas/main.tscn +++ b/microjogos/2022S1/gamuturai/cenas/main.tscn @@ -489,14 +489,14 @@ script = ExtResource("6") [node name="AnimationPlayer" type="AnimationPlayer" parent="Gamuturai"] libraries = { -"": SubResource("AnimationLibrary_k7gop") +&"": SubResource("AnimationLibrary_k7gop") } [node name="Folha" type="CPUParticles2D" parent="."] position = Vector2(2020, 540) amount = 32 -lifetime = 5.0 texture = ExtResource("8") +lifetime = 5.0 emission_shape = 3 emission_rect_extents = Vector2(1, 600) direction = Vector2(-1, 0) @@ -512,8 +512,8 @@ scale_amount_max = 3.0 [node name="Folha(amongus)" type="CPUParticles2D" parent="."] position = Vector2(2020, 540) amount = 4 -lifetime = 5.0 texture = ExtResource("11_7ysg3") +lifetime = 5.0 emission_shape = 3 emission_rect_extents = Vector2(1, 600) direction = Vector2(-1, 0) diff --git a/microjogos/2022S1/gamuturai/cenas/scripts/main.gd b/microjogos/2022S1/gamuturai/cenas/scripts/main.gd index 4809cb2a3..fa4fc3ddd 100644 --- a/microjogos/2022S1/gamuturai/cenas/scripts/main.gd +++ b/microjogos/2022S1/gamuturai/cenas/scripts/main.gd @@ -2,10 +2,3 @@ extends Node2D func _ready(): $Musica.play() - -signal win -signal lose - - -const WIDTH = 1920 -const HEIGHT = 1080 diff --git a/microjogos/2022S1/race/cenas/Player.gd b/microjogos/2022S1/race/cenas/Player.gd index 6cff11f70..1b7e79d68 100644 --- a/microjogos/2022S1/race/cenas/Player.gd +++ b/microjogos/2022S1/race/cenas/Player.gd @@ -34,7 +34,7 @@ func _physics_process(delta): rotation = atan2(velocity.y, velocity.x) var collided = move_and_collide(velocity*delta) if(collided): - parent.register_lose() + Minigames.register_lose(self) alive = false get_node("Sprite2D").visible = false get_node("Trail").emitting = false diff --git a/microjogos/2022S1/race/cenas/scripts/main.gd b/microjogos/2022S1/race/cenas/scripts/main.gd index 976c8976a..93c42800f 100644 --- a/microjogos/2022S1/race/cenas/scripts/main.gd +++ b/microjogos/2022S1/race/cenas/scripts/main.gd @@ -1,11 +1,7 @@ extends Node2D -signal win -signal lose -const WIDTH = 1920 -const HEIGHT = 1080 var winnable = true var losable = true @@ -19,11 +15,11 @@ func register_win(): if(winnable): losable = false get_node("VictorySFX").play() - emit_signal("win") + Minigames.register_win(self) func register_lose(): if(losable): winnable = false losable = false get_node("DefeatSFX").play() - emit_signal("lose") + Minigames.register_lose(self) diff --git a/microjogos/2022S1/seu_projeto/capa.png b/microjogos/2022S1/seu_projeto/capa.png deleted file mode 100644 index 41ee872d4..000000000 Binary files a/microjogos/2022S1/seu_projeto/capa.png and /dev/null differ diff --git a/microjogos/2022S1/seu_projeto/cenas/cenas.txt b/microjogos/2022S1/seu_projeto/cenas/cenas.txt deleted file mode 100644 index 5452e0e17..000000000 --- a/microjogos/2022S1/seu_projeto/cenas/cenas.txt +++ /dev/null @@ -1 +0,0 @@ -Coloque suas cenas aqui! A cena que vai rodar no jogo deve necessariamente ser a Main.tscn \ No newline at end of file diff --git a/microjogos/2022S1/seu_projeto/cenas/main.tscn b/microjogos/2022S1/seu_projeto/cenas/main.tscn deleted file mode 100644 index 2884a31b3..000000000 --- a/microjogos/2022S1/seu_projeto/cenas/main.tscn +++ /dev/null @@ -1,6 +0,0 @@ -[gd_scene load_steps=2 format=3 uid="uid://b1a762rtbal6j"] - -[ext_resource type="Script" uid="uid://caopud87pssfg" path="res://microjogos/2022S1/race/cenas/scripts/main.gd" id="1"] - -[node name="SeuJogo" type="Node2D"] -script = ExtResource("1") diff --git a/microjogos/2022S1/seu_projeto/cenas/scripts/main.gd b/microjogos/2022S1/seu_projeto/cenas/scripts/main.gd deleted file mode 100644 index e154b7797..000000000 --- a/microjogos/2022S1/seu_projeto/cenas/scripts/main.gd +++ /dev/null @@ -1,9 +0,0 @@ -extends Node2D - - -signal win -signal lose - - -const WIDTH = 1920 -const HEIGHT = 1080 diff --git a/microjogos/2022S1/seu_projeto/cenas/scripts/main.gd.uid b/microjogos/2022S1/seu_projeto/cenas/scripts/main.gd.uid deleted file mode 100644 index b29ef0c94..000000000 --- a/microjogos/2022S1/seu_projeto/cenas/scripts/main.gd.uid +++ /dev/null @@ -1 +0,0 @@ -uid://cc2nstc41ktlk diff --git a/microjogos/2022S1/seu_projeto/cenas/scripts/scripts.txt b/microjogos/2022S1/seu_projeto/cenas/scripts/scripts.txt deleted file mode 100644 index da9d2afec..000000000 --- a/microjogos/2022S1/seu_projeto/cenas/scripts/scripts.txt +++ /dev/null @@ -1 +0,0 @@ -Coloque seus scripts aqui! \ No newline at end of file diff --git a/microjogos/2022S1/seu_projeto/creditos/creditos.txt b/microjogos/2022S1/seu_projeto/creditos/creditos.txt deleted file mode 100644 index a309f5722..000000000 --- a/microjogos/2022S1/seu_projeto/creditos/creditos.txt +++ /dev/null @@ -1 +0,0 @@ -Preencha esse arquivo com os créditos do seu jogo, incluindo quem fez cada parte e o link para qualquer recurso externo que foi utilizado! Se quiser incluir alguma imagem, jogue ela nessa pasta diff --git a/microjogos/2022S1/seu_projeto/recursos/recursos.txt b/microjogos/2022S1/seu_projeto/recursos/recursos.txt deleted file mode 100644 index dc6a91edd..000000000 --- a/microjogos/2022S1/seu_projeto/recursos/recursos.txt +++ /dev/null @@ -1 +0,0 @@ -Guarde os recursos - como imagens, sons e fontes - que seu jogo vai usar aqui. É recomendado criar subpastas pra organizar melhor seus arquivos dependendo do tipo ou propósito diff --git a/microjogos/2022S1/seu_projeto/seu projeto.txt b/microjogos/2022S1/seu_projeto/seu projeto.txt deleted file mode 100644 index a627e0078..000000000 --- a/microjogos/2022S1/seu_projeto/seu projeto.txt +++ /dev/null @@ -1,3 +0,0 @@ -Boas vindas à sua área de trabalho! Sinta-se livre para renomear essa pasta com o seu nome ou o nome do seu jogo. O que tiver aqui vai ser sua entrega final quando o seu jogo estiver pronto. - -As pastas aqui dentro tem arquivos de texto explicando seu propósito, e a cena principal está localizada em cenas. O arquivo capa é uma imagem 450x450 que aparece quando seu jogo carrega. Troque ela por alguma coisa interessante mais pra frente! \ No newline at end of file diff --git a/microjogos/2023S1/GamutoVeiga/cenas/scripts/main.gd b/microjogos/2023S1/GamutoVeiga/cenas/scripts/main.gd index 262306588..85f32cd74 100644 --- a/microjogos/2023S1/GamutoVeiga/cenas/scripts/main.gd +++ b/microjogos/2023S1/GamutoVeiga/cenas/scripts/main.gd @@ -13,17 +13,12 @@ var efeito_swap var efeito_ganhou var efeito_perdeu - -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + const TOLERANCE = 20 @@ -82,7 +77,7 @@ func resultado(x): if abs(copo_2.position.x - x) < TOLERANCE: print("VENCEU") efeito_ganhou.play() - register_win() + Minigames.register_win(self) else: print("PERDEU") timer.disconnect("timeout", mostrar) @@ -91,7 +86,7 @@ func resultado(x): timer.one_shot = true timer.start() efeito_perdeu.play() - register_lose() + Minigames.register_lose(self) func subir_copo_certo(): copo_2.subir() @@ -154,11 +149,3 @@ func mostrar(): gamuto.position = Vector2(copo_2.position.x, 592) gamuto.show() escolha_flag = true - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2023S1/bis-limao/cenas/scripts/main.gd b/microjogos/2023S1/bis-limao/cenas/scripts/main.gd index 2b05b68a2..4ccf85545 100644 --- a/microjogos/2023S1/bis-limao/cenas/scripts/main.gd +++ b/microjogos/2023S1/bis-limao/cenas/scripts/main.gd @@ -1,15 +1,11 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + var rng = RandomNumberGenerator.new() var alreadyLost = false @@ -20,7 +16,7 @@ var alreadyLost = false # Esta função é chamada assim que esta cena é instanciada, ou seja, assim que seu minigame inicia func _ready(): - register_win() + Minigames.register_win(self) rng.randomize() @@ -90,16 +86,10 @@ func my_method(): # vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador # perderá o jogo - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - # Chame esta função para registrar que o jogador perdeu o jogo func register_lose(reason: String): if alreadyLost: return - emit_signal("lose") + Minigames.register_lose(self) alreadyLost = true get_node("Gamuto").loseAnim(reason) diff --git a/microjogos/2023S1/mail_cleaner/cenas/scripts/main.gd b/microjogos/2023S1/mail_cleaner/cenas/scripts/main.gd index 69416a8d7..677824ba2 100644 --- a/microjogos/2023S1/mail_cleaner/cenas/scripts/main.gd +++ b/microjogos/2023S1/mail_cleaner/cenas/scripts/main.gd @@ -1,12 +1,8 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + #--------------------------------------------------------------------------------------------------- # VARIÁVEIS LOCAIS @@ -55,7 +51,7 @@ func _process(delta): mail_list.pop_at(0) if len(mail_list) == 0 and not lost: - register_win() + Minigames.register_win(self) # -------------------------------------------------------------------------------------------------- # FUNÇÕES LOCAIS @@ -89,15 +85,10 @@ func mail_fall(delta: float): # CONDIÇÕES DE VITÓRIA # -------------------------------------------------------------------------------------------------- -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - # Chame esta função para registrar que o jogador perdeu o jogo func register_lose(): $Phone/BlueScreen.visible = true $Music.playing = false $Scratch.playing = true GlobalCamera.add_trauma(0.75) - emit_signal("lose") + Minigames.register_lose(self) diff --git a/microjogos/2023S1/projeto-RafaelCarro/cenas/scripts/main.gd b/microjogos/2023S1/projeto-RafaelCarro/cenas/scripts/main.gd index 25f576fa3..2751eb920 100644 --- a/microjogos/2023S1/projeto-RafaelCarro/cenas/scripts/main.gd +++ b/microjogos/2023S1/projeto-RafaelCarro/cenas/scripts/main.gd @@ -1,17 +1,13 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - signal StartInput(Input) # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + const MIN_TIME = 2.0 const MAX_TIME = 5.0 @@ -62,7 +58,7 @@ func my_method(): func aumentar_acertos(): Acertos += 1 if Acertos >= 5: - register_win() + Minigames.register_win(self) func hit_sounds(): if Acertos == 0: @@ -76,23 +72,3 @@ func hit_sounds(): elif Acertos == 4: $Hit5.play() - - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2023S1/projeto-brabesf/cenas/scripts/main.gd b/microjogos/2023S1/projeto-brabesf/cenas/scripts/main.gd index ab1fbcc55..fe80308c9 100644 --- a/microjogos/2023S1/projeto-brabesf/cenas/scripts/main.gd +++ b/microjogos/2023S1/projeto-brabesf/cenas/scripts/main.gd @@ -1,16 +1,11 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + const WIDTH_PANNELS = 4 const HEIGHT_PANNELS = 3 @@ -144,7 +139,7 @@ func pode_mover(movimento): # Chame esta função para registrar que o jogador venceu o jogo func register_win(): mostrar_frutas() - emit_signal("win") + Minigames.register_win(self) func mostrar_frutas(): var im11 = get_node("Card11/fruit2D") @@ -167,7 +162,7 @@ func mostrar_frutas(): # Chame esta função para registrar que o jogador perdeu o jogo func register_lose(): mostrar_frutas() - emit_signal("lose") + Minigames.register_lose(self) func draw_gamuto(): var gamuto = get_node("Player") diff --git a/microjogos/2023S1/projeto-enzo-bertoloti/cenas/scripts/CharacterBody2D.gd b/microjogos/2023S1/projeto-enzo-bertoloti/cenas/scripts/CharacterBody2D.gd index 34b45938e..08cf1a98d 100644 --- a/microjogos/2023S1/projeto-enzo-bertoloti/cenas/scripts/CharacterBody2D.gd +++ b/microjogos/2023S1/projeto-enzo-bertoloti/cenas/scripts/CharacterBody2D.gd @@ -37,7 +37,7 @@ func _physics_process(delta): func _on_win_body_entered(body): var player = $"../Player" if body == player: - base.register_win() + Minigames.register_win(self) print("Voce ganhou!") jogo_acabou = true som_morte.play() @@ -45,7 +45,7 @@ func _on_win_body_entered(body): func _on_espinhos_body_entered(body): var player = $"../Player" if body == player: - base.emit_signal("lose") + Minigames.register_lose(self) print("Voce perdeu!") jogo_acabou = true som_morte.play() diff --git a/microjogos/2023S1/projeto-enzo-bertoloti/cenas/scripts/main.gd b/microjogos/2023S1/projeto-enzo-bertoloti/cenas/scripts/main.gd index d212f80b2..573b45562 100644 --- a/microjogos/2023S1/projeto-enzo-bertoloti/cenas/scripts/main.gd +++ b/microjogos/2023S1/projeto-enzo-bertoloti/cenas/scripts/main.gd @@ -1,15 +1,11 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + @onready var musica = get_node("AudioStreamPlayer") # -------------------------------------------------------------------------------------------------- @@ -49,23 +45,3 @@ func instanciar_objeto(): # Um método genérico. Crie quantos métodos você precisar! func my_method(): pass - - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2023S1/projeto-esteche/cenas/areadepouso.gd b/microjogos/2023S1/projeto-esteche/cenas/areadepouso.gd index 6f009b0b8..eaa97d72a 100644 --- a/microjogos/2023S1/projeto-esteche/cenas/areadepouso.gd +++ b/microjogos/2023S1/projeto-esteche/cenas/areadepouso.gd @@ -6,7 +6,7 @@ func _ready(): body_entered.connect(win) func win(body): - get_parent().register_win() + Minigames.register_win(self) body.done = true $VictoryFanfare.play() diff --git a/microjogos/2023S1/projeto-esteche/cenas/scripts/main.gd b/microjogos/2023S1/projeto-esteche/cenas/scripts/main.gd index 14675892b..a596d83b8 100644 --- a/microjogos/2023S1/projeto-esteche/cenas/scripts/main.gd +++ b/microjogos/2023S1/projeto-esteche/cenas/scripts/main.gd @@ -1,15 +1,11 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + const MIN_ASTEROID_Y = 50 const MAX_ASTEROID_Y = 900 @@ -50,24 +46,3 @@ func _process(delta): # Um método genérico. Crie quantos métodos você precisar! func my_method(): pass - - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - print("eba") - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2023S1/projeto-gabriel-morais/cenas/scripts/main.gd b/microjogos/2023S1/projeto-gabriel-morais/cenas/scripts/main.gd index 9a3b0a622..c2a1de231 100644 --- a/microjogos/2023S1/projeto-gabriel-morais/cenas/scripts/main.gd +++ b/microjogos/2023S1/projeto-gabriel-morais/cenas/scripts/main.gd @@ -1,17 +1,13 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - var num_mac = 0 # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + # -------------------------------------------------------------------------------------------------- @@ -45,27 +41,6 @@ func _process(delta): func my_method(): pass - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") - - func ganhou(): if num_mac >= 2: - register_win() + Minigames.register_win(self) diff --git a/microjogos/2023S1/projeto-guglielmo-223300/cenas/scripts/Teclado.gd b/microjogos/2023S1/projeto-guglielmo-223300/cenas/scripts/Teclado.gd index 91d72f49c..a4a9e97c4 100644 --- a/microjogos/2023S1/projeto-guglielmo-223300/cenas/scripts/Teclado.gd +++ b/microjogos/2023S1/projeto-guglielmo-223300/cenas/scripts/Teclado.gd @@ -72,7 +72,7 @@ func _mudar(): i = rnd else: if not missed: - get_parent().register_win() + Minigames.register_win(self) win_sound.play() else: lose_sound.play() diff --git a/microjogos/2023S1/projeto-guglielmo-223300/cenas/scripts/main.gd b/microjogos/2023S1/projeto-guglielmo-223300/cenas/scripts/main.gd index d7c5049d7..ce6ec5644 100644 --- a/microjogos/2023S1/projeto-guglielmo-223300/cenas/scripts/main.gd +++ b/microjogos/2023S1/projeto-guglielmo-223300/cenas/scripts/main.gd @@ -19,13 +19,3 @@ const HEIGHT = 1080 # Esta função é chamada assim que esta cena é instanciada, ou seja, assim que seu minigame inicia func _ready(): pass - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2023S1/projeto-jose-victor/cenas/scripts/main.gd b/microjogos/2023S1/projeto-jose-victor/cenas/scripts/main.gd index b13516b27..ed28a4bea 100644 --- a/microjogos/2023S1/projeto-jose-victor/cenas/scripts/main.gd +++ b/microjogos/2023S1/projeto-jose-victor/cenas/scripts/main.gd @@ -1,10 +1,7 @@ extends Node2D -signal win -signal lose - -const WIDTH = 1920 -const HEIGHT = 1080 + + const MIN_X = 500 const MAX_X = 1700 @@ -33,18 +30,10 @@ func _process(delta): func ganhar_ponto(body): pontuacao += 1 if(pontuacao >= 3): - register_win() + Minigames.register_win(self) $win.play() $player.acabou = true else: $mordida.play() -func register_win(): - emit_signal("win") - -func register_lose(): - emit_signal("lose") - - - diff --git a/microjogos/2023S1/projeto-matheuspavan/cenas/final_magia2.gd b/microjogos/2023S1/projeto-matheuspavan/cenas/final_magia2.gd index 70b4c3c11..80b3799d7 100644 --- a/microjogos/2023S1/projeto-matheuspavan/cenas/final_magia2.gd +++ b/microjogos/2023S1/projeto-matheuspavan/cenas/final_magia2.gd @@ -13,6 +13,6 @@ func _process(delta): func _on_area_2d_body_entered(body): print("colidiu") - get_parent().get_parent().register_win() + Minigames.register_win(self) pass # Replace with function body. diff --git a/microjogos/2023S1/projeto-matheuspavan/cenas/main.gd b/microjogos/2023S1/projeto-matheuspavan/cenas/main.gd index c8475e53b..40126b011 100644 --- a/microjogos/2023S1/projeto-matheuspavan/cenas/main.gd +++ b/microjogos/2023S1/projeto-matheuspavan/cenas/main.gd @@ -1,15 +1,11 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + # -------------------------------------------------------------------------------------------------- @@ -44,22 +40,3 @@ func _process(delta): func my_method(): pass - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2023S1/projeto-matheuspavan/cenas/scripts/main.gd b/microjogos/2023S1/projeto-matheuspavan/cenas/scripts/main.gd deleted file mode 100644 index c8475e53b..000000000 --- a/microjogos/2023S1/projeto-matheuspavan/cenas/scripts/main.gd +++ /dev/null @@ -1,65 +0,0 @@ -extends Node2D - -# Declaração dos sinais win e lose -signal win -signal lose - -# Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma -# tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para -# atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução -# 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 - - -# -------------------------------------------------------------------------------------------------- -# FUNÇÕES PADRÃO -# -------------------------------------------------------------------------------------------------- - -# Esta função é chamada assim que esta cena é instanciada, ou seja, assim que seu minigame inicia -func _ready(): - pass - - -# Esta função é chamada uma vez por frame e é otimizada para cálculos relacionados a física, como -# a movimentação de um personagem. O parâmetro delta indica a quantidade de tempo que passou desde -# a última chamada desta função. O comando pass não faz nada -func _physics_process(delta): - pass - - -# Esta função é chamada uma vez por frame e é otimizada para cálculos relacionados a renderização, -# como a movimentação de um personagem. O parâmetro delta indica a quantidade de tempo que passou -# desde a última chamada desta função. O comando pass não faz nada -func _process(delta): - pass - - -# -------------------------------------------------------------------------------------------------- -# SUAS FUNÇÕES -# -------------------------------------------------------------------------------------------------- - - -# Um método genérico. Crie quantos métodos você precisar! -func my_method(): - pass - - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2023S1/projeto-pluvinage/cenas/CharacterBody2D.gd b/microjogos/2023S1/projeto-pluvinage/cenas/CharacterBody2D.gd index 379226bd7..dc050edb2 100644 --- a/microjogos/2023S1/projeto-pluvinage/cenas/CharacterBody2D.gd +++ b/microjogos/2023S1/projeto-pluvinage/cenas/CharacterBody2D.gd @@ -31,14 +31,14 @@ func _physics_process(delta): func _on_goal_body_entered(body): get_parent().get_node("win_sound").play() body.queue_free() - var win = $"../" - win.register_win() + + Minigames.register_win(self) func _on_go_body_entered(body): get_parent().get_node("lose_sound").play() body.queue_free() - var win = $"../" - win.register_lose() + + Minigames.register_lose(self) func _on_powerup_body_entered(body): @@ -55,23 +55,21 @@ func _on_powerup_body_entered(body): func _on_bat_body_entered(body): get_parent().get_node("lose_sound").play() body.queue_free() - var win = $"../" - win.register_lose() + + Minigames.register_lose(self) func _on_bat2_body_entered(body): get_parent().get_node("lose_sound").play() body.queue_free() - var win = $"../" - win.register_lose() + + Minigames.register_lose(self) func _on_bat3_body_entered(body): get_parent().get_node("lose_sound").play() body.queue_free() - var win = $"../" - win.register_lose() + Minigames.register_lose(self) func _on_bat4_body_entered(body): get_parent().get_node("lose_sound").play() body.queue_free() - var win = $"../" - win.register_lose() + Minigames.register_lose(self) diff --git a/microjogos/2023S1/projeto-pluvinage/cenas/scripts/main.gd b/microjogos/2023S1/projeto-pluvinage/cenas/scripts/main.gd index f1a4552d0..994d41130 100644 --- a/microjogos/2023S1/projeto-pluvinage/cenas/scripts/main.gd +++ b/microjogos/2023S1/projeto-pluvinage/cenas/scripts/main.gd @@ -1,15 +1,11 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + var rng = RandomNumberGenerator.new() @@ -52,23 +48,3 @@ func _process(delta): # Um método genérico. Crie quantos métodos você precisar! func my_method(): pass - - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2023S1/projeto-pochete/cenas/scripts/main.gd b/microjogos/2023S1/projeto-pochete/cenas/scripts/main.gd index a2259e2ec..c28d53a7d 100644 --- a/microjogos/2023S1/projeto-pochete/cenas/scripts/main.gd +++ b/microjogos/2023S1/projeto-pochete/cenas/scripts/main.gd @@ -1,15 +1,11 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + var chosen_apples = [] var won = false @@ -77,25 +73,6 @@ func choose_apples(): apple.show() chosen_apples.append(apple) -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") - func _on_head_area_entered(area): if area in chosen_apples + [final_apple]: @@ -112,7 +89,7 @@ func _on_head_area_entered(area): win = true break if win: - register_win() + Minigames.register_win(self) won = true won_i = len(head.tail_nodes) #head.tail_nodes[-1].position = head.position diff --git a/microjogos/2023S1/projeto-thedeas/cenas/main.gd b/microjogos/2023S1/projeto-thedeas/cenas/main.gd index 55066945e..56e5a45b1 100644 --- a/microjogos/2023S1/projeto-thedeas/cenas/main.gd +++ b/microjogos/2023S1/projeto-thedeas/cenas/main.gd @@ -2,16 +2,13 @@ extends Node2D var death_god var Timer6sec -#Declaração dos sinais win e lose -signal win -signal lose # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + # -------------------------------------------------------------------------------------------------- @@ -49,26 +46,3 @@ func _process(delta): # Um método genérico. Crie quantos métodos você precisar! - - - - - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2023S1/projeto-thedeas/cenas/scripts/handMovment.gd b/microjogos/2023S1/projeto-thedeas/cenas/scripts/handMovment.gd index 2c07419c4..ff6c2e134 100644 --- a/microjogos/2023S1/projeto-thedeas/cenas/scripts/handMovment.gd +++ b/microjogos/2023S1/projeto-thedeas/cenas/scripts/handMovment.gd @@ -64,7 +64,7 @@ func _on_area_2d_area_entered(area): deathCounter += 1 if deathCounter == 5: - get_parent().register_win() + Minigames.register_win(self) area.queue_free() diff --git a/microjogos/2023S1/projeto-tiagoperrupato/cenas/scripts/Jogador.gd b/microjogos/2023S1/projeto-tiagoperrupato/cenas/scripts/Jogador.gd index 54fd7484e..843cfc982 100644 --- a/microjogos/2023S1/projeto-tiagoperrupato/cenas/scripts/Jogador.gd +++ b/microjogos/2023S1/projeto-tiagoperrupato/cenas/scripts/Jogador.gd @@ -26,4 +26,4 @@ func _physics_process(delta): if collision.get_collider().is_in_group("Veiculos"): explode() velocity.y = 0 - $"../".register_lose() + Minigames.register_lose(self) diff --git a/microjogos/2023S1/projeto-tiagoperrupato/cenas/scripts/Veiculos.gd b/microjogos/2023S1/projeto-tiagoperrupato/cenas/scripts/Veiculos.gd index adb3d5be8..0602311b2 100644 --- a/microjogos/2023S1/projeto-tiagoperrupato/cenas/scripts/Veiculos.gd +++ b/microjogos/2023S1/projeto-tiagoperrupato/cenas/scripts/Veiculos.gd @@ -12,4 +12,4 @@ func _physics_process(delta): if collider.has_method("explode"): # se colidir com jogador collider.explode() collider.velocity.y = 0 - $"../".register_lose() + Minigames.register_lose(self) diff --git a/microjogos/2023S1/projeto-tiagoperrupato/cenas/scripts/main.gd b/microjogos/2023S1/projeto-tiagoperrupato/cenas/scripts/main.gd index 32d2a00b3..10f879f5f 100644 --- a/microjogos/2023S1/projeto-tiagoperrupato/cenas/scripts/main.gd +++ b/microjogos/2023S1/projeto-tiagoperrupato/cenas/scripts/main.gd @@ -1,15 +1,11 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + # -------------------------------------------------------------------------------------------------- @@ -18,8 +14,7 @@ const HEIGHT = 1080 # Esta função é chamada assim que esta cena é instanciada, ou seja, assim que seu minigame inicia func _ready(): - - call_deferred("register_win") + Minigames.register_win(self) # Esta função é chamada uma vez por frame e é otimizada para cálculos relacionados a física, como # a movimentação de um personagem. O parâmetro delta indica a quantidade de tempo que passou desde @@ -33,22 +28,3 @@ func _physics_process(delta): # desde a última chamada desta função. O comando pass não faz nada func _process(delta): pass - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2023S1/projeto-viniwaki/cenas/main.gd b/microjogos/2023S1/projeto-viniwaki/cenas/main.gd index 28a906ed2..0ca01547b 100644 --- a/microjogos/2023S1/projeto-viniwaki/cenas/main.gd +++ b/microjogos/2023S1/projeto-viniwaki/cenas/main.gd @@ -8,16 +8,12 @@ var slice_queues = { 4: [], } -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + # -------------------------------------------------------------------------------------------------- @@ -26,7 +22,7 @@ const HEIGHT = 1080 # Esta função é chamada assim que esta cena é instanciada, ou seja, assim que seu minigame inicia func _ready(): - register_win() + Minigames.register_win(self) @@ -76,7 +72,7 @@ func successful_cut(dir: int): func remove_from_slice_queue(d, fruit): slice_queues[d].erase(fruit) $audio_lose.play() - register_lose() + Minigames.register_lose(self) func throw_fruit(): var new_fruit = fruit_scene.instantiate() @@ -102,21 +98,3 @@ func _on_timer_timeout(): if randf() > 0.5: throw_fruit() -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2023S1/projeto-viniwaki/cenas/scripts/main.gd b/microjogos/2023S1/projeto-viniwaki/cenas/scripts/main.gd index c8475e53b..e21379d4d 100644 --- a/microjogos/2023S1/projeto-viniwaki/cenas/scripts/main.gd +++ b/microjogos/2023S1/projeto-viniwaki/cenas/scripts/main.gd @@ -1,15 +1,11 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + # -------------------------------------------------------------------------------------------------- @@ -43,23 +39,3 @@ func _process(delta): # Um método genérico. Crie quantos métodos você precisar! func my_method(): pass - - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2023S1/projeto-yan-oliveira/cenas/scripts/Mosca.gd b/microjogos/2023S1/projeto-yan-oliveira/cenas/scripts/Mosca.gd index 2095b96b7..ec440103a 100644 --- a/microjogos/2023S1/projeto-yan-oliveira/cenas/scripts/Mosca.gd +++ b/microjogos/2023S1/projeto-yan-oliveira/cenas/scripts/Mosca.gd @@ -26,7 +26,7 @@ func tentar_deletar(area): queue_free() get_parent().mosca_morta += 1 if get_parent().mosca_morta == 3: - get_parent().register_win() + Minigames.register_win(self) # Called every frame. 'delta' is the elapsed time since the previous frame. diff --git a/microjogos/2023S1/projeto-yan-oliveira/cenas/scripts/main.gd b/microjogos/2023S1/projeto-yan-oliveira/cenas/scripts/main.gd index 2126ec1e2..b96b34f56 100644 --- a/microjogos/2023S1/projeto-yan-oliveira/cenas/scripts/main.gd +++ b/microjogos/2023S1/projeto-yan-oliveira/cenas/scripts/main.gd @@ -1,16 +1,13 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose var mosca_morta = 0 # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + # -------------------------------------------------------------------------------------------------- @@ -44,23 +41,3 @@ func _process(delta): # Um método genérico. Crie quantos métodos você precisar! func my_method(): pass - - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2023S1/projetoAnaBeatriz/cenas/main.gd b/microjogos/2023S1/projetoAnaBeatriz/cenas/main.gd index b03acc2cf..07a73ba24 100644 --- a/microjogos/2023S1/projetoAnaBeatriz/cenas/main.gd +++ b/microjogos/2023S1/projetoAnaBeatriz/cenas/main.gd @@ -1,15 +1,11 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + const MIN_X = 600.0 const MAX_X = 1320.0 @@ -56,24 +52,5 @@ func delete_enemy(): total_enemies -= 1 if total_enemies == 0 and not morreu: - register_win() - - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - + Minigames.register_win(self) -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2023S1/projetoAnaBeatriz/cenas/scripts/main.gd b/microjogos/2023S1/projetoAnaBeatriz/cenas/scripts/main.gd deleted file mode 100644 index c8475e53b..000000000 --- a/microjogos/2023S1/projetoAnaBeatriz/cenas/scripts/main.gd +++ /dev/null @@ -1,65 +0,0 @@ -extends Node2D - -# Declaração dos sinais win e lose -signal win -signal lose - -# Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma -# tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para -# atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução -# 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 - - -# -------------------------------------------------------------------------------------------------- -# FUNÇÕES PADRÃO -# -------------------------------------------------------------------------------------------------- - -# Esta função é chamada assim que esta cena é instanciada, ou seja, assim que seu minigame inicia -func _ready(): - pass - - -# Esta função é chamada uma vez por frame e é otimizada para cálculos relacionados a física, como -# a movimentação de um personagem. O parâmetro delta indica a quantidade de tempo que passou desde -# a última chamada desta função. O comando pass não faz nada -func _physics_process(delta): - pass - - -# Esta função é chamada uma vez por frame e é otimizada para cálculos relacionados a renderização, -# como a movimentação de um personagem. O parâmetro delta indica a quantidade de tempo que passou -# desde a última chamada desta função. O comando pass não faz nada -func _process(delta): - pass - - -# -------------------------------------------------------------------------------------------------- -# SUAS FUNÇÕES -# -------------------------------------------------------------------------------------------------- - - -# Um método genérico. Crie quantos métodos você precisar! -func my_method(): - pass - - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2023S1/projeto_alexia/cenas/scripts/main.gd b/microjogos/2023S1/projeto_alexia/cenas/scripts/main.gd index 2cd7e691c..63dfbe72f 100644 --- a/microjogos/2023S1/projeto_alexia/cenas/scripts/main.gd +++ b/microjogos/2023S1/projeto_alexia/cenas/scripts/main.gd @@ -1,12 +1,8 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma -const WIDTH = 1920 -const HEIGHT = 1080 + + const TOTAL_LIVROS = 6 @@ -53,7 +49,7 @@ func _physics_process(delta): var aux if livros == base: win_sound.play() - register_win() + Minigames.register_win(self) venceu = true if select == 0: @@ -122,22 +118,3 @@ func _process(delta): # Um método genérico. Crie quantos métodos você precisar! - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2023S1/projeto_leonardo_valente/cenas/Creeper.gd b/microjogos/2023S1/projeto_leonardo_valente/cenas/Creeper.gd index 3f0905190..a5d3edbaf 100644 --- a/microjogos/2023S1/projeto_leonardo_valente/cenas/Creeper.gd +++ b/microjogos/2023S1/projeto_leonardo_valente/cenas/Creeper.gd @@ -1,9 +1,11 @@ extends CharacterBody2D const SPEED = 150.0 + const WIDTH = 1920 const HEIGHT = 1080 + var target = Vector2(0,0) var exploded = false diff --git a/microjogos/2023S1/projeto_leonardo_valente/cenas/CreeperSpawner.gd b/microjogos/2023S1/projeto_leonardo_valente/cenas/CreeperSpawner.gd index 351c8744f..496cf3138 100644 --- a/microjogos/2023S1/projeto_leonardo_valente/cenas/CreeperSpawner.gd +++ b/microjogos/2023S1/projeto_leonardo_valente/cenas/CreeperSpawner.gd @@ -22,10 +22,10 @@ func _timeout_explosao(): i.explode() if(perdeu): $"../Player".morrer() - $"..".register_lose() + Minigames.register_lose(self) #print("morreu") else: - $"..".register_win() + Minigames.register_win(self) #print("viveu") diff --git a/microjogos/2023S1/projeto_leonardo_valente/cenas/main.gd b/microjogos/2023S1/projeto_leonardo_valente/cenas/main.gd index 3ec4cfee5..2aeea6ebe 100644 --- a/microjogos/2023S1/projeto_leonardo_valente/cenas/main.gd +++ b/microjogos/2023S1/projeto_leonardo_valente/cenas/main.gd @@ -1,15 +1,11 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + # -------------------------------------------------------------------------------------------------- @@ -42,30 +38,5 @@ func _process(delta): # Um método genérico. Crie quantos métodos você precisar! - - - - - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") - - func _matar_player(): pass # Replace with function body. diff --git a/microjogos/2023S1/projeto_leonardo_valente/cenas/scripts/main.gd b/microjogos/2023S1/projeto_leonardo_valente/cenas/scripts/main.gd deleted file mode 100644 index c8475e53b..000000000 --- a/microjogos/2023S1/projeto_leonardo_valente/cenas/scripts/main.gd +++ /dev/null @@ -1,65 +0,0 @@ -extends Node2D - -# Declaração dos sinais win e lose -signal win -signal lose - -# Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma -# tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para -# atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução -# 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 - - -# -------------------------------------------------------------------------------------------------- -# FUNÇÕES PADRÃO -# -------------------------------------------------------------------------------------------------- - -# Esta função é chamada assim que esta cena é instanciada, ou seja, assim que seu minigame inicia -func _ready(): - pass - - -# Esta função é chamada uma vez por frame e é otimizada para cálculos relacionados a física, como -# a movimentação de um personagem. O parâmetro delta indica a quantidade de tempo que passou desde -# a última chamada desta função. O comando pass não faz nada -func _physics_process(delta): - pass - - -# Esta função é chamada uma vez por frame e é otimizada para cálculos relacionados a renderização, -# como a movimentação de um personagem. O parâmetro delta indica a quantidade de tempo que passou -# desde a última chamada desta função. O comando pass não faz nada -func _process(delta): - pass - - -# -------------------------------------------------------------------------------------------------- -# SUAS FUNÇÕES -# -------------------------------------------------------------------------------------------------- - - -# Um método genérico. Crie quantos métodos você precisar! -func my_method(): - pass - - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2023S1/projeto_vinicius_carvalho/cenas/scripts/Player.gd b/microjogos/2023S1/projeto_vinicius_carvalho/cenas/scripts/Player.gd index d77958d88..cf20858b3 100644 --- a/microjogos/2023S1/projeto_vinicius_carvalho/cenas/scripts/Player.gd +++ b/microjogos/2023S1/projeto_vinicius_carvalho/cenas/scripts/Player.gd @@ -39,7 +39,7 @@ func _on_hitbox_body_entered(body): death_s = $SomDeath death_s.play() timer = $Timer - get_parent().register_lose() + Minigames.register_lose(self) timer.start(1) diff --git a/microjogos/2023S1/projeto_vinicius_carvalho/cenas/scripts/main.gd b/microjogos/2023S1/projeto_vinicius_carvalho/cenas/scripts/main.gd deleted file mode 100644 index fef0cd81e..000000000 --- a/microjogos/2023S1/projeto_vinicius_carvalho/cenas/scripts/main.gd +++ /dev/null @@ -1,71 +0,0 @@ -extends Node2D - -# Declaração dos sinais win e lose -signal win -signal lose - -# Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma -# tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para -# atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução -# 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 - - -# -------------------------------------------------------------------------------------------------- -# FUNÇÕES PADRÃO -# -------------------------------------------------------------------------------------------------- - -# Esta função é chamada assim que esta cena é instanciada, ou seja, assim que seu minigame inicia -func _ready(): - # Verifica a linguagem do jogo e mostra texto nesta linguagem. Deve dar uma ideia do que deve - # ser feito para vencer o jogo. A fonte usada não suporta caracteres latinos como ~ ou ´ - match Global.language: - Global.LANGUAGE.EN: - NotificationCenter.notify("DO SOMETHING!") - Global.LANGUAGE.PT: - NotificationCenter.notify("FACA ALGO!") - - -# Esta função é chamada uma vez por frame e é otimizada para cálculos relacionados a física, como -# a movimentação de um personagem. O parâmetro delta indica a quantidade de tempo que passou desde -# a última chamada desta função. O comando pass não faz nada -func _physics_process(delta): - pass - - -# Esta função é chamada uma vez por frame e é otimizada para cálculos relacionados a renderização, -# como a movimentação de um personagem. O parâmetro delta indica a quantidade de tempo que passou -# desde a última chamada desta função. O comando pass não faz nada -func _process(delta): - pass - - -# -------------------------------------------------------------------------------------------------- -# SUAS FUNÇÕES -# -------------------------------------------------------------------------------------------------- - - -# Um método genérico. Crie quantos métodos você precisar! -func my_method(): - pass - - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2023S1/projeto_vinicius_carvalho/cenas/scripts/mapa.gd b/microjogos/2023S1/projeto_vinicius_carvalho/cenas/scripts/mapa.gd index f3a25749f..8e0fc6875 100644 --- a/microjogos/2023S1/projeto_vinicius_carvalho/cenas/scripts/mapa.gd +++ b/microjogos/2023S1/projeto_vinicius_carvalho/cenas/scripts/mapa.gd @@ -1,10 +1,7 @@ extends Node2D -const WIDTH = 1920 -const HEIGHT = 1080 -signal win -signal lose + var timer var timer_win @@ -20,7 +17,7 @@ func _ready(): timer = $Timer timer.start(0.5) - register_win() + Minigames.register_win(self) @@ -43,10 +40,3 @@ func _on_timer_timeout(): timer.start(2) instanciar_obj() - -func register_win(): - emit_signal("win") - - -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2024S1/Projeto-Yago/cenas/scripts/main.gd b/microjogos/2024S1/Projeto-Yago/cenas/scripts/main.gd index bcc2250f8..02de00794 100644 --- a/microjogos/2024S1/Projeto-Yago/cenas/scripts/main.gd +++ b/microjogos/2024S1/Projeto-Yago/cenas/scripts/main.gd @@ -2,15 +2,12 @@ extends Node2D @onready var player = $Player -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + # -------------------------------------------------------------------------------------------------- @@ -32,7 +29,7 @@ func register_win(): # NotificationCenter.notify("WIN!") # Global.LANGUAGE.PT: # NotificationCenter.notify("COMPRA COMPLETA!") - emit_signal("win") + Minigames.register_win(self) remove_child($Player) # Chame esta função para registrar que o jogador perdeu o jogo @@ -42,5 +39,5 @@ func register_lose(): # NotificationCenter.notify("LOSE!") # Global.LANGUAGE.PT: # NotificationCenter.notify("PERDEU PLAYBOY!") - emit_signal("lose") + Minigames.register_lose(self) remove_child($Player) diff --git a/microjogos/2024S1/ShootGamuto/cenas/scripts/Canhao2.gd b/microjogos/2024S1/ShootGamuto/cenas/scripts/Canhao2.gd index 133b9723a..0e6201a52 100644 --- a/microjogos/2024S1/ShootGamuto/cenas/scripts/Canhao2.gd +++ b/microjogos/2024S1/ShootGamuto/cenas/scripts/Canhao2.gd @@ -77,13 +77,4 @@ func _attack(): #$"../RichTextLabel".text = "you won" acertou_bom = true set_process_input(false) - register_win() - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - main.register_win() - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - main.register_lose() + Minigames.register_win(self) diff --git a/microjogos/2024S1/ShootGamuto/cenas/scripts/main.gd b/microjogos/2024S1/ShootGamuto/cenas/scripts/main.gd deleted file mode 100644 index 013125a14..000000000 --- a/microjogos/2024S1/ShootGamuto/cenas/scripts/main.gd +++ /dev/null @@ -1,67 +0,0 @@ -extends Node2D - -# Declaração dos sinais win e lose - -signal win -signal lose - -# Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma -# tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para -# atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução -# 16:9 -const WIDTH = 960 -const HEIGHT = 540 - - -# -------------------------------------------------------------------------------------------------- -# FUNÇÕES PADRÃO -# -------------------------------------------------------------------------------------------------- - -# Esta função é chamada assim que esta cena é instanciada, ou seja, assim que seu minigame inicia -func _ready(): - pass - - -# Esta função é chamada uma vez por frame e é otimizada para cálculos relacionados a física, como -# a movimentação de um personagem. O parâmetro delta indica a quantidade de tempo que passou desde -# a última chamada desta função. O comando pass não faz nada -func _physics_process(delta): - pass - - -# Esta função é chamada uma vez por frame e é otimizada para cálculos relacionados a renderização, -# como a movimentação de um personagem. O parâmetro delta indica a quantidade de tempo que passou -# desde a última chamada desta função. O comando pass não faz nada -func _process(delta): - pass - - -# -------------------------------------------------------------------------------------------------- -# SUAS FUNÇÕES -# -------------------------------------------------------------------------------------------------- - - -# Um método genérico. Crie quantos métodos você precisar! -func my_method(): - pass - - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") - diff --git a/microjogos/2024S1/ShootGamuto/microgame.tres b/microjogos/2024S1/ShootGamuto/microgame.tres index dd46f2de1..d6cfdec3d 100644 --- a/microjogos/2024S1/ShootGamuto/microgame.tres +++ b/microjogos/2024S1/ShootGamuto/microgame.tres @@ -1,7 +1,7 @@ -[gd_resource type="Resource" script_class="MicrogameAsset" load_steps=4 format=3] +[gd_resource type="Resource" script_class="MicrogameAsset" load_steps=4 format=3 uid="uid://b2kihfd8hlwi7"] -[ext_resource type="Script" path="res://principal/microgame_asset.gd" id="1_q3nob"] -[ext_resource type="Texture2D" path="res://microjogos/2024S1/ShootGamuto/capa.png" id="1_v55o0"] +[ext_resource type="Script" uid="uid://bus1nknp6xsc0" path="res://principal/microgame_asset.gd" id="1_q3nob"] +[ext_resource type="Texture2D" uid="uid://boes7y0uflfl1" path="res://microjogos/2024S1/ShootGamuto/capa.png" id="1_v55o0"] [ext_resource type="PackedScene" path="res://microjogos/2024S1/ShootGamuto/cenas/main.tscn" id="2_wwtyr"] [resource] @@ -15,3 +15,4 @@ start_message_pt = &"Ataque as torres!" start_message_en = &"Attack the towers!" main_scene = ExtResource("2_wwtyr") difficulty = 0 +screen_dimensions = Vector2i(960, 540) diff --git a/microjogos/2024S1/gamufit/cenas/scripts/main.gd b/microjogos/2024S1/gamufit/cenas/scripts/main.gd index 838784334..4bb141f64 100644 --- a/microjogos/2024S1/gamufit/cenas/scripts/main.gd +++ b/microjogos/2024S1/gamufit/cenas/scripts/main.gd @@ -1,29 +1,16 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 - -# -------------------------------------------------------------------------------------------------- -# FUNÇÕES PADRÃO -# -------------------------------------------------------------------------------------------------- -# Esta função é chamada assim que esta cena é instanciada, ou seja, assim que seu minigame inicia -func _ready(): - pass # Chame esta função para registrar que o jogador venceu o jogo func register_win(): - emit_signal("win") + Minigames.register_win(self) # Chame esta função para registrar que o jogador perdeu o jogo func register_lose(): - emit_signal("lose") + Minigames.register_lose(self) diff --git a/microjogos/2024S1/jucamm/cenas/aaaaaaaaaaaaaaaaaaaaaaaaaa.gd b/microjogos/2024S1/jucamm/cenas/aaaaaaaaaaaaaaaaaaaaaaaaaa.gd index 8def7f3ee..12f6037bd 100644 --- a/microjogos/2024S1/jucamm/cenas/aaaaaaaaaaaaaaaaaaaaaaaaaa.gd +++ b/microjogos/2024S1/jucamm/cenas/aaaaaaaaaaaaaaaaaaaaaaaaaa.gd @@ -3,7 +3,7 @@ extends RigidBody2D # Called when the node enters the scene tree for the first time. func _ready(): - emit_signal("win"); + Minigames.register_win(self) custom_integrator = true; $AnimatedSprite2D.play("default") pass # Replace with function body. diff --git a/microjogos/2024S1/jucamm/cenas/barra_gelo.gd b/microjogos/2024S1/jucamm/cenas/barra_gelo.gd index 7fa8c5d6a..ffe3c09bf 100644 --- a/microjogos/2024S1/jucamm/cenas/barra_gelo.gd +++ b/microjogos/2024S1/jucamm/cenas/barra_gelo.gd @@ -14,7 +14,7 @@ func _physics_process(delta): var colisao = get_colliding_bodies() for i in colisao: if i.is_in_group ("area"): - main.register_lose() + Minigames.register_lose(self) if len(colisao) > 0: $Bounce.play() diff --git a/microjogos/2024S1/jucamm/cenas/scripts/main.gd b/microjogos/2024S1/jucamm/cenas/scripts/main.gd index 7e955a07d..d909e464e 100644 --- a/microjogos/2024S1/jucamm/cenas/scripts/main.gd +++ b/microjogos/2024S1/jucamm/cenas/scripts/main.gd @@ -1,15 +1,11 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + # -------------------------------------------------------------------------------------------------- @@ -20,7 +16,7 @@ const HEIGHT = 1080 func _ready(): $Music.play() - register_win() + Minigames.register_win(self) # Esta função é chamada uma vez por frame e é otimizada para cálculos relacionados a física, como @@ -45,23 +41,3 @@ func _process(delta): # Um método genérico. Crie quantos métodos você precisar! func my_method(): pass - - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2024S1/lari-sem-cafe/cenas/main.tscn b/microjogos/2024S1/lari-sem-cafe/cenas/main.tscn index 3b27fefdd..962eb6b3e 100644 --- a/microjogos/2024S1/lari-sem-cafe/cenas/main.tscn +++ b/microjogos/2024S1/lari-sem-cafe/cenas/main.tscn @@ -1,7 +1,6 @@ -[gd_scene load_steps=113 format=3 uid="uid://bl4xe8ma8dfpq"] +[gd_scene load_steps=112 format=3 uid="uid://bl4xe8ma8dfpq"] [ext_resource type="Texture2D" uid="uid://ca7t6a13spiin" path="res://microjogos/2024S1/lari-sem-cafe/assets/Seasonal Tilesets/Seasonal Tilesets/2 - Autumn Forest/Terrain (16 x 16).png" id="1_2vy5b"] -[ext_resource type="Script" uid="uid://paavcajuaipg" path="res://microjogos/2024S1/lari-sem-cafe/cenas/scripts/main.gd" id="1_a3vdj"] [ext_resource type="Script" uid="uid://bj7i37itbockt" path="res://microjogos/2024S1/lari-sem-cafe/scripts/Player.gd" id="1_eiv4f"] [ext_resource type="Texture2D" uid="uid://c6se0pq8eeue8" path="res://microjogos/2024S1/lari-sem-cafe/assets/Sprite Pack 3/Sprite Pack 3/2 - Twiggy/Idle (32 x 32).png" id="1_yh7jc"] [ext_resource type="Texture2D" uid="uid://ducnm6t8q8joq" path="res://microjogos/2024S1/lari-sem-cafe/assets/Seasonal Tilesets/Seasonal Tilesets/2 - Autumn Forest/Autumn_entities (16 x 16).png" id="2_mfqs3"] @@ -630,7 +629,6 @@ shadow_color = Color(1, 0, 0, 0) [node name="World" type="Node2D"] texture_filter = 1 position = Vector2(42, 72) -script = ExtResource("1_a3vdj") [node name="TileMap" type="TileMap" parent="."] tile_set = SubResource("TileSet_7uosf") diff --git a/microjogos/2024S1/lari-sem-cafe/cenas/scripts/main.gd b/microjogos/2024S1/lari-sem-cafe/cenas/scripts/main.gd deleted file mode 100644 index 63d28ae17..000000000 --- a/microjogos/2024S1/lari-sem-cafe/cenas/scripts/main.gd +++ /dev/null @@ -1,61 +0,0 @@ -extends Node2D - -# Declaração dos sinais win e lose -signal win -signal lose - -# Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma -# tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para -# atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução -# 16:9 -const WIDTH = 640 -const HEIGHT = 360 -# -------------------------------------------------------------------------------------------------- -# FUNÇÕES PADRÃO -# -------------------------------------------------------------------------------------------------- - -# Esta função é chamada assim que esta cena é instanciada, ou seja, assim que seu minigame inicia -func _ready(): - pass - - -# Esta função é chamada uma vez por frame e é otimizada para cálculos relacionados a física, como -# a movimentação de um personagem. O parâmetro delta indica a quantidade de tempo que passou desde -# a última chamada desta função. O comando pass não faz nada -func _physics_process(delta): - pass - - -# Esta função é chamada uma vez por frame e é otimizada para cálculos relacionados a renderização, -# como a movimentação de um personagem. O parâmetro delta indica a quantidade de tempo que passou -# desde a última chamada desta função. O comando pass não faz nada -func _process(delta): - pass - - -# -------------------------------------------------------------------------------------------------- -# SUAS FUNÇÕES -# -------------------------------------------------------------------------------------------------- - - -# Um método genérico. Crie quantos métodos você precisar! -func my_method(): - pass - - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2024S1/lari-sem-cafe/microgame.tres b/microjogos/2024S1/lari-sem-cafe/microgame.tres index 5e40b2d66..7b1db8804 100644 --- a/microjogos/2024S1/lari-sem-cafe/microgame.tres +++ b/microjogos/2024S1/lari-sem-cafe/microgame.tres @@ -2,7 +2,7 @@ [ext_resource type="Script" uid="uid://bus1nknp6xsc0" path="res://principal/microgame_asset.gd" id="1_4mn5x"] [ext_resource type="Texture2D" uid="uid://c4p0a50nlcnrs" path="res://microjogos/2024S1/lari-sem-cafe/capa.png" id="1_h30xq"] -[ext_resource type="PackedScene" path="res://microjogos/2024S1/lari-sem-cafe/cenas/main.tscn" id="2_h30xq"] +[ext_resource type="PackedScene" uid="uid://bl4xe8ma8dfpq" path="res://microjogos/2024S1/lari-sem-cafe/cenas/main.tscn" id="2_h30xq"] [resource] script = ExtResource("1_4mn5x") @@ -29,3 +29,4 @@ start_message_pt = &"COLETE OS PATOS!" start_message_en = &"\"COLLECT THE DUCKS!" main_scene = ExtResource("2_h30xq") difficulty = 0 +screen_dimensions = Vector2i(640, 360) diff --git a/microjogos/2024S1/lari-sem-cafe/scripts/Cafe.gd b/microjogos/2024S1/lari-sem-cafe/scripts/Cafe.gd index 453e20195..b9943f7b0 100644 --- a/microjogos/2024S1/lari-sem-cafe/scripts/Cafe.gd +++ b/microjogos/2024S1/lari-sem-cafe/scripts/Cafe.gd @@ -17,7 +17,7 @@ func _on_body_shape_entered(body_rid, body, body_shape_index, local_shape_index) anim.play("gone") $"AudioStreamPlayer".play() $"../Label".text = "SUCESSO!" - $"../".register_win() + Minigames.register_win(self) func _on_animated_sprite_2d_animation_finished(): queue_free() diff --git a/microjogos/2024S1/nyan-thulu/cenas/scripts/main.gd b/microjogos/2024S1/nyan-thulu/cenas/scripts/main.gd index 579c18188..d0c5d1211 100644 --- a/microjogos/2024S1/nyan-thulu/cenas/scripts/main.gd +++ b/microjogos/2024S1/nyan-thulu/cenas/scripts/main.gd @@ -2,16 +2,12 @@ extends Node2D @export var cookie_scene: PackedScene -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + var rng = RandomNumberGenerator.new() @@ -26,29 +22,10 @@ var player_is_dead = false # Esta função é chamada assim que esta cena é instanciada, ou seja, assim que seu minigame inicia func _ready(): - register_win() + Minigames.register_win(self) rng.randomize() spawners = [$"Spawner", $"Spawner2", $"Spawner3", $"Spawner4"] -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") - func _on_timer_timeout(): if player_is_dead: @@ -61,5 +38,5 @@ func _on_timer_timeout(): func _on_player_dead(): - register_lose() + Minigames.register_lose(self) player_is_dead = true diff --git a/microjogos/2024S1/projeto-FastFood/cenas/scripts/main.gd b/microjogos/2024S1/projeto-FastFood/cenas/scripts/main.gd index 7653735f1..dbf94dcfb 100644 --- a/microjogos/2024S1/projeto-FastFood/cenas/scripts/main.gd +++ b/microjogos/2024S1/projeto-FastFood/cenas/scripts/main.gd @@ -1,15 +1,11 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + # -------------------------------------------------------------------------------------------------- @@ -63,11 +59,8 @@ func my_method(): # Chame esta função para registrar que o jogador venceu o jogo func register_win(): - emit_signal("win") + Minigames.register_win(self) -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2024S1/projeto-andre/cenas/scripts/main.gd b/microjogos/2024S1/projeto-andre/cenas/scripts/main.gd index c1d75c40b..56a13a0dc 100644 --- a/microjogos/2024S1/projeto-andre/cenas/scripts/main.gd +++ b/microjogos/2024S1/projeto-andre/cenas/scripts/main.gd @@ -1,15 +1,11 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + const Card = preload("res://microjogos/2024S1/projeto-andre/cenas/scripts/card.gd") @@ -160,17 +156,6 @@ func choice_made(make: bool): m.material.set_shader_parameter("shine_color", Color(0.5, 0.5, 0.5, 0.8)) if make == venceu: - register_win() + Minigames.register_win(self) else: - register_lose() - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - print("VENCEU") - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - print("PERDEU") - emit_signal("lose") + Minigames.register_lose(self) diff --git a/microjogos/2024S1/projeto-asteroids/cenas/scripts/main.gd b/microjogos/2024S1/projeto-asteroids/cenas/scripts/main.gd index e48b27abe..fd76af64f 100644 --- a/microjogos/2024S1/projeto-asteroids/cenas/scripts/main.gd +++ b/microjogos/2024S1/projeto-asteroids/cenas/scripts/main.gd @@ -5,16 +5,12 @@ extends Node2D #= preload("res://microjogos/2024S1/projeto-asteroids/cenas/asteroid.tscn") -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + # -------------------------------------------------------------------------------------------------- @@ -64,26 +60,6 @@ func game_start(): pass -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhu m sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") - - func _on_start_timer_timeout(): $AsteroidTimer.start() pass # Replace with function body. @@ -114,7 +90,7 @@ func _on_asteroid_timer_timeout(): func _on_win_timer_timeout(): var a = get_node("Base/Player") if a.is_alive: - register_win() + Minigames.register_win(self) else: - register_lose() + Minigames.register_lose(self) pass # Replace with function body. diff --git a/microjogos/2024S1/projeto-cores/cenas/scripts/main.gd b/microjogos/2024S1/projeto-cores/cenas/scripts/main.gd index affe64b14..31ff12aaf 100644 --- a/microjogos/2024S1/projeto-cores/cenas/scripts/main.gd +++ b/microjogos/2024S1/projeto-cores/cenas/scripts/main.gd @@ -1,11 +1,5 @@ extends Node2D -const WIDTH = 320 -const HEIGHT = 180 - -signal win -signal lose - const COLOR_TOLERANCE = 0.5 var rng = RandomNumberGenerator.new() @@ -88,7 +82,7 @@ func put_color(i): elif used==4: $Cor5/Polygon2D.modulate = Color(c[i][0], c[i][1], c[i][2]) if tentativa==resp: - emit_signal("win") + Minigames.register_win(self) $Sprite2D.modulate = Color((R0+R1)/2, (G0+G1)/2, (B0+B1)/2, 1) $Polygon13.modulate = Color(0,0,0,0) $Polygon14.modulate = Color(0,0,0,0) diff --git a/microjogos/2024S1/projeto-cores/microgame.tres b/microjogos/2024S1/projeto-cores/microgame.tres index e30a0471c..cc79381ac 100644 --- a/microjogos/2024S1/projeto-cores/microgame.tres +++ b/microjogos/2024S1/projeto-cores/microgame.tres @@ -1,7 +1,7 @@ -[gd_resource type="Resource" script_class="MicrogameAsset" load_steps=4 format=3] +[gd_resource type="Resource" script_class="MicrogameAsset" load_steps=4 format=3 uid="uid://de27lnuapuc81"] -[ext_resource type="Texture2D" path="res://microjogos/2024S1/projeto-cores/capa.png" id="1_6kwc0"] -[ext_resource type="Script" path="res://principal/microgame_asset.gd" id="1_jr3v4"] +[ext_resource type="Texture2D" uid="uid://hi8jcq2u4w4y" path="res://microjogos/2024S1/projeto-cores/capa.png" id="1_6kwc0"] +[ext_resource type="Script" uid="uid://bus1nknp6xsc0" path="res://principal/microgame_asset.gd" id="1_jr3v4"] [ext_resource type="PackedScene" path="res://microjogos/2024S1/projeto-cores/cenas/main.tscn" id="2_6kwc0"] [resource] @@ -21,3 +21,4 @@ start_message_pt = &"ORDENE AS CORES!" start_message_en = &"ORDER THE COLORS!" main_scene = ExtResource("2_6kwc0") difficulty = 0 +screen_dimensions = Vector2i(320, 180) diff --git a/microjogos/2024S1/projeto-danielh/cenas/Player.gd b/microjogos/2024S1/projeto-danielh/cenas/Player.gd index b334754a9..18cd123ae 100644 --- a/microjogos/2024S1/projeto-danielh/cenas/Player.gd +++ b/microjogos/2024S1/projeto-danielh/cenas/Player.gd @@ -37,7 +37,7 @@ func _physics_process(_delta): move_and_slide() func _on_area_2d_body_entered(body): - $"..".register_win() + Minigames.register_win(self) diff --git a/microjogos/2024S1/projeto-danielh/cenas/main.gd b/microjogos/2024S1/projeto-danielh/cenas/main.gd index 95563d5de..b0fa47a8c 100644 --- a/microjogos/2024S1/projeto-danielh/cenas/main.gd +++ b/microjogos/2024S1/projeto-danielh/cenas/main.gd @@ -1,15 +1,11 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + const SPAWN_POSITIONS = [ Vector2(0, 0), @@ -50,24 +46,3 @@ func _physics_process(delta): # Um método genérico. Crie quantos métodos você precisar! func my_method(): pass - - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") - diff --git a/microjogos/2024S1/projeto-danielh/cenas/scripts/main.gd b/microjogos/2024S1/projeto-danielh/cenas/scripts/main.gd index fef0cd81e..61ffa8c3e 100644 --- a/microjogos/2024S1/projeto-danielh/cenas/scripts/main.gd +++ b/microjogos/2024S1/projeto-danielh/cenas/scripts/main.gd @@ -1,15 +1,11 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + # -------------------------------------------------------------------------------------------------- @@ -49,23 +45,3 @@ func _process(delta): # Um método genérico. Crie quantos métodos você precisar! func my_method(): pass - - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2024S1/projeto-do-FelipeG/cenas/scripts/main.gd b/microjogos/2024S1/projeto-do-FelipeG/cenas/scripts/main.gd index c2dd8e06f..f7f48060c 100644 --- a/microjogos/2024S1/projeto-do-FelipeG/cenas/scripts/main.gd +++ b/microjogos/2024S1/projeto-do-FelipeG/cenas/scripts/main.gd @@ -1,15 +1,11 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + @export var speed_multiplier: float = 3.0 var sorvetes_capturados: int = 0 @@ -61,13 +57,9 @@ func my_method(): # Chame esta função para registrar que o jogador venceu o jogo func register_win(): - emit_signal("win") + Minigames.register_win(self) NotificationCenter.notify("YOU WIN!") -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") - func _on_sorvete_capturado(): sorvetes_capturados += 1 if(!won): diff --git a/microjogos/2024S1/projeto-eco-g/cenas/scripts/main.gd b/microjogos/2024S1/projeto-eco-g/cenas/scripts/main.gd index 3dccff132..70346cf82 100644 --- a/microjogos/2024S1/projeto-eco-g/cenas/scripts/main.gd +++ b/microjogos/2024S1/projeto-eco-g/cenas/scripts/main.gd @@ -1,15 +1,11 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + # -------------------------------------------------------------------------------------------------- @@ -18,7 +14,7 @@ const HEIGHT = 1080 # Esta função é chamada assim que esta cena é instanciada, ou seja, assim que seu minigame inicia func _ready(): - register_win() + Minigames.register_win(self) # Esta função é chamada uma vez por frame e é otimizada para cálculos relacionados a física, como @@ -44,27 +40,5 @@ func _process(delta): func my_method(): pass - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - #get_tree().paused = true - emit_signal("lose") - - func _on_gamuto_dead(): - register_lose() + Minigames.register_lose(self) diff --git a/microjogos/2024S1/projeto-estrela/cenas/scripts/CharacterBody2D.gd b/microjogos/2024S1/projeto-estrela/cenas/scripts/CharacterBody2D.gd index 248e8e54f..40bd0f828 100644 --- a/microjogos/2024S1/projeto-estrela/cenas/scripts/CharacterBody2D.gd +++ b/microjogos/2024S1/projeto-estrela/cenas/scripts/CharacterBody2D.gd @@ -41,7 +41,7 @@ func coletar(body): $quack.play() c=c+1 if c>=5: - get_parent().register_win() # Volta para o Node principal e chama a funcao register_win enviando o sinal para o GamutoWare + Minigames.register_win(self) return c diff --git a/microjogos/2024S1/projeto-estrela/cenas/scripts/main.gd b/microjogos/2024S1/projeto-estrela/cenas/scripts/main.gd deleted file mode 100644 index c8475e53b..000000000 --- a/microjogos/2024S1/projeto-estrela/cenas/scripts/main.gd +++ /dev/null @@ -1,65 +0,0 @@ -extends Node2D - -# Declaração dos sinais win e lose -signal win -signal lose - -# Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma -# tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para -# atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução -# 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 - - -# -------------------------------------------------------------------------------------------------- -# FUNÇÕES PADRÃO -# -------------------------------------------------------------------------------------------------- - -# Esta função é chamada assim que esta cena é instanciada, ou seja, assim que seu minigame inicia -func _ready(): - pass - - -# Esta função é chamada uma vez por frame e é otimizada para cálculos relacionados a física, como -# a movimentação de um personagem. O parâmetro delta indica a quantidade de tempo que passou desde -# a última chamada desta função. O comando pass não faz nada -func _physics_process(delta): - pass - - -# Esta função é chamada uma vez por frame e é otimizada para cálculos relacionados a renderização, -# como a movimentação de um personagem. O parâmetro delta indica a quantidade de tempo que passou -# desde a última chamada desta função. O comando pass não faz nada -func _process(delta): - pass - - -# -------------------------------------------------------------------------------------------------- -# SUAS FUNÇÕES -# -------------------------------------------------------------------------------------------------- - - -# Um método genérico. Crie quantos métodos você precisar! -func my_method(): - pass - - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2024S1/projeto-fakarasz/cenas/scripts/main.gd b/microjogos/2024S1/projeto-fakarasz/cenas/scripts/main.gd index 82022e8aa..316a7e928 100644 --- a/microjogos/2024S1/projeto-fakarasz/cenas/scripts/main.gd +++ b/microjogos/2024S1/projeto-fakarasz/cenas/scripts/main.gd @@ -1,15 +1,11 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + const AMPLITUDE = 112 const CENTER = 113 @@ -49,33 +45,13 @@ func _process(delta): func my_method(): pass - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") - func _on_Gamutos_area_entered(area): area.queue_free() - register_lose() + Minigames.register_lose(self) func _on_Gol_area_entered(area): area.queue_free() - register_win() + Minigames.register_win(self) diff --git a/microjogos/2024S1/projeto-felipe-silva/cenas/scripts/Main Character.gd b/microjogos/2024S1/projeto-felipe-silva/cenas/scripts/Main Character.gd index 328934079..2501bdeb7 100644 --- a/microjogos/2024S1/projeto-felipe-silva/cenas/scripts/Main Character.gd +++ b/microjogos/2024S1/projeto-felipe-silva/cenas/scripts/Main Character.gd @@ -25,7 +25,7 @@ func _physics_process(_delta): if bike: # if the bike hits you, you die. print("lose") - emit_signal("lose") + Minigames.register_lose(self) get_node("CollisionShape2D").disabled = true get_node("Bike Bell").play() active = false diff --git a/microjogos/2024S1/projeto-felipe-silva/cenas/scripts/local-main.gd b/microjogos/2024S1/projeto-felipe-silva/cenas/scripts/local-main.gd index daf850973..77a5e895f 100644 --- a/microjogos/2024S1/projeto-felipe-silva/cenas/scripts/local-main.gd +++ b/microjogos/2024S1/projeto-felipe-silva/cenas/scripts/local-main.gd @@ -1,15 +1,11 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + const NUM_ANONS = 25 const anon_scene = preload("res://microjogos/2024S1/projeto-felipe-silva/cenas/anon.tscn") @@ -25,11 +21,11 @@ func _ready(): func _on_world_limit_body_entered(body): if body == $"Main Character": - emit_signal("win") + Minigames.register_win(self) body.active = false func _on_porta_area_body_entered(body): if body == $"Main Character": - emit_signal("win") + Minigames.register_win(self) body.active = false diff --git a/microjogos/2024S1/projeto-felipe-silva/cenas/scripts/main.gd b/microjogos/2024S1/projeto-felipe-silva/cenas/scripts/main.gd deleted file mode 100644 index 410ba6bf0..000000000 --- a/microjogos/2024S1/projeto-felipe-silva/cenas/scripts/main.gd +++ /dev/null @@ -1,40 +0,0 @@ -extends Node2D - -# Declaração dos sinais win e lose -signal win -signal lose - -# Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma -# tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para -# atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução -# 16:9 -const WIDTH = 480 -const HEIGHT = 270 - - -# -------------------------------------------------------------------------------------------------- -# FUNÇÕES PADRÃO -# -------------------------------------------------------------------------------------------------- - -# Esta função é chamada assim que esta cena é instanciada, ou seja, assim que seu minigame inicia -func _ready(): - pass - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2024S1/projeto-felipe-silva/microgame.tres b/microjogos/2024S1/projeto-felipe-silva/microgame.tres index cdebb19fc..2bcc9efc6 100644 --- a/microjogos/2024S1/projeto-felipe-silva/microgame.tres +++ b/microjogos/2024S1/projeto-felipe-silva/microgame.tres @@ -1,7 +1,7 @@ -[gd_resource type="Resource" script_class="MicrogameAsset" load_steps=4 format=3] +[gd_resource type="Resource" script_class="MicrogameAsset" load_steps=4 format=3 uid="uid://ccja78ym04i24"] -[ext_resource type="Script" path="res://principal/microgame_asset.gd" id="1_5t5hy"] -[ext_resource type="Texture2D" path="res://microjogos/2024S1/projeto-felipe-silva/capa.png" id="1_6x2bw"] +[ext_resource type="Script" uid="uid://bus1nknp6xsc0" path="res://principal/microgame_asset.gd" id="1_5t5hy"] +[ext_resource type="Texture2D" uid="uid://cuw0k12ig2viu" path="res://microjogos/2024S1/projeto-felipe-silva/capa.png" id="1_6x2bw"] [ext_resource type="PackedScene" path="res://microjogos/2024S1/projeto-felipe-silva/cenas/main.tscn" id="2_u4car"] [resource] @@ -23,3 +23,4 @@ start_message_pt = &"SIGA!" start_message_en = &"FOLLOW!" main_scene = ExtResource("2_u4car") difficulty = 0 +screen_dimensions = Vector2i(1920, 1080) diff --git a/microjogos/2024S1/projeto-guilherme/cenas/main.tscn b/microjogos/2024S1/projeto-guilherme/cenas/main.tscn index b7aa46548..fca41141b 100644 --- a/microjogos/2024S1/projeto-guilherme/cenas/main.tscn +++ b/microjogos/2024S1/projeto-guilherme/cenas/main.tscn @@ -135,6 +135,3 @@ position = Vector2(1388, -450) scale = Vector2(13, 13) texture = ExtResource("17_vxn8a") script = ExtResource("17_oqj4w") - -[connection signal="lose" from="lista" to="." method="register_lose"] -[connection signal="win" from="lista" to="." method="register_win"] diff --git a/microjogos/2024S1/projeto-guilherme/cenas/scripts/lista.gd b/microjogos/2024S1/projeto-guilherme/cenas/scripts/lista.gd index 37ec20f99..ac721c500 100644 --- a/microjogos/2024S1/projeto-guilherme/cenas/scripts/lista.gd +++ b/microjogos/2024S1/projeto-guilherme/cenas/scripts/lista.gd @@ -1,6 +1,4 @@ extends Node2D -signal win -signal lose var resp = "" var jogador = "" @@ -105,10 +103,10 @@ func _process(delta): if resp == jogador: jogo = "win" - win.emit() + Minigames.register_win(self) else: jogo ="lose" - lose.emit() + Minigames.register_lose(self) diff --git a/microjogos/2024S1/projeto-guilherme/cenas/scripts/main.gd b/microjogos/2024S1/projeto-guilherme/cenas/scripts/main.gd deleted file mode 100644 index 2671d321a..000000000 --- a/microjogos/2024S1/projeto-guilherme/cenas/scripts/main.gd +++ /dev/null @@ -1,64 +0,0 @@ -extends Node2D - -# Declaração dos sinais win e lose -signal win -signal lose - -# Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma -# tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para -# atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução -# 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 - - -# -------------------------------------------------------------------------------------------------- -# FUNÇÕES PADRÃO -# -------------------------------------------------------------------------------------------------- - -# Esta função é chamada assim que esta cena é instanciada, ou seja, assim que seu minigame inicia -func _ready(): - pass - -# Esta função é chamada uma vez por frame e é otimizada para cálculos relacionados a física, como -# a movimentação de um personagem. O parâmetro delta indica a quantidade de tempo que passou desde -# a última chamada desta função. O comando pass não faz nada -func _physics_process(delta): - pass - - -# Esta função é chamada uma vez por frame e é otimizada para cálculos relacionados a renderização, -# como a movimentação de um personagem. O parâmetro delta indica a quantidade de tempo que passou -# desde a última chamada desta função. O comando pass não faz nada -func _process(delta): - pass - - -# -------------------------------------------------------------------------------------------------- -# SUAS FUNÇÕES -# -------------------------------------------------------------------------------------------------- - - -# Um método genérico. Crie quantos métodos você precisar! -func my_method(): - pass - - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2024S1/projeto-jantinha/cenas/scripts/main.gd b/microjogos/2024S1/projeto-jantinha/cenas/scripts/main.gd index 3d58e2637..9ca033e83 100644 --- a/microjogos/2024S1/projeto-jantinha/cenas/scripts/main.gd +++ b/microjogos/2024S1/projeto-jantinha/cenas/scripts/main.gd @@ -1,15 +1,11 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + const WOLF_DISTANCE_FROM_SPAWN = Vector2(200, 100) @@ -49,23 +45,3 @@ func _process(delta): # Um método genérico. Crie quantos métodos você precisar! func my_method(): pass - - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2024S1/projeto-jantinha/cenas/scripts/ovelha.gd b/microjogos/2024S1/projeto-jantinha/cenas/scripts/ovelha.gd index 98a9dd8d4..f229ab998 100644 --- a/microjogos/2024S1/projeto-jantinha/cenas/scripts/ovelha.gd +++ b/microjogos/2024S1/projeto-jantinha/cenas/scripts/ovelha.gd @@ -18,7 +18,7 @@ func _morrer(): func _on_hitboxovelha_area_entered(area): if area.name == "hitboxlobo" and not is_dead: _morrer() - get_parent().get_parent().register_win() + Minigames.register_win(self) pass # Replace with function body. func _on_sensacao_area_entered(area): diff --git a/microjogos/2024S1/projeto-leticia/cenas/scripts/main.gd b/microjogos/2024S1/projeto-leticia/cenas/scripts/main.gd index 6d49a73d1..b3479c268 100644 --- a/microjogos/2024S1/projeto-leticia/cenas/scripts/main.gd +++ b/microjogos/2024S1/projeto-leticia/cenas/scripts/main.gd @@ -1,15 +1,11 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + const UP_POS = 854 const DOWN_POS = 1005 @@ -40,7 +36,7 @@ func _ready(): elif not gone_up: cars[1].position[1] = UP_POS - register_win() + Minigames.register_win(self) # Called every frame. 'delta' is the elapsed time since the previous frame. @@ -63,27 +59,7 @@ func _physics_process(delta): func my_method(): pass - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") - func _on_carro_principal_lose(): - register_lose() + Minigames.register_lose(self) $Background.paused = true $Policias.is_lose = true diff --git a/microjogos/2024S1/projeto-matheusSC/cenas/scripts/controle_cena.gd b/microjogos/2024S1/projeto-matheusSC/cenas/scripts/controle_cena.gd index c16143eb6..f6adb8b6c 100644 --- a/microjogos/2024S1/projeto-matheusSC/cenas/scripts/controle_cena.gd +++ b/microjogos/2024S1/projeto-matheusSC/cenas/scripts/controle_cena.gd @@ -32,7 +32,7 @@ func _process(delta): if not crowd_anim_played: crowd_anim.play("crowd_shake") crowd_anim_played = true - emit_signal("win") + Minigames.register_win(self) if perdeu: oh_no.play() oh_no.visible = true diff --git a/microjogos/2024S1/projeto-matheusSC/cenas/scripts/main.gd b/microjogos/2024S1/projeto-matheusSC/cenas/scripts/main.gd index 6d2d13121..1a5d4cc35 100644 --- a/microjogos/2024S1/projeto-matheusSC/cenas/scripts/main.gd +++ b/microjogos/2024S1/projeto-matheusSC/cenas/scripts/main.gd @@ -13,16 +13,12 @@ var gota var crowd_anim_played = false -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + # -------------------------------------------------------------------------------------------------- @@ -66,7 +62,7 @@ func _process(delta): if not crowd_anim_played: crowd_anim.play("crowd_shake") crowd_anim_played = true - register_win() + Minigames.register_win(self) if perdeu: if $Music.playing: $Wrong.play() @@ -89,22 +85,3 @@ func my_method(): func _on_timer_timeout(): pode_checkar = true pass # Replace with function body. - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2024S1/projeto-naomi/cenas/scripts/main.gd b/microjogos/2024S1/projeto-naomi/cenas/scripts/main.gd index 14c2ff4c3..63aa8c7d2 100644 --- a/microjogos/2024S1/projeto-naomi/cenas/scripts/main.gd +++ b/microjogos/2024S1/projeto-naomi/cenas/scripts/main.gd @@ -1,15 +1,11 @@ extends Node2D -# Declaração dos sinais win e lose -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + # -------------------------------------------------------------------------------------------------- @@ -44,26 +40,5 @@ func _process(delta): func my_method(): pass - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") - - func _on_door_body_entered(body): - register_win() + Minigames.register_win(self) diff --git a/microjogos/2024S1/projeto-naomi/cenas/scripts/player.gd b/microjogos/2024S1/projeto-naomi/cenas/scripts/player.gd index 269847b46..1a312625b 100644 --- a/microjogos/2024S1/projeto-naomi/cenas/scripts/player.gd +++ b/microjogos/2024S1/projeto-naomi/cenas/scripts/player.gd @@ -30,5 +30,5 @@ func _physics_process(delta): func _on_hurtbox_body_entered(body): if body == get_parent().get_node("Enemy"): - emit_signal("lose") + Minigames.register_lose(self) self.queue_free() diff --git a/microjogos/2024S1/projeto-samuel/cenas/scripts/main.gd b/microjogos/2024S1/projeto-samuel/cenas/scripts/main.gd index a753bf865..ea54549a8 100644 --- a/microjogos/2024S1/projeto-samuel/cenas/scripts/main.gd +++ b/microjogos/2024S1/projeto-samuel/cenas/scripts/main.gd @@ -10,8 +10,8 @@ signal lose # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + @onready var gmts = [$Gamuto, $Gamuto2, $Gamuto3] @@ -41,7 +41,7 @@ func _physics_process(delta): func _process(delta): if vitoria >= 2: vitoria = 0 - register_win() + Minigames.register_win(self) # -------------------------------------------------------------------------------------------------- # SUAS FUNÇÕES @@ -52,27 +52,6 @@ func _process(delta): func my_method(): pass - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") - - func _on_gamuto_g_1(): vitoria += 1 diff --git a/microjogos/2024S1/projeto-samuel/cenas/scripts/scripts.txt b/microjogos/2024S1/projeto-samuel/cenas/scripts/scripts.txt index e309a7c92..2234ace1f 100644 --- a/microjogos/2024S1/projeto-samuel/cenas/scripts/scripts.txt +++ b/microjogos/2024S1/projeto-samuel/cenas/scripts/scripts.txt @@ -1,4 +1,4 @@ Coloque seus scripts aqui! -register_win() +Minigames.register_win(self) print("3") diff --git a/microjogos/2024S1/projeto_felipe_onorio/cenas/main.gd b/microjogos/2024S1/projeto_felipe_onorio/cenas/main.gd index d2c5467d1..15bf290cd 100644 --- a/microjogos/2024S1/projeto_felipe_onorio/cenas/main.gd +++ b/microjogos/2024S1/projeto_felipe_onorio/cenas/main.gd @@ -1,10 +1,7 @@ extends Node2D -signal win() -signal lose() -const WIDTH = 1920 -const HEIGHT = 1080 + signal right_pressed signal down_pressed @@ -62,7 +59,7 @@ func game_won(): var win_animations = $interface_static_elements/win_animation win_animations.show() win_animations.play("default") - win.emit() + Minigames.register_win(self) func _process(_delta): diff --git a/microjogos/2025S1/Cookies/cenas/scripts/main.gd b/microjogos/2025S1/Cookies/cenas/scripts/main.gd index a699cc10a..28de5f8d1 100644 --- a/microjogos/2025S1/Cookies/cenas/scripts/main.gd +++ b/microjogos/2025S1/Cookies/cenas/scripts/main.gd @@ -1,16 +1,11 @@ extends Node2D -# Declaração dos sinais win e lose - -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + # -------------------------------------------------------------------------------------------------- @@ -26,7 +21,7 @@ func _ready(): # Verifica a linguagem do jogo e mostra texto nesta linguagem. Deve dar uma ideia do que deve # ser feito para vencer o jogo. A fonte usada não suporta caracteres latinos como ~ ou ´ - register_win() + Minigames.register_win(self) # Esta função é chamada uma vez por frame e é otimizada para cálculos relacionados a física, como @@ -67,23 +62,3 @@ func _process(delta): # Um método genérico. Crie quantos métodos você precisar! func my_method(): pass - - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2025S1/Cookies/cenas/scripts/monster.gd b/microjogos/2025S1/Cookies/cenas/scripts/monster.gd index 98910fd22..65751da9b 100644 --- a/microjogos/2025S1/Cookies/cenas/scripts/monster.gd +++ b/microjogos/2025S1/Cookies/cenas/scripts/monster.gd @@ -15,7 +15,7 @@ func _process(delta: float) -> void: $AnimatedSprite2D.frame = 1 velocity.y = 0 health = 500 - get_parent().register_lose() + Minigames.register_lose(self) move_and_slide() func hit(damage: float): if health > 0: @@ -25,4 +25,4 @@ func hit(damage: float): $HealthBar.value = health if health <= 0: velocity.y = 300 - get_parent().register_win() + Minigames.register_win(self) diff --git a/microjogos/2025S1/seu_projeto/cenas/scripts/main.gd b/microjogos/2025S1/seu_projeto/cenas/scripts/main.gd index f7521dab2..e21379d4d 100644 --- a/microjogos/2025S1/seu_projeto/cenas/scripts/main.gd +++ b/microjogos/2025S1/seu_projeto/cenas/scripts/main.gd @@ -1,16 +1,11 @@ extends Node2D -# Declaração dos sinais win e lose - -signal win -signal lose - # Estas constantes são usadas para determinar o tamanho da tela do seu jogo. Por padrão, definem uma # tela 1920x1080, que é padrão para monitores full HD. Caso você queira uma resolução menor para # atingir uma estética mais pixelada, você pode mudar estes números para qualquer outra resolução # 16:9 -const WIDTH = 1920 -const HEIGHT = 1080 + + # -------------------------------------------------------------------------------------------------- @@ -44,23 +39,3 @@ func _process(delta): # Um método genérico. Crie quantos métodos você precisar! func my_method(): pass - - -# -------------------------------------------------------------------------------------------------- -# CONDIÇÕES DE VITÓRIA -# -------------------------------------------------------------------------------------------------- -# Quando o jogo começa, ela assume que o jogador não conseguiu vencer o jogo ainda, ou seja, se não -# acontecer nada, o jogador vai perder o jogo. A verificação se o jogador venceu o minigame é feita -# com base na emissão dos sinais "win" e "lose". Se "win" foi o último sinal emitido, o jogador -# vencerá o jogo, e se "lose" foi o último sinal emitido ou nenhum sinal foi emitido, o jogador -# perderá o jogo - - -# Chame esta função para registrar que o jogador venceu o jogo -func register_win(): - emit_signal("win") - - -# Chame esta função para registrar que o jogador perdeu o jogo -func register_lose(): - emit_signal("lose") diff --git a/microjogos/2025S1/seu_projeto/microgame.tres b/microjogos/2025S1/seu_projeto/microgame.tres index bf54ffbc6..34620dc35 100644 --- a/microjogos/2025S1/seu_projeto/microgame.tres +++ b/microjogos/2025S1/seu_projeto/microgame.tres @@ -11,3 +11,4 @@ credits_en = "Game crédits" start_message_pt = &"FAÇA ALGO!" start_message_en = &"DO SOMETHING!" difficulty = 0 +screen_dimensions = Vector2i(1920, 1080) diff --git a/microjogos/demo/frogger/cenas/scripts/Frog.gd b/microjogos/demo/frogger/cenas/scripts/Frog.gd index 31fec6c3b..1e346f55f 100644 --- a/microjogos/demo/frogger/cenas/scripts/Frog.gd +++ b/microjogos/demo/frogger/cenas/scripts/Frog.gd @@ -49,7 +49,7 @@ func _physics_process(delta): yay.play() active = false - main.register_win() + Minigames.register_win(self) # Chamada quando entra em outra. Mata o jogador @@ -60,4 +60,4 @@ func hit(area): active = false hide() - main.register_lose() + Minigames.register_lose(self) diff --git a/microjogos/demo/frogger/cenas/scripts/main.gd b/microjogos/demo/frogger/cenas/scripts/main.gd index 380f4a1b9..1362b94b1 100644 --- a/microjogos/demo/frogger/cenas/scripts/main.gd +++ b/microjogos/demo/frogger/cenas/scripts/main.gd @@ -6,11 +6,6 @@ const Car = preload("res://microjogos/demo/frogger/cenas/Car.tscn") const TURNS_PER_SPAWN = 3 - -signal win -signal lose - - const WIDTH = 256 const HEIGHT = 144 @@ -64,11 +59,3 @@ func spawn_car_y(x_pos): new_car.position = Vector2(x_pos, STEP_SIZE * 1.5 + STEP_SIZE * (randi() % ((HEIGHT - 3 * STEP_SIZE) / STEP_SIZE))) car_container.add_child(new_car) - - -func register_win(): - emit_signal("win") - - -func register_lose(): - emit_signal("lose") diff --git a/microjogos/demo/frogger/microgame.tres b/microjogos/demo/frogger/microgame.tres index e662c6f0f..8fcba3c96 100644 --- a/microjogos/demo/frogger/microgame.tres +++ b/microjogos/demo/frogger/microgame.tres @@ -1,8 +1,8 @@ -[gd_resource type="Resource" script_class="MicrogameAsset" load_steps=4 format=3] +[gd_resource type="Resource" script_class="MicrogameAsset" load_steps=4 format=3 uid="uid://h41i5kvndtgi"] -[ext_resource type="Script" path="res://principal/microgame_asset.gd" id="1_4iqi5"] -[ext_resource type="Texture2D" path="res://microjogos/demo/frogger/capa.png" id="1_7ibmg"] -[ext_resource type="PackedScene" path="res://microjogos/demo/frogger/cenas/main.tscn" id="2_xxold"] +[ext_resource type="Script" uid="uid://bus1nknp6xsc0" path="res://principal/microgame_asset.gd" id="1_4iqi5"] +[ext_resource type="Texture2D" uid="uid://bdsug836tp45t" path="res://microjogos/demo/frogger/capa.png" id="1_7ibmg"] +[ext_resource type="PackedScene" uid="uid://dxgstxi35e5b1" path="res://microjogos/demo/frogger/cenas/main.tscn" id="2_xxold"] [resource] script = ExtResource("1_4iqi5") @@ -23,3 +23,4 @@ start_message_pt = &"CROSS THE ROAD!" start_message_en = &"ATRAVESSE A RUA!" main_scene = ExtResource("2_xxold") difficulty = 0 +screen_dimensions = Vector2i(256, 144) diff --git a/microjogos/demo/tiro_ao_alvo/cenas/scripts/main.gd b/microjogos/demo/tiro_ao_alvo/cenas/scripts/main.gd index 5a1d7d502..71dc5a4af 100644 --- a/microjogos/demo/tiro_ao_alvo/cenas/scripts/main.gd +++ b/microjogos/demo/tiro_ao_alvo/cenas/scripts/main.gd @@ -1,11 +1,7 @@ extends Node2D -signal win -signal lose -const WIDTH = 1920 -const HEIGHT = 1080 const Target = preload("res://microjogos/demo/tiro_ao_alvo/cenas/Alvo.tscn") const TOTAL_TARGETS = 4 @@ -28,12 +24,4 @@ func _ready(): func register_hit(): hits += 1 if hits >= TOTAL_TARGETS: - register_win() - - -func register_win(): - emit_signal("win") - -func register_lose(): - emit_signal("lose") - + Minigames.register_win(self) diff --git a/microjogos/godotware/Bang/Main.gd b/microjogos/godotware/Bang/Main.gd index f1ea5e6a8..1498c9910 100644 --- a/microjogos/godotware/Bang/Main.gd +++ b/microjogos/godotware/Bang/Main.gd @@ -1,13 +1,5 @@ extends Node2D - -signal win -signal lose - - -const WIDTH = 640 -const HEIGHT = 360 - const SHOOT_TIME = 0.6 const MIN_WAIT_TIME = 2 const MAX_WAIT_TIME = 5 @@ -55,7 +47,7 @@ func _input(event): if set: animated_sprite.set_animation("win") - emit_signal("win") + Minigames.register_win(self) else: animated_sprite.set_animation("dodge") music.stop() diff --git a/microjogos/godotware/Bang/microgame.tres b/microjogos/godotware/Bang/microgame.tres index 995170b11..bcf38749e 100644 --- a/microjogos/godotware/Bang/microgame.tres +++ b/microjogos/godotware/Bang/microgame.tres @@ -1,8 +1,8 @@ -[gd_resource type="Resource" script_class="MicrogameAsset" load_steps=4 format=3] +[gd_resource type="Resource" script_class="MicrogameAsset" load_steps=4 format=3 uid="uid://b7wc10kv8nhoy"] -[ext_resource type="Script" path="res://principal/microgame_asset.gd" id="1_8j2ou"] -[ext_resource type="Texture2D" path="res://microjogos/godotware/Bang/capa.png" id="1_ubs16"] -[ext_resource type="PackedScene" path="res://microjogos/godotware/Bang/Main.tscn" id="2_wfjyu"] +[ext_resource type="Script" uid="uid://bus1nknp6xsc0" path="res://principal/microgame_asset.gd" id="1_8j2ou"] +[ext_resource type="Texture2D" uid="uid://cn58pcwd1eqcl" path="res://microjogos/godotware/Bang/capa.png" id="1_ubs16"] +[ext_resource type="PackedScene" uid="uid://c62qhhfmkvajw" path="res://microjogos/godotware/Bang/Main.tscn" id="2_wfjyu"] [resource] script = ExtResource("1_8j2ou") @@ -23,3 +23,4 @@ start_message_pt = &"SE PREPARE..." start_message_en = &"GET READY..." main_scene = ExtResource("2_wfjyu") difficulty = 0 +screen_dimensions = Vector2i(640, 360) diff --git a/microjogos/godotware/Simon/Main.gd b/microjogos/godotware/Simon/Main.gd index 08c71d553..645da5942 100644 --- a/microjogos/godotware/Simon/Main.gd +++ b/microjogos/godotware/Simon/Main.gd @@ -1,13 +1,5 @@ extends Node2D - -signal win -signal lose - - -const WIDTH = 640 -const HEIGHT = 360 - const TOTAL_COLORS = 4 const WAIT_TIME = 0.5 const START_EXTRA_TIME = 0.3 @@ -83,7 +75,7 @@ func button_click(color_code): active = false win_sound.play() - emit_signal("win") + Minigames.register_win(self) func play_color(color_code): diff --git a/microjogos/godotware/Simon/microgame.tres b/microjogos/godotware/Simon/microgame.tres index 8980b5961..691cf504b 100644 --- a/microjogos/godotware/Simon/microgame.tres +++ b/microjogos/godotware/Simon/microgame.tres @@ -1,6 +1,17 @@ +<<<<<<< HEAD +<<<<<<< HEAD +[gd_resource type="Resource" script_class="MicrogameAsset" load_steps=3 format=3 uid="uid://2g1ukvwmscfq"] + +======= [gd_resource type="Resource" script_class="MicrogameAsset" format=3 uid="uid://dp8y5s1m0sp4e"] [ext_resource type="Texture2D" uid="uid://jd6dmhpdjnje" path="res://microjogos/godotware/Simon/capa.png" id="1_pinp6"] +>>>>>>> dcd945ec (Add missing cover to Simon Says microgame (godotware/Simon)) +======= +[gd_resource type="Resource" script_class="MicrogameAsset" format=3 uid="uid://dp8y5s1m0sp4e"] + +[ext_resource type="Texture2D" uid="uid://jd6dmhpdjnje" path="res://microjogos/godotware/Simon/capa.png" id="1_pinp6"] +>>>>>>> master [ext_resource type="Script" uid="uid://bus1nknp6xsc0" path="res://principal/microgame_asset.gd" id="1_rc2nu"] [ext_resource type="PackedScene" uid="uid://m56hivov4ion" path="res://microjogos/godotware/Simon/Main.tscn" id="1_x3ipl"] @@ -26,3 +37,6 @@ Assets: https://freesound.org/people/LittleRobotSoundFactory/sounds/270333/" start_message_pt = &"IMITE!" start_message_en = &"SIMON SAYS..." main_scene = ExtResource("1_x3ipl") +difficulty = 0 +screen_dimensions = Vector2i(640, 360) + diff --git a/microjogos/moraguma/candle prick/cenas/scripts/Game.gd b/microjogos/moraguma/candle prick/cenas/scripts/Game.gd index 9996170c8..13ca00bf1 100644 --- a/microjogos/moraguma/candle prick/cenas/scripts/Game.gd +++ b/microjogos/moraguma/candle prick/cenas/scripts/Game.gd @@ -32,7 +32,3 @@ func _ready(): func has_floor(cell_pos): return tiles.get_cell_source_id(0, cell_pos) in VALID_TILES - - -func register_win(): - get_parent().get_parent().win_game() diff --git a/microjogos/moraguma/candle prick/cenas/scripts/Main.gd b/microjogos/moraguma/candle prick/cenas/scripts/Main.gd index 3b4db0615..6ec48b973 100644 --- a/microjogos/moraguma/candle prick/cenas/scripts/Main.gd +++ b/microjogos/moraguma/candle prick/cenas/scripts/Main.gd @@ -1,18 +1,5 @@ extends Node2D - -signal win -signal lose - - -const WIDTH = 240 -const HEIGHT = 135 - - func _ready(): $Wind.play() $Music.play() - - -func win_game(): - win.emit() diff --git a/microjogos/moraguma/candle prick/cenas/scripts/WinningArea.gd b/microjogos/moraguma/candle prick/cenas/scripts/WinningArea.gd index 44da6525f..6c059124f 100644 --- a/microjogos/moraguma/candle prick/cenas/scripts/WinningArea.gd +++ b/microjogos/moraguma/candle prick/cenas/scripts/WinningArea.gd @@ -24,7 +24,7 @@ func _physics_process(delta): if candle.position.distance_to(position) < CANDLE_TOLERANCE: active = false - parent.register_win() + Minigames.register_win(self) candle.register_win() diff --git a/microjogos/moraguma/candle prick/microgame.tres b/microjogos/moraguma/candle prick/microgame.tres index c2da2ec82..bf7e3fa82 100644 --- a/microjogos/moraguma/candle prick/microgame.tres +++ b/microjogos/moraguma/candle prick/microgame.tres @@ -1,8 +1,8 @@ -[gd_resource type="Resource" script_class="MicrogameAsset" load_steps=4 format=3] +[gd_resource type="Resource" script_class="MicrogameAsset" load_steps=4 format=3 uid="uid://cosa74pm7btpi"] -[ext_resource type="Script" path="res://principal/microgame_asset.gd" id="1_6ie47"] -[ext_resource type="Texture2D" path="res://microjogos/moraguma/candle prick/capa.png" id="1_uvdim"] -[ext_resource type="PackedScene" path="res://microjogos/moraguma/candle prick/cenas/Main.tscn" id="2_arxhb"] +[ext_resource type="Script" uid="uid://bus1nknp6xsc0" path="res://principal/microgame_asset.gd" id="1_6ie47"] +[ext_resource type="Texture2D" uid="uid://cgs0r3wy2sgnj" path="res://microjogos/moraguma/candle prick/capa.png" id="1_uvdim"] +[ext_resource type="PackedScene" uid="uid://coegrh14dch8v" path="res://microjogos/moraguma/candle prick/cenas/Main.tscn" id="2_arxhb"] [resource] script = ExtResource("1_6ie47") @@ -31,3 +31,4 @@ start_message_pt = &"EMPURRE!" start_message_en = &"PUSH!" main_scene = ExtResource("2_arxhb") difficulty = 0 +screen_dimensions = Vector2i(240, 135) diff --git a/microjogos/moraguma/deerskull/cenas/scripts/Main.gd b/microjogos/moraguma/deerskull/cenas/scripts/Main.gd index 1f4190be4..23d2da714 100644 --- a/microjogos/moraguma/deerskull/cenas/scripts/Main.gd +++ b/microjogos/moraguma/deerskull/cenas/scripts/Main.gd @@ -1,17 +1,5 @@ extends Node2D - -signal win -signal lose - - -const HEIGHT = 180 -const WIDTH = 320 - - - - - const LINE_POINTS = [Vector2(-4, -4), Vector2(324, -4), Vector2(324, 184), Vector2(-4, 184), Vector2(-4, -3)] const FIRST_TIME = 1 const SPAWN_TIME = 0.389 @@ -27,7 +15,7 @@ func _ready(): music.play() - call_deferred("emit_signal", "win") + Minigames.register_win(self) randomize() @@ -50,4 +38,4 @@ func spawn(): func register_lose(): timer.stop() - emit_signal("lose") + Minigames.register_lose(self) diff --git a/microjogos/moraguma/deerskull/microgame.tres b/microjogos/moraguma/deerskull/microgame.tres index 90609111d..f4ae6671d 100644 --- a/microjogos/moraguma/deerskull/microgame.tres +++ b/microjogos/moraguma/deerskull/microgame.tres @@ -1,8 +1,8 @@ -[gd_resource type="Resource" script_class="MicrogameAsset" load_steps=4 format=3] +[gd_resource type="Resource" script_class="MicrogameAsset" load_steps=4 format=3 uid="uid://dlb0jfw447p1y"] -[ext_resource type="Script" path="res://principal/microgame_asset.gd" id="1_mq6lb"] -[ext_resource type="Texture2D" path="res://microjogos/moraguma/deerskull/capa.png" id="1_s5r6s"] -[ext_resource type="PackedScene" path="res://microjogos/moraguma/deerskull/cenas/Main.tscn" id="2_w8deb"] +[ext_resource type="Script" uid="uid://bus1nknp6xsc0" path="res://principal/microgame_asset.gd" id="1_mq6lb"] +[ext_resource type="Texture2D" uid="uid://8hmaryvrwd7s" path="res://microjogos/moraguma/deerskull/capa.png" id="1_s5r6s"] +[ext_resource type="PackedScene" uid="uid://ci10ibxytwob5" path="res://microjogos/moraguma/deerskull/cenas/Main.tscn" id="2_w8deb"] [resource] script = ExtResource("1_mq6lb") @@ -27,3 +27,4 @@ start_message_pt = &"DESVIE!" start_message_en = &"DODGE!" main_scene = ExtResource("2_w8deb") difficulty = 0 +screen_dimensions = Vector2i(320, 180) diff --git a/microjogos/moraguma/hora_da_necromancia/cenas/scripts/Main.gd b/microjogos/moraguma/hora_da_necromancia/cenas/scripts/Main.gd index 443386738..3d55d29db 100644 --- a/microjogos/moraguma/hora_da_necromancia/cenas/scripts/Main.gd +++ b/microjogos/moraguma/hora_da_necromancia/cenas/scripts/Main.gd @@ -1,11 +1,7 @@ extends Node2D -signal win -signal lose -const WIDTH = 1920 -const HEIGHT = 1080 const LOVE = {Global.LANGUAGE.PT: ["Você fica lindo sob a luz do luar", "Os seus chifres são brilhantes", "Seus olhos me incandescem", "Sua capa é tão sedosa..."], Global.LANGUAGE.EN: ["You look beautiful under the moonlight", "Your antlers look radiant", "I could get lost in your eyes", "Your cape is so soft..."]} const FAMILY = {Global.LANGUAGE.PT: ["Saudades da sua irmã...", "Aquele teu tio é doido", "E vovó, cadê?", "Me passa o número da sua tia?"], Global.LANGUAGE.EN: ["I miss your sister...", "That uncle of yours is insane", "And grandma? Where is she?", "Can I get your aunt's number?"]} @@ -84,7 +80,7 @@ func _physics_process(delta): win_sound.play() wow_sound.play() animation_player.play("love") - emit_signal("win") + Minigames.register_win(self) else: lose_sound.play() music.stop() diff --git a/microjogos/moraguma/ifuv/cenas/scripts/Main.gd b/microjogos/moraguma/ifuv/cenas/scripts/Main.gd index 8ef63612d..b8b598fa5 100644 --- a/microjogos/moraguma/ifuv/cenas/scripts/Main.gd +++ b/microjogos/moraguma/ifuv/cenas/scripts/Main.gd @@ -1,14 +1,5 @@ extends Node2D - -signal win -signal lose - - -const WIDTH = 160 -const HEIGHT = 90 - - const CURSOR_LERP_WEIGHT = 0.3 const PASSWORD_LENGTH = 3 const MAX_LENGTH = 3 @@ -89,7 +80,7 @@ func erase(): func enter(): if input == correct_password: enabled = false - emit_signal("win") + Minigames.register_win(self) door_animation_player.play("close") else: diff --git a/microjogos/moraguma/ifuv/microgame.tres b/microjogos/moraguma/ifuv/microgame.tres index ec6790c00..df135dd75 100644 --- a/microjogos/moraguma/ifuv/microgame.tres +++ b/microjogos/moraguma/ifuv/microgame.tres @@ -1,8 +1,8 @@ -[gd_resource type="Resource" script_class="MicrogameAsset" load_steps=4 format=3] +[gd_resource type="Resource" script_class="MicrogameAsset" load_steps=4 format=3 uid="uid://bpax1kry4uklx"] -[ext_resource type="Script" path="res://principal/microgame_asset.gd" id="1_o5mcw"] -[ext_resource type="Texture2D" path="res://microjogos/moraguma/ifuv/capa.png" id="1_tu0yr"] -[ext_resource type="PackedScene" path="res://microjogos/moraguma/ifuv/cenas/Main.tscn" id="2_ib0x2"] +[ext_resource type="Script" uid="uid://bus1nknp6xsc0" path="res://principal/microgame_asset.gd" id="1_o5mcw"] +[ext_resource type="Texture2D" uid="uid://c4omh77sdqnlm" path="res://microjogos/moraguma/ifuv/capa.png" id="1_tu0yr"] +[ext_resource type="PackedScene" uid="uid://cukdi0t5sqxm8" path="res://microjogos/moraguma/ifuv/cenas/Main.tscn" id="2_ib0x2"] [resource] script = ExtResource("1_o5mcw") @@ -29,3 +29,4 @@ start_message_pt = &"DIGITE!" start_message_en = &"TYPE!" main_scene = ExtResource("2_ib0x2") difficulty = 0 +screen_dimensions = Vector2i(160, 90) diff --git a/microjogos/moraguma/soulchain/cenas/scripts/Main.gd b/microjogos/moraguma/soulchain/cenas/scripts/Main.gd index 1e0e87892..9a4522c25 100644 --- a/microjogos/moraguma/soulchain/cenas/scripts/Main.gd +++ b/microjogos/moraguma/soulchain/cenas/scripts/Main.gd @@ -1,14 +1,5 @@ extends Node2D - -signal win -signal lose - - -const WIDTH = 384 -const HEIGHT = 216 - - const MAX_PLAYER_MOVEMENT = Vector2(48, 0) const MAX_GOAL_MOVEMENT_1 = Vector2(0, -32) const MAX_GOAL_MOVEMENT_2 = Vector2(16, 16) @@ -37,7 +28,4 @@ func _ready(): func register_win(_body): - emit_signal("win") - -func register_lose(_body): - emit_signal("lose") + Minigames.register_win(self) diff --git a/microjogos/moraguma/soulchain/microgame.tres b/microjogos/moraguma/soulchain/microgame.tres index 06d5bc7d0..fd656cadf 100644 --- a/microjogos/moraguma/soulchain/microgame.tres +++ b/microjogos/moraguma/soulchain/microgame.tres @@ -1,8 +1,8 @@ -[gd_resource type="Resource" script_class="MicrogameAsset" load_steps=4 format=3] +[gd_resource type="Resource" script_class="MicrogameAsset" load_steps=4 format=3 uid="uid://b8ywmwyrtddkr"] -[ext_resource type="Texture2D" path="res://microjogos/moraguma/soulchain/capa.png" id="1_65jq3"] -[ext_resource type="Script" path="res://principal/microgame_asset.gd" id="1_era8q"] -[ext_resource type="PackedScene" path="res://microjogos/moraguma/soulchain/cenas/Main.tscn" id="2_htk62"] +[ext_resource type="Texture2D" uid="uid://c4uli67uaejag" path="res://microjogos/moraguma/soulchain/capa.png" id="1_65jq3"] +[ext_resource type="Script" uid="uid://bus1nknp6xsc0" path="res://principal/microgame_asset.gd" id="1_era8q"] +[ext_resource type="PackedScene" uid="uid://con3bdyv0ce17" path="res://microjogos/moraguma/soulchain/cenas/Main.tscn" id="2_htk62"] [resource] script = ExtResource("1_era8q") @@ -25,3 +25,4 @@ start_message_pt = &"ATRAVESSE!" start_message_en = &"CROSS!" main_scene = ExtResource("2_htk62") difficulty = 0 +screen_dimensions = Vector2i(384, 216) diff --git a/microjogos/moraguma/whale_eater/cenas/scripts/Main.gd b/microjogos/moraguma/whale_eater/cenas/scripts/Main.gd index 8f32e4784..7b1c5beb2 100644 --- a/microjogos/moraguma/whale_eater/cenas/scripts/Main.gd +++ b/microjogos/moraguma/whale_eater/cenas/scripts/Main.gd @@ -1,14 +1,5 @@ extends Node2D - -const WIDTH = 480 -const HEIGHT = 270 - - -signal win -signal lose - - var Player = preload("res://microjogos/moraguma/whale_eater/cenas/Player.tscn") @@ -73,6 +64,6 @@ func get_input_dir(): func register_win(body): active = false - emit_signal("win") + Minigames.register_win(self) heart_animation_player.play("enter") diff --git a/microjogos/moraguma/whale_eater/microgame.tres b/microjogos/moraguma/whale_eater/microgame.tres index f2696acd8..aa7989a1c 100644 --- a/microjogos/moraguma/whale_eater/microgame.tres +++ b/microjogos/moraguma/whale_eater/microgame.tres @@ -29,3 +29,4 @@ start_message_pt = &"FOGE!" start_message_en = &"GET OUT!" main_scene = ExtResource("2_tcnpy") difficulty = 0 +screen_dimensions = Vector2i(480,270) diff --git a/principal/cenas/Jogo.tscn b/principal/cenas/Jogo.tscn index 4d40d3575..fc7d15426 100644 --- a/principal/cenas/Jogo.tscn +++ b/principal/cenas/Jogo.tscn @@ -3,14 +3,14 @@ [ext_resource type="Texture2D" uid="uid://d1pcvjogk0whm" path="res://principal/recursos/sprites/GMTIconSpritesheet.png" id="1"] [ext_resource type="Script" uid="uid://nuc4ey4h6jxi" path="res://principal/cenas/scripts/Jogo.gd" id="2"] [ext_resource type="Texture2D" uid="uid://wvr13kxa83wa" path="res://principal/recursos/sprites/Battery.png" id="3"] -[ext_resource type="Theme" uid="uid://n5yo736vdclg" path="res://principal/recursos/themes/GameTheme.tres" id="3_umkw3"] +[ext_resource type="Theme" uid="uid://crcbrmfw0ia6c" path="res://principal/recursos/themes/GameTheme.tres" id="3_umkw3"] [ext_resource type="Script" uid="uid://c5686qim2k0a0" path="res://principal/cenas/scripts/Bateria.gd" id="4"] [ext_resource type="Script" uid="uid://bo1sbktvlmt0m" path="res://principal/cenas/scripts/Relogio.gd" id="6"] [ext_resource type="Texture2D" uid="uid://cf6e7k0jprikg" path="res://principal/recursos/sprites/Cursor.png" id="7"] [ext_resource type="Texture2D" uid="uid://d2g21riptaer" path="res://principal/recursos/sprites/GreenGameIcon.png" id="8"] [ext_resource type="Texture2D" uid="uid://chkkxnuifd6go" path="res://principal/recursos/sprites/Game.png" id="9"] [ext_resource type="Script" uid="uid://efo8g4tp4r2f" path="res://principal/cenas/scripts/Vida.gd" id="10"] -[ext_resource type="Theme" uid="uid://cb4tlwb81nq48" path="res://principal/recursos/themes/TitleTheme.tres" id="11_coplq"] +[ext_resource type="Theme" path="res://principal/recursos/themes/TitleTheme.tres" id="11_coplq"] [ext_resource type="Texture2D" uid="uid://ctijuu2jh4eyo" path="res://principal/recursos/sprites/LifeSpritesheet.png" id="12"] [ext_resource type="Texture2D" uid="uid://bwhscrkgcredi" path="res://principal/recursos/sprites/excitedParticles.png" id="14"] [ext_resource type="Script" uid="uid://il22ucs6kg8r" path="res://principal/cenas/scripts/Droppable.gd" id="15"] @@ -1508,11 +1508,10 @@ _data = { [node name="Main" type="Node2D"] script = ExtResource("2") -microgame_paths = ["res://microjogos/demo/frogger/cenas/main.tscn", "res://microjogos/demo/tiro_ao_alvo/cenas/main.tscn"] [node name="AnimationPlayer" type="AnimationPlayer" parent="."] libraries = { -"": SubResource("AnimationLibrary_6caji") +&"": SubResource("AnimationLibrary_6caji") } [node name="GameUI" type="Sprite2D" parent="."] @@ -1609,17 +1608,17 @@ script = ExtResource("10") [node name="AnimationPlayer" type="AnimationPlayer" parent="GameUI/Life"] libraries = { -"": SubResource("AnimationLibrary_ortrc") +&"": SubResource("AnimationLibrary_ortrc") } [node name="GMTConfetti" type="CPUParticles2D" parent="GameUI"] position = Vector2(0, 700) emitting = false amount = 32 +texture = ExtResource("14") lifetime = 5.0 one_shot = true explosiveness = 0.7 -texture = ExtResource("14") emission_shape = 1 emission_sphere_radius = 100.0 direction = Vector2(0, -1) diff --git a/principal/cenas/autoloads/NotificationCenter.tscn b/principal/cenas/autoloads/NotificationCenter.tscn index 917821688..3ddec7342 100644 --- a/principal/cenas/autoloads/NotificationCenter.tscn +++ b/principal/cenas/autoloads/NotificationCenter.tscn @@ -1,7 +1,7 @@ [gd_scene load_steps=9 format=3 uid="uid://4a8sqqgp1gx6"] [ext_resource type="Script" uid="uid://cpxde47kber5j" path="res://principal/cenas/scripts/NotificationCenter.gd" id="1"] -[ext_resource type="Theme" uid="uid://cb4tlwb81nq48" path="res://principal/recursos/themes/TitleTheme.tres" id="2_18get"] +[ext_resource type="Theme" path="res://principal/recursos/themes/TitleTheme.tres" id="2_18get"] [sub_resource type="Animation" id="Animation_0hrvw"] length = 0.001 @@ -326,5 +326,5 @@ text = "[center]Test" [node name="AnimationPlayer" type="AnimationPlayer" parent="."] libraries = { -"": SubResource("AnimationLibrary_w8uvh") +&"": SubResource("AnimationLibrary_w8uvh") } diff --git a/principal/cenas/scripts/MinigameDisplay.gd b/principal/cenas/scripts/MinigameDisplay.gd index 7908cc635..26c90fdd4 100644 --- a/principal/cenas/scripts/MinigameDisplay.gd +++ b/principal/cenas/scripts/MinigameDisplay.gd @@ -30,6 +30,8 @@ var t: Tween func _ready() -> void: timer.connect("timeout", free_microgame) free_timer.connect("timeout", instant_free_microgame) + Minigames._win.connect(win_microgame) + Minigames._lose.connect(lose_microgame) func set_mask_center(pos): @@ -47,12 +49,13 @@ func start_game(microgame): print("Loading without previous request: "+microgame.main_scene.resource_path) ResourceLoader.load_threaded_request(microgame.main_scene.resource_path) current_microgame = ResourceLoader.load_threaded_get(microgame.main_scene.resource_path).instantiate() - current_microgame.connect("win", win_microgame) - current_microgame.connect("lose", lose_microgame) - var convert_ratio = max(BASE_WIDTH/float(current_microgame.WIDTH),BASE_HEIGHT/float(current_microgame.HEIGHT)) + var width: int = microgame.screen_dimensions.x + var height: int = microgame.screen_dimensions.y + + var convert_ratio = max(BASE_WIDTH/float(width),BASE_HEIGHT/float(height)) - display.size = Vector2(current_microgame.WIDTH, current_microgame.HEIGHT) + display.size = microgame.screen_dimensions display.scale=Vector2(convert_ratio,convert_ratio) display.texture_filter = current_microgame.texture_filter @@ -106,9 +109,19 @@ func reset_tween(): t.set_trans(Tween.TRANS_CIRC) -func win_microgame(): +func win_microgame(source: Node) -> void: + if source == null or current_microgame == null: + return + # Microgame cannot register win if source of win call is not a descendant of the current microgames main node + if source != current_microgame and not current_microgame.is_ancestor_of(source): + return won = true -func lose_microgame(): +func lose_microgame(source: Node): + if source == null or current_microgame == null: + return + # Microgame cannot register lose if source of win call is not a descendant of the current microgames main node + if source != current_microgame and not current_microgame.is_ancestor_of(source): + return won = false diff --git a/principal/microgame_asset.gd b/principal/microgame_asset.gd index df4040f82..c976d0e8a 100644 --- a/principal/microgame_asset.gd +++ b/principal/microgame_asset.gd @@ -21,3 +21,16 @@ class_name MicrogameAsset @export var difficulty: int +# Dimensions +## Sets microgame zoom so that screen dimensions, default is 1920x1080 (16:9) +@export var screen_dimensions: Vector2i = Vector2i(1920, 1080) : + set(value): + if value.x < 0: + value.x = -value.x + if value.x == 0: + value.x = screen_dimensions.x + if value.y < 0: + value.y = -value.y + if value.y == 0: + value.y = screen_dimensions.y + screen_dimensions = value diff --git a/principal/recursos/data/Minigames.gd b/principal/recursos/data/Minigames.gd index cb259a025..47d30cf8d 100644 --- a/principal/recursos/data/Minigames.gd +++ b/principal/recursos/data/Minigames.gd @@ -1,5 +1,7 @@ extends Node +#region minigame-setup + const minigame_packs = { "class_of_2025" : preload("res://principal/recursos/data/packs/class_of_2025.tres"), "class_of_2024" : preload("res://principal/recursos/data/packs/class_of_2024.tres"), @@ -21,7 +23,23 @@ const filters = { var pack_data = minigame_packs.values() + filters.values() var minigame_data = [] +#endregion + +#region minigame-run + +signal _win(source: Node) +signal _lose(source: Node) + +#endregion + func _ready(): for pack in pack_data: minigame_data.append_array(pack.microgames) + +# Source has to be descendant of current microgame's main node +func register_win(source: Node) -> void: + _win.emit(source) + +func register_lose(source: Node) -> void: + _lose.emit(source) diff --git a/principal/recursos/themes/GameTheme.tres b/principal/recursos/themes/GameTheme.tres index a70a83c8d..4251a740b 100644 --- a/principal/recursos/themes/GameTheme.tres +++ b/principal/recursos/themes/GameTheme.tres @@ -1,6 +1,6 @@ -[gd_resource type="Theme" load_steps=4 format=3] +[gd_resource type="Theme" load_steps=4 format=3 uid="uid://crcbrmfw0ia6c"] -[ext_resource type="FontFile" path="res://principal/recursos/fonts/coolvetica/coolvetica rg.otf" id="1_ws0p3"] +[ext_resource type="FontFile" uid="uid://bh37fuggg4bip" path="res://principal/recursos/fonts/coolvetica/coolvetica rg.otf" id="1_ws0p3"] [sub_resource type="StyleBoxEmpty" id="StyleBoxEmpty_horhx"]