Разработка игр на C# в Godot: пошаговое руководство для начинающих

using Godot;
using System;

public partial class MyScript : Node2D
{
// 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(double delta)
{
}
}

public partial class Player : CharacterBody2D
{
// Код класса
}

// В GDScript
var speed = 5 # Тип определяется автоматически

// В C#
private int _speed = 5; // Явное указание типа

[Export] public float Speed { get; set; } = 5.0f;

[Export(PropertyHint.Range, "0,100,1")] 
public int Health { get; set; } = 100;

// Определение сигнала
[Signal] public delegate void HealthChanged(int newHealth);

// Вызов сигнала
EmitSignal(SignalName.HealthChanged, currentHealth);

// Подписка на сигнал (обычно в _Ready)
otherNode.Connect(OtherNode.SignalName.SomethingHappened, Callable.From(OnSomethingHappened));

// Скрипт для узла Sprite2D
public partial class PlayerSprite : Sprite2D
{
// Теперь класс имеет доступ ко всем методам и свойствам Sprite2D
public override void _Ready()
{
// Изменение свойства из базового класса
Texture = ResourceLoader.Load<Texture2D>("res://player.png");
}
}

private Label _scoreLabel;

public override void _Ready()
{
_scoreLabel = GetNode<Label>("UI/ScoreLabel");
_scoreLabel.Text = "Score: 0";
}

[NodePath("UI/ScoreLabel")]
private Label _scoreLabel = null;

public override void _Ready()
{
// Узел уже доступен, нет необходимости в GetNode
_scoreLabel.Text = "Score: 0";
}

// Создание нового узла
Label newLabel = new Label();
newLabel.Text = "Dynamically created!";

// Добавление узла в сцену
AddChild(newLabel);

// Позиционирование (если это узел с пространственными свойствами)
if (newLabel is Control controlLabel)
{
controlLabel.Position = new Vector2(100, 100);
}

// Определение сигнала в классе
[Signal]
public delegate void PlayerDied(Vector2 position, int score);

// Вызов сигнала
EmitSignal(SignalName.PlayerDied, GlobalPosition, _currentScore);

// Подключение к сигналу в другом скрипте
public override void _Ready()
{
var player = GetNode<Player>("Player");
player.Connect(Player.SignalName.PlayerDied, Callable.From(OnPlayerDied));
}

// Обработчик сигнала
private void OnPlayerDied(Vector2 position, int score)
{
ShowGameOver(score);
SpawnExplosion(position);
}

// Добавление узла в группу
public override void _Ready()
{
AddToGroup("enemies");
}

// В другом скрипте: получение всех узлов из группы
private void DestroyAllEnemies()
{
foreach (Node enemy in GetTree().GetNodesInGroup("enemies"))
{
if (enemy is Enemy enemyNode)
{
enemyNode.TakeDamage(999);
}
}
}

public partial class Player : CharacterBody2D
{
[Export] public float Speed { get; set; } = 300.0f;
[Export] public float JumpVelocity { get; set; } = -400.0f;

private float _gravity = ProjectSettings.GetSetting("physics/2d/default_gravity").AsSingle();

public override void _PhysicsProcess(double delta)
{
Vector2 velocity = Velocity;

// Добавляем гравитацию
if (!IsOnFloor())
velocity.Y += _gravity * (float)delta;

// Обрабатываем прыжок
if (Input.IsActionJustPressed("ui_accept") && IsOnFloor())
velocity.Y = JumpVelocity;

// Получаем направление горизонтального движения
Vector2 direction = Input.GetVector("ui_left", "ui_right", "ui_up", "ui_down");
velocity.X = direction.X * Speed;

Velocity = velocity;
MoveAndSlide();
}
}

// Определение предмета
public class Item
{
public string Name { get; set; }
public string Description { get; set; }
public Texture2D Icon { get; set; }
public int MaxStackSize { get; set; } = 1;

public virtual void Use(Player player)
{
// Базовая реализация
GD.Print($"Using item: {Name}");
}
}

// Класс конкретного предмета
public class HealthPotion : Item
{
public int HealAmount { get; set; } = 20;

public override void Use(Player player)
{
player.Heal(HealAmount);
GD.Print($"Healed for {HealAmount} HP");
}
}

