基于Unity3D的塔防游戏

已于 2023-08-18 16:03:26 修改
阅读量3.2k 收藏 16
点赞数 7
分类专栏： 实训 文章标签： 游戏 游戏开发 unity3d c#
于 2020-04-11 11:20:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46237892/article/details/105448588
版权

课题主要内容

设计建议塔防游戏，实现规定敌人移动路线，在塔的基座的基础上升级塔、卖掉塔、更换塔，来射击敌人。
要求：1、基于c#编程语言实现；
2、发射子弹攻击敌人；
记录分数，判定游戏成功与否。

课题研究方案

基于Android平台进行开发，开发工具使用Unity3D 3.7 、 PhotoshopCS6、Visual Studio 2019。
游戏UI设计与制作主要用PhotoshopCS6,包括游戏场景的背景、个性化按钮、游戏信息的显示等贴图。
游戏的模型建立使用Unity3D 开发工具，包括地图制作、环境制作、粒子效果、模型的物理特性等。
游戏中最核心部分脚本代码的编写需要使用Visual Studio 2019编辑工具，代码的语言选用比较简单易操作的C#语言。将脚本指定给游戏模型，再将各种类型参数连接，完成游戏设计方案

功能要求

此为塔防游戏,即地图一端会自动产生敌人到另一端,在中间部位玩家可按照自己的思路放置炮塔来阻击敌人的前进,一旦炮塔的放置位置不对,或者所选择的炮塔攻击力不够的话,便阻止不了敌人的前进,那么敌人很容易就能逃脱,玩家便输了。所以这类策略游戏不仅可以使玩家娱乐,还能使玩家的智力得到很好地提升,为此,要求此游戏要给玩家尽量大的个人发挥空间。

游戏描述

1.敌人从地图的一端进入，经过某个特定的路径后最终达到目的地（通常是地图相反的一端）。
2.玩家沿着路径放置一些防御炮塔，在敌人经过时朝他们开火。敌人一波一波的过来，玩家需要不断放置更多的防御工事，同时升级这些炮塔。
3.要赢得游戏，玩家得挺过1分钟，并且得分大于等于200分。
4.本游戏设计只设置玩家得分和游戏时间，而不设置宝物。并且本游戏中的关卡不会在此体现出来，不同关卡知识地图不同，开始时系统排出的出兵方式不同，其他都一样。故只对一个关卡进行分析。

游戏场景

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

GameController模块

public class GameController : MonoBehaviour
{
    public static bool GameIsOver;
    void Start()
    {
        GameIsOver = false;
    }
    void Update()
    {
        if (GameIsOver)
        {
            return;
        }
        if (Convert.ToInt16(Time.time) == 60)
        {
            if (Bullet.grade >= 200)
            {
                GameReturn();
            }
            else
            {
                GameEnd();
            }
        }
    }
    private void GameEnd()
    {
        GameIsOver = true;
        Global.GetInstance().GetEvent().Invoke(EventEnum.failureMenu, gameObject);
        Time.timeScale = 0;
    }
    private void GameReturn()
    {
        Global.GetInstance().GetEvent().Invoke(EventEnum.successMenu, gameObject);
        Time.timeScale = 0;
    }
}

Enemy模块

