编写玩家代码

在这一课中，我们将添加玩家的动作、动画，并将其设置为检测碰撞。

现在我们需要添加一些内置节点所不具备的功能，因此要添加一个脚本。点击 Player 节点然后点击“附加脚本”按钮：

../../_images/add_script_button.png

在脚本设置窗口中，你可以维持默认设置。点击“创建”即可：

备注

如果你要创建 C# 脚本或者其他语言的脚本，那就在创建之前在语言下拉菜单中选择语言。

../../_images/attach_node_window.png

备注

如果这是你第一次接触 GDScript，请在继续之前阅读 脚本语言。

首先声明该对象将需要的成员变量：

GDScriptC#C++

  1. extends Area2D
  3. export var speed = 400 # How fast the player will move (pixels/sec).
  4. var screen_size # Size of the game window.
  1. using Godot;
  2. using System;
  4. public class Player : Area2D
  5. {
  6.     [Export]
  7.     public int Speed = 400; // How fast the player will move (pixels/sec).
  9.     public Vector2 ScreenSize; // Size of the game window.
  10. }
  1. // A `player.gdns` file has already been created for you. Attach it to the Player node.
  3. // Create two files `player.cpp` and `player.hpp` next to `entry.cpp` in `src`.
  4. // This code goes in `player.hpp`. We also define the methods we'll be using here.
  5. #ifndef PLAYER_H
  6. #define PLAYER_H
  8. #include <AnimatedSprite.hpp>
  9. #include <Area2D.hpp>
  10. #include <CollisionShape2D.hpp>
  11. #include <Godot.hpp>
  12. #include <Input.hpp>
  14. class Player : public godot::Area2D {
  15.     GODOT_CLASS(Player, godot::Area2D)
  17.     godot::AnimatedSprite *_animated_sprite;
  18.     godot::CollisionShape2D *_collision_shape;
  19.     godot::Input *_input;
  20.     godot::Vector2 _screen_size; // Size of the game window.
  22. public:
  23.     real_t speed = 400; // How fast the player will move (pixels/sec).
  25.     void _init() {}
  26.     void _ready();
  27.     void _process(const double p_delta);
  28.     void start(const godot::Vector2 p_position);
  29.     void _on_Player_body_entered(godot::Node2D *_body);
  31.     static void _register_methods();
  32. };
  34. #endif // PLAYER_H

在第一个变量 speed 上使用 export 关键字，这样我们就可以在“检查器”中设置其值。对于希望能够像节点的内置属性一样进行调整的值，这可能很方便。点击 Player 节点，您将看到该属性现在显示在“检查器”的“Script Variables”（脚本变量）部分。请记住，如果您在此处更改值，它将覆盖脚本中所写的值。

警告

如果使用的是 C#，则每当要查看新的导出变量或信号时，都需要（重新）构建项目程序集。点击编辑器窗口底部的“Mono”一词以显示 Mono 面板，然后单击“构建项目”按钮，即可手动触发构建。

../../_images/export_variable.png

当节点进入场景树时，_ready() 函数被调用，这是查看游戏窗口大小的好时机：

GDScriptC#C++

  1. func _ready():
  2.     screen_size = get_viewport_rect().size
  1. public override void _Ready()
  2. {
  3.     ScreenSize = GetViewportRect().Size;
  4. }
  1. // This code goes in `player.cpp`.
  2. #include "player.hpp"
  4. void Player::_ready() {
  5.     _animated_sprite = get_node<godot::AnimatedSprite>("AnimatedSprite");
  6.     _collision_shape = get_node<godot::CollisionShape2D>("CollisionShape2D");
  7.     _input = godot::Input::get_singleton();
  8.     _screen_size = get_viewport_rect().size;
  9. }

现在我们可以使用 _process() 函数定义玩家将执行的操作。_process() 在每一帧都被调用，因此我们将使用它来更新我们希望会经常变化的游戏元素。对于玩家而言，我们需要执行以下操作：

  • 检查输入。

  • 沿给定方向移动。

  • 播放合适的动画。

首先，我们需要检查输入——玩家是否正在按键？对于这个游戏，我们有 4 个方向的输入要检查。输入动作在项目设置中的“输入映射”下定义。在这里，您可以定义自定义事件，并为其分配不同的按键、鼠标事件、或者其他输入。对于此游戏，我们将把方向键映射给四个方向。

