1267 lines
37 KiB
C#
1267 lines
37 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEngine.UI;
|
|
|
|
public class GMScript : MonoBehaviour
|
|
{
|
|
|
|
public GameObject[] PartyMembers;
|
|
public Sprite[] OrderSprites;
|
|
public GameObject Hit;
|
|
public GameObject EnemyHit;
|
|
public GameObject Shield;
|
|
public GameObject EnemyShield;
|
|
|
|
public GameObject Victory;
|
|
public GameObject GameOver;
|
|
public GameObject ShieldHit;
|
|
public GameObject WeakPointHit;
|
|
|
|
public Text EnemyDamageText;
|
|
public Text PartyDamageText;
|
|
public Text EnemyHealthText;
|
|
public Text PartyHealthText;
|
|
|
|
public GameObject[] EnemyParts;
|
|
|
|
public Sprite[] EnemyHead;
|
|
public Sprite[] EnemyAntenna;
|
|
public Sprite[] EnemyBody;
|
|
public Sprite[] EnemyArm;
|
|
public Sprite[] EnemyChest;
|
|
public Sprite[] EnemyWeakness;
|
|
|
|
public Sprite[] Symbols;
|
|
|
|
private bool noRepeat = true;
|
|
private bool shield = false;
|
|
private bool enemyShield = false;
|
|
private bool buff = false;
|
|
private bool weakPointHit = false;
|
|
private bool gameover = false;
|
|
private bool victory = false;
|
|
private int partyHealth = 16;
|
|
private int enemyHealth = 32;
|
|
private int partyAttack = 2;
|
|
private int enemyAttack = 2;
|
|
private static int partySize = 4;
|
|
private string[] PartyMemberOrder = new string[partySize];
|
|
private int[] OrderNumbers = new int[partySize];
|
|
private int[] PartyColours = new int[partySize];
|
|
private int[] EnemyPartsColours;
|
|
private int[] EnemyKillSequence;
|
|
|
|
enum Colours {
|
|
Red, Brown, Orange,
|
|
Amber, Yellow, Lime,
|
|
Green, Cyan, Blue,
|
|
Indigo, Purple, Pink,
|
|
White, Grey, Black
|
|
}
|
|
|
|
Colours robotColour;
|
|
|
|
// Start is called before the first frame update
|
|
void Start()
|
|
{
|
|
|
|
EnemyPartsColours = new int[EnemyParts.Length];
|
|
// KILL SEQUENCE RANGES FROM LENGTH OF 2 TO 5 HITS
|
|
EnemyKillSequence = new int[Random.Range(2, 5)];
|
|
|
|
// COLOURS FOR KILL SEQUENCE ARE GENERATED HERE
|
|
for(int i = 0; i < EnemyKillSequence.Length - 1; i++)
|
|
{
|
|
EnemyKillSequence[i] = Random.Range(0, 12);
|
|
}
|
|
|
|
EnemyBuilder();
|
|
|
|
EnemyHealthText.text = enemyHealth.ToString();
|
|
PartyHealthText.text = partyHealth.ToString();
|
|
EnemyDamageText.text = null;
|
|
PartyDamageText.text = null;
|
|
|
|
robotColour = Colours.Red;
|
|
|
|
PartyColours[0] = Random.Range(0, 15);
|
|
PartyColours[1] = Random.Range(0, 15);
|
|
PartyColours[2] = Random.Range(0, 15);
|
|
PartyColours[3] = Random.Range(0, 15);
|
|
|
|
for(int i = 0; i < partySize; i++)
|
|
{
|
|
|
|
//SETTING AND OUTPUT OF ROBOT COLOUR
|
|
PartyMembers[i].transform.GetComponent<SpriteRenderer>().color =
|
|
SetColour(PartyColours[i]);
|
|
PartyMembers[i].transform.GetChild(1).GetComponent<SpriteRenderer>().sprite =
|
|
Symbols[PartyColours[i]];
|
|
PartyMembers[i].transform.GetChild(1).GetComponent<SpriteRenderer>().color =
|
|
SetColour(PartyColours[i]);
|
|
//print(robotColour);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Update is called once per frame
|
|
void Update()
|
|
{
|
|
|
|
noRepeat = true;
|
|
EnemyHealthText.text = enemyHealth.ToString();
|
|
PartyHealthText.text = partyHealth.ToString();
|
|
|
|
if (Input.GetMouseButtonDown(0) && gameover == false && victory == false)
|
|
{
|
|
Vector3 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
|
|
Vector2 mousePos2D = new Vector2(mousePos.x, mousePos.y);
|
|
|
|
RaycastHit2D hit = Physics2D.Raycast(mousePos2D, Vector2.zero);
|
|
|
|
if (hit.collider != null) {
|
|
|
|
|
|
if(hit.collider.gameObject.tag == "Party")
|
|
{
|
|
CheckParty(hit.collider.gameObject);
|
|
|
|
if(noRepeat)
|
|
{
|
|
AddMember(hit.collider.gameObject);
|
|
} else {
|
|
RemoveMember(hit.collider.gameObject);
|
|
}
|
|
|
|
OutputParty();
|
|
}
|
|
|
|
if(hit.collider.gameObject.tag == "Attack" && PartyMemberOrder[0] != null)
|
|
{
|
|
|
|
StartCoroutine(AttackParty(robotColour));
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
if(partyHealth <= 0 && gameover == false)
|
|
{
|
|
partyHealth = 0;
|
|
|
|
GameObject[] party = GameObject.FindGameObjectsWithTag("Party");
|
|
foreach(GameObject memeber in party) GameObject.Destroy(memeber);
|
|
|
|
print("The Super Robo Squad has been destroyed! Try again!");
|
|
|
|
gameover = true;
|
|
|
|
GameOver.SetActive(true);
|
|
|
|
}
|
|
|
|
if(enemyHealth <= 0 || victory == true)
|
|
{
|
|
//enemyHealth = 0;
|
|
|
|
GameObject[] enemy = GameObject.FindGameObjectsWithTag("Enemy");
|
|
foreach(GameObject parts in enemy) GameObject.Destroy(parts);
|
|
|
|
print("The enemy robot has been destroyed! Congrats!");
|
|
|
|
victory = false;
|
|
gameover = true;
|
|
|
|
Victory.SetActive(true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void CheckParty(GameObject member)
|
|
{
|
|
for(int i = 0; i < partySize; i++)
|
|
{
|
|
if(PartyMemberOrder[i] == member.name)
|
|
{
|
|
noRepeat = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
void AddMember(GameObject member)
|
|
{
|
|
|
|
for(int i = 0; i < partySize; i++)
|
|
{
|
|
if(PartyMemberOrder[i] == null)
|
|
{
|
|
PartyMemberOrder[i] = member.name;
|
|
|
|
string[] nameParse = PartyMemberOrder[i].Split(' ');
|
|
int partyNumber = int.Parse(nameParse[2]);
|
|
OrderNumbers[i] = partyNumber;
|
|
|
|
i = partySize;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void RemoveMember(GameObject member)
|
|
{
|
|
for(int i = 0; i < partySize; i++)
|
|
{
|
|
if(PartyMemberOrder[i] == member.name)
|
|
{
|
|
for(int j = i; j < partySize; j++)
|
|
{
|
|
if(j < partySize-1){
|
|
PartyMemberOrder[j] = PartyMemberOrder[j+1];
|
|
OrderNumbers[j] = OrderNumbers[j+1];
|
|
} else {
|
|
PartyMemberOrder[j] = null;
|
|
OrderNumbers[j] = 0;
|
|
}
|
|
}
|
|
|
|
i = partySize;
|
|
}
|
|
}
|
|
}
|
|
|
|
void OutputParty(){
|
|
|
|
//RESET ORDER DISPLAY
|
|
for(int i = 0; i < partySize; i++)
|
|
{
|
|
|
|
PartyMembers[i].transform.GetChild(0).GetComponent<SpriteRenderer>().sprite = null;
|
|
|
|
//FOR DEBUGGING
|
|
if(OrderNumbers[i] != 0)
|
|
{
|
|
|
|
//print(OrderNumbers[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for(int i = 0; i < partySize; i++)
|
|
{
|
|
|
|
for(int j = 1; j <= partySize; j++)
|
|
{
|
|
|
|
//DISPLAYS ORDER ABOVE IF NUMBER IS PRESENT (1-4)
|
|
//ADD OUTPUT FOR DEBUGGING IF NECESSARY
|
|
if(OrderNumbers[i] == j)
|
|
{
|
|
|
|
PartyMembers[OrderNumbers[i]-1].transform.GetChild(0).GetComponent<SpriteRenderer>().sprite = OrderSprites[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
IEnumerator AttackParty(Colours robotColour)
|
|
{
|
|
|
|
// RUNS ATTACK ANIMATION BASED ON PARTY ORDER
|
|
for(int i = 0; i < partySize; i++)
|
|
{
|
|
|
|
if(OrderNumbers[i] != 0)
|
|
{
|
|
|
|
PartyMembers[OrderNumbers[i]-1].transform.GetChild(0).GetComponent<SpriteRenderer>().sprite = null;
|
|
|
|
Animator attack = PartyMembers[OrderNumbers[i]-1].transform.GetComponent<Animator>();
|
|
attack.SetTrigger("AttackTrigger");
|
|
|
|
yield return new WaitForSeconds(
|
|
attack.GetCurrentAnimatorStateInfo(0).length
|
|
+attack.GetCurrentAnimatorStateInfo(0).normalizedTime);
|
|
|
|
attack.SetTrigger("AttackTrigger");
|
|
|
|
print(PartyColours[OrderNumbers[i]-1]);
|
|
|
|
//SETTING AND OUTPUT OF ROBOT COLOUR
|
|
robotColour = (Colours)PartyColours[OrderNumbers[i]-1];
|
|
//print(robotColour);
|
|
|
|
//PARTY MEMEBER ATTACKING ENEMY
|
|
yield return DamageParty(partyAttack, robotColour);
|
|
}
|
|
|
|
// CLEAN UP IN CASE ANYTHING IS MISSED
|
|
OrderNumbers[i] = 0;
|
|
PartyMemberOrder[i] = null;
|
|
|
|
}
|
|
|
|
// CLEAN UP IN CASE ANYTHING IS MISSED
|
|
for(int i = 0; i < partySize; i++)
|
|
{
|
|
|
|
PartyMembers[i].transform.GetChild(0).GetComponent<SpriteRenderer>().sprite = null;
|
|
|
|
}
|
|
|
|
yield return StartCoroutine(AttackEnemy());
|
|
|
|
}
|
|
|
|
IEnumerator AttackEnemy()
|
|
{
|
|
|
|
// PRE ATTACK BUFF EFFECT ANIMATION
|
|
yield return StartCoroutine(PreAttackBuffAnimEnemy());
|
|
|
|
// ANIMATION FOR FIRST ARM
|
|
yield return StartCoroutine(AttackAnimEnemy());
|
|
|
|
// FIRST ARM EFFECT ANIMATION AND DAMAGE CALCULATIONS
|
|
yield return StartCoroutine(DamageEnemy(enemyAttack, EnemyPartsColours[3]));
|
|
|
|
// ANIMATION FOR SECOND ARM
|
|
yield return StartCoroutine(AttackAnimEnemy());
|
|
|
|
// SECOND ARM EFFECT ANIMATION AND DAMAGE CALCULATIONS
|
|
yield return StartCoroutine(DamageEnemy(enemyAttack, EnemyPartsColours[4]));
|
|
|
|
// POST ATTACK ABILITY EFFECT ANIMATION
|
|
yield return StartCoroutine(PostAttackBuffAnimEnemy());
|
|
|
|
}
|
|
|
|
IEnumerator HitEffectParty(Colours partyMember)
|
|
{
|
|
|
|
//CHECKING IF AN "ATTACK" OR "NON-ATTACK" ROBOT IS GOING
|
|
if((partyMember != Colours.Grey &&
|
|
partyMember != Colours.White &&
|
|
partyMember != Colours.Black)
|
|
&& shield != true && enemyShield != true)
|
|
{
|
|
|
|
Hit.transform.GetComponent<SpriteRenderer>().color =
|
|
SetColour((int)partyMember);
|
|
|
|
Hit.transform.GetChild(0).GetComponent<SpriteRenderer>().sprite =
|
|
Symbols[(int)partyMember];
|
|
|
|
Hit.transform.GetChild(0).GetComponent<SpriteRenderer>().color =
|
|
SetColour((int)partyMember);
|
|
|
|
Hit.SetActive(true);
|
|
|
|
Animator hit = Hit.transform.GetComponent<Animator>();
|
|
hit.SetTrigger("HitTrigger");
|
|
|
|
yield return new WaitForSeconds(
|
|
hit.GetCurrentAnimatorStateInfo(0).length
|
|
+hit.GetCurrentAnimatorStateInfo(0).normalizedTime);
|
|
|
|
Hit.SetActive(false);
|
|
hit.SetTrigger("HitTrigger");
|
|
|
|
}
|
|
|
|
// GREY ROBOT (SHIELD) IS GOING
|
|
if (partyMember == Colours.Grey){
|
|
|
|
shield = true;
|
|
Shield.transform.GetComponent<SpriteRenderer>().color =
|
|
SetColour((int)partyMember);
|
|
Shield.SetActive(true);
|
|
|
|
}
|
|
|
|
// NON-ATTACK ROBOT IS GOING
|
|
if (partyMember == Colours.White ||
|
|
partyMember == Colours.Grey ||
|
|
partyMember == Colours.Black){
|
|
|
|
EnemyHit.transform.GetComponent<SpriteRenderer>().color =
|
|
SetColour((int)partyMember);
|
|
|
|
EnemyHit.transform.GetChild(0).GetComponent<SpriteRenderer>().sprite =
|
|
Symbols[(int)partyMember];
|
|
|
|
EnemyHit.transform.GetChild(0).GetComponent<SpriteRenderer>().color =
|
|
SetColour((int)partyMember);
|
|
|
|
EnemyHit.SetActive(true);
|
|
|
|
Animator hit = EnemyHit.transform.GetComponent<Animator>();
|
|
hit.SetTrigger("HitTrigger");
|
|
|
|
yield return new WaitForSeconds(
|
|
hit.GetCurrentAnimatorStateInfo(0).length
|
|
+hit.GetCurrentAnimatorStateInfo(0).normalizedTime);
|
|
|
|
EnemyHit.SetActive(false);
|
|
hit.SetTrigger("HitTrigger");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
IEnumerator HitEffectEnemy(int attackColour)
|
|
{
|
|
|
|
EnemyHit.transform.GetComponent<SpriteRenderer>().color =
|
|
SetColour(attackColour);
|
|
|
|
EnemyHit.transform.GetChild(0).GetComponent<SpriteRenderer>().sprite =
|
|
Symbols[attackColour];
|
|
|
|
EnemyHit.transform.GetChild(0).GetComponent<SpriteRenderer>().color =
|
|
SetColour(attackColour);
|
|
|
|
if((Colours)attackColour == Colours.White ||
|
|
(Colours)attackColour == Colours.Grey ||
|
|
(Colours)attackColour == Colours.Black)
|
|
{
|
|
Hit.transform.GetComponent<SpriteRenderer>().color =
|
|
SetColour(attackColour);
|
|
|
|
Hit.transform.GetChild(0).GetComponent<SpriteRenderer>().sprite =
|
|
Symbols[attackColour];
|
|
|
|
Hit.transform.GetChild(0).GetComponent<SpriteRenderer>().color =
|
|
SetColour(attackColour);
|
|
|
|
Hit.SetActive(true);
|
|
|
|
Animator hit = Hit.transform.GetComponent<Animator>();
|
|
hit.SetTrigger("HitTrigger");
|
|
|
|
yield return new WaitForSeconds(
|
|
hit.GetCurrentAnimatorStateInfo(0).length
|
|
+hit.GetCurrentAnimatorStateInfo(0).normalizedTime);
|
|
|
|
Hit.SetActive(false);
|
|
hit.SetTrigger("HitTrigger");
|
|
}
|
|
|
|
// ENEMY SHIELD GOES UP IF
|
|
if ((Colours)attackColour == Colours.Grey){
|
|
|
|
enemyShield = true;
|
|
EnemyShield.transform.GetComponent<SpriteRenderer>().color =
|
|
SetColour(attackColour);
|
|
EnemyShield.SetActive(true);
|
|
|
|
}
|
|
|
|
//HIT EFFECT ONLY WORKS IF THERE IS NO SHIELD UP
|
|
if(!shield && !enemyShield
|
|
&& (Colours)attackColour != Colours.White &&
|
|
(Colours)attackColour != Colours.Grey &&
|
|
(Colours)attackColour != Colours.Black)
|
|
{
|
|
|
|
EnemyHit.SetActive(true);
|
|
|
|
Animator hit = EnemyHit.transform.GetComponent<Animator>();
|
|
hit.SetTrigger("HitTrigger");
|
|
|
|
yield return new WaitForSeconds(
|
|
hit.GetCurrentAnimatorStateInfo(0).length
|
|
+hit.GetCurrentAnimatorStateInfo(0).normalizedTime);
|
|
|
|
hit.SetTrigger("HitTrigger");
|
|
|
|
EnemyHit.SetActive(false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
IEnumerator DamageParty(int partyAttack, Colours partyMember)
|
|
{
|
|
|
|
float modifier = 1.0f;
|
|
float modifiedAttack = 2.0f;
|
|
float modifiedHeal = 0f;
|
|
int colourModifier = ColourCompare(partyMember, (Colours)EnemyPartsColours[2]);
|
|
|
|
// ATTACK MODIFIER BASED ON THE RELATION OF THE COLOUR OF THE PARTY MEMBER
|
|
// AND THE COLOUR OF THE ENEMY ROBOT BASE BODY COLOUR
|
|
switch(colourModifier)
|
|
{
|
|
case(2):
|
|
modifier = 2;
|
|
if((Colours)EnemyPartsColours[1] == (Colours)EnemyPartsColours[2]) modifier = 4;
|
|
break;
|
|
case(1):
|
|
modifier = 1.5f;
|
|
if((Colours)EnemyPartsColours[1] == (Colours)EnemyPartsColours[2]) modifier = 2;
|
|
break;
|
|
case(-1):
|
|
modifier = 0.5f;
|
|
if((Colours)EnemyPartsColours[1] == (Colours)EnemyPartsColours[2]) modifier = 0;
|
|
break;
|
|
case(-2):
|
|
modifier = 0;
|
|
if((Colours)EnemyPartsColours[1] == (Colours)EnemyPartsColours[2]) modifier = -1;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// DETERMINING A SEQUENCE BREAK ABSED ON THE NEXT COLOUR IN THE SEQUENCE
|
|
// IF IT'S THE LAST COLOUR THE ROBOT IS DESTROYED
|
|
// IF NOT COLOURS AND SPRITES AND CHANGED ACCORDINGLY
|
|
if(ColourCompare(partyMember, (Colours)EnemyKillSequence[0]) > 0
|
|
&& !shield && !enemyShield)
|
|
{
|
|
|
|
print("Weakness hit!");
|
|
weakPointHit = true;
|
|
|
|
if(EnemyKillSequence[1] == -1)
|
|
{
|
|
|
|
EnemyParts[6].transform.GetChild(0).GetComponent<SpriteRenderer>().sprite = null;
|
|
victory = true;
|
|
|
|
} else {
|
|
|
|
for(int i = 0; i < EnemyKillSequence.Length - 1; i++)
|
|
{
|
|
EnemyKillSequence[i] = EnemyKillSequence[i+1];
|
|
}
|
|
|
|
EnemyKillSequence[EnemyKillSequence.Length-1] = -1;
|
|
|
|
if(EnemyParts[5].activeSelf)
|
|
{
|
|
EnemyParts[5].SetActive(false);
|
|
} else {
|
|
EnemyParts[6].transform.GetChild(0).GetComponent<SpriteRenderer>().color =
|
|
SetColour(EnemyKillSequence[0]);
|
|
EnemyParts[6].transform.GetChild(1).GetComponent<SpriteRenderer>().sprite =
|
|
Symbols[EnemyKillSequence[0]];
|
|
EnemyParts[6].transform.GetChild(1).GetComponent<SpriteRenderer>().color =
|
|
SetColour(EnemyKillSequence[0]);
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// ACTIONS DONE FOR NON-ATTACK ROBOTS
|
|
if(partyMember == Colours.Grey ||
|
|
partyMember == Colours.White ||
|
|
partyMember == Colours.Black)
|
|
{
|
|
|
|
if(partyMember == Colours.White)
|
|
{
|
|
|
|
if(buff)
|
|
{
|
|
modifiedHeal = (partyAttack * modifier) * 2;
|
|
} else {
|
|
modifiedHeal = partyAttack * modifier;
|
|
}
|
|
|
|
partyHealth += (int)modifiedHeal;
|
|
|
|
print(partyMember + " healed the team for " + modifiedHeal + " HP");
|
|
print("Party health is now: " + partyHealth + " HP");
|
|
|
|
}
|
|
|
|
if(partyMember == Colours.Black)
|
|
{
|
|
|
|
|
|
print(partyMember + " buffed the team!");
|
|
print("Party health is now: " + partyHealth + " HP");
|
|
buff = true;
|
|
|
|
}
|
|
|
|
|
|
modifier = 0;
|
|
|
|
}
|
|
|
|
// ATTACKS ARE BLOCK IF SHIELD IS UP
|
|
if(shield || enemyShield &&
|
|
(partyMember != Colours.White
|
|
&& partyMember != Colours.Grey
|
|
&& partyMember != Colours.Black))
|
|
{
|
|
modifier = 0;
|
|
|
|
if(enemyShield)
|
|
{
|
|
print("Enemy Shield Hit!");
|
|
EnemyShield.SetActive(false);
|
|
}
|
|
|
|
}
|
|
|
|
// IN CASE MODIFIER IS NEGATIVE
|
|
if(modifier < 0) modifier = 0;
|
|
|
|
// ATTACKS ARE DOUBLE DAMAGE IF BLACK ROBOT HAS DONE ITS ACTION
|
|
if(buff)
|
|
{
|
|
modifiedAttack = (partyAttack * modifier) * 2;
|
|
} else {
|
|
modifiedAttack = partyAttack * modifier;
|
|
}
|
|
|
|
yield return StartCoroutine(HitEffectParty(partyMember));
|
|
|
|
if(partyMember == Colours.White)
|
|
{
|
|
yield return StartCoroutine(DisplayDamageText((int)modifiedHeal, PartyDamageText, partyMember));
|
|
} else if(partyMember == Colours.Black) {
|
|
yield return StartCoroutine(DisplayDamageText(0, PartyDamageText, partyMember));
|
|
} else if(partyMember != Colours.Grey){
|
|
yield return StartCoroutine(DisplayDamageText((int)modifiedAttack, EnemyDamageText, partyMember));
|
|
enemyShield = false;
|
|
}
|
|
|
|
enemyHealth -= (int)modifiedAttack;
|
|
print(partyMember + " robot attacked for " + modifiedAttack);
|
|
print("Enemy robot health is now: " + enemyHealth + " HP");
|
|
|
|
}
|
|
|
|
IEnumerator DamageEnemy(int enemyAttack, int attackColour)
|
|
{
|
|
|
|
int modifier = 0;
|
|
int modifiedAttack = 2;
|
|
|
|
for(int i = 0; i < 2; i++){
|
|
for(int j = 0; j < partySize; j++){
|
|
|
|
modifier +=
|
|
ColourCompare((Colours)attackColour, (Colours)PartyColours[j]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// ADD DAMAGE IF EITHER OF THE ARMS MATCHES THE COLOUR OF THE ANTENNA
|
|
if(EnemyPartsColours[0] == attackColour)
|
|
{
|
|
print("Antenna Buff!");
|
|
modifier += 2;
|
|
}
|
|
|
|
// IN CASE MODIFIER MAKES ENEMY ATTACK NEGATIVE
|
|
if(modifier < -enemyAttack) modifier = -enemyAttack;
|
|
|
|
modifiedAttack = enemyAttack + modifier;
|
|
|
|
// RUN "NON-ATTACK" BUFF FOR ENEMY IF ANTENNA IS BLACK SO ATTACKS ARE BUFFED
|
|
if((Colours)EnemyPartsColours[0] == Colours.Black)
|
|
{
|
|
modifiedAttack *= 2;
|
|
}
|
|
|
|
//HIT ONLY DAMAGES IF THERE IS NO SHIELD UP
|
|
if(shield || enemyShield)
|
|
{
|
|
|
|
modifiedAttack = 0;
|
|
print("Shield Hit!");
|
|
Shield.SetActive(false);
|
|
|
|
}
|
|
|
|
buff = false;
|
|
|
|
yield return StartCoroutine(HitEffectEnemy(attackColour));
|
|
yield return StartCoroutine(DisplayDamageText(modifiedAttack, PartyDamageText, (Colours)attackColour));
|
|
|
|
if(shield)
|
|
{
|
|
shield = false;
|
|
}
|
|
|
|
partyHealth -= modifiedAttack;
|
|
print((Colours)attackColour + " enemy robot arm attacked for " + modifiedAttack);
|
|
print("Party health is now: " + partyHealth + " HP");
|
|
|
|
}
|
|
|
|
IEnumerator DisplayDamageText(int damage, Text display, Colours displayColour)
|
|
{
|
|
|
|
display.color = SetColour((int)displayColour);
|
|
display.text = damage.ToString();
|
|
|
|
// ATTACKS ARE BLOCK IF SHIELD IS UP
|
|
if((shield || enemyShield) &&
|
|
(displayColour != Colours.White
|
|
&& displayColour != Colours.Grey
|
|
&& displayColour != Colours.Black)) ShieldHit.SetActive(true);
|
|
|
|
if(weakPointHit)
|
|
{
|
|
weakPointHit = false;
|
|
WeakPointHit.SetActive(true);
|
|
}
|
|
|
|
yield return new WaitForSeconds(1);
|
|
|
|
ShieldHit.SetActive(false);
|
|
WeakPointHit.SetActive(false);
|
|
|
|
display.text = null;
|
|
|
|
}
|
|
|
|
IEnumerator AttackAnimEnemy()
|
|
{
|
|
// RUNS ATTACK ANIMATION OF ENEMY
|
|
Animator enemyAttackAnim = EnemyParts[2].transform.parent.GetComponent<Animator>();
|
|
enemyAttackAnim.SetTrigger("AttackTrigger");
|
|
|
|
yield return new WaitForSeconds(
|
|
enemyAttackAnim.GetCurrentAnimatorStateInfo(0).length
|
|
+enemyAttackAnim.GetCurrentAnimatorStateInfo(0).normalizedTime);
|
|
|
|
enemyAttackAnim.SetTrigger("AttackTrigger");
|
|
}
|
|
|
|
IEnumerator PreAttackBuffAnimEnemy()
|
|
{
|
|
// RUN "NON-ATTACK" BUFF ANIMATION FOR ENEMY IF ANTENNA IS BLACK SO ATTACKS ARE BUFFED
|
|
// BEFORE THE ENEMY DOES ITS ATTACK ANIMATION
|
|
if((Colours)EnemyPartsColours[0] == Colours.Black)
|
|
{
|
|
yield return StartCoroutine(HitEffectEnemy(EnemyPartsColours[0]));
|
|
}
|
|
}
|
|
|
|
IEnumerator PostAttackBuffAnimEnemy()
|
|
{
|
|
// RUN "NON-ATTACK" ABILITY ANIMATION FOR ENEMY IF ANTENNA IS WHITE OR GREY RESPECTIVELY
|
|
// NOW SO THESE ANIMATIONS APPEAR AFTER THE ENEMY IS DONE ATTACKING
|
|
if((Colours)EnemyPartsColours[0] == Colours.White)
|
|
{
|
|
enemyHealth += 2;
|
|
yield return StartCoroutine(HitEffectEnemy(EnemyPartsColours[0]));
|
|
StartCoroutine(DisplayDamageText(2, EnemyDamageText, (Colours)EnemyPartsColours[0]));
|
|
}
|
|
|
|
if((Colours)EnemyPartsColours[0] == Colours.Grey)
|
|
{
|
|
yield return StartCoroutine(HitEffectEnemy(EnemyPartsColours[0]));
|
|
}
|
|
}
|
|
|
|
void EnemyBuilder()
|
|
{
|
|
|
|
EnemyParts[0].transform.GetChild(0).GetComponent<SpriteRenderer>().sprite =
|
|
EnemyAntenna[Random.Range(0, EnemyAntenna.Length)];
|
|
|
|
EnemyPartsColours[0] = Random.Range(0, 15);
|
|
EnemyParts[0].transform.GetChild(0).GetComponent<SpriteRenderer>().color =
|
|
SetColour(EnemyPartsColours[0]);
|
|
|
|
EnemyParts[0].transform.GetChild(1).GetComponent<SpriteRenderer>().sprite =
|
|
Symbols[EnemyPartsColours[0]];
|
|
|
|
EnemyParts[0].transform.GetChild(1).GetComponent<SpriteRenderer>().color =
|
|
SetColour(EnemyPartsColours[0]);
|
|
|
|
EnemyParts[1].transform.GetChild(0).GetComponent<SpriteRenderer>().sprite =
|
|
EnemyHead[Random.Range(0, EnemyHead.Length)];
|
|
|
|
EnemyPartsColours[1] = Random.Range(0, 15);
|
|
EnemyParts[1].transform.GetChild(0).GetComponent<SpriteRenderer>().color =
|
|
SetColour(EnemyPartsColours[1]);
|
|
|
|
EnemyParts[1].transform.GetChild(1).GetComponent<SpriteRenderer>().sprite =
|
|
Symbols[EnemyPartsColours[1]];
|
|
|
|
EnemyParts[1].transform.GetChild(1).GetComponent<SpriteRenderer>().color =
|
|
SetColour(EnemyPartsColours[1]);
|
|
|
|
EnemyParts[2].transform.GetChild(0).GetComponent<SpriteRenderer>().sprite =
|
|
EnemyBody[Random.Range(0, EnemyBody.Length)];
|
|
|
|
EnemyPartsColours[2] = Random.Range(0, 12);
|
|
EnemyParts[2].transform.GetChild(0).GetComponent<SpriteRenderer>().color =
|
|
SetColour(EnemyPartsColours[2]);
|
|
|
|
EnemyParts[2].transform.GetChild(1).GetComponent<SpriteRenderer>().sprite =
|
|
Symbols[EnemyPartsColours[2]];
|
|
|
|
EnemyParts[2].transform.GetChild(1).GetComponent<SpriteRenderer>().color =
|
|
SetColour(EnemyPartsColours[2]);
|
|
|
|
EnemyParts[2].transform.GetChild(2).GetComponent<SpriteRenderer>().sprite =
|
|
Symbols[EnemyPartsColours[2]];
|
|
|
|
EnemyParts[2].transform.GetChild(2).GetComponent<SpriteRenderer>().color =
|
|
SetColour(EnemyPartsColours[2]);
|
|
|
|
EnemyParts[3].transform.GetChild(0).GetComponent<SpriteRenderer>().sprite =
|
|
EnemyArm[Random.Range(0, EnemyArm.Length)];
|
|
|
|
EnemyPartsColours[3] = Random.Range(0, 12);
|
|
EnemyParts[3].transform.GetChild(0).GetComponent<SpriteRenderer>().color =
|
|
SetColour(EnemyPartsColours[3]);
|
|
|
|
EnemyParts[3].transform.GetChild(1).GetComponent<SpriteRenderer>().sprite =
|
|
Symbols[EnemyPartsColours[3]];
|
|
|
|
EnemyParts[3].transform.GetChild(1).GetComponent<SpriteRenderer>().color =
|
|
SetColour(EnemyPartsColours[3]);
|
|
|
|
EnemyParts[4].transform.GetChild(0).GetComponent<SpriteRenderer>().sprite =
|
|
EnemyArm[Random.Range(0, EnemyArm.Length)];
|
|
|
|
EnemyPartsColours[4] = Random.Range(0, 12);
|
|
EnemyParts[4].transform.GetChild(0).GetComponent<SpriteRenderer>().color =
|
|
SetColour(EnemyPartsColours[4]);
|
|
|
|
EnemyParts[4].transform.GetChild(1).GetComponent<SpriteRenderer>().sprite =
|
|
Symbols[EnemyPartsColours[4]];
|
|
|
|
EnemyParts[4].transform.GetChild(1).GetComponent<SpriteRenderer>().color =
|
|
SetColour(EnemyPartsColours[4]);
|
|
|
|
EnemyParts[5].transform.GetChild(0).GetComponent<SpriteRenderer>().sprite =
|
|
EnemyChest[Random.Range(0, EnemyChest.Length)];
|
|
|
|
EnemyPartsColours[5] = EnemyKillSequence[0];
|
|
EnemyParts[5].transform.GetChild(0).GetComponent<SpriteRenderer>().color =
|
|
SetColour(EnemyPartsColours[5]);
|
|
EnemyKillSequence[0] = EnemyPartsColours[5];
|
|
|
|
EnemyParts[5].transform.GetChild(1).GetComponent<SpriteRenderer>().sprite =
|
|
Symbols[EnemyPartsColours[5]];
|
|
|
|
EnemyParts[5].transform.GetChild(1).GetComponent<SpriteRenderer>().color =
|
|
SetColour(EnemyPartsColours[5]);
|
|
|
|
EnemyParts[6].transform.GetChild(0).GetComponent<SpriteRenderer>().sprite =
|
|
EnemyWeakness[Random.Range(0, EnemyWeakness.Length)];
|
|
|
|
EnemyPartsColours[6] = EnemyKillSequence[1];
|
|
EnemyParts[6].transform.GetChild(0).GetComponent<SpriteRenderer>().color =
|
|
SetColour(EnemyPartsColours[6]);
|
|
EnemyKillSequence[1] = EnemyPartsColours[6];
|
|
|
|
EnemyParts[6].transform.GetChild(1).GetComponent<SpriteRenderer>().sprite =
|
|
Symbols[EnemyPartsColours[6]];
|
|
|
|
EnemyParts[6].transform.GetChild(1).GetComponent<SpriteRenderer>().color =
|
|
SetColour(EnemyPartsColours[6]);
|
|
|
|
}
|
|
|
|
int ColourCompare(Colours AttackColour, Colours DefendColour)
|
|
{
|
|
|
|
switch(AttackColour)
|
|
{
|
|
// WHITE, GREY AND BLACK ARE NEITHER WEAK NOR STRONG AGAINST
|
|
// DEFENDING COLOUR SINCE THEY ARE "NON-ATTACK" COLOURS
|
|
case Colours.White:
|
|
return 0;
|
|
case Colours.Grey:
|
|
return 0;
|
|
case Colours.Black:
|
|
return 0;
|
|
case Colours.Red:
|
|
// DEFEND COLOUR HAS STRONG DEFENSE IF ATTACK COLOUR IS SAME
|
|
if(DefendColour == AttackColour)
|
|
{
|
|
return -2;
|
|
}
|
|
// DEFEND COLOUR HAS GOOD DEFENSE IF ATTACK COLOUR IS AN ADJACENT COLOUR
|
|
else if (DefendColour == (Colours)(((int)AttackColour-1)%12) ||
|
|
DefendColour == (Colours)(((int)AttackColour+1)%12))
|
|
{
|
|
return -1;
|
|
}
|
|
// DEFEND COLOUR HAS NO DEFENSE IF ATTACK COLOUR IS OPPOSITE
|
|
else if (DefendColour == (Colours)(((int)AttackColour+6)%12))
|
|
{
|
|
return 2;
|
|
}
|
|
// DEFEND COLOUR HAS WEAK DEFENSE IF ATTACK COLOUR IS ADJACENT TO OPPOSITE COLOUR
|
|
else if (DefendColour == (Colours)(((int)AttackColour+5)%12) ||
|
|
DefendColour == (Colours)(((int)AttackColour+7)%12))
|
|
{
|
|
return 1;
|
|
}
|
|
break;
|
|
case Colours.Brown:
|
|
// DEFEND COLOUR HAS STRONG DEFENSE IF ATTACK COLOUR IS SAME
|
|
if(DefendColour == AttackColour)
|
|
{
|
|
return -2;
|
|
}
|
|
// DEFEND COLOUR HAS GOOD DEFENSE IF ATTACK COLOUR IS AN ADJACENT COLOUR
|
|
else if (DefendColour == (Colours)(((int)AttackColour-1)%12) ||
|
|
DefendColour == (Colours)(((int)AttackColour+1)%12))
|
|
{
|
|
return -1;
|
|
}
|
|
// DEFEND COLOUR HAS NO DEFENSE IF ATTACK COLOUR IS OPPOSITE
|
|
else if (DefendColour == (Colours)(((int)AttackColour+6)%12))
|
|
{
|
|
return 2;
|
|
}
|
|
// DEFEND COLOUR HAS WEAK DEFENSE IF ATTACK COLOUR IS ADJACENT TO OPPOSITE COLOUR
|
|
else if (DefendColour == (Colours)(((int)AttackColour+5)%12) ||
|
|
DefendColour == (Colours)(((int)AttackColour+7)%12))
|
|
{
|
|
return 1;
|
|
}
|
|
break;
|
|
case Colours.Orange:
|
|
// DEFEND COLOUR HAS STRONG DEFENSE IF ATTACK COLOUR IS SAME
|
|
if(DefendColour == AttackColour)
|
|
{
|
|
return -2;
|
|
}
|
|
// DEFEND COLOUR HAS GOOD DEFENSE IF ATTACK COLOUR IS AN ADJACENT COLOUR
|
|
else if (DefendColour == (Colours)(((int)AttackColour-1)%12) ||
|
|
DefendColour == (Colours)(((int)AttackColour+1)%12))
|
|
{
|
|
return -1;
|
|
}
|
|
// DEFEND COLOUR HAS NO DEFENSE IF ATTACK COLOUR IS OPPOSITE
|
|
else if (DefendColour == (Colours)(((int)AttackColour+6)%12))
|
|
{
|
|
return 2;
|
|
}
|
|
// DEFEND COLOUR HAS WEAK DEFENSE IF ATTACK COLOUR IS ADJACENT TO OPPOSITE COLOUR
|
|
else if (DefendColour == (Colours)(((int)AttackColour+5)%12) ||
|
|
DefendColour == (Colours)(((int)AttackColour+7)%12))
|
|
{
|
|
return 1;
|
|
}
|
|
break;
|
|
case Colours.Amber:
|
|
// DEFEND COLOUR HAS STRONG DEFENSE IF ATTACK COLOUR IS SAME
|
|
if(DefendColour == AttackColour)
|
|
{
|
|
return -2;
|
|
}
|
|
// DEFEND COLOUR HAS GOOD DEFENSE IF ATTACK COLOUR IS AN ADJACENT COLOUR
|
|
else if (DefendColour == (Colours)(((int)AttackColour-1)%12) ||
|
|
DefendColour == (Colours)(((int)AttackColour+1)%12))
|
|
{
|
|
return -1;
|
|
}
|
|
// DEFEND COLOUR HAS NO DEFENSE IF ATTACK COLOUR IS OPPOSITE
|
|
else if (DefendColour == (Colours)(((int)AttackColour+6)%12))
|
|
{
|
|
return 2;
|
|
}
|
|
// DEFEND COLOUR HAS WEAK DEFENSE IF ATTACK COLOUR IS ADJACENT TO OPPOSITE COLOUR
|
|
else if (DefendColour == (Colours)(((int)AttackColour+5)%12) ||
|
|
DefendColour == (Colours)(((int)AttackColour+7)%12))
|
|
{
|
|
return 1;
|
|
}
|
|
break;
|
|
case Colours.Yellow:
|
|
// DEFEND COLOUR HAS STRONG DEFENSE IF ATTACK COLOUR IS SAME
|
|
if(DefendColour == AttackColour)
|
|
{
|
|
return -2;
|
|
}
|
|
// DEFEND COLOUR HAS GOOD DEFENSE IF ATTACK COLOUR IS AN ADJACENT COLOUR
|
|
else if (DefendColour == (Colours)(((int)AttackColour-1)%12) ||
|
|
DefendColour == (Colours)(((int)AttackColour+1)%12))
|
|
{
|
|
return -1;
|
|
}
|
|
// DEFEND COLOUR HAS NO DEFENSE IF ATTACK COLOUR IS OPPOSITE
|
|
else if (DefendColour == (Colours)(((int)AttackColour+6)%12))
|
|
{
|
|
return 2;
|
|
}
|
|
// DEFEND COLOUR HAS WEAK DEFENSE IF ATTACK COLOUR IS ADJACENT TO OPPOSITE COLOUR
|
|
else if (DefendColour == (Colours)(((int)AttackColour+5)%12) ||
|
|
DefendColour == (Colours)(((int)AttackColour+7)%12))
|
|
{
|
|
return 1;
|
|
}
|
|
break;
|
|
case Colours.Lime:
|
|
// DEFEND COLOUR HAS STRONG DEFENSE IF ATTACK COLOUR IS SAME
|
|
if(DefendColour == AttackColour)
|
|
{
|
|
return -2;
|
|
}
|
|
// DEFEND COLOUR HAS GOOD DEFENSE IF ATTACK COLOUR IS AN ADJACENT COLOUR
|
|
else if (DefendColour == (Colours)(((int)AttackColour-1)%12) ||
|
|
DefendColour == (Colours)(((int)AttackColour+1)%12))
|
|
{
|
|
return -1;
|
|
}
|
|
// DEFEND COLOUR HAS NO DEFENSE IF ATTACK COLOUR IS OPPOSITE
|
|
else if (DefendColour == (Colours)(((int)AttackColour+6)%12))
|
|
{
|
|
return 2;
|
|
}
|
|
// DEFEND COLOUR HAS WEAK DEFENSE IF ATTACK COLOUR IS ADJACENT TO OPPOSITE COLOUR
|
|
else if (DefendColour == (Colours)(((int)AttackColour+5)%12) ||
|
|
DefendColour == (Colours)(((int)AttackColour+7)%12))
|
|
{
|
|
return 1;
|
|
}
|
|
break;
|
|
case Colours.Green:
|
|
// DEFEND COLOUR HAS STRONG DEFENSE IF ATTACK COLOUR IS SAME
|
|
if(DefendColour == AttackColour)
|
|
{
|
|
return -2;
|
|
}
|
|
// DEFEND COLOUR HAS GOOD DEFENSE IF ATTACK COLOUR IS AN ADJACENT COLOUR
|
|
else if (DefendColour == (Colours)(((int)AttackColour-1)%12) ||
|
|
DefendColour == (Colours)(((int)AttackColour+1)%12))
|
|
{
|
|
return -1;
|
|
}
|
|
// DEFEND COLOUR HAS NO DEFENSE IF ATTACK COLOUR IS OPPOSITE
|
|
else if (DefendColour == (Colours)(((int)AttackColour+6)%12))
|
|
{
|
|
return 2;
|
|
}
|
|
// DEFEND COLOUR HAS WEAK DEFENSE IF ATTACK COLOUR IS ADJACENT TO OPPOSITE COLOUR
|
|
else if (DefendColour == (Colours)(((int)AttackColour+5)%12) ||
|
|
DefendColour == (Colours)(((int)AttackColour+7)%12))
|
|
{
|
|
return 1;
|
|
}
|
|
break;
|
|
case Colours.Cyan:
|
|
// DEFEND COLOUR HAS STRONG DEFENSE IF ATTACK COLOUR IS SAME
|
|
if(DefendColour == AttackColour)
|
|
{
|
|
return -2;
|
|
}
|
|
// DEFEND COLOUR HAS GOOD DEFENSE IF ATTACK COLOUR IS AN ADJACENT COLOUR
|
|
else if (DefendColour == (Colours)(((int)AttackColour-1)%12) ||
|
|
DefendColour == (Colours)(((int)AttackColour+1)%12))
|
|
{
|
|
return -1;
|
|
}
|
|
// DEFEND COLOUR HAS NO DEFENSE IF ATTACK COLOUR IS OPPOSITE
|
|
else if (DefendColour == (Colours)(((int)AttackColour+6)%12))
|
|
{
|
|
return 2;
|
|
}
|
|
// DEFEND COLOUR HAS WEAK DEFENSE IF ATTACK COLOUR IS ADJACENT TO OPPOSITE COLOUR
|
|
else if (DefendColour == (Colours)(((int)AttackColour+5)%12) ||
|
|
DefendColour == (Colours)(((int)AttackColour+7)%12))
|
|
{
|
|
return 1;
|
|
}
|
|
break;
|
|
case Colours.Blue:
|
|
// DEFEND COLOUR HAS STRONG DEFENSE IF ATTACK COLOUR IS SAME
|
|
if(DefendColour == AttackColour)
|
|
{
|
|
return -2;
|
|
}
|
|
// DEFEND COLOUR HAS GOOD DEFENSE IF ATTACK COLOUR IS AN ADJACENT COLOUR
|
|
else if (DefendColour == (Colours)(((int)AttackColour-1)%12) ||
|
|
DefendColour == (Colours)(((int)AttackColour+1)%12))
|
|
{
|
|
return -1;
|
|
}
|
|
// DEFEND COLOUR HAS NO DEFENSE IF ATTACK COLOUR IS OPPOSITE
|
|
else if (DefendColour == (Colours)(((int)AttackColour+6)%12))
|
|
{
|
|
return 2;
|
|
}
|
|
// DEFEND COLOUR HAS WEAK DEFENSE IF ATTACK COLOUR IS ADJACENT TO OPPOSITE COLOUR
|
|
else if (DefendColour == (Colours)(((int)AttackColour+5)%12) ||
|
|
DefendColour == (Colours)(((int)AttackColour+7)%12))
|
|
{
|
|
return 1;
|
|
}
|
|
break;
|
|
case Colours.Indigo:
|
|
// DEFEND COLOUR HAS STRONG DEFENSE IF ATTACK COLOUR IS SAME
|
|
if(DefendColour == AttackColour)
|
|
{
|
|
return -2;
|
|
}
|
|
// DEFEND COLOUR HAS GOOD DEFENSE IF ATTACK COLOUR IS AN ADJACENT COLOUR
|
|
else if (DefendColour == (Colours)(((int)AttackColour-1)%12) ||
|
|
DefendColour == (Colours)(((int)AttackColour+1)%12))
|
|
{
|
|
return -1;
|
|
}
|
|
// DEFEND COLOUR HAS NO DEFENSE IF ATTACK COLOUR IS OPPOSITE
|
|
else if (DefendColour == (Colours)(((int)AttackColour+6)%12))
|
|
{
|
|
return 2;
|
|
}
|
|
// DEFEND COLOUR HAS WEAK DEFENSE IF ATTACK COLOUR IS ADJACENT TO OPPOSITE COLOUR
|
|
else if (DefendColour == (Colours)(((int)AttackColour+5)%12) ||
|
|
DefendColour == (Colours)(((int)AttackColour+7)%12))
|
|
{
|
|
return 1;
|
|
}
|
|
break;
|
|
case Colours.Purple:
|
|
// DEFEND COLOUR HAS STRONG DEFENSE IF ATTACK COLOUR IS SAME
|
|
if(DefendColour == AttackColour)
|
|
{
|
|
return -2;
|
|
}
|
|
// DEFEND COLOUR HAS GOOD DEFENSE IF ATTACK COLOUR IS AN ADJACENT COLOUR
|
|
else if (DefendColour == (Colours)(((int)AttackColour-1)%12) ||
|
|
DefendColour == (Colours)(((int)AttackColour+1)%12))
|
|
{
|
|
return -1;
|
|
}
|
|
// DEFEND COLOUR HAS NO DEFENSE IF ATTACK COLOUR IS OPPOSITE
|
|
else if (DefendColour == (Colours)(((int)AttackColour+6)%12))
|
|
{
|
|
return 2;
|
|
}
|
|
// DEFEND COLOUR HAS WEAK DEFENSE IF ATTACK COLOUR IS ADJACENT TO OPPOSITE COLOUR
|
|
else if (DefendColour == (Colours)(((int)AttackColour+5)%12) ||
|
|
DefendColour == (Colours)(((int)AttackColour+7)%12))
|
|
{
|
|
return 1;
|
|
}
|
|
break;
|
|
case Colours.Pink:
|
|
// DEFEND COLOUR HAS STRONG DEFENSE IF ATTACK COLOUR IS SAME
|
|
if(DefendColour == AttackColour)
|
|
{
|
|
return -2;
|
|
}
|
|
// DEFEND COLOUR HAS GOOD DEFENSE IF ATTACK COLOUR IS AN ADJACENT COLOUR
|
|
else if (DefendColour == (Colours)(((int)AttackColour-1)%12) ||
|
|
DefendColour == (Colours)(((int)AttackColour+1)%12))
|
|
{
|
|
return -1;
|
|
}
|
|
// DEFEND COLOUR HAS NO DEFENSE IF ATTACK COLOUR IS OPPOSITE
|
|
else if (DefendColour == (Colours)(((int)AttackColour+6)%12))
|
|
{
|
|
return 2;
|
|
}
|
|
// DEFEND COLOUR HAS WEAK DEFENSE IF ATTACK COLOUR IS ADJACENT TO OPPOSITE COLOUR
|
|
else if (DefendColour == (Colours)(((int)AttackColour+5)%12) ||
|
|
DefendColour == (Colours)(((int)AttackColour+7)%12))
|
|
{
|
|
return 1;
|
|
}
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
|
|
// IF AN ATTACKING COLOUR DOESN'T MATCH WITH ANY OF THE ABOVE PARAMETERS
|
|
// IT IS NEITHER WEAK NOR STRONG AGAINST THE DEFENDING COLOUR
|
|
return 0;
|
|
}
|
|
|
|
|
|
Color SetColour(int robotColour)
|
|
{
|
|
Color colourValue = new Color(1, 1, 1, 1);
|
|
|
|
switch((Colours)robotColour)
|
|
{
|
|
case Colours.Red:
|
|
colourValue
|
|
= new Color(1, 0, 0, 1);
|
|
break;
|
|
case Colours.Yellow:
|
|
colourValue
|
|
= new Color(1, 1, 0, 1);
|
|
break;
|
|
case Colours.Blue:
|
|
colourValue
|
|
= new Color(0, 0, 1, 1);
|
|
break;
|
|
case Colours.Grey:
|
|
colourValue
|
|
= new Color(0.5f, 0.5f, 0.5f, 1);
|
|
break;
|
|
case Colours.Orange:
|
|
colourValue
|
|
= new Color(1, 0.5f, 0, 1);
|
|
break;
|
|
case Colours.Green:
|
|
colourValue
|
|
= new Color(0, 0.8f, 0, 1);
|
|
break;
|
|
case Colours.Purple:
|
|
colourValue
|
|
= new Color(0.5f, 0, 1, 1);
|
|
break;
|
|
case Colours.Black:
|
|
colourValue
|
|
= new Color(0.125f, 0.125f, 0.125f, 1);
|
|
break;
|
|
case Colours.White:
|
|
colourValue
|
|
= new Color(1, 1, 1, 1);
|
|
break;
|
|
case Colours.Pink:
|
|
colourValue
|
|
= new Color(1, 0, 0.5f, 1);
|
|
break;
|
|
case Colours.Brown:
|
|
colourValue
|
|
= new Color(0.4f, 0.2f, 0, 1);
|
|
break;
|
|
case Colours.Lime:
|
|
colourValue
|
|
= new Color(0.5f, 1, 0, 1);
|
|
break;
|
|
case Colours.Cyan:
|
|
colourValue
|
|
= new Color(0, 1, 1, 1);
|
|
break;
|
|
case Colours.Indigo:
|
|
colourValue
|
|
= new Color(0.2f, 0, 1, 1);
|
|
break;
|
|
case Colours.Amber:
|
|
colourValue
|
|
= new Color(1, 0.87f, 0, 1);
|
|
break;
|
|
default:
|
|
colourValue
|
|
= new Color(1, 1, 1, 1);
|
|
break;
|
|
}
|
|
|
|
return colourValue;
|
|
|
|
}
|
|
|
|
}
|