// Система инвентаря
public partial class Inventory : Node
{
[Signal] public delegate void InventoryChangedEventHandler();

private List<(Item Item, int Count)> _items = new();
[Export] public int MaxSlots { get; set; } = 20;

public bool AddItem(Item item, int count = 1)
{
// Ищем существующий стек этого предмета
var existingStack = _items.FindIndex(i => i.Item.Name == item.Name && i.Count < i.Item.MaxStackSize);

if (existingStack >= 0)
{
var currentStack = _items[existingStack];
int canAdd = Math.Min(count, currentStack.Item.MaxStackSize – currentStack.Count);

_items[existingStack] = (currentStack.Item, currentStack.Count + canAdd);
count -= canAdd;

if (count <= 0)
{
EmitSignal(SignalName.InventoryChanged);
return true;
}
}

// Если остались предметы или нет подходящего стека, создаем новый
if (_items.Count >= MaxSlots)
return false; // Инвентарь полон

_items.Add((item, count));
EmitSignal(SignalName.InventoryChanged);
return true;
}

public Item GetItem(int slot)
{
if (slot >= 0 && slot < _items.Count)
return _items[slot].Item;
return null;
}

public bool UseItem(int slot, Player player)
{
if (slot >= 0 && slot < _items.Count)
{
var (item, count) = _items[slot];
item.Use(player);

// Удаляем предмет после использования
if (count > 1)
_items[slot] = (item, count – 1);
else
_items.RemoveAt(slot);

EmitSignal(SignalName.InventoryChanged);
return true;
}
return false;
}
}

// Базовый интерфейс состояния
public interface IState
{
void Enter();
void Exit();
void Update(double delta);
void PhysicsUpdate(double delta);
void HandleInput();
}

// Конкретное состояние – бег
public class RunningState : IState
{
private PlayerController _player;

public RunningState(PlayerController player)
{
_player = player;
}

public void Enter()
{
_player.Animator.Play("run");
}

public void Exit()
{
// Очистка при выходе из состояния
}

public void HandleInput()
{
if (Input.IsActionJustPressed("jump") && _player.IsOnFloor())
_player.StateMachine.ChangeState(_player.JumpingState);
else if (Input.GetActionStrength("move_right") == 0 && Input.GetActionStrength("move_left") == 0)
_player.StateMachine.ChangeState(_player.IdleState);
}

public void Update(double delta)
{
// Логика не связанная с физикой
}

public void PhysicsUpdate(double delta)
{
float moveInput = Input.GetActionStrength("move_right") – Input.GetActionStrength("move_left");
_player.Velocity = new Vector2(moveInput * _player.RunSpeed, _player.Velocity.Y);
_player.MoveAndSlide();
}
}

// Машина состояний
public class StateMachine
{
public IState CurrentState { get; private set; }

public void Initialize(IState startingState)
{
CurrentState = startingState;
CurrentState.Enter();
}

public void ChangeState(IState newState)
{
CurrentState.Exit();
CurrentState = newState;
CurrentState.Enter();
}

public void Update(double delta)
{
CurrentState?.HandleInput();
CurrentState?.Update(delta);
}

public void PhysicsUpdate(double delta)
{
CurrentState?.PhysicsUpdate(delta);
}
}

[Tool]
public partial class DialogueResource : Resource
{
[Export] public string SpeakerName { get; set; } = "";
[Export] public string DialogueText { get; set; } = "";
[Export] public Texture2D SpeakerPortrait { get; set; }
[Export] public DialogueResource[] Responses { get; set; } = Array.Empty<DialogueResource>();

// Событие, которое произойдёт при завершении диалога
[Export] public string EventName { get; set; } = "";
}

