'잡다한것들전부/공식예제' 카테고리의 글 목록

MovingObject, player, enemy

| 잡다한것들전부/공식예제 2015. 2. 22. 16:07

Posted by 히아레인

using UnityEngine;
using System.Collections;

namespace Completed
{
	//The abstract keyword enables you to create classes and class members that are incomplete and must be implemented in a derived class.
	public abstract class MovingObject : MonoBehaviour
	{
		public float moveTime = 0.1f;			//Time it will take object to move, in seconds.
		public LayerMask blockingLayer;			//Layer on which collision will be checked.
	
		private BoxCollider2D boxCollider; 		//The BoxCollider2D component attached to this object.
		private Rigidbody2D rb2D;				//The Rigidbody2D component attached to this object.
		private float inverseMoveTime;			//Used to make movement more efficient.
		
		
		//Protected, virtual functions can be overridden by inheriting classes.
		protected virtual void Start ()
		{
			//Get a component reference to this object's BoxCollider2D
			boxCollider = GetComponent <BoxCollider2D> ();
			
			//Get a component reference to this object's Rigidbody2D
			rb2D = GetComponent <Rigidbody2D> ();
			
			//By storing the reciprocal of the move time we can use it by multiplying instead of dividing, this is more efficient.
			inverseMoveTime = 1f / moveTime;
		}
		
		
		//Move returns true if it is able to move and false if not. 
		//Move takes parameters for x direction, y direction and a RaycastHit2D to check collision.
		protected bool Move (int xDir, int yDir, out RaycastHit2D hit)
		{
			//Store start position to move from, based on objects current transform position.
			Vector2 start = transform.position;
			
			// Calculate end position based on the direction parameters passed in when calling Move.
			Vector2 end = start + new Vector2 (xDir, yDir);
			
			//Disable the boxCollider so that linecast doesn't hit this object's own collider.
			boxCollider.enabled = false;
			
			//Cast a line from start point to end point checking collision on blockingLayer.
			hit = Physics2D.Linecast (start, end, blockingLayer);
			
			//Re-enable boxCollider after linecast
			boxCollider.enabled = true;
			
			//Check if anything was hit
			if(hit.transform == null)
			{
				//If nothing was hit, start SmoothMovement co-routine passing in the Vector2 end as destination
				StartCoroutine (SmoothMovement (end));
				
				//Return true to say that Move was successful
				return true;
			}
			
			//If something was hit, return false, Move was unsuccesful.
			return false;
		}
		
		
		//Co-routine for moving units from one space to next, takes a parameter end to specify where to move to.
		protected IEnumerator SmoothMovement (Vector3 end)
		{
			//Calculate the remaining distance to move based on the square magnitude of the difference between current position and end parameter. 
			//Square magnitude is used instead of magnitude because it's computationally cheaper.
			float sqrRemainingDistance = (transform.position - end).sqrMagnitude;
			
			//While that distance is greater than a very small amount (Epsilon, almost zero):
			while(sqrRemainingDistance > float.Epsilon)
			{
				//Find a new position proportionally closer to the end, based on the moveTime
				Vector3 newPostion = Vector3.MoveTowards(rb2D.position, end, inverseMoveTime * Time.deltaTime);

Debug.Log(newPostion);
				//Call MovePosition on attached Rigidbody2D and move it to the calculated position.
				rb2D.MovePosition (newPostion);
				
				//Recalculate the remaining distance after moving.
				sqrRemainingDistance = (transform.position - end).sqrMagnitude;
				
				//Return and loop until sqrRemainingDistance is close enough to zero to end the function
				yield return null;
			}
		}
		
		
		//The virtual keyword means AttemptMove can be overridden by inheriting classes using the override keyword.
		//AttemptMove takes a generic parameter T to specify the type of component we expect our unit to interact with if blocked (Player for Enemies, Wall for Player).
		protected virtual void AttemptMove <T> (int xDir, int yDir)
			where T : Component
		{
			//Hit will store whatever our linecast hits when Move is called.
			RaycastHit2D hit;
			
			//Set canMove to true if Move was successful, false if failed.
			bool canMove = Move (xDir, yDir, out hit);
			
			//Check if nothing was hit by linecast
			if(hit.transform == null)
				//If nothing was hit, return and don't execute further code.
				return;
			
			//Get a component reference to the component of type T attached to the object that was hit
			T hitComponent = hit.transform.GetComponent <T> ();
			
			//If canMove is false and hitComponent is not equal to null, meaning MovingObject is blocked and has hit something it can interact with.
			if(!canMove && hitComponent != null)
				
				//Call the OnCantMove function and pass it hitComponent as a parameter.
				OnCantMove (hitComponent);
		}
		
		
		//The abstract modifier indicates that the thing being modified has a missing or incomplete implementation.
		//OnCantMove will be overriden by functions in the inheriting classes.
		protected abstract void OnCantMove <T> (T component)
			where T : Component;
	}
}

using UnityEngine;
using System.Collections;
using UnityEngine.UI;	//Allows us to use UI.

namespace Completed
{
	//Player inherits from MovingObject, our base class for objects that can move, Enemy also inherits from this.
	public class Player : MovingObject
	{
		public float restartLevelDelay = 1f;		//Delay time in seconds to restart level.
		public int pointsPerFood = 10;				//Number of points to add to player food points when picking up a food object.
		public int pointsPerSoda = 20;				//Number of points to add to player food points when picking up a soda object.
		public int wallDamage = 1;					//How much damage a player does to a wall when chopping it.
		public Text foodText;						//UI Text to display current player food total.
		public AudioClip moveSound1;				//1 of 2 Audio clips to play when player moves.
		public AudioClip moveSound2;				//2 of 2 Audio clips to play when player moves.
		public AudioClip eatSound1;					//1 of 2 Audio clips to play when player collects a food object.
		public AudioClip eatSound2;					//2 of 2 Audio clips to play when player collects a food object.
		public AudioClip drinkSound1;				//1 of 2 Audio clips to play when player collects a soda object.
		public AudioClip drinkSound2;				//2 of 2 Audio clips to play when player collects a soda object.
		public AudioClip gameOverSound;				//Audio clip to play when player dies.
		
		private Animator animator;					//Used to store a reference to the Player's animator component.
		private int food;							//Used to store player food points total during level.
		private Vector2 touchOrigin = -Vector2.one;	//Used to store location of screen touch origin for mobile controls.
		
		
		//Start overrides the Start function of MovingObject
		protected override void Start ()
		{
			//Get a component reference to the Player's animator component
			animator = GetComponent<Animator>();
			
			//Get the current food point total stored in GameManager.instance between levels.
			food = GameManager.instance.playerFoodPoints;
			
			//Set the foodText to reflect the current player food total.
			foodText.text = "Food: " + food;
			
			//Call the Start function of the MovingObject base class.
			base.Start ();
		}
		
		
		//This function is called when the behaviour becomes disabled or inactive.
		private void OnDisable ()
		{
			//When Player object is disabled, store the current local food total in the GameManager so it can be re-loaded in next level.
			GameManager.instance.playerFoodPoints = food;
		}
		
		
		private void Update ()
		{
			//If it's not the player's turn, exit the function.
			if(!GameManager.instance.playersTurn) return;
			
			int horizontal = 0;  	//Used to store the horizontal move direction.
			int vertical = 0;		//Used to store the vertical move direction.
			
			//Check if we are running either in the Unity editor or in a standalone build.
			#if UNITY_STANDALONE || UNITY_WEBPLAYER
			
			//Get input from the input manager, round it to an integer and store in horizontal to set x axis move direction
			horizontal = (int) (Input.GetAxisRaw ("Horizontal"));
			
			//Get input from the input manager, round it to an integer and store in vertical to set y axis move direction
			vertical = (int) (Input.GetAxisRaw ("Vertical"));
			
			//Check if moving horizontally, if so set vertical to zero.
			if(horizontal != 0)
			{
				vertical = 0;
			}
			//Check if we are running on iOS, Android, Windows Phone 8 or Unity iPhone
			#elif UNITY_IOS || UNITY_ANDROID || UNITY_WP8 || UNITY_IPHONE
			
			//Check if Input has registered more than zero touches
			if (Input.touchCount > 0)
			{
				//Store the first touch detected.
				Touch myTouch = Input.touches[0];
				
				//Check if the phase of that touch equals Began
				if (myTouch.phase == TouchPhase.Began)
				{
					//If so, set touchOrigin to the position of that touch
					touchOrigin = myTouch.position;
				}
				
				//If the touch phase is not Began, and instead is equal to Ended and the x of touchOrigin is greater or equal to zero:
				else if (myTouch.phase == TouchPhase.Ended && touchOrigin.x >= 0)
				{
					//Set touchEnd to equal the position of this touch
					Vector2 touchEnd = myTouch.position;
					
					//Calculate the difference between the beginning and end of the touch on the x axis.
					float x = touchEnd.x - touchOrigin.x;
					
					//Calculate the difference between the beginning and end of the touch on the y axis.
					float y = touchEnd.y - touchOrigin.y;
					
					//Set touchOrigin.x to -1 so that our else if statement will evaluate false and not repeat immediately.
					touchOrigin.x = -1;
					
					//Check if the difference along the x axis is greater than the difference along the y axis.
					if (Mathf.Abs(x) > Mathf.Abs(y))
						//If x is greater than zero, set horizontal to 1, otherwise set it to -1
						horizontal = x > 0 ? 1 : -1;
					else
						//If y is greater than zero, set horizontal to 1, otherwise set it to -1
						vertical = y > 0 ? 1 : -1;
				}
			}
			
			#endif //End of mobile platform dependendent compilation section started above with #elif
			//Check if we have a non-zero value for horizontal or vertical
			if(horizontal != 0 || vertical != 0)
			{
				//Call AttemptMove passing in the generic parameter Wall, since that is what Player may interact with if they encounter one (by attacking it)
				//Pass in horizontal and vertical as parameters to specify the direction to move Player in.
				AttemptMove<Wall> (horizontal, vertical);
			}
		}
		
