auto

Samples~/Bomberman/Scripts/Block.cs

@@ -0,0 +1,25 @@
+using UnityEngine;
+using Netick;
+using Netick.Unity;
+
+namespace Netick.Samples.Bomberman
+{
+    public class Block : NetworkBehaviour
+    {
+        // Networked properties
+        [Networked]
+        public bool Visible { get; set; } = true;
+
+        [OnChanged(nameof(Visible))]
+        private void OnVisibleChanged(OnChangedData onChangedData)
+        {
+            // for visual components, don't use "enabled" property when you want to disable/enable it, instead use SetEnabled().
+            // -- GetComponent<Renderer>().enabled = Visible; #### Not like this.
+
+            GetComponent<Renderer>().SetEnabled(Sandbox, Visible); // #### Like this.
+
+            GetComponent<BoxCollider>().enabled = Visible;
+        }
+    }
+}
+

Samples~/Bomberman/Scripts/Block.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a9a2540dae5c3e2479c6e165f43a834d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/Bomberman/Scripts/Bomb.cs

@@ -0,0 +1,87 @@
+using UnityEngine;
+using Netick;
+using Netick.Unity;
+
+namespace Netick.Samples.Bomberman
+{
+
+	public class Bomb : NetworkBehaviour
+	{
+		public GameObject		   ExplosionPrefab;
+
+		public BombermanController Bomber;
+		public float			   ExplosionDelay = 3.0f;
+
+		private readonly Vector3[] _directionsAroundBomb = new Vector3[4] { Vector3.right, Vector3.left, Vector3.up, Vector3.down };
+
+		public override void NetworkStart()
+		{
+			Bomber?.SpawnedBombs.Add(this);
+		}
+
+		public override void NetworkDestroy()
+		{
+			Bomber?.SpawnedBombs.Remove(this);
+
+			// spawn explosion
+			if (ExplosionPrefab != null)
+				Instantiate(ExplosionPrefab, transform.position, Quaternion.identity);
+		}
+
+		public override void NetworkReset()
+		{
+			GetComponent<Renderer>().enabled = true;
+		}
+
+		public override void NetworkFixedUpdate()
+		{
+			if (Sandbox.TickToTime(Sandbox.Tick - Object.SpawnTick) >= ExplosionDelay)
+				Explode();
+		}
+
+		private void Explode()
+		{
+			// hide bomb after delay
+			GetComponent<Renderer>().enabled = false;
+
+			// dealing damage is done on the server only
+			if (IsServer)
+				DamageTargetsAroundBomb(transform.position);
+
+			// only the server can destroy the bomb or the client but only when the Id of the bomb is -1, meaning it was a spawn-predicted but never was confirmed by the server
+			if (IsServer || Id == -1)
+				Sandbox.Destroy(Object);
+		}
+
+		
+		private void DamageTargetsAroundBomb(Vector3 pos)
+		{
+			// Find all objects around the bomb position
+			// Note: Causes GC
+            foreach (var dir in _directionsAroundBomb)
+            {
+				var hits = Physics.RaycastAll(pos, dir, 1f);
+
+				foreach (var hit in hits)
+					Damage(hit.collider.gameObject);
+			}
+		}
+
+		private void Damage(GameObject target)
+		{
+			var obj    = target.GetComponent<NetworkObject>();
+			var block  = target.GetComponent<Block>();
+			var bomber = target.GetComponent<BombermanController>();
+
+			// make sure the object is not null and in the same sandbox as the bomb
+			if (obj == null || obj.Sandbox != Sandbox)
+				return;
+
+			if (block != null)
+				block.Visible = false;
+
+			if (bomber != null)
+				bomber.Die();
+		}
+	}
+}

Samples~/Bomberman/Scripts/Bomb.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 205eff2d73df3c14882a59d0377eebb7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 10
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/Bomberman/Scripts/BombermanController.cs

