做一个简单的打飞碟游戏

最新推荐文章于 2021-05-21 03:41:28 发布
最新推荐文章于 2021-05-21 03:41:28 发布
阅读量1.3k 收藏 4
点赞数
分类专栏： 3D游戏设计

简介

就是一个简单的打飞碟游戏。。游戏难度会随着你获得的分数提升，胜利条件是获得1000分。

对象处理

就简单的一个飞碟预制就行了（十分简单，就一个圆柱体。。完毕）
这里写图片描述
还有一个粒子系统用来模拟飞碟被击中时的爆炸效果，粒子的参数如下：
这里写图片描述
这里写图片描述
就这么简单。。没了

UML

这里写图片描述

代码部分

其实这个飞碟的代码跟之前的那个牧师与魔鬼的代码十分的相似，主要是由于老师提供的框架可塑性实在是太强大了（膜拜一下老师）。只需要增加一个记分员，一个飞碟工厂，再加上之前的框架，就搞定了。
Singleton.cs（单例模型的模板）

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Singleton<T> where T : MonoBehaviour
{
    private static T instance;
    public static T Instance {
        get {
            if (instance == null) {
                instance = (T)Object.FindObjectOfType(typeof(T));
                if (instance == null) {
                    Debug.LogError("Can't find instance of " + typeof(T));
                }
            }
            return instance;
        }
    }
}

Director.cs

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Director : System.Object {
    public static Director _instance;
    public ISceneController currentSceneController { get; set; }
    public bool running { get; set; }

    public static Director getInstance() {
        if (_instance == null) _instance = new Director();
        return _instance;
    }

    public int getFPS() {
        return Application.targetFrameRate;
    }

    public void setFPS(int fps) {
        Application.targetFrameRate = fps;
    }
}

DiskData.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class DiskData : MonoBehaviour {
    public float size;
    public Color color;
    public float speed;
}

ScoreRecorder.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ScoreRecorder : MonoBehaviour {
    private float score;

    public float getScore() {
        return score;
    }

    public void Record(GameObject disk) {
        score += (100 - disk.GetComponent<DiskData>().size *(20 - disk.GetComponent<DiskData>().speed));

        Color c = disk.GetComponent<DiskData>().color;
        switch (c.ToString()) {
        case "red":
            score += 50;
            break;
        case "green":
            score += 40;
            break;
        case "blue":
            score += 30;
            break;
        case "yellow":
            score += 10;
            break;
        }
    }

    public void Reset() {
        score = 0;
    }
}

DiskFactory.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class DiskFactory : MonoBehaviour {

    private List<GameObject> used = new List<GameObject>();
    private List<GameObject> free = new List<GameObject>();

    private Color[] color = { Color.red, Color.green, Color.blue, Color.yellow };

    public GameObject GetDisk(int ruler) {
        GameObject a_disk;
        if (free.Count > 0) {
            a_disk = free[0];
            free.Remove(free[0]);
        } else {
            a_disk = GameObject.Instantiate(Resources.Load("prefabs/Disk")) as GameObject;
        }
        switch (ruler) {
        case 1:
            a_disk.GetComponent<DiskData>().size = UnityEngine.Random.Range(0, 6);
            a_disk.GetComponent<DiskData>().color = color[UnityEngine.Random.Range(0, 4)];
            a_disk.GetComponent<DiskData>().speed = UnityEngine.Random.Range(10, 15);

            a_disk.transform.localScale = new Vector3(a_disk.GetComponent<DiskData>().size * 2, a_disk.GetComponent<DiskData>().size * 0.1f, a_disk.GetComponent<DiskData>().size * 2);
            a_disk.GetComponent<Renderer>().material.color = a_disk.GetComponent<DiskData>().color;
            break;
        case 2:
            a_disk.GetComponent<DiskData>().size = UnityEngine.Random.Range(0, 4);
            a_disk.GetComponent<DiskData>().color = color[UnityEngine.Random.Range(0, 4)];
            a_disk.GetComponent<DiskData>().speed = UnityEngine.Random.Range(15, 20);

            a_disk.transform.localScale = new Vector3(a_disk.GetComponent<DiskData>().size * 2, a_disk.GetComponent<DiskData>().size * 0.1f, a_disk.GetComponent<DiskData>().size * 2);
            a_disk.GetComponent<Renderer>().material.color = a_disk.GetComponent<DiskData>().color;
            break;
        }
        a_disk.SetActive(true);
        used.Add(a_disk);
        return a_disk;
    }

    public void FreeDisk(GameObject disk) {
        for(int i = 0; i < used.Count; i++) {
            if(used[i] == disk) {
                disk.SetActive(false);
                used.Remove(used[i]);
                free.Add(disk);
            }
        }
    }
}

