离散仿真引擎基础及Unity3D入门编程实践

于 2023-10-09 16:32:38 发布
阅读量185 收藏
点赞数 1
文章标签： 游戏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63734223/article/details/133701283
版权

一、简答题：离散仿真引擎基础

  • 解释 游戏对象（GameObjects） 和 资源（Assets）的区别与联系。

区别：
游戏对象(GameObjects)：相当于一个容器，可以容纳组件。它们本身不做任何事情，需要特殊属性(special properties)才能成为一个角色、一种环境或者一种特殊效果
资源(Assets)：在项目中可以导入使用的文件，包括图像、视频、脚本文件、预制文件等
联系：
游戏对象可以通过资源保存起来
资源可以用来创建对象实例
一个资源可以创建多个对象

  • 下载几个游戏案例，分别总结资源、对象组织的结构（指资源的目录组织结构与游戏对象树的层次结构）

总结：

资源的目录组织结构：

Assets：主文件夹，包含所有工程需要用到的资源

Editor：所有在Editor和它的子文件夹的脚本，都不会作为运行期脚本被编译，而是作为动态添加Unity编译器功能的脚本来编译，在该文件夹和其子文件夹的脚本不能被添加到GameObject上

Materials：材料

Models：模型

Prefabs：预设

Scenes：场景

Textures：纹理

Scripts：C#脚本

游戏对象树的层次结构的组织则主要是一个继承或是组合/聚合的关系

  • 编写一个代码，使用 debug 语句来验证 MonoBehaviour 基本行为或事件触发的条件
    • 基本行为包括 Awake() Start() Update() FixedUpdate() LateUpdate()
    • 常用事件包括 OnGUI() OnDisable() OnEnable()

 代码如下：

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

public class Test : MonoBehaviour
{
    private void Awake()
    {
        Debug.Log("awake\n");
    }
    // Start is called before the first frame update
    void Start()
    {
        Debug.Log("start\n");
    }

    // Update is called once per frame
    void Update()
    {
        Debug.Log("update\n");
    }

    private void FixedUpdate()
    {
        Debug.Log("fixed-update\n");
    }

    private void OnEnable()
    {
        Debug.Log("on-enbale\n");
    }

    private void OnDisable()
    {
        Debug.Log("on-disable\n");
    }
    private void OnGUI()
    {
        Debug.Log("on-GUI\n");
    }
}
  • 查找脚本手册，了解 GameObject，Transform，Component 对象
    • 分别翻译官方对三个对象的描述（Description）

GameObject：Unity场景中所有实体的基类。
Transform：一个对象的位置、旋转角度和大小。它用来存储和控制物体的位置、旋转角度和大小。每一个Transform组件都有一个父Transform组件，这便允许我们分层地应用位置、旋转角度和大小。

Component ：基类，用于处理附加到 GameObject 的所有内容。

  • 资源预设（Prefabs）与 对象克隆 (clone)
    • 预设（Prefabs）有什么好处？

预设是一个容易复用的类模板，可以迅速方便创建大量相同属性的对象、操作简单，代码量少，减少出错概率。修改的复杂度降低，一旦需要修改所有相同属性的对象，只需要修改预设即可，所有通过预设实例化的对象都会做出相应变化。

  • 预设与对象克隆 (clone or copy or Instantiate of Unity Object) 关系？

两者都可用于批量产生对象，但是对象克隆不受克隆本体的影响，因此A对象克隆的对象B不会因为A的改变而相应改变。

二、 编程实践：小游戏

        通过井字棋小游戏的案例学习，理解 MVC 元素之间的协作关系，对Unity 3D、IMGUI有了初步的了解后，现在模仿井字棋代码，参考“井字棋”案例，编写制作一个简单的计算器。

（一）效果展示

【实验三 【Unity3D入门IMGUI应用案例】计算器工具开发】 https://www.bilibili.com/video/BV1Zj41147cu/?share_source=copy_web&vd_source=955c67204ef88fcc078f826659e5a767

（二）代码实现

        代码使用IMGUI及OnGui()函数搭建绘制UI界面，程序按注释的代码框架，严格分为 Model-View-Controller三部分，并满足三部分之间的约束关系。

using UnityEngine;
using System.Text.RegularExpressions;
using System;

public class Calculator : MonoBehaviour
{
    // Entities and their states / Model
    public string result = "";//用来显示结果
    public static string str1 = "";//第一个操作数
    public static bool haveDot = false;//第二个操作数
    public static bool isCaclutate = false;

    public static bool IsNumeric(string value)
    {
        return Regex.IsMatch(value, @"^[+-]?\d*[.]?\d*$");
    }


    // View render entities / models
    // Here! you cannot modify model directly, use components/controls to do it
    void OnGUI()
    {
        //对数字进行处理
        if (GUI.Button(new Rect(100, 100, 100, 60), "CE"))
        {
            result = "";
            str1 = "";
            haveDot = false;
        }
        if (GUI.Button(new Rect(210, 100, 100, 60), "×") && str1.Substring(str1.Length - 1, 1) != "-" && str1.Substring(str1.Length - 1, 1) != "+" && str1.Substring(str1.Length - 1, 1) != ".")
        {
            if (IsNumeric(str1.Substring(str1.Length - 1, 1)))
            {
                Debug.Log(str1.Substring(str1.Length - 1, 1));
                str1 += "*";
                haveDot = false;
                isCaclutate = false;
            }
            result = str1;
        }
        if (GUI.Button(new Rect(320, 100, 100, 60), "÷") && str1.Substring(str1.Length - 1, 1) != "-" && str1.Substring(str1.Length - 1, 1) != "+" && str1.Substring(str1.Length - 1, 1) != ".")
        {
            if (IsNumeric(str1.Substring(str1.Length - 1, 1)))
            {
                str1 += "/";
                haveDot = false;
                isCaclutate = false;
            }
            result = str1;
        }
        if (GUI.Button(new Rect(430, 100, 100, 60), "←"))
        {
            if (isCaclutate == true)
            {
                str1 = "";
                isCaclutate = false;
            }
            else if (result.Length != 0)
            {
                str1 = str1.Substring(0, str1.Length - 1);
            }
            result = str1;
        }
        if (GUI.Button(new Rect(100, 170, 100, 60), "1"))
        {
            if (isCaclutate == true)
            {
                str1 = "";
                isCaclutate = false;
                haveDot = false;
            }
            str1 += "1";
            result = str1;
        }
        if (GUI.Button(new Rect(210, 170, 100, 60), "2"))
        {
            if (isCaclutate == true)
            {
                str1 = "";
                isCaclutate = false;
                haveDot = false;
            }
            str1 += "2";
            result = str1;
        }
        if (GUI.Button(new Rect(320, 170, 100, 60), "3"))
        {
            if (isCaclutate == true)
            {
                str1 = "";
                isCaclutate = false;
                haveDot = false;
            }
            str1 += "3";
            result = str1;
        }
        if (GUI.Button(new Rect(430, 170, 100, 60), "-"))
        {
            if (IsNumeric(str1.Substring(str1.Length - 1, 1)) && str1.Substring(str1.Length - 1, 1) != "-" && str1.Substring(str1.Length - 1, 1) != "+" && str1.Substring(str1.Length - 1, 1) != ".")
            {
                str1 += "-";
                haveDot = false;
                isCaclutate = false;
            }
            result = str1;
        }
        if (GUI.Button(new Rect(100, 240, 100, 60), "4"))
        {
            if (isCaclutate == true)
            {
                str1 = "";
                isCaclutate = false;
                haveDot = false;
            }
            str1 += "4";
            result = str1;
        }
        if (GUI.Button(new Rect(210, 240, 100, 60), "5"))
        {
            if (isCaclutate == true)
            {
                str1 = "";
                isCaclutate = false;
                haveDot = false;
            }
            str1 += "5";
            result = str1;
        }
        if (GUI.Button(new Rect(320, 240, 100, 60), "6"))
        {
            if (isCaclutate == true)
            {
                str1 = "";
                isCaclutate = false;
                haveDot = false;
            }
            str1 += "6";
            result = str1;
        }
        if (GUI.Button(new Rect(430, 240, 100, 60), "+") && str1.Substring(str1.Length - 1, 1) != "+" && str1.Substring(str1.Length - 1, 1) != "-" && str1.Substring(str1.Length - 1, 1) != ".")
        {
            if (IsNumeric(str1.Substring(str1.Length - 1, 1)))
            {
                str1 += "+";
                haveDot = false;
                isCaclutate = false;
            }
            result = str1;
        }
        if (GUI.Button(new Rect(100, 310, 100, 60), "7"))
        {
            if (isCaclutate == true)
            {
                str1 = "";
                isCaclutate = false;
                haveDot = false;
            }
            str1 += "7";
            result = str1;
        }
        if (GUI.Button(new Rect(210, 310, 100, 60), "8"))
        {
            if (isCaclutate == true)
            {
                str1 = "";
                isCaclutate = false;
                haveDot = false;
            }
            str1 += "8";
            result = str1;
        }
        if (GUI.Button(new Rect(320, 310, 100, 60), "9"))
        {
            if (isCaclutate == true)
            {
                str1 = "";
                isCaclutate = false;
                haveDot = false;
            }
            str1 += "9";
            result = str1;
        }
        if (GUI.Button(new Rect(430, 310, 100, 130), "="))
        {

            var tmp = Evaluator.Eval(result);
            Debug.Log(tmp.ToString());
            result = tmp.ToString();
            str1 = result;
            isCaclutate = true;
            if (result.Contains("."))
            {
                haveDot = true;
            }
        }
        if (GUI.Button(new Rect(100, 380, 210, 60), "0"))
        {
            if (isCaclutate == true)
            {
                str1 = "";
                isCaclutate = false;
                haveDot = false;
            }
            str1 += "0";
            result = str1;
        }

        if (GUI.Button(new Rect(320, 380, 100, 60), "."))
        {
            if (isCaclutate == true)
            {
                str1 = "0.";
                isCaclutate = false;
            }
            if (IsNumeric(str1.Substring(str1.Length - 1, 1)) && str1.Substring(str1.Length - 1, 1) != "." && haveDot == false)
            {
                Debug.Log(str1.Substring(str1.Length - 1, 1));
                str1 += ".";
                haveDot = true;
                isCaclutate = false;
            }
            result = str1;
        }
        GUI.TextArea(new Rect(100, 20, 430, 60), result);
    }

    // Components
    // here! any ui can not be referenced
    
    /**/
    /// <summary>
    /// 动态求值
    /// </summary>
    public class Evaluator
    {
        /**/
        /// <summary>
        /// 计算结果,如果表达式出错则抛出异常
        /// </summary>
        /// <param name="statement">表达式,如"1+2+3+4"</param>
        /// <returns>结果</returns>
        public static object Eval(string statement)
        {
            if (statement.Trim() != string.Empty)
            {
                Evaluator evaluator = new Evaluator();
                return evaluator.GetFormulaResult(statement);
            }
            else
            {
                return null;
            }
        }


        private object GetFormulaResult(string s)
        {
            if (s == "")
            {
                return null;
            }
            string S = BuildingRPN(s);

            string tmp = "";
            System.Collections.Stack sk = new System.Collections.Stack();

            char c = ' ';
            System.Text.StringBuilder Operand = new System.Text.StringBuilder();
            double x, y;
            for (int i = 0; i < S.Length; i++)
            {
                c = S[i];
                //added c==',' for germany culture
                if (char.IsDigit(c) || c == '.' || c == ',')
                {
                    //数据值收集.
                    Operand.Append(c);
                }
                else if (c == ' ' && Operand.Length > 0)
                {
                    #region 运算数转换
                    try
                    {
                        tmp = Operand.ToString();
                        if (tmp.StartsWith("-"))//负数的转换不被直接支持.
                        {
                            //这个分支可能永远不会被执行.
                            sk.Push(-((double)Convert.ToDouble(tmp.Substring(1, tmp.Length - 1))));
                        }
                        else
                        {
                            sk.Push(Convert.ToDouble(tmp));
                        }
                    }
                    catch
                    {
                        return null; 
                    }
                    Operand = new System.Text.StringBuilder();
                    #endregion
                }
                else if (c == '+'//运算符处理.双目运算处理.
                    || c == '-'
                    || c == '*'
                    || c == '/'
                    || c == '%'
                    || c == '^')
                {
                    #region 双目运算
                    if (sk.Count > 0)//输入的表达式根本没有包含运算符.或是根本就是空串.
                    {
                        y = (double)sk.Pop();
                    }
                    else
                    {
                        sk.Push(0);
                        break;
                    }
                    if (sk.Count > 0)
                        x = (double)sk.Pop();
                    else
                    {
                        sk.Push(y);
                        break;
                    }
                    switch (c)
                    {
                        case '+':
                            sk.Push(x + y);
                            break;
                        case '-':
                            sk.Push(x - y);
                            break;
                        case '*':
                            if (y == 0)
                            {
                                sk.Push(x * 1);
                            }
                            else
                            {
                                sk.Push(x * y);
                            }
                            break;
                        case '/':
                            if (y == 0)
                            {
                                sk.Push(x / 0);
                            }
                            else
                            {
                                sk.Push(x / y);
                            }
                            break;
                        case '%':
                            sk.Push(x % y);
                            break;
                        case '^':
                            if (x > 0)
                            {
                                sk.Push(System.Math.Pow(x, y));
                            }
                            
                            else
                            {
                                
                                double t = y;
                                string ts = "";
                                t = 1 / (2 * t);
                                ts = t.ToString();
                                if (ts.ToUpper().LastIndexOf('E') > 0)//
                                {
                                    ;
                                }
                            }
                            break;
                    }
                    #endregion
                }
                else if (c == '!')//单目取反.
                {
                    sk.Push(-((double)sk.Pop()));
                }
            }
            if (sk.Count > 1)
            {
                return null;
            }
            if (sk.Count == 0)
            {
                return null;
            }
            return sk.Pop();
        }
        /**/
        /// <summary>
        /// 
        /// </summary>
        private string BuildingRPN(string s)
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(s);
            System.Collections.Stack sk = new System.Collections.Stack();
            System.Text.StringBuilder re = new System.Text.StringBuilder();

