牧师与魔鬼（动作分离版）

最新推荐文章于 2022-10-23 23:11:16 发布
最新推荐文章于 2022-10-23 23:11:16 发布
阅读量519 收藏 1
点赞数
分类专栏： 3D游戏设计

简介

用 Unity实现一个简单的小游戏，就做牧师与魔鬼，没玩过的童鞋们可以去玩一玩，一个益智小游戏传送门
（之前做了个没有动作分离的。。但是那时忘了发博客。。于是。。只能做动作分离版的了）

UML图

这里写图片描述
这个框架主要参考了老师上课给的框架。。而且大部分代码都是参考老师的代码。。

对象处理

由于是做一个简单的小游戏，所以人物什么的模型也没有花心思去找了。
这里写图片描述
蓝色的矩形表示船
这里写图片描述
红色的球表示魔鬼（注意：在Tag那里也要设为魔鬼，方便代码调用）
这里写图片描述
绿色的球表示牧师（注意项跟魔鬼相同）

代码

代码。。貌似有点多
SSDirector.cs

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

public enum State { WIN, LOSE, PAUSE, CONTINUE , START };
public class SSDirector : System.Object {

    private static SSDirector _instance;
    public int totalSeconds = 60;
    public int leaveSeconds;
    public bool onCountDown = false;
    public string countDownTitle = "Start";

    public ISceneController currentSceneController { get; set; }
    public State state { get; set; }
    public bool running { get; set; }

    // get instance anytime anywhere!
    public static SSDirector getInstance() {
        if (_instance == null) {
            _instance = new SSDirector ();
        }
        return _instance;
    }

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

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

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

FirstController.cs

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

public class FirstController : MonoBehaviour, IUserAction, ISceneController {

    public CCActionManager actionManager;

    List<GameObject> LeftObjList = new List<GameObject>();
    List<GameObject> RightObjList = new List<GameObject>();
    GameObject[] boat = new GameObject[2];

    GameObject boat_obj, leftShore_obj, rightShore_obj;

    Vector3 LeftShorePos = new Vector3(-12, 0, 0);
    Vector3 RightShorePos = new Vector3(12, 0, 0);
    Vector3 BoatLeftPos = new Vector3(-4, 0, 0);
    Vector3 BoatRightPos = new Vector3(4, 0, 0);

    void Awake() {
        SSDirector director = SSDirector.getInstance();
        director.setFPS(60);
        director.currentSceneController = this;
        director.currentSceneController.LoadResources();
        director.leaveSeconds = director.totalSeconds;
    }

    void Start () {
        SSDirector.getInstance().state = State.PAUSE;
        SSDirector.getInstance().countDownTitle = "Start";
        actionManager = GetComponent<CCActionManager>() as CCActionManager;
    }

    void Update() {
        check();
    }

    public void LoadResources() {
        GameObject priest_obj, devil_obj;
        Camera.main.transform.position = new Vector3(0, 0, -20);

        leftShore_obj = Instantiate(Resources.Load("prefabs/Shore"), LeftShorePos, Quaternion.identity) as GameObject;
        rightShore_obj = Instantiate(Resources.Load("prefabs/Shore"), RightShorePos, Quaternion.identity) as GameObject;
        leftShore_obj.name = "left_shore";
        rightShore_obj.name = "right_shore";

        boat_obj = Instantiate(Resources.Load("prefabs/Boat"), BoatLeftPos, Quaternion.identity) as GameObject;
        boat_obj.name = "boat";
        boat_obj.transform.parent = leftShore_obj.transform;

        for (int i = 0; i < 3; ++i) {
            priest_obj = Instantiate(Resources.Load("prefabs/Priest")) as GameObject;
            priest_obj.name = i.ToString();
            priest_obj.transform.position = new Vector3(-16f + 1.5f * Convert.ToInt32(priest_obj.name), 2.7f, 0);
            priest_obj.transform.parent = leftShore_obj.transform;
            LeftObjList.Add(priest_obj);

            devil_obj = Instantiate(Resources.Load("prefabs/Devil")) as GameObject;
            devil_obj.name = (i + 3).ToString();
            devil_obj.transform.position = new Vector3(-16f + 1.5f * Convert.ToInt32(devil_obj.name), 2.7f, 0);
            devil_obj.transform.parent = leftShore_obj.transform;
            LeftObjList.Add(devil_obj);
        }
    }

