Building a 3D Shooter

Building it Single Player

Making it Multiplayer

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class Bomb : MonoBehaviour
{
[SerializeField] float _countdownTime = 5f;
[SerializeField] float _radius = 5f;
[SerializeField] int _damage = 5;
float _explodeTime;
int _playerNumber;
public void SetPlayer(int playerNumber) => _playerNumber = playerNumber;
// Start is called before the first frame update
IEnumerator Start()
{
_explodeTime = Time.time + _countdownTime;
while (Time.time < _explodeTime)
{
yield return null;
float randomRed = Random.Range(0, 255);
Color newColor = new Color(randomRed, 0, 0);
GetComponent<Renderer>().material.color = newColor;
}
// Do damage
Collider[] colliders = Physics.OverlapSphere(transform.position, _radius);
foreach (var collider in colliders)
{
var enemy = collider.GetComponent<Enemy>();
if (enemy)
enemy.TakeDamage(enemy.transform.position, _playerNumber, _damage);
}
Destroy(gameObject);
}
}
view raw Bomb.cs hosted with ❤ by GitHub
using UnityEngine;
public class BombDropper : MonoBehaviour
{
[SerializeField] Bomb _bombPrefab;
[SerializeField] float _delay = 5;
[SerializeField] float _releaseVelocity = 10f;
float _nextDropTime;
Player _player;
void Awake() => _player = GetComponent<Player>();
void Update()
{
if (ShouldDropBomb())
DropBomb();
}
void DropBomb()
{
_nextDropTime = Time.time + _delay;
Bomb bomb = Instantiate(_bombPrefab, transform.position, transform.rotation);
bomb.SetPlayer(_player.PlayerNumber);
var rigidbody = bomb.GetComponent<Rigidbody>();
if (rigidbody != null)
rigidbody.velocity = transform.forward * _releaseVelocity;
}
bool ShouldDropBomb()
{
if (Time.time >= _nextDropTime && Input.GetButtonDown("Bomb" + _player.PlayerNumber))
return true;
return false;
}
}
view raw BombDropper.cs hosted with ❤ by GitHub
using UnityEngine;
public class Bullet: MonoBehaviour
{
[SerializeField] float _maxLifetime = 10;
Gun _gun;
float _disableTime;
public void SetGun(Gun gun) => _gun = gun;
void OnCollisionEnter(Collision collision)
{
gameObject.SetActive(false);
_gun?.AddToPool(this);
var enemy = collision.collider.GetComponent<Enemy>();
if (enemy != null)
{
int playerNumber = _gun.GetComponent<Player>().PlayerNumber;
enemy.TakeDamage(collision.contacts[0].point, playerNumber);
}
}
void Update()
{
if (Time.time >= _disableTime)
gameObject.SetActive(false);
}
void OnEnable() => _disableTime = Time.time + _maxLifetime;
}
view raw Bullet.cs hosted with ❤ by GitHub
using System;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.SceneManagement;
public class Enemy : MonoBehaviour
{
[SerializeField] GameObject _hitPrefab;
[SerializeField] GameObject _explosionPrefab;
[SerializeField] int _health = 3;
[SerializeField] int _pointValue = 100;
AudioSource _audioSource;
int _currentHealth;
void OnEnable()
{
_audioSource = GetComponent<AudioSource>();
_currentHealth = _health;
}
void Update()
{
var player = FindObjectOfType<Player>();
GetComponent<NavMeshAgent>().SetDestination(player.transform.position);
}
public void TakeDamage(Vector3 impactPoint, int playerNumber, int amount = 1)
{
_currentHealth -= amount ;
Instantiate(_hitPrefab, impactPoint, transform.rotation);
if (_audioSource != null)
_audioSource.Play();
if (_currentHealth <= 0)
{
Instantiate(_explosionPrefab, impactPoint, transform.rotation);
gameObject.SetActive(false);
ScoreSystem.Add(_pointValue, playerNumber);
}
}
void OnCollisionEnter(Collision collision)
{
var player = collision.collider.GetComponent<Player>();
if (player != null)
{
SceneManager.LoadScene(0);
}
}
}
view raw Enemy.cs hosted with ❤ by GitHub
using System.Collections.Generic;
using UnityEngine;
public class Gun : MonoBehaviour
{
[SerializeField] Bullet _bulletPrefab;
[SerializeField] float _delay = 0.2f;
[SerializeField] float _bulletSpeed = 5f;
float _nextShootTime;
Vector3 _direction;
Queue<Bullet> _pool = new Queue<Bullet>();
Player _player;
void Awake() => _player = GetComponent<Player>();
void Update()
{
if (CanShoot())
Shoot();
}
void Shoot()
{
_nextShootTime = Time.time + _delay;
var bullet = GetBullet();
bullet.transform.position = _player.ShootPoint.position;
bullet.transform.rotation = _player.ShootPoint.rotation;
bullet.GetComponent<Rigidbody>().velocity = transform.forward * _bulletSpeed;
}
Bullet GetBullet()
{
if (_pool.Count > 0)
{
var bullet = _pool.Dequeue();
bullet.gameObject.SetActive(true);
return bullet;
}
else
{
var bullet = Instantiate(_bulletPrefab, _player.ShootPoint.position, _player.ShootPoint.rotation);
bullet.SetGun(this);
return bullet;
}
}
bool CanShoot()
{
return Time.time >= _nextShootTime;
}
public void AddToPool(Bullet bullet)
{
_pool.Enqueue(bullet);
}
}
view raw Gun.cs hosted with ❤ by GitHub
using UnityEngine;
public class Player : MonoBehaviour
{
[SerializeField] float _speed = 1f;
[SerializeField] Transform _direction;
[SerializeField] Transform _shootPoint;
[SerializeField] int _playerNumber = 1;
public Transform ShootPoint => _shootPoint;
public int PlayerNumber => _playerNumber;
Animator _animator;
void Awake() => _animator = GetComponent<Animator>();
void Update()
{
MoveWithController();
AimWithController();
}
void MoveWithController()
{
float horizontal = Input.GetAxis("Horizontal" + _playerNumber);
float vertical = Input.GetAxis("Vertical" + _playerNumber);
Vector3 movement = new Vector3(horizontal, 0f, vertical);
transform.Translate(movement * Time.deltaTime * _speed, _direction);
_animator.SetBool("Run", movement.magnitude > 0);
}
void AimWithController()
{
float horizontalAim = Input.GetAxis("HorizontalAim" + _playerNumber);
float verticalAim = Input.GetAxis("VerticalAim" + _playerNumber);
if (horizontalAim != 0 && verticalAim != 0)
transform.forward = new Vector3(horizontalAim, 0, verticalAim);
}
}
view raw Player.cs hosted with ❤ by GitHub
using TMPro;
using UnityEngine;
public class ScoreSystem : MonoBehaviour
{
int _player1;
int _player2;
static int _highScore;
static ScoreSystem _instance;
void Awake() => _instance = this;
[SerializeField] TMP_Text _player1Text;
[SerializeField] TMP_Text _player2Text;
[SerializeField] TMP_Text _highScoreText;
public void ResetHighScore()
{
_highScore = 0;
PlayerPrefs.SetInt("HighScore", _highScore);
UpdateText();
}
void OnEnable()
{
_highScore = PlayerPrefs.GetInt("HighScore");
UpdateText();
}
void UpdateText()
{
_player1Text.SetText(_player1.ToString());
_player2Text.SetText(_player2.ToString());
_highScoreText.SetText(_highScore.ToString());
}
public static void Add(int points, int playerNumber)
{
_instance.AddPoints(points, playerNumber);
}
void AddPoints(int points, int playerNumber)
{
if (playerNumber == 1)
{
_player1 += points;
if (_player1 >= _highScore)
{
_highScore = _player1;
PlayerPrefs.SetInt("HighScore", _highScore);
}
}
else
{
_player2 += points;
if (_player2 >= _highScore)
{
_highScore = _player2;
PlayerPrefs.SetInt("HighScore", _highScore);
}
}
UpdateText();
}
}
view raw ScoreSystem.cs hosted with ❤ by GitHub
using System;
using UnityEngine;
public class Spawner : MonoBehaviour
{
float _nextSpawnTime;
[SerializeField] float _delay = 2f;
[SerializeField] Transform[] _spawnPoints;
[SerializeField] Enemy[] _enemies;
void Update()
{
if (ShouldSpawn())
Spawn();
}
void Spawn()
{
_nextSpawnTime = Time.time + _delay;
Transform spawnPoint = ChooseSpawnPoint();
Enemy enemy = ChooseEnemy();
Instantiate(enemy, spawnPoint.position, spawnPoint.rotation);
}
Enemy ChooseEnemy()
{
int randomIndex = UnityEngine.Random.Range(0, _enemies.Length);
var enemy = _enemies[randomIndex];
return enemy;
}
Transform ChooseSpawnPoint()
{
int randomIndex = UnityEngine.Random.Range(0, _spawnPoints.Length);
var spawnPoint = _spawnPoints[randomIndex];
return spawnPoint;
}
bool ShouldSpawn()
{
return Time.time >= _nextSpawnTime;
}
}
view raw Spawner.cs hosted with ❤ by GitHub