            char c = ' ';
            for (int i = 0; i < sb.Length; i++)
            {
                c = sb[i];
                if (char.IsDigit(c) || c == ',')
                    re.Append(c);
                char.IsLetter(c);
                switch (c)
                {
                    case '+':
                    case '-':
                    case '*':
                    case '/':
                    case '%':
                    case '^':
                    case '!':
                    case '(':
                    case ')':
                    case '.':
                        re.Append(c);
                        break;
                    default:
                        continue;
                }
            }
            sb = new System.Text.StringBuilder(re.ToString());
            #region 对负号进行预转义处理.负号变单目运算符求反.
            for (int i = 0; i < sb.Length - 1; i++)
                if (sb[i] == '-' && (i == 0 || sb[i - 1] == '('))
                    sb[i] = '!';
            //字符转义.
            #endregion
            #region 将中缀表达式变为后缀表达式.
            re = new System.Text.StringBuilder();
            for (int i = 0;
                i < sb.Length;
                i++)
            {
                if (char.IsDigit(sb[i]) || sb[i] == '.')//如果是数值.
                {
                    re.Append(sb[i]);
                    //加入后缀式
                }
                else if (sb[i] == '+'
                    || sb[i] == '-'
                    || sb[i] == '*'
                    || sb[i] == '/'
                    || sb[i] == '%'
                    || sb[i] == '^'
                    || sb[i] == '!')//.
                {
                    #region 运算符处理
                    while (sk.Count > 0) //栈不为空时
                    {
                        c = (char)sk.Pop();
                        //将栈中的操作符弹出.
                        if (c == '(') //如果发现左括号.停.
                        {
                            sk.Push(c);
                            //将弹出的左括号压回.因为还有右括号要和它匹配.
                            break;
                            //中断.
                        }
                        else
                        {
                            if (Power(c) < Power(sb[i]))//如果优先级比上次的高,则压栈.
                            {
                                sk.Push(c);
                                break;
                            }
                            else
                            {
                                re.Append(' ');
                                re.Append(c);
                            }
                            //如果不是左括号,那么将操作符加入后缀式中.
                        }
                    }
                    sk.Push(sb[i]);
                    //把新操作符入栈.
                    re.Append(' ');
                    #endregion
                }
                else if (sb[i] == '(')//基本优先级提升
                {
                    sk.Push('(');
                    re.Append(' ');
                }
                else if (sb[i] == ')')//基本优先级下调
                {
                    while (sk.Count > 0) //栈不为空时
                    {
                        c = (char)sk.Pop();
                        //pop Operator
                        if (c != '(')
                        {
                            re.Append(' ');
                            re.Append(c);
                            //加入空格主要是为了防止不相干的数据相临产生解析错误.
                            re.Append(' ');
                        }
                        else
                            break;
                    }
                }
                else
                    re.Append(sb[i]);
            }
            while (sk.Count > 0)//最后一个弹栈.
            {
                re.Append(' ');
                re.Append(sk.Pop());
            }
            #endregion
            re.Append(' ');
            return FormatSpace(re.ToString());
            //在这里进行一次表达式格式化.这里就是后缀式了.  
        }