public class diren : MonoBehaviour
{
    public GameObject pathObject;
    public GameObject enemyPrefab;
    public GameObject enemy;
private float currentAddEnemyTime = 0.0f;
    public float addEnemyDutacion = 0.0f;
    private ObjectPool enemyPool = new ObjectPool();
    private List<GameObject> enemyList = new List<GameObject>();
    void Start()
    {
        for(int i = 0;i < 10;i++)
        {
            GameObject enemy = this.CreateEnemy();
            enemyPool.PushObject(enemy);
        }
        Global.GetInstance().SetEnemyController(gameObject);
    }
GameObject CreateEnemy()
    {
        GameObject enemy = Instantiate(enemyPrefab);
        enemy.transform.parent = this.transform;
        enemy.transform.GetComponent<dr>().SetObjectPool(enemyPool);
        return enemy;
    }
    public List<GameObject> GetEnemyList()
    {
        return enemyList;
    }
    void AddEnemy()
    {
        GameObject enemy = enemyPool.GetObject();
        if(enemy == null)
        {
            enemy = this.CreateEnemy();
        }
        enemy.SetActive(true);
enemy.transform.parent = transform;
        enemy.transform.position = pathObject.transform.GetChild(0).transform.position;
        enemy.transform.GetComponent<dr>().InitWithData(pathObject, gameObject);   
           this.enemyList.Add(enemy);
    }
    void Update()
    {
        if(this.currentAddEnemyTime >= addEnemyDutacion)
        {
            this.AddEnemy();
            this.currentAddEnemyTime = 0.0f;
        }
        else
        {
            this.currentAddEnemyTime += Time.deltaTime;
        }
    }
    public void EnemyEnd(GameObject enemy)
    {
        enemyList.Remove(enemy);
        Debug.Log("enemy list" + enemyList.Count);
    }
}

EnemyController模块

public class dr : MonoBehaviour
{
    private List<Vector3> pathList = new List<Vector3>();
    private int pathIndex = 0;
    private Vector3 targetPos = Vector3.zero;
    private ObjectPool enemyPool = null;
    private GameObject enemyController = null;
void Start()
    {
        
}
 public void SetObjectPool(ObjectPool pool)
    {
        enemyPool = pool;
}
    void Update()
    {
      if(pathList.Count!=0&&targetPos.Equals(Vector3.zero)&&pathIndex<pathList.Count)
        {
            targetPos = pathList[pathIndex];
        }
        if(!targetPos.Equals(Vector3.zero))
        {
            transform.position = Vector3.MoveTowards(transform.position, targetPos, 0.08f);
        }
        
        float distance = Vector3.Distance(transform.position, targetPos);
        if(distance < 0.1f)
        {
            pathIndex ++;
            targetPos = Vector3.zero;
            if(pathIndex == pathList.Count)
            {
                this.enemyController.transform.GetComponent<diren>().EnemyEnd(gameObject);
                enemyPool.PushObject(gameObject);
            }
        }
    }
    public void InitWithData(GameObject path,GameObject ctl )
    {
        this.enemyController = ctl;
        for (int i = 0; i < path.transform.childCount; i++)
        {
            pathList.Add(path.transform.GetChild(i).transform.position);
        }
}
}

TowerBase模块

public class TowerBase : MonoBehaviour
{
    void Start()
    {}
    void Update()
    {}
    public void OnMouseDown()
    {
        Global.GetInstance().GetEvent().Invoke(EventEnum.BuildMenu, gameObject);
    }
}

Tower模块