RoundController.cs

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public enum State { WIN, LOSE, PAUSE, CONTINUE, START };

public class RoundController : MonoBehaviour, IUserAction, ISceneController {

    public DiskFactory diskFactory;
    public RoundActionManager actionManager;
    public ScoreRecorder scoreRecorder;
    private List<GameObject> disks;
    private int round;
    private GameObject shootAtSth;
    GameObject explosion;

    public State state { get; set; }
    public int leaveSeconds;
    public int count;

    IEnumerator DoCountDown() {
        while (leaveSeconds >= 0) {
            yield return new WaitForSeconds(1);
            leaveSeconds--;
        }
    }

    void Awake() {
        Director director = Director.getInstance();
        director.setFPS(60);
        director.currentSceneController = this;

        LoadResources();

        diskFactory = Singleton<DiskFactory>.Instance;
        scoreRecorder = Singleton<ScoreRecorder>.Instance;
        actionManager = Singleton<RoundActionManager>.Instance;

        leaveSeconds = 60;
        count = leaveSeconds;
        state = State.PAUSE;
        disks = new List<GameObject>();
    }


    void Start () {
        round = 1;
        LoadResources();
    }

    void Update() {
        LaunchDisk();
        Judge();
        RecycleDisk();
    }

    public void LoadResources() {
        Camera.main.transform.position = new Vector3(0, 0, -15);
        explosion = Instantiate(Resources.Load("Prefabs/ParticleSys"), new Vector3(-40, 0, 0), Quaternion.identity) as GameObject;

    }

    public void shoot() {
        if (Input.GetMouseButtonDown(0) && (state == State.START || state == State.CONTINUE)) {
            Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
            RaycastHit hit;
            if (Physics.Raycast(ray, out hit)) {
                if ((Director.getInstance().currentSceneController.state == State.START || Director.getInstance().currentSceneController.state == State.CONTINUE)) {
                    shootAtSth = hit.transform.gameObject;

                    explosion.transform.position = hit.collider.gameObject.transform.position;
                    explosion.GetComponent<Renderer>().material = hit.collider.gameObject.GetComponent<Renderer>().material;
                    explosion.GetComponent<ParticleSystem>().Play();
                }
            }
        }
    }

    public void LaunchDisk() {
        if(count - leaveSeconds == 1) {
            count = leaveSeconds;
            GameObject disk = diskFactory.GetDisk(round);
            Debug.Log(disk);
            disks.Add(disk);
            actionManager.addRandomAction(disk);
        }
    }

    public void RecycleDisk() {
        for(int i = 0; i < disks.Count; i++) {
            if( disks[i].transform.position.z < -18) {
                diskFactory.FreeDisk(disks[i]);
                disks.Remove(disks[i]);
            }
        }
    }

    public void Judge() {
        if(shootAtSth != null && shootAtSth.transform.tag == "Disk" && shootAtSth.activeInHierarchy) {
            scoreRecorder.Record(shootAtSth);
            diskFactory.FreeDisk(shootAtSth);
            shootAtSth = null;
        }

        if(scoreRecorder.getScore() > 500 * round) {
            round++;
            leaveSeconds = count = 60;
        }

        if (round == 3) {
            StopAllCoroutines ();
            state = State.WIN;
        } else if (leaveSeconds == 0 && scoreRecorder.getScore () < 500 * round) {
            StopAllCoroutines ();
            state = State.LOSE;
        } else state = State.CONTINUE;
    }

    public void Pause() {
        state = State.PAUSE;
        StopAllCoroutines();
        for (int i = 0; i < disks.Count; i++) disks[i].SetActive(false);
    }

    public void Resume() {
        StartCoroutine(DoCountDown());
        state = State.CONTINUE;
        for (int i = 0; i < disks.Count; i++) disks[i].SetActive(true);
    }

    public void Restart() {
        scoreRecorder.Reset();
        Application.LoadLevel(Application.loadedLevelName);
        Director.getInstance().currentSceneController.state = State.START;
    }
}

RoundActionManager.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class RoundActionManager : SSActionManager, ISSActionCallback {
    public RoundController scene;
    public MoveToAction action1, action2;
    float speed;

    public void addRandomAction(GameObject gameObj) {
        int[] X = { -20, 20 };
        int[] Y = { -5, 5 };
        int[] Z = { -20, -20 };

        Vector3 startPos = new Vector3(
            UnityEngine.Random.Range(-20, 20),
            UnityEngine.Random.Range(-5, 5),
            UnityEngine.Random.Range(50, 10)
        );

        gameObj.transform.position = startPos;

        Vector3 randomTarget = new Vector3(
            X[UnityEngine.Random.Range(0, 2)],
            Y[UnityEngine.Random.Range(0, 2)],
            Z[UnityEngine.Random.Range(0, 2)]
        );

        MoveToAction action = MoveToAction.GetSSAction(randomTarget, gameObj.GetComponent<DiskData>().speed);
        RunAction(gameObj, action, this);
    }

    protected void Start() {
        scene = (RoundController)Director.getInstance().currentSceneController;
        scene.actionManager = this;
    }

    protected new void Update() {
        base.Update();
    }

    public void SSActionEvent(SSAction source,SSActionEventType events = SSActionEventType.Completed,
        int intParam = 0,
        string strParam = null,
        Object objectParam = null) {
    }
}

UserGUI.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public interface IUserAction {
    void shoot();
}

public class UserGUI : MonoBehaviour {
    private IUserAction action;
    private float width, height;
    private string countDownTitle;

    void Start() {
        countDownTitle = "Start";
        action = Director.getInstance().currentSceneController as IUserAction;
    }

    float castw(float scale) {
        return (Screen.width - width) / scale;
    }

    float casth(float scale) {
        return (Screen.height - height) / scale;
    }

    void OnGUI() {
        width = Screen.width / 12;
        height = Screen.height / 12;

        GUI.Label(new Rect(castw(2f)+20, casth(6f) - 20, 50, 50), ((RoundController)Director.getInstance().currentSceneController).leaveSeconds.ToString());
        GUI.Button(new Rect(580, 10, 80, 30), ((RoundController)Director.getInstance().currentSceneController).scoreRecorder.getScore().ToString());

        if (Director.getInstance().currentSceneController.state != State.WIN && Director.getInstance().currentSceneController.state != State.LOSE
            && GUI.Button(new Rect(10, 10, 80, 30), countDownTitle)) {

            if (countDownTitle == "Start") {
                countDownTitle = "Pause";
                Director.getInstance().currentSceneController.Resume();
            } else {
                countDownTitle = "Start";
                Director.getInstance().currentSceneController.Pause();
            }
        }

        if (Director.getInstance().currentSceneController.state == State.WIN) {
            if (GUI.Button(new Rect(castw(2f), casth(6f), width, height), "Win!")) Director.getInstance().currentSceneController.Restart();
        } else if (Director.getInstance().currentSceneController.state == State.LOSE) {
            if (GUI.Button(new Rect(castw(2f), casth(6f), width, height), "Lose!")) Director.getInstance().currentSceneController.Restart();
        }
    }

    void Update() {
        action.shoot();
    }
}

剩下的就跟之前的牧师与魔鬼的代码一样啦。
这里最最最重要的是（红笔五角星），要调整脚本的调用顺序。否则会出错的。
这里写图片描述
没啦，就这么多了。希望玩得愉快

Yjl_Richard
关注
专栏目录
简单打飞碟游戏
pnxldzw的博客
05-30 1774
一、鼠标点击小游戏         在写简单飞碟游戏之前，先写一个鼠标点击的小游戏热热身：游戏场景中会随机出现小圆圈，鼠标点击后，圆圈3秒后自动消失。      (1).  首先，创建Terrain, 并标记为Finish；创建Cylinder并设置其大小，将其拉到Assert/Resources/Prefabs下，再在Prfabs下创建meterial并设置颜色，将meterial拖到Cyl
利用Funcode平台使用C++语言:打飞碟
04-10
Funcode平台,C++语言
打飞碟游戏
07-23
玩家通过鼠标控制大炮发射炮弹，击中飞碟获得相应的分数。 要求如下: 1、游戏的初始界面如图，单击空格键开始游戏。左上方有两个文字编辑精灵用于记录游戏的剩余时间和分数。下方有五个文字精灵用于记录分数最高的前五个。 2、单击空格键之后，通过鼠标控制大炮的炮口朝向和发射，准心精灵随鼠标的移动而移动。三种不同大小的飞碟从右上角飞下，当把准心移动到飞碟身上，单击鼠标左键，则大炮发射炮弹。 3、大炮发射炮弹的时候炮口有真实场景中开火的效果，炮弹击中飞碟后有爆炸的效果。 4、三种飞碟大小不一样，下落速度不同，同时被击中后所能获取的分数也不同。如果飞碟没有被击中，则飞碟从右下方飞出，删除该飞碟实体。
C++程序设计_打飞碟
06-26
C++程序设计_打飞碟,是一个有关于打飞碟游戏的设计思路
Flash游戏制作--打飞碟
wangangie3
04-05 389
射击类游戏不仅在各种平台的游戏中占有重要地位，在Flash游戏中也占有数量上的绝对优势，不少朋友喜欢将学习Flash射击游戏的制作作为学习Flash游戏制作的开始，又因为射击游戏可根据作者自己水平的不同，可难可易，较易掌握，所以Flash射击游戏的制作成为Flash游戏的一大热点，这次我们就来学习一款简单的Flash射击游戏—打飞碟 图1为游戏的主界面： [img]/Files/Beyon...
Unity 3D-learning 简单打飞碟游戏
qq_36321775的博客
04-17 416
一、编写一个简单的打飞碟游戏游戏内容要求：游戏有 n 个 round，每个 round 都包括10 次 trial；每个 trial 的飞碟的色彩、大小、发射位置、速度、角度、同时出现的个数都可能不同。它们由该 round 的 ruler 控制；每个 trial 的飞碟有随机性，总体难度随 round 上升；鼠标点中得分，得分规则按色彩、大小、速度不同计算，规则可自由设定。游戏的要求：使用带缓存的...
c语言课程设计--打飞碟源代码,飞碟游戏(飞碟游戏规则)
weixin_29536515的博客
05-21 526
2021年5月13日发(作者：封孟绅)计算机技术基础课程设计C语言设计报告题目：打飞碟游戏学院：机电工程学院专业：工业工程班级：050109姓名：刁玉斌指导教师：顾煜新设计时间：2007年1月9日一．课设题目：打飞碟游戏二．选题背景：我们在繁忙的工作之余,总会想一些办法来调节一下自己紧张的神经。电脑小游戏就是调节自己的最好办法，本程序就是在这个前提下提出的。如：程序中游飞碟速度的控制；飞碟所在方位...
unity 3D打飞碟游戏，虚拟现实大作业（免积分下载）
10-27
在“unity 3D打飞碟游戏，虚拟现实大作业”项目中，我们可以深入探讨Unity 3D在游戏设计与开发中的关键知识点。 首先，游戏的菜单系统是任何游戏的起点，它提供了用户界面（UI）和游戏控制的入口。在Unity中，通常...
一个飞碟游戏源码
07-22
每个对象通常对应一个类，包含了其属性和行为。 9. **资源管理**：游戏中的图像、音频和其他资源需要被正确地加载和释放，以避免内存泄漏。源码会包含加载和释放资源的函数。 10. **计分系统**：飞碟被击落会增加...
C++编程之简单打飞碟游戏
02-11
【C++编程之简单打飞碟游戏】是一个适合初学者的编程练习，旨在通过实现一个基本的游戏来学习C++编程的基础知识。这个游戏的核心是利用C++的图形库和键盘输入处理，让玩家控制一个瞄准器击落飞碟。以下是游戏涉及的...
funcode 打飞虫c语言源码
12-28
源代码 如果想要加入音乐的话 在playsound里面加入自己想要的东西 直接加入bin里面然后导入 只能是wav格式的 如果有不对的或者哪里错误了 直接滴滴我
一个c语言写的飞碟案列
05-09
使用.net写得一个程序，可以试试，比较好玩哈哈。
funcode 拍飞虫（c语言）
04-01
C语言课程设计二 拍飞虫 游戏介绍 拍飞虫游戏是玩家用鼠标控制拍子，拍飞虫。飞虫每次从不同的位置、以不同的速度飞来飞去。玩家拍的飞虫越多，分数越高。 这是funcode选修的一项内容，用funcode打开对应文件即可查看。
编写飞碟射击一个游戏程序。
11-03
屏幕中央下方中央有一猎枪，位置固定，可用鼠标左、右键控制其转动方向。用空格键控制开枪。程序控制由屏幕左、右方以随机方向自动抛出飞碟（每次抛一个，各次抛出间有适当间隔）。抛出飞碟前应有提示。对每个飞碟，最多可以开两枪。程序应可统计当前击中飞碟数和失败次数。 程序可使用对话框结构或基于框架窗口的程序结构，设有开始和结束按钮或菜单选项。
FunCode.exe
07-15
FunCode是一款全新的基于游戏和动画界面的 程序设计开发平台，支持C\C++\JAVA三种程序语 言。该平台将游戏引擎、界面编辑器、集成开发 环境（使用VC++或Eclipse）、API整合在一起， 学生用课堂里学到的程序设计知识，就能轻松开 发出一款互动式游戏或者一段动画。
简单打飞碟小游戏
patrick_lii的博客
10-09 709
简单打飞碟小游戏 游戏内容要求： 游戏有 n 个 round，每个 round 都包括10 次 trial； 每个 trial 的飞碟的色彩、大小、发射位置、速度、角度、同时出现的个数都可能不同。它们由该 round 的 ruler 控制； 每个 trial 的飞碟有随机性，总体难度随 round 上升； 鼠标点中得分，得分规则按色彩、大小、速度不同计算，规则可自由设定。 游戏的要求： ...
3D游戏编程4--打飞碟
yaoxh6的博客
04-13 618
编写一个简单的鼠标打飞碟（Hit UFO）游戏 游戏内容要求 游戏的要求 游戏实现 文件结构 c#文件 DiskFactory DiskFactoryController FirstController RoundController SceneController ScoreController UserInterface 资源 编写一个简单的鼠标打飞碟（Hit UF...
c语言课程设计--打飞碟源代码,【图片】发几个C语言课程设计源代码（恭喜自己当上技术小吧主）【东华理工大学吧】_百度贴吧...
weixin_39890629的博客
05-21 143
该楼层疑似违规已被系统折叠隐藏此楼查看此楼/*************************************************查询函数**********************************************/void search(){int flag,j,x;char w[20];FILE *fp;char v[20];printf("(1)按作者\n");...
c语言编写的游戏小程序,[C语言编写小程序]简单打飞碟游戏
weixin_36096321的博客
05-17 124
该楼层疑似违规已被系统折叠隐藏此楼查看此楼同样是最初步的模拟，有待再完善下去。飞碟速度上的问题还是希望大家自己调整gamespeed的速度。 空格是发射，发射的具体样子我没写。 #include #include #include #include #define KEY_ESC 0x01#define KEY_SPACE 0x39#define KEY_UP 0x48#de...
C++游戏设计：打飞碟实战教程
在C++程序设计的"打飞碟"游戏中，学生需要实现一个互动的娱乐应用，通过控制大炮发射炮弹击落飞碟来得分。游戏的主要功能和设计要点如下： 一、游戏初始化与界面 1. 游戏启动时展示初始界面，包括一个开始游戏的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值