跳至主要內容

6. 小兵与防御塔

EVOCOSMOS2026/4/15大约 7 分钟

6. 小兵与防御塔：战场的推进力量

6.1 小兵系统概述

小兵（Minion）是 MOBA 游戏中最基础的战斗单位。它们定时从基地出发，沿着三条路前进，自动攻击遇到的敌人。小兵是游戏经济的核心来源——"补刀"（给小兵最后一击）是玩家获取金币的主要方式。

小兵属性

属性近战小兵远程小兵炮车
生命值400280800
攻击力122040
攻击速度1.00.80.6
移动速度3.53.53.0
攻击范围1.55.05.0
击杀金币201540

刷兵规则

每 30 秒刷新一波小兵，从双方基地同时出发。每波小兵的组成：

游戏时间每波组成
0:00 - 5:003 近战 + 1 远程
5:00 - 15:003 近战 + 2 远程
15:00 之后3 近战 + 2 远程 + 1 炮车

6.2 小兵生成器

C#
// MinionSpawner.cs
using Godot;

public partial class MinionSpawner : Node
{
    [Export] public int TeamId { get; set; } = 0; // 0=蓝方, 1=红方
    [Export] public float SpawnInterval { get; set; } = 30.0f;

    private float _timer;
    private float _gameTime;
    private LaneManager _laneManager;
    private PackedScene _meleeScene;
    private PackedScene _rangedScene;
    private PackedScene _siegeScene;

    public override void _Ready()
    {
        _laneManager = GetNode<LaneManager>("/root/Main/World/LaneManager");
        _meleeScene = GD.Load<PackedScene>("res://scenes/units/minion_melee.tscn");
        _rangedScene = GD.Load<PackedScene>("res://scenes/units/minion_ranged.tscn");
        _siegeScene = GD.Load<PackedScene>("res://scenes/units/minion_siege.tscn");
    }

    public override void _Process(double delta)
    {
        _gameTime += (float)delta;
        _timer += (float)delta;

        if (_timer >= SpawnInterval)
        {
            _timer = 0;
            SpawnWave();
        }
    }

    private void SpawnWave()
    {
        string[] lanes = { "top", "mid", "bot" };
        foreach (var lane in lanes)
        {
            var lanePath = _laneManager.GetLane(lane);
            if (lanePath == null) continue;

            var waypoints = TeamId == 0
                ? lanePath.BlueWaypoints
                : lanePath.RedWaypoints;

            if (waypoints == null || waypoints.Length == 0) continue;

            Vector3 spawnPos = waypoints[0];

            // 根据游戏时间决定出兵组成
            SpawnMinion(_meleeScene, spawnPos, lane, waypoints, 3);
            SpawnMinion(_rangedScene, spawnPos, lane, waypoints, 2);

            if (_gameTime > 900) // 15分钟后出炮车
            {
                SpawnMinion(_siegeScene, spawnPos, lane, waypoints, 1);
            }
        }
    }

    private void SpawnMinion(PackedScene scene, Vector3 pos,
        string lane, Vector3[] waypoints, int count)
    {
        for (int i = 0; i < count; i++)
        {
            var minion = scene.Instantiate<Node3D>();
            // 稍微偏移一下，避免重叠
            minion.Position = pos + new Vector3(
                (float)GD.RandRange(-1, 1), 0,
                (float)GD.RandRange(-1, 1));
            minion.Set("team_id", TeamId);
            minion.Set("lane_name", lane);
            minion.Set("waypoints", waypoints);

            GetTree().Root.GetNode("Main/World/Units").AddChild(minion);
        }
    }
}

6.3 小兵 AI

小兵的 AI 逻辑很简单：沿路线前进 → 看到敌人就打 → 打完继续走。

C#
// Minion.cs
using Godot;

public partial class Minion : CharacterBody3D
{
    public int TeamId { get; set; }
    public string LaneName { get; set; }
    public Vector3[] Waypoints { get; set; }
    private int _currentWaypoint = 0;
    private Node3D _target;
    private float _hp;
    private float _maxHp;
    private float _attackDamage;
    private float _attackRange;
    private float _attackCooldown;
    private float _attackTimer;
    private float _moveSpeed = 3.5f;