public class Tower : MonoBehaviour
{
    public GameObject body;public float attackDistance;
    public float attackDuraction;public GameObject bulletPos;
    public GameObject bulletPrefab; private float currentAttackTime;
    private ObjectPool bulletPool = new ObjectPool();
    private Color currentColor;private int towerLevel = 0;
    private List<Color> levelColor = new List<Color>();
    private GameObject targetEnemy = null;
    GameObject enemyController = Global.GetInstance().GetEnemyController();
    void Start()
    {
        levelColor.Add(Color.blue);
        levelColor.Add(Color.red);
        levelColor.Add(Color.black);
        currentColor = body.transform.GetComponent<MeshRenderer>().material.color;
        for(int i = 0;i < 5;i ++)
        {
            GameObject obj = this.CreateBullet();
            bulletPool.PushObject(obj);
        }
    }
    GameObject CreateBullet()
    {
        GameObject bullet = Instantiate(bulletPrefab);
        bullet.transform.position = this.bulletPos.transform.position;
        bullet.transform.GetComponent<Bullet>().SetObjectPool(bulletPool);
        bullet.transform.parent = transform.parent;
        return bullet;
    }
    void AddBullet(GameObject target)
    {
        GameObject bullet = bulletPool.GetObject();
        if(bullet == null)
        {
            bullet = this.CreateBullet();
        }
        bullet.SetActive(true);
        bullet.transform.position = bulletPos.transform.position;
        bullet.transform.GetComponent<Bullet>().SetTarget(target);
    }
    void Update()
    {
        if (targetEnemy == null)
{  List<GameObject>enemyList=enemyController.transform.GetComponent<diren>().GetEnemyList();
            for(int i = 0;i < enemyList.Count;i ++)
            {
GameObject enemy = enemyList[i];
                Vector3 enemyPos = enemy.transform.position;
                Vector3 towerPos = transform.position;
                float dis = Vector3.Distance(enemyPos,towerPos);
                if(dis < attackDistance)
                {
                    this.targetEnemy = enemy;
                }
            }
        }
        else
        {
            if(this.currentAttackTime > this.attackDistance)
            {
                this.AddBullet(this.targetEnemy);
                this.currentAttackTime = 0.0f;
            }
            else
            {
                this.currentAttackTime += Time.deltaTime;
            }
            Vector3 towerV = new Vector3(0, 0, 1);
            Vector3 enemyV = this.targetEnemy.transform.position - transform.position;
            float angle = Vector3.SignedAngle(towerV, enemyV,Vector3.up);
            transform.rotation = Quaternion.AngleAxis(angle,Vector3.up);
Vector3 enemyPos = this.targetEnemy.transform.position;
            Vector3 towerPos = this.transform.position;
            float dis = Vector3.Distance(enemyPos, towerPos);
            if(dis > this.attackDistance)
            {
                this.targetEnemy = null;
            }
        }
    }
    public void OnMouseDown()
{        
Global.GetInstance().GetEvent().Invoke(EventEnum.ShowUpdateMenu, gameObject);
    }
    public void UpdateLevel()
    {
        if(towerLevel == 3)
        {
            return;
        }
            towerLevel++;
            this.body.transform.GetComponent<MeshRenderer>().material.color= levelColor[towerLevel - 1];
            currentColor = levelColor[towerLevel - 1];
    }
}

TowerController模块

public class TowerController : MonoBehaviour
{
    public List<GameObject> towerPrefabList;
    void Start()
    {
        Global.GetInstance().GetEvent().AddListener(ProcessEvent);
    }
    void ProcessEvent(EventEnum eventType, GameObject obj)
    {
        switch(eventType)
        {
            case EventEnum.BuildTower1:
                this.BuildTower(towerPrefabList[0],obj);
                break;
            case EventEnum.BuildTower2:
                this.BuildTower(towerPrefabList[1],obj);
 break;
            default:
                break;
        }
    }
    void BuildTower(GameObject obj,GameObject tb)
    {
        GameObject tower = Instantiate(obj);
        tower.transform.parent = transform;
        tower.transform.position = tb.transform.position;
    }
    void Update()
    {}
}

Bullet模块

public class Bullet : MonoBehaviour
{
public static int grade = 100;public int timer = 1; private static Bullet instance;
private ObjectPool bulletPool = null; private GameObject targetEnemy = null;
   public static Bullet getInstance
    {
        get
        {
            if (instance == null)
            {
                instance = new Bullet();
            }
            return instance;
        }
    }
    void Start()
    { }
    [System.Obsolete]
    void Update()
    {
        timer -= Convert.ToInt16(Time.deltaTime);
        if(timer <= 0)
        {
            timer = 1;
        }
        if(this.targetEnemy != null && this.targetEnemy.active == true)
        {
            Vector3 enemyPos = this.targetEnemy.transform.position;
            Vector3 bulletPos = transform.position;
            float dis = Vector3.Distance(enemyPos, bulletPos);
            transform.position = Vector3.MoveTowards(bulletPos,enemyPos,0.1f);
            if(dis < 0.5)
            {
                bulletPool.PushObject(gameObject);
                this.targetEnemy = null;
                grade = grade + 10;
            }
        }
    }
    public void SetObjectPool(ObjectPool pool)
    {
        bulletPool = pool;
    }
    public void SetTarget(GameObject target)
    {
        this.targetEnemy = target;
    }
}