// Менеджер диалогов
public partial class DialogueManager : CanvasLayer
{
[Export] private NodePath _dialoguePanelPath;
[Export] private NodePath _speakerLabelPath;
[Export] private NodePath _dialogueLabelPath;
[Export] private NodePath _portraitTexturePath;
[Export] private NodePath _responseContainerPath;
[Export] private PackedScene _responseButtonScene;

private Control _dialoguePanel;
private Label _speakerLabel;
private RichTextLabel _dialogueLabel;
private TextureRect _portraitTexture;
private VBoxContainer _responseContainer;

private DialogueResource _currentDialogue;

public override void _Ready()
{
_dialoguePanel = GetNode<Control>(_dialoguePanelPath);
_speakerLabel = GetNode<Label>(_speakerLabelPath);
_dialogueLabel = GetNode<RichTextLabel>(_dialogueLabelPath);
_portraitTexture = GetNode<TextureRect>(_portraitTexturePath);
_responseContainer = GetNode<VBoxContainer>(_responseContainerPath);

_dialoguePanel.Visible = false;
}

public void StartDialogue(DialogueResource dialogue)
{
_currentDialogue = dialogue;
_dialoguePanel.Visible = true;

_speakerLabel.Text = dialogue.SpeakerName;
_dialogueLabel.Text = dialogue.DialogueText;
_portraitTexture.Texture = dialogue.SpeakerPortrait;

// Очищаем предыдущие варианты ответов
foreach (Node child in _responseContainer.GetChildren())
{
child.QueueFree();
}

// Добавляем новые варианты ответов
foreach (var response in dialogue.Responses)
{
var button = _responseButtonScene.Instantiate<Button>();
button.Text = response.DialogueText;
button.Connect("pressed", Callable.From(() => OnResponseSelected(response)));
_responseContainer.AddChild(button);
}

// Если нет вариантов ответов, добавляем кнопку "Продолжить"
if (dialogue.Responses.Length == 0)
{
var button = _responseButtonScene.Instantiate<Button>();
button.Text = "Продолжить";
button.Connect("pressed", Callable.From(() => EndDialogue()));
_responseContainer.AddChild(button);
}
}

private void OnResponseSelected(DialogueResource response)
{
StartDialogue(response);
}

private void EndDialogue()
{
_dialoguePanel.Visible = false;

if (!string.IsNullOrEmpty(_currentDialogue.EventName))
{
EmitSignal(_currentDialogue.EventName);
}
}
}

public partial class Player : CharacterBody2D
{
[Export] public float Speed { get; set; } = 300.0f;
[Export] public PackedScene BulletScene { get; set; }
[Export] public int MaxHealth { get; set; } = 3;

[Signal] public delegate void HealthChangedEventHandler(int health);
[Signal] public delegate void PlayerDiedEventHandler();

private int _health;
private float _shootCooldown = 0.0f;
private const float ShootDelay = 0.2f;

public override void _Ready()
{
_health = MaxHealth;
EmitSignal(SignalName.HealthChanged, _health);
}

public override void _Process(double delta)
{
// Обработка стрельбы
_shootCooldown -= (float)delta;

if (Input.IsActionPressed("shoot") && _shootCooldown <= 0)
{
Shoot();
_shootCooldown = ShootDelay;
}
}

public override void _PhysicsProcess(double delta)
{
// Обработка движения
Vector2 direction = Input.GetVector("move_left", "move_right", "move_up", "move_down");
Velocity = direction * Speed;

MoveAndSlide();

// Ограничиваем движение в пределах экрана
Vector2 viewportSize = GetViewportRect().Size;
Vector2 position = Position;

position.X = Mathf.Clamp(position.X, 0, viewportSize.X);
position.Y = Mathf.Clamp(position.Y, 0, viewportSize.Y);

Position = position;
}

private void Shoot()
{
if (BulletScene != null)
{
var bullet = BulletScene.Instantiate<Bullet>();
GetParent().AddChild(bullet);
bullet.Position = Position + new Vector2(0, -30); // Позиция перед кораблем
bullet.Launch(new Vector2(0, -1)); // Направление вверх
}
}

public void TakeDamage()
{
_health--;
EmitSignal(SignalName.HealthChanged, _health);

if (_health <= 0)
{
Die();
}
else
{
// Визуальный эффект получения урона
var tween = CreateTween();
tween.TweenProperty(this, "modulate", Colors.Red, 0.1f);
tween.TweenProperty(this, "modulate", Colors.White, 0.1f);
}
} 

private void Die()
{
EmitSignal(SignalName.PlayerDied);
QueueFree();
}
}

public partial class Bullet : Area2D
{
[Export] public float Speed { get; set; } = 700.0f;

private Vector2 _direction = Vector2.Up;

public void Launch(Vector2 direction)
{
_direction = direction.Normalized();

// Устанавливаем угол поворота в соответствии с направлением
Rotation = Mathf.Atan2(_direction.Y, _direction.X) + Mathf.Pi/2;
}

public override void _Process(double delta)
{
Position += _direction * Speed * (float)delta;

// Удаление снаряда, если он покинул экран
if (!GetViewportRect().HasPoint(Position))
{
QueueFree();
}
}

private void OnBodyEntered(Node2D body)
{
if (body is Enemy enemy)
{
enemy.Destroy();
QueueFree();
}
}
}