		// 캐릭터 이동시 처음으로 무조건 실행. -> 상위 메서드 호출.
		//AttemptMove overrides the AttemptMove function in the base class MovingObject
		//AttemptMove takes a generic parameter T which for Player will be of the type Wall, it also takes integers for x and y direction to move in.
		protected override void AttemptMove <T> (int xDir, int yDir)
		{
			//Every time player moves, subtract from food points total.
			food--;
			
			//Update food text display to reflect current score.
			foodText.text = "Food: " + food;
			
			//Call the AttemptMove method of the base class, passing in the component T (in this case Wall) and x and y direction to move.
			base.AttemptMove <T> (xDir, yDir);
			
			//Hit allows us to reference the result of the Linecast done in Move.
			RaycastHit2D hit;
			
			//If Move returns true, meaning Player was able to move into an empty space.
			if (Move (xDir, yDir, out hit)) 
			{
				//Call RandomizeSfx of SoundManager to play the move sound, passing in two audio clips to choose from.
				SoundManager.instance.RandomizeSfx (moveSound1, moveSound2);
			}
			
			//Since the player has moved and lost food points, check if the game has ended.
			CheckIfGameOver ();
			
			//Set the playersTurn boolean of GameManager to false now that players turn is over.
			GameManager.instance.playersTurn = false;
		}
		
		
		//OnCantMove overrides the abstract function OnCantMove in MovingObject.
		//It takes a generic parameter T which in the case of Player is a Wall which the player can attack and destroy.
		protected override void OnCantMove <T> (T component)
		{
			//Set hitWall to equal the component passed in as a parameter.
			Wall hitWall = component as Wall;
			
			//Call the DamageWall function of the Wall we are hitting.
			hitWall.DamageWall (wallDamage);
			
			//Set the attack trigger of the player's animation controller in order to play the player's attack animation.
			animator.SetTrigger ("playerChop");
		}
		
		
		//OnTriggerEnter2D is sent when another object enters a trigger collider attached to this object (2D physics only).
		private void OnTriggerEnter2D (Collider2D other)
		{
			//Check if the tag of the trigger collided with is Exit.
			if(other.tag == "Exit")
			{
				//Invoke the Restart function to start the next level with a delay of restartLevelDelay (default 1 second).
				Invoke ("Restart", restartLevelDelay);
				
				//Disable the player object since level is over.
				enabled = false;
			}
			
			//Check if the tag of the trigger collided with is Food.
			else if(other.tag == "Food")
			{
				//Add pointsPerFood to the players current food total.
				food += pointsPerFood;
				
				//Update foodText to represent current total and notify player that they gained points
				foodText.text = "+" + pointsPerFood + " Food: " + food;
				
				//Call the RandomizeSfx function of SoundManager and pass in two eating sounds to choose between to play the eating sound effect.
				SoundManager.instance.RandomizeSfx (eatSound1, eatSound2);
				
				//Disable the food object the player collided with.
				other.gameObject.SetActive (false);
			}
			
			//Check if the tag of the trigger collided with is Soda.
			else if(other.tag == "Soda")
			{
				//Add pointsPerSoda to players food points total
				food += pointsPerSoda;
				
				//Update foodText to represent current total and notify player that they gained points
				foodText.text = "+" + pointsPerSoda + " Food: " + food;
				
				//Call the RandomizeSfx function of SoundManager and pass in two drinking sounds to choose between to play the drinking sound effect.
				SoundManager.instance.RandomizeSfx (drinkSound1, drinkSound2);
				
				//Disable the soda object the player collided with.
				other.gameObject.SetActive (false);
			}
		}
		
		
		//Restart reloads the scene when called.
		private void Restart ()
		{
			//Load the last scene loaded, in this case Main, the only scene in the game.
			Application.LoadLevel (Application.loadedLevel);
		}
		
		
		//LoseFood is called when an enemy attacks the player.
		//It takes a parameter loss which specifies how many points to lose.
		public void LoseFood (int loss)
		{
			//Set the trigger for the player animator to transition to the playerHit animation.
			animator.SetTrigger ("playerHit");
			
			//Subtract lost food points from the players total.
			food -= loss;
			
			//Update the food display with the new total.
			foodText.text = "-"+ loss + " Food: " + food;
			
			//Check to see if game has ended.
			CheckIfGameOver ();
		}
		
		
		//CheckIfGameOver checks if the player is out of food points and if so, ends the game.
		private void CheckIfGameOver ()
		{
			//Check if food point total is less than or equal to zero.
			if (food <= 0) 
			{
				//Call the PlaySingle function of SoundManager and pass it the gameOverSound as the audio clip to play.
				SoundManager.instance.PlaySingle (gameOverSound);
				
				//Stop the background music.
				SoundManager.instance.musicSource.Stop();
				
				//Call the GameOver function of GameManager.
				GameManager.instance.GameOver ();
			}
		}
	}
}

using UnityEngine;
using System.Collections;