点击项目 -> 项目设置打开项目设置窗口，然后单击顶部的键位映射选项卡。在顶部栏中键入“move_right”，然后单击“添加”按钮以添加该 move_right 动作。

../../_images/input-mapping-add-action.png

我们需要给这个动作指定一个键。点击右边的“+”图标，然后点击下拉菜单中的“按键”选项。会有一个对话框要求你键入所需的键。按键盘上的右箭头键，然后点击“确定”。

../../_images/input-mapping-add-key.png

重复这些步骤以再添加三个映射：

  1. move_left 映射到左箭头键。

  2. move_up 映射到向上箭头键。

  3. move_down 映射到向下箭头键。

按键映射选项卡应该看起来类似这样：

../../_images/input-mapping-completed.png

单击“关闭”按钮关闭项目设置。

备注

我们只将一个键映射到每个输入动作，但你可以将多个键、操纵杆按钮或鼠标按钮映射到同一个输入动作。

您可以使用 Input.is_action_pressed() 来检测是否按下了键, 如果按下会返回 true, 否则返回 false .

GDScriptC#C++

  1. func _process(delta):
  2.     var velocity = Vector2.ZERO # The player's movement vector.
  3.     if Input.is_action_pressed("move_right"):
  4.         velocity.x += 1
  5.     if Input.is_action_pressed("move_left"):
  6.         velocity.x -= 1
  7.     if Input.is_action_pressed("move_down"):
  8.         velocity.y += 1
  9.     if Input.is_action_pressed("move_up"):
  10.         velocity.y -= 1
  12.     if velocity.length() > 0:
  13.         velocity = velocity.normalized() * speed
  14.         $AnimatedSprite.play()
  15.     else:
  16.         $AnimatedSprite.stop()
  1. public override void _Process(float delta)
  2. {
  3.     var velocity = Vector2.Zero; // The player's movement vector.
  5.     if (Input.IsActionPressed("move_right"))
  6.     {
  7.         velocity.x += 1;
  8.     }
  10.     if (Input.IsActionPressed("move_left"))
  11.     {
  12.         velocity.x -= 1;
  13.     }
  15.     if (Input.IsActionPressed("move_down"))
  16.     {
  17.         velocity.y += 1;
  18.     }
  20.     if (Input.IsActionPressed("move_up"))
  21.     {
  22.         velocity.y -= 1;
  23.     }
  25.     var animatedSprite = GetNode<AnimatedSprite>("AnimatedSprite");
  27.     if (velocity.Length() > 0)
  28.     {
  29.         velocity = velocity.Normalized() * Speed;
  30.         animatedSprite.Play();
  31.     }
  32.     else
  33.     {
  34.         animatedSprite.Stop();
  35.     }
  36. }
  1. // This code goes in `player.cpp`.
  2. void Player::_process(const double p_delta) {
  3.     godot::Vector2 velocity(0, 0);
  5.     velocity.x = _input->get_action_strength("move_right") - _input->get_action_strength("move_left");
  6.     velocity.y = _input->get_action_strength("move_down") - _input->get_action_strength("move_up");
  8.     if (velocity.length() > 0) {
  9.         velocity = velocity.normalized() * speed;
  10.         _animated_sprite->play();
  11.     } else {
  12.         _animated_sprite->stop();
  13.     }
  14. }

我们首先将 velocity 设置为 (0, 0)——默认情况下玩家不应该移动。然后我们检查每个输入并从 velocity 中进行加/减以获得总方向。例如，如果您同时按住 右 和 下，则生成的 velocity 向量将为 (1, 1)。此时，由于我们同时向水平和垂直两个方向进行移动，玩家斜向移动的速度将会比水平移动要更快。

只要对速度进行归一化就可以防止这种情况，也就是将速度的长度设置为 1，然后乘以想要的速度。这样就不会有过快的斜向运动了。

小技巧

如果您以前从未使用过向量数学，或者需要复习，可以在 Godot 中的 向量数学 上查看向量用法的解释。最好了解一下，但对于本教程的其余部分而言，这不是必需的。

我们也要检查玩家是否在移动，以便在 AnimatedSprite 上调用 play() 或 stop()。

小技巧

$ 是 get_node() 的简写。因此在上面的代码中，$AnimatedSprite.play() 与 get_node("AnimatedSprite").play() 相同。

