Using System

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class Attacker : MonoBehaviour {
[Range (0f, 5f)]

float currentSpeed = 1f;
GameObject currentTarget;
private void Awake()

{
FindObjectOfType<LevelController>().AttackerSpawned();
}
private void OnDestroy()

{
LevelController levelController = FindObjectOfType<LevelController>();
if (levelController != null)
{
levelController.AttackerKilled();
}
}
void Update () {
transform.Translate(Vector2.left * currentSpeed * Time.deltaTime);
UpdateAnimationState();
}
private void UpdateAnimationState()

{
if(!currentTarget)
{
GetComponent<Animator>().SetBool("isAttacking", false);
}
}
public void SetMovementSpeed (float speed)

{
currentSpeed = speed;
}
public void Attack(GameObject target)

{
GetComponent<Animator>().SetBool("isAttacking", true);
currentTarget = target;
}
public void StrikeCurrentTarget(float damage)

{
if (!currentTarget) { return; }
Health health = currentTarget.GetComponent<Health>();
if (health)
{
health.DealDamage(damage);
}
}
}
using UnityEngine;
public class AttackerSpawner : MonoBehaviour {
[SerializeField] float minSpawnDelay = 1f;

[SerializeField] float maxSpawnDelay = 5f;
[SerializeField] Attacker[] attackerPrefabArray;
bool spawn = true;
IEnumerator Start()
{
while(spawn)
{
yield return new WaitForSeconds(Random.Range(minSpawnDelay,
maxSpawnDelay));
SpawnAttacker();
}
}

public void StopSpawning()
{
spawn = false;
}
private void SpawnAttacker()

{
var attackerIndex = Random.Range(0, attackerPrefabArray.Length);
Spawn(attackerPrefabArray[attackerIndex]);
}
private void Spawn (Attacker myAttacker)

{
Attacker newAttacker = Instantiate
(myAttacker, transform.position, transform.rotation)
as Attacker;
newAttacker.transform.parent = transform;
}
}
using UnityEngine;
public class DamageCollider : MonoBehaviour {
private void OnTriggerEnter2D(Collider2D otherCollider)

{
FindObjectOfType<LivesDisplay>().TakeLife();
Destroy(otherCollider.gameObject);
}
}
using System;
using UnityEngine;
using UnityEngine.UI;
public class DefenderButton : MonoBehaviour {
[SerializeField] Defender defenderPrefab;
private void Start()

{
LabelButtonWithCost();
}
private void LabelButtonWithCost()

{
Text costText = GetComponentInChildren<Text>();
if (!costText)
{
//Debug.LogError(name + " has no cost text, add some!");
}
else
{
costText.text = defenderPrefab.GetStarCost().ToString();
}
}
private void OnMouseDown()

{
var buttons = FindObjectsOfType<DefenderButton>();
foreach(DefenderButton button in buttons)
{
button.GetComponent<SpriteRenderer>().color = new Color32(41, 41,
41, 255);
}
GetComponent<SpriteRenderer>().color = Color.white;
FindObjectOfType<DefenderSpawner>().SetSelectedDefender(defenderPrefab);
}
}
using System;
using UnityEngine;
public class DefenderSpawner : MonoBehaviour {
Defender defender;
GameObject defenderParent;
const string DEFENDER_PARENT_NAME = "Defenders";

{
CreateDefenderParent();
}
private void CreateDefenderParent()

{
defenderParent = GameObject.Find(DEFENDER_PARENT_NAME);
if (!defenderParent)
{
defenderParent = new GameObject(DEFENDER_PARENT_NAME);
}
}
private void OnMouseDown()

{
AttemptToPlaceDefenderAt(GetSquareClicked());
}
public void SetSelectedDefender(Defender defenderToSelect)

{
defender = defenderToSelect;
}
private void AttemptToPlaceDefenderAt(Vector2 gridPos)

{
var StarDisplay = FindObjectOfType<StarDisplay>();
int defenderCost = defender.GetStarCost();
if (StarDisplay.HaveEnoughStars(defenderCost))
{
SpawnDefender(gridPos);
StarDisplay.SpendStars(defenderCost);
}
}
private Vector2 GetSquareClicked()
{
Vector2 clickPos = new Vector2(Input.mousePosition.x,
Input.mousePosition.y);
Vector2 worldPos = Camera.main.ScreenToWorldPoint(clickPos);
Vector2 gridPos = SnapToGrid(worldPos);
return gridPos;
}
private Vector2 SnapToGrid(Vector2 rawWorldPos)

{
float newX = Mathf.RoundToInt(rawWorldPos.x);
float newY = Mathf.RoundToInt(rawWorldPos.y);
return new Vector2(newX, newY);
}
private void SpawnDefender(Vector2 roundedPos)

{
Defender newDefender = Instantiate(defender, roundedPos,
Quaternion.identity) as Defender;
newDefender.transform.parent = defenderParent.transform;
}
}
using UnityEngine;
public class Fox : MonoBehaviour {

{
GameObject otherObject = otherCollider.gameObject;
if(otherObject.GetComponent<Gravestone>())
{
GetComponent<Animator>().SetTrigger("jumpTrigger");
}
else if (otherObject.GetComponent<Defender>())
{
GetComponent<Attacker>().Attack(otherObject);
}
}
}
using UnityEngine;
public class GameTimer : MonoBehaviour {
[Tooltip("Our level timer in SECONDS")]

[SerializeField] float levelTime = 10;
bool triggeredLevelFinished = false;

// Update is called once per frame
void Update ()
{
if (triggeredLevelFinished) { return; }
GetComponent<Slider>().value = Time.timeSinceLevelLoad / levelTime;
bool timerFinished = (Time.timeSinceLevelLoad >= levelTime);

if (timerFinished)
{
FindObjectOfType<LevelController>().LevelTimerFinished();
triggeredLevelFinished = true;
}
}
}
using UnityEngine;
public class Gravestone : MonoBehaviour {
private void OnTriggerStay2D(Collider2D otherCollider)

{
Attacker attacker = otherCollider.GetComponent<Attacker>();
if(attacker)
{
// TODO Add some sort of animation
}
}
}
using UnityEngine;
public class Health : MonoBehaviour {
[SerializeField] float health = 100f;

[SerializeField] GameObject deathVFX;
public void DealDamage(float damage)

{
health -= damage;
if (health <= 0)
{
TriggerDeathVFX();
Destroy(gameObject);
}
}

private void TriggerDeathVFX()
{
if(!deathVFX) { return; }
GameObject deathVFXObject = Instantiate(deathVFX, transform.position,
transform.rotation);
Destroy(deathVFXObject, 1f);
}
}
using UnityEngine;
public class LevelController : MonoBehaviour {
[SerializeField] float waitToLoad = 4f;

[SerializeField] GameObject winLabel;
[SerializeField] GameObject loseLabel;
int numberOfAttackers = 0;
bool levelTimerFinished = false;

{
winLabel.SetActive(false);
loseLabel.SetActive(false);
}
public void AttackerSpawned()

{
numberOfAttackers++;
}
public void AttackerKilled()

{
numberOfAttackers--;
if (numberOfAttackers <= 0 && levelTimerFinished)
{
StartCoroutine(HandleWinCondition());
}
}
IEnumerator HandleWinCondition()
{
winLabel.SetActive(true);
GetComponent<AudioSource>().Play();
yield return new WaitForSeconds(waitToLoad);
FindObjectOfType<LevelLoader>().LoadNextScene();
}
public void HandleLoseCondition()

{
loseLabel.SetActive(true);
Time.timeScale = 0;
}
public void LevelTimerFinished()
{
levelTimerFinished = true;
StopSpawners();
}
private void StopSpawners()

{
AttackerSpawner[] spawnerArray = FindObjectsOfType<AttackerSpawner>();
foreach (AttackerSpawner spawner in spawnerArray)
{
spawner.StopSpawning();
}
}
}
using UnityEngine;
using UnityEngine.SceneManagement;
public class LevelLoader : MonoBehaviour {
[SerializeField] int timeToWait = 4;

int currentSceneIndex;
// Use this for initialization

void Start () {
currentSceneIndex = SceneManager.GetActiveScene().buildIndex;
if (currentSceneIndex == 0)
{
StartCoroutine(WaitForTime());
}
}
IEnumerator WaitForTime()
{
yield return new WaitForSeconds(timeToWait);
LoadNextScene();
}
public void RestartScene()

{
Time.timeScale = 1;
SceneManager.LoadScene(currentSceneIndex);
}
public void LoadMainMenu()

{
Time.timeScale = 1;
SceneManager.LoadScene("Start Screen");
}
public void LoadOptionsScreen()

{
SceneManager.LoadScene("Options Screen");
}
public void LoadNextScene()

{
SceneManager.LoadScene(currentSceneIndex + 1);
}
public void LoadYouLose()

{
SceneManager.LoadScene("Lose Screen");
}

public void QuitGame()
{
Application.Quit();
}
}
using UnityEngine;
public class LivesDisplay : MonoBehaviour {
[SerializeField] float baseLives = 3;

[SerializeField] int damage = 1;
float lives;
Text livesText;
void Start()
{
lives = baseLives - PlayerPrefsController.GetDifficulty();
livesText = GetComponent<Text>();
UpdateDisplay();
Debug.Log("difficulty setting currently is " +
PlayerPrefsController.GetDifficulty());
}
private void UpdateDisplay()

{
livesText.text = lives.ToString();
}
public void TakeLife()

{
lives -= damage;
UpdateDisplay();
if (lives <= 0)
{
FindObjectOfType<LevelController>().HandleLoseCondition();
}
}
}
using UnityEngine;
public class Lizard : MonoBehaviour {

{
GameObject otherObject = otherCollider.gameObject;
if (otherObject.GetComponent<Defender>())
{
GetComponent<Attacker>().Attack(otherObject);
}
}
using UnityEngine;
public class MusicPlayer : MonoBehaviour {
AudioSource audioSource;

void Start () {
DontDestroyOnLoad(this);
audioSource = GetComponent<AudioSource>();
audioSource.volume = PlayerPrefsController.GetMasterVolume();
}

public void SetVolume(float volume)
{
audioSource.volume = volume;
}
}
using UnityEngine;
public class OptionsController : MonoBehaviour {
[SerializeField] Slider volumeSlider;

[SerializeField] float defaultVolume = 0.8f;
[SerializeField] Slider difficultySlider;
[SerializeField] float defaultDifficulty = 0f;

void Start ()
{
volumeSlider.value = PlayerPrefsController.GetMasterVolume();
difficultySlider.value = PlayerPrefsController.GetDifficulty();
}
// Update is called once per frame

void Update ()
{
var musicPlayer = FindObjectOfType<MusicPlayer>();
if (musicPlayer)
{
musicPlayer.SetVolume(volumeSlider.value);
}
else
{
Debug.LogWarning("No music player found... did you start from splash
screen?");
}
}
public void SaveAndExit()

{
PlayerPrefsController.SetMasterVolume(volumeSlider.value);
PlayerPrefsController.SetDifficulty(difficultySlider.value);
FindObjectOfType<LevelLoader>().LoadMainMenu();
}
public void SetDefaults()

{
volumeSlider.value = defaultVolume;
difficultySlider.value = defaultDifficulty;
}
}
using UnityEngine;
public class PlayerPrefsController : MonoBehaviour {
const string MASTER_VOLUME_KEY = "master volume";

const string DIFFICULTY_KEY = "difficulty";
const float MIN_VOLUME = 0f;

const float MAX_VOLUME = 1f;
const float MIN_DIFFICULTY = 0f;

const float MAX_DIFFICULTY = 2f;
public static void SetMasterVolume(float volume)

{
if (volume >= MIN_VOLUME && volume <= MAX_VOLUME)
{
Debug.Log("Master volume set to " + volume);
PlayerPrefs.SetFloat(MASTER_VOLUME_KEY, volume);
}
else
{
Debug.LogError("Master volume is out of range");
}
}
public static float GetMasterVolume()

{
return PlayerPrefs.GetFloat(MASTER_VOLUME_KEY);
}
public static void SetDifficulty(float difficulty)

{
if (difficulty >= MIN_DIFFICULTY && difficulty <= MAX_DIFFICULTY)
{
PlayerPrefs.SetFloat(DIFFICULTY_KEY, difficulty);
}
else
{
Debug.LogError("Difficulty setting is not in range");
}
}
public static float GetDifficulty()

{
return PlayerPrefs.GetFloat(DIFFICULTY_KEY);
}
using UnityEngine;
public class Projectile : MonoBehaviour {
[SerializeField] float speed = 1f;

[SerializeField] float damage = 50;
void Update ()
{
transform.Translate(Vector2.right * speed * Time.deltaTime);
}

{
var health = otherCollider.GetComponent<Health>();
var attacker = otherCollider.GetComponent<Attacker>();
if(attacker && health)

{
health.DealDamage(damage);
Destroy(gameObject);
}
}
}
using System;
using UnityEngine;
public class Shooter : MonoBehaviour {
[SerializeField] GameObject projectile, gun;

AttackerSpawner myLaneSpawner;
Animator animator;
GameObject projectileParent;
const string PROJECTILE_PARENT_NAME = "Projectiles";

{
SetLaneSpawner();
animator = GetComponent<Animator>();
CreateProjectileParent();
}
private void CreateProjectileParent()

{
projectileParent = GameObject.Find(PROJECTILE_PARENT_NAME);
if(!projectileParent)
{
projectileParent = new GameObject(PROJECTILE_PARENT_NAME);
}
}
private void Update()

{
if(IsAttackerInLane())
{
animator.SetBool("isAttacking", true);
}
else
{
animator.SetBool("isAttacking", false);
}
}
private void SetLaneSpawner()

{
AttackerSpawner[] spawners = FindObjectsOfType<AttackerSpawner>();
foreach (AttackerSpawner spawner in spawners)

{
bool IsCloseEnough =
(Mathf.Abs(spawner.transform.position.y - transform.position.y)
<= Mathf.Epsilon);
if (IsCloseEnough)
{
myLaneSpawner = spawner;
}
}
}
private bool IsAttackerInLane()

{
if (myLaneSpawner.transform.childCount <= 0)
{
return false;
}
else
{
return true;
}
}
public void Fire()

{
GameObject newProjectile =
Instantiate(projectile, gun.transform.position, transform.rotation)
as GameObject;
newProjectile.transform.parent = projectileParent.transform;
}
}
using UnityEngine;
public class StarDisplay : MonoBehaviour

{
[SerializeField] int stars = 100;

Text starText;
void Start()
{
starText = GetComponent<Text>();
UpdateDisplay();
}
private void UpdateDisplay()

{
starText.text = stars.ToString();
}
public bool HaveEnoughStars(int amount)

{
return stars >= amount;
}
public void AddStars(int amount)

{
stars += amount;
UpdateDisplay();
}
public void SpendStars(int amount)

{
if (stars >= amount)
{
stars -= amount;
UpdateDisplay();
}
}
}
-126560
-136560
-76601.6
-78601.6
-122999.9
-76388 Change in 3rd number
-126499.9
-76588

Using System

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Using System

Uploaded by

Copyright:

Available Formats

using System;

public class Attacker : MonoBehaviour {

[Range (0f, 5f)]

private void Awake()

private void OnDestroy()

private void UpdateAnimationState()

public void SetMovementSpeed (float speed)

public void Attack(GameObject target)

public void StrikeCurrentTarget(float damage)

public class AttackerSpawner : MonoBehaviour {

[SerializeField] float minSpawnDelay = 1f;

bool spawn = true;

private void SpawnAttacker()

private void Spawn (Attacker myAttacker)

public class DamageCollider : MonoBehaviour {

private void OnTriggerEnter2D(Collider2D otherCollider)

public class DefenderButton : MonoBehaviour {

[SerializeField] Defender defenderPrefab;

private void Start()

private void LabelButtonWithCost()

private void OnMouseDown()

public class DefenderSpawner : MonoBehaviour {

private void Start()

private void CreateDefenderParent()

private void OnMouseDown()

public void SetSelectedDefender(Defender defenderToSelect)

private void AttemptToPlaceDefenderAt(Vector2 gridPos)

private Vector2 SnapToGrid(Vector2 rawWorldPos)

private void SpawnDefender(Vector2 roundedPos)

public class Fox : MonoBehaviour {

private void OnTriggerEnter2D(Collider2D otherCollider)

public class GameTimer : MonoBehaviour {

[Tooltip("Our level timer in SECONDS")]

bool timerFinished = (Time.timeSinceLevelLoad >= levelTime);

public class Gravestone : MonoBehaviour {

private void OnTriggerStay2D(Collider2D otherCollider)

public class Health : MonoBehaviour {

[SerializeField] float health = 100f;

public void DealDamage(float damage)

public class LevelController : MonoBehaviour {

[SerializeField] float waitToLoad = 4f;

private void Start()

public void AttackerSpawned()

public void AttackerKilled()

public void HandleLoseCondition()

private void StopSpawners()

public class LevelLoader : MonoBehaviour {

[SerializeField] int timeToWait = 4;

// Use this for initialization

public void RestartScene()

public void LoadMainMenu()

public void LoadOptionsScreen()

public void LoadNextScene()

public void LoadYouLose()

public class LivesDisplay : MonoBehaviour {

[SerializeField] float baseLives = 3;

private void UpdateDisplay()

public void TakeLife()

public class Lizard : MonoBehaviour {

private void OnTriggerEnter2D(Collider2D otherCollider)

public class MusicPlayer : MonoBehaviour {

// Use this for initialization

public class OptionsController : MonoBehaviour {