    public override void _Ready()
    {
        AddToGroup("minions");
        AddToGroup(TeamId == 0 ? "blue_units" : "red_units");

        _attackTimer = 0;
        _currentWaypoint = 1; // 从第一个路径点之后开始
    }

    public override void _PhysicsProcess(double delta)
    {
        _attackTimer -= (float)delta;

        // 查找最近的敌方单位
        _target = FindNearestEnemy();

        if (_target != null)
        {
            var dist = GlobalPosition.DistanceTo(_target.GlobalPosition);
            if (dist <= _attackRange)
            {
                // 在攻击范围内，停下来打
                if (_attackTimer <= 0)
                {
                    Attack();
                    _attackTimer = _attackCooldown;
                }
            }
            else
            {
                // 不在范围内，走向目标
                MoveTo(_target.GlobalPosition, (float)delta);
            }
        }
        else
        {
            // 没有敌人，沿路线前进
            FollowWaypoints((float)delta);
        }
    }

    private void FollowWaypoints(float delta)
    {
        if (_currentWaypoint >= Waypoints.Length) return;

        var target = Waypoints[_currentWaypoint];
        var dist = GlobalPosition.DistanceTo(target);

        if (dist < 1.0f)
        {
            _currentWaypoint++;
            return;
        }

        MoveTo(target, delta);
    }

    private void MoveTo(Vector3 target, float delta)
    {
        var direction = (target - GlobalPosition).Normalized();
        Velocity = new Vector3(direction.X * _moveSpeed, 0, direction.Z * _moveSpeed);
        LookAt(new Vector3(target.X, GlobalPosition.Y, target.Z), Vector3.Up);
        MoveAndSlide();
    }

    private void Attack()
    {
        if (_target != null && _target.HasMethod("TakeDamage"))
        {
            _target.Call("TakeDamage", _attackDamage, "physical", this);
        }
    }

    private Node3D FindNearestEnemy()
    {
        Node3D nearest = null;
        float minDist = _attackRange * 3; // 搜索范围为攻击范围的3倍

        foreach (var node in GetTree().GetNodesInGroup("units"))
        {
            var unit = node as Node3D;
            if (unit == null || unit == this) continue;

            // 检查是否敌方
            int unitTeam = (int)unit.Get("team_id");
            if (unitTeam == TeamId) continue;

            var dist = GlobalPosition.DistanceTo(unit.GlobalPosition);
            if (dist < minDist)
            {
                minDist = dist;
                nearest = unit;
            }
        }

        return nearest;
    }

    public void TakeDamage(float damage, string type, Node3D source)
    {
        _hp -= damage;
        if (_hp <= 0)
        {
            // 死亡：给击杀者金币
            if (source != null && source.IsInGroup("heroes"))
            {
                source.Call("GainGold", 20);
                source.Call("GainExp", 30);
            }
            QueueFree();
        }
    }
}

6.4 防御塔系统

防御塔是 MOBA 游戏的战略核心。推掉对方的塔，你的小兵才能继续前进。

防御塔属性

属性外塔内塔高地塔水晶
生命值3000350040005000
攻击力150180200150
攻击范围8.08.59.07.0
攻击速度0.830.830.830.83
护甲506080100

防御塔目标优先级

防御塔按以下顺序选择攻击目标：

1. 正在攻击己方英雄的敌方英雄（最高优先级）
2. 距离最近的敌方小兵
3. 距离最近的敌方英雄
4. 距离最近的敌方召唤物
C#
// Tower.cs
using Godot;
using System.Collections.Generic;
using System.Linq;

public partial class Tower : StaticBody3D
{
    [Export] public int TeamId { get; set; }
    [Export] public string TowerType { get; set; } = "outer"; // outer, inner, base, crystal
    [Export] public float AttackRange { get; set; } = 8.0f;
    [Export] public float AttackDamage { get; set; } = 150;
    [Export] public float AttackCooldown { get; set; } = 1.2f;
    [Export] public float MaxHp { get; set; } = 3000;

    private float _hp;
    private float _attackTimer;
    private Node3D _currentTarget;
    private bool _isDestroyed;