在 GDScript 中，$ 返回相对于当前节点路径处的节点，如果找不到该节点，则返回 null。由于 AnimatedSprite 是当前节点的子项，因此我们可以使用 $AnimatedSprite。

现在我们有了一个运动方向，我们可以更新玩家的位置了。我们也可以使用 clamp() 来防止它离开屏幕。 clamp 一个值意味着将其限制在给定范围内。将以下内容添加到 _process 函数的底部：

GDScriptC#C++

  1. position += velocity * delta
  2. position.x = clamp(position.x, 0, screen_size.x)
  3. position.y = clamp(position.y, 0, screen_size.y)
  1. Position += velocity * delta;
  2. Position = new Vector2(
  3.     x: Mathf.Clamp(Position.x, 0, ScreenSize.x),
  4.     y: Mathf.Clamp(Position.y, 0, ScreenSize.y)
  5. );
  1. godot::Vector2 position = get_position();
  2. position += velocity * (real_t)p_delta;
  3. position.x = godot::Math::clamp(position.x, (real_t)0.0, _screen_size.x);
  4. position.y = godot::Math::clamp(position.y, (real_t)0.0, _screen_size.y);
  5. set_position(position);

小技巧

_process() 函数的 delta 参数是 帧长度 ——完成上一帧所花费的时间. 使用这个值的话, 可以保证你的移动不会被帧率的变化所影响.

点击“运行场景”（F6，macOS 上为 Cmd + R）并确认您能够在屏幕中沿任一方向移动玩家。

警告

如果在“调试器”面板中出现错误

Attempt to call function 'play' in base 'null instance' on a null instance（尝试调用空实例在基类“空实例”上的“play”函数）

这可能意味着您拼错了 AnimatedSprite节点的名称。节点名称区分大小写，并且 $NodeName 必须与您在场景树中看到的名称匹配。

选择动画

现在玩家可以移动了，我们需要根据方向更改 AnimatedSprite 所播放的动画。我们的“walk”动画显示的是玩家向右走。向左移动时就应该使用 flip_h 属性将这个动画进行水平翻转。我们还有向上的“up”动画，向下移动时就应该使用 flip_v 将其进行垂直翻转。让我们把这段代码放在 _process() 函数的末尾：

GDScriptC#C++

  1. if velocity.x != 0:
  2.     $AnimatedSprite.animation = "walk"
  3.     $AnimatedSprite.flip_v = false
  4.     # See the note below about boolean assignment.
  5.     $AnimatedSprite.flip_h = velocity.x < 0
  6. elif velocity.y != 0:
  7.     $AnimatedSprite.animation = "up"
  8.     $AnimatedSprite.flip_v = velocity.y > 0
  1. if (velocity.x != 0)
  2. {
  3.     animatedSprite.Animation = "walk";
  4.     animatedSprite.FlipV = false;
  5.     // See the note below about boolean assignment.
  6.     animatedSprite.FlipH = velocity.x < 0;
  7. }
  8. else if (velocity.y != 0)
  9. {
  10.     animatedSprite.Animation = "up";
  11.     animatedSprite.FlipV = velocity.y > 0;
  12. }
  1. if (velocity.x != 0) {
  2.     _animated_sprite->set_animation("walk");
  3.     _animated_sprite->set_flip_v(false);
  4.     // See the note below about boolean assignment.
  5.     _animated_sprite->set_flip_h(velocity.x < 0);
  6. } else if (velocity.y != 0) {
  7.     _animated_sprite->set_animation("up");
  8.     _animated_sprite->set_flip_v(velocity.y > 0);
  9. }

备注

上面代码中的布尔赋值是程序员常用的缩写. 在做布尔比较同时, 同时可 赋 一个布尔值. 参考这段代码与上面的单行布尔赋值:

GDScriptC#

  1. if velocity.x < 0:
  2.     $AnimatedSprite.flip_h = true
  3. else:
  4.     $AnimatedSprite.flip_h = false
  1. if (velocity.x < 0)
  2. {
  3.     animatedSprite.FlipH = true;
  4. }
  5. else
  6. {
  7.     animatedSprite.FlipH = false;
  8. }

再次播放场景并检查每个方向上的动画是否正确.

小技巧

