精华内容
下载资源
问答
  • 匀速运动:指是物体在一条直线上运动,并且物体在任何相等时间间隔内通过位移都是相等。其实就是匀速直线运动,它特点是加速度为0,从定义可知,在任何相等时间间隔内,速度大小和方向是相同。 1 <...

    匀速运动:指的是物体在一条直线上运动,并且物体在任何相等时间间隔内通过的位移都是相等的。其实就是匀速直线运动,它的特点是加速度为0,从定义可知,在任何相等的时间间隔内,速度大小和方向是相同的。

     1 <head>
     2     <meta charset='utf-8' />
     3     <style>
     4         #canvas {
     5             border: 1px dashed #aaa;
     6         }
     7     </style>
     8     <script>
     9         window.onload = function () {
    10             var oCanvas = document.querySelector("#canvas"),
    11                 oGc = oCanvas.getContext('2d'),
    12                 width = oCanvas.width, height = oCanvas.height,
    13                 x = 0;
    14             function drawBall( x, y, cxt ){
    15                 cxt.fillStyle = '#09f';
    16                 cxt.beginPath();
    17                 cxt.arc( x, y, 20, 0, 2 * Math.PI );
    18                 cxt.closePath();
    19                 cxt.fill();
    20             }
    21             ( function linear(){
    22                 oGc.clearRect( 0, 0, width, height );
    23                 drawBall( x, height / 2, oGc );
    24                 x  = 2;
    25                 console.log( x );
    26                 requestAnimationFrame( linear );
    27             } )();
    28         }
    29     </script>
    30 </head>
    31 <body>
    32     <canvas id="canvas" width="1200" height="600"></canvas>
    33 </body>

    上述实例让一个半径20px的小球 从x=0, y=canvas高度的一半,以每帧2px的速度向右匀速运动.

    我们可以把小球封装成一个对象:

    ball.js文件:

     1 function Ball( x, y, r, color ){
     2     this.x = x || 0;
     3     this.y = y || 0;
     4     this.radius = r || 20;
     5     this.color = color || '#09f';
     6 }
     7 Ball.prototype = {
     8     constructor : Ball,
     9     stroke : function( cxt ){
    10         cxt.strokeStyle = this.color;
    11         cxt.beginPath();
    12         cxt.arc( this.x, this.y, this.radius, 0, 2 * Math.PI );
    13         cxt.closePath();
    14         cxt.stroke();
    15     },
    16     fill : function( cxt ){
    17         cxt.fillStyle = this.color;
    18         cxt.beginPath();
    19         cxt.arc( this.x, this.y, this.radius, 0, 2 * Math.PI );
    20         cxt.closePath();
    21         cxt.fill();
    22     }
    23 }

    该小球对象,可以定制位置半径和颜色,支持两种渲染方式(描边和填充)

     1 <head>
     2     <meta charset='utf-8' />
     3     <style>
     4         #canvas {
     5             border: 1px dashed #aaa;
     6         }
     7     </style>
     8     <script src="./ball.js"></script>
     9     <script>
    10         window.onload = function () {
    11             var oCanvas = document.querySelector("#canvas"),
    12                 oGc = oCanvas.getContext('2d'),
    13                 width = oCanvas.width, height = oCanvas.height,
    14                 ball = new Ball( 0, height / 2 );
    15             (function linear() {
    16                 oGc.clearRect(0, 0, width, height);
    17                 ball.fill( oGc );
    18                 ball.x  = 2;
    19                 requestAnimationFrame(linear);
    20             })();
    21         }
    22     </script>
    23 </head>
    24 
    25 <body>
    26     <canvas id="canvas" width="1200" height="600"></canvas>
    27 </body>

     斜线匀速运动:

     1 <head>
     2     <meta charset='utf-8' />
     3     <style>
     4         #canvas {
     5             border: 1px dashed #aaa;
     6         }
     7     </style>
     8     <script src="./ball.js"></script>
     9     <script>
    10         window.onload = function () {
    11             var oCanvas = document.querySelector("#canvas"),
    12                 oGc = oCanvas.getContext('2d'),
    13                 width = oCanvas.width, height = oCanvas.height,
    14                 ball = new Ball( 0, height );
    15             (function linear() {
    16                 oGc.clearRect(0, 0, width, height);
    17                 ball.fill( oGc );
    18                 ball.x  = 2;
    19                 ball.y -= 1;
    20                 requestAnimationFrame(linear);
    21             })();
    22         }
    23     </script>
    24 </head>
    25 
    26 <body>
    27     <canvas id="canvas" width="1200" height="600"></canvas>
    28 </body>

     任意方向的匀速运动(速度分解)

     1 <head>
     2     <meta charset='utf-8' />
     3     <style>
     4         #canvas {
     5             border: 1px dashed #aaa;
     6         }
     7     </style>
     8     <script src="./ball.js"></script>
     9     <script>
    10         window.onload = function () {
    11             var oCanvas = document.querySelector("#canvas"),
    12                 oGc = oCanvas.getContext('2d'),
    13                 width = oCanvas.width, height = oCanvas.height,
    14                 ball = new Ball( 0, 0 ),
    15                 speed = 5,
    16                 vx = speed * Math.cos( 10 * Math.PI / 180 ),
    17                 vy = speed * Math.sin( 10 * Math.PI / 180 );
    18                 
    19             (function linear() {
    20                 oGc.clearRect(0, 0, width, height);
    21                 ball.fill( oGc );
    22                 ball.x  = vx;
    23                 ball.y  = vy;
    24                 requestAnimationFrame(linear);
    25             })();
    26         }
    27     </script>
    28 </head>
    29 <body>
    30     <canvas id="canvas" width="1200" height="600"></canvas>
    31 </body>

     

    展开全文
  • 一.匀速直线运动:1....2.速度:匀速直线运动中物体的位移与时间的比值叫匀速直线运动的速度。3.物理意义:描述匀速直线运动物体运动快慢的物理量。4.公式:注:仅适用于匀速直线运动例1.下列有关匀速直...
    匀速直线运动:1. 定义:物体沿一条直线运动,在任意相等的时间内通过的位移相同,这种运动就叫匀速直线运动。1)任意相等的时间指任意选取任意长短的任何时候的相等时间。2)位移相同指位移的大小与方向都相同。2. 速度:匀速直线运动中物体的位移与时间的比值叫匀速直线运动的速度。3. 物理意义:描述匀速直线运动物体运动快慢的物理量。4. 公式:a8b6c34a4975866a97e35a962e60dfd1.png注:仅适用于匀速直线运动1. 下列有关匀速直线运动物体的叙述,正确的是(    )A. 做匀速直线运动物体的位移和路程相等B. 做匀速直线运动物体位移的大小和路程相等C. 做匀速直线运动的速度等于运动路程与运动时间之比解析:依据匀速直线运动、位移、路程、速度的定义分析答案:B平均速度:1. 定义:运动物体的位移与所用时间的比值,叫这段位移(或者这段时间)内的平均速度。2. 物理意义:粗略描述物体运动快慢的物理量。3. 公式:d6b32b60f7409bbd5492a9e2ab6f1a32.png2. 物体沿一直线运动,前一半位移的速度为v1,后一半位移的速度为v2,则整个位移的平均速度为多少?解析:依据平均速度的定义,求平均速度要找相对应的位移段与时间段。设总位移为2s,则:7deaa2cd3ab16291be92d4f59494053e.png79e08bf0c0fbdb4d5c916770108b1619.png总结:求平均速度要找相对应的位移段与时间段,严格按照定义求。3. 物体沿一直线运动,前一半时间的速度为v1,后一半时间的速度为v2,则整个位移的平均速度为多少?解析:同上设总时间为2t,则:4e68cc194d909e0121c0618d0a792d3f.png6091cd64aad005bb5156565e152ee8e1.png4. 说明:1)适用于任何运动。2)求平均速度要找相对应的位移段与时间段,严格按照定义求。瞬时速度:1. 定义:运动物体在某时刻或某位置的速度,叫瞬时速度。其大小简称速率。2. 物理意义;精确描述物体运动快慢的物理量。3. 矢量:大小:测量瞬时速度,可以用很短时间内的平均速度的大小来代替,而且所取时间越短,误差越小。方向:与物体在该时刻或该位置的运动方向相同或说沿轨迹的切线方向。 4. 关于匀速直线运动,下列说法中正确的是 (    )A. 瞬时速度不变的运动,一定是匀速直线运动B. 速率不变的运动,一定是匀速直线运动C. 相同时间内平均速度相同的运动,一定是匀速直线运动D. 瞬时速度的方向始终不变的运动,一定是匀速直线运动解析:关于物体运动的快慢,物理上给出了多种概念,应分清各个概念的联系与区别。选A加速度:1. 物理意义:描述速度变化快慢的物理量。2. 定义:速度的改变跟发生这一改变所用时间的比值。3. 表达式:7c5360c459ac753ebb600c840d39c6e2.png单位:m/s24. 强调:1)是矢量,既有大小又有方向,其方向与速度改变的方向一致。2)加速度的正、负号只表示其方向,而不表示其大小。3)av 同向则加速,反向则减速。4)av无必然联系,a取决于物体的受力和质量。 5. 一物体以初速度1.5m/s沿光滑斜面上滑,2s末物体沿斜面下滑,速度大小为1m/s,求物体的加速度。解析:处理一条直线上的各矢量加减运算时必须先规定正方向,矢量的方向用正负号表示。计算结果中出现负号必须加以说明。取物体的初速度方向为正,物体的末速度与初速度相反,为负值,所以加速度:0ac039572e31d12a8ee74d32bd628c66.pngm/s2=-1.25 m/s26. 沿一条直线运动的物体,当物体的加速度逐渐减小时,下列说法正确的是(    )A. 物体运动的速度一定增大B. 物体运动的速度一定减小C. 物体运动速度的变化量一定减小D. 物体运动的路程一定增大解析:理清速度与加速度的关系是关键,本题选D

    ▍ 来源:综合网络

    ▍ 编辑:Wordwuli

    ▍ 声明:如有侵权,请联系删除;若需转载,请注明出处。

    ▍ 提示:①更多精彩内容,请点击文章标题下方的公众号名称查看;②进入公众号后,发送关键词给我,我会立即回复相关内容给您。

    展开全文
  • html5--质点运动与反射

    千次阅读 2012-10-18 19:04:38
     物体在一条直线上运动,且在任意相等时间间隔内位移相等,这种运行称为匀速直线运动。  在台球实验中,按照如下方式定义小球: var ball = { position: { x: 100, y: 100 }, r: 15 };  其中包含...

    匀速直线运动:

             物体在一条直线上运动,且在任意相等的时间间隔内位移相等,这种运行称为匀速直线运动。

             在台球的实验中,按照如下方式定义小球:

    var ball = {
                position: { x: 100, y: 100 },
                r: 15
            };


        其中包含了小球的位置和半径两个属性,因为要用小球来做物理实验,所以为小球增加两上属性,VX和VY,分别代表小球沿X轴方向和Y轴方向上的速度,这在物理学上叫做 运动独立性原理:

    var ball = {
                position: { x: 100, y: 100 },
                r: 15,
                vx: 190,
                vy: 110
            };


    代码中假定了小球沿X轴方向的速度为190,沿Y轴的方向上的速度为110.

      定义好了小球的速度,如何把它的运动状态体现在Canvas中呢?在以前的例子中,已经用到了Jscex来实现,这里我们继续使用。

      首先我们要引用类库文件:

     <script src="../../Scripts/jscex.jscexRequire.min.js" type="text/javascript"></script>


    这样就可以使用Jscex了。

     <canvas id="myCanvas" width="600" height="500">
    你的浏览器不支持canvas
    </canvas>
        <script type="text/javascript">
            var c = document.getElementById("myCanvas");
            var cxt = c.getContext("2d");
            var ball = {
                position: { x: 100, y: 100 },
                r: 15,
                vx: 190,
                vy: 110
            };
            var cyc = 10;
            var moveAsync = eval(Jscex.compile("async", function () {
                while (true) {
                        cxt.fillStyle = "rgba(0,0,0,.3)";
                        cxt.fillRect(0, 0, c.width, c.height);
                        cxt.fillStyle = "#fff";
                        cxt.beginPath();
                        cxt.arc(ball.position.x, ball.position.y, ball.r, 0, Math.PI * 2, true);
                        cxt.closePath();
                        cxt.fill();
                        ball.position.x += ball.vx * cyc / 1000;
                        ball.position.y += ball.vy * cyc / 1000;
                        $await(Jscex.Async.sleep(cyc));
                               }
            }));
            moveAsync().start();
        </script>


    也可以让小球往返不停的运动:

     <canvas id="myCanvas" width="600" height="500">
    你的浏览器不支持canvas
    </canvas>
        <script type="text/javascript">
            var c = document.getElementById("myCanvas");
            var cxt = c.getContext("2d");
            var ball = {
                position: { x: 100, y: 100 },
                r: 15,
                vx: 190,
                vy: 110
            };
            var cyc = 10;
            var moveAsync = eval(Jscex.compile("async", function () {
                while (true) {
                    while (ball.position.x < 600) {
                        cxt.fillStyle = "rgba(0,0,0,.3)";
                        cxt.fillRect(0, 0, c.width, c.height);
                        cxt.fillStyle = "#fff";
                        cxt.beginPath();
                        cxt.arc(ball.position.x, ball.position.y, ball.r, 0, Math.PI * 2, true);
                        cxt.closePath();
                        cxt.fill();
                        ball.position.x += ball.vx * cyc / 1000;
                        ball.position.y += ball.vy * cyc / 1000;
                        $await(Jscex.Async.sleep(cyc));
                    }
                    while (ball.position.x > 0) {
                        cxt.fillStyle = "rgba(0,0,0,.3)";
                        cxt.fillRect(0, 0, c.width, c.height);
                        cxt.fillStyle = "#fff";
                        cxt.beginPath();
                        cxt.arc(ball.position.x, ball.position.y, 15, 0, Math.PI * 2, true);
                        cxt.closePath();
                        cxt.fill();
                        ball.position.x -= ball.vx * cyc / 1000;
                        ball.position.y -= ball.vy * cyc / 1000;
                        $await(Jscex.Async.sleep(cyc));
                    }
                }
            }));
            moveAsync().start();
        </script>


    可以看到上面的代码共有3个while,从上到下依次无限循环执行下去,效果如下所示:

     

    倘若小球和四壁碰撞,就会发生反射,反弹符合反射定律。

    所以在Canvas中模拟的结果就是:当小球与上下壁相撞时,Y轴速度方向变成其反方向,大小写不变,X轴速度不变;当小球与左右两壁纸碰撞时,X轴速度方向变成其反方向,大小写不变,Y轴速度大小方向都不变,可以得出:

      cxt.fillStyle = "rgba(0,0,0,.3)";
                    cxt.fillRect(0, 0, c.width, c.height);
                    cxt.fillStyle = "#fff";
                    cxt.beginPath();
                    cxt.arc(ball.position.x, ball.position.y, ball.r, 0, Math.PI * 2, true);
                    cxt.closePath();
                    cxt.fill();
    
                    if (ball.r + ball.position.x > c.width || ball.position.x < ball.r)
                        ball.vx *= -1;
                    if (ball.r + ball.position.y > c.height || ball.position.y < ball.r)
                        ball.vy *= -1;
                    ball.position.x += ball.vx * cyc / 1000;
                    ball.position.y += ball.vy * cyc / 1000;
    
                    $await(Jscex.Async.sleep(cyc));


    这样小球永远逃不出Canvas画布的范围了,当然这是碰撞的一种特殊情况,因为碰撞面分别与X轴和Y轴平行,所以处理起来非常方便,如果遇到任意碰撞面,就不能这么简单地处理,在后面的例子中将进一步学习。

     

    展开全文
  • 简答 游戏对象运动的本质是什么? 游戏对象运动的本质是随着每一帧刷新,对象的positoin、rotation离散地进行变化。...即x轴上做匀速直线运动,y轴上匀变速直线运动。所以首先我们都要定义好的就...

    简答

    • 游戏对象运动的本质是什么?

            游戏对象运动的本质是随着每一帧刷新,对象的positoin、rotation离散地进行变化。

    • 请用三种方法以上方法,实现物体的抛物线运动。(如,修改Transform属性,使用向量Vector3的方法…)

            无论用什么样的方法,我们都要让运动满足抛物线的定义。即x轴上做匀速直线运动,y轴上匀变速直线运动。所以首先我们都要定义好的就是x轴上的速度,y轴上的加速度和初始速度。

            首先是最简单的通过vector3向量来改变position。

    public class test : MonoBehaviour {    
        public float vY = 3.0f;
        public float aY = 1.0f;
        public float vX = 1.0f;
        
        void Start(){
            Debug.Log("Start!");
        }    
    
        void Update(){
            Vector3 change = new Vector3(Time.deltaTime * vX, Time.deltaTime * vY, 0);
            this.transform.position += change;
            vY -= aY * Time.deltaTime; 
        }
    }

            然后是使用Vector3.Lerp()函数。

    public class test : MonoBehaviour {    
        public float vY = 3.0f;
        public float aY = 1.0f;
        public float vX = 1.0f;
        
        void Start(){
            Debug.Log("Start!");
        }    
    
        void Update(){
            Vector3 change = new Vector3(Time.deltaTime * vX, Time.deltaTime * vY, 0);
            this.transform.postion = Vector3.Lerp(this.transform.position, this.transform.position + move, 1);
            vY -= aY * Time.deltaTime; 
        }
    }

            最后一种方法是使用transform.translate()函数

    public class test : MonoBehaviour {    
        public float vY = 3.0f;
        public float aY = 1.0f;
        public float vX = 1.0f;
        
        void Start(){
            Debug.Log("Start!");
        }    
    
        void Update(){
            Vector3 change = new Vector3(Time.deltaTime * vX, Time.deltaTime * vY, 0);
            this.transform.Translate(change);
            vY -= aY * Time.deltaTime; 
        }
    }
    • 写一个程序,实现一个完整的太阳系, 其他星球围绕太阳的转速必须不一样,且不在一个法平面上。

            首先需要分别创建太阳系中所有的恒星和行星,在Start中导入并确认Sun的位置。然后在Update中用RotateAround实现公转,Rotate实现自传。

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class NewBehaviourScript1 : MonoBehaviour
    {
        GameObject Sun, Moon, Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune;
        
        void Start(){
            Sun = GameObject.Find("Sun");
            Moon = GameObject.Find("Moon");
            Mercury = GameObject.Find("Mercury");
            Venus = GameObject.Find("Venus");
            Earth = GameObject.Find("Earth");
            Mars = GameObject.Find("Mars");
            Jupiter = GameObject.Find("Jupiter");
            Saturn = GameObject.Find("Saturn");
            Uranus = GameObject.Find("Uranus");
            Neptune = GameObject.Find("Neptune");
        }
    
        void Update(){
            Sun.transform.Rotate(Vector3.up * Time.deltaTime * 5 );
    
            Mercury.transform.RotateAround(Sun.transform.position, new Vector3(0.1f, 1, 0), 60 * Time.deltaTime);
            Mercury.transform.Rotate(Vector3.up * 10000/58 * Time.deltaTime);
            
            Venus.transform.RotateAround(Sun.transform.position, new Vector3(0, 1, -0.1f), 55 * Time.deltaTime);
            Venus.transform.Rotate(Vector3.up * 10000/243 * Time.deltaTime);
            
            Earth.transform.RotateAround(Sun.transform.position, Vector3.up, 50 * Time.deltaTime);
            Earth.transform.Rotate(Vector3.up * 10000 * Time.deltaTime);
            Moon.transform.RotateAround(Earth.transform.position, Vector3.up, 5 * Time.deltaTime);
            Moon.transform.Rotate(Vector3.up * 10000/27 * Time.deltaTime);
            
            Mars.transform.RotateAround(Sun.transform.position, new Vector3(0.2f, 1, 0), 45 * Time.deltaTime);
            Mars.transform.Rotate(Vector3.up * 10000 * Time.deltaTime);
            
            Jupiter.transform.RotateAround(Sun.transform.position, new Vector3(-0.1f, 2, 0), 38 * Time.deltaTime);
            Jupiter.transform.Rotate(Vector3.up * 10000/0.3f * Time.deltaTime);
            
            Saturn.transform.RotateAround(Sun.transform.position, new Vector3(0, 1, 0.2f), 36 * Time.deltaTime);
            Saturn.transform.Rotate(Vector3.up * 10000/0.4f * Time.deltaTime);
            
            Uranus.transform.RotateAround(Sun.transform.position, new Vector3(0, 2, 0.1f), 35 * Time.deltaTime);
            Uranus.transform.Rotate(Vector3.up * 10000/0.6f * Time.deltaTime);
            
            Neptune.transform.RotateAround(Sun.transform.position, new Vector3(-0.1f, 1, -0.1f), 33 * Time.deltaTime);
            Neptune.transform.Rotate(Vector3.up * 10000/0.7f * Time.deltaTime); 
        }
    }
    

     

     

    牧师与魔鬼

    所谓MVC架构,是指将程序分为三个部分:

    • 模型(Model):数据对象及关系
      • 游戏对象、空间关系
    • 控制器(Controller):接受用户事件,控制模型的变化
      • 一个场景一个主控制器
      • 至少实现与玩家交互的接口(IPlayerAction)
      • 实现或管理运动
    • 界面(View):显示模型,将人机交互事件交给控制器处理
      • 处收 Input 事件
      • 渲染 GUI ,接收事件

    简单来说,MVC架构很好地降低了系统的耦合性,是一种好的设计。在接下来这个小游戏的设计中,我们也采用这种架构,具体的UML图大概如下图:

    其中场景中的所有GameObject就是MVC中的Model,也即上图中被FirstController直接控制的GameModels,包括boat、coast以及character;同时为了降低耦合性,每种Object都有对应的controller,最终整合在FirstController中,也即MVC中的C。而MVC中的V是指View,就是GUI界面,具体在这次的程序中就是UserGUI和ClickGUI,用于与用户进行交互。

    在具体的代码中,director就直接使用单例模式。

    public class SSDirector : System.Object {
    		// singlton instance
    		private static SSDirector _instance;
    
    		public SceneController currentSceneController { get; set; }
    		public bool running { get; set; }
    
    		// get instance anytime anywhere!
    		public static SSDirector getInstance() {
    			if (_instance == null) {
    				_instance = new SSDirector ();
    			}
    			return _instance;
    		}
    	}

    然后是ISceneControl和IUserAction两个接口。这里结合应用场景,用户的行为只有点击按钮移动船,点击character移动上船下船,以及点击按钮重置;而SceneControl要做的也就只有加载资源。

        public interface IUserAction {
    		void moveBoat();
    		void characterIsClicked(MyCharacterController characterCtrl);
    		void restart();
    	}
    
    	public interface ISceneController {
    		void loadResources ();
    	}

    接下来就是针对三种对象分别写三个controller,分别写上需要的操作函数,然后整合在firstController中。这里就不把代码全部贴上来了,我们直接看firstController。

    public class FirstController : MonoBehaviour, ISceneController, IUserAction {
    
    	readonly Vector3 water_pos = new Vector3(0,0.5F,0);
    
    
    	UserGUI userGUI;
    
    	public CoastController fromCoast;
    	public CoastController toCoast;
    	public BoatController boat;
    	private MyCharacterController[] characters;
    
    	void Awake() {
    		SSDirector director = SSDirector.getInstance ();
    		director.currentSceneController = this;
    		userGUI = gameObject.AddComponent <UserGUI>() as UserGUI;
    		characters = new MyCharacterController[6];
    		loadResources ();
    	}
    
    	public void loadResources() {
    		GameObject water = Instantiate (Resources.Load ("Perfabs/Water", typeof(GameObject)), water_pos, Quaternion.identity, null) as GameObject;
    		water.name = "water";
    
    		fromCoast = new CoastController ("from");
    		toCoast = new CoastController ("to");
    		boat = new BoatController ();
    
    		// load characters
    		for (int i = 0; i < 3; i++) {
    			MyCharacterController newCharacter = new MyCharacterController ("priest");
    			newCharacter.setName("priest" + i);
    			newCharacter.setPosition (fromCoast.getEmptyPosition ());
    			newCharacter.getOnCoast (fromCoast);
    			fromCoast.getOnCoast (newCharacter);
    
    			characters [i] = newCharacter;
    		}
    
    		for (int i = 0; i < 3; i++) {
    			MyCharacterController newCharacter = new MyCharacterController ("devil");
    			newCharacter.setName("devil" + i);
    			newCharacter.setPosition (fromCoast.getEmptyPosition ());
    			newCharacter.getOnCoast (fromCoast);
    			fromCoast.getOnCoast (newCharacter);
    
    			characters [i+3] = newCharacter;
    		}
    	}
    
    	public void moveBoat() {
    		if (boat.isEmpty ())
    			return;
    		boat.Move ();
    		userGUI.status = check_game_over ();
    	}
    
    	public void characterIsClicked(MyCharacterController characterCtrl) {
    		if (characterCtrl.isOnBoat ()) {
    			CoastController whichCoast;
    			if (boat.get_to_or_from () == -1) { // to->-1; from->1
    				whichCoast = toCoast;
    			} else {
    				whichCoast = fromCoast;
    			}
    
    			boat.GetOffBoat (characterCtrl.getName());
    			characterCtrl.moveToPosition (whichCoast.getEmptyPosition ());
    			characterCtrl.getOnCoast (whichCoast);
    			whichCoast.getOnCoast (characterCtrl);
    
    		} else {									// character on coast
    			CoastController whichCoast = characterCtrl.getCoastController ();
    
    			if (boat.getEmptyIndex () == -1) {		// boat is full
    				return;
    			}
    
    			if (whichCoast.get_to_or_from () != boat.get_to_or_from ())	// boat is not on the side of character
    				return;
    
    			whichCoast.getOffCoast(characterCtrl.getName());
    			characterCtrl.moveToPosition (boat.getEmptyPosition());
    			characterCtrl.getOnBoat (boat);
    			boat.getOnBoat (characterCtrl);
    		}
    		userGUI.status = check_game_over ();
    	}
    
    	int check_game_over() {	// 0->not finish, 1->lose, 2->win
    		int from_priest = 0;
    		int from_devil = 0;
    		int to_priest = 0;
    		int to_devil = 0;
    
    		int[] fromCount = fromCoast.getCharacterNum ();
    		from_priest += fromCount[0];
    		from_devil += fromCount[1];
    
    		int[] toCount = toCoast.getCharacterNum ();
    		to_priest += toCount[0];
    		to_devil += toCount[1];
    
    		if (to_priest + to_devil == 6)		// win
    			return 2;
    
    		int[] boatCount = boat.getCharacterNum ();
    		if (boat.get_to_or_from () == -1) {	// boat at toCoast
    			to_priest += boatCount[0];
    			to_devil += boatCount[1];
    		} else {	// boat at fromCoast
    			from_priest += boatCount[0];
    			from_devil += boatCount[1];
    		}
    		if (from_priest < from_devil && from_priest > 0) {		// lose
    			return 1;
    		}
    		if (to_priest < to_devil && to_priest > 0) {
    			return 1;
    		}
    		return 0;			// not finish
    	}
    
    	public void restart() {
    		boat.reset ();
    		fromCoast.reset ();
    		toCoast.reset ();
    		for (int i = 0; i < characters.Length; i++) {
    			characters [i].reset ();
    		}
    	}
    }
    

    每次启动首先调用Awake函数,创建导演等实例,然后加载资源。其他的就是一些完成程序运行的功能函数如chek_game_over()来检查游戏是否结束以及最终的游戏结果。另外值得一提的是移动character的部分,为了降低耦合性,要分别调用三个对象对应的函数,包括载coast中移除或加入character、移动character本身,以及在船上移除或加入character。然后在每一次移动了character或者boat之后,都要做一次check_game_over的判定。

    还有值得一提的是,为了降低代码的重复性,这里将船和人与移动有关的代码封装到一个movable类中,然后在两个controller中分别调用。

    /*-----------------------------------Moveable------------------------------------------*/
    	public class Moveable: MonoBehaviour {
    		
    		readonly float move_speed = 20;
    
    		// change frequently
    		int moving_status;	// 0->not moving, 1->moving to middle, 2->moving to dest
    		Vector3 dest;
    		Vector3 middle;
    
    		void Update() {
    			if (moving_status == 1) {
    				transform.position = Vector3.MoveTowards (transform.position, middle, move_speed * Time.deltaTime);
    				if (transform.position == middle) {
    					moving_status = 2;
    				}
    			} else if (moving_status == 2) {
    				transform.position = Vector3.MoveTowards (transform.position, dest, move_speed * Time.deltaTime);
    				if (transform.position == dest) {
    					moving_status = 0;
    				}
    			}
    		}
    		public void setDestination(Vector3 _dest) {
    			dest = _dest;
    			middle = _dest;
    			if (_dest.y == transform.position.y) {	// boat moving
    				moving_status = 2;
    			}
    			else if (_dest.y < transform.position.y) {	// character from coast to boat
    				middle.y = transform.position.y;
    			} else {								// character from boat to coast
    				middle.x = transform.position.x;
    			}
    			moving_status = 1;
    		}
    
    		public void reset() {
    			moving_status = 0;
    		}
    	}

    最终游戏的效果如下图所示:

    视频地址:https://www.bilibili.com/video/av68411117

    展开全文
  • 一、问题描述1、问题描述用c语言实现一个弹球游戏,实现小球在控制台一定范围内(可自行定义范围,此博客小球横坐标范围...小球在水平方向是匀速直线运动,在竖直方向是加速度向下变速运动。2.3.小球运动学方...
  • 高中物理33个核心考点解读(1):位移、...时间图象的物理意义:①匀速直线运动的s-t图象是一条倾斜直线,或某直线运动的s-t图象是倾斜直线则表示其作匀速直线运动。②s-t图象中斜率(倾斜程度)大小表示物体运动快慢...
  • S和S’系分别为静止的参考系和相对静止参考系做匀速直线运动的参考系,伽利略和牛顿的实验已经证明,在两个参考系中所观测到的时间和空间不变。严格来说,这只是在低速条件下成立,物体的运动速度比光速小很多,采用...
  • 使用陀螺仪或者加速度计,首先要理解的就是各个坐标系,尤其是惯性参考坐标系...研究惯性器件的力学问题时,通常将相对恒星确定的参考系称作惯性空间,空间中静止或匀速直线运动的参考坐标系称为惯性参考坐标系。 研...
  • 滤波系列(一)卡尔曼滤波算法(KF)...举一个物体做匀速直线运动的例子: 物体的状态由位置和速度组成定义为 Xt=[xt,vt]TX_t=[x_t,v_t ]^TXt​=[xt​,vt​]T,根据匀速直线运动公式可知: xt=xt−1+vt∆t+12a∆t2(1...
  • ,这和IT系统和代码没有什么关系;鸡汤式文章,看烦了就关掉吧,想看请听我碎碎念。...百度百科是这样定义惯性定理,“一切物体在没有受到力作用时候,总保持静止状态或匀速直线运动状态...
  • 在实现运动控制范围内,行程控制又可分为直线和曲线、进退与上下,如果将其细分并观察其特点,就有了:直线——平面上前后左右、曲线——规则曲线和不规则曲线、进退——在平面内界定方向后,前后就成为进退、...
  • 在实现运动控制范围内,行程控制又可分为直线和曲线、进退与上下,如果将其细分并观察其特点,就有了:直线——平面上前后左右、曲线——规则曲线和不规则曲线、进退——在平面内界定方向后,前后就成为进退、...
  • 1.电功率P(补充:W代表功 ): 1.1 公式1:P=W/t=UI ; 公式2:P=I^2 * R=U^2/R (适用纯电阻电路,用到了U=IR即...公式2:P=FV (适用匀速直线运动); 2.2 单位1:P单位是瓦特(简称瓦),符号是W ; 单位2:W单位...
  • 1、胡克:英国物理学家;发现了胡克定律(F弹=kx)  2、伽利略:意大利的著名物理学家;...通过斜面实验,推断出物体如不受外力作用将维持匀速直线运动的结论。后由牛顿归纳成惯性定律。伽利略的科学推理方法是
  • 牛顿第一定律:不受力或受合力为零质点做匀速直线运动或静止 牛顿第一定律作用是定义惯性系,满足牛顿第一定律即是惯性系,相对于惯性系静止或匀速运动且没有相对转动坐标系是惯性系 牛顿第二定律:质点所受...
  • 静力学

    2019-07-10 20:25:00
    概述 静力学是经典力学重要基础,在以后力学学习中经常使用 ...物体处于静止状态或匀速直线运动状态 $F_{合}=0$或者$\begin{cases} F_x=0 \\ F_y=0 \end{cases}$ 力合成与分解 共...
  • css3

    2011-12-06 11:07:36
    一、animation 属性:1、animation-name 定义和用法 动画name属性指定了一个名称为@关键帧动画。@keyframes name 2、animation-duration ...(1)linear 匀速直线运动 (1)ease 慢到快再到慢 (1)ease-in
  • 初中物理公式之力学部分(1)匀速直线运动的速度公式:v=S/t(2)重力与质量的关系:G=mg(3)密度定义式:ρ=m/V(4)压强定义式:p=F/S(5)液体压强公式:p=ρgh注:h指的是距离液面的深度。(6)浮力定义公式F浮...
  • 初中物理公式之力学部分(1)匀速直线运动的速度公式:v=S/t(2)重力与质量的关系:G=mg(3)密度定义式:ρ=m/V(4)压强定义式:p=F/S(5)液体压强公式:p=ρgh注:h指的是距离液面的深度。(6)浮力定义公式F浮...
  • 高考中常出现多种运动形式组合 匀速直线运动 F合=0 V0≠0 静止 匀变速直线运动:初速为零,初速不为零, 匀变速直曲线运动(决于F合与V0方向关系) 但 F合= 恒力 只受重力作用下几种运动:自由落体,竖直下抛,...
  • 第六部分 振动和波第一讲 基本知识...谐振子的加速度:=-2、简谐运动的方程回避高等数学工具,我们可以将简谐运动看成匀速圆周运动在某一条直线上的投影运动(以下均看在x方向的投影),圆周运动的半径即为简谐运动的...
  • 数学图形之螺旋曲面

    2014-07-31 12:45:00
    这一节中将提供各种螺旋曲面的生成方法. ... 正螺旋面就是让一条直线l的初始位置与x轴重合,然后让直线l一边绕z轴作匀速转动,一边沿z轴方向作匀速运动,则直线在这两种运动的合成下扫出的曲面就是正螺...

空空如也

空空如也

1 2
收藏数 32
精华内容 12
关键字:

匀速直线运动的定义