namespace Completed
{
	//Enemy inherits from MovingObject, our base class for objects that can move, Player also inherits from this.
	public class Enemy : MovingObject
	{
		public int playerDamage; 							//The amount of food points to subtract from the player when attacking.
		public AudioClip attackSound1;						//First of two audio clips to play when attacking the player.
		public AudioClip attackSound2;						//Second of two audio clips to play when attacking the player.
		
		
		private Animator animator;							//Variable of type Animator to store a reference to the enemy's Animator component.
		private Transform target;							//Transform to attempt to move toward each turn.
		private bool skipMove;								//Boolean to determine whether or not enemy should skip a turn or move this turn.
		
		
		//Start overrides the virtual Start function of the base class.
		protected override void Start ()
		{
			//Register this enemy with our instance of GameManager by adding it to a list of Enemy objects. 
			//This allows the GameManager to issue movement commands.
			GameManager.instance.AddEnemyToList (this);
			
			//Get and store a reference to the attached Animator component.
			animator = GetComponent<Animator> ();
			
			//Find the Player GameObject using it's tag and store a reference to its transform component.
			target = GameObject.FindGameObjectWithTag ("Player").transform;
			
			//Call the start function of our base class MovingObject.
			base.Start ();
		}
		
		
		//Override the AttemptMove function of MovingObject to include functionality needed for Enemy to skip turns.
		//See comments in MovingObject for more on how base AttemptMove function works.
		protected override void AttemptMove <T> (int xDir, int yDir)
		{
			//Check if skipMove is true, if so set it to false and skip this turn.
			if(skipMove)
			{
				skipMove = false;
				return;
				
			}
			
			//Call the AttemptMove function from MovingObject.
			base.AttemptMove <T> (xDir, yDir);
			
			//Now that Enemy has moved, set skipMove to true to skip next move.
			skipMove = true;
		}
		
		
		//MoveEnemy is called by the GameManger each turn to tell each Enemy to try to move towards the player.
		public void MoveEnemy ()
		{
			//Declare variables for X and Y axis move directions, these range from -1 to 1.
			//These values allow us to choose between the cardinal directions: up, down, left and right.
			int xDir = 0;
			int yDir = 0;
			
			//If the difference in positions is approximately zero (Epsilon) do the following:
			if(Mathf.Abs (target.position.x - transform.position.x) < float.Epsilon)
				
				//If the y coordinate of the target's (player) position is greater than the y coordinate of this enemy's position set y direction 1 (to move up). If not, set it to -1 (to move down).
				yDir = target.position.y > transform.position.y ? 1 : -1;
			
			//If the difference in positions is not approximately zero (Epsilon) do the following:
			else
				//Check if target x position is greater than enemy's x position, if so set x direction to 1 (move right), if not set to -1 (move left).
				xDir = target.position.x > transform.position.x ? 1 : -1;
			
			//Call the AttemptMove function and pass in the generic parameter Player, because Enemy is moving and expecting to potentially encounter a Player
			AttemptMove <Player> (xDir, yDir);
		}
		
		
		//OnCantMove is called if Enemy attempts to move into a space occupied by a Player, it overrides the OnCantMove function of MovingObject 
		//and takes a generic parameter T which we use to pass in the component we expect to encounter, in this case Player
		protected override void OnCantMove <T> (T component)
		{
			//Declare hitPlayer and set it to equal the encountered component.
			Player hitPlayer = component as Player;
			
			//Call the LoseFood function of hitPlayer passing it playerDamage, the amount of foodpoints to be subtracted.
			hitPlayer.LoseFood (playerDamage);
			
			//Set the attack trigger of animator to trigger Enemy attack animation.
			animator.SetTrigger ("enemyAttack");
			
			//Call the RandomizeSfx function of SoundManager passing in the two audio clips to choose randomly between.
			SoundManager.instance.RandomizeSfx (attackSound1, attackSound2);
		}
	}
}

저작자표시

'잡다한것들전부 > 공식예제' 카테고리의 다른 글

MovingObject, player, enemy (0)	2015.02.22
맵 생성 스크립트 - BoardManager (0)	2015.02.22
배경 생성 관련 스크립트 - BackgroundPropSpawner (0)	2014.02.25
몬스터 관련 함수 - Enemy 스크립트 (0)	2014.02.25
점수 표현 - Score (0)	2014.02.25
폭탄과 구급 상자 - Bomb Pickup, Bomb (0)	2014.02.25

Trackback 0 And Comment 0

맵 생성 스크립트 - BoardManager

| 잡다한것들전부/공식예제 2015. 2. 22. 16:03

Posted by 히아레인

using UnityEngine;
using System;
using System.Collections.Generic; 		//Allows us to use Lists.
using Random = UnityEngine.Random; 		//Tells Random to use the Unity Engine random number generator.

namespace Completed	
{
	public class BoardManager : MonoBehaviour
	{
		// Using Serializable allows us to embed a class with sub properties in the inspector.
		[Serializable]
		public class Count
		{
			public int minimum; 			//Minimum value for our Count class.
			public int maximum; 			//Maximum value for our Count class.
					
			//Assignment constructor.
			public Count (int min, int max)
			{
				minimum = min;
				maximum = max;
			}
		}
		
		public int columns = 8; 										//Number of columns in our game board.
		public int rows = 8;											//Number of rows in our game board.
		public Count wallCount = new Count (5, 9);						//Lower and upper limit for our random number of walls per level.
		public Count foodCount = new Count (1, 5);						//Lower and upper limit for our random number of food items per level.
		public GameObject exit;											//Prefab to spawn for exit.
		public GameObject[] floorTiles;									//Array of floor prefabs.
		public GameObject[] wallTiles;									//Array of wall prefabs.
		public GameObject[] foodTiles;									//Array of food prefabs.
		public GameObject[] enemyTiles;									//Array of enemy prefabs.
		public GameObject[] outerWallTiles;								//Array of outer tile prefabs.
		
		private Transform boardHolder;									//A variable to store a reference to the transform of our Board object.
		private List <Vector3> gridPositions = new List <Vector3> ();	//A list of possible locations to place tiles.
		
		
		//Clears our list gridPositions and prepares it to generate a new board.
		void InitialiseList ()
		{
			//Clear our list gridPositions.
			gridPositions.Clear ();
			
			//Loop through x axis (columns).
			for(int x = 1; x < columns-1; x++)
			{
				//Within each column, loop through y axis (rows).
				for(int y = 1; y < rows-1; y++)
				{
					//At each index add a new Vector3 to our list with the x and y coordinates of that position.
					gridPositions.Add (new Vector3(x, y, 0f));
				}
			}
		}
		
		
		//Sets up the outer walls and floor (background) of the game board.
		void BoardSetup ()
		{
			//Instantiate Board and set boardHolder to its transform.
			boardHolder = new GameObject ("Board").transform;
			
			//Loop along x axis, starting from -1 (to fill corner) with floor or outerwall edge tiles.
			for(int x = -1; x < columns + 1; x++)
			{
				//Loop along y axis, starting from -1 to place floor or outerwall tiles.
				for(int y = -1; y < rows + 1; y++)
				{
					//Choose a random tile from our array of floor tile prefabs and prepare to instantiate it.
					GameObject toInstantiate = floorTiles[Random.Range (0,floorTiles.Length)];
					
					//Check if we current position is at board edge, if so choose a random outer wall prefab from our array of outer wall tiles.
					if(x == -1 || x == columns || y == -1 || y == rows)
						toInstantiate = outerWallTiles [Random.Range (0, outerWallTiles.Length)];
					
					//Instantiate the GameObject instance using the prefab chosen for toInstantiate at the Vector3 corresponding to current grid position in loop, cast it to GameObject.
					GameObject instance =
						Instantiate (toInstantiate, new Vector3 (x, y, 0f), Quaternion.identity) as GameObject;
					
					//Set the parent of our newly instantiated object instance to boardHolder, this is just organizational to avoid cluttering hierarchy.
					instance.transform.SetParent (boardHolder);
				}
			}
		}
		
		
		//RandomPosition returns a random position from our list gridPositions.
		Vector3 RandomPosition ()
		{
			//Declare an integer randomIndex, set it's value to a random number between 0 and the count of items in our List gridPositions.
			int randomIndex = Random.Range (0, gridPositions.Count);
			
			//Declare a variable of type Vector3 called randomPosition, set it's value to the entry at randomIndex from our List gridPositions.
			Vector3 randomPosition = gridPositions[randomIndex];
			
			//Remove the entry at randomIndex from the list so that it can't be re-used.
			gridPositions.RemoveAt (randomIndex);
			
			//Return the randomly selected Vector3 position.
			return randomPosition;
		}
		
		
		//LayoutObjectAtRandom accepts an array of game objects to choose from along with a minimum and maximum range for the number of objects to create.
		void LayoutObjectAtRandom (GameObject[] tileArray, int minimum, int maximum)
		{
			//Choose a random number of objects to instantiate within the minimum and maximum limits
			int objectCount = Random.Range (minimum, maximum+1);
			
			//Instantiate objects until the randomly chosen limit objectCount is reached
			for(int i = 0; i < objectCount; i++)
			{
				//Choose a position for randomPosition by getting a random position from our list of available Vector3s stored in gridPosition
				Vector3 randomPosition = RandomPosition();
				
				//Choose a random tile from tileArray and assign it to tileChoice
				GameObject tileChoice = tileArray[Random.Range (0, tileArray.Length)];
				
				//Instantiate tileChoice at the position returned by RandomPosition with no change in rotation
				Instantiate(tileChoice, randomPosition, Quaternion.identity);
			}
		}
		
		
		//SetupScene initializes our level and calls the previous functions to lay out the game board
		public void SetupScene (int level)
		{
			//Creates the outer walls and floor.
			BoardSetup ();
			
			//Reset our list of gridpositions.
			InitialiseList ();
			
			//Instantiate a random number of wall tiles based on minimum and maximum, at randomized positions.
			LayoutObjectAtRandom (wallTiles, wallCount.minimum, wallCount.maximum);
			
			//Instantiate a random number of food tiles based on minimum and maximum, at randomized positions.
			LayoutObjectAtRandom (foodTiles, foodCount.minimum, foodCount.maximum);
			
			//Determine number of enemies based on current level number, based on a logarithmic progression
			int enemyCount = (int)Mathf.Log(level, 2f);
			
			//Instantiate a random number of enemies based on minimum and maximum, at randomized positions.
			LayoutObjectAtRandom (enemyTiles, enemyCount, enemyCount);
			
			//Instantiate the exit tile in the upper right hand corner of our game board
			Instantiate (exit, new Vector3 (columns - 1, rows - 1, 0f), Quaternion.identity);
		}
	}
}