这里一个常见错误是打错了动画的名字。“动画帧”面板中的动画名称必须与在代码中键入的内容匹配。如果你将动画命名成了 "Walk"，就必须在代码中也使用大写的“W”。

当您确定移动正常工作时， 请将此行添加到 _ready() 中，在游戏开始时隐藏玩家：

GDScriptC#C++

  1. hide()
  1. Hide();
  1. hide();

准备碰撞

我们希望 Player 能够检测到何时被敌人击中, 但是我们还没有任何敌人！没关系, 因为我们将使用Godot的 信号 功能来使其正常工作.

在脚本开头, extends Area2d 下添加:

GDScriptC#C++

  1. signal hit
  1. // Don't forget to rebuild the project so the editor knows about the new signal.
  3. [Signal]
  4. public delegate void Hit();
  1. // This code goes in `player.cpp`.
  2. // We need to register the signal here, and while we're here, we can also
  3. // register the other methods and register the speed property.
  4. void Player::_register_methods() {
  5.     godot::register_method("_ready", &Player::_ready);
  6.     godot::register_method("_process", &Player::_process);
  7.     godot::register_method("start", &Player::start);
  8.     godot::register_method("_on_Player_body_entered", &Player::_on_Player_body_entered);
  9.     godot::register_property("speed", &Player::speed, (real_t)400.0);
  10.     // This below line is the signal.
  11.     godot::register_signal<Player>("hit", godot::Dictionary());
  12. }

这定义了一个叫作“hit”的自定义信号，当玩家与敌人碰撞时，我们会让他发出这个信号。我们将使用 Area2D 来检测碰撞。选中 Player 节点，然后点击“检查器”选项卡旁边的“节点”选项卡，就可以查看玩家可以发出的信号列表：

../../_images/player_signals.png

请注意自定义的“hit”信号也在其中！由于敌人将是 RigidBody2D 节点，所以需要 body_entered(body: Node) 信号。当物体接触到玩家时就会发出这个信号。点击“连接…”就会出现“连接信号”窗口。不需要改变这些设置，再次点击“连接”，Godot 会自动在你的玩家脚本中创建一个函数。

../../_images/player_signal_connection.png

请注意函数名旁的绿色图标, 这表示信号已经连接到这个函数. 将以下代码添加到函数体中:

GDScriptC#C++

  1. func _on_Player_body_entered(body):
  2.     hide() # Player disappears after being hit.
  3.     emit_signal("hit")
  4.     # Must be deferred as we can't change physics properties on a physics callback.
  5.     $CollisionShape2D.set_deferred("disabled", true)
  1. public void OnPlayerBodyEntered(PhysicsBody2D body)
  2. {
  3.     Hide(); // Player disappears after being hit.
  4.     EmitSignal(nameof(Hit));
  5.     // Must be deferred as we can't change physics properties on a physics callback.
  6.     GetNode<CollisionShape2D>("CollisionShape2D").SetDeferred("disabled", true);
  7. }
  1. // This code goes in `player.cpp`.
  2. void Player::_on_Player_body_entered(godot::Node2D *_body) {
  3.     hide(); // Player disappears after being hit.
  4.     emit_signal("hit");
  5.     // Must be deferred as we can't change physics properties on a physics callback.
  6.     _collision_shape->set_deferred("disabled", true);
  7. }

敌人每次击中 玩家时都会发出一个信号。我们需要禁用玩家的碰撞检测，确保我们不会多次触发 hit 信号。

备注

如果在引擎的碰撞处理过程中禁用区域的碰撞形状可能会导致错误。使用 set_deferred() 告诉 Godot 等待可以安全地禁用形状时再这样做。

最后再为玩家添加一个函数，用于在开始新游戏时调用来重置玩家。

GDScriptC#C++

  1. func start(pos):
  2.     position = pos
  3.     show()
  4.     $CollisionShape2D.disabled = false
  1. public void Start(Vector2 pos)
  2. {
  3.     Position = pos;
  4.     Show();
  5.     GetNode<CollisionShape2D>("CollisionShape2D").Disabled = false;
  6. }
  1. // This code goes in `player.cpp`.
  2. void Player::start(const godot::Vector2 p_position) {
  3.     set_position(p_position);
  4.     show();
  5.     _collision_shape->set_disabled(false);
  6. }

在玩家部分的工作完成后，我们将在下一课中研究敌人。