@@ -0,0 +1,137 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+using Netick;
+using Netick.Unity;
+
+namespace Netick.Samples.Bomberman
+{
+    public class BombermanController : NetworkBehaviour
+    {
+        public List<Bomb>            SpawnedBombs                    = new List<Bomb>();
+        [HideInInspector]
+        public Vector3               SpawnPos;
+        [SerializeField]
+        private float                _speed                          = 6.0f;
+        [SerializeField]
+        private float                _speedBoostMultiplayer          = 2f;
+
+      
+        private GameObject           _bombPrefab;
+        private CharacterController  _CC;
+
+        // Networked properties
+        [Networked]
+        public int                   Score              { get; set; } = 0;
+        [Networked]
+        public bool                  Alive              { get; set; } = true;
+
+        [Networked(relevancy: Relevancy.InputSource)]
+        public int                   MaxBombs           { get; set; } = 1;
+        [Networked(relevancy: Relevancy.InputSource)]
+        public float                 SpeedPowerUpTimer  { get; set; } = 0;
+        [Networked(relevancy: Relevancy.InputSource)]
+        public float                 BombPowerUpTimer   { get; set; } = 0;
+ 
+        void Awake()
+        {
+            // We store the spawn pos so that we use it later during respawn
+            SpawnPos    = transform.position;
+            _CC         = GetComponent<CharacterController>();
+        } 
+
+        public override void NetworkStart()
+        {
+            _bombPrefab = Sandbox.GetPrefab("Bomb");
+        }
+
+        public override void OnInputSourceLeft()
+        {
+            Sandbox.GetComponent<BombermanEventsHandler>().KillPlayer(this);
+            // destroy the player object when its input source (controller player) leaves the game
+            Sandbox.Destroy(Object);
+        }
+
+        public override void NetworkFixedUpdate()
+        {
+            if (!Alive)
+                return;
+
+            if (FetchInput(out BombermanInput input))
+            {
+                if (BombPowerUpTimer > 0)
+                    BombPowerUpTimer -= Sandbox.FixedDeltaTime;
+                else
+                    MaxBombs = 1;
+
+                if (SpeedPowerUpTimer > 0)
+                    SpeedPowerUpTimer -= Sandbox.FixedDeltaTime;
+
+                var hasSpeedBoost  = SpeedPowerUpTimer > 0;
+                var speed          = hasSpeedBoost ? _speed * _speedBoostMultiplayer : _speed;
+
+                _CC.Move(input.Movement * speed * Sandbox.FixedDeltaTime);
+
+                // we make sure the z coord of the pos of the player is always zero
+                transform.position = new Vector3(transform.position.x, transform.position.y, 0f);
+             
+                if (IsServer && input.PlantBomb && SpawnedBombs.Count < MaxBombs)
+                {
+                    // * round the bomb pos so that it snaps to the nearest square.
+                    var bomb = Sandbox.NetworkInstantiate(_bombPrefab, Round(transform.position), Quaternion.identity).GetComponent<Bomb>();
+                    bomb.Bomber = this;
+                }
+            }
+        }
+
+        public void ReceivePowerUp(PowerUpType type, float boostTime)
+        {
+            if (type == PowerUpType.IncreaseBombs)
+            {
+                SpeedPowerUpTimer += boostTime;
+            }
+            else if (type == PowerUpType.Speed)
+            {
+                BombPowerUpTimer  += boostTime;
+                MaxBombs          += 1;
+            }
+        }
+
+        public void Die()
+        {
+            Alive = false;
+            Sandbox.GetComponent<BombermanEventsHandler>().KillPlayer(this);
+        }
+
+        public void Respawn()
+        {
+            Alive = true;
+            Sandbox.GetComponent<BombermanEventsHandler>().RespawnPlayer(this);
+
+            transform.position = SpawnPos;
+
+            SpeedPowerUpTimer  = 0;
+            BombPowerUpTimer   = 0;
+            MaxBombs           = 1;
+        }
+
+        [OnChanged(nameof(Alive))]
+        private void OnAliveChanged(OnChangedData onChangedData)
+        {
+            // Based on state of Alive:
+
+            // * Hide/show player object
+            GetComponentInChildren<Renderer>().SetEnabled(Sandbox,Alive);
+
+            // * Enable/disable the CharacterController
+            _CC.enabled                                = Alive;
+        }
+
+        public Vector3 Round(Vector3 vec)
+        {
+            return new Vector3(Mathf.Round(vec.x), Mathf.Round(vec.y), Mathf.Round(vec.z));
+        }
+
+    }
+}