    public void click() {
        GameObject gameObj = null;

        if (Input.GetMouseButtonDown(0) && 
            (SSDirector.getInstance().state == State.START || SSDirector.getInstance().state == State.CONTINUE)) {
            Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
            RaycastHit hit;
            if (Physics.Raycast(ray, out hit)) gameObj = hit.transform.gameObject;
        }

        if (gameObj == null) return;
        else if (gameObj.name == "0" || gameObj.name == "1" || gameObj.name == "2"
            || gameObj.name == "3" || gameObj.name == "4" || gameObj.name == "5")
            MovePeople(gameObj);
        else if(gameObj.name == "boat") MoveBoat();
    }

    void MovePeople(GameObject people) {
        int shoreNum, seatNum;

        if (people.transform.parent == boat_obj.transform.parent && (boat[0] == null || boat[1] == null)) {
            seatNum = boat[0] == null ? 0 : 1;
            if (people.transform.parent == leftShore_obj.transform) {
                shoreNum = 0;
                for (int i = 0; i < LeftObjList.Count; i++) {
                    if (people.name == LeftObjList[i].name) {
                        Debug.Log (actionManager);
                        actionManager.getOnBoat(people, shoreNum, seatNum);
                        LeftObjList.Remove(LeftObjList[i]);
                    }
                }
            } else {
                shoreNum = 1;
                for (int i = 0; i < RightObjList.Count; i++) {
                    if (people.name == RightObjList[i].name) {
                        actionManager.getOnBoat(people, shoreNum, seatNum);
                        RightObjList.Remove(RightObjList[i]);
                    }
                }
            }
            boat[seatNum] = people;
            people.transform.parent = boat_obj.transform;
        } else if (people.transform.parent == boat_obj.transform) {
            shoreNum = boat_obj.transform.parent == leftShore_obj.transform ? 0 : 1;
            seatNum = (boat[0] != null && boat[0].name == people.name) ? 0 : 1;

            actionManager.getOffBoat(people, shoreNum);

            boat[seatNum] = null;
            if(shoreNum == 0) {
                people.transform.parent = leftShore_obj.transform;
                LeftObjList.Add(people);
            } else {
                people.transform.parent = rightShore_obj.transform;
                RightObjList.Add(people);
            }
        }
    }

    void MoveBoat() {
        if (!(boat[0]==null && boat[1] == null)) {
            actionManager.moveBoat(boat_obj);
            boat_obj.transform.parent = boat_obj.transform.parent == leftShore_obj.transform ? rightShore_obj.transform : leftShore_obj.transform;
        }
    }

    public void check() {
        int left_d = 0, left_p = 0, right_d = 0, right_p = 0;

        foreach (GameObject element in LeftObjList) {
            if (element.tag == "Priest") left_p++;
            if (element.tag == "Devil") left_d++;
        }

        foreach (GameObject element in RightObjList) {
            if (element.tag == "Priest") right_p++;
            if (element.tag == "Devil") right_d++;
        }

        for (int i = 0; i < 2; i++) {
            if (boat[i] != null && boat_obj.transform.parent == leftShore_obj.transform) {
                if (boat[i].tag == "Priest") left_p++;
                else left_d++;
            }
            if (boat[i] != null && boat_obj.transform.parent == rightShore_obj.transform) {
                if (boat[i].tag == "Priest") right_p++;
                else right_d++;
            }
        }

        if ((left_d > left_p && left_p != 0) || (right_d > right_p && right_p != 0) || SSDirector.getInstance().leaveSeconds == 0)
            SSDirector.getInstance().state = State.LOSE;
        else if (right_d == right_p && right_d == 3) SSDirector.getInstance().state = State.WIN;
    }

    public void Pause() {
        SSDirector.getInstance().state = State.PAUSE;
    }

    public void Resume() {
        SSDirector.getInstance().state = State.CONTINUE;
    }

    public void Restart() {
        Application.LoadLevel(Application.loadedLevelName);
        SSDirector.getInstance().state = State.START;
    }
}

SSActionManager.cs

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

public class SSActionManager : MonoBehaviour {