UIController 模块

public class UIController : MonoBehaviour
{
    public GameObject buileMenu;public GameObject updateMenu;
    public GameObject successMenu;public GameObject failureMenu;
    public GameObject targetObject;public GameObject textback;
    void Start()
    {
        Global.GetInstance().GetEvent().AddListener(ProcessEvent);
    }
    void ProcessEvent(EventEnum eventType, GameObject obj)
    {
        this.targetObject = obj;
        switch(eventType)
        {
            case EventEnum.BuildMenu:
                this.ShowBuileMenu(obj);
                break;
            case EventEnum.ShowUpdateMenu:
                this.ShowUpdateMenu(obj);
                break;
            case EventEnum.successMenu:
                this.ShowsuccessMenu(obj);
                break;
            case EventEnum.failureMenu:
                this.ShowfailureMenu(obj);
                break;
            default:
                break;
        }
 }
    void ShowUpdateMenu(GameObject obj)
    {
        this.buileMenu.SetActive(false);this.updateMenu.SetActive(true);
        this.updateMenu.transform.position= Camera.main.WorldToScreenPoint(obj.transform.position);
    }
    void ShowBuileMenu(GameObject obj)
    {
        this.updateMenu.SetActive(false); this.buileMenu.SetActive(true);
        this.buileMenu.transform.position= Camera.main.WorldToScreenPoint(obj.transform.position);
    }

    void ShowsuccessMenu(GameObject obj)
    {
        this.successMenu.SetActive(true);
    }
    void ShowfailureMenu(GameObject obj)
    {
        this.failureMenu.SetActive(true);
    }
    public void OnButtonClick(string data)
    {
        Debug.Log("button click ="+data);
        switch(data)
        {
            case "build-tower-1":
                if (Bullet.grade >= 100)
                {
                    Global.GetInstance().GetEvent().Invoke(EventEnum.BuildTower1, this.targetObject);
                    this.buileMenu.SetActive(false);
                    Bullet.grade = Bullet.grade - 100;
                }
                else
                {
                    this.buileMenu.SetActive(false);
                }
                break;
            case "build-tower-2":
                if (Bullet.grade >= 100)
                {
                    Global.GetInstance().GetEvent().Invoke(EventEnum.BuildTower2, this.targetObject);
                    this.buileMenu.SetActive(false);
                    Bullet.grade = Bullet.grade - 100;
                }
                else
                {
                     this.buileMenu.SetActive(false);
                }
                break;
            case "update":
                if (Bullet.grade >= 100)
                {
                   this.targetObject.transform.GetComponent<Tower>().UpdateLevel();
                    this.updateMenu.SetActive(false);
                    Bullet.grade = Bullet.grade - 100;
                }
                else
                {
                    this.buileMenu.SetActive(false);
                }
                break;
            case "sell":
                Destroy(this.targetObject);
                this.updateMenu.SetActive(false);
                Bullet.grade = Bullet.grade + 50;
                break;
            default:
                break;
        }
}
}

CM 模块