    public override void _Ready()
    {
        _hp = MaxHp;
        _attackTimer = 0;
        AddToGroup("towers");
        AddToGroup(TeamId == 0 ? "blue_units" : "red_units");
    }

    public override void _Process(double delta)
    {
        if (_isDestroyed) return;

        _attackTimer -= (float)delta;

        if (_attackTimer <= 0)
        {
            _currentTarget = SelectTarget();
            if (_currentTarget != null)
            {
                FireAtTarget();
                _attackTimer = AttackCooldown;
            }
        }
    }

    // 防御塔目标选择（按优先级）
    private Node3D SelectTarget()
    {
        var enemiesInRange = GetEnemiesInRange();
        if (enemiesInRange.Count == 0) return null;

        // 优先级1：正在攻击己方英雄的敌方英雄
        var attackingHero = enemiesInRange
            .FirstOrDefault(e => e.IsInGroup("heroes") && IsAttackingAllyHero(e));

        if (attackingHero != null) return attackingHero;

        // 优先级2：距离最近的小兵
        var nearestMinion = enemiesInRange
            .Where(e => e.IsInGroup("minions"))
            .OrderBy(e => GlobalPosition.DistanceTo(e.GlobalPosition))
            .FirstOrDefault();

        if (nearestMinion != null) return nearestMinion;

        // 优先级3：距离最近的英雄
        var nearestHero = enemiesInRange
            .Where(e => e.IsInGroup("heroes"))
            .OrderBy(e => GlobalPosition.DistanceTo(e.GlobalPosition))
            .FirstOrDefault();

        return nearestHero;
    }

    private List<Node3D> GetEnemiesInRange()
    {
        var result = new List<Node3D>();
        var spaceState = GetWorld3D().DirectSpaceState;
        var shape = new SphereShape3D();
        shape.Radius = AttackRange;
        var query = new PhysicsShapeQueryParameters3D();
        query.Shape = shape;
        query.Transform = new Transform3D(Basis.Identity, GlobalPosition);

        var intersections = spaceState.IntersectShape(query);
        foreach (var dict in intersections)
        {
            var collider = dict["collider"].AsGodotObject() as Node3D;
            if (collider != null && collider != this)
            {
                int unitTeam = (int)collider.Get("team_id");
                if (unitTeam != TeamId)
                    result.Add(collider);
            }
        }
        return result;
    }

    private void FireAtTarget()
    {
        // 创建塔的攻击弹道
        var projectileScene = GD.Load<PackedScene>("res://scenes/effects/tower_projectile.tscn");
        var projectile = projectileScene.Instantiate<Node3D>();
        projectile.Position = GlobalPosition + Vector3.Up * 3; // 从塔顶发射
        GetTree().Root.AddChild(projectile);

        if (projectile.HasMethod("Launch"))
        {
            projectile.Call("Launch", _currentTarget.GlobalPosition,
                15.0f, AttackDamage, "physical", this, TeamId);
        }
    }

    public void TakeDamage(float damage, string type, Node3D source)
    {
        if (_isDestroyed) return;
        _hp -= damage;

        if (_hp <= 0)
        {
            Destroy();
        }
    }

    private void Destroy()
    {
        _isDestroyed = true;

        // 给对方英雄金币奖励
        foreach (var node in GetTree().GetNodesInGroup("heroes"))
        {
            var hero = node as Node3D;
            if (hero != null && (int)hero.Get("team_id") != TeamId)
            {
                hero.Call("GainGold", 150);
                hero.Call("GainExp", 200);
            }
        }

        // 播放摧毁特效
        // TODO: 添加爆炸特效

        // 变成残骸（不可攻击但视觉上可见）
        // 实际项目中可以切换模型
        SetPhysicsProcess(false);
    }

    private bool IsAttackingAllyHero(Node3D enemy)
    {
        // 简化实现：检查敌人是否正在攻击范围内有己方英雄
        // 实际实现需要检查敌人的攻击目标
        return false;
    }
}

章节导航

上一章下一章
← 5. 战斗与技能系统7. 装备与经济系统 →
最近更新:
贡献者: bobokaka
EVOCOSMOS
Copyright © 2026 EVOCOSMOS