Samples~/Bomberman/Scripts/BombermanController.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0695901b53a12474ca18412bd5b6ac69
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/Bomberman/Scripts/BombermanEventsHandler.cs

@@ -0,0 +1,191 @@
+using System.Collections.Generic;
+using UnityEngine;
+using Netick;
+using Netick.Unity;
+
+namespace Netick.Samples.Bomberman
+{
+    public class BombermanEventsHandler : NetworkEventsListener
+    {
+       
+        public List<BombermanController>  AlivePlayers   = new List<BombermanController>();
+        public Vector3[]                  SpawnPositions = new Vector3[4]  
+        { 
+            new Vector3(11, 9, 0), 
+            new Vector3(11, 1, 0), 
+            new Vector3(1,  9, 0), 
+            new Vector3(1,  1, 0)
+        };
+
+        private GameObject               _playerPrefab;
+        private Queue<Vector3>           _freePositions = new Queue<Vector3>(4);
+
+        // ******************* Netick Callbacks *******************
+
+        // This is called on the server and the clients when Netick has started.
+        public override void OnStartup(NetworkSandbox sandbox)
+        {
+            _playerPrefab = sandbox.GetPrefab("Bomberman Player");
+            sandbox.InitializePool(sandbox.GetPrefab("Bomb"), 5);
+        }
+
+        // This is called to read inputs.
+        public override void OnInput(NetworkSandbox sandbox)
+        {
+            var input = sandbox.GetInput<BombermanInput>();
+
+            input.Movement   = GetMovementDir();
+            input.PlantBomb |= Input.GetKeyDown(KeyCode.Space);
+            sandbox.SetInput(input);
+        }
+
+        // This is called on the server when a player has connected.
+        public override void OnPlayerConnected(NetworkSandbox sandbox, NetworkPlayer networkPlayer)
+        {
+            var player                 = sandbox.NetworkInstantiate(_playerPrefab, SpawnPositions[Sandbox.ConnectedPlayers.Count], Quaternion.identity, networkPlayer).GetComponent<BombermanController>();
+            networkPlayer.PlayerObject = player.gameObject;
+            AlivePlayers.Add(player);
+        }
+
+        // This is called on the server when a client has disconnected.
+        public override void OnClientDisconnected(NetworkSandbox sandbox, NetworkConnection client, TransportDisconnectReason reason)
+        {
+            _freePositions.Enqueue(((GameObject)client.PlayerObject).GetComponent<BombermanController>().SpawnPos);
+        }
+
+        public override void OnConnectRequest(NetworkSandbox sandbox, NetworkConnectionRequest request)
+        {
+            if (_freePositions.Count < 1)
+                request.Refuse();
+        }
+
+        // This is called on the server and the clients when the scene has been loaded.
+        public override void OnSceneLoaded(NetworkSandbox sandbox)
+        {
+            if (sandbox.IsClient)
+                return;
+
+            _freePositions.Clear();
+
+            for (int i = 0; i < 4; i++)
+                _freePositions.Enqueue(SpawnPositions[i]);
+
+            RestartGame();
+        }
+
+        // *******************  ********************
+
+        public void RestartGame()
+        {
+            DestroyLevel();
+            CreateNewLevel();
+
+            foreach (var player in Sandbox.ConnectedPlayers)
+                ((GameObject)player.PlayerObject).GetComponent<BombermanController>().Respawn();
+        }
+
+        private void DestroyLevel()
+        {
+            var blocks = Sandbox.FindObjectsOfType<Block>();
+            var bombs  = Sandbox.FindObjectsOfType<Bomb>();
+
+            foreach (var block in blocks)
+                Sandbox.Destroy(block.Object);
+            foreach (var bomb in bombs)
+                Sandbox.Destroy(bomb.Object);
+        }
+
+
+        private void CreateNewLevel()
+        {
+            var blockPrefab      = Sandbox.GetPrefab("DestroyableBlock");
+            var powerUpPrefab    = Sandbox.GetPrefab("Power Up");
+            var numberOfBoosters = Random.Range(2, 4+1);
+            var takenPositions   = new List<Vector3>();
+            var maxX             = 11;
+            var maxY             = 9;
+
+            for (int x = 1; x <= maxX; x++)
+            {
+                for (int y = 1; y <= maxY; y++)
+                {
+                    var spawn = Random.value > 0.5f;
+                    var pos   = new Vector3(x, y);
+        
+                    if (spawn && IsValidPos(pos))
+                    {
+                        Sandbox.NetworkInstantiate(blockPrefab, pos, Quaternion.identity);
+                        takenPositions.Add(pos);
+                    }
+                }
+            }
+
+            while (numberOfBoosters > 0)
+            {
+                var randomPos = new Vector3(Random.Range(1, 11+1), Random.Range(1, 9+1), 0);
+                var type      = (Random.value > 0.5f) ? PowerUpType.Speed : PowerUpType.IncreaseBombs;
+
+                if (!takenPositions.Contains(randomPos) && IsValidPos(randomPos))
+                {
+                    var booster  = Sandbox.NetworkInstantiate(powerUpPrefab, randomPos, Quaternion.identity).GetComponent<PowerUp>();
+                    booster.Type = type;
+                    numberOfBoosters--;
+                }
+            }
+        }
+
+        private bool IsValidPos(Vector3 pos)
+        {
+            // if the pos is the position of a static block, we ignore it
+            if ((pos.x >= 2 && pos.x <= 10) && (pos.y >= 2 && pos.y <= 8))
+                if (pos.x % 2 == 0 && pos.y % 2 == 0)
+                    return false;
+
+            // if the pos is near the position of the spawn locations of the players, we ignore it
+            foreach (var loc in SpawnPositions)
+            {
+                if (pos == loc)
+                    return false;
+                if (pos == loc + Vector3.up   || pos == loc + Vector3.down)
+                    return false;
+                if (pos == loc + Vector3.left || pos == loc + Vector3.right)
+                    return false;
+            }
+
+            return true;
+        }
+
+        public void KillPlayer(BombermanController bomber)
+        {
+            AlivePlayers.Remove(bomber);
+
+            if (AlivePlayers.Count == 1)
+            {
+                AlivePlayers[0].Score++;
+                RestartGame();
+            }
+
+            else if (AlivePlayers.Count < 1)
+                RestartGame();
+        }
+        public void RespawnPlayer(BombermanController bomber)
+        {
+            if (!AlivePlayers.Contains(bomber))
+                AlivePlayers.Add(bomber);
+        }
+
+        private Vector2 GetMovementDir()
+        {
+            if (Input.GetKey(KeyCode.W))
+                return Vector2.up;
+            else if (Input.GetKey(KeyCode.D))
+                return Vector2.right;
+            else if (Input.GetKey(KeyCode.S))
+                return Vector2.down;
+            else if (Input.GetKey(KeyCode.A))
+                return Vector2.left;
+            else
+                return Vector2.zero;
+        }
+    }
+}

