Roll a Ball & Battle City

这是以前做过的两个小游戏，是根据unity官方教程来学习的，非常的简单。github下载地址在文末。

Roll a Ball：

控制一个球来回移动，碰撞旋转的cube可以消除，颜色可以根据自己的喜好来设定，Roll a Ball其实也不算个游戏，没有音效，只有简单的字体UI。不过camera可以随着球体的移动而移动。下面是截图。

Battle City:

双人游戏，W/S/A/D/J控制player1，UP/DOWN/LEFT/RIGHT/ENTER控制player2。值得说的是，坦克在移动时尾部会有灰尘效果，而坦克发射炮弹时，上面有点光源，且炮弹落到地面有炸裂效果，炸裂效果是由几张贴图生成的。炮弹对于对方坦克具有物理击飞效果。Battle City具有背景音效，炮弹音效等等，也具有文字UI。

 

两个游戏都是由C#来撰写游戏逻辑的。

Roll a Ball：

using UnityEngine;
using System.Collections;

public class CameraController : MonoBehaviour {

    public GameObject player;

    private Vector3 offset;

    // Use this for initialization
    void Start () {
        offset = transform.position - player.transform.position;
    }
    
    // Update is called once per frame
    void LateUpdate () {
        transform.position = player.transform.position + offset;
    }
}

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

public class PlayerController : MonoBehaviour
{

    public float speed;
    public Text countText;
    public Text winText;

    private Rigidbody rb;

    private int count;

    void Start()
    {
        rb = GetComponent<Rigidbody>();
        count = 0;
        SetCountText();
        winText.text = "";
    }

    void FixedUpdate()
    {
        float moveHorizontal = Input.GetAxis("Horizontal");
        float moveVertical = Input.GetAxis("Vertical");

        Vector3 movement = new Vector3(moveHorizontal, 0.0f, moveVertical);

        rb.AddForce(movement * speed);
    }

    void OnTriggerEnter(Collider other)
    {
        if (other.gameObject.CompareTag("Pick up"))
        {
            other.gameObject.SetActive(false);
            count = count + 1;
            SetCountText();
        }
    }

    void SetCountText()
    {
        countText.text = "Count: " + count.ToString();
        if (count >= 16)
        {
            winText.text = "You Win!";
        }
    }
}

using UnityEngine;
using System.Collections;

public class Rotator : MonoBehaviour {
    
    // Update is called once per frame
    void Update () {
        transform.Rotate(new Vector3(15, 30, 45) * Time.deltaTime);
    }
}

Battle City：

• Camera 

  using UnityEngine;
  
  public class CameraControl : MonoBehaviour
  {
      public float m_DampTime = 0.2f;                 
      public float m_ScreenEdgeBuffer = 4f;           
      public float m_MinSize = 6.5f;                  
      [HideInInspector] public Transform[] m_Targets; 
  
  
      private Camera m_Camera;                        
      private float m_ZoomSpeed;                      
      private Vector3 m_MoveVelocity;                 
      private Vector3 m_DesiredPosition;              
  
  
      private void Awake()
      {
          m_Camera = GetComponentInChildren<Camera>();
      }
  
  
      private void FixedUpdate()
      {
          Move();
          Zoom();
      }
  
  
      private void Move()
      {
          FindAveragePosition();
  
          transform.position = Vector3.SmoothDamp(transform.position, m_DesiredPosition, ref m_MoveVelocity, m_DampTime);
      }
  
  
      private void FindAveragePosition()
      {
          Vector3 averagePos = new Vector3();
          int numTargets = 0;
  
          for (int i = 0; i < m_Targets.Length; i++)
          {
              if (!m_Targets[i].gameObject.activeSelf)
                  continue;
  
              averagePos += m_Targets[i].position;
              numTargets++;
          }
  
          if (numTargets > 0)
              averagePos /= numTargets;
  
          averagePos.y = transform.position.y;
  
          m_DesiredPosition = averagePos;
      }
  
  
      private void Zoom()
      {
          float requiredSize = FindRequiredSize();
          m_Camera.orthographicSize = Mathf.SmoothDamp(m_Camera.orthographicSize, requiredSize, ref m_ZoomSpeed, m_DampTime);
      }
  
  
      private float FindRequiredSize()
      {
          Vector3 desiredLocalPos = transform.InverseTransformPoint(m_DesiredPosition);
  
          float size = 0f;
  
          for (int i = 0; i < m_Targets.Length; i++)
          {
              if (!m_Targets[i].gameObject.activeSelf)
                  continue;
  
              Vector3 targetLocalPos = transform.InverseTransformPoint(m_Targets[i].position);
  
              Vector3 desiredPosToTarget = targetLocalPos - desiredLocalPos;
  
              size = Mathf.Max (size, Mathf.Abs (desiredPosToTarget.y));
  
              size = Mathf.Max (size, Mathf.Abs (desiredPosToTarget.x) / m_Camera.aspect);
          }
          
          size += m_ScreenEdgeBuffer;
  
          size = Mathf.Max(size, m_MinSize);
  
          return size;
      }
  
  
      public void SetStartPositionAndSize()
      {
          FindAveragePosition();
  
          transform.position = m_DesiredPosition;
  
          m_Camera.orthographicSize = FindRequiredSize();
      }
  }