    private Dictionary<int, SSAction> actions = new Dictionary<int, SSAction> ();
    private List<SSAction> waitingAdd = new List<SSAction>();
    private List<int> waitingDelete = new List<int>();
    protected void Update() {
        foreach (SSAction ac in waitingAdd) {
            actions[ac.GetInstanceID()] = ac;
        }
        waitingAdd.Clear();
        foreach (KeyValuePair<int, SSAction> kv in actions) {
            SSAction ac = kv.Value;
            if (ac.destory) {
                waitingDelete.Add(ac.GetInstanceID());
            } else if (ac.enable) {
                ac.Update();
            }
        }
        foreach(int key in waitingDelete) {
            SSAction ac = actions[key];
            actions.Remove(key);
            DestroyObject(ac);
        }
        waitingDelete.Clear();
    }

    public void RunAction(GameObject gameobject, SSAction action, ISSActionCallback manager) {
        action.gameobject = gameobject;
        action.transform = gameobject.transform;
        action.callback = manager;
        waitingAdd.Add(action);
        action.Start();
    }

    protected void Start() {}
}

SSAction.cs

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

public class SSAction : ScriptableObject {

    public bool enable = true;
    public bool destory = false;

    public GameObject gameobject{ get; set;}
    public Transform transform{ get; set; }
    public ISSActionCallback callback{ get; set; }

    protected SSAction() {}

    public virtual void Start () {
        throw new System.NotImplementedException();
    }

    public virtual void Update () {
        throw new System.NotImplementedException ();
    }
}

CCMoveToAction.cs

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

public class CCMoveToAction : SSAction {
    public Vector3 target;
    public float speed;

    public static CCMoveToAction GetSSAction (Vector3 target, float speed) {
        CCMoveToAction action = ScriptableObject.CreateInstance<CCMoveToAction>();
        action.target = target;
        action.speed = speed;
        return action;
    }

    public override void Update () {
        this.transform.position = Vector3.MoveTowards (this.transform.position, target, speed * Time.deltaTime);
        if (this.transform.position == target) {
            this.destory = true;
            this.callback.SSActionEvent (this);
        }
    }

    public override void Start () {}
}

CCSequenceAction.cs

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

public class CCSequenceAction : SSAction, ISSActionCallback {

    public List<SSAction> sequence;
    public int repeat = -1;
    public int start = 0;


    public static CCSequenceAction GetSSAction (int repeat, int start, List<SSAction> sequence) {
        CCSequenceAction action = ScriptableObject.CreateInstance<CCSequenceAction> ();
        action.repeat = repeat;
        action.sequence = sequence;
        action.start = start;
        return action;
    }

    public override void Update () {
        if (sequence.Count == 0) return;
        if (start < sequence.Count) {
            sequence [start].Update ();
        }
    }

    public void SSActionEvent (SSAction source, SSActionEventType events = SSActionEventType.Completed, int Param = 0, string strParam = null, Object objectParam = null) {
        source.destory = false;
        this.start++;
        if (this.start >= sequence.Count) {
            this.start = 0;
            if (repeat > 0) repeat--;
            if (repeat == 0) {
                this.destory = true;
                this.callback.SSActionEvent(this);
            }
        }
    }
    // Use this for initialization
    public override void Start () {
        foreach (SSAction action in sequence) {
            action.gameobject = this.gameobject;
            action.transform = this.transform;
            action.callback = this;
            action.Start();
        }
    }

    void OnDestory() {}
}

ISSActionCallback.cs

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

public enum SSActionEventType:int {Started, Completed}

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

ISceneController.cs

public interface ISceneController {
    void LoadResources();
    void Pause();
    void Resume();
    void Restart();
}

UserGUI.cs

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

public interface IUserAction {
    void click();
}

public class UserGUI : MonoBehaviour {

    private IUserAction action;
    float width, height;