Samples~/Bomberman/Scripts/BombermanEventsHandler.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a132672521c94b04d9660a22f195ad7e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/Bomberman/Scripts/BombermanInput.cs

@@ -0,0 +1,12 @@
+using UnityEngine;
+using Netick;
+using Netick.Unity;
+
+namespace Netick.Samples.Bomberman
+{
+    public struct BombermanInput : INetworkInput
+    {
+        public Vector2     Movement;
+        public NetworkBool PlantBomb;
+    }
+}

Samples~/Bomberman/Scripts/BombermanInput.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1eba0815da5ffc341be9fb61d878ae59
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/Bomberman/Scripts/PowerUp.cs

@@ -0,0 +1,54 @@
+using UnityEngine;
+using Netick;
+using Netick.Unity;
+
+namespace Netick.Samples.Bomberman
+{
+    public enum PowerUpType
+    {
+        Speed,
+        IncreaseBombs
+    }
+
+    public class PowerUp : NetworkBehaviour
+    {
+        public float       PowerUpTime = 35;
+        private Material   _mat;
+
+        // Networked properties
+        [Networked]
+        public PowerUpType Type { get; set; }
+
+        private void Awake()
+        {
+            _mat = GetComponentInChildren<Renderer>().material;
+        }
+
+        private void Update()
+        {
+            if (Type == PowerUpType.IncreaseBombs)
+                _mat.color = GetColor(Color.green);
+            else
+                _mat.color = GetColor(Color.blue);
+        }
+
+        private Color GetColor(Color color)
+        {
+            return Color.Lerp(color, color * 0.5f, Mathf.InverseLerp(-1f, 1f, Mathf.Sin(15f * Time.time)));
+        }
+
+        public void OnTriggerEnter(Collider other)
+        {
+            if (Sandbox == null)
+                return;
+
+            var player = other.gameObject.GetComponent<BombermanController>();
+
+            if (Sandbox.IsServer)
+            {
+                player.ReceivePowerUp(Type, PowerUpTime);
+                Sandbox.Destroy(Object);
+            }
+        }
+    }
+}

