You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

293 lines
9.5 KiB

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using System.Linq;
  5. /// <summary>
  6. /// Class which defines blocks around the level
  7. /// </summary>
  8. [RequireComponent(typeof(BoxCollider))]
  9. public class Block : MonoBehaviour
  10. {
  11. #region Inspector Fields
  12. [SerializeField]
  13. [Tooltip("Offset from the top of the block from which a character should stand")]
  14. private Vector3 VisualOffset = Vector3.zero;
  15. [SerializeField]
  16. [Tooltip("Can this type of block be walked on")]
  17. public bool is_Walkable = true;
  18. [Tooltip("Is this block underwater?")]
  19. public bool isWater = false;
  20. [Tooltip("Is this block at the bottom of a pit?")]
  21. public bool isPit = false;
  22. public bool isCrystals = false;
  23. public bool isRock = false;
  24. public bool isCollectableSpawnable = false;
  25. [Header("Spawn Settings")]
  26. [Tooltip("Can this block be spawned on")]
  27. public bool isSpawnable = false;
  28. [Tooltip("Direction Player is poting at when spawned")]
  29. public Direction SpawnDirection = Direction.Forward;
  30. #endregion InspectorFields
  31. #region Private Functions
  32. /// <summary>
  33. /// List of current players on this block
  34. /// </summary>
  35. public Character CurrentPlayer { get; protected set; }
  36. private Renderer renderer;
  37. #endregion Private Functions
  38. #region ReadOnly Properties
  39. /// <summary>
  40. /// Blocks position in global space
  41. /// </summary>
  42. public Vector3 position { get { return transform.position; } }
  43. /// <summary>
  44. /// Position character should stand in global space
  45. /// </summary>
  46. public Vector3 VisualPosition { get { return position + VisualOffset + Vector3.up * 0.5f; } }
  47. #endregion ReadOnly Properties
  48. #region Public Functions
  49. /// <summary>
  50. /// Is a block valid to walk on
  51. /// </summary>
  52. /// <param name="layerMask">Layers to check for when checking for blocks above</param>
  53. /// <returns></returns>
  54. public bool isWalkable(LayerMask layerMask)
  55. {
  56. //checks if there is no block above this one and that this is tagged as walkable
  57. return (is_Walkable && !isBlockAtPosition(position + Vector3.up, 1, layerMask));
  58. }
  59. /// <summary>
  60. /// Is called when a player moves onto this block
  61. ///
  62. /// Should be implemented by a derived class
  63. /// </summary>
  64. /// <param name="player">Player which moved on to block</param>
  65. ///<param name="moveDirection">The direction the player moved to get to this block</param>
  66. public virtual IEnumerator OnWalkedOnByPlayer(Character player, Vector3 moveDirection)
  67. {
  68. yield return StartCoroutine(DoPush(player, moveDirection));
  69. }
  70. /// <summary>
  71. /// Is called when a player moves off of block
  72. ///
  73. /// Should be implemented by a derived class
  74. /// </summary>
  75. /// <param name="player">Player which moved on to block</param>
  76. public virtual void OnLeftByPlayer(Character player)
  77. {
  78. CurrentPlayer = null;
  79. }
  80. /// <summary>
  81. /// Called to deal with players colliding on this block
  82. /// </summary>
  83. /// <param name="newPlayer">Player which is moving into this block</param>
  84. /// <param name="moveDirection">The direction the player moved to get to this block</param>
  85. public virtual IEnumerator DoPush(Character newPlayer, Vector3 moveDirection)
  86. {
  87. if (CurrentPlayer == null)
  88. {
  89. CurrentPlayer = newPlayer;
  90. yield break;
  91. }
  92. Block pushBlock = GetPushLocation(moveDirection, ~CurrentPlayer.Ignore);
  93. if (pushBlock != this)
  94. {
  95. Character oldPlayer = CurrentPlayer;
  96. CurrentPlayer = newPlayer;
  97. yield return StartCoroutine(oldPlayer.MoveToBlock(pushBlock, Character.Animation.Hit, 1));
  98. }
  99. else
  100. {
  101. Block returnBlock = GetPushLocation(-moveDirection, ~newPlayer.Ignore);
  102. if (returnBlock != this)
  103. yield return StartCoroutine(newPlayer.MoveToBlock(returnBlock, Character.Animation.Hit, 1));
  104. }
  105. }
  106. public bool isVisible()
  107. {
  108. return isPositionVisible(position);
  109. }
  110. #endregion Public Functions
  111. #region Protected Functions
  112. protected Block GetPushLocation(Vector3 pushDirection, LayerMask ignoreMask)
  113. {
  114. //setting up variables
  115. Vector3 newPosition = position + pushDirection; // position wanted
  116. Block hit; //output of block detection
  117. //if move is obstucted no where to move
  118. if (Block.isBlockAtPosition(newPosition + Vector3.up, 1, ignoreMask))
  119. return this;
  120. return Block.GetOrCreateBlockAtPosition(newPosition, 1, ignoreMask);
  121. }
  122. #endregion Protected Functions
  123. #region Editor Functions
  124. private void OnDrawGizmos()
  125. {
  126. Vector3 DrawPosition = VisualPosition + Vector3.up * 0.4f;
  127. if (isCollectableSpawnable)
  128. {
  129. Vector3 offset = Vector3.zero;
  130. #if UNITY_EDITOR
  131. offset = Vector3.up * Mathf.Sin((float)UnityEditor.EditorApplication.timeSinceStartup * 0.5f) * 0.1f;
  132. #endif
  133. DebugExtensions.DrawCube(DrawPosition + offset, 0.15f, Color.yellow, 0,true);
  134. #if UNITY_EDITOR
  135. var view = UnityEditor.EditorWindow.GetWindow<UnityEditor.SceneView>();
  136. view.Repaint();
  137. #endif
  138. }
  139. if (!isSpawnable)
  140. return;
  141. Vector3 Perp = Quaternion.Euler(0, 90, 0) * SpawnDirection.ToVector();
  142. DebugExtensions.DrawCube(DrawPosition, 0.4f, Color.magenta, 0, true);
  143. //Eyes
  144. Vector3 eyePosition = DrawPosition + SpawnDirection.ToVector() * 0.4f;
  145. DebugExtensions.DrawCube(eyePosition + Perp * 0.2f, 0.1f, Color.magenta, 0, true);
  146. DebugExtensions.DrawCube(eyePosition - Perp * 0.2f, 0.1f, Color.magenta, 0, true);
  147. //ears
  148. Vector3 earPosition = DrawPosition + SpawnDirection.ToVector() * 0.2f + Vector3.up * 0.4f;
  149. Vector3 earScale = Quaternion.LookRotation(SpawnDirection.ToVector()) * new Vector3(0.1f, 0.1f, 0.05f);
  150. DebugExtensions.DrawCube(earPosition + Perp * 0.3f, earScale, Color.magenta, 0, true);
  151. DebugExtensions.DrawCube(earPosition - Perp * 0.3f, earScale, Color.magenta, 0, true);
  152. }
  153. #endregion Editor Functions
  154. #region Static Functions
  155. /// <summary>
  156. /// Checks if there is a block at supplied position
  157. /// </summary>
  158. /// <param name="position">position to check at</param>
  159. /// <param name="Scale">Scale of block. (should be 1)</param>
  160. /// <param name="layerMask">Layers to check on</param>
  161. /// <param name="hit">Block hit</param>
  162. /// <returns>if a block is at position</returns>
  163. public static bool isBlockAtPosition(Vector3 position, float Scale, LayerMask layerMask, out Block hit)
  164. {
  165. //Turn scale into halfextent and shrink a bit so it doesn't hit bordering blocks
  166. Vector3 halfExtent = Vector3.one * ((Scale - 0.1f) / 2);
  167. //Get every collider which is at position
  168. Collider[] cols = Physics.OverlapBox(position, halfExtent, Quaternion.identity, layerMask);
  169. //Filter colliders for only GameObjects with an Block component
  170. Block[] blocks = cols.Where(p => p.GetComponent<Block>() != null).Select(p => p.GetComponent<Block>()).ToArray();
  171. //Draw cube, for visuals
  172. DebugExtensions.DrawCube(position, halfExtent, Color.cyan, 1, false);
  173. //if didn't hit anyblocks return false
  174. if (blocks.Length == 0)
  175. {
  176. hit = null;
  177. return false;
  178. }
  179. else
  180. {
  181. //else get the closest block to disered position, (in case we hit mulitple blocks)
  182. hit = Utility.minBy(blocks, p => Vector3.Distance(p.transform.position, position));
  183. return true;
  184. }
  185. }
  186. /// <summary>
  187. /// Checks if there is a block at supplied position
  188. /// </summary>
  189. /// <param name="position">position to check at</param>
  190. /// <param name="Scale">Scale of block. (should be 1)</param>
  191. /// <param name="layerMask">Layers to check on</param>
  192. /// <returns>if a block is at position</returns>
  193. public static bool isBlockAtPosition(Vector3 position, float scale, LayerMask layerMask)
  194. {
  195. //Return Overloaded function above
  196. Block hit;
  197. return (isBlockAtPosition(position, scale, layerMask, out hit));
  198. }
  199. /// <summary>
  200. /// Gets the block at a position or creates an airblock if there isn't one there
  201. /// </summary>
  202. /// <param name="position">position to get block at</param>
  203. /// <param name="Scale">Scale of block. (should be 1)</param>
  204. /// <param name="layerMask">Layers to check on</param>
  205. /// <returns>block at position</returns>
  206. public static Block GetOrCreateBlockAtPosition(Vector3 position, float Scale, LayerMask layerMask)
  207. {
  208. Block retVal;
  209. if (isBlockAtPosition(position, Scale, layerMask, out retVal))
  210. return retVal;
  211. GameObject airBlock = Resources.Load<GameObject>("Cube_Air");
  212. Debug.Log(airBlock, airBlock);
  213. GameObject newBlock = Instantiate(airBlock);
  214. newBlock.name = "AIR_BLOCK";
  215. Debug.Log(newBlock, newBlock);
  216. newBlock.transform.position = position;
  217. return newBlock.GetComponent<Air>();
  218. }
  219. public static bool isPositionVisible(Vector3 position)
  220. {
  221. Camera camera = Camera.main;
  222. Vector2 screenPos = camera.WorldToViewportPoint(position);
  223. if (screenPos.x > 1 || screenPos.x < 0)
  224. {
  225. return false;
  226. }
  227. if (screenPos.y > 1 || screenPos.y < 0)
  228. {
  229. return false;
  230. }
  231. return true;
  232. }
  233. #endregion
  234. }