Loader 에서 GameManager 프리팹 생성. GameManger 프리팹에 BoardManager 존재.

BoardManager에는 해당되는 프리팹들 모두 연결됨.

- Floor

- Food

- Enemy

- OuterWall

여기 있는 프리팹 배열 중에 랜덤으로 뿌려줌.

gridPositions List 에 x = 1~columns-1

y = 1 ~ rows-1

까지의 위치값들을 전부 저장하고. 랜덤으로 위치값을 지정해줄때. 리스트에 있는 값들을 하나하나 뽑아서 사용함.

RemoveAt을 사용해서 뽑았던 값들은 다시 나오지 않도록 제거함.

Enemy 의 수는 Mathf.Log 함수를 사용해서 레벨이 올라가면 적의 숫자를 올라가도록 설정했음..

저작자표시

'잡다한것들전부 > 공식예제' 카테고리의 다른 글

MovingObject, player, enemy (0)	2015.02.22
맵 생성 스크립트 - BoardManager (0)	2015.02.22
배경 생성 관련 스크립트 - BackgroundPropSpawner (0)	2014.02.25
몬스터 관련 함수 - Enemy 스크립트 (0)	2014.02.25
점수 표현 - Score (0)	2014.02.25
폭탄과 구급 상자 - Bomb Pickup, Bomb (0)	2014.02.25

Roguelike

Trackback 0 And Comment 0

배경 생성 관련 스크립트 - BackgroundPropSpawner

| 잡다한것들전부/공식예제 2014. 2. 25. 18:40

Posted by 히아레인

using UnityEngine;
using System.Collections;

public class BackgroundPropSpawner : MonoBehaviour
{
	public Rigidbody2D backgroundProp;		// The prop to be instantiated.
	public float leftSpawnPosX;				// The x coordinate of position if it's instantiated on the left.
	public float rightSpawnPosX;			// The x coordinate of position if it's instantiated on the right.
	public float minSpawnPosY;				// The lowest possible y coordinate of position.
	public float maxSpawnPosY;				// The highest possible y coordinate of position.
	public float minTimeBetweenSpawns;		// The shortest possible time between spawns.
	public float maxTimeBetweenSpawns;		// The longest possible time between spawns.
	public float minSpeed;					// The lowest possible speed of the prop.
	public float maxSpeed;					// The highest possible speeed of the prop.

void Start ()
	{
		// Set the random seed so it's not the same each game.
		Random.seed = System.DateTime.Today.Millisecond;

// Start the Spawn coroutine.
		StartCoroutine("Spawn");
	}

IEnumerator Spawn ()
	{
		// Create a random wait time before the prop is instantiated.
		float waitTime = Random.Range(minTimeBetweenSpawns, maxTimeBetweenSpawns);

// Wait for the designated period.
		yield return new WaitForSeconds(waitTime);

// Randomly decide whether the prop should face left or right.
		bool facingLeft = Random.Range(0,2) == 0;

// If the prop is facing left, it should start on the right hand side, otherwise it should start on the left.
		float posX = facingLeft ? rightSpawnPosX : leftSpawnPosX;

// Create a random y coordinate for the prop.
		float posY = Random.Range(minSpawnPosY, maxSpawnPosY);

// Set the position the prop should spawn at.
		Vector3 spawnPos = new Vector3(posX, posY, transform.position.z);

// Instantiate the prop at the desired position.
		Rigidbody2D propInstance = Instantiate(backgroundProp, spawnPos, Quaternion.identity) as Rigidbody2D;

// The sprites for the props all face left.  Therefore, if the prop should be facing right...
		if(!facingLeft)
		{
			// ... flip the scale in the x axis.
			Vector3 scale = propInstance.transform.localScale;
			scale.x *= -1;
			propInstance.transform.localScale = scale;
		}

// Create a random speed.
		float speed = Random.Range(minSpeed, maxSpeed);

// These speeds would naturally move the prop right, so if it's facing left, multiply the speed by -1.
		speed *= facingLeft ? -1f : 1f;

// Set the prop's velocity to this speed in the x axis.
		propInstance.velocity = new Vector2(speed, 0);

// Restart the coroutine to spawn another prop.
		StartCoroutine(Spawn());

// While the prop exists...
		while(propInstance != null)
		{
			// ... and if it's facing left...
			if(facingLeft)
			{
				// ... and if it's beyond the left spawn position...
				if(propInstance.transform.position.x < leftSpawnPosX - 0.5f)
					// ... destroy the prop.
					Destroy(propInstance.gameObject);
			}
			else
			{
				// Otherwise, if the prop is facing right and it's beyond the right spawn position...
				if(propInstance.transform.position.x > rightSpawnPosX + 0.5f)
					// ... destroy the prop.
					Destroy(propInstance.gameObject);
			}

// Return to this point after the next update.
			yield return null;
		}
	}
}

backgroundProp -> 이 변수에 각각 버스, 백조, 택시등을 넣어줄수있음

코루틴으로 Spawn() 함수를 계속 호출함

waitTime -> 다음 프리팹이 생성될 시간 랜덤값(최소시간 ~ 최대시간)

facingLeft->오른쪽에서 나올지 왼쪽에서 나올지

와; 코루틴을 사용해서 while문 돌려주고 그 안에서 propInstance 의 값을 체크해서 범위를 넘으면 삭제..

대박;

결국엔 Destroy 하면 해당 while문은 null이 되고 코루틴을 빠져나옴.

저작자표시

'잡다한것들전부 > 공식예제' 카테고리의 다른 글

MovingObject, player, enemy (0)	2015.02.22
맵 생성 스크립트 - BoardManager (0)	2015.02.22
배경 생성 관련 스크립트 - BackgroundPropSpawner (0)	2014.02.25
몬스터 관련 함수 - Enemy 스크립트 (0)	2014.02.25
점수 표현 - Score (0)	2014.02.25
폭탄과 구급 상자 - Bomb Pickup, Bomb (0)	2014.02.25

Trackback 0 And Comment 0

몬스터 관련 함수 - Enemy 스크립트

| 잡다한것들전부/공식예제 2014. 2. 25. 17:54

Posted by 히아레인

벌레와 우주선이 있는데요

벌레는 꼬리부분을 개별적으로 짤라주고 축을 오른족으로 두어서 꼬리의 크기를 늘렸다 줄였다하면서 애니메이션을 줄수있습니다.

둘다 Enemy 스크립트를 가지고 있지만 익스펙터에서 값을 조정해서 사용한다.

using UnityEngine;
using System.Collections;

public class Enemy : MonoBehaviour
{
	public float moveSpeed = 2f;		// The speed the enemy moves at.
	public int HP = 2;					// How many times the enemy can be hit before it dies.
	public Sprite deadEnemy;			// A sprite of the enemy when it's dead.
	public Sprite damagedEnemy;			// An optional sprite of the enemy when it's damaged.
	public AudioClip[] deathClips;		// An array of audioclips that can play when the enemy dies.
	public GameObject hundredPointsUI;	// A prefab of 100 that appears when the enemy dies.
	public float deathSpinMin = -100f;			// A value to give the minimum amount of Torque when dying
	public float deathSpinMax = 100f;			// A value to give the maximum amount of Torque when dying

private SpriteRenderer ren;			// Reference to the sprite renderer.
	private Transform frontCheck;		// Reference to the position of the gameobject used for checking if something is in front.
	private bool dead = false;			// Whether or not the enemy is dead.
	private Score score;				// Reference to the Score script.

void Awake()
	{
		// Setting up the references.
		ren = transform.Find("body").GetComponent<SpriteRenderer>();
		frontCheck = transform.Find("frontCheck").transform;
		score = GameObject.Find("Score").GetComponent<Score>();
	}

void FixedUpdate ()
	{
		// Create an array of all the colliders in front of the enemy.
		Collider2D[] frontHits = Physics2D.OverlapPointAll(frontCheck.position, 1);

// Check each of the colliders.
		foreach(Collider2D c in frontHits)
		{
			// If any of the colliders is an Obstacle...
			if(c.tag == "Obstacle")
			{
				// ... Flip the enemy and stop checking the other colliders.
				Flip ();
				break;
			}
		}

// Set the enemy's velocity to moveSpeed in the x direction.
		rigidbody2D.velocity = new Vector2(transform.localScale.x * moveSpeed, rigidbody2D.velocity.y);

// If the enemy has one hit point left and has a damagedEnemy sprite...
		if(HP == 1 && damagedEnemy != null)
			// ... set the sprite renderer's sprite to be the damagedEnemy sprite.
			ren.sprite = damagedEnemy;
			
		// If the enemy has zero or fewer hit points and isn't dead yet...
		if(HP <= 0 && !dead)
			// ... call the death function.
			Death ();
	}
	