        /// <summary>  
        /// 优先级别测试函数.  
        /// </summary>  
        /// <param name="opr"></param>  
        /// <returns></returns>  
        private static int Power(char opr)
        {
            switch (opr)
            {
                case '+':
                case '-':
                    return 1;
                case '*':
                case '/':
                    return 2;
                case '%':
                case '^':
                case '!':
                    return 3;
                default:
                    return 0;
            }
        }

        /// <summary>  
        /// 规范化逆波兰表达式.
        /// </summary>  
        /// <param name="s"></param>  
        /// <returns></returns>  
        private static string FormatSpace(string s)
        {
            System.Text.StringBuilder ret = new System.Text.StringBuilder();
            for (int i = 0; i < s.Length; i++)
            {
                if (!(s.Length > i + 1 && s[i] == ' ' && s[i + 1] == ' '))
                    ret.Append(s[i]);
                else
                    ret.Append(s[i]);
            }
            return ret.ToString();
            //.Replace( '!','-' )
        }
    }
}

（三）组建运行

        创建一个空的模型（Create Empty），同样命名为Calculator，将Calculator.cs拖动到Calculator上面。

        再点击工具栏中的运行按钮即可运行计算器：

Zephyrus160
关注
【虚拟仿真】Unity3D对物体进行拆分实现
CSDN博客专家，Unity3D高级软件工程师，《Unity 3D从入门到实战》作者。
12-08 1万+
在仿真开发中，会遇到将模型进行移动、放大、旋转、拆分、合并等操作，其他的移动、放大、旋转都有比较多的例子进行参考，今天就分享一下如何将物体进行拆分。
matlab从无到有系列（九）：Simulink基础仿真详解（全网最全，从入门到放弃）
热门推荐
左手の明天的博客
04-02 8万+
🔗 运行环境：Matlab 🚩 作者：左手の明天 🥇 精选专栏：《python》 🔥 推荐专栏：《算法研究》 📚 选自专栏：《数学建模》 🧿 优秀专栏：《Matlab神经网络案例分析》 目前持续更新的专栏： 🥇 专栏：Matlab GUI编程技巧 🔥 专栏：Matlab从无到有系列 📚 专栏：《数学建模》 💗 大家好，我是左手の明天！💗 📆 最近更新：2022 年 4 月 2 日，左手の明天的第215 篇原创博客 🌟🌟往期必看🌟🌟 matlab从无到有系列（二）：矩阵运算基础...
离散引擎仿真基础
CharlesKai 的博客
09-22 285
1. 简答题Q&A [Q] 解释 游戏对象（GameObjects）和 资源（Assets）的区别与联系。 [A] [Q] 下载几个游戏案例，分别总结资源、对象组织的结构（指 资源的目录组织结构 与 游戏对象树的层次结构） [Q] 编写一个代码，使用 debug 语句来验证 MonoBehaviour 基本行为或事件触发的条件 基本行为包括 Awake() Start() Update() FixedUpdate() LateUpdate() 常用事件包括 OnGUI() OnDisa
Unity3D学习笔记_基础——离散仿真引擎
学习记录
12-07 2582
Unity3D学习笔记_离散仿真引擎 02-01 GameObject 练习 使用 菜单 -> GameObject -> 3D Object -> Cube 或 在层次视图点右键（上下文菜单 -> 3D Object -> Cube） 使用 菜单 -> Assets -> Create -> Material 或 项目视图（Assets）的上下文菜单 -> Create -> Material 拖动（Drag） RedMaterial 放落（
sim:Sim提供了离散事件模拟引擎，以促进基于Rust和npm的模拟产品和项目
04-03
辛 “ Sim”或“ SimRS”是离散事件模拟程序包，可简化基于Rust和npm的仿真产品和项目 | | “ Sim”或“ SimRS”是一个离散的事件模拟程序包，可简化基于Rust和npm的模拟产品和项目。 该存储库包含： ，用于轻松指定随机模型行为。 ，用于快速构建具有通用模块化组件的动态系统的仿真。 ，用于统计分析模拟输出。 ，用于管理和执行离散事件模拟。 Sim与多种编译目标兼容，包括WebAssembly。 Sim不需要每晚进行Rust。 目录 背景 仿真是用于分析和设计复杂系统的强大工具。 但是，大多数模拟器具有陡峭的学习曲线，是专有的，并且具有受限的可移植性。 Sim希望减少构建新的仿真产品，完成仿真项目以及学习仿真基础所需的时间。 Sim是开源的，并且由于具有编译目标的灵活性，因此相对易于移植。 安装 要在Rust代码库中使用，请将包装作为cargo依赖项使
二、离散仿真引擎基础
weixin_43372552的博客
09-22 452
目录1、简答题1.1 解释 游戏对象（GameObjects） 和 资源（Assets）的区别与联系。1.2 下载几个游戏案例，分别总结资源、对象组织的结构（指资源的目录组织结构与游戏对象树的层次结构）1.3 编写一个代码，使用 debug 语句来验证 MonoBehaviour 基本行为或事件触发的条件1.4 查找脚本手册，了解 GameObject，Transform，Component 对象1.5 资源预设（Prefabs）与 对象克隆 (clone) 1、简答题 1.1 解释 游戏对象（GameOb
Unity3d--离散仿真基础
TempterCyn的博客
09-06 501
Unity3d–离散仿真基础 List item 1.简答题 解释 游戏对象（GameObjects）和 资源（Assets）的区别与联系。 区别：游戏对象（GameObjects）是Unity中的基本对象，代表角色，道具和风景等等。它本身并不完成实际的功能，而是各种组件的容器，根据要创建的对象类型，可以添加不同的组件组合到游戏对象中。资源（Assets）包含在游戏文件中，可以是我们自定义...
Unity3d离散仿真引擎基础
hellowangld的博客
03-23 1325
1. 解释对象与资源的区别与联系 对象：对象直接出现在游戏场景中，是资源整合的具体表现，对象一般有玩家，敌人，游戏场景，摄像机等虚拟父类，这些父类没有实例化，而他们的子类实例化并包含了这些游戏对象，我们可以对这些对象进行操作。 资源：资源可以是我们自定义或下载下来的素材，可以被多个对象使用，有些资源可以做为模板并实例化为对象。资源文件夹（Asset）通常包含脚本，预设，场景，声音等。 ...
Unity学习记录——离散仿真引擎基础
jmpei32534的博客
09-22 895
Unity学习记录——离散仿真引擎基础
java3d源码-JaamSim:JaamSim离散事件仿真
06-04
开发的离散事件仿真环境，是我们所有仿真应用程序的基础。 它代表了自 2002 年以来大约 10 个人年的努力，并且正在不断发展以支持我们的模拟项目。 我们的 16 名模拟分析师和程序员团队每天都在使用 JaamSim。 我们...
离散仿真引擎基础
MADAYEI的博客
09-13 417
离散仿真引擎基础 1、解释 游戏对象（GameObjects） 和 资源（Assets）的区别与联系。 对象：对象直接出现在游戏场景中，是资源整合的具体表现，对象一般有玩家，敌人，游戏场景，摄像机等虚拟父类，这些父类没有实例化，而他们的子类实例化并包含了这些游戏对象，我们可以对这些对象进行操作。 资源：资源可以是我们自定义或下载下来的素材，可以被多个对象使用，有些资源可以做为模板并实例化为对象。...
作业2-离散仿真引擎基础
yige16的博客
09-22 197
1、简答题 ·解释游戏对象（GameObjects）和资源（Assets）的区别与联系。 区别：游戏对象是代表角色、道具和场景的基本对象。它们本身不能完成很多工作，但它们容纳实现实际功能的组件。 资源是游戏或项目中可以使用的对象，可能来自Unity外部创建的文件，也可能是在Unity中创建的。 相对而言，游戏对象更抽象，而资源更具体。 联系：资源可以被游戏对象使用。 ·下载几个游戏案例，分别总结资源、对象组织的结构（指资源的目录组织结构与游戏对象树的层次结构） 下载的游戏文件后缀为unitypackage，
02-离散仿真引擎基础
Edith的博客
09-14 448
Homework02 简答题 1. 解释游戏对象（GameObjects）和资源（Assets）的区别与联系 区别：游戏对象是具有一定属性与功能的类的实体化，对应为Unity中具有对应职能与属性的组件，例如游戏中常见的玩家、怪物等；资源是预先准备好的模型、图片、音乐等，可以直接并重复使用 联系：资源可以添加到游戏对象作为其一部分，而游戏对象可以保存作为一种资源以便捷地重复使用 2. 下载几个游戏案例，分别总结资源、对象组织的结构（指资源的目录组织结构与游戏对象树的层次结构） 从资源网站下载愤怒的小鸟、
ch02离散仿真引擎基础——Unity3D学习
yesor_not的博客
09-22 842
unity3D——ch02离散仿真引擎基础 井字棋小游戏
ns-3离散事件仿真之default与realtime（一）
U__obliviate_H的博客
07-14 594
ns-3是基于离散事件调度的网络仿真开源项目，在介绍其default与realtime两种仿真模式前，先给各位看官介绍一下什么是离散事件仿真。 离散事件仿真（Discrete Event Simulation，缩写为DES），它关注的是这样的一类系统：系统的状态只在某一时点发生变化，而状态的变化是由于事件发生造成的。 以银行系统为例（银行系统是DES的经典案例，如同cat之于模式识别），上图展现了一个简单的银行系统。在5分钟时首个顾客到达，由于没有其他顾...
FactorySimulation仿真引擎的性能测试
最新发布
m0_49729945的博客
05-22 429
其中模型复杂程度包括静态对象（设备、缓冲区、物流资源等）的数量、移动对象（在制品）的数量、逻辑控制（Method）的复杂性等等，仿真设置情况包括是否记录仿真数据、是否刷新动画、是否记录生产历史、是否产生数据图表等等，显然，关闭仿真动画并减少数据记录，可以提高仿真速度。当然，（2）也不是（1）的简单叠加，FactorySimulation支持并行仿真，n次仿真的时间=单次仿真的时间*n/m，其中m=2-25，也就是说，多次仿真速度比串行运行单次仿真的速度快2到25倍（具体取决于CPU核数）。
Python离散事件仿真入门【Simpy】
新缸中之脑
05-30 2551
离散事件仿真 (DES) 往往是专门产品的领域，例如 SIMUL8 和 MatLab/Simulink 。然而，当我在 Python 中执行过去使用 MatLab 的分析时，我很想测试 Python 是否也有 DES 的解决方案。 DES 是一种使用统计函数对现实事件进行建模的方法，通常用于医疗保健、制造、物流等领域的队列和资源使用。最终目标是获得关键运营指标，例如资源使用情况和平均等待时间，以便评估和优化各种现实生活中的配置。SIMUL8 有一个视频，描述了如何对急诊室等待时间进行建模 ，MathWor
离散事件仿真
beyondwdq的专栏
04-15 8687
刚刚在陈硕老师的blog看到他针对一个模拟银行叫号系统给出的答案和代码。陈老师代码文章都写得好，令人佩服。恰好我的很大一部分工作都是基于仿真来做的，这里按照我自己的理解，简要介绍一些主要的仿真技术，给出一个非常简单的事件驱动的仿真程序，并用一个排队系统初步演示一下仿真程序的使用。 为什么要仿真说起为什么需要仿真，理由可以列举很多，简要来说，它是在纯数学建模和实际系统的优缺点之间的一个折中。相对数学模型来说，仿真不需要高深的数学技巧，也不需要作过多的简化和假设，并且在求解复杂系统时，不会面对状态和空间爆炸的问
OMNET++ 4.0入门：离散事件仿真与应用实践
OMNET++4.0是一款强大的离散事件仿真软件，它在科研和教育领域中被广泛用于网络仿真研究。本文将重点介绍如何判断哪些研究课题适合使用OMNET++，以及如何进行有效的安装与入门。 首先，理解离散事件仿真至关重要。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值