• Managers

  using UnityEngine;
  using System.Collections;
  //using UnityEngine.SceneManagement;
  using UnityEngine.UI;
  
  public class GameManager : MonoBehaviour
  {
      public int m_NumRoundsToWin = 5;        
      public float m_StartDelay = 3f;         
      public float m_EndDelay = 3f;           
      public CameraControl m_CameraControl;   
      public Text m_MessageText;              
      public GameObject m_TankPrefab;         
      public TankManager[] m_Tanks;           
  
  
      private int m_RoundNumber;              
      private WaitForSeconds m_StartWait;     
      private WaitForSeconds m_EndWait;       
  /*    private TankManager m_RoundWinner;
      private TankManager m_GameWinner;       
  */
  
      private void Start()
      {
          m_StartWait = new WaitForSeconds(m_StartDelay);
          m_EndWait = new WaitForSeconds(m_EndDelay);
  
          SpawnAllTanks();
          SetCameraTargets();
  
          StartCoroutine(GameLoop());
      }
  
  
      private void SpawnAllTanks()
      {
          for (int i = 0; i < m_Tanks.Length; i++)
          {
              m_Tanks[i].m_Instance =
                  Instantiate(m_TankPrefab, m_Tanks[i].m_SpawnPoint.position, m_Tanks[i].m_SpawnPoint.rotation) as GameObject;
              m_Tanks[i].m_PlayerNumber = i + 1;
              m_Tanks[i].Setup();
          }
      }
  
  
      private void SetCameraTargets()
      {
          Transform[] targets = new Transform[m_Tanks.Length];
  
          for (int i = 0; i < targets.Length; i++)
          {
              targets[i] = m_Tanks[i].m_Instance.transform;
          }
  
          m_CameraControl.m_Targets = targets;
      }
  
  
      private IEnumerator GameLoop()
      {
          yield return StartCoroutine(RoundStarting());
          yield return StartCoroutine(RoundPlaying());
          yield return StartCoroutine(RoundEnding());
  
  /*        if (m_GameWinner != null)
          {
              SceneManager.LoadScene(0);
          }
          else
          {
              StartCoroutine(GameLoop());
          }
  */    }
  
  
      private IEnumerator RoundStarting()
      {
          yield return m_StartWait;
      }
  
  
      private IEnumerator RoundPlaying()
      {
          yield return null;
      }
  
  
      private IEnumerator RoundEnding()
      {
          yield return m_EndWait;
      }
  
  
      private bool OneTankLeft()
      {
          int numTanksLeft = 0;
  
          for (int i = 0; i < m_Tanks.Length; i++)
          {
              if (m_Tanks[i].m_Instance.activeSelf)
                  numTanksLeft++;
          }
  
          return numTanksLeft <= 1;
      }
  
  /*
      private TankManager GetRoundWinner()
      {
          for (int i = 0; i < m_Tanks.Length; i++)
          {
              if (m_Tanks[i].m_Instance.activeSelf)
                  return m_Tanks[i];
          }
  
          return null;
      }
  
  
      private TankManager GetGameWinner()
      {
          for (int i = 0; i < m_Tanks.Length; i++)
          {
              if (m_Tanks[i].m_Wins == m_NumRoundsToWin)
                  return m_Tanks[i];
          }
  
          return null;
      }
  
  
      private string EndMessage()
      {
          string message = "DRAW!";
  
          if (m_RoundWinner != null)
              message = m_RoundWinner.m_ColoredPlayerText + " WINS THE ROUND!";
  
          message += "
  
  
  
  ";
  
          for (int i = 0; i < m_Tanks.Length; i++)
          {
              message += m_Tanks[i].m_ColoredPlayerText + ": " + m_Tanks[i].m_Wins + " WINS
  ";
          }
  
          if (m_GameWinner != null)
              message = m_GameWinner.m_ColoredPlayerText + " WINS THE GAME!";
  
          return message;
      }
  */
  
      private void ResetAllTanks()
      {
          for (int i = 0; i < m_Tanks.Length; i++)
          {
              m_Tanks[i].Reset();
          }
      }
  
  
      private void EnableTankControl()
      {
          for (int i = 0; i < m_Tanks.Length; i++)
          {
              m_Tanks[i].EnableControl();
          }
      }
  
  
      private void DisableTankControl()
      {
          for (int i = 0; i < m_Tanks.Length; i++)
          {
              m_Tanks[i].DisableControl();
          }
      }
  }

  using System;
  using UnityEngine;
  
  [Serializable]
  public class TankManager
  {
      public Color m_PlayerColor;            
      public Transform m_SpawnPoint;         
      [HideInInspector] public int m_PlayerNumber;             
      [HideInInspector] public string m_ColoredPlayerText;
      [HideInInspector] public GameObject m_Instance;          
      [HideInInspector] public int m_Wins;                     
  
  
      private TankMovement m_Movement;       
      private TankShooting m_Shooting;
      private GameObject m_CanvasGameObject;
  
  
      public void Setup()
      {
          m_Movement = m_Instance.GetComponent<TankMovement>();
          m_Shooting = m_Instance.GetComponent<TankShooting>();
          m_CanvasGameObject = m_Instance.GetComponentInChildren<Canvas>().gameObject;
  
          m_Movement.m_PlayerNumber = m_PlayerNumber;
          m_Shooting.m_PlayerNumber = m_PlayerNumber;
  
          m_ColoredPlayerText = "<color=#" + ColorUtility.ToHtmlStringRGB(m_PlayerColor) + ">PLAYER " + m_PlayerNumber + "</color>";
  
          MeshRenderer[] renderers = m_Instance.GetComponentsInChildren<MeshRenderer>();
  
          for (int i = 0; i < renderers.Length; i++)
          {
              renderers[i].material.color = m_PlayerColor;
          }
      }
  
  
      public void DisableControl()
      {
          m_Movement.enabled = false;
          m_Shooting.enabled = false;
  
          m_CanvasGameObject.SetActive(false);
      }
  
  
      public void EnableControl()
      {
          m_Movement.enabled = true;
          m_Shooting.enabled = true;
  
          m_CanvasGameObject.SetActive(true);
      }
  
  
      public void Reset()
      {
          m_Instance.transform.position = m_SpawnPoint.position;
          m_Instance.transform.rotation = m_SpawnPoint.rotation;
  
          m_Instance.SetActive(false);
          m_Instance.SetActive(true);
      }
  }