public class CM : MonoBehaviour
{
    public AudioClip music;public AudioSource back;
    public float moveSpeed = 200f;private int t = 0;
    void Start()
    {
        back = this.GetComponent<AudioSource>();
        back.loop = true; //设置循环播放  
        back.volume = 0.5f;//设置音量最大，区间在0-1之间
        back.clip = music;
        back.Play(); //播放背景音乐
     }
void Update()
    {
        float x = Input.GetAxis("Horizontal") * Time.deltaTime * moveSpeed;
        float z = Input.GetAxis("Vertical") * Time.deltaTime * moveSpeed;
        transform.Translate(x, 0, z);
 }
    public void OnButtonClick(string data)
    {
        switch (data)
        {
            case "musicbutton":
                ++t;
                if(t % 2 == 1)
                {
                    back.Stop();
                }
                else
                    back.Play();
                break; 
             default:
                break;
        }
    }
}

TextShow 模块

public class TextShow : MonoBehaviour
{
public float timer = 1.0f;
 void Start()
    { }
    void Update()
    {
        timer -= Time.deltaTime;
        GameObject.Find("Canvas/time").GetComponent<Text>().text = "时间:" + Convert.ToInt16(Time.time);
        GameObject.Find("Canvas/grade").GetComponent<Text>().text = "分数：" + Bullet.grade;
    }
}

最后有需要的朋友可以下载看看：基于Unity3D的塔防游戏