	public void Hurt()
	{
		// Reduce the number of hit points by one.
		HP--;
	}
	
	void Death()
	{
		// Find all of the sprite renderers on this object and it's children.
		SpriteRenderer[] otherRenderers = GetComponentsInChildren<SpriteRenderer>();

// Disable all of them sprite renderers.
		foreach(SpriteRenderer s in otherRenderers)
		{
			s.enabled = false;
		}

// Re-enable the main sprite renderer and set it's sprite to the deadEnemy sprite.
		ren.enabled = true;
		ren.sprite = deadEnemy;

// Increase the score by 100 points
		score.score += 100;

// Set dead to true.
		dead = true;

// Allow the enemy to rotate and spin it by adding a torque.
		rigidbody2D.fixedAngle = false;
		rigidbody2D.AddTorque(Random.Range(deathSpinMin,deathSpinMax));

// Find all of the colliders on the gameobject and set them all to be triggers.
		Collider2D[] cols = GetComponents<Collider2D>();
		foreach(Collider2D c in cols)
		{
			c.isTrigger = true;
		}

// Play a random audioclip from the deathClips array.
		int i = Random.Range(0, deathClips.Length);
		AudioSource.PlayClipAtPoint(deathClips[i], transform.position);

// Create a vector that is just above the enemy.
		Vector3 scorePos;
		scorePos = transform.position;
		scorePos.y += 1.5f;

// Instantiate the 100 points prefab at this point.
		Instantiate(hundredPointsUI, scorePos, Quaternion.identity);
	}

public void Flip()
	{
		// Multiply the x component of localScale by -1.
		Vector3 enemyScale = transform.localScale;
		enemyScale.x *= -1;
		transform.localScale = enemyScale;
	}
}

deadEnemy = 죽는 모습 스프라이트

damagedEnemy = 몬스터 공격 당할시 스프라이트

deathClips = 사운드

hundredPointsUI -> 적을 죽이면 100 생성

deathSpinMin -> 죽을때 떨어지는 각도

ren - > 몸통 렌더러

frontCheck -> 바로 앞에 있는 값 체크

Collider2D[] frontHits = Physics2D.OverlapPointAll(frontCheck.position, 1); -> 바로 앞에 있는 모든 값 체크

레이어 마스크 값이 1이면 모든 값;

그중에 Obstacle 값이면 Flip 함수실행 -> 좌우 반전

움직임 조절 rigidbody2D.velocity = new Vector2(transform.localScale.x * moveSpeed, rigidbody2D.velocity.y);

죽으면 죽는 함수 실행

if(HP <= 0 && !dead)

// ... call the death function.

Death ();

void Death() 함수

모든 스프라이트 렌더러를 불러와서 다 안보이게 한다.

그리고 바디 렌더러(ren)는 보이게 하고

그 렌더러의 스프라이트를 죽는 모습으로 변경하고

스코어를 100점 올려주고 dead 를 true 로 변경

리지드바디의 앵글을 고정시켜버린다.(떨어질때 변경되지 않도록)

AddTorque -> 함수를 사용하여 축을 중심으로 회전되게한다.

그리고 주인공 스크립트에서 했던것과 마찬가지로 모든 콜라이더를 isTrigger 처리 해줘서 적이 떨어지도록 한다

스코어는 적의 위치 바로 위에 생성되게 한다.

저작자표시

'잡다한것들전부 > 공식예제' 카테고리의 다른 글

맵 생성 스크립트 - BoardManager (0)	2015.02.22
배경 생성 관련 스크립트 - BackgroundPropSpawner (0)	2014.02.25
몬스터 관련 함수 - Enemy 스크립트 (0)	2014.02.25
점수 표현 - Score (0)	2014.02.25
폭탄과 구급 상자 - Bomb Pickup, Bomb (0)	2014.02.25
물체 파괴 함수 -> Destroyer 스크립트 (0)	2014.02.25

Trackback 0 And Comment 0

점수 표현 - Score

| 잡다한것들전부/공식예제 2014. 2. 25. 17:48

Posted by 히아레인

UI 의 스코어에 붙어있는 스크립트

화면 위에 있는 점수

guiText 값 변경 해주고

점수를 얻으면 Taunt 함수를호출

저작자표시

'잡다한것들전부 > 공식예제' 카테고리의 다른 글

배경 생성 관련 스크립트 - BackgroundPropSpawner (0)	2014.02.25
몬스터 관련 함수 - Enemy 스크립트 (0)	2014.02.25
점수 표현 - Score (0)	2014.02.25
폭탄과 구급 상자 - Bomb Pickup, Bomb (0)	2014.02.25
물체 파괴 함수 -> Destroyer 스크립트 (0)	2014.02.25
killTrigger -> 모든 적과 주인공 충돌(강) - Removver 스크립트 (0)	2014.02.25

Trackback 0 And Comment 0

폭탄과 구급 상자 - Bomb Pickup, Bomb

| 잡다한것들전부/공식예제 2014. 2. 25. 17:02

Posted by 히아레인

bombCrate -> crate, parachute

FloatDown 애니(떨어질때 흔들흔들하는모션) 와 BombLanding(떨어지고 나서 낙하산이 없어지는모션) 애니로 구성되있음

using UnityEngine;
using System.Collections;

public class BombPickup : MonoBehaviour
{
	public AudioClip pickupClip;		// Sound for when the bomb crate is picked up.

private Animator anim;				// Reference to the animator component.
	private bool landed = false;		// Whether or not the crate has landed yet.

void Awake()
	{
		// Setting up the reference.
		anim = transform.root.GetComponent<Animator>();
	}

void OnTriggerEnter2D (Collider2D other)
	{
		// If the player enters the trigger zone...
		if(other.tag == "Player")
		{
			// ... play the pickup sound effect.
			AudioSource.PlayClipAtPoint(pickupClip, transform.position);

// Increase the number of bombs the player has.
			other.GetComponent<LayBombs>().bombCount++;

// Destroy the crate.
			Destroy(transform.root.gameObject);
		}
		// Otherwise if the crate lands on the ground...
		else if(other.tag == "ground" && !landed)
		{
			// ... set the animator trigger parameter Land.
			anim.SetTrigger("Land");
			transform.parent = null;
			gameObject.AddComponent<Rigidbody2D>();
			landed = true;		
		}
	}
}

landed -> 현재 땅인지 체크

폭탄은 서클 콜라이더와 박스 콜라이더로 구성되있고 서클콜라이더는 is Trigger 체크 되있음

그래서 OnTriggerEnter 함수를 호출할수잇음. 박스콜라이더는 땅과 부딪히게 할려고 부착한 상태인듯. isTrigger 시 충돌 무시해버리고 통과되기때문.

Player 와 부딪힐 경우에는 플레이어의 폭탄 개수를 늘려주고 삭제해버림.

그리고 땅과 부딪힐경우에는 else if(other.tag == "ground" && !landed)

Ladn 애니메이션을 실행시키고

Create 폭탄의 부모 오브젝트를 null값으로 만들어준다.

그리고 리지드바디를 추가시킴(추가가 안될시 플레이어와 물리효과를 집어널수없기때문,.)

explosionParticle -> 은 히어라이키에 한개만 존재함 이함수를 재활요해서 계속 사용함

using UnityEngine;
using System.Collections;