Samples~/Bomberman/Scripts/PowerUp.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f52db60e2b6aada409a755973bc842b6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/Bomberman/Scripts/UI.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e81ae9cba80f10c4183a913765574781
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/Bomberman/Scripts/UI/UIServerBroweser.cs

@@ -0,0 +1,49 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using Netick;
+using Netick.Unity;
+public class UIServerBroweser : NetworkEventsListener
+{
+    [SerializeField]
+    private GameObject       _UIServerElementPrefab; 
+    [SerializeField]
+    private Vector3          _startPosition;
+    [SerializeField]
+    private float            _stepSize = 50;
+
+    [SerializeField]
+    private List<GameObject> _servers = new List<GameObject>();
+
+    public void Refresh()
+    {
+        Sandbox?.RefreshMatchList();
+    }
+
+    public override void OnStartup(NetworkSandbox sandbox)
+    {
+        if (sandbox.IsServer)
+            Destroy(gameObject);
+    }
+
+    public override void OnConnectedToServer(NetworkSandbox sandbox, NetworkConnection server)
+    {
+        Destroy(gameObject);
+    }
+
+    public override void OnMatchListUpdate(NetworkSandbox sandbox, List<Session> sessions)
+    {
+        foreach (var server in _servers)
+            Destroy(server);
+
+        _servers.Clear();
+
+        for (int i = 0; i < sessions.Count; i++)
+        {
+            var session = sessions[i];
+            var newElement = Instantiate(_UIServerElementPrefab, gameObject.transform).GetComponent<UIServerElement>();
+            newElement.Init(Sandbox,session.Name, session.IP, session.Port, _startPosition - (Vector3.up * i * _stepSize));
+            _servers.Add(newElement.gameObject);
+        }
+    }
+}

Samples~/Bomberman/Scripts/UI/UIServerBroweser.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f8e8276de5223424c801fbb31d5ccbf9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/Bomberman/Scripts/UI/UIServerElement.cs

@@ -0,0 +1,39 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+using Netick;
+using Netick.Unity;
+
+public class UIServerElement : MonoBehaviour
+{
+    [SerializeField]
+    private Text           _nameText;
+
+    [SerializeField]
+    private Text           _ipText;
+
+    [SerializeField]
+    private string         _ip;
+    [SerializeField]
+    private int            _Port;
+
+    private NetworkSandbox _sandbox;
+
+    public void Init(NetworkSandbox sandbox, string name, string ip, int port, Vector3 position)
+    {
+        _sandbox       = sandbox;
+
+        _ip            = ip;
+        _Port          = port;
+        _nameText.text = name;
+        _ipText.text   = ip;
+        GetComponent<RectTransform>().anchoredPosition3D = position;
+
+    }
+
+    public void Connect()
+    {
+        _sandbox.Connect(_Port, _ip);
+    }
+}

Samples~/Bomberman/Scripts/UI/UIServerElement.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 742d47201bd4e0e47b3460de2b0f17c4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: