自制滚动的天空，原来很简单，就差细节来人给做做

于 2018-05-02 11:09:42 发布
阅读量1.3w 收藏 14
点赞数 4
分类专栏： unity插件my 文章标签： unity 游戏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42030891/article/details/80163293
版权

滚动的天空，比较好玩的游戏，自己也尝试着做一做，


场景的样子，是这样的，很简单


运行后是这样的，用鼠标在屏幕上下滑动可以实现跳起来和快速落下，左右划就可以左右摆动一格，

给你整个小包包

 密码: ubga

代码解释：

ballrun是控制小球的，实现滑动控制小球的动作，代码里控制了小球的跳跃高度，左右最大距离和时间，还有记录分数等，这里用了dotween，让小球看起来平滑，重要信息都有备注了，需要的话可以调试修改，里面也用到了动画，可以改一下动画，方便添加复杂任务等

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using DG.Tweening;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using System;

public class ballrun : MonoBehaviour {

    //使用dotween方法，实现小球平滑
   
    public static float gametime = 0.5f;//左右划使用一秒时间完成
    public Vector3 jumpheight = new Vector3(0, 6, 0);//向上滑，跳的高度，只修改y值；记得修改系统重力，此处为-13的重力；
    public Text tes;
    public Button starga;

    private int gameposX;//记录小球当前x轴；
    private bool isgroound = true;
    private float terr = 0.38f;//在小球下方0.35米处检测；
    public static Vector3 gospeed = new Vector3(0, 0, 1);//小球的前进速度，
    public static Transform balltr;
    private Animator ani;
    void ground()
    {
        balltr = transform;

      
        // 以摄像机所在位置为起点，创建一条向下发射的射线  
        Ray ray = new Ray(transform.position, -transform.up);
        RaycastHit hit;
        if (Physics.Raycast(ray, out hit, terr))
        {
            // 如果射线与平面碰撞，打印碰撞物体信息  
            //Debug.Log("碰撞对象: " + hit.collider.name);
            // 在场景视图中绘制射线  
            Debug.DrawLine(transform.position, hit.point, Color.red);
            if (hit.collider.name != null)
            {
                isgroound = true;
                ani.SetBool("down", false);
               
            }
   
        }
        else
        {
       
        }

    }
    
    //下面为百度资源，为了快速，实现识别手指滑动方向，
    private float fingerActionSensitivity = Screen.width * 0.05f; 
    //手指动作的敏感度，这里设定为 二十分之一的屏幕宽度.
    private float fingerBeginX;
    private float fingerBeginY;
    private float fingerCurrentX;
    private float fingerCurrentY;
    private float fingerSegmentX;
    private float fingerSegmentY;
    //
    private int fingerTouchState;
    //
    private int FINGER_STATE_NULL = 0;
    private int FINGER_STATE_TOUCH = 1;
    private int FINGER_STATE_ADD = 2;
    // Use this for initialization
    void Start()
    {
        Time.timeScale = 1;
        gospeed = new Vector3(0, 0, 0.02f);
        balltr = transform;
        ani = gameObject.GetComponent<Animator>();


        fingerActionSensitivity = Screen.width * 0.05f;

        fingerBeginX = 0;
        fingerBeginY = 0;
        fingerCurrentX = 0;
        fingerCurrentY = 0;
        fingerSegmentX = 0;
        fingerSegmentY = 0;

        fingerTouchState = FINGER_STATE_NULL;
        tes.text = "";
        starga.gameObject.SetActive(false);
    }
    // Update is called once per frame

      

    private void OnEnable()
    {
       
      
        starga.onClick.AddListener(starscene);

    }

    private void starscene()
    {
        Time.timeScale = 1;
        SceneManager.LoadScene("lifescene");

    }

    void Update()
    {
        ground();
        //当掉下去的时候，重新开始游戏；
        if (gameObject.transform.position.y <=-0.2f)
        {
            starga.gameObject.SetActive(true);
            tes.text = "得分："  + (int)(lifemape.ballz);
            Time.timeScale = 0;
        }
        else
        {
           // print(gospeed.z);
            gameObject.transform.position += gospeed;
        }


        if (Input.GetKeyDown(KeyCode.Mouse0))
        {

            if (fingerTouchState == FINGER_STATE_NULL)
            {
                fingerTouchState = FINGER_STATE_TOUCH;
                fingerBeginX = Input.mousePosition.x;
                fingerBeginY = Input.mousePosition.y;
            }

        }

        if (fingerTouchState == FINGER_STATE_TOUCH)
        {
            fingerCurrentX = Input.mousePosition.x;
            fingerCurrentY = Input.mousePosition.y;
            fingerSegmentX = fingerCurrentX - fingerBeginX;
            fingerSegmentY = fingerCurrentY - fingerBeginY;

        }


        if (fingerTouchState == FINGER_STATE_TOUCH)
        {
            float fingerDistance = fingerSegmentX * fingerSegmentX + fingerSegmentY * fingerSegmentY;

            if (fingerDistance > (fingerActionSensitivity * fingerActionSensitivity))
            {
                toAddFingerAction();
            }
        }

        if (Input.GetKeyUp(KeyCode.Mouse0))
        {
            fingerTouchState = FINGER_STATE_NULL;
        }
    }

    private void toAddFingerAction()
    {

        fingerTouchState = FINGER_STATE_ADD;

        if (Mathf.Abs(fingerSegmentX) > Mathf.Abs(fingerSegmentY))
        {
            fingerSegmentY = 0;
        }
        else
        {
            fingerSegmentX = 0;
        }

        if (fingerSegmentX == 0)
        {
            if (fingerSegmentY > 0)
            {
                //Debug.Log("up");//上滑时执行的地方；
                if (isgroound)//射线检测好是否着地，是否能跳
                {
                    isgroound = false;
                    gameObject.GetComponent<Rigidbody>().velocity = jumpheight;
                  
                    ani.SetBool("down", true);
                }
 
            }
            else
            {
                //Debug.Log("down");//下滑执行的地方
                gameObject.GetComponent<Rigidbody>().velocity = -jumpheight;
            }
        }
        else if (fingerSegmentY == 0)
        {
            if (fingerSegmentX > 0)
            {
                //Debug.Log("right");//右滑时执行的地方
                gameposX++;
                if (gameposX> lifemape.cubecount)
                {
                    gameposX = lifemape.cubecount;
                }
                gameObject.transform.DOMoveX(gameposX, gametime);
              
            }
            else
            {
                //Debug.Log("left");//左滑时执行的地方
                gameposX--;
                if (gameposX < -lifemape.cubecount)
                {
                    gameposX = -lifemape.cubecount;
                }
                gameObject.transform.DOMoveX(gameposX, gametime);
                
            }
        }

    }
}

cameraflow是给相机附上的，为了玩起来后感觉很有3d的感觉，而且也平滑的很多，很多游戏也可以用这个相机的，也可以直接调节里面的参数，拥有不同的效果，

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

public class CameraFlow : MonoBehaviour {

    //相机平滑跟随代码；代码赋给相机
    public  Transform target;//目标需要赋值目标；


    public float distanceUp = 1.5f;
    public float distanceAway = 2.8f;
    public float hig = 1;//相机看到比目标高点的距离；
    public float smooth = 10.0f;//位置平滑移动值这里不需要太平滑，所以直接改为10
    public float camDepthSmooth = -10f;//滑轮控制远近速度；

    private Vector3 disPos;
    // Use this for initialization
    void Start()
    {

        //target.position += new Vector3(0, 10, 0);
    }

    // Update is called once per frame
    void Update()
    {
        // 鼠标轴控制相机的远近
        if ((Input.mouseScrollDelta.y != 0))
        {
            
                distanceAway += Input.mouseScrollDelta.y * camDepthSmooth * Time.deltaTime;

            if (distanceAway > 6.0f)
            {
                distanceAway = 6.0f;
            }
            if (distanceAway < 1.6f)
            {
                distanceAway = 1.6f;
            }
        }
        if (target)
        {
            disPos = target.position + Vector3.up * distanceUp - target.forward * distanceAway;
            transform.position = Vector3.Lerp(transform.position, disPos, Time.deltaTime * smooth);
        }            //相机的角度
        transform.LookAt(  new Vector3(target.position.x, hig, target.position.z + distanceAway * 2));
    }

 
}