public class Bomb : MonoBehaviour
{
	public float bombRadius = 10f;			// Radius within which enemies are killed.
	public float bombForce = 100f;			// Force that enemies are thrown from the blast.
	public AudioClip boom;					// Audioclip of explosion.
	public AudioClip fuse;					// Audioclip of fuse.
	public float fuseTime = 1.5f;
	public GameObject explosion;			// Prefab of explosion effect.

private LayBombs layBombs;				// Reference to the player's LayBombs script.
	private PickupSpawner pickupSpawner;	// Reference to the PickupSpawner script.
	private ParticleSystem explosionFX;		// Reference to the particle system of the explosion effect.

void Awake ()
	{
		// Setting up references.
		explosionFX = GameObject.FindGameObjectWithTag("ExplosionFX").GetComponent<ParticleSystem>();
		pickupSpawner = GameObject.Find("pickupManager").GetComponent<PickupSpawner>();
		if(GameObject.FindGameObjectWithTag("Player"))
			layBombs = GameObject.FindGameObjectWithTag("Player").GetComponent<LayBombs>();
	}

void Start ()
	{
		
		// If the bomb has no parent, it has been laid by the player and should detonate.
		if(transform.root == transform)
			StartCoroutine(BombDetonation());
	}

IEnumerator BombDetonation()
	{
		// Play the fuse audioclip.
		AudioSource.PlayClipAtPoint(fuse, transform.position);

// Wait for 2 seconds.
		yield return new WaitForSeconds(fuseTime);

// Explode the bomb.
		Explode();
	}

public void Explode()
	{
		
		// The player is now free to lay bombs when he has them.
		layBombs.bombLaid = false;

// Make the pickup spawner start to deliver a new pickup.
		pickupSpawner.StartCoroutine(pickupSpawner.DeliverPickup());

// Find all the colliders on the Enemies layer within the bombRadius.
		Collider2D[] enemies = Physics2D.OverlapCircleAll(transform.position, bombRadius, 1 << LayerMask.NameToLayer("Enemies"));

// For each collider...
		foreach(Collider2D en in enemies)
		{
			// Check if it has a rigidbody (since there is only one per enemy, on the parent).
			Rigidbody2D rb = en.rigidbody2D;
			if(rb != null && rb.tag == "Enemy")
			{
				// Find the Enemy script and set the enemy's health to zero.
				rb.gameObject.GetComponent<Enemy>().HP = 0;

// Find a vector from the bomb to the enemy.
				Vector3 deltaPos = rb.transform.position - transform.position;

// Apply a force in this direction with a magnitude of bombForce.
				Vector3 force = deltaPos.normalized * bombForce;
				rb.AddForce(force);
			}
		}

// Set the explosion effect's position to the bomb's position and play the particle system.
		explosionFX.transform.position = transform.position;
		explosionFX.Play();

// Instantiate the explosion prefab.
		Instantiate(explosion,transform.position, Quaternion.identity);

// Play the explosion sound effect.
		AudioSource.PlayClipAtPoint(boom, transform.position);

// Destroy the bomb.
		Destroy (gameObject);
	}
}

폭탄관련함수

if(transform.root == transform)

StartCoroutine(BombDetonation());

플레이어가 알트 버튼을 눌러서 폭파 시킬때 실행됨 최상위 오브젝트가 없을때(Create일때) -> LayBombs 스크립트에서 실행

Explode() -> 외부에서 실행됨 폭탄이 내려오는데 플레이어가 총으로 맞춘다던가

bombLaid 를 false로 만들어줌.

pickupSpawner -> 픽업매니저 스크립트 -> PickupSpawner 구급상자와 폭탄 생성

pickupSpawner.StartCoroutine(pickupSpawner.DeliverPickup()); -> 아이템 재생성

Collider2D[] enemies = Physics2D.OverlapCircleAll(transform.position, bombRadius, 1 << LayerMask.NameToLayer("Enemies"));

반경 원안에 있는 적들 배열에 집어넣기

foreach(Collider2D en in enemies)

