提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言

这个游戏叫做“Dodge the Creeps!”。你的角色必须尽可能长时间移动并避开敌人。gd版本号为3.5.3，代码语言为C#。整体教学参考官方文档，在此基础上进行细节补充。在最后总结部分，列出了每个场景中添加的节点和脚本代码。本文主要供本人学习复盘使用，写的还不是很好，希望大家留下意见，共同进步！

开源项目地址，下载后在该目录的2D文件夹中找到该游戏
Godot3.5.3下载地址

一、设置项目

  1. 打开godot，点击New Project创建项目，需要保存到一个空文件夹中
  2. 将开源项目中art和fonts文件添加到新建项目的文件夹中在这里插入图片描述
  3. 进入编辑器界面，点击Project -> Project Settings，在弹窗的General选项卡下，找到Display -> Window tab，在Size选项中设置游戏场景的宽度Width为480，高度Height为720在这里插入图片描述
  4. 在同窗口下拉找到Stretch选项，将Mode设置为2d，Aspect设置为keep。这样可以确保游戏画面在不同尺寸的屏幕中都能保持比例。在这里插入图片描述
    注：该项目将包含Player、Mob、HUD三个子场景，及一个主场景Main，由于规模较小，场景和脚本文件都一起放在根文件夹res://下。对于大型的项目，应该分别创建各自的文件夹存放在这里插入图片描述

二、创建玩家场景

项目创建完成后，需要在Scene面板添加根节点（把每个Scene场景都看作树状结构，故每个场景都有且只有一个根节点）。如图，点击2D Scene会快速添加Node2D节点，3D Scene会添加Spatial节点，User Interface会添加Control节点，Other Node可以选择所有节点。
在这里插入图片描述

  1. 创建根节点，点击添加Other Node，选择并添加Area2D节点，该节点的作用是检测与玩家重叠或进入玩家内部的物体，双击节点名称并更改为Player在这里插入图片描述
  2. 在添加任何子节点到Player节点前，为确保不因点击子节点而移动或者调整其大小。在这里插入图片描述
  3. 点击导航栏Scene -> Save，将场景命名并保存为Player.tscn。
  4. 点击Player节点并添加子节点AnimatedSprite。该子节点会处理player的外观和动画，然后在右侧Inspector面板找到Frames属性，点击empty -> New SpriteFrame在这里插入图片描述
  5. 点击创建好的SpriteFrame，在屏幕下方显示Animation列表在这里插入图片描述
  6. 将解压后的工程中art文件内对应的资源添加到动画up和walk中在这里插入图片描述
  7. 点击AnimatedSprite节点将Scale属性设置为（0.5，0.5）
  8. 添加子节点CollisionShape2D，将蓝色区域覆盖住整个动画在这里插入图片描述

三、编写玩家代码

  1. 添加Player的移动、动画和检测碰撞脚本代码。注意使用的是后缀为mono版本的gd编辑器，在语言这边选择C#。在这里插入图片描述在这里插入图片描述
    创建完成后的脚本视图，如下。
    创建完成后

  2. 声明Player需要使用的成员变量。其中，在speed上添加export关键字，即可在右侧Inspector中设置其值，在该处修改值会覆盖脚本中的值。
    如果使用的是 C#，则每当要查看新的导出变量或信号时，都需要（重新）构建项目程序集。可以通过点击编辑器右上方的Build或者底部MSBuild中的Build更新变量参数的显示。
    在这里插入图片描述
    在这里插入图片描述

在这里插入图片描述

using Godot;
using System;

public class Player : Area2D
{
    [Export]
    public int Speed = 400; // How fast the player will move (pixels/sec).

    public Vector2 ScreenSize; // Size of the game window.
}
  1. 您的player.gd脚本应该已经包含_ready（）和_process（）函数。当一个节点进入场景树时，会自动调用func _ready() 函数，是一个获得游戏窗口大小的好时机
public override void _Ready()
{
    ScreenSize = GetViewportRect().Size;
}
  1. 现在我们可以使用_process（）函数来定义玩家将要做的事情。 _process（）在每一帧中都被调用，所以我们将使用它来更新游戏的元素，我们预计这些元素会经常更改。对于玩家，我们需要做到以下几点：
    （1）检查按键输入。
    （2）对象按指定方向移动。
    （3）播放适当的动画来显示移动过程。
  2. 首先，我们需要检查输入，即玩家是否在按键？对于这个游戏，我们有4个方向输入要检查。输入操作在Input Map下的项目设置中定义。在这里，您可以定义自定义事件，并为它们分配不同的键、鼠标事件或其他输入。对于这个游戏，我们将把箭头键映射到四个方向。

点击菜单栏 Project -> Project Settings 打开项目设置窗口，然后单击顶部的Input Map选项卡。在顶部栏中键入“move_right”，然后单击“添加”按钮添加move_right操作。在这里插入图片描述
我们需要为此操作分配一个按键。单击右侧的“+”图标，打开事件管理器窗口。

在这里插入图片描述
“right”键现在与move_right操作相关联。重复这些步骤以添加另外三个映射：
move_left、move_up、move_down。
在这里插入图片描述

  1. 可以使用Input.IsActionPressed()来检测是否按下了某个键，如果按下了，则返回true；如果没有按下，则返回false。
public override void _Process(double delta)
{
    var velocity = Vector2.Zero; // The player's movement vector.

    if (Input.IsActionPressed("move_right"))
    {
        velocity.X += 1;
    }

    if (Input.IsActionPressed("move_left"))
    {
        velocity.X -= 1;
    }

    if (Input.IsActionPressed("move_down"))
    {
        velocity.Y += 1;
    }

    if (Input.IsActionPressed("move_up"))
    {
        velocity.Y -= 1;
    }

    var animatedSprite2D = GetNode<AnimatedSprite2D>("AnimatedSprite2D");

    if (velocity.Length() > 0)
    {
        velocity = velocity.Normalized() * Speed;
        animatedSprite2D.Play();
    }
    else
    {
        animatedSprite2D.Stop();
    }
}

其中GetNode<AnimatedSprite2D>("AnimatedSprite2D");的作用是返回指定路径"AnimatedSprite2D"的节点，并最终转化为AnimatedSprite2D类型。

Normalized()则是将速度矢量单位化，这样在斜向运动时候的速度不会偏快。

  1. 现在我们有了移动方向，可以更新玩家的位置。我们也可以使用clamp（）来防止它离开屏幕。固定值意味着将其限制在给定范围内。将以下内容添加到_process函数的底部（确保它没有缩进到else下）：
Position += velocity * delta;
Position = new Vector2(
    x: Mathf.Clamp(Position.x, 0, ScreenSize.x),
    y: Mathf.Clamp(Position.y, 0, ScreenSize.y)
);

_process（）函数中的delta参数指的是帧长度，即前一帧完成所需的时间。使用此值可确保即使帧速率发生变化，您的移动也将保持一致。

  1. 在向左和向下运动的时候，分别对动画进行水平和垂直翻转。
if (velocity.x != 0)
{
    animatedSprite.Animation = "walk";
    animatedSprite.FlipV = false;
    // See the note below about boolean assignment.
    animatedSprite.FlipH = velocity.x < 0;
}
else if (velocity.y != 0)
{
    animatedSprite.Animation = "up";
    animatedSprite.FlipV = velocity.y > 0;
}

在确认人物可以正常的移动后，在_ready()函数的末尾添加Hide();在游戏开始的时候隐藏人物。

  1. 检测碰撞。虽然目前还未创建敌人，而我们希望去检测玩家是否被敌人碰撞，可以使用Godot的signal功能。在public class Player : Area2D{ }中添加以下代码：
[Signal]
public delegate void Hit();

这定义了一个称为“Hit”的自定义信号，当玩家与敌人碰撞时，我们会让玩家发出该信号。我们将使用Area2D来检测碰撞。选择Player节点，然后单击检查器选项卡旁边的“Node”选项卡，查看Player可以发出的信号列表：
在这里插入图片描述
注意我们的自定义“Hit”信号也在那里！由于我们的敌人将是RigidBody2D节点，我们想要body_entred（body:Node）信号。当身体接触玩家时，会发出此信号。单击“Connect…”（连接…），此时会出现“Connect a Signal”（连接信号）窗口。我们不需要更改任何这些设置所以请再次单击“连接”。Godot会自动在玩家的脚本中创建一个函数。添加以下代码：

public void OnPlayerBodyEntered(PhysicsBody2D body)
{
    Hide(); // Player disappears after being hit.
    EmitSignal(nameof(Hit));
    // Must be deferred as we can't change physics properties on a physics callback.
    GetNode<CollisionShape2D>("CollisionShape2D").SetDeferred("disabled", true);
}

每当敌人击中玩家时，就会发出信号。我们需要禁用玩家的碰撞，这样我们就不会多次触发命中信号。最后一项是添加一个函数，我们可以在开始新游戏时调用该函数来重置玩家。

public void Start(Vector2 pos)
{
    Position = pos;
    Show();
    GetNode<CollisionShape2D>("CollisionShape2D").Disabled = false;
}

四、创建敌人

  1. 创建Mob场景
    点击Scene-> New Scene 创建场景后添加以下节点：
    在这里插入图片描述
    在RigidBody2D属性中，将“Gravity Scale”设定为0，这样mob就不会向下坠落。此外，在“CollisionObject2D”区域下，单击“Mask”属性并取消选中第一个框。这将确保mob之间不会发生冲突。
    在这里插入图片描述
  2. 设置mob的动画。在AnimatedSprite中创建fly、swim、walk三个动画，并分别将图片资源导入。
    在这里插入图片描述
    然后，将其Playing属性设置为on。Scale设置为0.75、0.75。同时，添加CapsuleShape2D作为碰撞的面积，为了更好地贴合，将Rotation Degrees设置为90。然后保存场景。
  3. 编写mob.cs脚本。新建脚本，在_ready（）中，播放动画，并从三种动画类型中随机选择一种：
public class Mob : RigidBody2D
{
    // Don't forget to rebuild the project.
    public override void _Ready()
	{
	    var animSprite = GetNode<AnimatedSprite>("AnimatedSprite");
	    animSprite.Playing = true;
	    string[] mobTypes = animSprite.Frames.GetAnimationNames();
	    animSprite.Animation = mobTypes[GD.Randi() % mobTypes.Length];
	}
}

如果希望每次运行场景时“随机”数字序列不同，则必须使用randomize（）。我们将在主场景中使用randomize（），所以这里不需要它。
最后一件事是让mob在离开屏幕时删除自己。连接VisibilityNotificationer2D节点的screen_exited（）信号，并添加以下代码：

public void OnVisibilityNotifier2DScreenExited()
{
    QueueFree();
}

注意：C#在添加signal的时候，需要确保Receiver Method的名称与在.cs中的函数名称一致，一般不会自动生成、或者会生成.gd中适合的格式然后报错，需要我们手动删除报错的部分，再将函数手动添加到根节点的.cs脚本中
在这里插入图片描述

五、游戏主场景

  1. 新建Main场景，并添加Node作为根节点，其子节点如下：
    在这里插入图片描述
    在这里插入图片描述
  2. 在场景的四周随机产生mob。
    添加Path2D节点，命名为MobPath作为Main的child node。在选中Path2D节点时，会显示下图，选中红色框出的选项，并按gif所示操作。
    在这里插入图片描述
    在这里插入图片描述
    现在路径已经定义，那么添加一个PathFollow2D节点作为MobPath的子节点，并将其命名为MobSpawnLocation。该节点将在路径移动时自动旋转并跟随路径，因此我们可以使用它沿路径选择随机位置和方向。
  3. 添加main的脚本：在脚本的顶部，我们使用export（PackedScene）来选择要实例化的Mob场景。
public class Main : Node
{
    // Don't forget to rebuild the project so the editor knows about the new export variable.

	#pragma warning disable 649
	    // We assign this in the editor, so we don't need the warning about not being assigned.
	    [Export]
	    public PackedScene MobScene;
	#pragma warning restore 649

    public int Score;
    public override void _Ready()
	{
	    GD.Randomize();
	}
}

Build后单击Main节点，您将在Inspector中的“Script Variables”看到Mob Scene属性。点击 "[empty]"旁向下的箭头选中 "Load"并选择 Mob.tscn.
然后，选中Scene dock中的Player节点，并确保在Inspectors的Node中选择了“signal”选项卡。
您应该看到Player节点的信号列表。在列表中找到并双击Hit信号（或右键单击并选择“连接…”）。这将打开信号连接对话框。我们想制作一个名为GameOver的新函数，它将处理游戏结束时需要发生的事情。在信号连接对话框底部的“接收器方法”框中键入GameOver，然后单击“连接”。在新函数中添加以下代码，以及一个NewGame函数，该函数将为新游戏设置一切：

public void GameOver()
{
    GetNode<Timer>("MobTimer").Stop();
    GetNode<Timer>("ScoreTimer").Stop();
}

public void NewGame()
{
    Score = 0;

    var player = GetNode<Player>("Player");
    var startPosition = GetNode<Position2D>("StartPosition");
    player.Start(startPosition.Position);

    GetNode<Timer>("StartTimer").Start();
}

现在将每个Timer节点（StartTimer、ScoreTimer和MobTimer）的timeout（）信号连接到主脚本。StartTimer将启动另外两个计时器。ScoreTimer将使分数增加1。

public void OnScoreTimerTimeout()
{
    Score++;
}

public void OnStartTimerTimeout()
{
    GetNode<Timer>("MobTimer").Start();
    GetNode<Timer>("ScoreTimer").Start();
}

在OnMobTimerTimeout（）中，我们将创建一个mob实例，沿着Path2D选择一个随机起始位置，并设置mob的运动。PathFollow2D节点将在沿路径旋转时自动旋转，因此我们将使用它来选择暴徒的方向及其位置。当我们产生一个暴民时，我们会选择一个150.0到250.0之间的随机值来表示每个暴民的移动速度（如果他们都以相同的速度移动，那会很无聊）。

public void OnMobTimerTimeout()
{
    // Note: Normally it is best to use explicit types rather than the `var`
    // keyword. However, var is acceptable to use here because the types are
    // obviously Mob and PathFollow2D, since they appear later on the line.

    // Create a new instance of the Mob scene.
    var mob = (Mob)Mobscene.Instance();

    // Choose a random location on Path2D.
    var mobSpawnLocation = GetNode<PathFollow2D>("MobPath/MobSpawnLocation");
    mobSpawnLocation.Offset = GD.Randi();

    // Set the mob's direction perpendicular to the path direction.
    float direction = mobSpawnLocation.Rotation + Mathf.Pi / 2;

    // Set the mob's position to a random location.
    mob.Position = mobSpawnLocation.Position;

    // Add some randomness to the direction.
    direction += (float)GD.RandRange(-Mathf.Pi / 4, Mathf.Pi / 4);
    mob.Rotation = direction;

    // Choose the velocity.
    var velocity = new Vector2((float)GD.RandRange(150.0, 250.0), 0);
    mob.LinearVelocity = velocity.Rotated(direction);

    // Spawn the mob by adding it to the Main scene.
    AddChild(mob);
}

让我们测试一下场景，确保一切正常。将此NewGame调用添加到_ready（）：

public override void _Ready()
{
    NewGame();
}

让我们还将Main指定为我们的“主场景”——当游戏启动时自动运行的场景。按下“play”按钮，并在提示时选择Main.tscn。
你应该能够移动玩家，看到mob产生，并看到玩家在被暴徒击中时消失。当您确定一切正常时，请从_ready（）中删除对new_game（）的调用。

六、游戏信息显示

  1. 创建一个新场景，并添加一个名为HUD的CanvasLayer根节点。HUD是一种信息显示，显示在游戏视图的顶层。
    在这里插入图片描述
  2. 单击ScoreLabel，然后在Inspector的Text字段中键入一个数字。“控制”节点的默认字体较小，缩放效果不佳。游戏资产中包含一个名为“Xolonium Regular.ttf”的字体文件。要使用此字体，请执行以下操作：
    在Theme overrides > font 下，点[empty]并选择“New DynamicFont”
    在这里插入图片描述
    单击您添加的“DynamicFont”，然后在Font>FontData下，选择“load”并选择“Xolonium Regular.ttf”文件。
    在这里插入图片描述
    在“settings”下设置“size”属性，64效果良好。
    在ScoreLabel上完成此操作后，您可以单击Font属性旁边的向下箭头，然后选择“复制”，然后在其他两个Control节点的同一位置“粘贴”它。
    按如下所示排列节点。单击“布局”按钮设置控制节点的布局：

在这里插入图片描述

在这里插入图片描述
在HUD.cs中添加代码：

public class HUD : CanvasLayer
{
    // Don't forget to rebuild the project so the editor knows about the new signal.

    [Signal]
    public delegate void StartGame();
}

start_game信号告诉Main节点按钮已被按下。

public void ShowMessage(string text)
{
    var message = GetNode<Label>("Message");
    message.Text = text;
    message.Show();

    GetNode<Timer>("MessageTimer").Start();
}

当我们想要临时显示一条消息时，会调用此函数，例如“Get Ready”。当玩家输了时会调用此函数。它将显示“游戏结束”2秒，然后返回标题屏幕，短暂停顿后显示“开始”按钮。

async public void ShowGameOver()
{
    ShowMessage("Game Over");

    var messageTimer = GetNode<Timer>("MessageTimer");
    await ToSignal(messageTimer, "timeout");

    var message = GetNode<Label>("Message");
    message.Text = "Dodge the\nCreeps!";
    message.Show();

    await ToSignal(GetTree().CreateTimer(1), "timeout");
    GetNode<Button>("StartButton").Show();
}

public void UpdateScore(int score)
{
    GetNode<Label>("ScoreLabel").Text = score.ToString();
}
public void OnStartButtonPressed()
{
    GetNode<Button>("StartButton").Hide();
    EmitSignal("StartGame");
}

public void OnMessageTimerTimeout()
{
    GetNode<Label>("Message").Hide();
}
  1. 将HUD连接到Main。
    现在我们已经完成了HUD场景的创建，返回Main。在Main中实例化HUD场景，就像在Player场景中一样。场景树应该是这样的，所以请确保您没有错过任何内容：

在这里插入图片描述
现在我们需要将HUD功能连接到我们的主脚本。这需要在主场景中添加一些内容：在节点选项卡中，通过在“连接信号”窗口的“接收器方法”中键入“NewGame”，将HUD的Start_game信号连接到主节点的NewGame（）函数。
在NewGame（）中，更新分数显示并显示“准备就绪”消息：

var hud = GetNode<HUD>("HUD");
hud.UpdateScore(Score);
hud.ShowMessage("Get Ready!");

在GameOver（）中，我们需要调用相应的HUD函数：

GetNode<HUD>("HUD").ShowGameOver();

最后，将其添加到OnScoreTimerTimeout（）中，以使显示与不断变化的分数保持同步：

GetNode<HUD>("HUD").UpdateScore(Score);

如果你一直玩到“游戏结束”，然后马上开始一个新游戏，上一个游戏的毛骨悚然可能仍然在屏幕上。如果他们在新游戏开始时全部消失，那就更好了。我们只需要一种方法来告诉所有的暴徒离开自己。我们可以通过“群组”功能来实现这一点。
在Mob场景中，选择根节点，然后单击Inspector（与查找节点信号的位置相同）旁边的“节点”选项卡。在“信号”旁边，单击“组”，您可以键入一个新的组名，然后单击“添加”。
现在所有的暴民都将加入“暴民”组。然后，我们可以在Main中的NewGame（）函数中添加以下行：

// Note that for calling Godot-provided methods with strings,
// we have to use the original Godot snake_case name.
GetTree().CallGroup("mobs", "queue_free");

CallGroup（）函数调用组中每个节点上的命名函数——在这种情况下，我们告诉每个mob删除自己。
游戏在这一点上基本完成了。在下一部分也是最后一部分中，我们将通过添加背景、循环音乐和一些键盘快捷键来对其进行润色。

总结

Player场景中的节点:
Player场景中的节点
最终Player.cs中的代码：

using Godot;
using System;

public class Player : Area2D
{
	// Declare member variables here. Examples:
	// private int a = 2;
	// private string b = "text";
	[Signal]
	public delegate void Hit();

	[Export]
	public int Speed { get; set; } = 400; // How fast the player will move (pixels/sec).

	public Vector2 ScreenSize; // Size of the game window.
	
	// Called when the node enters the scene tree for the first time.
	public override void _Ready()
	{
		ScreenSize = GetViewportRect().Size;
		Hide();
	}

//  // Called every frame. 'delta' is the elapsed time since the previous frame.
	public override void _Process(float delta)
	{
		var velocity = Vector2.Zero; //速度矢量初值设为0向量
		if(Input.IsActionPressed("move_right"))
		{
			velocity.x+=1;		
		}
		if(Input.IsActionPressed("move_left"))
		{
			velocity.x-=1;		
		}
		if(Input.IsActionPressed("move_down"))
		{
			velocity.y+=1;		
		}
		if(Input.IsActionPressed("move_up"))
		{
			velocity.y-=1;		
		}

		var animatedSprite = GetNode<AnimatedSprite>("AnimatedSprite");

		if(velocity.Length()>0)
		{
			velocity=velocity.Normalized()*Speed;
			animatedSprite.Play();
		}
		else
		{
			animatedSprite.Stop();
		}
		Position+=velocity *delta;
		Position =new Vector2(
			x:Mathf.Clamp(Position.x,0,ScreenSize.x),
			y:Mathf.Clamp(Position.y,0,ScreenSize.y)
		);
		if(velocity.x != 0)
		{
			animatedSprite.Animation="walk";
			animatedSprite.FlipV=false;
			animatedSprite.FlipH=velocity.x <0;
		}
		else if(velocity.y!=0)
		{
			animatedSprite.Animation="up";
			animatedSprite.FlipV=velocity.y>0;
		}
		
	}
	private void OnPlayerBodyEntered(PhysicsBody2D body)
	{
		// Replace with function body.
		Hide(); // Player disappears after being hit.
		EmitSignal(nameof(Hit));
		// Must be deferred as we can't change physics properties on a physics callback.
		GetNode<CollisionShape2D>("CollisionShape2D").SetDeferred("disabled", true);
	}
	public void Start(Vector2 pos)
	{
		Position = pos;
		Show();
		GetNode<CollisionShape2D>("CollisionShape2D").Disabled = false;
	}
}

mob场景中的节点：
在这里插入图片描述
mob.cs最终的代码：

using Godot;
using System;

public class Mob : RigidBody2D
{
    // Declare member variables here. Examples:
    // private int a = 2;
    // private string b = "text";

    // Called when the node enters the scene tree for the first time.
    public override void _Ready()
    {
        var animSprite = GetNode<AnimatedSprite>("AnimatedSprite");
        animSprite.Playing = true;
        string[] mobTypes = animSprite.Frames.GetAnimationNames();
        animSprite.Animation = mobTypes[GD.Randi() % mobTypes.Length];
    }
    public void OnVisibilityNotifier2DScreenExited()
    {
        QueueFree();
    }
    
//  // Called every frame. 'delta' is the elapsed time since the previous frame.
//  public override void _Process(float delta)
//  {
//      
//  }
}

HUD场景中的节点：
在这里插入图片描述
HUD.cs:

using Godot;
using System;

public class HUD : CanvasLayer
{
    // Declare member variables here. Examples:
    // private int a = 2;
    // private string b = "text";
    [Signal]
    public delegate void StartGame();
    public void ShowMessage(string text)
    {
        var message = GetNode<Label>("Message");
        message.Text = text;
        message.Show();

        GetNode<Timer>("MessageTimer").Start();
    }

    async public void ShowGameOver()
    {
        ShowMessage("Game Over");

        var messageTimer = GetNode<Timer>("MessageTimer");
        await ToSignal(messageTimer, "timeout");

        var message = GetNode<Label>("Message");
        message.Text = "Dodge the\nCreeps!";
        message.Show();

        await ToSignal(GetTree().CreateTimer(1), "timeout");
        GetNode<Button>("StartButton").Show();
    }
    public void UpdateScore(int score)
    {
        GetNode<Label>("ScoreLabel").Text = score.ToString();
    }
    public void OnStartButtonPressed()
    {
        GetNode<Button>("StartButton").Hide();
        EmitSignal("StartGame");
    }