    void Start() {
        action = SSDirector.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), SSDirector.getInstance().leaveSeconds.ToString());// 倒计时秒数 //  
        if (SSDirector.getInstance().state != State.WIN && SSDirector.getInstance().state != State.LOSE
            && GUI.Button(new Rect(10, 10, 80, 30), SSDirector.getInstance().countDownTitle)) {
            if (SSDirector.getInstance().countDownTitle == "Start") {

                SSDirector.getInstance().currentSceneController.Resume();
                SSDirector.getInstance().countDownTitle = "Pause";
                SSDirector.getInstance().onCountDown = true;
                StartCoroutine(SSDirector.getInstance().DoCountDown());
            } else {
                SSDirector.getInstance().currentSceneController.Pause();
                SSDirector.getInstance().countDownTitle = "Start";
                SSDirector.getInstance().onCountDown = false;
                StopAllCoroutines();
            }
        }

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

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

}

CCActionManager.cs

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

public class CCActionManager : SSActionManager, ISSActionCallback {

    public FirstController scene;
    public CCMoveToAction action1, action2;
    public CCSequenceAction saction;
    float speed = 30f;

    public void moveBoat(GameObject boat) {
        action1 = CCMoveToAction.GetSSAction((boat.transform.position ==  new Vector3(4, 0, 0)? new Vector3(-4, 0, 0) : new Vector3(4, 0, 0)), speed);
        this.RunAction(boat, action1, this);
    }

    public void getOnBoat(GameObject people, int shore, int seat) {
        if (shore == 0 && seat == 0) {
            action1 = CCMoveToAction.GetSSAction(new Vector3(-5f, 2.7f, 0), speed);
            action2 = CCMoveToAction.GetSSAction(new Vector3(-5f, 1.2f, 0), speed);
        }
        else if(shore==0 && seat == 1) {
            action1 = CCMoveToAction.GetSSAction(new Vector3(-3f, 2.7f, 0), speed);
            action2 = CCMoveToAction.GetSSAction(new Vector3(-3f, 1.2f, 0), speed);
        }
        else if (shore == 1 && seat == 0) {
            action1 = CCMoveToAction.GetSSAction(new Vector3(3f, 2.7f, 0), speed);
            action2 = CCMoveToAction.GetSSAction(new Vector3(3f, 1.2f, 0), speed);
        }
        else if (shore == 1 && seat == 1) {
            action1 = CCMoveToAction.GetSSAction(new Vector3(5f, 2.7f, 0), speed);
            action2 = CCMoveToAction.GetSSAction(new Vector3(5f, 1.2f, 0), speed);
        }

        CCSequenceAction saction = CCSequenceAction.GetSSAction(0, 0, new List<SSAction> { action1, action2 });
        this.RunAction(people, saction, this);
    }

    public void getOffBoat(GameObject people, int shoreNum) {
        action1 = CCMoveToAction.GetSSAction(new Vector3(people.transform.position.x, 2.7f, 0), speed);
        if (shoreNum == 0)  action2 = CCMoveToAction.GetSSAction(new Vector3(-16f + 1.5f * System.Convert.ToInt32(people.name), 2.7f, 0), speed);
        else action2 = CCMoveToAction.GetSSAction(new Vector3(16f - 1.5f * System.Convert.ToInt32(people.name), 2.7f, 0), speed);

        CCSequenceAction saction = CCSequenceAction.GetSSAction(0, 0, new List < SSAction >{ action1, action2});
        this.RunAction(people, saction, this);
    }

    protected void Start() {
        scene = (FirstController)SSDirector.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) {
        Debug.Log("Done");
    }
}

其中UserGUI是挂在摄像机上的，CCActionManager和FirstController是挂在Main对象上的。
由于代码。。大多数都是参考老师的框架。。所以我先投为转的吧。

效果

gif录制器突然。。找不到了。。找几个过场图片撑撑场面。
这里写图片描述
结果。。输了。。