• Shell

  using UnityEngine;
  
  public class ShellExplosion : MonoBehaviour
  {
      public LayerMask m_TankMask;
      public ParticleSystem m_ExplosionParticles;       
      public AudioSource m_ExplosionAudio;              
      public float m_MaxDamage = 100f;                  
      public float m_ExplosionForce = 1000f;            
      public float m_MaxLifeTime = 2f;                  
      public float m_ExplosionRadius = 5f;              
  
  
      private void Start()
      {
          Destroy(gameObject, m_MaxLifeTime);
      }
  
  
      private void OnTriggerEnter(Collider other)
      {
          // Find all the tanks in an area around the shell and damage them.
          Collider[] colliders = Physics.OverlapSphere(transform.position, m_ExplosionRadius, m_TankMask);
          for (int i = 0; i < colliders.Length; i++)
          {
              Rigidbody targetRigidbody = colliders[i].GetComponent<Rigidbody>();
  
              if (!targetRigidbody)
                  continue;
  
              targetRigidbody.AddExplosionForce(m_ExplosionForce, transform.position, m_ExplosionRadius);
              TankHealth targetHealth = targetRigidbody.GetComponent<TankHealth>();
  
              if (!targetHealth)
                  continue;
  
              float damage = CalculateDamage(targetRigidbody.position);
  
              targetHealth.TakeDamage(damage);
          }
  
          m_ExplosionParticles.transform.parent = null;
  
          m_ExplosionParticles.Play();
  
          m_ExplosionAudio.Play();
  
          Destroy(m_ExplosionParticles.gameObject, m_ExplosionParticles.duration);
          Destroy(gameObject);
      }
  
  
      private float CalculateDamage(Vector3 targetPosition)
      {
          // Calculate the amount of damage a target should take based on it's position.
          Vector3 explosionToTarget = targetPosition - transform.position;
  
          float explosionDistance = explosionToTarget.magnitude;
  
          float relativeDistance = (m_ExplosionRadius - explosionDistance) / m_ExplosionRadius;
  
          float damage = relativeDistance * m_MaxDamage;
  
          damage = Mathf.Max(0f, damage);
  
          return damage;
      }
  }

• UI

  using UnityEngine;
  
  public class UIDirectionControl : MonoBehaviour
  {
      public bool m_UseRelativeRotation = true;  
  
  
      private Quaternion m_RelativeRotation;     
  
  
      private void Start()
      {
          m_RelativeRotation = transform.parent.localRotation;
      }
  
  
      private void Update()
      {
          if (m_UseRelativeRotation)
              transform.rotation = m_RelativeRotation;
      }
  }