{

// Check if it has a rigidbody (since there is only one per enemy, on the parent).

Rigidbody2D rb = en.rigidbody2D;

if(rb != null && rb.tag == "Enemy")

{

// Find the Enemy script and set the enemy's health to zero.

rb.gameObject.GetComponent<Enemy>().HP = 0;

// Find a vector from the bomb to the enemy.

Vector3 deltaPos = rb.transform.position - transform.position;

// Apply a force in this direction with a magnitude of bombForce.

Vector3 force = deltaPos.normalized * bombForce;

rb.AddForce(force);

}

적들의 체력을 0으로 만들고 적들을 튕겨내버림

explosionFX.transform.position = transform.position;

explosionFX.Play();

이펙트 위치 설정 및 실행

using UnityEngine;
using System.Collections;

public class LayBombs : MonoBehaviour
{
	[HideInInspector]
	public bool bombLaid = false;		// Whether or not a bomb has currently been laid.
	public int bombCount = 0;			// How many bombs the player has.
	public AudioClip bombsAway;			// Sound for when the player lays a bomb.
	public GameObject bomb;				// Prefab of the bomb.

private GUITexture bombHUD;			// Heads up display of whether the player has a bomb or not.

void Awake ()
	{
		// Setting up the reference.
		bombHUD = GameObject.Find("ui_bombHUD").guiTexture;
	}

void Update ()
	{
		// If the bomb laying button is pressed, the bomb hasn't been laid and there's a bomb to lay...
		if(Input.GetButtonDown("Fire2") && !bombLaid && bombCount > 0)
		{
			// Decrement the number of bombs.
			bombCount--;

// Set bombLaid to true.
			bombLaid = true;

// Play the bomb laying sound.
			AudioSource.PlayClipAtPoint(bombsAway,transform.position);

// Instantiate the bomb prefab.
			Instantiate(bomb, transform.position, transform.rotation);
		}

// The bomb heads up display should be enabled if the player has bombs, other it should be disabled.
		bombHUD.enabled = bombCount > 0;
	}
}

플레이어에 붙어있는 스크립트

bombLaid -> 폭탄 발사여부 - > Explode 함수가 실행되야 false로 변함

bombCount -> 폭탄 개수

알트 버튼 누르면 발사

저작자표시

'잡다한것들전부 > 공식예제' 카테고리의 다른 글

몬스터 관련 함수 - Enemy 스크립트 (0)	2014.02.25
점수 표현 - Score (0)	2014.02.25
폭탄과 구급 상자 - Bomb Pickup, Bomb (0)	2014.02.25
물체 파괴 함수 -> Destroyer 스크립트 (0)	2014.02.25
killTrigger -> 모든 적과 주인공 충돌(강) - Removver 스크립트 (0)	2014.02.25
플레이어의 체력 - PlayerHealth (0)	2014.02.25

Trackback 0 And Comment 0

물체 파괴 함수 -> Destroyer 스크립트

| 잡다한것들전부/공식예제 2014. 2. 25. 16:22

Posted by 히아레인

Splash -> 강물빠지는거

explosionCircle -> 폭탄 사용시 잠시 원처럼 뜨는것.

ui_100points -> 적 죽이면 점수 화면에 뿌려줄때

Splash 와 Score 는 에니메이션으로 구성되있고 에니메이션 이벤트의 마지막에 -> DestroyGameObject를 실행시킨다.

explosionCircle 은 발생과 동시에 0.1초만에 오브젝트를 삭제시킨다.

using UnityEngine;
using System.Collections;

public class Destroyer : MonoBehaviour
{
	public bool destroyOnAwake;			// Whether or not this gameobject should destroyed after a delay, on Awake.
	public float awakeDestroyDelay;		// The delay for destroying it on Awake.
	public bool findChild = false;				// Find a child game object and delete it
	public string namedChild;			// Name the child object in Inspector

void Awake ()
	{
		// If the gameobject should be destroyed on awake,
		if(destroyOnAwake)
		{
			if(findChild)
			{
				Destroy (transform.Find(namedChild).gameObject);
			}
			else
			{
				// ... destroy the gameobject after the delay.
				Destroy(gameObject, awakeDestroyDelay);
			}

}

void DestroyChildGameObject ()
	{
		// Destroy this child gameobject, this can be called from an Animation Event.
		if(transform.Find(namedChild).gameObject != null)
			Destroy (transform.Find(namedChild).gameObject);
	}

void DisableChildGameObject ()
	{
		// Destroy this child gameobject, this can be called from an Animation Event.
		if(transform.Find(namedChild).gameObject.activeSelf == true)
			transform.Find(namedChild).gameObject.SetActive(false);
	}

void DestroyGameObject ()
	{
		// Destroy this gameobject, this can be called from an Animation Event.
		Destroy (gameObject);
	}
}

destroyOnAwake -> 시작과 동시에 삭제시킬지 여부

findChild -> 자기의 자식을 삭제시킬지 여부

namedChild - > 자식을 삭제시킬때 삭제시킬 자식 이름

DestroyChildGameObject -> 자식 삭제

DisableChildGameObject -> 자식을 비활성화로

DestroyGameObject -> 자기 자신 삭제

저작자표시

'잡다한것들전부 > 공식예제' 카테고리의 다른 글

점수 표현 - Score (0)	2014.02.25
폭탄과 구급 상자 - Bomb Pickup, Bomb (0)	2014.02.25
물체 파괴 함수 -> Destroyer 스크립트 (0)	2014.02.25
killTrigger -> 모든 적과 주인공 충돌(강) - Removver 스크립트 (0)	2014.02.25
플레이어의 체력 - PlayerHealth (0)	2014.02.25
플레이어 무기 발사 - gun 스크립트 (0)	2014.02.25

Trackback 0 And Comment 0

killTrigger -> 모든 적과 주인공 충돌(강) - Removver 스크립트

| 잡다한것들전부/공식예제 2014. 2. 25. 16:15

Posted by 히아레인

using UnityEngine;
using System.Collections;

public class Remover : MonoBehaviour
{
	public GameObject splash;

void OnTriggerEnter2D(Collider2D col)
	{
		// If the player hits the trigger...
		if(col.gameObject.tag == "Player")
		{
			// .. stop the camera tracking the player
			GameObject.FindGameObjectWithTag("MainCamera").GetComponent<CameraFollow>().enabled = false;

// .. stop the Health Bar following the player
			if(GameObject.FindGameObjectWithTag("HealthBar").activeSelf)
			{
				GameObject.FindGameObjectWithTag("HealthBar").SetActive(false);
			}

// ... instantiate the splash where the player falls in.
			Instantiate(splash, col.transform.position, transform.rotation);
			// ... destroy the player.
			Destroy (col.gameObject);
			// ... reload the level.
			StartCoroutine("ReloadGame");
		}
		else
		{
			// ... instantiate the splash where the enemy falls in.
			Instantiate(splash, col.transform.position, transform.rotation);

// Destroy the enemy.
			Destroy (col.gameObject);	
		}
	}

IEnumerator ReloadGame()
	{			
		// ... pause briefly
		yield return new WaitForSeconds(2);
		// ... and then reload the level.
		Application.LoadLevel(Application.loadedLevel);
	}
}

강물 위치에 배치되있음.

Remover 스크립트가 할당되있고, 몬스터가 강물에 빠지면 해당 오브젝트를 제거하고 플레이어가 빠지면 특정 작업을 한후 재시작함.

// If the player hits the trigger...

if(col.gameObject.tag == "Player")

{

// .. stop the camera tracking the player

GameObject.FindGameObjectWithTag("MainCamera").GetComponent<CameraFollow>().enabled = false;

// .. stop the Health Bar following the player

if(GameObject.FindGameObjectWithTag("HealthBar").activeSelf)

{

GameObject.FindGameObjectWithTag("HealthBar").SetActive(false);

}

// ... instantiate the splash where the player falls in.

Instantiate(splash, col.transform.position, transform.rotation);

// ... destroy the player.

Destroy (col.gameObject);

// ... reload the level.

StartCoroutine("ReloadGame");

}

else

{

// ... instantiate the splash where the enemy falls in.

Instantiate(splash, col.transform.position, transform.rotation);

// Destroy the enemy.

}

메인카메라의 CameraFollow 스크립트 기능 끄기

HealthBar 활성화 상태이면 안보이게 하기 (activeSelf -> 오브젝트 활성화 여부 체크)

Splash 프리팹 생성 -> 강물 빠지는 모양 -> 프리팹에는 Destroyer 스크립트 연결되있음(애니메이션 마지막 부부분에서 자기자신을 삭제해줌)

플레이어 제거

ReloadGame 코루틴 실행

IEnumerator ReloadGame()

{

// ... pause briefly

yield return new WaitForSeconds(2);

// ... and then reload the level.

Application.LoadLevel(Application.loadedLevel);

}

2초후 게임 다시 실행

저작자표시

'잡다한것들전부 > 공식예제' 카테고리의 다른 글

폭탄과 구급 상자 - Bomb Pickup, Bomb (0)	2014.02.25
물체 파괴 함수 -> Destroyer 스크립트 (0)	2014.02.25
killTrigger -> 모든 적과 주인공 충돌(강) - Removver 스크립트 (0)	2014.02.25
플레이어의 체력 - PlayerHealth (0)	2014.02.25
플레이어 무기 발사 - gun 스크립트 (0)	2014.02.25
주인공을 따라다니는 카메라 (0)	2014.02.25

Trackback 0 And Comment 0

플레이어의 체력 - PlayerHealth

| 잡다한것들전부/공식예제 2014. 2. 25. 15:22

Posted by 히아레인

using UnityEngine;
using System.Collections;

public class PlayerHealth : MonoBehaviour
{	
	public float health = 100f;					// The player's health.
	public float repeatDamagePeriod = 2f;		// How frequently the player can be damaged.
	public AudioClip[] ouchClips;				// Array of clips to play when the player is damaged.
	public float hurtForce = 10f;				// The force with which the player is pushed when hurt.
	public float damageAmount = 10f;			// The amount of damage to take when enemies touch the player

private SpriteRenderer healthBar;			// Reference to the sprite renderer of the health bar.
	private float lastHitTime;					// The time at which the player was last hit.
	private Vector3 healthScale;				// The local scale of the health bar initially (with full health).
	private PlayerControl playerControl;		// Reference to the PlayerControl script.
	private Animator anim;						// Reference to the Animator on the player

void Awake ()
	{
		// Setting up references.
		playerControl = GetComponent<PlayerControl>();
		healthBar = GameObject.Find("HealthBar").GetComponent<SpriteRenderer>();
		anim = GetComponent<Animator>();

// Getting the intial scale of the healthbar (whilst the player has full health).
		healthScale = healthBar.transform.localScale;
	}

void OnCollisionEnter2D (Collision2D col)
	{
		// If the colliding gameobject is an Enemy...
		if(col.gameObject.tag == "Enemy")
		{
			// ... and if the time exceeds the time of the last hit plus the time between hits...
			if (Time.time > lastHitTime + repeatDamagePeriod) 
			{
				// ... and if the player still has health...
				if(health > 0f)
				{
					// ... take damage and reset the lastHitTime.
					TakeDamage(col.transform); 
					lastHitTime = Time.time; 
				}
				// If the player doesn't have health, do some stuff, let him fall into the river to reload the level.
				else
				{
					// Find all of the colliders on the gameobject and set them all to be triggers.
					Collider2D[] cols = GetComponents<Collider2D>();
					foreach(Collider2D c in cols)
					{
						c.isTrigger = true;
					}

// Move all sprite parts of the player to the front
					SpriteRenderer[] spr = GetComponentsInChildren<SpriteRenderer>();
					foreach(SpriteRenderer s in spr)
					{
						s.sortingLayerName = "UI";
					}

// ... disable user Player Control script
					GetComponent<PlayerControl>().enabled = false;

// ... disable the Gun script to stop a dead guy shooting a nonexistant bazooka
					GetComponentInChildren<Gun>().enabled = false;

// ... Trigger the 'Die' animation state
					anim.SetTrigger("Die");
				}
			}
		}
	}

void TakeDamage (Transform enemy)
	{
		// Make sure the player can't jump.
		playerControl.jump = false;

// Create a vector that's from the enemy to the player with an upwards boost.
		Vector3 hurtVector = transform.position - enemy.position + Vector3.up * 5f;

// Add a force to the player in the direction of the vector and multiply by the hurtForce.
		rigidbody2D.AddForce(hurtVector * hurtForce);

// Reduce the player's health by 10.
		health -= damageAmount;

// Update what the health bar looks like.
		UpdateHealthBar();

// Play a random clip of the player getting hurt.
		int i = Random.Range (0, ouchClips.Length);
		AudioSource.PlayClipAtPoint(ouchClips[i], transform.position);
	}

public void UpdateHealthBar ()
	{
		// Set the health bar's colour to proportion of the way between green and red based on the player's health.
		healthBar.material.color = Color.Lerp(Color.green, Color.red, 1 - health * 0.01f);

// Set the scale of the health bar to be proportional to the player's health.
		healthBar.transform.localScale = new Vector3(healthScale.x * health * 0.01f, 1, 1);
	}
}

Health - > 체력

repeatDamagePeriod -> 데미지를 받고나서 다시한번 받을때 까지 간격

ouch clips -> 아픈 사운드 종류별로;

Hurt Force -> 플레이어와 적 충돌시 발생되는 힘

Damage Amount -> 깍이는 체력양

healthBar -> 체력 바는 피봇 위치를 왼쪽으로 해준다.

healthScale -> 이값을 이용하여 체력 게이지의 크기를 줄여줌

OnCollisionEnter2D -> 캐릭터와 충돌 발생시

if(col.gameObject.tag == "Enemy")

{

// ... and if the time exceeds the time of the last hit plus the time between hits...

if (Time.time > lastHitTime + repeatDamagePeriod)

{

// ... and if the player still has health...

if(health > 0f)

{

// ... take damage and reset the lastHitTime.

TakeDamage(col.transform);

lastHitTime = Time.time;

}

Enemy 태그와 충돌시

그리고 repeatDamagePeriod 간격이 지날때만 실행 -> 인스펙터 창에서 조절 가능

체력이 0보다 클때는 TakeDamage 함수 실행

// If the player doesn't have health, do some stuff, let him fall into the river to reload the level.

else

{

// Find all of the colliders on the gameobject and set them all to be triggers.

Collider2D[] cols = GetComponents<Collider2D>();

foreach(Collider2D c in cols)

{

c.isTrigger = true;

}

// Move all sprite parts of the player to the front

SpriteRenderer[] spr = GetComponentsInChildren<SpriteRenderer>();

foreach(SpriteRenderer s in spr)

{

s.sortingLayerName = "UI";

}

// ... disable user Player Control script

GetComponent<PlayerControl>().enabled = false;

// ... disable the Gun script to stop a dead guy shooting a nonexistant bazooka

GetComponentInChildren<Gun>().enabled = false;

// ... Trigger the 'Die' animation state

anim.SetTrigger("Die");

}

체력이 0보다 작을때는(죽을때) 모든 물체의 충돌을 무시하기 위해서 모든 충돌체를 isTrigger 해주고

모든 스프라이트 렌더러의 레이어 값을 UI 로 설정해줌->최상위 오브젝트로(맨위에 보이게)

그리고 PlayerControl 스크립트를 꺼주어 캐릭터가 못움직이게 한다

Gun 스크립트를 꺼주어서 총을 발사를 못하게 한다.

마지막으로 죽는 애니메이션을 실행시킨다.

플레이어가 충돌시 실행되는 함수

void TakeDamage (Transform enemy)

{

// Make sure the player can't jump.

playerControl.jump = false;

// Create a vector that's from the enemy to the player with an upwards boost.

Vector3 hurtVector = transform.position - enemy.position + Vector3.up * 5f;

// Add a force to the player in the direction of the vector and multiply by the hurtForce.

rigidbody2D.AddForce(hurtVector * hurtForce);

// Reduce the player's health by 10.

health -= damageAmount;

// Update what the health bar looks like.

UpdateHealthBar();

// Play a random clip of the player getting hurt.

int i = Random.Range (0, ouchClips.Length);

AudioSource.PlayClipAtPoint(ouchClips[i], transform.position);

}

충돌발생시 점프를 못하게하고

적과 부딪힌 방향으로 캐릭터를 튕기게 해준다. -> rigidbody2D.AddForce(hurtVector * hurtForce);

그리고 체력을 깍고 UpdateHealthBar함수를 실행시켜 게임내에서 체력바를 적용되게 한다.

마지막으로 오디오 사운드를 실행시킴..

public void UpdateHealthBar ()

{

// Set the health bar's colour to proportion of the way between green and red based on the player's health.

healthBar.material.color = Color.Lerp(Color.green, Color.red, 1 - health * 0.01f);

// Set the scale of the health bar to be proportional to the player's health.

healthBar.transform.localScale = new Vector3(healthScale.x * health * 0.01f, 1, 1);

}

체력이 깍일수록 점점 빨간색으로 변함.

health 값으로 체력바의 길이 조절

체력바 에 붙는 스크립트

주인공위에 항상 따라다님.

ui_healthDisplay

저작자표시

'잡다한것들전부 > 공식예제' 카테고리의 다른 글

물체 파괴 함수 -> Destroyer 스크립트 (0)	2014.02.25
killTrigger -> 모든 적과 주인공 충돌(강) - Removver 스크립트 (0)	2014.02.25
플레이어의 체력 - PlayerHealth (0)	2014.02.25
플레이어 무기 발사 - gun 스크립트 (0)	2014.02.25
주인공을 따라다니는 카메라 (0)	2014.02.25
플레이어 컨트롤 스크립트 (0)	2014.02.25

Trackback 0 And Comment 0

플레이어 무기 발사 - gun 스크립트

| 잡다한것들전부/공식예제 2014. 2. 25. 15:15

Posted by 히아레인

using UnityEngine;
using System.Collections;

public class Gun : MonoBehaviour
{
	public Rigidbody2D rocket;				// Prefab of the rocket.
	public float speed = 20f;				// The speed the rocket will fire at.

private PlayerControl playerCtrl;		// Reference to the PlayerControl script.
	private Animator anim;					// Reference to the Animator component.

void Awake()
	{
		// Setting up the references.
		anim = transform.root.gameObject.GetComponent<Animator>();
		playerCtrl = transform.root.GetComponent<PlayerControl>();
	}

void Update ()
	{
		// If the fire button is pressed...
		if(Input.GetButtonDown("Fire1"))
		{
			// ... set the animator Shoot trigger parameter and play the audioclip.
			anim.SetTrigger("Shoot");
			audio.Play();

// If the player is facing right...
			if(playerCtrl.facingRight)
			{
				// ... instantiate the rocket facing right and set it's velocity to the right. 
				Rigidbody2D bulletInstance = Instantiate(rocket, transform.position, Quaternion.Euler(new Vector3(0,0,0))) as Rigidbody2D;
				bulletInstance.velocity = new Vector2(speed, 0);
			}
			else
			{
				// Otherwise instantiate the rocket facing left and set it's velocity to the left.
				Rigidbody2D bulletInstance = Instantiate(rocket, transform.position, Quaternion.Euler(new Vector3(0,0,180f))) as Rigidbody2D;
				bulletInstance.velocity = new Vector2(-speed, 0);
			}
		}
	}
}

프리팹을 생성해줄때 Rigidbody2D 로 생성해줄수도 있음.. 생성해주고 나서 리지드바디의 velocity 값을 수정해서 로켓이 발사되는 위치를 지정해줌.

transform.root -> 등을 사용하여 최상위 오브젝트에 접근한다.

저작자표시

'잡다한것들전부 > 공식예제' 카테고리의 다른 글

killTrigger -> 모든 적과 주인공 충돌(강) - Removver 스크립트 (0)	2014.02.25
플레이어의 체력 - PlayerHealth (0)	2014.02.25
플레이어 무기 발사 - gun 스크립트 (0)	2014.02.25
주인공을 따라다니는 카메라 (0)	2014.02.25
플레이어 컨트롤 스크립트 (0)	2014.02.25
배경 시차 스크롤 카메라의 움직임에따라 (0)	2014.02.25

Trackback 0 And Comment 0

일	월	화	수	목	금	토
	1	2	3	4	5	6
7	8	9	10	11	12	13
14	15	16	17	18	19	20
21	22	23	24	25	26	27
28	29	30

Article Category

Notice

Recent Article

Recent Comment

Recent Trackback

'잡다한것들전부/공식예제'에 해당되는 글 13건

'잡다한것들전부 > 공식예제' 카테고리의 다른 글

Trackback

'잡다한것들전부 > 공식예제' 카테고리의 다른 글

Trackback

'잡다한것들전부 > 공식예제' 카테고리의 다른 글

Trackback

'잡다한것들전부 > 공식예제' 카테고리의 다른 글

Trackback

'잡다한것들전부 > 공식예제' 카테고리의 다른 글

Trackback

'잡다한것들전부 > 공식예제' 카테고리의 다른 글

Trackback

'잡다한것들전부 > 공식예제' 카테고리의 다른 글

Trackback

'잡다한것들전부 > 공식예제' 카테고리의 다른 글

Trackback

'잡다한것들전부 > 공식예제' 카테고리의 다른 글

Trackback

'잡다한것들전부 > 공식예제' 카테고리의 다른 글

Trackback

Tag Cloud

Calendar

Archive

My Link