Yjl_Richard
关注
专栏目录
牧师与魔鬼——动作分离版
EmilyBluse的博客
04-10 641
牧师与魔鬼——动作分离版 在上周的作业中，牧师与魔鬼游戏中的各个事件，都是写在Director中，并且都是继承Monobehavior的。在这周动作分离的设计中，我将上船、下船以及船的移动都分离出来。参照老师给的设计模式，画出简略的UML图如下： 面向对象设计UML图 动作序列 在这里的设计中，参照之前师兄的设计模式，可以将动作序列分成如下几个: 文件名 功...
牧师与魔鬼-动作分离版
Edith的博客
10-04 236
1. 动作分离 目的：将物体的动作与空间属性分开来，从而降低耦合，易于开发者维护 实现方案：新增一个动作管理类，实现如下 2. 设计一个裁判类，当游戏达到结束条件时，通知场景控制器游戏结束 ...
牧师与魔鬼 动作分离版
qq_36184359的博客
04-10 321
牧师与魔鬼 动作分离版 目标 ​ 建立动作管理器，使动作抽象出来，可以应用到任何游戏对象上，以此提高代码复用性。 UML图 核心设计 ​ 将GenGameObject类物体移动的代码放在MoveToAction的类中，然后用ActionManager类对物体对象的动作进行管理，也就是说GenGameObject类的Update()不再进行物体的移动，而是在MoveTo...
Unity3d牧师与魔鬼动作分离版
hellowangld的博客
04-10 436
关于牧师与魔鬼动作分离版，这里只介绍动作管理器的部分，有需要者请结合我的上一篇博客：牧师与魔鬼，加深理解。 动作管理器的设计： 一开始，我们先创建一下几个类： 1. 动作基类：public class SSAction : ScriptableObject{} 2. 简单动作实现类： public class SSMoveToAction : SSAction {} 3. 组合动作实现类...
基于unity实现的牧师与魔鬼 动作分离版【unity课程大作业】
最新发布
06-24
【作品名称】：基于unity实现的牧师与魔鬼 动作分离版【unity课程大作业】 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目...
Unity3d入门之路-牧师与魔鬼 动作分离版
sir_beginner的博客
09-29 261
文章目录牧师与魔鬼 动作分离版实现过程Action模块Judge实现代码与视频 牧师与魔鬼 动作分离版 【2019新要求】：设计一个裁判类，当游戏达到结束条件时，通知场景控制器游戏结束 实现过程 什么是动作分离版呢？还记得我们上个版本的牧师与魔鬼为了实现character与boat的移动，实现了一个Moveable的脚本，并把此脚本作为组件加到character与boat上了。然而这样的实现方...
3D游戏 | 场景的搭建 + 牧师与魔鬼
Metamorphosis_Anja的博客
09-29 668
基本操作演练 下载 Fantasy Skybox FREE， 构建自己的游戏场景 在Assert Store搜索Fantasy Skybox FREE并下载，下好之后import进项目中。 Fantasy Skybox FREE中提供了四种天空，以及一些花草、地形的Demo。 首先创建一个地形，我这个地形应该是群山。 接下来给山上种上草，首先用layer，再用细节画笔画上小草，然后将...
3D游戏编程实践——Priests and Devils（动作分离版）
ctlchild的博客
09-26 194
编程实践——Priests and Devils 动作分离版 Priests and Devils is a puzzle game in which you will help the Priests and Devils to cross the river within the time limit. There are 3 priests and 3 devils at one side...
Unity3d学习之路-牧师与魔鬼V2(动作分离版)
C486C的博客
04-08 1269
Unity3d学习之路-牧师与魔鬼V2(动作分离版) 该版本改进的目的 把每个需要移动的游戏对象的移动方法提取出来，建立一个动作管理器来管理不同的移动方法。 对于上一个版本，每一个可移动的游戏对象的组件都有一个Move脚本，当游戏对象需要移动时候，游戏对象自己调用Move脚本中的方法让自己移动。而动作分离版，则剥夺了游戏对象自己调用动作的能力，建立一个动作管理器，通过场景控制器(在我的游...
游戏对象与图形基础——牧师与魔鬼（动作分离版）
weixin_43960457的博客
10-09 555
文章目录游戏对象与图形基础——牧师与魔鬼（动作分离版）一、基本操作演练1.1 下载 Fantasy Skybox FREE， 构建自己的游戏场景1.2 总结：二、牧师与魔鬼（动作分离版）2.1 UML图2.2 程序实现： 游戏对象与图形基础——牧师与魔鬼（动作分离版） 一、基本操作演练 1.1 下载 Fantasy Skybox FREE， 构建自己的游戏场景 首先在Asset Store中，下载Fantasy Skybox FREE素材包，之后再unity中导入。 之后，我们可以看到素材包中包含了天空盒
Unity3D游戏编程-牧师与恶魔 动作分离版
学习记录
10-19 550
Unity3D游戏编程-牧师与恶魔 动作分离版 文章目录Unity3D游戏编程-牧师与恶魔 动作分离版作业要求项目配置项目演示视频演示项目下载文字说明项目截图实现过程和方法(算法）裁判类Judge遇到的问题动作分离FirstSceneActionManagerActionManager与ObjActionActionCallback参考资料 作业要求 牧师与魔鬼的动作分离版。 设计一个裁判类，当游戏达到结束条件时，通知场景控制器游戏结束。 项目配置 Windows 10 Unity 2020.3.17f1
魔鬼与牧师动作分离版
xuyq23的博客
04-11 236
关于动作分离。可以通过对游戏对象增加可执行的动作，可以划分出很多的基础动作，如上船，下船，前进后退等。所以我们可以通过提取基础动作，然后使用类的方法来执行游戏对象的动作，同时通过配备动作管理者，让其去调度游戏对象执行动作。动作管理者-SSActionManager通过创教类来管理动作的集合，动作做完自动回收。并且展示了集合对象的使用方法。并且要执行start()方法。publicclass SSA...
Unity3D学习（4）之分离动作管理器的3D版牧师与魔鬼
zzj051319的博客
03-18 2549
上次作业做完之后，我一直有一个疑问，场记需要做的事情实在太多了，既需要载入资源，也需要控制数据，显得很臃肿。即使写再多的接口，你的函数实现仍然要在场记里面。到了下一节课，老师讲了动作管理器，将动作从场记里面解放出来了。
牧师与魔鬼
qq_40326198的博客
09-21 776
作业内容 1、简答并用程序验证【建议做】 游戏对象运动的本质是什么？ 请用三种方法以上方法，实现物体的抛物线运动。（如，修改Transform属性，使用向量Vector3的方法…） 写一个程序，实现一个完整的太阳系， 其他星球围绕太阳的转速必须不一样，且不在一个法平面上。 2、编程实践 阅读以下游戏脚本 Priests and Devils Priests and Devils is a...
Unity3D：牧师与魔鬼
yoyo_hu的博客
10-08 1150
unity3D游戏设计之牧师与魔鬼 3d游戏编程与设计作业博客 附有完整代码以及配置方法
Unity——牧师与魔鬼
qq_56266553的博客
10-23 556
游戏对象运动的本质，就是游戏对象跟随每一帧发生变化的过程。在变化的过程中，主要是指游戏对象的transform中的rotation与position两个属性。其中，rotation是指游戏对象所处位置的角度变化，而position则是指游戏对象在坐标系中位置的改变。河岸（Coast）、船（Boat）、河流（River）、魔鬼（Devils）、牧师（Priests）第三种：调用transform中的translate函数来改变position。列出游戏中提及的事物（Objects）第二种：添加重力特性。
Unity3D 牧师与魔鬼
hellowangld的博客
04-03 658
使用MVC结构编程 首先，我针对这个游戏总结了UML图，明确了我需要哪些函数，哪些类来支持游戏的实现： GameModel 从图上我们可以看出我们需要4个GameModel，分别是： moveable：用于控制角色和船的移动。 CoastController：用于控制与河岸有关的动作，比如角色上下岸，船的离开和停靠。 MyCharacterController：用于控制6个角色的动作...
3D-03-牧师与魔鬼
liytN的博客
10-06 412
本文是3D游戏编程与设计第三次作业的博客，内容为游戏“牧师与魔鬼(Priests and Devils)”的编程 目录游戏规则游戏脚本具体内容游戏设计列出游戏中提及的事物（Objects）用表格列出玩家动作表（规则表）制作对象预制程序架构代码展示成果展示 游戏规则 游戏脚本 Priests and Devils Priests and Devils is a puzzle game in which you will help the Priests and Devils to cross the riv
牧师与野人问题求解c#
11-10
以下是C#语言实现牧师与野人问题求解的代码和注释： ```csharp using System; using System.Collections.Generic; namespace MissionariesAndCannibals { class Program { static void Main(string[] args) { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值