    public void OnMessageTimerTimeout()
    {
        GetNode<Label>("Message").Hide();
    }
    // Called when the node enters the scene tree for the first time.
    public override void _Ready()
    {
        
    }
    
//  // Called every frame. 'delta' is the elapsed time since the previous frame.
//  public override void _Process(float delta)
//  {
//      
//  }
}

Main场景中的节点：
在这里插入图片描述
Main.cs:

using Godot;
using System;

public class Main : Node
{
    // Declare member variables here. Examples:
    // private int a = 2;
    // private string b = "text";
#pragma warning disable 649
    [Export]
    public PackedScene Mobscene;
#pragma warning restore 649
public int Score;
    // Called when the node enters the scene tree for the first time.
    public override void _Ready()
    {
        GD.Randomize();
    }

	public void GameOver()
	{	
        GetNode<Timer>("ScoreTimer").Stop();
		GetNode<Timer>("MobTimer").Stop();
        GetNode<HUD>("HUD").ShowGameOver();
	}

	public void NewGame()
	{
		Score = 0;

		var player = GetNode<Player>("Player");
		var startPosition = GetNode<Position2D>("StartPosition");
		player.Start(startPosition.Position);

		GetNode<Timer>("StartTimer").Start();
        var hud = GetNode<HUD>("HUD");
        hud.UpdateScore(Score);
        hud.ShowMessage("Get Ready!");
        GetTree().CallGroup("mobs", "queue_free");
	} 
    
    
    public void OnStartTimerTimeout()
    {
        GetNode<Timer>("MobTimer").Start();
        GetNode<Timer>("ScoreTimer").Start();
    }

    public void OnScoreTimerTimeout()
    {
        Score++;
        GetNode<HUD>("HUD").UpdateScore(Score);
    }

  

    public void OnMobTimerTimeout()
    {
        // Note: Normally it is best to use explicit types rather than the `var`
        // keyword. However, var is acceptable to use here because the types are
        // obviously Mob and PathFollow2D, since they appear later on the line.

        // Create a new instance of the Mob scene.
        var mob = (Mob)Mobscene.Instance();

        // Choose a random location on Path2D.
        var mobSpawnLocation = GetNode<PathFollow2D>("MobPath/MobSpawnLocation");
        mobSpawnLocation.Offset = GD.Randi();

        // Set the mob's direction perpendicular to the path direction.
        float direction = mobSpawnLocation.Rotation + Mathf.Pi / 2;

        // Set the mob's position to a random location.
        mob.Position = mobSpawnLocation.Position;

        // Add some randomness to the direction.
        direction += (float)GD.RandRange(-Mathf.Pi / 4, Mathf.Pi / 4);
        mob.Rotation = direction;

        // Choose the velocity.
        var velocity = new Vector2((float)GD.RandRange(150.0, 250.0), 0);
        mob.LinearVelocity = velocity.Rotated(direction);

        // Spawn the mob by adding it to the Main scene.
        AddChild(mob);
    }
//  // Called every frame. 'delta' is the elapsed time since the previous frame.
    // public override void _Process(float delta)
    // {
        
    // }
}
# godot # 学习 # c#
Logo
开放原子开发者工作坊

开放原子开发者工作坊旨在鼓励更多人参与开源活动，与志同道合的开发者们相互交流开发经验、分享开发心得、获取前沿技术趋势。工作坊有多种形式的开发者活动，如meetup、训练营等，主打技术交流，干货满满，真诚地邀请各位开发者共同参与！

更多推荐

“源”聚天大，码动未来|开放原子校源行（天津大学站）即将启幕！

11月22日，开放原子校源行（天津大学站）将在天津大学北洋园校区隆重举办。

avatar 开放原子开发者工作坊

openEuler系累计装机量突破1000万，树立操作系统产业新里程碑

11月15日，以“以智能，致世界”为主题的操作系统大会2024在北京中关村国际创新中心召开。

avatar 开放原子开发者工作坊

多模态大模型&科学计算双管齐下，百度飞桨两大赛项报名倒计时！

第二届开放原子大赛是由开放原子开源基金会组织举办的开源技术领域专业赛事，聚焦解决真问题，重点覆盖基础软件、工业软件、人工智能大模型等领域

avatar 开放原子开发者工作坊