• UITank

  using UnityEngine;
  using UnityEngine.UI;
  
  public class TankHealth : MonoBehaviour
  {
      public float m_StartingHealth = 100f;          
      public Slider m_Slider;                        
      public Image m_FillImage;                      
      public Color m_FullHealthColor = Color.green;  
      public Color m_ZeroHealthColor = Color.red;    
      public GameObject m_ExplosionPrefab;
      
      /*
      private AudioSource m_ExplosionAudio;          
      private ParticleSystem m_ExplosionParticles;   
      private float m_CurrentHealth;  
      private bool m_Dead;            
  
  
      private void Awake()
      {
          m_ExplosionParticles = Instantiate(m_ExplosionPrefab).GetComponent<ParticleSystem>();
          m_ExplosionAudio = m_ExplosionParticles.GetComponent<AudioSource>();
  
          m_ExplosionParticles.gameObject.SetActive(false);
      }
  
  
      private void OnEnable()
      {
          m_CurrentHealth = m_StartingHealth;
          m_Dead = false;
  
          SetHealthUI();
      }
      */
  
      public void TakeDamage(float amount)
      {
          // Adjust the tank's current health, update the UI based on the new health and check whether or not the tank is dead.
      }
  
  
      private void SetHealthUI()
      {
          // Adjust the value and colour of the slider.
      }
  
  
      private void OnDeath()
      {
          // Play the effects for the death of the tank and deactivate it.
      }
  }

  using UnityEngine;
  
  public class TankMovement : MonoBehaviour
  {
      public int m_PlayerNumber = 1;         
      public float m_Speed = 12f;            
      public float m_TurnSpeed = 180f;       
      public AudioSource m_MovementAudio;    
      public AudioClip m_EngineIdling;       
      public AudioClip m_EngineDriving;      
      public float m_PitchRange = 0.2f;
  
      /*
      private string m_MovementAxisName;     
      private string m_TurnAxisName;         
      private Rigidbody m_Rigidbody;         
      private float m_MovementInputValue;    
      private float m_TurnInputValue;        
      private float m_OriginalPitch;         
  
  
      private void Awake()
      {
          m_Rigidbody = GetComponent<Rigidbody>();
      }
  
  
      private void OnEnable ()
      {
          m_Rigidbody.isKinematic = false;
          m_MovementInputValue = 0f;
          m_TurnInputValue = 0f;
      }
  
  
      private void OnDisable ()
      {
          m_Rigidbody.isKinematic = true;
      }
  
  
      private void Start()
      {
          m_MovementAxisName = "Vertical" + m_PlayerNumber;
          m_TurnAxisName = "Horizontal" + m_PlayerNumber;
  
          m_OriginalPitch = m_MovementAudio.pitch;
      }
      */
  
      private void Update()
      {
          // Store the player's input and make sure the audio for the engine is playing.
      }
  
  
      private void EngineAudio()
      {
          // Play the correct audio clip based on whether or not the tank is moving and what audio is currently playing.
      }
  
  
      private void FixedUpdate()
      {
          // Move and turn the tank.
      }
  
  
      private void Move()
      {
          // Adjust the position of the tank based on the player's input.
      }
  
  
      private void Turn()
      {
          // Adjust the rotation of the tank based on the player's input.
      }
  }

  using UnityEngine;
  using UnityEngine.UI;
  
  public class TankShooting : MonoBehaviour
  {
      public int m_PlayerNumber = 1;       
      public Rigidbody m_Shell;            
      public Transform m_FireTransform;    
      public Slider m_AimSlider;           
      public AudioSource m_ShootingAudio;  
      public AudioClip m_ChargingClip;     
      public AudioClip m_FireClip;         
      public float m_MinLaunchForce = 15f; 
      public float m_MaxLaunchForce = 30f; 
      public float m_MaxChargeTime = 0.75f;
  
      /*
      private string m_FireButton;         
      private float m_CurrentLaunchForce;  
      private float m_ChargeSpeed;         
      private bool m_Fired;                
  
  
      private void OnEnable()
      {
          m_CurrentLaunchForce = m_MinLaunchForce;
          m_AimSlider.value = m_MinLaunchForce;
      }
  
  
      private void Start()
      {
          m_FireButton = "Fire" + m_PlayerNumber;
  
          m_ChargeSpeed = (m_MaxLaunchForce - m_MinLaunchForce) / m_MaxChargeTime;
      }
      */
  
      private void Update()
      {
          // Track the current state of the fire button and make decisions based on the current launch force.
      }
  
  
      private void Fire()
      {
          // Instantiate and launch the shell.
      }
  }

链接：https://github.com/yl-me/Game