Priests and Devils

最新推荐文章于 2019-09-26 17:07:18 发布
最新推荐文章于 2019-09-26 17:07:18 发布
阅读量433 收藏
点赞数
分类专栏： unity3D
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33454112/article/details/68631891
版权

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 of the river. They all want to get to the other side of this river, but there is only one boat and this boat can only carry two persons each time. And there must be one person steering the boat from one side to the other side. In the flash game, you can click on them to move them and click the go button to move the boat to the other direction. If the priests are out numbered by the devils on either side of the river, they get killed and the game is over. You can try it in many ways. Keep all priests alive! Good luck!
Please click here to play the gamePriests and Devils

1.列出游戏中提及的事物（Objects）

答：这个游戏中的事物有游戏角色：3个牧师、3个恶魔；
游戏场景：2个草地河岸、一艘小船；
游戏控件：开始、运动、重试按钮，时间提示；

2.请使用课件架构图编程，不接受非 MVC 结构程序

答：使用三个文件实现MVC架构设计，分别为：
Basecode.cs V
GenGameObjects M
SceneController C
这里写图片描述

3.在 GenGameObjects 中创建 长方形、正方形、球 及其色彩代表游戏中的对象。

答：Devil: 恶魔
Priset:牧师
Shore:河岸
Boat:船
创建效果如下图：
这里写图片描述

4.用表格列出玩家动作表（规则表），注意，动作越少越好

项目条件动作
开船船在开始岸、船在结束岸船开到对面岸
船的左方/右方下船船靠岸且船左方/右方有对象左边/右边对象下船上岸
左边/右边岸上船船在左边/右边岸，船有空位，岸上有对象对象坐上船左方/右方
判断结束任意一边岸与船上恶魔数量大于牧师游戏结束

5.实验代码

在上述设计后对内容进行了修改，不再使用预设，而是代码动态生成

Action.cs
using UnityEngine;
using System.Collections;
using Com.Mygame;

public class Actions : MonoBehaviour
{
    GameSceneController mygame;
    ImyAction actions;
    float BottonW = Screen.width / 4;
    float BottonH = Screen.height / 16;
    float firstBx = Screen.width / 4;
    float firstBy = Screen.height / 8;
    float blank = 5;
    private string str = "点击重置！";
    // Use this for initialization
    void Start()
    {

        mygame = GameSceneController.GetInstance();
        actions = GameSceneController.GetInstance() as ImyAction;
    }

    void OnGUI()
    {

        if (GUI.Button(new Rect(firstBx, firstBy, BottonW, BottonH), "魔鬼上船"))
        {
            actions.DevilGoOnBoat();
        }
        if (GUI.Button(new Rect(firstBx + BottonW + blank, firstBy, BottonW, BottonH), "魔鬼下船"))
        {
            actions.DevilGoOffBoat();
        }
        if (GUI.Button(new Rect(firstBx, firstBy + BottonH + blank, BottonW, BottonH), "牧师上船"))
        {
            actions.PriestGoOnBoat();
        }
        if (GUI.Button(new Rect(firstBx + BottonW + blank, firstBy + BottonH + blank, BottonW, BottonH), "牧师下船"))
        {
            actions.PriestGoOffBoat();
        }
        if (GUI.Button(new Rect(firstBx, firstBy + (BottonH + blank) * 2, BottonW * 2 + blank, BottonH * 2), "开船！"))
        {
            actions.BoatGo();
            if (mygame.wl == WinOrLose.Gaming) str = "点击重置！";
            else if (mygame.wl == WinOrLose.Lose) str = "输了...重来！";
            else if (mygame.wl == WinOrLose.Win) str = "赢了！再来！";
        }

        if (GUI.Button(new Rect(Screen.width - BottonW / 2, firstBy, BottonW / 2, BottonH), str))
        {
            Application.LoadLevel(Application.loadedLevelName);
            mygame.wl = WinOrLose.Gaming;
        }

        //GUI.Label (new Rect (firstBx,firstBy-BottonH,BottonW*2,BottonH), str);

    }
}
BaseCode.cs
using UnityEngine;
using System.Collections;
using Com.Mygame;

namespace Com.Mygame
{

    public enum WinOrLose { Win, Lose, Gaming };

    public interface ImyAction
    {
        void DevilGoOnBoat();
        void DevilGoOffBoat();
        void PriestGoOnBoat();
        void PriestGoOffBoat();
        void BoatGo();
    }

    public class GameSceneController : System.Object, ImyAction
    {
        private static GameSceneController _instance;
        private BaseCode _base_code;
        private GenGameObjects _gen_game_object;

        public WinOrLose wl = WinOrLose.Gaming;

        public static GameSceneController GetInstance()
        {
            if (null == _instance)
            {
                _instance = new GameSceneController();
            }
            return _instance;
        }

        public BaseCode getBaseCode()
        {
            return _base_code;
        }

        internal void setBaseCode(BaseCode bc)
        {
            if (null == _base_code)
            {
                _base_code = bc;
            }
        }

        public GenGameObjects getGenGameObject()
        {
            return _gen_game_object;
        }

        internal void setGenGameObject(GenGameObjects g)
        {
            if (_gen_game_object == null)
            {
                _gen_game_object = g;
            }
        }

        public void DevilGoOnBoat()
        {
            _gen_game_object.DevilGoOnBoat();
        }

        public void DevilGoOffBoat()
        {
            _gen_game_object.DevilGoOffBoat();
        }

        public void PriestGoOnBoat()
        {
            _gen_game_object.PriestGoOnBoat();
        }

        public void PriestGoOffBoat()
        {
            _gen_game_object.PriestGoOffBoat();
        }

        public void BoatGo()
        {
            _gen_game_object.BoatGo();
        }
    }
}

public class BaseCode : MonoBehaviour
{

    public string gameName;
    public string gameRule;


    // Use this for initialization
    void Start()
    {
        this.transform.position = new Vector3(0.0f, 5.0f, -12.0f);
        GameSceneController mygame = GameSceneController.GetInstance();
        mygame.setBaseCode(this);
    }

    // Update is called once per frame
    void Update()
    {

    }
}
GenGameObject.cs
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using Com.Mygame;

public class GenGameObjects : MonoBehaviour
{

    GameSceneController mygame;
    //boat
    int state = 0;
    GameObject Boat;
    Vector3 boatscale = new Vector3(4.0f, 0.3f, 2.0f);  //boat's size;
    Vector3 boatStartpos = new Vector3(-6.0f, 0.0f, 0.0f);
    Vector3 boatEndpos = new Vector3(6.0f, 0.0f, 0.0f);
    // sits on the boat
    Vector3 boatsit1 = new Vector3(-0.25f, 3.45f, 0.0f); //  localposition is care with the scale
    Vector3 boatsit2 = new Vector3(0.25f, 3.45f, 0.0f);
    // others about boats
    float boatspeed = 1.0f;
    int boatnumber = 0;
    int Ifboatsit1have = 0;
    int Ifboatsit2have = 0;
    //river


    //Devils
    List<GameObject> devils = new List<GameObject>();
    Vector3[] devilStartpos = new Vector3[3]{
        new Vector3(-10f,1.15f,-3f),
        new Vector3(-10f,1.15f,-2f),
        new Vector3(-10f,1.15f,-1f)
    };
    Vector3[] devilEndpos = new Vector3[3]{
        new Vector3(10f,1.15f,-3f),
        new Vector3(10f,1.15f,-2f),
        new Vector3(10f,1.15f,-1f)
    };
    Vector3[] devilScale = new Vector3[3]{
        new Vector3(),
        new Vector3(),
        new Vector3()
    };
    int[] DevilsState = new int[3] { 0, 0, 0 }; // 0-startside 1-endside 2-onboat
    int[] Devilssite = new int[3] { 0, 0, 0 }; //0表示 nosite 1-1site 2-2site

    int devilStartside = 3;
    int devilEndside = 0;

    //Priest
    List<GameObject> priests = new List<GameObject>();
    Vector3[] priestStartpos = new Vector3[3]{
        new Vector3(-10f,1.15f,1f),
        new Vector3(-10f,1.15f,2f),
        new Vector3(-10f,1.15f,3f)
    };
    Vector3[] prisetEndpos = new Vector3[3]{
        new Vector3(10f,1.15f,1f),
        new Vector3(10f,1.15f,2f),
        new Vector3(10f,1.15f,3f)
    };
    Vector3[] priestScale = new Vector3[3]{
        new Vector3(),
        new Vector3(),
        new Vector3()
    };

    int[] PriestState = new int[3] { 0, 0, 0 }; // 0-startside 1-endside 2-onboat
    int[] Priestsite = new int[3] { 0, 0, 0 };

    int priestStartside = 3;
    int priestEndside = 0;

    // startside
    GameObject startside;
    Vector3 startsidepos = new Vector3(-10.0f, 0.0f, 0.0f);
    Vector3 startsidescale = new Vector3(4f, 0.3f, 8f);
    // endside
    GameObject endside;
    Vector3 endsidepos = new Vector3(10.0f, 0.0f, 0.0f);
    Vector3 endsidescale = new Vector3(4f, 0.3f, 8f);

    // Use this for initialization
    void Start()
    {
        mygame = GameSceneController.GetInstance();
        mygame.setGenGameObject(this);
        InsAll();
    }

    // Update is called once per frame
    void Update()
    {

        float step = boatspeed * Time.deltaTime;
        if (state == 2)
        {
            Boat.transform.position = Vector3.MoveTowards(Boat.transform.position, boatEndpos, boatspeed);
            if (Boat.transform.position == boatEndpos) state = 1;
        }
        else if (state == 3)
        {
            Boat.transform.position = Vector3.MoveTowards(Boat.transform.position, boatStartpos, boatspeed);
            if (Boat.transform.position == boatStartpos) state = 0;
        }
    }



    // ins all gameobjects
    void InsAll()
    {
        //sides
        startside = GameObject.CreatePrimitive(PrimitiveType.Cube);
        startside.transform.localScale = startsidescale;
        startside.transform.position = startsidepos;
        startside.GetComponent<Renderer>().material.color = Color.green;
        endside = GameObject.CreatePrimitive(PrimitiveType.Cube);
        endside.transform.localScale = endsidescale;
        endside.transform.position = endsidepos;
        endside.GetComponent<Renderer>().material.color = Color.green;
        //boat
        Boat = GameObject.CreatePrimitive(PrimitiveType.Cube);
        Boat.transform.position = boatStartpos;
        Boat.transform.localScale = boatscale;
        Boat.GetComponent<Renderer>().material.color = Color.grey;
        //devils and Priests
        for (int i = 0; i < 3; i++)
        {
            GameObject devil = GameObject.CreatePrimitive(PrimitiveType.Cylinder);
            devil.GetComponent<Renderer>().material.color = Color.red;
            devil.transform.position = devilStartpos[i];
            devils.Add(devil);
            GameObject priest = GameObject.CreatePrimitive(PrimitiveType.Cylinder);
            priest.transform.position = priestStartpos[i];
            priests.Add(priest);

        }

        //light !!cool
        GameObject light = new GameObject("The light");
        Light lightComp = light.AddComponent<Light>();
        lightComp.type = LightType.Directional;
        light.transform.position = new Vector3();
        Quaternion Q;
        Q = Quaternion.Euler(20.0f, 0.0f, 0.0f);
        light.transform.rotation = Q;

    }

    public void DevilGoOnBoat()
    { // must write by public ,or the interface can not use it
        if (state == 0)
        { //startside
            if (boatnumber != 2)
            {
                for (int i = 0; i < 3; i++)
                {
                    if (DevilsState[i] == 0)
                    {

                        DevilsState[i] = 2;//mean now this devil's state is on boat

                        devils[i].transform.parent = Boat.transform;

                        if (Ifboatsit1have == 0 && Ifboatsit2have == 0)
                        {
                            devils[i].transform.localPosition = boatsit1;
                            Devilssite[i] = 1;
                            Ifboatsit1have = 1;
                        }
                        else if (Ifboatsit1have == 1 && Ifboatsit2have == 0)
                        {
                            devils[i].transform.localPosition = boatsit2;
                            Devilssite[i] = 2;
                            Ifboatsit2have = 1;
                        }
                        else if (Ifboatsit1have == 0 && Ifboatsit2have == 1)
                        {
                            devils[i].transform.localPosition = boatsit1;
                            Devilssite[i] = 1;
                            Ifboatsit1have = 1;
                        }

                        devilStartside--;
                        boatnumber++;
                        break;
                    }
                }
            }
        }
        else if (state == 1)
        { // endside
            if (boatnumber != 2)
            {
                for (int i = 0; i < 3; i++)
                {
                    if (DevilsState[i] == 1)
                    {

                        DevilsState[i] = 2;//mean now this devil's state is on boat
                        devils[i].transform.parent = Boat.transform;

                        if (Ifboatsit1have == 0 && Ifboatsit2have == 0)
                        {
                            devils[i].transform.localPosition = boatsit1;
                            Devilssite[i] = 1;
                            Ifboatsit1have = 1;
                        }
                        else if (Ifboatsit1have == 1 && Ifboatsit2have == 0)
                        {
                            devils[i].transform.localPosition = boatsit2;
                            Devilssite[i] = 2;
                            Ifboatsit2have = 1;
                        }
                        else if (Ifboatsit1have == 0 && Ifboatsit2have == 1)
                        {
                            devils[i].transform.localPosition = boatsit1;
                            Devilssite[i] = 1;
                            Ifboatsit1have = 1;
                        }

                        devilEndside--;
                        boatnumber++;
                        break;
                    }
                }
            }
        }
    }

    public void DevilGoOffBoat()
    {
        if (state == 0)
        { // startside
            for (int i = 0; i < 3; i++)
            {
                if (DevilsState[i] == 2)
                {
                    devils[i].transform.parent = null;
                    devils[i].transform.position = devilStartpos[i];
                    DevilsState[i] = 0;

                    if (Devilssite[i] == 1)
                        Ifboatsit1have = 0;
                    else if (Devilssite[i] == 2)
                        Ifboatsit2have = 0;
                    Devilssite[i] = 0;

                    devilStartside++;
                    boatnumber--;
                    break;
                }
            }
        }
        else if (state == 1)
        { // endside
            for (int i = 0; i < 3; i++)
            {
                if (DevilsState[i] == 2)
                {
                    devils[i].transform.parent = null;
                    devils[i].transform.position = devilEndpos[i];
                    DevilsState[i] = 1;

                    if (Devilssite[i] == 1)
                        Ifboatsit1have = 0;
                    else if (Devilssite[i] == 2)
                        Ifboatsit2have = 0;
                    Devilssite[i] = 0;

                    devilEndside++;
                    boatnumber--;
                    break;
                }
            }
        }
    }

    public void PriestGoOnBoat()
    {
        if (state == 0)
        { //startside
            if (boatnumber != 2)
            {
                for (int i = 0; i < 3; i++)
                {
                    if (PriestState[i] == 0)
                    {

                        PriestState[i] = 2;//mean now this devil's state is on boat
                        priests[i].transform.parent = Boat.transform;

                        if (Ifboatsit1have == 0 && Ifboatsit2have == 0)
                        {
                            priests[i].transform.localPosition = boatsit1;
                            Priestsite[i] = 1;
                            Ifboatsit1have = 1;
                        }
                        else if (Ifboatsit1have == 1 && Ifboatsit2have == 0)
                        {
                            priests[i].transform.localPosition = boatsit2;
                            Priestsite[i] = 2;
                            Ifboatsit2have = 1;
                        }
                        else if (Ifboatsit1have == 0 && Ifboatsit2have == 1)
                        {
                            priests[i].transform.localPosition = boatsit1;
                            Priestsite[i] = 1;
                            Ifboatsit1have = 1;
                        }

                        priestStartside--;
                        boatnumber++;
                        break;
                    }
                }
            }
        }
        else if (state == 1)
        { // endside
            if (boatnumber != 2)
            {
                for (int i = 0; i < 3; i++)
                {
                    if (PriestState[i] == 1)
                    {

                        PriestState[i] = 2;//mean now this devil's state is on boat
                        priests[i].transform.parent = Boat.transform;

                        if (Ifboatsit1have == 0 && Ifboatsit2have == 0)
                        {
                            priests[i].transform.localPosition = boatsit1;
                            Priestsite[i] = 1;
                            Ifboatsit1have = 1;
                        }
                        else if (Ifboatsit1have == 1 && Ifboatsit2have == 0)
                        {
                            priests[i].transform.localPosition = boatsit2;
                            Priestsite[i] = 2;
                            Ifboatsit2have = 1;
                        }
                        else if (Ifboatsit1have == 0 && Ifboatsit2have == 1)
                        {
                            priests[i].transform.localPosition = boatsit1;
                            Priestsite[i] = 1;
                            Ifboatsit1have = 1;
                        }

                        priestEndside--;
                        boatnumber++;
                        break;
                    }
                }
            }
        }
    }

    public void PriestGoOffBoat()
    {
        if (state == 0)
        { // startside
            for (int i = 0; i < 3; i++)
            {
                if (PriestState[i] == 2)
                {
                    priests[i].transform.parent = null;
                    priests[i].transform.position = priestStartpos[i];
                    PriestState[i] = 0;
                    if (Priestsite[i] == 1)
                        Ifboatsit1have = 0;
                    else if (Priestsite[i] == 2)
                        Ifboatsit2have = 0;
                    Priestsite[i] = 0;
                    priestStartside++;
                    boatnumber--;
                    break;
                }
            }
        }
        else if (state == 1)
        { // endside
            for (int i = 0; i < 3; i++)
            {
                if (PriestState[i] == 2)
                {
                    priests[i].transform.parent = null;
                    priests[i].transform.position = prisetEndpos[i];
                    PriestState[i] = 1;

                    if (Priestsite[i] == 1)
                        Ifboatsit1have = 0;
                    else if (Priestsite[i] == 2)
                        Ifboatsit2have = 0;
                    Priestsite[i] = 0;
                    priestEndside++;
                    boatnumber--;
                    break;
                }
            }
        }
    }

    public void BoatGo()
    {
        if (boatnumber != 0)
        {
            check();
            if (state == 0)
            {
                // from startpos to endpos,move
                state = 2;
            }
            else if (state == 1)
            {
                state = 3;
                // form endpos to startpos,move
            }
        }
    }

    public void check()
    {
        //lose check
        print(devilStartside);
        print(devilEndside);
        print(priestStartside);
        print(priestEndside);
        if (state == 0)
        {
            if ((devilStartside > priestStartside && priestStartside != 0) || ((3 - devilStartside) > (3 - priestStartside) && (3 - priestStartside) != 0))
            {
                mygame.wl = WinOrLose.Lose;
                return;
            }
        }
        else if (state == 1)
        {
            if ((devilEndside > priestEndside && priestEndside != 0) || ((3 - devilEndside) > (3 - priestEndside) && (3 - priestEndside) != 0))
            {
                mygame.wl = WinOrLose.Lose;
                return;
            }
        }
        //win check
        if (devilStartside == 0 && priestStartside == 0) mygame.wl = WinOrLose.Win;

    }
}

(代码参考师兄博客)

tomyleee
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
unity3D-H3
住在地球仪上的小刺猬的博客
09-18 378
作业内容 1、简答并用程序验证【建议做】 游戏对象运动的本质是什么？ 》游戏对象的运动，在本质上是在离散的时间点上，物体按照物理引擎说运算出的，呈现出不同的位置。游戏对象跟随每一帧的变化，空间地变化。这里的空间变化包括了游戏对象的transform属性中的position跟rotation两个属性。一个是绝对或者相对位置的改变，一个是所处位置的角度的旋转变化。 请用三种方法以上方法，实现物...
牧师与魔鬼Priests and Devils--unity小游戏
最新发布
weixin_70964175的博客
10-21 230
为了辅助表达游戏对象的设计，在这里通过UML图画出主要的对象以及它们之间的关系：在这里给出上述个对象的简介：IUserAction：作为动作接口，定义了四个函数，分别是移动船只（MoveBoat）、移动角色（MoveRole）、检查游戏是否结束（Check）、重新开始游戏（Restart）。ISceneController：作为场景接口，定义了两个函数，分别是加载资源（LoadResource）、销毁资源（destroyResource）。
[Unity3D课堂作业] Priests and Devils 牧师与恶魔
MokHoYin的博客
02-25 884
先把游戏效果po一下吧（白色胶囊体代表牧师、红色胶囊体代表魔鬼、蓝色代表船、两条白色圆柱体代表两岸）： 这次作业与TA的实现方法稍有不同，多用了两个类：PersonStatus（动态加载到6个牧师和恶魔上）用来管理角色上船（即下岸）以及上岸（即下船）的行为；BoatBehaviour（动态加载到船上）用来管理船的移动行为。同时增加了一个IGameJudge接口，用于判断胜利/失败
[Unity3D课堂作业] 改进版：Priests and Devils 牧师与恶魔
MokHoYin的博客
03-11 840
还是先po一下效果咯~~ 这次作业其实就是：将上次作业在Update()函数一帧帧改位置控制运动，改为类似cocos2d的一个Action方法控制物体自己运动，也就是所谓的面向对象的设计。但其实本质上还是在每一帧的时间里做改动。 课件上面那个设计框架基本上可以plug and play 即插即用，所以就直接套过来用了，只需要在CCActionManager处与上次作业的
系统分析与设计——领域模型作图实例
a1211545688的博客
04-22 4862
工具——UMLet 网盘下载，提取码：i3k5 案例——牧师与魔鬼 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...
【学习小记】UML——概念类图
热门推荐
gstrong98
03-31 2万+
这学期接触了《系统设计与分析》这门课，重要，但是觉得挺不好学的，因为好像很多决策都不存在很明确的界限。所以，多思多想多交流吧，看一些相关的案例还是有些帮助的。现在把自己学习时的一些想法与大家分享，初写这类博客，有错请指出，共同进步。 概念类图（conceptual  class  diagram）其实是领域模型（domain  model）中的一个术语，要理解概念类图，先要了解一下什么是领域模型
Olympus_of_the_Priests:Игра
03-19
《Olympus_of_the_Priests》是一款游戏，它的开发很可能采用了C#编程语言，这是一种在游戏开发领域广泛应用的语言，以其高效、灵活和强大的库支持而著名。C#由微软公司开发，最初是为了.NET框架而设计，现在已经成为...
example-dapp-high-priests:神秘的社会捐赠应用程序。 用它来学习 rDAI API！
05-30
大祭司 大祭司是住在 在 24 小时内制作 <3 @ ETH Denver 2020 :trophy: 感谢这些出色的赏金赞助商：Maker、3Box 和 TheGraph :rocket: 快速开始 这个 dapp 可以帮助您了解如何使用 rDAI API ( )。...
Json-Cell:CLua5关联内存机器
03-27
They were the priests of the Eye - Be - Machine I AM MACHINE IT SAID . Json超图机。 超图 具有云智能指导系统的完全可编程的关联存储系统。 细胞核 每个单元机器至少具有一个内核。 它具有根单元和至少1个...
unity3D-learnin：Priests and Devils
tangyt77的博客
04-03 299
阅读以下游戏脚本Priests and DevilsPriests 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 of th...
3D游戏编程与设计3——空间与运动
qiao_zhang的博客
09-21 588
1、简答并用程序验证 游戏对象运动的本质是什么？ 请用三种以上方法，实现物体的抛物线运动。（如，修改 Transform 属性，使用向量 Vector3 的方法…） 写一个程序，实现一个完整的太阳系，其他星球围绕太阳的转速必须不一样，且不在一个法平面上。 2、编程实践 阅读以下游戏脚本 Priests and Devils Priests and Devils is a puzzle g...
3D游戏编程实践——Priests and Devils
ctlchild的博客
09-18 485
编程实践——Priests and Devils github链接：https://github.com/ctlchild/SYSU-unity3d-learning/tree/master/hw2 Priests and Devils is a puzzle game in which you will help the Priests and Devils to cross the rive...
Unity-3D |作业二
Vickyiiiiii的博客
09-20 288
简答题 游戏对象运动的本质是什么？ 游戏对象运动的本质是游戏对象transform属性的position、rotation和scale等属性随每一帧的变化。 请用三种方法以上方法，实现物体的抛物线运动。（如，修改Transform属性，使用向量Vector3的方法…） 利用position矢量相加分为水平和竖直两个方向的运动来实现 using System.Collections;...
3d学习笔记（二）——游戏对象的运动
第五清风的博客
03-30 1483
简答题简答并用程序验证游戏对象运动的本质是什么？请用三种方法以上方法，实现物体的抛物线运动。（如，修改Transform属性，使用向量Vector3的方法…）写一个程序，实现一个完整的太阳系， 其他星球围绕太阳的转速必须不一样，且不在一个法平面上。游戏对象运动的本质游戏对象运动的本质，其实是游戏对象跟随每一帧的变化，空间地变化。这里的空间变化包括了游戏对象的transform属性中的positio...
Priests-and-Devils - Unity3D作业
WeiXiaoAssassin的博客
09-22 312
Priests-and-Devils - Unity3D作业 文章目录Priests-and-Devils - Unity3D作业列出游戏中提及的事物（Objects）用表格列出玩家动作表（规则表），注意，动作越少越好请将游戏中对象做成预制MVC 结构程序结构分析游戏界面 视频地址：HERE 博客地址：HERE 原游戏地址：HERE 作业要求： 整个游戏仅 主摄像机 和 一个 Empty 对象，...
3D游戏编程实践——Priests and Devils（动作分离版）
ctlchild的博客
09-26 188
编程实践——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问答题及简单计算器
自信打不死的心态活到老
03-31 1847
1.解释对象与资源的区别与联系，根据官方案例，分别总结资源和对象组织的规则/规律。答：在显式支持面向对象的语言中，”对象”一般是指类在内存中装载的实例，具有相关的成员变量和成员函数(也称为方法)。对象一般都是直接体现于游戏的场景中，整合了各种游戏的资源。对象一般指游戏中玩家、队友、敌人、周围生物、环境事物、摄像机和音乐等虚拟父类，这些父节点本身没有实体，但它们的子类真正包含了游戏中会出现的对象。而资
动画案例及设计模式研究
自信打不死的心态活到老
04-24 1314
一、设计模式主要分为三类：1. 创建者模式2.结构性模式3.行为模式<一>创建者模式是创建型模式中最负责的一个设计模式了，创建者负责构建一个对象的各个部分，并且完成组装的过程，我们可以这么理解创建者模式，创建者模式类似与一个步骤基本固定，但是每个步骤中的具体形式却又可以变化的这类对象的创建。创建者模式主要是用于创建复杂的一些对象，这些对象的创建步骤基本固定，但是可能具体的对象的组成部分却又可以自由的
用c++代码实现假如有n个牧师和n个野人准备渡河，但只有一条能容纳c个人的小船，为了防止野人侵犯牧师，要求无论在何处，牧师的人数不得少于野人的人数（除非牧师人数为0），且假定两种人都会划船，试设计一个算法，确定它们能否渡过河去，若能，则给出一只小船来回次数最少的最佳方案。
05-25
cout << "Please input the number of priests and devils (n): "; cin >> n; cout (c): "; cin >> c; StateInfo start = {n, n, 0, 0, LEFT, ""}; StateInfo target = {0, 0, n, n, RIGHT, ""}; if (find...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值