明月夜&
关注
专栏目录
使用Unity构建3D塔防游戏：项目指南
gitblog_00066的博客
05-24 548
使用Unity构建3D塔防游戏：项目指南 Tower-Defense-TutorialLearn how to make a 3D Tower Defence Game using Unity.项目地址:https://gitcode.com/gh_mirrors/to/Tower-Defense-Tutorial 在这个开源项目中，你将学习如何利用Unity引擎和C#编程语言制作一款3D塔防游...
基于Unity3D的塔防游戏.zip
04-11
设计建议塔防游戏，实现规定敌人移动路线，在塔的基座的基础上升级塔、卖掉塔、更换塔，来射击敌人。 要求：1、基于c#编程语言实现； 2、发射子弹攻击敌人； 3、记录分数，判定游戏成功与否。
游戏开发设计模式之策略模式
最新发布
Ctrl+CV九段手
08-23 1163
策略模式：适合于需要根据不同的游戏状态或玩家选择动态改变游戏行为的场景，强调算法的灵活性和独立性。观察者模式：适用于需要松散耦合、事件驱动的游戏系统，如成就系统和UI事件处理。状态模式：适合于需要明确和集中管理状态转换的复杂条件逻辑，提高系统的可维护性和可扩展性。
Unity塔防游戏
12-08
Unity塔防游戏,编译好的游戏，喜欢的道友可以玩玩
Unity3D 塔防游戏
11-06
一个Unity塔防的资源包，供大家参考使用
Unity3D开发塔防游戏源码
01-14
采用Unity3D开发的塔防类游戏源码，功能齐全，适合初学者。
Unity3D制作塔防类游戏
m0_58367586的博客
11-20 9890
分为蓝，紫，粉，红四批敌人，每一批的敌人都比前一批的数量要多，并且速度要快，血量要多，当一批敌人死光了，才会出来第二批敌人，一共有三种炮塔每个金额为70，80，90，初始金额为1000，选择炮塔类型，点击Cube，即可以插放，再次点击时候可以选择升级或拆除，由于地图过大，可以一共上下左右键来控制地图前后左右视角，用鼠标滑轮来控制上下视角，把四批敌人杀光才可以通关成功，否则失败。
基于Unity3d的FPS与塔防相结合的游戏设计.doc
05-09
《基于Unity3d的FPS与塔防相结合的游戏设计》这篇文档详细阐述了如何利用Unity3d引擎设计一款融合了第一人称射击（FPS）与塔防（Tower Defense）元素的游戏。这种创新的游戏类型旨在提供玩家更为丰富的游戏体验，将...
U3D制作塔防游戏源码（基于Unity5.5-2019）.zip
07-08
《Unity3D构建塔防游戏源代码解析》 Unity3D，简称U3D，是一款强大的跨平台游戏开发工具，广泛应用于游戏制作、虚拟现实、增强现实等领域。本篇文章将详细解析基于Unity5.5至2019版本的塔防游戏源码，帮助开发者...
高分项目，基于Unity3D开发实现的手机版像素塔防游戏，内含完整源码+资源
06-16
高分项目，基于Unity3D开发实现的手机版像素塔防游戏，内含完整源码+资源 炮塔防御（Tower Defence），简称塔防，一种游戏类型。炮塔防御游戏起源于最早的一款Desktop Tower Defence游戏。现在除了单纯的建造炮塔...
软件设计--基于unity 3d 的塔防游戏
Flandree的博客
11-23 966
第一阶段 1.地图 2.敌人的生成和移动 目前利用不同颜色的球体代替不同的敌人，敌人会自动从出生点移动到目标点。不同敌人各种属性不同（生命，速度等） 3.控制游戏视野 可以通过鼠标的滑轮和键盘的wasd键孔氏游戏视野的大小和移动 4.炮台模型 目前找到了三种炮台模型，每种有初始和升级后两种状态。 5.购买界面UI 设计了一个炮台购买界面的UI，可以通过鼠标点击选中相应炮塔 下一阶段目标 1...
Unity塔防游戏制作
09-08
Unity3D塔防游戏制作，包含已打包可试玩的游戏程序和Unity3D工程源码。试玩前请认真阅读游戏引导。
基于Unity3D的虚拟校园漫游系统
12-30
基于Unity3D的虚拟校园漫游系统. 虚幻4引擎专题相关参考文献。
unity塔防游戏资源
05-12
unity塔防类游戏场景资源，卡通风格。。。。。。。。。
Unity塔防类游戏
12-17
该款小游戏为我们小组制作，基于Unity开发的3D类塔防小游戏
Unity 塔防类游戏示例
03-07
简单的路径系统，1种敌人，4种防御塔AI，1个示例场景。1个场景搭建的辅助脚本（位置对齐）C#事件的简单使用。
Unity实现一个3D塔防游戏
voidinit的专栏
04-25 2827
在本例中，我们将创建一个基本的塔防游戏，玩家需要建造防御塔来阻止敌人进入自己的领地。在本例中，我们需要创建一个3D地图，所以我们需要使用Unity的3D对象来创建地图。我们需要在脚本中使用UI组件来显示资源的数量，并在玩家建造和升级防御塔时扣除相应的资源。我们需要在脚本中使用事件系统来检测游戏的胜利和失败条件，并在游戏结束时显示相应的UI。最后，我们需要实现敌人的攻击行为。在游戏中，我们需要实现一个游戏管理系统来控制游戏的开始、暂停、结束等行为。我们需要创建一个新的Unity场景，并添加游戏中需要的对象。
使用Unity3D引擎制作塔防类游戏(一)
qq_41535966的博客
01-03 1961
使用Unity3D引擎制作塔防类游戏(一) 写在开头：U3D小白一枚，第一次写博客，如有写的不足或错误之处，请大佬多多指教。另外，我不是第一个吃螃蟹的人，该项目用了一位兄台的资源，借鉴了游戏处理的逻辑，下面就把链接贴出来： 链接 该游戏的UI比较多，用到的Sprite更多，要想做这个游戏的第一步，先把图片分类好(是的，你没有看错)。该游戏的序列帧动画也非常多，如果不想自己动手，可以借鉴一下上面链接...
Unity-3D塔防
westos_linux的博客
01-04 614
技术点： 1. UGUI   事件的绑定   动画的制作 2. 创建preFab对象   3. 类对象的封装 4. 泛型集合List 实现效果： 在整个游戏开发过程中，游戏设计思路很重要，实现的方法其次，先是搭建游戏的场景，场景搭建完毕之后，创建敌人的预设和你的炮塔的预设，在这里面需要用到泛型集合List，以及封装类对象，产生类的对象集合， 封装类的对象  public 
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值