public partial class Enemy : RigidBody2D
{
[Signal] public delegate void EnemyDestroyedEventHandler(int points, Vector2 position);

[Export] public int PointValue { get; set; } = 10;
[Export] public PackedScene ExplosionEffect { get; set; }

public void Destroy()
{
EmitSignal(SignalName.EnemyDestroyed, PointValue, Position);

// Создание эффекта взрыва
if (ExplosionEffect != null)
{
var explosion = ExplosionEffect.Instantiate<Node2D>();
GetParent().AddChild(explosion);
explosion.GlobalPosition = GlobalPosition;
}

QueueFree();
}

private void OnBodyEntered(Node2D body)
{
if (body is Player player)
{
player.TakeDamage();
Destroy();
}
}
}

public partial class Main : Node2D
{
[Export] public PackedScene EnemyScene { get; set; }
[Export] public NodePath ScoreLabelPath { get; set; }
[Export] public NodePath GameOverPanelPath { get; set; }

private Label _scoreLabel;
private Control _gameOverPanel;
private int _score = 0;
private Random _random = new Random();
private double _enemySpawnTime = 0;

public override void _Ready()
{
_scoreLabel = GetNode<Label>(ScoreLabelPath);
_gameOverPanel = GetNode<Control>(GameOverPanelPath);
_gameOverPanel.Visible = false;

// Подключаемся к сигналу от игрока
var player = GetNode<Player>("Player");
player.Connect(Player.SignalName.PlayerDied, Callable.From(OnPlayerDied));

UpdateScoreLabel();
}

public override void _Process(double delta)
{
_enemySpawnTime -= delta;

if (_enemySpawnTime <= 0)
{
SpawnEnemy();
_enemySpawnTime = 1.0 + _random.NextDouble() * 2.0; // Случайный интервал между 1 и 3 секундами
}
}

private void SpawnEnemy()
{
if (EnemyScene != null)
{
var enemy = EnemyScene.Instantiate<Enemy>();
AddChild(enemy);

// Подключаемся к сигналу врага
enemy.Connect(Enemy.SignalName.EnemyDestroyed, Callable.From<int, Vector2>(OnEnemyDestroyed));

// Устанавливаем случайную позицию врага в верхней части экрана
var viewportWidth = GetViewportRect().Size.X;
enemy.Position = new Vector2((float)_random.NextDouble() * viewportWidth, -50);

// Добавляем небольшой случайный импульс
enemy.LinearVelocity = new Vector2((float)(_random.NextDouble() * 100 – 50), (float)(_random.NextDouble() * 100 + 50));
}
}

private void OnEnemyDestroyed(int points, Vector2 position)
{
_score += points;
UpdateScoreLabel();
}

private void UpdateScoreLabel()
{
_scoreLabel.Text = $"Score: {_score}";
}

private void OnPlayerDied()
{
_gameOverPanel.Visible = true;
GetTree().Paused = true; // Останавливаем игру
}

public void OnRestartButtonPressed()
{
GetTree().Paused = false; // Возобновляем игру
GetTree().ReloadCurrentScene(); // Перезагружаем текущую сцену
}

public void OnMainMenuButtonPressed()
{
GetTree().Paused = false; // Возобновляем игру
GetTree().ChangeSceneToFile("res://MainMenu.tscn"); // Переходим в главное меню
}
}

public partial class UI : CanvasLayer
{
[Export] public NodePath HealthContainerPath { get; set; }
[Export] public Texture2D HealthIconTexture { get; set; }

private HBoxContainer _healthContainer;

public override void _Ready()
{
_healthContainer = GetNode<HBoxContainer>(HealthContainerPath);

// Подключаемся к сигналу изменения здоровья игрока
var player = GetTree().GetFirstNodeInGroup("Player") as Player;
if (player != null)
{
player.Connect(Player.SignalName.HealthChanged, Callable.From<int>(UpdateHealthDisplay));
UpdateHealthDisplay(player.MaxHealth); // Инициализация начального отображения
}
}

private void UpdateHealthDisplay(int health)
{
// Удаляем все существующие иконки здоровья
foreach (var child in _healthContainer.GetChildren())
{
child.QueueFree();
}

// Добавляем новые иконки в соответствии с текущим здоровьем
for (int i = 0; i < health; i++)
{
var healthIcon = new TextureRect
{
Texture = HealthIconTexture,
StretchMode = TextureRect.StretchModeEnum.KeepAspect,
CustomMinimumSize = new Vector2(30, 30)
};

_healthContainer.AddChild(healthIcon);
}
}
}

public partial class MainMenu : Control
{
public void OnStartButtonPressed()
{
GetTree().ChangeSceneToFile("res://Main.tscn");
}

public void OnQuitButtonPressed()
{
GetTree().Quit();
}
}