lifemape，本来想用生命游戏里面的原理制作地图，但是现在没心情，因为正在求职中，有点烦，所以就用随机的原理做了一个地图。开始时，克隆好了所有的cube，等待使用，进行调节cube的位置，创建好了你看到的地图，barrier就是添加的障碍物，如需更多按着barrier找到哪里添加障碍物

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

public class lifemape : MonoBehaviour {

    public static int cubecount = 2;//代表左边或右边最多为几个；
    public GameObject cube;//出现cube的预设体；
    public GameObject barrier;//障碍物模型；
    public Text grade;

    private GameObject[] barriers;
    private GameObject[][] cubes;
    private float time;
    private int cubeZ;
    private Vector3 newbarrier = new Vector3(0,0.3f, 0);
	// Use this for initialization
	void Start () {



        cubes = new GameObject[20][];
        grade.text = "新的游戏";

        for (int i = 0; i < cubes.Length; i++)
        {
            cubes[i] = new GameObject[cubecount * 2 + 1];
        }

        //场景里最多出现100个障碍物；
        barriers = new GameObject[100];
        for (int i = 0; i < barriers.Length; i++)
        {
            barriers[i] = Instantiate(barrier,gameObject.transform);
        }
       
        for (int i = 0; i < cubes.Length; i++)
        {
            for (int j = 0; j < cubes[i].Length; j++)
            {
                cubes[i][j] = Instantiate(cube,gameObject.transform);
            }
        }

        time = ballrun.gametime;
    }

    private int iii;
    private int zzz;
    public static int ballz;
	// Update is called once per frame
	void Update () {
   
        ballz = ((int)(ballrun.balltr.position.z));

        if (ballz > 0)
        {
            grade.text ="" + "分数: "+ ballz.ToString();
        }

        if (ballz> zzz && ballz != zzz)
        {
            zzz = ballz;
            if (iii==cubes.Length -1)
            {
                iii = 0;
            }
            if (iii < cubes.Length)
            {
                iii++;
                cubeZ++;
                for (int j = 0; j < cubes[iii].Length; j++)
                {
                    cubes[iii][j].transform.position = new Vector3(j - cubecount, 0, cubeZ);
                    if (Random.Range(0, 2) == 1)
                    {
                        cubes[iii][j].SetActive(true);
                        //此处为显示出方块的地方在显示方块的地方在随机添加一个障碍物，，,,,,,,,,,,,,,,,,,,,,,,,
                        if (Random.Range(0, 2) == 1)
                        {
                            
                            barriers[iii * cubecount * 2 + j].transform.position = cubes[iii][j].transform.position + newbarrier;
                            barriers[iii * cubecount * 2 + j].SetActive(true);
                        }

                      

                    }
                    else
                    {
                        cubes[iii][j].SetActive(false);
                    }
                }
                
            }
        }
        else
        {
            zzz = ballz;
        }
	}
    
}


cubeani没有太大作用，只是为了提高游戏的可玩性和难度，在这个游戏里旋转的cube用的这个代码，也可以添加自己的难度，放在地图里，

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

public class cubeani : MonoBehaviour {

	// Use this for initialization
	void Start () {
        gameObject.transform.eulerAngles = new Vector3(0,Random.Range(0,180), 0);
	}
    public Vector3 rospeed = new Vector3(0,1, 0);
	// Update is called once per frame
	void Update () {
        gameObject.transform.eulerAngles += rospeed;
	}
}

 

我觉得重要的地方都有注释，代码不算太难，我制作用了一下午时间，如果喜欢多多支持，
 

再看一下玩起来的样子，
 


 

挂了
 


 

随机的地图，可能挂不掉，可以增加速度活其他来增加难度，
 


 

地图不怎么好看，你可以改改地图，然后直接打包成手机玩玩，

                

        

        

    

  


    

      

        

            

              
                
                  tianxindodo
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









              

  



          




        



    





    



      

      

        
      

      





	

		
评论 2

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值