Can I ignore "You are trying to create a MonoBehaviour using the 'new' keyword"?

Xhitman · Sep 3, 2018

I get many warning on

Code (CSharp):

public List<Transform> AllProjectilesInScene = new List<Transform>();

public List<Weapon> weapon = new List<Weapon>();

but I don't find any error when run the game. ?

Fido789 · Sep 3, 2018

That error probably belongs to something else, you are not creating any MonoBehaviours in the code above.

Xhitman · Sep 3, 2018

I get the warning when I start Unity. No need to run the game.
More details:

You are trying to create a MonoBehaviour using the 'new' keyword. This is not allowed. MonoBehaviours can only be added using AddComponent(). Alternatively, your script can inherit from ScriptableObject or no base class at all
UnityEngine.MonoBehaviour:.ctor()
RobotAI:.ctor() (at Assets/BattleMap/RobotAI.cs:200)
BattleManager:.ctor() (at Assets/BattleMap/BattleManager.cs:87)

Code (CSharp):

using UnityEngine;

using System;

using System.Collections.Generic;

using System.Collections;

using UnityEngine.AI;

using System.Linq;

using Random = UnityEngine.Random;

public class RobotAI : MonoBehaviour {

AssetBundle assetBundle;

// what is the list index in the Data

public int robotIndex;

public float moveDistanceMax;

public Transform target ;

public Transform targetCATRoot;

Vector3 targetOriginalPosition;

Vector3 robotOriginalPosition;

Quaternion robotOriginalRotation;

[SerializeField] Animator animator;

[SerializeField] GameObject robotExplosion;

string robotAnimationIdleClipName;

Rigidbody robotRigidBody;

NavMeshAgent navAgent;

Vector3 destination;

public Transform placeHolder;

public Transform catRoot;

Vector3 catLocalPositionOriginal;

// Need to know what animiation this robot is playing now

// reason is: how to find out jab vs jab ? when melee weaponeffect dummy hit target, we dont know what target robot is doing.

// And what target robot doing affect the reaction animation choice

public RobotAnimation currentAnimation;

// Death

enum DeathMode {Prepare, Animation, Explosion}

DeathMode deathMode = DeathMode.Prepare;

// For rocket punch hand and digit transfer

// public Transform handLCAT, handRCAT;

//------------------- Fast refer to the body parts

public Transform head;

public Transform eye;

public Transform earL;

public Transform earR;

public Transform mouth;

public Transform helm;

public Transform helmTop;

public Transform neck;

public Transform chest;

public Transform back;

public Transform abdomen;

public Transform pelvis;

public Transform shoulderL;

public Transform shoulderR;

public Transform upperArmL;

public Transform upperArmR;

public Transform foreArmL;

public Transform foreArmR;

public Transform handL;

public Transform handR;

// for robotEditor, BattleManager dont use them

public Transform digitL;

public Transform digitR;

public List<Transform> digitLList = new List<Transform>();

public List<Transform> digitRList = new List<Transform>();

public Transform thighL;

public Transform thighR;

public Transform calfL;

public Transform calfR;

public Transform footL;

public Transform footR;

// Inverse Kinematic target for ForeArm

public InverseKinematics IKForeArmL;

public InverseKinematics IKForeArmR;

//----------------------Skill--------------------------

public List<Transform> assistAttackMember = new List<Transform>();

// total repeat attack time

public int repeatAttack = 0;

//-------------Extra Weapon

// 1. Use this extra weapon if they are not null

// 2. if target is out of this extra weapon range, use any weapon that robot animation is standby

// how many attack used before remove weapon from hand?

public int ExtraWpRUseMax;

public int ExtraWpRUseCounter;

public int ExtraWpLUseMax;

public int ExtraWpLUseCounter;

public Transform ExtraWpR;

public Transform ExtraWpL;

//===============================================================

[SerializeField]

GameObject meleeHandDetectDummy;

[SerializeField]

GameObject meleeKickDetectDummy;

// refer to the dummy generated in scene

GameObject meleeDetectDummy;

enum MeleeDetectDummyLocation {HandL,HandR,FootL,FootR }

// decide need to move the robot or not while playing melee animation

bool meleeMove = false; // check if this is melee type animation

public bool meleeMoveStart = false; // check if now is the melee animation that can start moving transform. make it public to let battleManager know this robot is moving

bool meleeMoveStartAtIdle = false; // transform start moving when robot animation start, or when robot animation Idle start

public bool meleeHit = false; // access by weapon manager, check hit target or not, to stop moving transform

public Vector3 meleeDestination; // to finialize the robot position, need to record it before target and robot move (the location where the robot hit target may not be the middle of Hex)

float meleeMoveDelta=1f; //1 for 1 hex distance, 2 for 2 hex distance

// the point the robot move to when punch by Jab

//public Vector3 attackedByJabDestinationSelf;

public Vector3 attackedByJabDestinationWorld;

const float attackedByJabMoveSpeed = 50;

//===============================Super Electrical Drill Path

[SerializeField] GameObject SEDMovePath1Prefab;

GameObject SEDMovePathAnimation;

// path 1: Start point to path 1 point, attach robot on path dummy1

// path 2: move to target freely by script, remove path dummy

// path 3: when hit target, attach robot on path dummy2

// path 4: Return robot to destination point on ground

// path 7: rotate to origional rotation

// path 8: fall to ground animation

// path 9: for non robot unit, keep rotating for 2 sec at target, then go to 7

public enum SEDMoveModeStage {Path1Setup, Path1, Path2, Path3Setup, Path3, Path4, Path5, Path6, Path7, Path8, Path9}

public SEDMoveModeStage SEDMoveMode;

public float SEDPath9Timer;

int SEDCATRotateSpeed = 5000;

[SerializeField]

GameObject emptyDummyPrefab; // an alternative solution for robot to follow another object position/rotation when set parent is impossible

GameObject emptyDummy;

//==============Sword

// Three speical issue:

// 1. Sword attack: prepare sword, move forward, sword hit, where sword hit cannot start from standby, so the RA0, RA1 system wont work

// 2. Total two weapon dummy: PA0 is the enemy detection dummy, PA1 is the sword hit dummy

// 3. Robot animation and part animation parelle, RAPAParalle true.

// (robot take sword and move forward same time is not an option now)

enum MeleeSubMode {Prepare, MoveForward, Attack, Return}

MeleeSubMode meleeSubMode = MeleeSubMode.Prepare;

// ========Shield

// check target projectile and standby state

// Need to start checking after target attack, otherwise robot will end shield animation immediately

enum ShieldSubMode {WaitTargetAttack, Defending}

ShieldSubMode shieldSubMode = ShieldSubMode.WaitTargetAttack;

// -------------------------------------------

// this collider list is for projectile physic ignore in weapon management, because projectile can hit robot itself if not ignore

public List<Collider> robotBodyPartColliderList = new List<Collider>();

public RobotActionMode actionMode = RobotActionMode.Idle;

// assign from enemy weapon effect manager, it decide what melee animation this robot should take when being attacked

public RobotReactionToAttack robotReactionToAttack = RobotReactionToAttack.Null;

enum MeleeReturnSubMode { Setup, Waiting }

MeleeReturnSubMode meleeReturnSubMode = MeleeReturnSubMode.Setup;

public enum ReactionToAttackSubMode {ReactionAnimation1, ReactionAnimationWaiting1, ReactionAnimation2, ReactionAnimationWaiting2}

public ReactionToAttackSubMode reactionToAttackSubMode = RobotAI.ReactionToAttackSubMode.ReactionAnimation1;

public int weaponID =0 ; //trace which weapon is attacking now

public int weaponIDExtraWpR = 99; // if hand have weapon, which weapon it is in the weapon list?

public int weaponIDExtraWpL = 99; // 99 = not equip

// the projectiles list in the weapon class is not enough for checking

// for shield defend case. We need to know all projectiles are destoryed before cancel shield defend.

// the original NoprojectileInscene() cannot check sub-projectile, such as machine gun.

// The current weapon system work fine, robot cancel animation when projectiles are destoryed.

// So we dont modifiy it. We add another list that include sub projectiles for defend checking

public List<Transform> AllProjectilesInScene = new List<Transform>();

public List<Weapon> weapon = new List<Weapon>();

Quaternion deltaRot;

Vector3 test;

Vector3 startRot;

//---------

void Awake()

{

// assetBundle = GameObject.Find("Canvas").GetComponent<BattleManager>().assetBundle;

catLocalPositionOriginal = catRoot.localPosition;

robotRigidBody = GetComponent<Rigidbody>();

navAgent = GetComponent<NavMeshAgent>();

IKForeArmL = catRoot.GetComponent<RobotCATStructure>().upperArmL.parent.GetComponent<InverseKinematics>();

IKForeArmR = catRoot.GetComponent<RobotCATStructure>().upperArmR.parent.GetComponent<InverseKinematics>();

// health = Data.robotMaxHealth;

}

// Import weapon from all robot parts, should only be called by Battle Manager

public void ImportWeaponData()

{

Transform[] bodyParts;

bodyParts = GetComponentsInChildren<Transform>();

// First, generate weapon list

for (int i = 0; i < bodyParts.Length; i++)

{

if (bodyParts[i].GetComponent<RobotBodyPartSpec>() != null && bodyParts[i].GetComponent<RobotBodyPartSpec>().weapon.type!= WeaponType.Null)

{

weapon.Add(bodyParts[i].GetComponent<RobotBodyPartSpec>().weapon);

}

}

// Remove combo weapon part that is not a pair

for(int i = weapon.Count-1;i>=0 ;i--)

{

if (weapon[i].comboRBP != ComboRobotBodyPart.Null && !ComboRBPExist(i))

weapon.RemoveAt(i);

}

// sort the list by range

weapon = weapon.OrderBy(wp => wp.range).ToList();

}

// Check if the required combo part exist

// if no, return false; if yes, check if pair exist

bool ComboRBPExist(int wpID)

{

string fal = foreArmL.name.Replace("L", ""); ;

string far = foreArmR.name.Replace("R", ""); ;

if (weapon[wpID].parentID == ParentID.RobotForeArmL && weapon[wpID].comboRBP.ToString() == far)

return true;

else if (weapon[wpID].parentID == ParentID.RobotForeArmR && weapon[wpID].comboRBP.ToString() == fal)

return true;

else

return false;

}

// Set physic ignore for each colliders on Robot, for example, upperarm collider wont trigger forearm collider

public void IgnoreRobotAllColliders()

{

for (int k = 0; k < robotBodyPartColliderList.Count; k++)

for (int i=0; i<robotBodyPartColliderList.Count;i++)

Physics.IgnoreCollision(robotBodyPartColliderList[k], robotBodyPartColliderList[i]);

}

void FixedUpdate()

{

Vector3 direction;

// Standard flow: robot animation -> part animation -> Wait weapon Dummy hit -> robot animation -> part animation -> Wait weapon Dummy hit -> end

// RA0 ->PA0 ->RA1 -> PA1 -> End

// Special Flow: For the case that there are too many little animation clip need to match between part and robot animation, we match the animation in 3DS max, and start both animation same time.

// So, no matching need to be handled in Unity

switch (actionMode)

{

case RobotActionMode.Idle:

// nav agent should be enable when idle , it may be turn off by melee attack

// if (!navAgent.enabled && Data.playerRobot[robotIndex].map != Map.RBLauncher)

// navAgent.enabled = true;

// possible bug that running in RA003 loop

if (animator.GetCurrentAnimatorStateInfo(0).IsName("RA003") && !animator.GetBool("Idle End"))

{

// animator.SetTrigger("Idle End");

}

break;

case RobotActionMode.RA0:

// transform start to move when animation start

// or transform start to move when animation Idle start

// decide at robotanimationstart()

if (meleeMove && !meleeMoveStart)

{

if (!meleeMoveStartAtIdle && animator.GetCurrentAnimatorStateInfo(0).IsName(weapon[weaponID].RA0.ToString()))

meleeMoveStart = true;

else if (meleeMoveStartAtIdle && animator.GetCurrentAnimatorStateInfo(0).IsName(robotAnimationIdleClipName))

meleeMoveStart = true;

}

// Fixedupate run faster than animation, so need to make sure animation is idle

if (meleeMoveStart && !meleeHit)

{

if (targetCATRoot.position.y > 10)

direction = new Vector3(targetCATRoot.position.x, 0, targetCATRoot.position.z) - catRoot.position;

else

direction = targetCATRoot.position - catRoot.position;

transform.Translate(direction.normalized * meleeMoveDelta, Space.World);

// Stop moving

if (direction.magnitude < 1)

{

Destroy(meleeDetectDummy);

meleeMoveStart = false;

meleeMove = false;

}

}

// robot animation finish, now start PartAnimation

else if (animator.GetCurrentAnimatorStateInfo(0).IsName(robotAnimationIdleClipName))

{

meleeMove = false;

meleeHit = false;

// Check for arm IK target

SetArmIKTarge(true);

// 1. PA after RA

// 2. No PA after RA

// 2a. Melee

// 2b. NonMelee

if (weapon[weaponID].PA0)

RobotBodyPartAnimationTurnOn(weaponID, false);

else if (weapon[weaponID].type != WeaponType.SideKick01 && weapon[weaponID].type != WeaponType.Jab)

{

// 2b.

// for rocket punch that do not have PA, need to pass fingers to forearm before firing

if (weapon[weaponID].digitsRoot != null)

FingersToBodyPartCAT(weaponID);

RobotBodyPartWeaponEffect(weapon[weaponID].projectile0);

actionMode = RobotActionMode.WE0;

}

else

{

// 2a.

// Do meleeReturn need for this animation?

if (weapon[weaponID].type == WeaponType.Jab || weapon[weaponID].type == WeaponType.SideKick01)

actionMode = RobotActionMode.MeleeReturn;

else

{

// RA, and No PA, meleemove stop or hit by melee,

// so this part is for melee only

weapon[weaponID].projectile0.projectileInScene.Clear();

transform.position = meleeDestination;

// forbid the case that other robot set action mode to reaction, but this robot set itself to idle at the same frame

if (actionMode != RobotActionMode.ReactionToAttack)

{

ReturnIdle();

}

}

}

}

break;

case RobotActionMode.PAS0:

if (weapon[weaponID].animator.GetCurrentAnimatorStateInfo(0).IsName("PAI0"))

{

RobotBodyPartWeaponEffect(weapon[weaponID].projectile0);

actionMode = RobotActionMode.WE0;

}

break;

case RobotActionMode.WE0:

// Waiting Weapon Effect Finish

// 3 cases:

// 1. No RA, No PA, (no need to put in WE1)

// 2. No RA, PA

// 3. RA, PA

if (NoWeaponProjectileInScene())

{

SetArmIKTarge(false);

// end part animation

if (weapon[weaponID].PA0)

weapon[weaponID].animator.SetTrigger("PAE0");

// forbid the case that other robot set action mode to reaction, but this robot set itself to idle at the same frame

if (actionMode != RobotActionMode.ReactionToAttack)

{

if (weapon[weaponID].RA0 != RobotAnimation.Null)

{

animator.SetTrigger("Idle End"); // end robot animation

}

if (weapon[weaponID].RA1 == RobotAnimation.Null)

{

ReturnIdle();

}

else

{

StartRobotAnimation(weapon[weaponID].RA1);

actionMode = RobotActionMode.RA1;

}

// Extra Weapon

if (weapon[weaponID].extraWeaponSpec != null)

{

if (weapon[weaponID].parentID == ParentID.RobotHandL || weapon[weaponID].parentID == ParentID.RobotForeArmL)

{

ExtraWpLUseCounter++;

if (ExtraWpLUseCounter >= ExtraWpLUseMax)

{

weapon[weaponID].extraWeaponSpec.returnWeapon = true;

// set weapon timer, count start when weapon return

weapon[weaponID].coolDownTimer = Data.currentTurn[(int)Data.currentMap];

}

}

else if (weapon[weaponID].parentID == ParentID.RobotHandR || weapon[weaponID].parentID == ParentID.RobotForeArmR)

{

ExtraWpRUseCounter++;

if (ExtraWpRUseCounter >= ExtraWpRUseMax)

{

weapon[weaponID].extraWeaponSpec.returnWeapon = true;

// set weapon timer, count start when weapon return

weapon[weaponID].coolDownTimer = Data.currentTurn[(int)Data.currentMap];

}

}

}

}

}

break;

case RobotActionMode.RA1:

// transform start to move when animation start

// or transform start to move when animation Idle start

if (meleeMove && !meleeMoveStart)

{

if (!meleeMoveStartAtIdle && animator.GetCurrentAnimatorStateInfo(0).IsName(weapon[weaponID].RA1.ToString()))

meleeMoveStart = true;

else if (meleeMoveStartAtIdle && animator.GetCurrentAnimatorStateInfo(0).IsName(robotAnimationIdleClipName))

meleeMoveStart = true;

}

if (meleeMoveStart && !meleeHit)

{

if (targetCATRoot.position.y > 10)

direction = new Vector3(targetCATRoot.position.x, 0, targetCATRoot.position.z) - catRoot.position;

else

direction = targetCATRoot.position - catRoot.position;

transform.Translate(direction.normalized * meleeMoveDelta, Space.World);

// Stop moving

if (direction.magnitude < 1)

{

Destroy(meleeDetectDummy);

meleeMoveStart = false;

meleeMove = false;

}

}

// robot animation finish, now start PartAnimation

else if (animator.GetCurrentAnimatorStateInfo(0).IsName(robotAnimationIdleClipName))

{

meleeHit = false;

meleeMove = false;

SetArmIKTarge(true);

// start part animation after hit target

// if no part animation, keep moving to target destination

if (weapon[weaponID].PA1)

RobotBodyPartAnimationTurnOn(weaponID, false);

else if (weapon[weaponID].type != WeaponType.SideKick01 && weapon[weaponID].type != WeaponType.Jab)

{

RobotBodyPartWeaponEffect(weapon[weaponID].projectile1);

actionMode = RobotActionMode.WE1;

}

else

{

// Do meleeReturn need for this animation?

if (weapon[weaponID].type == WeaponType.Jab || weapon[weaponID].type == WeaponType.SideKick01)

actionMode = RobotActionMode.MeleeReturn;

else

{

weapon[weaponID].projectile1.projectileInScene.Clear();

transform.position = meleeDestination;

// forbid the case that other robot set action mode to reaction, but this robot set itself to idle at the same frame

if (actionMode != RobotActionMode.ReactionToAttack)

{

ReturnIdle();

}

}

}

}

break;

case RobotActionMode.PAS1:

if (weapon[weaponID].animator.GetCurrentAnimatorStateInfo(0).IsName("PAI1"))

{

RobotBodyPartWeaponEffect(weapon[weaponID].projectile1);

actionMode = RobotActionMode.WE1;

}

break;

case RobotActionMode.WE1: // Waiting Weapon Effect Finish

if (NoWeaponProjectileInScene())

{

SetArmIKTarge(false);

if (weapon[weaponID].PA1)

weapon[weaponID].animator.SetTrigger("PAE1"); // end part animation

// forbid the case that other robot set action mode to reaction, but this robot set itself to idle at the same frame

if (actionMode != RobotActionMode.ReactionToAttack)

{

if (weapon[weaponID].RA1 != RobotAnimation.Null)

animator.SetTrigger("Idle End"); // end robot animation

ReturnIdle();

}

// Extra Weapon

if (weapon[weaponID].extraWeaponSpec != null)

{

if (weapon[weaponID].parentID == ParentID.RobotHandL || weapon[weaponID].parentID == ParentID.RobotForeArmL)

{

ExtraWpLUseCounter++;

if (ExtraWpLUseCounter >= ExtraWpLUseMax)

{

weapon[weaponID].extraWeaponSpec.returnWeapon = true;

// set weapon timer, count start when weapon return

weapon[weaponID].coolDownTimer = Data.currentTurn[(int)Data.currentMap];

}

}

else if (weapon[weaponID].parentID == ParentID.RobotHandR || weapon[weaponID].parentID == ParentID.RobotForeArmR)

{

ExtraWpRUseCounter++;

if (ExtraWpRUseCounter >= ExtraWpRUseMax)

{

weapon[weaponID].extraWeaponSpec.returnWeapon = true;

// set weapon timer, count start when weapon return

weapon[weaponID].coolDownTimer = Data.currentTurn[(int)Data.currentMap];

}

}

}

}

break;

case RobotActionMode.Melee:

// Enter by WeaponFire()

// Three speical issue:

// 1. Sword attack: prepare sword, move forward, sword hit, where sword hit cannot start from standby, so the RA0, RA1 system wont work

// 2. Total two weapon dummy: PA0 is the enemy detection dummy, PA1 is the sword hit dummy

// 3. Robot animation and part animation parelle, RAPAParalle true.

// (robot take sword and move forward same time is not an option now)

// Melee mode

// 1. PA0/RA0 - > Transform forward -> Hit Enemy, Idle End -> RA0-Return (animation can hit enemy by muzzle1 hit dummy)

// 2. PA0 -> PA Idle -> RA0 - RA0 Idle -> Transform forward -> Hit Enemy, Idle End -> RA0-Return (animation can hit enemy by muzzle1 hit dummy)

// flying knee strike use the sword system

switch (meleeSubMode)

{

case MeleeSubMode.Prepare:

// RA and PA start by WeaponFire, and now is waiting for RA idle

if (animator.GetCurrentAnimatorStateInfo(0).IsName(robotAnimationIdleClipName))

{

// let robot move inside target agent

// navAgent.enabled = false;

// create detect dummy

RobotBodyPartWeaponEffect(weapon[weaponID].projectile0);

meleeSubMode = MeleeSubMode.MoveForward;

//if(weapon[weaponID].animator!=null)

// weapon[weaponID].animator.SetTrigger("PAE0");

}

break;

case MeleeSubMode.MoveForward:

// cancel immediately if target die

if (target == null)

{

if (weapon[weaponID].animator != null)

weapon[weaponID].animator.SetTrigger("PAE0");

animator.Play(RobotAnimation.StandBy.ToString());

meleeSubMode = MeleeSubMode.Prepare;

meleeReturnSubMode = MeleeReturnSubMode.Waiting;

actionMode = RobotActionMode.MeleeReturn;

}

// Not hit yet? keep moving to target

// detect dummy should be destory by weapon effect manager when hit

if (NoWeaponProjectileInScene())

{

// sword case: sword hit animation do not start from Standby, so it cant use RA1

// So it will be a problem for sword attack.

// sword hit animation is in the same sword attack flow, so we use Idle end to trigger hit animation

// also need to create sword hit dummy

meleeHit = false;

animator.applyRootMotion = true;

animator.SetTrigger("Idle End"); // start sword hit animation

RobotBodyPartWeaponEffect(weapon[weaponID].projectile1);

meleeSubMode = MeleeSubMode.Attack;

}

else

{

//if (targetCATRoot.position.y > 10)

// direction = new Vector3(targetCATRoot.position.x, 0, targetCATRoot.position.z) - catRoot.position;

// else

direction = targetCATRoot.position - catRoot.position;

// Stop moving

if (direction.magnitude < 1)

{

Debug.Log("error");

actionMode = RobotActionMode.Idle;

}

else

transform.Translate(direction.normalized * meleeMoveDelta, Space.World);

}

break;

case MeleeSubMode.Attack:

// Waiting Sword hit target

// detect dummy should be destory by weapon effect manager when hit

if (NoWeaponProjectileInScene() || animator.GetCurrentAnimatorStateInfo(0).IsName(RobotAnimation.StandBy.ToString()))

{

// Safe point check

// for the case that melee attack animation finish, but dummy still not trigger

// bug: robot become idle, but weapon dummy in scene not empty

if (weapon[weaponID].projectile1.projectileInScene.Count != 0)

CancelProjectileInScene(true);

if (weapon[weaponID].animator != null)

weapon[weaponID].animator.SetTrigger("PAE0");

// it is too early to set extra weapon return true here, need to wait the animation return finish

// so do it at meleeReturn

meleeSubMode = MeleeSubMode.Prepare;

meleeReturnSubMode = MeleeReturnSubMode.Waiting;

actionMode = RobotActionMode.MeleeReturn;

}

break;

}

break;

case RobotActionMode.Shield:

// no projectile, no part animation, Only robot defend animation

// wait until all target projectile in scene destoryed

// also need to wait target become idle, in case target is still in melee action, but this robot cancel defend animation too early

switch (shieldSubMode)

{

case ShieldSubMode.WaitTargetAttack:

// wait until target create projectile in scene

if (!target.GetComponent<RobotAI>().NoWeaponProjectileInScene())

shieldSubMode = ShieldSubMode.Defending;

break;

case ShieldSubMode.Defending:

// wait until all projectiles destoryed

if (target.GetComponent<RobotAI>().NoAnyProjectileInScene() && target.GetComponent<RobotAI>().animator.GetCurrentAnimatorStateInfo(0).IsName("StandBy"))

{

// shield on L, so only check L;

if (weapon[weaponID].extraWeaponSpec != null)

{

ExtraWpLUseCounter++;

if (ExtraWpLUseCounter >= ExtraWpLUseMax)

{

weapon[weaponID].extraWeaponSpec.returnWeapon = true;

// set weapon timer, count start when weapon return

weapon[weaponID].coolDownTimer = Data.currentTurn[(int)Data.currentMap];

}

}

shieldSubMode = ShieldSubMode.WaitTargetAttack;

currentAnimation = RobotAnimation.Null;

animator.SetTrigger("Idle End");

actionMode = RobotActionMode.Idle;

// clear up transform list

NoAnyProjectileInScene();

}

break;

}

break;

case RobotActionMode.MeleeReturn:

// use default "-E" animation in animator controller

// but need to control the catRoot, such that it stay on terrain

switch (meleeReturnSubMode)

{

case MeleeReturnSubMode.Setup:

animator.SetTrigger("Idle End");

meleeReturnSubMode = MeleeReturnSubMode.Waiting;

break;

case MeleeReturnSubMode.Waiting:

// Now it should be RA008

// robot return to ground destination point

// fall on ground

if (catRoot.position.y >= 2)

{

// return animation include attack, if falling start too early, attack will miss.

// so wait until standby mode to start falling.

if (animator.GetCurrentAnimatorStateInfo(0).IsName("StandBy"))

transform.Translate(Vector3.down * 50 * Time.deltaTime, Space.World);

}

else

{

if (catRoot.position.y <= 0)

catRoot.position = new Vector3(catRoot.position.x, 0, catRoot.position.z);

if (animator.GetCurrentAnimatorStateInfo(0).IsName("StandBy"))

{

// for sword (shield do not need meleereturn)

// do not want shield disappear during attack.

if (weapon[weaponID].extraWeaponSpec != null)

{

if (weapon[weaponID].parentID == ParentID.RobotHandL || weapon[weaponID].parentID == ParentID.RobotForeArmL)

{

ExtraWpLUseCounter++;

if (ExtraWpLUseCounter >= ExtraWpLUseMax)

{

weapon[weaponID].extraWeaponSpec.returnWeapon = true;

// set weapon timer, count start when weapon return

weapon[weaponID].coolDownTimer = Data.currentTurn[(int)Data.currentMap];

}

}

else if (weapon[weaponID].parentID == ParentID.RobotHandR || weapon[weaponID].parentID == ParentID.RobotForeArmR)

{

ExtraWpRUseCounter++;

if (ExtraWpRUseCounter >= ExtraWpRUseMax)

{

weapon[weaponID].extraWeaponSpec.returnWeapon = true;

// set weapon timer, count start when weapon return

weapon[weaponID].coolDownTimer = Data.currentTurn[(int)Data.currentMap];

}

}

}

ReturnIdle();

}

}

break;

}

break;

case RobotActionMode.ComboRA:

robotAnimationIdleClipName = weapon[weaponID].comboRA.ToString() + "-I";

// start move only if now is the melee animation, the reason is animation clip run slower than fixedupdate

if (meleeMove && animator.GetCurrentAnimatorStateInfo(0).IsName(weapon[weaponID].comboRA.ToString()))

meleeMoveStart = true;

// Fixedupate run faster than animation, so need to make sure animation is at the "melee" stage

// case 1. punch hit target, punch target back and move to target current hex

// case 2. punch hit target, start part animation before punch target back

if (meleeMoveStart && !meleeHit)

{

transform.Translate(transform.forward * meleeMoveDelta, Space.World);

}

// robot animation finish, now start PartAnimation

else if (animator.GetCurrentAnimatorStateInfo(0).IsName(robotAnimationIdleClipName))

{

meleeMove = false;

meleeMoveStart = false;

meleeHit = false;

// start this part and combo part animation after hit target

// if no part animation, keep moving to target destination hex location

if (weapon[weaponID].PA0)

{

RobotBodyPartAnimationTurnOn(weaponID, false);

RobotBodyPartAnimationTurnOn(GetComboWeaponID(), false);

// override the actionmode declared in RobotBodyPartAnimationTurnOn;

actionMode = RobotActionMode.ComboPAS;

}

else

{

direction = meleeDestination - transform.position;

if (direction.magnitude > 1)

transform.Translate(transform.forward * meleeMoveDelta, Space.World);

else

{

weapon[weaponID].projectile0.projectileInScene.Clear();

weapon[GetComboWeaponID()].projectile0.projectileInScene.Clear();

transform.position = meleeDestination; // make sure the robot is exactly on the hex center

// forbid the case that other robot set action mode to reaction, but this robot set itself to idle at the same frame

if (actionMode != RobotActionMode.ReactionToAttack)

{

ReturnIdle();

}

}

}

}

break;

case RobotActionMode.ComboPAS:

if (weapon[weaponID].animator.GetCurrentAnimatorStateInfo(0).IsName("PAI0") && weapon[GetComboWeaponID()].animator.GetCurrentAnimatorStateInfo(0).IsName("PAI0"))

{

weapon[weaponID].projectile0.projectileInScene.Clear();

weapon[GetComboWeaponID()].projectile0.projectileInScene.Clear();

RobotBodyPartWeaponEffect(weapon[weaponID].projectile0);

RobotBodyPartWeaponEffect(weapon[GetComboWeaponID()].projectile0);

actionMode = RobotActionMode.ComboWE;

// Set up Path Node for SED

if (weapon[weaponID].type == WeaponType.SuperElectricalDrill)

{

SEDMoveMode = SEDMoveModeStage.Path1Setup;

// Let cut in camera know

meleeMoveStart = true;

SEDMove();

}

}

break;

case RobotActionMode.ComboWE:

if (weapon[weaponID].type == WeaponType.SuperElectricalDrill)

{

SEDMove();

}

else if (NoWeaponProjectileInScene())

{

weapon[weaponID].animator.SetTrigger("PAE0"); // end part animation

weapon[GetComboWeaponID()].animator.SetTrigger("PAE0");

// forbid the case that other robot set action mode to reaction, but this robot set itself to idle at the same frame

if (actionMode != RobotActionMode.ReactionToAttack)

{

ReturnIdle();

}

}

break;

case RobotActionMode.Move:

// Normal Move, Walking or Fly

if (Vector3.Distance(destination, transform.position) <= navAgent.stoppingDistance)

{

animator.SetTrigger("Idle End"); // end walking animation

navAgent.velocity = Vector3.zero;

navAgent.Stop();

currentAnimation = RobotAnimation.Null;

actionMode = RobotActionMode.Idle;

break;

}

// Limit the max distance move

if (Vector3.Distance(robotOriginalPosition, transform.position) >= moveDistanceMax)

{

animator.SetTrigger("Idle End");

navAgent.velocity = Vector3.zero;

navAgent.Stop();

currentAnimation = RobotAnimation.Null;

actionMode = RobotActionMode.Idle;

}

break;

case RobotActionMode.ReactionToAttack:

// Weapon dummy may still in go home stage and weapon animator in idle stage, need to trigger the idle when dummy at home

/* if (weapon[weaponID].animator!=null)

{

if (weapon[weaponID].animator.GetCurrentAnimatorStateInfo(0).IsName("PAI0") && NoWeaponProjectileInScene())

weapon[weaponID].animator.SetTrigger("PAE0");

if (weapon[weaponID].animator.GetCurrentAnimatorStateInfo(0).IsName("PAI1") && NoWeaponProjectileInScene())

weapon[weaponID].animator.SetTrigger("PAE1");

}

*/

// Force aniamtion state to become StandBy and set IK target to null before start the expected reaction animation

switch (robotReactionToAttack)

{

case RobotReactionToAttack.RE_SelfRotating:

// animation is "Standby"

SelfRotator(720);

// Need a way to break loop

// if target is idle, it means no anymore attack from target, so break loop

if (target.GetComponent<RobotAI>().actionMode == RobotActionMode.Idle)

{

ReturnIdle();

}

break;

case RobotReactionToAttack.RE_JumpBack:

switch (reactionToAttackSubMode)

{

case ReactionToAttackSubMode.ReactionAnimation1:

// Play reaction animation directly

// also clear IK target if any

SetArmIKTarge(false);

animator.Play(robotReactionToAttack.ToString());

reactionToAttackSubMode = ReactionToAttackSubMode.ReactionAnimationWaiting1;

break;

case ReactionToAttackSubMode.ReactionAnimationWaiting1:

if (animator.GetCurrentAnimatorStateInfo(0).IsName("StandBy"))

{

reactionToAttackSubMode = ReactionToAttackSubMode.ReactionAnimation1;

ReturnIdle();

}

break;

}

break;

case RobotReactionToAttack.RE_FallOnGroundFront:

switch (reactionToAttackSubMode)

{

case ReactionToAttackSubMode.ReactionAnimation1:

SetArmIKTarge(false);

animator.Play(robotReactionToAttack.ToString());

reactionToAttackSubMode = ReactionToAttackSubMode.ReactionAnimationWaiting1;

break;

case ReactionToAttackSubMode.ReactionAnimationWaiting1:

if (animator.GetCurrentAnimatorStateInfo(0).IsName("StandBy"))

{

reactionToAttackSubMode = ReactionToAttackSubMode.ReactionAnimation1;

ReturnIdle();

/*

currentAnimation = RobotAnimation.Null;

navAgent.enabled = true;

actionMode = RobotActionMode.Idle;

meleeMoveStart = false;

*/

}

break;

}

break;

case RobotReactionToAttack.RE_PushBack:

switch (reactionToAttackSubMode)

{

case ReactionToAttackSubMode.ReactionAnimation1:

SetArmIKTarge(false);

animator.Play(robotReactionToAttack.ToString());

// Start knock back animation once

animator.applyRootMotion = true;

reactionToAttackSubMode = ReactionToAttackSubMode.ReactionAnimationWaiting1;

break;

case ReactionToAttackSubMode.ReactionAnimationWaiting1:

if (animator.GetCurrentAnimatorStateInfo(0).IsName(robotReactionToAttack.ToString() + "-I"))

{

// Move robot root transform to destination hex position, shift CAT by delta so it can stay at same point in scene when root transform move

ReturnIdle();

/*

Vector3 delta = catRoot.position - transform.position;

transform.position = catRoot.position;

catRoot.position -= delta;

catRoot.localPosition = Vector3.zero;

catRoot.localRotation = Quaternion.Euler(0, 0, 0);

transform.LookAt(target);

animator.SetTrigger("Idle End");

animator.applyRootMotion = false;

reactionToAttackSubMode = ReactionToAttackSubMode.ReactionAnimation1;

currentAnimation = RobotAnimation.Null;

navAgent.enabled = true;

actionMode = RobotActionMode.Idle;

meleeMoveStart = false;

*/

}

break;

}

break;

case RobotReactionToAttack.RE_SEDFull:

switch (reactionToAttackSubMode)

{

case ReactionToAttackSubMode.ReactionAnimation1:

SetArmIKTarge(false);

animator.Play(robotReactionToAttack.ToString());

animator.applyRootMotion = true;

reactionToAttackSubMode = ReactionToAttackSubMode.ReactionAnimationWaiting1;

break;

case ReactionToAttackSubMode.ReactionAnimationWaiting1:

if (animator.GetCurrentAnimatorStateInfo(0).IsName(robotReactionToAttack.ToString() + "-I"))

{

// shift CAT by delta so it can stay at same point in scene when root transform move

ReturnIdle();

/*

Vector3 delta = catRoot.position - transform.position;

transform.position = catRoot.position;

catRoot.position -= delta;

animator.SetTrigger("Idle End");

animator.applyRootMotion = false;

catRoot.localPosition = Vector3.zero;

catRoot.localRotation = Quaternion.Euler(0, 0, 0);

transform.LookAt(target);

reactionToAttackSubMode = ReactionToAttackSubMode.ReactionAnimation1;

currentAnimation = RobotAnimation.Null;

navAgent.enabled = true;

actionMode = RobotActionMode.Idle;

meleeMoveStart = false;

*/

}

break;

}

break;

case RobotReactionToAttack.RE_SEDHalf:

switch (reactionToAttackSubMode)

{

case ReactionToAttackSubMode.ReactionAnimation1:

SetArmIKTarge(false);

animator.Play(robotReactionToAttack.ToString());

animator.applyRootMotion = true;

reactionToAttackSubMode = ReactionToAttackSubMode.ReactionAnimationWaiting1;

break;

case ReactionToAttackSubMode.ReactionAnimationWaiting1:

if (animator.GetCurrentAnimatorStateInfo(0).IsName(robotReactionToAttack.ToString() + "-I"))

{

ReturnIdle();

// shift CAT by delta so it can stay at same point in scene when root transform move

/*

Vector3 delta = catRoot.position - transform.position;

transform.position = catRoot.position;

catRoot.position -= delta;

animator.SetTrigger("Idle End");

animator.applyRootMotion = false;

catRoot.localPosition = Vector3.zero;

catRoot.localRotation = Quaternion.Euler(0, 0, 0);

transform.LookAt(target);

reactionToAttackSubMode = ReactionToAttackSubMode.ReactionAnimation1;

currentAnimation = RobotAnimation.Null;

navAgent.enabled = true;

actionMode = RobotActionMode.Idle;

meleeMoveStart = false;

*/

}

break;

}

break;

}

break;

case RobotActionMode.Death:

// 1. trigger by weapon effect maanger when health <0

// 2. trigger death animation

// 4. instantiate explosion when death animation idle

// 5. "explosion killer" destory robot when particle effect end

// because animator death is a dead end flow, no problem to trgger idle end many times

switch (deathMode)

{

case DeathMode.Prepare:

animator.Play(RobotAnimation.Death.ToString());

Data.canvas.GetComponent<BattleManager>().RobotDeath(transform);

Data.canvas.GetComponent<BattleManager>().focusCameraTarget = transform;

deathMode = DeathMode.Animation;

break;

case DeathMode.Animation:

if (animator.GetCurrentAnimatorStateInfo(0).IsName(RobotAnimation.Death.ToString() + "-I"))

{

GameObject obj = Instantiate(robotExplosion, chest.position, transform.rotation);

obj.transform.SetParent(transform);

// put explosion in the projectiles, so ui need to wait for this robot die before taking next action

// to solve the null reference death robot problem

// for the case that this robot is killed by non robot turret, target may be null

if (target != null)

target.GetComponent<RobotAI>().AllProjectilesInScene.Add(obj.transform);

deathMode = DeathMode.Explosion;

}

break;

case DeathMode.Explosion:

break;

}

break;

}

}

// Reset all Idle paramter

void ReturnIdle()

{

Vector3 delta = catRoot.position - transform.position;

transform.position = catRoot.position;

catRoot.position -= delta;

catRoot.localPosition = new Vector3(0, 0.3f, 0);

catRoot.localRotation = Quaternion.Euler(0, 0, 0);

transform.LookAt(target);

animator.applyRootMotion = false;

actionMode = RobotActionMode.Idle;

reactionToAttackSubMode = ReactionToAttackSubMode.ReactionAnimation1;

meleeReturnSubMode = MeleeReturnSubMode.Setup;

currentAnimation = RobotAnimation.Null;

meleeMoveStart = false;

meleeHit = false;

meleeMove = false;

// both agent turn off when weapon fire

// so need to turn them on when attack finish

// some attack finish very early and will cause problem if they turn on target agent

// and same problem on 1 vs 1, because attack member is 0

navAgent.enabled = true;

// if (target != null && target.GetComponent<RobotAI>())

// if(target.GetComponent<RobotAI>().actionMode == RobotActionMode.Idle)

// target.GetComponent<NavMeshAgent>().enabled = true;

// clear up transform list

NoAnyProjectileInScene();

if (animator.GetCurrentAnimatorStateInfo(0).IsName(robotReactionToAttack.ToString() + "-I"))

animator.SetTrigger("Idle End");

// clear assist attack bool or end robot attack this turn

if (transform.CompareTag(Tag.PlayerRobot.ToString()))

{

if (Data.playerRobot[robotIndex].thisIsAssistAttack)

Data.playerRobot[robotIndex].thisIsAssistAttack = false;

else

Data.playerRobot[robotIndex].attackedThisTurn = true;

}

else

{

if (Data.enemyRobot[robotIndex].thisIsAssistAttack)

Data.enemyRobot[robotIndex].thisIsAssistAttack = false;

else

Data.enemyRobot[robotIndex].attackedThisTurn = true;

}

}

// 1. Import Default Data from Body Part Prefab

// 2. Import Player customerised Data, such as laser color, from Data Center

// 3. Also set attackDistance Max/Min value

//-----------------------------Attack---------------

// 1. Find out all enemy in attack range

// 2. Return closet enemy if no enemy in range

// 3. Sort enemy list by distance, return closest enemy that LOS ok and weapon available

// 4. Move to target in next attack range if no weapon avaiable

// Update enemy List, and return the closest as target

bool TargetInAttackRange(float d)

{

if (Vector3.Distance(target.position, transform.position) < d)

return true;

else

return false;

}

// Set Move animation, copy path point

public void Move(Vector3 point, float stoppingDistance )

{

actionMode = RobotActionMode.Move;

animator.SetBool("RA003", true);

navAgent.Resume();

navAgent.destination = point;

navAgent.stoppingDistance = stoppingDistance;

destination = point;

robotOriginalPosition = transform.position;

}

// Idle mode in RBLauncher

public void Idle(bool onOff)

{

if(onOff)

animator.SetTrigger("Idle");

else

animator.SetTrigger("Idle End");

}

//-------------- Fire Weapon Section--------------------------------------------------------------

// 1. Start CAT animation

// 2. When CAT animation enter idle, start body part animation

// 3. When body part animation enter idle, generate weapon effect

// 4. When weapon effect finish, restart the body part animation

// 5. When body part animation finish, restart the CAT animation

// 6 PA0 -> RA0 -> WE0 -> PA1 -> RA1 -> WE1

// Another Flow for sword:

// 1. Sword Prepare Animation, Create enemy detect dummy when Idle

// 2. Transform move forward until detect dummy trigger, and create hit dummy

// 3. Sword attack Animation, hit dummy trigger when hit target

// 4. RA -> transform move -> RA

public void WeaponFire(int wID)

{

targetOriginalPosition = target.position;

robotOriginalPosition = transform.position;

robotOriginalRotation = transform.rotation;

// nav agent, so they wont affect each other

if(target.GetComponent<RobotAI>())

target.GetComponent<NavMeshAgent>().enabled = false;

navAgent.enabled = false;

// pid is for identify which body part weapon

// Start Robot Animation

weaponID = wID;

// set weapon timer

weapon[weaponID].coolDownTimer = Data.currentTurn[(int)Data.currentMap];

// 4 cases:

// 1. No RA, No PA, fire weapon

// 2. No RA, PA, start part animation

// 3. RA, PA, start robot animation

// 4. RA, no PA

if (weapon[weaponID].type != WeaponType.Null && weapon[weaponID].RA0 == RobotAnimation.Null && !weapon[weaponID].PA0)

{

//1. No RA, No PA

RobotBodyPartWeaponEffect(weapon[weaponID].projectile0);

actionMode = RobotActionMode.WE0;

}

else if (weapon[weaponID].RA0 == RobotAnimation.Null)

{

// 2. No RA

RobotBodyPartAnimationTurnOn(weaponID, false);

}

else

{

// 3. RA And ( PA or no PA)

// check if this weapon need to change robot animation

if (weapon[weaponID].comboRA == RobotAnimation.Null)

{

// RA and PA

StartRobotAnimation(weapon[weaponID].RA0);

actionMode = RobotActionMode.RA0;

// also start part animation if parallel

// So, parellel action mode skip RA0, and go to PA0 directly

// Go to WE0 by default

if (weapon[weaponID].RAPAParalle)

RobotBodyPartAnimationTurnOn(weaponID, false);

//ExtraWpHandRPart is still null, so cannot access useweapon by them

// only call extraweapon function when no weapon on hand

// because the extraweapon function is responsible for color change and pass weapon.

// No need to change color and pass weapon when weapon already on hand.

if (weapon[weaponID].extraWeaponSpec != null)

if (!weapon[weaponID].extraWeaponSpec.weaponOnHand)

{

weapon[weaponID].extraWeaponSpec.useWeapon = true;

}

// Change to sword mode, or shield mode

if (weapon[weaponID].type == WeaponType.Sword || weapon[weaponID].type == WeaponType.KneeStrike)

{

actionMode = RobotActionMode.Melee;

}

else if (weapon[weaponID].type == WeaponType.Shield)

{

actionMode = RobotActionMode.Shield;

}

}

else if (ComboRBPExist())

{

// change to combo robot animation and combo mode

StartRobotAnimation(weapon[weaponID].comboRA);

actionMode = RobotActionMode.ComboRA;

}

else

{

// Use default robot animation if not pair

StartRobotAnimation(weapon[weaponID].RA0);

actionMode = RobotActionMode.RA0;

}

}

}

// Set Nav agent off here before melee start

// Resume on reaction mode

void StartRobotAnimation(RobotAnimation rba)

{

currentAnimation = rba;

// animation that require something more

// flying knee strike use the sword system

switch (rba)

{

// For some attack that do not start part animation, we need to create weapon effect dummy for detection before starting the animation

// also need to move the robot forward

// RA005 is flying punch that do not have part animation

case RobotAnimation.RA005:

MeleeDummyGenerator(MeleeDetectDummyLocation.HandR);

meleeDestination = target.position;

meleeMove = true;

meleeMoveStartAtIdle = false;

meleeMoveStart = false;

meleeHit = false;

if (Vector3.Distance(target.position, transform.position) >= 50)

meleeMoveDelta = 1.5f;

else

meleeMoveDelta = 1;

// disable nav agent, so this robot can enter other nav agent

//navAgent.enabled = false;

break;

// RA007 is super electronic Drill, start at part animation, then follow by robot animation. standard process

// so the melee detection dummy will be generated at RobotBodyPartWeaponEffec

case RobotAnimation.RA007:

// disable nav agent, so this robot can fly

//navAgent.enabled = false;

break;

// Kick from sky

case RobotAnimation.RA011:

MeleeDummyGenerator(MeleeDetectDummyLocation.FootR);

meleeDestination = target.position;

meleeMove = true;

meleeMoveStartAtIdle = true;

meleeMoveStart = false;

meleeHit = false;

animator.applyRootMotion = true;

//if (Vector3.Distance(target.position, transform.position) >= 50)

// meleeMoveDelta = f;

//else

meleeMoveDelta = 3;

// disable nav agent, so this robot can jump to sky

// navAgent.enabled = false;

break;

}

// check fingers

// Move fingers to CAT before start animation

// because they may not link to CAT due to the interrupt from attack

// i.e, robot go to idle mode after reaction mode, but fingers still on foreArm part cat

// The problem can be solved by adding a checking point before going to idle, but we put it here because it seems to be easier

if (handL.parent != catRoot.GetComponent<RobotCATStructure>().handL || handR.parent != catRoot.GetComponent<RobotCATStructure>().handR)

FingersToRobot(weaponID);

if (ExtraWpR == null && ExtraWpL == null)

{

animator.SetTrigger(rba.ToString());

}

else

{

// Use ex animation instead

// there is no RA0EX-I, so keep using original RA0-I for idle checking

if (weapon[weaponID].RA0Ex != RobotAnimation.Null)

animator.SetTrigger(weapon[weaponID].RA0Ex.ToString());

else

animator.SetTrigger(rba.ToString());

}

robotAnimationIdleClipName = rba.ToString() + "-I";

}

// Create dummy on Hand or Foot for collision detect

void MeleeDummyGenerator(MeleeDetectDummyLocation where)

{

GameObject obj=null;

switch(where)

{

case MeleeDetectDummyLocation.HandR:

obj = Instantiate(meleeHandDetectDummy, transform.position, transform.rotation);

// projectile detail seem not importamt for melee dummy, so just put projectile0 here

obj.GetComponent<WeaponEffectManager>().Init("Robot", transform, target, weapon[weaponID].projectile0);

SetParent(obj.transform, catRoot.GetComponent<RobotCATStructure>().handR);

break;

case MeleeDetectDummyLocation.FootR:

obj = Instantiate(meleeKickDetectDummy, transform.position, transform.rotation);

// projectile detail seem not importamt for melee dummy, so just put projectile0 here

obj.GetComponent<WeaponEffectManager>().Init("Robot", transform, target, weapon[weaponID].projectile0);

SetParent(obj.transform, catRoot.GetComponent<RobotCATStructure>().footR);

break;

}

// so we can refer it and destroy in RA0,RA1 later

meleeDetectDummy = obj;

}

// Check if the required combo part exist

// if no, return false; if yes, check if pair exist

bool ComboRBPExist()

{

string fal = foreArmL.name.Replace("L", ""); ;

string far = foreArmR.name.Replace("R", ""); ;

if (weapon[weaponID].parentID == ParentID.RobotForeArmL && weapon[weaponID].comboRBP.ToString() == far)

return true;

else if(weapon[weaponID].parentID == ParentID.RobotForeArmR && weapon[weaponID].comboRBP.ToString() == fal)

return true;

else

return false;

}

// find out the combo part weapon ID

int GetComboWeaponID()

{

if (weapon[weaponID].parentID == ParentID.RobotForeArmL)

for (int i = 0; i < weapon.Count; i++)

if (weapon[i].parentID == ParentID.RobotForeArmR)

return i;

if (weapon[weaponID].parentID == ParentID.RobotForeArmR)

for (int i = 0; i < weapon.Count; i++)

if (weapon[i].parentID == ParentID.RobotForeArmL)

return i;

return 999;

}

// number = false, robot animation 0; true = robot animation 1

public void RobotBodyPartAnimationTurnOn(int wID, bool number)

{

if (number)

{

// if (weapon[wID].digitsRoot != null)

// FingersToBodyPartCAT();

weapon[wID].animator.SetTrigger("PAS1");

actionMode = RobotActionMode.PAS1;

}

else

{

// for the case that pass digits to body part cat before start body part animation

if (weapon[wID].digitsRoot != null)

FingersToBodyPartCAT(wID);

weapon[wID].animator.SetTrigger("PAS0");

actionMode = RobotActionMode.PAS0;

}

}

// Reponsible for create projectile, laser dummy etc

public void RobotBodyPartWeaponEffect(Weapon.Projectile projectile)

{

GameObject obj = null;

// specially for funnel, pick a value for each funnel.

// Cannot assign from weaponeffectmanager(on the funnel projectile), because we need to make sure each funnel assigned value is different

Vector3[] funnelTargetPositionDeltaList = new Vector3[] { new Vector3(20, 20, 0), new Vector3(20, 20, -20), new Vector3(-20, 20, 0), new Vector3(-20, 20, 20), new Vector3(0, 20, 20) };

int funnelCounter = 0;

for (int i = 0; i < projectile.projectileMuzzleLocation.Count; i++)

{

obj = Instantiate(projectile.projecitlePrefab, projectile.projectileMuzzleLocation[i].position, projectile.projectileMuzzleLocation[i].rotation) as GameObject;

// Pass Data to WeaponEffectManager

obj.GetComponent<WeaponEffectManager>().Init("Robot", transform, target, projectile);

switch (weapon[weaponID].type)

{

case WeaponType.MachineGun:

obj.transform.parent = projectile.projectileMuzzleLocation[i];

break;

case WeaponType.MeleeTargetDetect:

obj.transform.parent = projectile.projectileMuzzleLocation[i];

break;

case WeaponType.Sword:

obj.transform.parent = projectile.projectileMuzzleLocation[i];

break;

case WeaponType.KneeStrike:

obj.transform.parent = projectile.projectileMuzzleLocation[i];

break;

case WeaponType.Funnel:

obj.GetComponent<WeaponEffectManager>().homePosition = projectile.projectileMuzzleLocation[i];

obj.GetComponent<WeaponEffectManager>().funnelID = i;

obj.GetComponent<WeaponEffectManager>().funnelTargetPositionDelta = funnelTargetPositionDeltaList[funnelCounter];

funnelCounter++;

break;

case WeaponType.RocketPunch:

// Move forearm to rocket dummy

switch (weapon[weaponID].parentID)

{

case ParentID.RobotForeArmR:

obj.GetComponent<WeaponEffectManager>().homePosition = foreArmR.parent;

foreArmR.parent = obj.transform;

// if rocket punch is provided by attack skill, attach the attack skill transform to rocket punch dummy too

// such that the digits on the dummy palm can also follow the rocket

if (weapon[weaponID].attackSkill)

weapon[weaponID].thisTransform.parent = obj.transform;

break;

case ParentID.RobotForeArmL:

obj.GetComponent<WeaponEffectManager>().homePosition = foreArmL.parent;

foreArmL.parent = obj.transform;

if (weapon[weaponID].attackSkill)

weapon[weaponID].thisTransform.parent = obj.transform;

break;

}

break;

case WeaponType.SuperElectricalDrill:

obj.transform.parent = projectile.projectileMuzzleLocation[i];

break;

case WeaponType.Turret:

// turn on turret to fire

// use empty dummy for standard turret, otherwise the projectile count check will stop the robot attack

// and also need a method for NoProjectileInScene checking in WE0 or WE1, we set a destory timer to ensure WE0/1 can end.

// mount the dummy on robot too, otherwise the projectile from turret can trigger collision on the dummy

weapon[weaponID].thisTransform.GetComponent<TurretAI>().fire = true;

// Place the dummy on the body part, not on the muzzle

obj.transform.parent = weapon[weaponID].thisTransform;

obj.transform.localPosition = Vector3.zero;

Destroy(obj, weapon[weaponID].projectile0.projectileKillTime);

break;

}

projectile.projectileInScene.Add(obj);

}

// Ingore each other collision

for (int i = 0; i < projectile.projectileInScene.Count; i++)

for (int k = 0; k < projectile.projectileInScene.Count; k++)

Physics.IgnoreCollision(projectile.projectileInScene[i].GetComponent<Collider>(), projectile.projectileInScene[k].GetComponent<Collider>());

}

// Check if all weapon projectile in scene destoryed

bool NoWeaponProjectileInScene()

{

// Remove all "missing" in projectile scene list

for(int i=0;i<weapon.Count;i++)

{

// projectile 0

try

{

for (int k = weapon[i].projectile0.projectileInScene.Count - 1; k >= 0; k--)

if (weapon[i].projectile0.projectileInScene[k] == null)

weapon[i].projectile0.projectileInScene.RemoveAt(k);

}

catch (NullReferenceException) { }

try

{

// projectile 1

for (int k = weapon[i].projectile1.projectileInScene.Count - 1; k >= 0; k--)

if (weapon[i].projectile1.projectileInScene[k] == null)

weapon[i].projectile1.projectileInScene.RemoveAt(k);

}

catch (NullReferenceException) { }

}

// if all list count is 0, return true

for (int i = 0; i < weapon.Count; i++)

{

try {

if (weapon[i].projectile0.projectileInScene.Count != 0)

return false;

}

catch (NullReferenceException) { }

try {

if (weapon[i].projectile1.projectileInScene.Count != 0)

return false;

}

catch (NullReferenceException) { }

}

if(NoAnyProjectileInScene())

return true;

return false;

}

// include sub projectile check, specially for shield defend

bool NoAnyProjectileInScene()

{

try

{

for (int k = AllProjectilesInScene.Count-1; k >= 0; k--)

if (AllProjectilesInScene[k] == null)

AllProjectilesInScene.RemoveAt(k);

}

catch (NullReferenceException) { }

// if all list count is 0, return true

try

{

if (AllProjectilesInScene.Count != 0)

return false;

}

catch (NullReferenceException) { }

return true;

}

public void CancelProjectileInScene(bool destroy)

{

for (int i = 0; i < weapon.Count; i++)

{

// projectile 0

for (int k = weapon[i].projectile0.projectileInScene.Count - 1; k >= 0; k--)

if (weapon[i].projectile0.projectileInScene[k] != null)

if (destroy)

Destroy(weapon[i].projectile0.projectileInScene[k]);

else

weapon[i].projectile0.projectileInScene[k].GetComponent<WeaponEffectManager>().Cancel();

weapon[i].projectile0.projectileInScene.Clear();

// projectile 1

for (int k = weapon[i].projectile1.projectileInScene.Count - 1; k >= 0; k--)

if (weapon[i].projectile1.projectileInScene[k] != null)

if(destroy)

Destroy(weapon[i].projectile1.projectileInScene[k]);

else

weapon[i].projectile1.projectileInScene[k].GetComponent<WeaponEffectManager>().Cancel();

weapon[i].projectile1.projectileInScene.Clear();

}

// end part animation, but rocket punch should only do part animation when forearm at home, so it will be trigger by rocket punch dummy

if (weapon[weaponID].animator != null && weapon[weaponID].type != WeaponType.RocketPunch)

{

if (weapon[weaponID].animator.GetCurrentAnimatorStateInfo(0).IsName("PAS0") || weapon[weaponID].animator.GetCurrentAnimatorStateInfo(0).IsName("PAI0"))

weapon[weaponID].animator.SetTrigger("PAE0");

if (weapon[weaponID].animator.GetCurrentAnimatorStateInfo(0).IsName("PAS1") || weapon[weaponID].animator.GetCurrentAnimatorStateInfo(0).IsName("PAI1"))

weapon[weaponID].animator.SetTrigger("PAE1");

}

}

// Rotate robot continuously, caused by tornado etc

void SelfRotator(int rotateSpeed)

{

transform.Rotate(transform.up, rotateSpeed * Time.deltaTime);

}

// move digits to body part digit root, so digits can follow animation

// should call before part animation start

public void FingersToBodyPartCAT(int wID)

{

switch (weapon[wID].parentID)

{

case ParentID.RobotForeArmR:

handR.parent = weapon[wID].digitsRoot;

for (int i = 0; i < digitRList.Count; i++)

{

digitRList[i].parent = weapon[wID].digitsRoot;

}

break;

case ParentID.RobotForeArmL:

handL.parent = weapon[wID].digitsRoot;

for (int i = 0; i < digitLList.Count; i++)

{

digitLList[i].parent = weapon[wID].digitsRoot;

}

break;

}

}

// Return fingers from rocket punch projectile to robot

public void FingersToRobot(int wID)

{

switch (weapon[wID].parentID)

{

case ParentID.RobotForeArmR:

SetParent(foreArmR, catRoot.GetComponent<RobotCATStructure>().foreArmR);

SetParent(handR, catRoot.GetComponent<RobotCATStructure>().handR);

for (int k = 0; k < digitRList.Count; k++)

{

switch (digitRList[k].name)

{

case "RD00":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD00);

break;

case "RD01":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD01);

break;

case "RD02":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD02);

break;

case "RD10":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD10);

break;

case "RD11":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD11);

break;

case "RD12":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD12);

break;

case "RD20":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD20);

break;

case "RD21":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD21);

break;

case "RD22":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD22);

break;

case "RD30":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD30);

break;

case "RD31":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD31);

break;

case "RD32":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD32);

break;

case "RD40":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD40);

break;

case "RD41":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD41);

break;

case "RD42":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD42);

break;

}

}

return;

case ParentID.RobotForeArmL:

SetParent(foreArmL,catRoot.GetComponent<RobotCATStructure>().foreArmL);

SetParent(handL, catRoot.GetComponent<RobotCATStructure>().handL);

for (int k = 0; k < digitLList.Count; k++)

{

switch (digitLList[k].name)

{

case "LD00":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD00);

break;

case "LD01":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD01);

break;

case "LD02":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD02);

break;

case "LD10":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD10);

break;

case "LD11":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD11);

break;

case "LD12":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD12);

break;

case "LD20":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD20);

break;

case "LD21":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD21);

break;

case "LD22":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD22);

break;

case "LD30":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD30);

break;

case "LD31":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD31);

break;

case "LD32":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD32);

break;

case "LD40":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD40);

break;

case "LD41":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD41);

break;

case "LD42":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD42);

break;

}

}

return;

}

// If the current weapon is not foreArm, we fix both hand

// HandR

SetParent(handR, catRoot.GetComponent<RobotCATStructure>().handR);

for (int k = 0; k < digitRList.Count; k++)

{

switch (digitRList[k].name)

{

case "RD00":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD00);

break;

case "RD01":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD01);

break;

case "RD02":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD02);

break;

case "RD10":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD10);

break;

case "RD11":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD11);

break;

case "RD12":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD12);

break;

case "RD20":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD20);

break;

case "RD21":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD21);

break;

case "RD22":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD22);

break;

case "RD30":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD30);

break;

case "RD31":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD31);

break;

case "RD32":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD32);

break;

case "RD40":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD40);

break;

case "RD41":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD41);

break;

case "RD42":

SetParent(digitRList[k], catRoot.GetComponent<RobotCATStructure>().RD42);

break;

}

}

// HandL

SetParent(handL, catRoot.GetComponent<RobotCATStructure>().handL);

for (int k = 0; k < digitLList.Count; k++)

{

switch (digitLList[k].name)

{

case "LD00":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD00);

break;

case "LD01":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD01);

break;

case "LD02":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD02);

break;

case "LD10":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD10);

break;

case "LD11":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD11);

break;

case "LD12":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD12);

break;

case "LD20":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD20);

break;

case "LD21":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD21);

break;

case "LD22":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD22);

break;

case "LD30":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD30);

break;

case "LD31":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD31);

break;

case "LD32":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD32);

break;

case "LD40":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD40);

break;

case "LD41":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD41);

break;

case "LD42":

SetParent(digitLList[k], catRoot.GetComponent<RobotCATStructure>().LD42);

break;

}

}

}

// Super Electrical Drill Setup

// 1. create SED Move Path Prefab

// 2. Set robot parent to SED prefab, so robot can follow

// 3. Start SED Move Path Animation

// hit stationary robot: Full process, path1 to path4

// hit stationary robot: Half process: path1, path2, path7, path8

// hit moving robot, move to target original position: Path1, path2, then Path5(trigger by weapon effect dummy) , Path6

// hit statinoary non robot unit: path 1, path 2, 9, 7, 8

void SEDMove()

{

Vector3 direction = Vector3.zero;

Quaternion r;

switch (SEDMoveMode)

{

case SEDMoveModeStage.Path1Setup:

SEDMovePathAnimation = Instantiate(SEDMovePath1Prefab, transform.position, transform.rotation);

transform.parent = SEDMovePathAnimation.transform;

SEDMovePathAnimation.GetComponent<Animator>().SetTrigger("SEDMoveStart");

SEDMoveMode = SEDMoveModeStage.Path1;

break;

case SEDMoveModeStage.Path1:

// follow path dummy until idle animation

if (SEDMovePathAnimation.GetComponent<Animator>().GetCurrentAnimatorStateInfo(0).IsName("SED-Idle"))

{

transform.parent = null;

Destroy(SEDMovePathAnimation);

SEDMovePathAnimation = null; //missing -> null

SEDMoveMode = SEDMoveModeStage.Path2;

}

catRoot.Rotate(Vector3.up, SEDCATRotateSpeed * Time.deltaTime, Space.Self);

break;

case SEDMoveModeStage.Path2:

// weapon dummy hit target, enter stage3

if (NoWeaponProjectileInScene())

{

switch (target.GetComponent<RobotAI>().robotReactionToAttack)

{

case RobotReactionToAttack.RE_SEDFull:

SEDMoveMode = SEDMoveModeStage.Path3Setup;

break;

case RobotReactionToAttack.RE_SEDHalf:

SEDMoveMode = SEDMoveModeStage.Path3Setup;

break;

}

}

else

{

// robot fly to target, no path animation

if (target.GetComponent<RobotAI>())

direction = target.GetComponent<RobotAI>().catRoot.GetComponent<RobotCATStructure>().pelvis.position - transform.position;

else if(target.GetComponent<RobotTargetDummy>())

direction = target.GetComponent<RobotTargetDummy>().hitPoint - transform.position;

r = Quaternion.FromToRotation(Vector3.up, direction);

transform.Translate(direction.normalized * 100 * Time.deltaTime, Space.World); //150

transform.rotation = Quaternion.RotateTowards(transform.rotation, r, Time.deltaTime * 200);

catRoot.Rotate(Vector3.up, SEDCATRotateSpeed * Time.deltaTime, Space.Self);

}

break;

case SEDMoveModeStage.Path3Setup:

// 1. Adjust robot transform, so the drill can hit the target pelvis

// 2. Create a dummy on target pelvis that robot can follow later

transform.position = target.TransformPoint(new Vector3(0, 13.7f, 28f));

transform.rotation = robotOriginalRotation;

transform.Rotate(Vector3.right, 90, Space.Self);

emptyDummy = Instantiate(emptyDummyPrefab, transform.position, transform.rotation);

emptyDummy.transform.parent = target.GetComponentInParent<RobotAI>().catRoot.GetComponent<RobotCATStructure>().pelvis;

SEDMoveMode = SEDMoveModeStage.Path3;

break;

case SEDMoveModeStage.Path3:

// follow target animation until height is 30, the peak of the sed reaction animation

if (emptyDummy.transform.position.y >30 && target.GetComponent<RobotAI>().robotReactionToAttack == RobotReactionToAttack.RE_SEDFull)

{

Destroy(emptyDummy);

emptyDummy = null;

// Let RBA idle end

weapon[weaponID].animator.SetTrigger("PAE0");

weapon[GetComboWeaponID()].animator.SetTrigger("PAE0");

transform.rotation = robotOriginalRotation;

catRoot.localRotation = Quaternion.Euler(0, 0, 0);

// go to RA008 rather than standby

currentAnimation = RobotAnimation.Null;

animator.SetTrigger("Idle End");

SEDMoveMode = SEDMoveModeStage.Path4;

break;

}

// cannot use y position to check, because the robot only mainly rotating at the original position

// angle start at 180 to 100

// another main difference is the meleeDestination which is not the target original position.

else if (Vector3.Angle(transform.forward, Vector3.up) <120 && target.GetComponent<RobotAI>().robotReactionToAttack == RobotReactionToAttack.RE_SEDHalf)

{

Destroy(emptyDummy);

emptyDummy = null;

// Let RBA idle end

weapon[weaponID].animator.SetTrigger("PAE0");

weapon[GetComboWeaponID()].animator.SetTrigger("PAE0");

transform.rotation = robotOriginalRotation;

catRoot.localRotation = Quaternion.Euler(0, 0, 0);

// go to RA008 rather than standby

currentAnimation = RobotAnimation.Null;

animator.SetTrigger("Idle End");

SEDMoveMode = SEDMoveModeStage.Path4;

break;

}

// Locked emptyDummy X axis related to Target

// because target pelvis may rotate by animation after Path3 is setup, it will cause emptyDummy shift out of target transform.forward.

// a bit math to make sure emptyDummy is always on target.forward direction

emptyDummy.transform.parent = target;

emptyDummy.transform.localPosition = new Vector3(0,emptyDummy.transform.localPosition.y, emptyDummy.transform.localPosition.z);

emptyDummy.transform.parent = target.GetComponentInParent<RobotAI>().catRoot.GetComponent<RobotCATStructure>().pelvis;

transform.position = emptyDummy.transform.position;

transform.LookAt(target.GetComponentInParent<RobotAI>().catRoot.GetComponent<RobotCATStructure>().pelvis);

transform.Rotate(Vector3.right, 90, Space.Self);

catRoot.Rotate(Vector3.up, SEDCATRotateSpeed * Time.deltaTime, Space.Self);

break;

case SEDMoveModeStage.Path4:

// Now it should be RA008

// robot return to ground destination point

direction = meleeDestination - transform.position;

if (direction.magnitude > 1)

{

transform.Translate(direction.normalized * 30 * Time.deltaTime, Space.World);

direction = targetOriginalPosition - robotOriginalPosition;

r = Quaternion.LookRotation(direction, Vector3.up);

transform.rotation = Quaternion.RotateTowards(transform.rotation, robotOriginalRotation, 50*Time.deltaTime);

}

else

{

// applyrootmotion should be false when enter this part

if (animator.applyRootMotion == false)

{

// start animation that touch ground

transform.position = meleeDestination;

transform.rotation = robotOriginalRotation;

animator.applyRootMotion = true;

currentAnimation = RobotAnimation.Null;

animator.SetTrigger("Idle End");

}

else if (animator.GetComponent<Animator>().GetCurrentAnimatorStateInfo(0).IsName("RA008-I"))

{

animator.applyRootMotion = false;

catRoot.localRotation = Quaternion.Euler(0, 0, 0);

catRoot.localPosition = Vector3.zero;

currentAnimation = RobotAnimation.Null;

animator.SetTrigger("Idle End");

navAgent.enabled = true;

actionMode = RobotActionMode.Idle;

meleeMoveStart = false;

}

}

break;

case SEDMoveModeStage.Path5:

// When 2 SED robot hit, continue to move to target original destination top

direction = new Vector3(targetOriginalPosition.x, transform.position.y, targetOriginalPosition.z) - transform.position;

transform.Translate(direction.normalized * 100 * Time.deltaTime, Space.World); //150

catRoot.Rotate(Vector3.up, SEDCATRotateSpeed * Time.deltaTime, Space.Self);

if (direction.magnitude < 5)

{

// weapon dummy cannot be destoryed in OntriggerEnter, because it will trigger robot animation idle end

// so weapon dummy will destory here when robot arrive top of target original destination

CancelProjectileInScene(false);

// Let RBA idle end

weapon[weaponID].animator.SetTrigger("PAE0");

weapon[GetComboWeaponID()].animator.SetTrigger("PAE0");

transform.rotation = robotOriginalRotation;

catRoot.localRotation = Quaternion.Euler(0, 0, 0);

// go to RA008 rather than standby

currentAnimation = RobotAnimation.Null;

animator.SetTrigger("Idle End");

SEDMoveMode = SEDMoveModeStage.Path6;

}

break;

case SEDMoveModeStage.Path6:

// Fall to ground same as standard process in Path4

// Now it should be RA008

// robot return to ground destination point

direction = targetOriginalPosition - transform.position;

if (direction.magnitude > 1)

{

transform.Translate(direction.normalized * 30 * Time.deltaTime, Space.World);

direction = targetOriginalPosition - robotOriginalPosition;

r = Quaternion.LookRotation(direction, Vector3.up);

transform.rotation = Quaternion.RotateTowards(transform.rotation, robotOriginalRotation, 50 * Time.deltaTime);

}

else

{

// It should trigger once only and wait until the animation finish, so we use animator root to check

if (animator.applyRootMotion == false)

{

// start animation that touch ground

transform.position = meleeDestination;

transform.rotation = robotOriginalRotation;

animator.applyRootMotion = true;

currentAnimation = RobotAnimation.Null;

animator.SetTrigger("Idle End");

}

else if (animator.GetComponent<Animator>().GetCurrentAnimatorStateInfo(0).IsName("RA008-I"))

{

animator.applyRootMotion = false;

catRoot.localRotation = Quaternion.Euler(0, 0, 0);

catRoot.localPosition = Vector3.zero;

currentAnimation = RobotAnimation.Null;

animator.SetTrigger("Idle End");

navAgent.enabled = true;

actionMode = RobotActionMode.Idle;

meleeMoveStart = false;

}

}

break;

case SEDMoveModeStage.Path7:

// Rotate robot to original rotation

transform.rotation = Quaternion.RotateTowards(transform.rotation, robotOriginalRotation, Time.deltaTime*100);

catRoot.Rotate(Vector3.up, SEDCATRotateSpeed * Time.deltaTime, Space.Self);

if (Quaternion.Angle(transform.rotation, robotOriginalRotation) < 10)

{

transform.rotation = robotOriginalRotation;

catRoot.localRotation = Quaternion.Euler(0, 0, 0);

// Let RBA idle end

weapon[weaponID].animator.SetTrigger("PAE0");

weapon[GetComboWeaponID()].animator.SetTrigger("PAE0");

// transform.rotation = robotOriginalRotation;

// catRoot.localRotation = Quaternion.Euler(0, 0, 0);

// go to RA008 rather than standby

currentAnimation = RobotAnimation.Null;

animator.SetTrigger("Idle End");

SEDMoveMode = SEDMoveModeStage.Path8;

}

break;

case SEDMoveModeStage.Path8:

// Now it should be RA008

// Fall to ground same as standard process in Path4, or Path6

// The main difference is the location which is not get from target

// Use vector.down directly, the location do not matter.

if (transform.position.y > 1)

{

transform.Translate(Vector3.down * 30 * Time.deltaTime, Space.World);

direction = targetOriginalPosition - robotOriginalPosition;

r = Quaternion.LookRotation(direction, Vector3.up);

transform.rotation = Quaternion.RotateTowards(transform.rotation, robotOriginalRotation, 20 * Time.deltaTime);

}

else

{

// It should trigger once only and wait until the animation finish, so we use animator root to check

if (animator.applyRootMotion == false)

{

// start animation that touch ground

// transform.position = meleeDestination;

transform.rotation = robotOriginalRotation;

animator.applyRootMotion = true;

currentAnimation = RobotAnimation.Null;

animator.SetTrigger("Idle End");

}

else if (animator.GetComponent<Animator>().GetCurrentAnimatorStateInfo(0).IsName("RA008-I"))

{

animator.applyRootMotion = false;

catRoot.localRotation = Quaternion.Euler(0, 0, 0);

catRoot.localPosition = Vector3.zero;

currentAnimation = RobotAnimation.Null;

animator.SetTrigger("Idle End");

navAgent.enabled = true;

actionMode = RobotActionMode.Idle;

meleeMoveStart = false;

}

}

break;

case SEDMoveModeStage.Path9:

catRoot.Rotate(Vector3.up, SEDCATRotateSpeed * Time.deltaTime, Space.Self);

if (SEDPath9Timer + 0.3 < Time.time)

SEDMoveMode = SEDMoveModeStage.Path7;

break;

}

}

// set forearm Ik target

void SetArmIKTarge(bool set)

{

// To know what weapon should set ik target, the simple method is to have a bool in the weapon class,

// another method is to check the robot animation, only animation that point hand to target need to set

if (set)

{

if (currentAnimation == RobotAnimation.RA002L || currentAnimation == RobotAnimation.RA002R

|| currentAnimation == RobotAnimation.RA014L || currentAnimation == RobotAnimation.RA014R || currentAnimation == RobotAnimation.RA002RL)

{

// if target is robot, need to switch to chest, otherwise arm will point to terrain

if (target.GetComponent<RobotAI>())

{

if (weapon[weaponID].parentID == ParentID.RobotForeArmL || weapon[weaponID].parentID == ParentID.RobotHandL)

IKForeArmL.target = target.GetComponent<RobotAI>().chest;

else if (weapon[weaponID].parentID == ParentID.RobotForeArmR || weapon[weaponID].parentID == ParentID.RobotHandR)

IKForeArmR.target = target.GetComponent<RobotAI>().chest;

}

else

{

if (weapon[weaponID].parentID == ParentID.RobotForeArmL || weapon[weaponID].parentID == ParentID.RobotHandL)

IKForeArmL.target = target;

else if (weapon[weaponID].parentID == ParentID.RobotForeArmR || weapon[weaponID].parentID == ParentID.RobotHandR)

IKForeArmR.target = target;

}

// Adjust angle for special case, dont know why hand upside down on some animation

if (currentAnimation == RobotAnimation.RA014L)

IKForeArmL.forearm_OffsetRotation.x = 0;

else if (currentAnimation == RobotAnimation.RA014R)

IKForeArmR.forearm_OffsetRotation.x = 180;

}

IKForeArmL.UpdateIK();

IKForeArmR.UpdateIK();

}

else

{

IKForeArmL.target = null;

IKForeArmR.target = null;

}

}

void SetParent(Transform child, Transform parent)

{

child.position = parent.position;

child.rotation = parent.rotation;

child.SetParent(parent);

}

}

Baste · Sep 3, 2018

This is strange. As you said, line 200 of RobotAI isn't creating any MonoBehaviours. What's BattleManager.87, though? Is that perhaps declaring a new RobotAI?

Xhitman · Sep 3, 2018

Baste said: ↑

This is strange. As you said, line 200 of RobotAI isn't creating any MonoBehaviours. What's BattleManager.87, though? Is that perhaps declaring a new RobotAI?
Click to expand...

it is

Code (CSharp):

RobotAI currentSelectedRobotAI = new RobotAI();

Full code:

Code (CSharp):

using UnityEngine;

using Random = UnityEngine.Random;

using System;

using System.Collections;

using System.Collections.Generic;

using UnityEngine.EventSystems;

using System.IO;

using UnityEngine.UI;

using UnityEngine.AI;

using UnityEngine.SceneManagement;

using System.Linq;

using TMPro;

public class BattleManager : MonoBehaviour

{

//------New-------

bool enemyTurnStart = false;

//----- Assist

//--------Line sign

[SerializeField]

LineRenderer walkLine;

Vector3 currentRobotDestination;

//-------UI---------

public Slider HealthBarPrefab;

public Transform HealthBarGroup;

[SerializeField]

GameObject battleMapUI;

public SkillManager skillManager;

[SerializeField]

Text currentTurnText;

[SerializeField]

RectTransform optionMenu;

//---------Enemy Generator--------

[SerializeField]

GameObject enemyRobotSpherePrefab;

//------Map---------

[SerializeField]

Map map;

[SerializeField]

Transform BSLauncher;

[SerializeField]

GameObject terrain;

[SerializeField]

Transform currentRobotDestinationIcon;

[SerializeField]

Transform currentSelectedRoboIcon;

List<TextMeshPro> iconRangeText = new List<TextMeshPro>();

[SerializeField]

Transform robotTargetDummy; // when robot attack battleship etc, battleship.transform.position do not work anymore

[SerializeField]

GameObject robotCAT;

//-------RobotInfoWindow-----

[SerializeField]

RectTransform robotInfoWindow;

[SerializeField]

RectTransform mousePointTo;

//--------Facility---------

[SerializeField]

List<Transform> RBLauncherPlatform = new List<Transform>();

[SerializeField]

RectTransform robotButtonGroup;

// refer to the robots transform

public List<Transform> playerRobotTransformList = new List<Transform>();

public List<Transform> enemyRobotTransformList = new List<Transform>();

// refer to non-robot unit

public List<Transform> playerNonRobotUnitTransformList = new List<Transform>();

public List<Transform> enemyNonRobotUnitTransformList = new List<Transform>();

// healt bar list

public List<RectTransform> playerRobotHealthBarList = new List<RectTransform>();

public List<RectTransform> enemyRobotHealthBarList = new List<RectTransform>();

// Enemy Robot Sphere

public List<Transform> enemyRobotSphereList = new List<Transform>();

public Transform currentSelectedRobot = null;

RobotAI currentSelectedRobotAI = new RobotAI();

Transform assistRobot = null;

public int currentEnemyRobotIndex;

public int currentSelectedRobotWeaponID;

public Transform currentSelectedRobotTarget = null;

public Transform currentSelectedRBLauncher = null;

public enum UIMode { Idle, PlayerTurret, AddEnemy, PlayerRobotMove, WaitingRobotMove, WaitingRobotAttack, PlayerRobotRotate, PlayerRobotAttack, AssistAttack, CameraMoving, RBLauncher, EnemyTurn, RobotInfoWindow };

public UIMode uiMode;

enum SubUIMode { Null, RobotFromRBLauncher, WaitingRobotMoveFromLauncher, RobotToRBLauncher, WaitingRobotMoveToLauncher, EnemyMove, WaitingEnemyMove, WaitingEnemyAttack }

SubUIMode subuiMode;

bool addEnemy = true;

//Transform cameraTargetPoint = null;

// public List<Transform> PlayerRobotMovePath = new List<Transform>();

// public List<Vector3> PlayerRobotMovePath = new List<Vector3>();

// public List<GameObject> PlayerRobotMovePathHighlight = new List<GameObject>();

// Transform lastHitHex;

// Vector3 lastTilePoint;

//-------------------

// Constant section

const int LOSSphereCastRadius = 5;

const int LOSSphereCastRadiusOnTurret = 2;

//

public bool LoadFromResource = true;

GameObject cat;

RaycastHit hit;

//int currentBattleMapID;

// Mouse

public float firstClickTime, doubleClickTimer;

//--------------Camera------------

enum CameraMode { Idle, RobotAttackZoomIn, RobotAttackZoomOut, TraceProjectile, LookOn, AddEnemy, PlayerTurret, RobotDeath }

CameraMode cameraMode;

// Camera Control, adjustable by player in option setting

const float cameraMoveSpeed = 5, cameraRotateSpeed = 1;

float screenW = Screen.width;

float screenH = Screen.height;

float screenAutoScrollLenght;

[SerializeField]

Transform cameraHolder;

public Transform mainCamera; // acces by damage text on weapon effect manager

public Transform cutInCamera;

[SerializeField]

Transform focusCamera;

Transform cutInCameraTarget;

public Transform focusCameraTarget; // assign by robotai

// time to delay before disable after target kill, because want to focus until death explosion end, target null check cannot do so

float focusCameraDelayTimer;

[SerializeField]

Transform cutInCamerasRoot;

//float playerTurretCameraTimer;

// First, switch to camera for part animation

// Second, switch to camera for robot animation

// Front, Back, Left, Right

const int FrontUpNear = 0; // chest

const int FrontMiddleNear = 1; // pelvis

const int FrontDownNear = 2; // leg

const int BackNear = 3;

const int LeftMiddleNear = 4;

const int RightMiddleNear = 5;

const int LeftDownNear = 6;

const int RightDownNear = 7;

const int BackFar = 8;

const int LeftBackFar = 9;

const int RighBackFar = 10;

const int TopFrontNear = 11;

const int TopLeftNear = 12;

const int TopRightNear = 13;

int[] allowCutInCameraChest = { FrontUpNear, LeftMiddleNear, RightMiddleNear };

int[] allowCutInCameraBack = { BackNear, BackFar };

int[] allowCutInCameraAbdomen = { FrontMiddleNear, LeftMiddleNear, RightMiddleNear };

int[] allowCutInCameraPelvis = { FrontMiddleNear, LeftMiddleNear, RightMiddleNear };

int[] allowCutInCameraShoulderL = { TopFrontNear, TopLeftNear, TopRightNear };

int[] allowCutInCameraShoulderR = { TopFrontNear, TopLeftNear, TopRightNear };

int[] allowCutInCameraForeArmL = { FrontUpNear, LeftMiddleNear };

int[] allowCutInCameraForeArmR = { FrontUpNear, RightMiddleNear };

int[] allowCutInCameraCalfL = { LeftDownNear };

int[] allowCutInCameraCalfR = { RightDownNear };

int[] allowCutInCameraZoomOut = { BackFar, LeftBackFar, RighBackFar };

//----------------------UI----------------------

//---Mini Map-----

[SerializeField]

Transform miniMap;

[SerializeField]

GameObject dotEnemyPrefab;

[SerializeField]

GameObject dotPlayerPrefab;

[SerializeField]

Transform miniMapCamera;

List<GameObject> dotList = new List<GameObject>();

/*

//-------Unit Battle Info --------

[SerializeField] UnitBattleInfo unitBattleInfo = new BattleManager.UnitBattleInfo();

[Serializable]

class UnitBattleInfo

{

public TextMeshProUGUI name;

public TextMeshProUGUI armor;

public TextMeshProUGUI damage;

public TextMeshProUGUI range;

}

*/

public TextMeshProUGUI damageTMPPrefab;

//--------------------testing

public int starTurn;

public int currentTurn;

public AssetBundle assetBundle;

void Awake()

{

doubleClickTimer = 0.5f;

screenAutoScrollLenght = 50;

Data.canvas = transform;

Data.skillManager = skillManager;

// init icon text

for (int i = 0; i < currentSelectedRoboIcon.childCount; i++)

iconRangeText.Add(currentSelectedRoboIcon.GetChild(i).GetComponent<TextMeshPro>());

// Load asset bundle

string assetBundleFileName = "robotparts";

string assetBundleFileLocation = System.IO.Path.Combine(Application.streamingAssetsPath, assetBundleFileName);

// assetBundle = AssetBundle.LoadFromFile(assetBundleFileLocation);

// currentBattleMapID = Data.currenBattleMapID;

}

void Start()

{

NewGame();

GameObject obj;

int transformListID;

Data.currentMap = map;

// Set camera

if (Data.cameraPosition != Vector3.zero)

{

cameraHolder.position = Data.cameraPosition;

cameraHolder.rotation = Data.cameraRotation;

mainCamera.GetComponent<Camera>().orthographicSize = Data.cameraOrthographicSize;

}

//-------------------Load Robot

for (int i = 0; i < Data.playerRobot.Count; i++)

{

// load robot to scene if robot belong to this map

if (Data.playerRobot[i].map == map)

{

LoadRobot(Data.playerRobot[i], playerRobotTransformList);

transformListID = playerRobotTransformList.Count - 1;

Data.playerRobot[i].transformListID = transformListID;

playerRobotTransformList[transformListID].GetComponent<RobotAI>().robotIndex = i;

LoadColliderToRobotAI(playerRobotTransformList[transformListID]);

playerRobotTransformList[transformListID].GetComponent<RobotAI>().IgnoreRobotAllColliders();

playerRobotTransformList[transformListID].GetComponent<RobotAI>().ImportWeaponData();

playerRobotTransformList[transformListID].GetComponent<RobotAI>().moveDistanceMax = Data.playerRobot[i].moveMaxDistance;

playerRobotTransformList[transformListID].tag = Tag.PlayerRobot.ToString();

playerRobotTransformList[transformListID].position = Data.playerRobot[i].position;

playerRobotTransformList[transformListID].rotation = Data.playerRobot[i].rotation;

playerRobotTransformList[transformListID].name = i.ToString();

// Idle posture rather than standby if robot is at launcher

// also need to turn off nav agent

if (Data.playerRobot[i].onRBLauncher)

{

playerRobotTransformList[transformListID].GetComponent<RobotAI>().Idle(true);

playerRobotTransformList[transformListID].GetComponent<NavMeshAgent>().enabled = false;

}

// create health bar

obj = Instantiate(HealthBarPrefab, Vector3.zero, transform.rotation).gameObject;

obj.SetActive(true);

obj.transform.SetParent(HealthBarGroup);

playerRobotHealthBarList.Add(obj.GetComponent<RectTransform>());

// Get extra armor, damage from skill

skillManager.Init(Data.playerRobot[i]);

}

}

for (int i = 0; i < Data.enemyRobot.Count; i++)

{

if (Data.enemyRobot[i].map == map)

{

LoadRobot(Data.enemyRobot[i], enemyRobotTransformList);

transformListID = enemyRobotTransformList.Count - 1;

Data.enemyRobot[i].transformListID = transformListID;

enemyRobotTransformList[transformListID].GetComponent<RobotAI>().robotIndex = i;

LoadColliderToRobotAI(enemyRobotTransformList[transformListID]);

enemyRobotTransformList[transformListID].GetComponent<RobotAI>().IgnoreRobotAllColliders();

enemyRobotTransformList[transformListID].GetComponent<RobotAI>().ImportWeaponData();

enemyRobotTransformList[transformListID].GetComponent<RobotAI>().moveDistanceMax = Data.enemyRobot[i].moveMaxDistance;

enemyRobotTransformList[transformListID].tag = Tag.EnemyRobot.ToString();

enemyRobotTransformList[transformListID].position = Data.enemyRobot[i].position;

enemyRobotTransformList[transformListID].rotation = Data.enemyRobot[i].rotation;

// create health bar

obj = Instantiate(HealthBarPrefab, Vector3.zero, transform.rotation).gameObject;

obj.SetActive(true);

obj.transform.SetParent(HealthBarGroup);

enemyRobotHealthBarList.Add(obj.GetComponent<RectTransform>());

// Get extra armor, damage from skill

skillManager.Init(Data.enemyRobot[i]);

}

}

// Load Non Robot Unit

for (int i = 0; i < Data.playerNonRobotUnit.Count; i++)

{

// load only if unit in the current map

if (Data.playerNonRobotUnit[i].map == map)

{

obj = Instantiate(Resources.Load(GetResourcesPath(Data.playerNonRobotUnit[i].uniqueID))) as GameObject;

// if it is stronghold map, battleship should be on the bs launcher

if (Data.playerNonRobotUnit[i].type == NonRobotUnitType.BattleShip && map == Map.MainMap)

{

Data.playerNonRobotUnit[i].position = BSLauncher.GetComponent<FacilityManager>().lift.position;

Data.playerNonRobotUnit[i].rotation = BSLauncher.GetComponent<FacilityManager>().lift.rotation;

// make the battleship mount on lift, and set renderqueue, so it can be visible below terrain

obj.transform.parent = BSLauncher.GetComponent<FacilityManager>().lift;

BSLauncher.GetComponent<FacilityManager>().SetRenderQueue();

}

obj.transform.position = Data.playerNonRobotUnit[i].position;

obj.transform.rotation = Data.playerNonRobotUnit[i].rotation;

playerNonRobotUnitTransformList.Add(obj.transform);

}

}

}

// Setup Data for new game

// should be moved to New game button in title later

void NewGame()

{

// only setup data for strongHold battleship

if (Data.playerNonRobotUnit.Count == 0)

{

NonRobotUnit u = new NonRobotUnit();

u.uniqueID = "BattleShip001";

u.map = Map.MainMap;

Data.playerNonRobotUnit.Add(u);

}

// setup Data turn

for (int i = 0; i < Enum.GetNames(typeof(Map)).Length; i++)

{

Data.startTurn.Add(0);

Data.currentTurn.Add(0);

}

}

// Update is called once per frame

void FixedUpdate()

{

// test

starTurn = Data.startTurn[(int)map];

currentTurn = Data.currentTurn[(int)map];

//------

CameraControl();

FocusCamera();

ShowHealth();

MousePointTo();

MouseClick();

MiniMap();

//ShowUnitBattleInfo();

// Task that need to do even mouse not click

// Player Turn -> enemy Turn -> add enemy - > Player Turret -> repeat

switch (uiMode)

{

case UIMode.PlayerTurret:

//const float playerTurretCameraTime = 2;

// if (Time.time > playerTurretCameraTime + playerTurretCameraTimer)

{

uiMode = UIMode.Idle;

CutInCameraSelector(CameraMode.Idle);

Data.currentTurn[(int)Data.currentMap]++;

}

currentTurnText.text = Data.currentTurn[(int)Data.currentMap].ToString();

break;

case UIMode.AddEnemy:

// This is follow by enemy turn

// add enemy every 5 turn

// switch to idle mode when the enemy sphere detsory

if (Data.currentTurn[(int)Data.currentMap] % 1 == 0 && addEnemy)

{

addEnemy = false;

AddEnemyRobot();

CutInCameraSelector(CameraMode.AddEnemy);

}

// when sphere toucn ground, it will kill and remove itself from sphere list,

// so check sphere list count here to make sure no sphere on scene

if (enemyRobotSphereList.Count == 0)

{

addEnemy = true;

//bool idleMode = true;

// Let battleship turrets fire

for (int i = 0; i < playerNonRobotUnitTransformList.Count; i++)

playerNonRobotUnitTransformList[i].GetComponent<NonRobotUnitAI>().fire = true;

/*

for (int k = 0; k < playerNonRobotUnitTransformList[i].GetComponent<NonRobotUnitAI>(). turretList.Count; k++)

if (playerNonRobotUnitTransformList[i].GetComponent<NonRobotUnitAI>().turretList[k].GetComponent<TurretAI>().target != null)

{

playerNonRobotUnitTransformList[i].GetComponent<NonRobotUnitAI>().fire = true;

idleMode = false;

}

if (idleMode)

{

uiMode = UIMode.Idle;

CutInCameraSelector(CameraMode.Idle);

Data.currentTurn[(int)Data.currentMap]++;

}

else

{

*/

uiMode = UIMode.PlayerTurret;

// playerTurretCameraTimer = Time.time;

CutInCameraSelector(CameraMode.PlayerTurret);

}

break;

case UIMode.Idle:

// end turn when all player robot finish

// also need to check if any enemy robot still in counter attack

if (playerRobotTransformList.Count != 0)

{

enemyTurnStart = true;

for (int i = 0; i < playerRobotTransformList.Count; i++)

{

if (!Data.playerRobot[playerRobotTransformList[i].GetComponent<RobotAI>().robotIndex].attackedThisTurn && playerRobotTransformList[i].GetComponent<RobotAI>().actionMode == RobotActionMode.Idle)

{

enemyTurnStart = false;

break;

}

}

for (int i = 0; i < enemyRobotTransformList.Count; i++)

{

if (enemyRobotTransformList[i].GetComponent<RobotAI>().actionMode != RobotActionMode.Idle)

{

enemyTurnStart = false;

break;

}

}

// start enemy turn if all player robot acted

if (enemyTurnStart)

EndTurn();

}

break;

case UIMode.EnemyTurn:

// Two way to exit enemy turn:

// 1. enemy index ++ until index >= count

// 2. no enemy in scene or enemy index > = count suddenly due to robot death

if (enemyRobotTransformList.Count == 0 || currentEnemyRobotIndex >= enemyRobotTransformList.Count)

{

int rbIndex;

// Reset player robot action bool

foreach(Transform rb in playerRobotTransformList)

{

rbIndex = rb.GetComponent<RobotAI>().robotIndex;

Data.playerRobot[rbIndex].movedThisTurn = false;

Data.playerRobot[rbIndex].attackedThisTurn = false;

skillManager.ArmorRegen(rb);

}

currentEnemyRobotIndex = 0;

uiMode = UIMode.AddEnemy;

subuiMode = SubUIMode.Null;

}

else

{

switch (subuiMode)

{

case SubUIMode.EnemyMove:

AI.StartAI(enemyRobotTransformList[currentEnemyRobotIndex], playerRobotTransformList);

if (AI.targetSelected != null)

{

enemyRobotTransformList[currentEnemyRobotIndex].GetComponent<RobotAI>().Move(AI.destination, 1);

subuiMode = SubUIMode.WaitingEnemyMove;

}

else

{

// if current robot cannot move to target, skip to next robot

currentEnemyRobotIndex++;

if (currentEnemyRobotIndex >= enemyRobotTransformList.Count)

{

int rbIndex;

// Reset player robot action bool

foreach (Transform rb in playerRobotTransformList)

{

rbIndex = rb.GetComponent<RobotAI>().robotIndex;

Data.playerRobot[rbIndex].movedThisTurn = false;

Data.playerRobot[rbIndex].attackedThisTurn = false;

skillManager.ArmorRegen(rb);

}

currentEnemyRobotIndex = 0;

uiMode = UIMode.AddEnemy;

subuiMode = SubUIMode.Null;

}

}

break;

case SubUIMode.WaitingEnemyMove:

// when this enemy robot is moving while other enemy die, the currentEnemyRobotIndex will be invalid

// need to reasgin, now is done at explosion killer when destory robot

if (enemyRobotTransformList[currentEnemyRobotIndex].GetComponent<RobotAI>().actionMode == RobotActionMode.Idle)

{

int weaponID = WeaponSelector(enemyRobotTransformList[currentEnemyRobotIndex], AI.targetSelected);

if (weaponID != 99 && enemyRobotTransformList[currentEnemyRobotIndex].GetComponent<RobotAI>().weapon[weaponID].type != WeaponType.Shield)

{

skillManager.Attack(enemyRobotTransformList[currentEnemyRobotIndex], AI.targetSelected);

RobotAttack(enemyRobotTransformList[currentEnemyRobotIndex], AI.targetSelected, weaponID, true);

currentSelectedRobot = enemyRobotTransformList[currentEnemyRobotIndex];

CutInCameraSelector(CameraMode.RobotAttackZoomIn);

}

subuiMode = SubUIMode.WaitingEnemyAttack;

}

break;

case SubUIMode.WaitingEnemyAttack:

// process if robot and its target both idle

if (enemyRobotTransformList[currentEnemyRobotIndex].GetComponent<RobotAI>().actionMode == RobotActionMode.Idle)

{

CutInCameraSelector(CameraMode.Idle);

if (enemyRobotTransformList[currentEnemyRobotIndex].GetComponent<RobotAI>().target == null || enemyRobotTransformList[currentEnemyRobotIndex].GetComponent<RobotAI>().target.GetComponent<RobotAI>().actionMode == RobotActionMode.Idle)

{

skillManager.KillEffect(RobotSkill.Taunt, 0);

currentEnemyRobotIndex++;

subuiMode = SubUIMode.EnemyMove;

/*

if (currentEnemyRobotIndex >= enemyRobotTransformList.Count)

{

// Reset player robot action bool

for (int i = 0; i < playerRobotTransformList.Count; i++)

{

Data.playerRobot[playerRobotTransformList[i].GetComponent<RobotAI>().robotIndex].movedThisTurn = false;

Data.playerRobot[playerRobotTransformList[i].GetComponent<RobotAI>().robotIndex].attackedThisTurn = false;

}

currentEnemyRobotIndex = 0;

uiMode = UIMode.AddEnemy;

subuiMode = SubUIMode.Null;

}

*/

}

}

break;

}

}

break;

case UIMode.PlayerRobotMove:

DrawRobotMoveLine();

break;

case UIMode.PlayerRobotRotate:

RotatePlayerRobot();

break;

case UIMode.WaitingRobotMove:

switch (subuiMode)

{

case SubUIMode.Null:

// Normal robot move

if (currentSelectedRobotAI.actionMode == RobotActionMode.Idle)

{

Data.playerRobot[currentSelectedRobotAI.robotIndex].movedThisTurn = true;

uiMode = UIMode.WaitingRobotAttack;

}

break;

case SubUIMode.WaitingRobotMoveFromLauncher:

// Robot from RBLauncher to Map

if (currentSelectedRobotAI.actionMode == RobotActionMode.Idle)

{

Data.playerRobot[currentSelectedRobotAI.robotIndex].map = Map.MainMap;

Data.playerRobot[currentSelectedRobotAI.robotIndex].movedThisTurn = true;

uiMode = UIMode.WaitingRobotAttack;

currentSelectedRobot.GetComponent<NavMeshAgent>().enabled = true;

currentSelectedRBLauncher.GetComponent<FacilityManager>().resume = true;

currentSelectedRBLauncher = null;

subuiMode = SubUIMode.Null;

}

break;

case SubUIMode.RobotToRBLauncher:

if (currentSelectedRBLauncher.GetComponent<FacilityManager>().idle)

{

currentSelectedRobotAI.Move(currentRobotDestination, 1);

subuiMode = SubUIMode.WaitingRobotMoveToLauncher;

}

break;

case SubUIMode.WaitingRobotMoveToLauncher:

if (currentSelectedRobotAI.actionMode == RobotActionMode.Idle)

{

// if launch is false, the whole RBLauncher animation finish

if (!currentSelectedRBLauncher.GetComponent<FacilityManager>().launch)

{

currentSelectedRobot.position = RBLauncherPlatform[Data.playerRobot[currentSelectedRobotAI.robotIndex].RBLauncherPlatformID].position;

currentSelectedRobot.rotation = RBLauncherPlatform[Data.playerRobot[currentSelectedRobotAI.robotIndex].RBLauncherPlatformID].rotation;

currentSelectedRobot.parent = null;

Data.playerRobot[currentSelectedRobotAI.robotIndex].movedThisTurn = true;

Data.playerRobot[currentSelectedRobotAI.robotIndex].attackedThisTurn = true;

currentSelectedRobotAI.Idle(true);

currentSelectedRBLauncher = null;

currentSelectedRobot = null;

currentSelectedRobotAI = null;

subuiMode = SubUIMode.Null;

uiMode = UIMode.Idle;

}

else if (!currentSelectedRBLauncher.GetComponent<FacilityManager>().resume)

{

// To Launcher, launch is still true at this stage

// When resume complete, launch will be set to false in FacilityManager, so the above part will be executed

currentSelectedRobot.parent = currentSelectedRBLauncher.GetComponent<FacilityManager>().lift;

currentSelectedRBLauncher.GetComponent<FacilityManager>().resume = true;

// Turn off agent, so robot can move to undergroup

Data.playerRobot[currentSelectedRobotAI.robotIndex].onRBLauncher = true;

currentSelectedRobot.GetComponent<NavMeshAgent>().enabled = false;

currentSelectedRoboIcon.gameObject.SetActive(false);

}

}

break;

}

break;

case UIMode.PlayerRobotAttack:

if (currentSelectedRobot == null || currentSelectedRobotAI.actionMode == RobotActionMode.Idle)

{

// next stage: repeat attack or assist attack

// Return to Top view main camera

CutInCameraSelector(CameraMode.Idle);

if (currentSelectedRobotAI.repeatAttack > 0)

{

if (currentSelectedRobotTarget == null)

uiMode = UIMode.AssistAttack;

// wait until target

if (currentSelectedRobotTarget.GetComponent<RobotAI>().actionMode == RobotActionMode.Idle)

{

currentSelectedRobotAI.repeatAttack--;

skillManager.KillEffect(RobotSkill.Repeat_Attack, 0);

// do not attack if target destroyed

if (currentSelectedRobotTarget == null)

{

uiMode = UIMode.AssistAttack;

break;

}

if (currentSelectedRobotTarget.CompareTag(Tag.EnemyRobot.ToString()))

{

int weaponID = WeaponSelector(currentSelectedRobot, currentSelectedRobotTarget);

// do not use shield attack

if (weaponID != 99 && currentSelectedRobotAI.weapon[weaponID].type != WeaponType.Shield)

{

RobotAttack(currentSelectedRobot, currentSelectedRobotTarget, weaponID, true);

uiMode = UIMode.PlayerRobotAttack;

CutInCameraSelector(CameraMode.RobotAttackZoomIn);

//currentSelectedRoboIcon.gameObject.SetActive(false);

}

}

else if (currentSelectedRobotTarget.CompareTag(Tag.EnemyNonRobotUnit.ToString()))

{

/*

// dummy position should be on terrain, so all melee attack will be correct

// hit should be the part that player trying to attack

// rootbody is the unit on scene, not a part

robotTargetDummy.GetComponent<RobotTargetDummy>().hitTransform = hit.transform;

robotTargetDummy.GetComponent<RobotTargetDummy>().hitPoint = hit.point;

robotTargetDummy.GetComponent<RobotTargetDummy>().hitRootTransfrom = hit.transform.root;

robotTargetDummy.position = hit.transform.GetComponent<Collider>().ClosestPointOnBounds(currentSelectedRobot.position);

// robotTargetDummy.position = new Vector3(hit.point.x, 0, hit.point.z);

*/

int weaponID = WeaponSelector(currentSelectedRobot, robotTargetDummy);

if (weaponID != 99)

{

RobotAttack(currentSelectedRobot, currentSelectedRobotTarget, weaponID, true);

uiMode = UIMode.PlayerRobotAttack;

CutInCameraSelector(CameraMode.RobotAttackZoomIn);

// currentSelectedRoboIcon.gameObject.SetActive(false);

}

}

}

}

else

uiMode = UIMode.AssistAttack;

}

break;

case UIMode.AssistAttack:

// Let assist attack member to attack one by one

// also check for the case target die

if (currentSelectedRobotTarget == null)

{

currentSelectedRobotAI.assistAttackMember.Clear();

uiMode = UIMode.Idle;

break;

}

// 1. wait for selected robot idle to start assist process

// 2. In the assist process, need to wait for assist robot idle to start next assist robot

if (currentSelectedRobotAI.actionMode == RobotActionMode.Idle && currentSelectedRobotTarget.GetComponent<RobotAI>().actionMode == RobotActionMode.Idle)

{

if (currentSelectedRobotAI.assistAttackMember.Count == 0)

{

// wait until assist rb finish attack

if (assistRobot == null || assistRobot.GetComponent<RobotAI>().actionMode == RobotActionMode.Idle)

uiMode = UIMode.Idle;

}

else

{

//currentSelectedRobot = currentSelectedRobotAI.assistAttackMember[currentSelectedRobotAI.assistAttackMember.Count - 1];

int assistRbId = currentSelectedRobotAI.assistAttackMember.Count - 1;

assistRobot = currentSelectedRobotAI.assistAttackMember[assistRbId];

// wait for idle to make sure robot attack one by one

if (assistRobot.GetComponent<RobotAI>().actionMode == RobotActionMode.Idle)

{

int weaponID = WeaponSelector(assistRobot, currentSelectedRobotTarget);

if (weaponID != 99)

{

RobotAttack(assistRobot, currentSelectedRobotTarget, weaponID, false);

}

skillManager.KillEffect(RobotSkill.Assist_Attack_I, assistRbId);

currentSelectedRobotAI.assistAttackMember.RemoveAt(assistRbId);

}

}

}

break;

case UIMode.RBLauncher:

switch (subuiMode)

{

case SubUIMode.RobotFromRBLauncher:

if (currentSelectedRBLauncher.GetComponent<FacilityManager>().idle)

{

currentSelectedRobot.parent = null;

currentSelectedRobot.position = new Vector3(currentSelectedRobot.position.x, 0, currentSelectedRobot.position.z);

uiMode = UIMode.PlayerRobotMove;

subuiMode = SubUIMode.WaitingRobotMoveFromLauncher; // it will be used for checking when mouse cancel click

currentSelectedRobot.GetComponent<NavMeshAgent>().enabled = true;

}

break;

}

break;

}

}

// Load robot from Data to scene, and assign the robot transform to player/enemy transform list

public void LoadRobot(Robot r, List<Transform> robotList)

{

string partName;

GameObject rb, part;

Material[] materials;

// Create robot CAT

rb = Instantiate(robotCAT, r.position, r.rotation);

robotList.Add(rb.transform);

for (int i = 0; i < r.partsList.Count; i++)

{

partName = r.partsList[i].prefabID;

part = Instantiate(Resources.Load(GetResourcesPath(partName)), r.position, r.rotation) as GameObject;

part.name = part.name.Replace("(Clone)", "");

if (!partName.Contains("Digit"))

{

part.transform.parent = GetParent(rb.GetComponent<RobotAI>().catRoot, r.partsList[i].parentID);

part.transform.localPosition = r.partsList[i].localTransfrom.position;

part.transform.localRotation = r.partsList[i].localTransfrom.rotation;

part.transform.localScale = r.partsList[i].localTransfrom.scale;

part.GetComponent<RobotBodyPartSpec>().weapon.thisTransform = part.transform;

// Remove editor collider from part

if (part.GetComponent<ExtraWeaponSpec>() && part.GetComponent<ExtraWeaponSpec>().colliderForEditor != null)

{

part.GetComponent<ExtraWeaponSpec>().colliderForEditor.SetParent(null);

Destroy(part.GetComponent<ExtraWeaponSpec>().colliderForEditor.gameObject);

part.GetComponent<ExtraWeaponSpec>().colliderForEditor = null;

}

// set color according to Data

for (int k = 0; k < part.GetComponent<RobotBodyPartSpec>().subParts.Count; k++)

{

materials = part.GetComponent<RobotBodyPartSpec>().subParts[k].GetComponent<Renderer>().materials;

for (int j = 0; j < materials.Length; j++)

{

materials[j].color = r.partsList[i].subPartsColor[k].colorList[j];

}

Array.Clear(materials, 0, materials.Length);

}

// For Pelvis, set all small parts to their CAT

if (part.GetComponent<PelvisDetail>())

{

SetParent(part.GetComponent<PelvisDetail>().Buttock, rb.GetComponent<RobotAI>().catRoot.GetComponent<RobotCATStructure>().Buttock);

SetParent(part.GetComponent<PelvisDetail>().HipR, rb.GetComponent<RobotAI>().catRoot.GetComponent<RobotCATStructure>().HipR);

SetParent(part.GetComponent<PelvisDetail>().HipL, rb.GetComponent<RobotAI>().catRoot.GetComponent<RobotCATStructure>().HipL);

SetParent(part.GetComponent<PelvisDetail>().InguinaR, rb.GetComponent<RobotAI>().catRoot.GetComponent<RobotCATStructure>().InguinaR);

SetParent(part.GetComponent<PelvisDetail>().InguinaL, rb.GetComponent<RobotAI>().catRoot.GetComponent<RobotCATStructure>().InguinaL);

}

// assign part to robotAI script

// ignore extra weapon part, they are not body part

//if (!part.GetComponent<ExtraWeaponSpec>() ||(part.GetComponent<ExtraWeaponSpec>() && part.GetComponent<ExtraWeaponSpec>().bodypart) && !part.name.Contains("AttackSkill"))

if (part.name.Contains("AttackSkill"))

{ }

else if (part.GetComponent<ExtraWeaponSpec>() && !part.GetComponent<ExtraWeaponSpec>().bodypart)

{ }

else

switch (r.partsList[i].parentID)

{

case ParentID.RobotChest:

rb.GetComponent<RobotAI>().chest = part.transform;

break;

case ParentID.RobotBack:

rb.GetComponent<RobotAI>().back = part.transform;

break;

case ParentID.RobotAbdomen:

rb.GetComponent<RobotAI>().abdomen = part.transform;

break;

case ParentID.RobotPelvis:

rb.GetComponent<RobotAI>().pelvis = part.transform;

break;

case ParentID.RobotShoulderL:

rb.GetComponent<RobotAI>().shoulderL = part.transform;

break;

case ParentID.RobotShoulderR:

rb.GetComponent<RobotAI>().shoulderR = part.transform;

break;

case ParentID.RobotUpperArmL:

rb.GetComponent<RobotAI>().upperArmL = part.transform;

break;

case ParentID.RobotUpperArmR:

rb.GetComponent<RobotAI>().upperArmR = part.transform;

break;

case ParentID.RobotForeArmL:

rb.GetComponent<RobotAI>().foreArmL = part.transform;

break;

case ParentID.RobotForeArmR:

rb.GetComponent<RobotAI>().foreArmR = part.transform;

break;

case ParentID.RobotHandL:

rb.GetComponent<RobotAI>().handL = part.transform;

break;

case ParentID.RobotHandR:

rb.GetComponent<RobotAI>().handR = part.transform;

break;

case ParentID.RobotCalfL:

rb.GetComponent<RobotAI>().calfL = part.transform;

break;

case ParentID.RobotCalfR:

rb.GetComponent<RobotAI>().calfR = part.transform;

break;

case ParentID.RobotThighL:

rb.GetComponent<RobotAI>().thighL = part.transform;

break;

case ParentID.RobotThighR:

rb.GetComponent<RobotAI>().thighR = part.transform;

break;

case ParentID.RobotFootL:

rb.GetComponent<RobotAI>().footL = part.transform;

break;

case ParentID.RobotFootR:

rb.GetComponent<RobotAI>().footR = part.transform;

break;

}

}

else

{

// assign digit to CAT one by one

for (int k = part.transform.childCount - 1; k >= 0; k--)

{

// List for rockect punch

if (part.transform.GetChild(k).name.Contains("LD"))

rb.GetComponent<RobotAI>().digitLList.Add(part.transform.GetChild(k));

else

rb.GetComponent<RobotAI>().digitRList.Add(part.transform.GetChild(k));

// Set each digit color to digit root color

part.transform.GetChild(k).GetComponent<Renderer>().material.color = r.partsList[i].subPartsColor[0].colorList[0];

switch (part.transform.GetChild(k).name)

{

case "LD00":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotLD00));

break;

case "LD01":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotLD01));

break;

case "LD02":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotLD02));

break;

case "LD10":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotLD10));

break;

case "LD11":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotLD11));

break;

case "LD12":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotLD12));

break;

case "LD20":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotLD20));

break;

case "LD21":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotLD21));

break;

case "LD22":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotLD22));

break;

case "LD30":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotLD30));

break;

case "LD31":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotLD31));

break;

case "LD32":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotLD32));

break;

case "LD40":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotLD40));

break;

case "LD41":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotLD41));

break;

case "LD42":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotLD42));

break;

// Right

case "RD00":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotRD00));

break;

case "RD01":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotRD01));

break;

case "RD02":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotRD02));

break;

case "RD10":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotRD10));

break;

case "RD11":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotRD11));

break;

case "RD12":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotRD12));

break;

case "RD20":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotRD20));

break;

case "RD21":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotRD21));

break;

case "RD22":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotRD22));

break;

case "RD30":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotRD30));

break;

case "RD31":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotRD31));

break;

case "RD32":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotRD32));

break;

case "RD40":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotRD40));

break;

case "RD41":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotRD41));

break;

case "RD42":

SetParent(part.transform.GetChild(k), GetParent(rb.GetComponent<RobotAI>().catRoot, ParentID.RobotRD42));

break;

}

}

// destory the transparent palm

Destroy(part);

}

}

}

string GetResourcesPath(string partName)

{

string result = null;

if (partName.Contains("Head"))

result = "RobotBodyParts/Head/" + partName;

else if (partName.Contains("Ear"))

result = "RobotBodyParts/Head/" + partName;

else if (partName.Contains("Eye"))

result = "RobotBodyParts/Head/" + partName;

else if (partName.Contains("Helm"))

result = "RobotBodyParts/Head/" + partName;

else if (partName.Contains("Mouth"))

result = "RobotBodyParts/Head/" + partName;

else if (partName.Contains("Neck"))

result = "RobotBodyParts/Neck/" + partName;

else if (partName.Contains("Chest"))

result = "RobotBodyParts/Chest/" + partName;

else if (partName.Contains("Back"))

result = "RobotBodyParts/Back/" + partName;

else if (partName.Contains("Abdomen"))

result = "RobotBodyParts/Abdomen/" + partName;

else if (partName.Contains("Pelvis"))

result = "RobotBodyParts/Pelvis/" + partName;

else if (partName.Contains("ShoulderL"))

result = "RobotBodyParts/ShoulderL/" + partName;

else if (partName.Contains("ShoulderR"))

result = "RobotBodyParts/ShoulderR/" + partName;

else if (partName.Contains("UpperArmL"))

result = "RobotBodyParts/UpperArmL/" + partName;

else if (partName.Contains("UpperArmR"))

result = "RobotBodyParts/UpperArmR/" + partName;

else if (partName.Contains("ForeArmL"))

result = "RobotBodyParts/ForeArmL/" + partName;

else if (partName.Contains("ForeArmR"))

result = "RobotBodyParts/ForeArmR/" + partName;

else if (partName.Contains("HandL"))

result = "RobotBodyParts/HandL/" + partName;

else if (partName.Contains("HandR"))

result = "RobotBodyParts/HandR/" + partName;

else if (partName.Contains("DigitR"))

result = "RobotBodyParts/HandR/" + partName;

else if (partName.Contains("DigitL"))

result = "RobotBodyParts/HandL/" + partName;

else if (partName.Contains("CalfR"))

result = "RobotBodyParts/CalfR/" + partName;

else if (partName.Contains("CalfL"))

result = "RobotBodyParts/CalfL/" + partName;

else if (partName.Contains("ThighL"))

result = "RobotBodyParts/ThighL/" + partName;

else if (partName.Contains("ThighR"))

result = "RobotBodyParts/ThighR/" + partName;

else if (partName.Contains("FootL"))

result = "RobotBodyParts/FootL/" + partName;

else if (partName.Contains("FootR"))

result = "RobotBodyParts/FootR/" + partName;

else if (partName.Contains("BattleShip"))

result = "NonRobotUnit/" + partName;

else if (partName.Contains("ExtraWeapon"))

result = "ExtraWeapon/" + partName;

else if (partName.Contains("AttackSkill"))

result = "AttackSkill/" + partName;

return result;

/*

string[] path;

path = Directory.GetFiles(Application.dataPath, partName + ".prefab", SearchOption.AllDirectories);

path[0] = path[0].Replace(Application.dataPath, "");

path[0] = path[0].Replace(".prefab", "");

path[0] = path[0].Replace(@"\", "/");

path[0] = path[0].Replace("/Resources/", "");

return path[0];

*/

}

// Get the robot CAT transform structure by ParentID

Transform GetParent(Transform rbCAT, ParentID parentID)

{

// Find parent, ie. bone, of this part

switch (parentID)

{

case ParentID.RobotHead:

return rbCAT.GetComponent<RobotCATStructure>().head;

case ParentID.RobotNeck:

return rbCAT.GetComponent<RobotCATStructure>().neck;

case ParentID.RobotChest:

return rbCAT.GetComponent<RobotCATStructure>().chest;

case ParentID.RobotBack:

return rbCAT.GetComponent<RobotCATStructure>().back;

case ParentID.RobotAbdomen:

return rbCAT.GetComponent<RobotCATStructure>().abdomen;

case ParentID.RobotPelvis:

return rbCAT.GetComponent<RobotCATStructure>().pelvis;

case ParentID.RobotShoulderL:

return rbCAT.GetComponent<RobotCATStructure>().shoulderL;

case ParentID.RobotShoulderR:

return rbCAT.GetComponent<RobotCATStructure>().shoulderR;

case ParentID.RobotUpperArmL:

return rbCAT.GetComponent<RobotCATStructure>().upperArmL;

case ParentID.RobotUpperArmR:

return rbCAT.GetComponent<RobotCATStructure>().upperArmR;

case ParentID.RobotForeArmL:

return rbCAT.GetComponent<RobotCATStructure>().foreArmL;

case ParentID.RobotForeArmR:

return rbCAT.GetComponent<RobotCATStructure>().foreArmR;

case ParentID.RobotHandL:

return rbCAT.GetComponent<RobotCATStructure>().handL;

case ParentID.RobotHandR:

return rbCAT.GetComponent<RobotCATStructure>().handR;

case ParentID.RobotThighL:

return rbCAT.GetComponent<RobotCATStructure>().thighL;

case ParentID.RobotThighR:

return rbCAT.GetComponent<RobotCATStructure>().thighR;

case ParentID.RobotCalfL:

return rbCAT.GetComponent<RobotCATStructure>().calfL;

case ParentID.RobotCalfR:

return rbCAT.GetComponent<RobotCATStructure>().calfR;

case ParentID.RobotFootL:

return rbCAT.GetComponent<RobotCATStructure>().footL;

case ParentID.RobotFootR:

return rbCAT.GetComponent<RobotCATStructure>().footR;

//--------Digit

case ParentID.RobotLD00:

return rbCAT.GetComponent<RobotCATStructure>().LD00;

case ParentID.RobotLD01:

return rbCAT.GetComponent<RobotCATStructure>().LD01;

case ParentID.RobotLD02:

return rbCAT.GetComponent<RobotCATStructure>().LD02;

case ParentID.RobotLD10:

return rbCAT.GetComponent<RobotCATStructure>().LD10;

case ParentID.RobotLD11:

return rbCAT.GetComponent<RobotCATStructure>().LD11;

case ParentID.RobotLD12:

return rbCAT.GetComponent<RobotCATStructure>().LD12;

case ParentID.RobotLD20:

return rbCAT.GetComponent<RobotCATStructure>().LD20;

case ParentID.RobotLD21:

return rbCAT.GetComponent<RobotCATStructure>().LD21;

case ParentID.RobotLD22:

return rbCAT.GetComponent<RobotCATStructure>().LD22;

case ParentID.RobotLD30:

return rbCAT.GetComponent<RobotCATStructure>().LD30;

case ParentID.RobotLD31:

return rbCAT.GetComponent<RobotCATStructure>().LD31;

case ParentID.RobotLD32:

return rbCAT.GetComponent<RobotCATStructure>().LD32;

case ParentID.RobotLD40:

return rbCAT.GetComponent<RobotCATStructure>().LD40;

case ParentID.RobotLD41:

return rbCAT.GetComponent<RobotCATStructure>().LD41;

case ParentID.RobotLD42:

return rbCAT.GetComponent<RobotCATStructure>().LD42;

// R Digit

case ParentID.RobotRD00:

return rbCAT.GetComponent<RobotCATStructure>().RD00;

case ParentID.RobotRD01:

return rbCAT.GetComponent<RobotCATStructure>().RD01;

case ParentID.RobotRD02:

return rbCAT.GetComponent<RobotCATStructure>().RD02;

case ParentID.RobotRD10:

return rbCAT.GetComponent<RobotCATStructure>().RD10;

case ParentID.RobotRD11:

return rbCAT.GetComponent<RobotCATStructure>().RD11;

case ParentID.RobotRD12:

return rbCAT.GetComponent<RobotCATStructure>().RD12;

case ParentID.RobotRD20:

return rbCAT.GetComponent<RobotCATStructure>().RD20;

case ParentID.RobotRD21:

return rbCAT.GetComponent<RobotCATStructure>().RD21;

case ParentID.RobotRD22:

return rbCAT.GetComponent<RobotCATStructure>().RD22;

case ParentID.RobotRD30:

return rbCAT.GetComponent<RobotCATStructure>().RD30;

case ParentID.RobotRD31:

return rbCAT.GetComponent<RobotCATStructure>().RD31;

case ParentID.RobotRD32:

return rbCAT.GetComponent<RobotCATStructure>().RD32;

case ParentID.RobotRD40:

return rbCAT.GetComponent<RobotCATStructure>().RD40;

case ParentID.RobotRD41:

return rbCAT.GetComponent<RobotCATStructure>().RD41;

case ParentID.RobotRD42:

return rbCAT.GetComponent<RobotCATStructure>().RD42;

}

return null;

}

//--------------------------------------------------------------------

void SetParent(Transform child, Transform parent)

{

child.position = parent.position;

child.rotation = parent.rotation;

child.SetParent(parent);

}

public void LoadColliderToRobotAI(Transform r)

{

Transform[] parts;

parts = r.GetComponentsInChildren<Transform>();

// ignore extra weapon collider

for (int i = 0; i < parts.Length; i++)

{

if (parts[i].GetComponent<BoxCollider>())

r.GetComponent<RobotAI>().robotBodyPartColliderList.Add(parts[i].GetComponent<BoxCollider>());

}

}

//---------------------Camera------------------

void CameraControl()

{

// 1. Idle Mode, allow to control camera

// 2. Player , Enemy Robot attack, cut in camera, cant control

// 3. Add enemy , cut in camera

// 4. turret attack, cut in camera

switch (cameraMode)

{

case CameraMode.Idle:

if (mainCamera.gameObject.activeSelf)

{

// Zoom

if (Input.mouseScrollDelta == Vector2.down)

Camera.main.orthographicSize += 10;

else if (Input.mouseScrollDelta == Vector2.up)

Camera.main.orthographicSize -= 10;

if (Camera.main.orthographicSize <= 0)

Camera.main.orthographicSize = 10;

else if (Camera.main.orthographicSize >= 300)

Camera.main.orthographicSize = 300;

// Rotate

if (Input.GetKey(KeyCode.E))

Camera.main.transform.Rotate(Vector3.up * cameraRotateSpeed, Space.World);

else if (Input.GetKey(KeyCode.Q))

Camera.main.transform.Rotate(Vector3.down * cameraRotateSpeed, Space.World);

// Move, Z use camera forward project vector, X use camera right

if (Input.GetButton("Horizontal") || Input.GetButton("Vertical"))

{

Vector3 projectVector = Vector3.ProjectOnPlane(Camera.main.transform.forward, Vector3.up);

cameraHolder.Translate(projectVector * Input.GetAxisRaw("Vertical") * cameraMoveSpeed, Space.World);

cameraHolder.Translate(Camera.main.transform.right * Input.GetAxisRaw("Horizontal") * cameraMoveSpeed, Space.World);

}

// Camera Up Down

if (Input.GetKey(KeyCode.Z))

Camera.main.transform.Rotate(Vector3.right * cameraRotateSpeed, Space.Self);

else if (Input.GetKey(KeyCode.X))

Camera.main.transform.Rotate(Vector3.left * cameraRotateSpeed, Space.Self);

}

break;

case CameraMode.RobotAttackZoomIn:

Weapon wp = currentSelectedRobotAI.weapon[currentSelectedRobotWeaponID];

// Zoom Out Camera when robot melee start

if (currentSelectedRobotAI.meleeMoveStart)

{

CutInCameraSelector(CameraMode.RobotAttackZoomOut);

}

// For arms that may move out of camera, such as SED

// if (cutInCameraTarget != null)

// cutInCamera.LookAt(cutInCameraTarget);

// For Turret, camera target is assigned by the turretAI, because it is turret to fire projectile

// robody part turret dummy -> turretAI fire true -> fire projectiles

// only check when cutincamera target is not assign

if (cutInCameraTarget == null)

{

// For turret, do not check the wp.projectile, check the turret AI projectiles direclty

if (wp.thisTransform.GetComponent<TurretAI>())

{

// wait until turret fire

if (wp.thisTransform.GetComponent<TurretAI>().projectilesInScene.Count != 0)

{

cutInCameraTarget = wp.thisTransform.GetComponent<TurretAI>().projectilesInScene[0];

}

}

else

{

// area emission is different from other, need to trace its camera dummy

if (wp.projectile0.projectileInScene.Count != 0 && wp.projectile0.projectileInScene[0] != null)

{

if (wp.type == WeaponType.AreaEmission)

cutInCameraTarget = wp.projectile0.projectileInScene[0].GetComponent<WeaponEffectManager>().cutInCameraTraceDummy;

else

cutInCameraTarget = wp.projectile0.projectileInScene[0].transform;

}

else if (wp.projectile1.projectileInScene.Count != 0 && wp.projectile1.projectileInScene[0] != null)

{

if (wp.type == WeaponType.AreaEmission)

cutInCameraTarget = wp.projectile1.projectileInScene[0].GetComponent<WeaponEffectManager>().cutInCameraTraceDummy;

else

cutInCameraTarget = wp.projectile1.projectileInScene[0].transform;

}

}

}

// How camera react after zoom in dependen on weapon type

// only check when cutincamera target is assign

if (cutInCameraTarget != null)

switch (wp.type)

{

case WeaponType.RocketPunch:

// camera trace rocket punch or not

if (Random.Range(0, 2) >= 1)

CutInCameraSelector(CameraMode.TraceProjectile);

else

CutInCameraSelector(CameraMode.RobotAttackZoomOut);

break;

case WeaponType.Beam:

if (Random.Range(0, 2) >= 1)

CutInCameraSelector(CameraMode.TraceProjectile);

else

CutInCameraSelector(CameraMode.RobotAttackZoomOut);

break;

case WeaponType.Projectile:

if (Random.Range(0, 2) >= 1)

CutInCameraSelector(CameraMode.TraceProjectile);

else

CutInCameraSelector(CameraMode.RobotAttackZoomOut);

break;

case WeaponType.Funnel:

// camera trace rocket punch or not

if (Random.Range(0, 2) >= 1)

CutInCameraSelector(CameraMode.TraceProjectile);

else

CutInCameraSelector(CameraMode.RobotAttackZoomOut);

break;

case WeaponType.SelfAOE:

// switch camera when the sphere is large enough to touch camera

if (Vector3.Distance(cutInCameraTarget.GetComponent<Renderer>().bounds.ClosestPoint(cutInCamera.position), cutInCamera.position) < 5)

CutInCameraSelector(CameraMode.Idle);

break;

case WeaponType.Missile:

if (Random.Range(0, 2) >= 1)

CutInCameraSelector(CameraMode.TraceProjectile);

else

CutInCameraSelector(CameraMode.RobotAttackZoomOut);

break;

case WeaponType.MachineGun:

// wait a bit before switch camera

// but i dont want to add a timer, so just count on the projectile in scene

if (wp.projectile0.projectileInScene.Count >= wp.projectile0.projectileMuzzleLocation.Count)

{

if (Random.Range(0, 2) >= 1)

CutInCameraSelector(CameraMode.TraceProjectile);

else

CutInCameraSelector(CameraMode.RobotAttackZoomOut);

}

break;

case WeaponType.AreaEmission:

CutInCameraSelector(CameraMode.RobotAttackZoomOut);

break;

case WeaponType.Sword:

CutInCameraSelector(CameraMode.RobotAttackZoomOut);

break;

case WeaponType.FlameThrower:

CutInCameraSelector(CameraMode.RobotAttackZoomOut);

break;

case WeaponType.Turret:

CutInCameraSelector(CameraMode.TraceProjectile);

break;

case WeaponType.DefendTurret:

CutInCameraSelector(CameraMode.TraceProjectile);

break;

case WeaponType.KneeStrike:

// lock on knee is better for view

//CutInCameraSelector(CameraMode.TraceProjectile);

cutInCamera.GetComponent<Camera>().fieldOfView = 70;

cameraMode = CameraMode.LookOn;

break;

case WeaponType.SuperElectricalDrill:

CutInCameraSelector(CameraMode.LookOn);

break;

}

break;

case CameraMode.LookOn:

// camera follow robot

cutInCamerasRoot.position = currentSelectedRobot.position;

cutInCamerasRoot.rotation = currentSelectedRobot.rotation;

break;

case CameraMode.TraceProjectile:

if (cutInCameraTarget != null)

{

cutInCamera.LookAt(cutInCameraTarget);

}

break;

case CameraMode.RobotAttackZoomOut:

if(currentSelectedRobot!=null)

cutInCamerasRoot.position = currentSelectedRobot.position;

if (cutInCameraTarget != null)

{

cutInCamera.LookAt(cutInCameraTarget);

}

break;

case CameraMode.AddEnemy:

if (cutInCamera.parent == null)

CutInCameraSelector(CameraMode.Idle);

break;

case CameraMode.RobotDeath:

if (cutInCameraTarget == null)

{

cameraMode = CameraMode.Idle;

CutInCameraSelector(CameraMode.Idle);

}

break;

}

}

void CutInCameraSelector(CameraMode cm)

{

// 1. Pick a default camera from list based on body part when robot attack

// 2. Set field of view based on body part

int cameraID = 0;

// do not change camera if now is death mode

// death mode only allow to change when robot disappear

if (cameraMode == CameraMode.RobotDeath)

return;

switch (cm)

{

case CameraMode.RobotAttackZoomIn:

// Save camera

Data.cameraPosition = cameraHolder.position;

Data.cameraRotation = cameraHolder.rotation;

Data.cameraOrthographicSize = mainCamera.GetComponent<Camera>().orthographicSize;

// do not zoom in if setting is 0 or 50% test

// 2 cases: player and enemy

if (uiMode == UIMode.EnemyTurn)

{

// enemy

if (Data.optionMenuEnemyCameraSetting == 0)

return;

if (Data.optionMenuEnemyCameraSetting == 1)

if (Random.Range(0, 2) == 0)

return;

}

else

{

// player

if (Data.optionMenuPlayerCameraSetting == 0)

return;

if (Data.optionMenuPlayerCameraSetting == 1)

if (Random.Range(0, 2) == 0)

return;

}

Weapon wp = currentSelectedRobotAI.weapon[currentSelectedRobotWeaponID];

cutInCameraTarget = null;

switch (wp.parentID)

{

case ParentID.RobotChest:

cameraID = allowCutInCameraChest[Random.Range(0, allowCutInCameraChest.Length)];

cutInCamera.GetComponent<Camera>().fieldOfView = 30;

break;

case ParentID.RobotBack:

cameraID = allowCutInCameraBack[Random.Range(0, allowCutInCameraBack.Length)];

cutInCamera.GetComponent<Camera>().fieldOfView = 30;

break;

case ParentID.RobotAbdomen:

cameraID = allowCutInCameraAbdomen[Random.Range(0, allowCutInCameraAbdomen.Length)];

cutInCamera.GetComponent<Camera>().fieldOfView = 30;

break;

case ParentID.RobotPelvis:

cameraID = allowCutInCameraPelvis[Random.Range(0, allowCutInCameraPelvis.Length)];

cutInCamera.GetComponent<Camera>().fieldOfView = 20;

break;

case ParentID.RobotShoulderL:

cameraID = allowCutInCameraShoulderL[Random.Range(0, allowCutInCameraShoulderL.Length)];

cutInCamera.GetComponent<Camera>().fieldOfView = 30;

break;

case ParentID.RobotShoulderR:

cameraID = allowCutInCameraShoulderR[Random.Range(0, allowCutInCameraShoulderR.Length)];

cutInCamera.GetComponent<Camera>().fieldOfView = 30;

break;

case ParentID.RobotForeArmL:

if (wp.type == WeaponType.SuperElectricalDrill)

cameraID = TopFrontNear;

else

cameraID = allowCutInCameraForeArmL[Random.Range(0, allowCutInCameraForeArmL.Length)];

cutInCamera.GetComponent<Camera>().fieldOfView = 30;

cutInCameraTarget = currentSelectedRobotAI.foreArmL;

break;

case ParentID.RobotForeArmR:

if (wp.type == WeaponType.SuperElectricalDrill)

cameraID = FrontUpNear;

else

cameraID = allowCutInCameraForeArmR[Random.Range(0, allowCutInCameraForeArmR.Length)];

cutInCamera.GetComponent<Camera>().fieldOfView = 30;

cutInCameraTarget = currentSelectedRobotAI.foreArmR;

break;

case ParentID.RobotCalfL:

// Do not zoom in if kick

if (wp.type == WeaponType.SideKick01)

{

CutInCameraSelector(CameraMode.RobotAttackZoomOut);

return;

}

else

{

cameraID = allowCutInCameraCalfL[Random.Range(0, allowCutInCameraCalfL.Length)];

cutInCamera.GetComponent<Camera>().fieldOfView = 30;

}

break;

case ParentID.RobotCalfR:

// Do not zoom in if kick

if (wp.type == WeaponType.SideKick01)

{

CutInCameraSelector(CameraMode.RobotAttackZoomOut);

return;

}

else

{

cameraID = allowCutInCameraCalfR[Random.Range(0, allowCutInCameraCalfR.Length)];

cutInCamera.GetComponent<Camera>().fieldOfView = 30;

}

break;

}

// Move cameraRoot to robot

cutInCamerasRoot.position = currentSelectedRobot.position;

cutInCamerasRoot.rotation = currentSelectedRobot.rotation;

// Move camera to cameraRoot child and enable it

cutInCamera.parent = cutInCamerasRoot.GetChild(cameraID);

cutInCamera.localPosition = Vector3.zero;

cutInCamera.localRotation = Quaternion.Euler(0, 0, 0);

cameraMode = CameraMode.RobotAttackZoomIn;

mainCamera.gameObject.SetActive(false);

cutInCamera.gameObject.SetActive(true);

break;

case CameraMode.RobotAttackZoomOut:

cameraID = allowCutInCameraZoomOut[Random.Range(0, allowCutInCameraZoomOut.Length)];

cutInCamera.GetComponent<Camera>().fieldOfView = 40;

// Move cameraRoot to robot

cutInCamerasRoot.position = currentSelectedRobot.position;

cutInCamerasRoot.rotation = currentSelectedRobot.rotation;

// Move camera to cameraRoot child and enable it

cutInCamera.parent = cutInCamerasRoot.GetChild(cameraID);

cutInCamera.localPosition = Vector3.zero;

cutInCamera.localRotation = Quaternion.Euler(0, 0, 0);

cameraMode = CameraMode.RobotAttackZoomOut;

mainCamera.gameObject.SetActive(false);

cutInCamera.gameObject.SetActive(true);

break;

case CameraMode.TraceProjectile:

cutInCamera.parent = null;

cameraMode = CameraMode.TraceProjectile;

mainCamera.gameObject.SetActive(false);

cutInCamera.gameObject.SetActive(true);

break;

case CameraMode.Idle:

cameraHolder.position = Data.cameraPosition;

cameraHolder.rotation = Data.cameraRotation;

mainCamera.GetComponent<Camera>().orthographicSize = Data.cameraOrthographicSize;

cameraMode = CameraMode.Idle;

cutInCamera.parent = null;

cutInCamera.gameObject.SetActive(false);

mainCamera.gameObject.SetActive(true);

break;

case CameraMode.AddEnemy:

cameraMode = CameraMode.AddEnemy;

// Save camera

Data.cameraPosition = cameraHolder.position;

Data.cameraRotation = cameraHolder.rotation;

Data.cameraOrthographicSize = mainCamera.GetComponent<Camera>().orthographicSize;

cutInCamera.parent = enemyRobotSphereList[0];

cutInCamera.position = enemyRobotSphereList[0].GetComponent<EnemyRobotSphere>().cameraLocation.position;

cutInCamera.rotation = enemyRobotSphereList[0].GetComponent<EnemyRobotSphere>().cameraLocation.rotation;

mainCamera.gameObject.SetActive(false);

cutInCamera.gameObject.SetActive(true);

break;

case CameraMode.PlayerTurret:

//cameraHolder.position = playerNonRobotUnitTransformList[0].GetComponent<NonRobotUnitAI>().cameraLocation.position;

//cameraHolder.rotation = playerNonRobotUnitTransformList[0].GetComponent<NonRobotUnitAI>().cameraLocation.rotation;

/*

cameraMode = CameraMode.PlayerTurret;

cutInCamera.parent = null;

cutInCamera.position = enemyRobotSphereList[0].GetComponent<EnemyRobotSphere>().cameraLocation.position;

cutInCamera.rotation = enemyRobotSphereList[0].GetComponent<EnemyRobotSphere>().cameraLocation.rotation;

mainCamera.gameObject.SetActive(false);

cutInCamera.gameObject.SetActive(true);

*/

break;

case CameraMode.RobotDeath:

Debug.Log("a");

cameraMode = CameraMode.RobotDeath;

// Save camera

Data.cameraPosition = cameraHolder.position;

Data.cameraRotation = cameraHolder.rotation;

Data.cameraOrthographicSize = mainCamera.GetComponent<Camera>().orthographicSize;

// Move cameraRoot to robot

cutInCamerasRoot.position = cutInCameraTarget.position;

cutInCamerasRoot.rotation = cutInCameraTarget.rotation;

// Move camera to cameraRoot child and enable it

cutInCamera.parent = cutInCamerasRoot.GetChild(allowCutInCameraChest[Random.Range(0, allowCutInCameraChest.Length)]);

cutInCamera.localPosition = Vector3.zero;

cutInCamera.localRotation = Quaternion.Euler(0, 0, 0);

mainCamera.gameObject.SetActive(false);

cutInCamera.gameObject.SetActive(true);

break;

}

}

void FocusCamera()

{

// only work on robot death now

if (focusCameraTarget != null && !focusCamera.gameObject.activeSelf)

{

List<Vector3> positionOption = new List<Vector3>();

positionOption.Add(new Vector3(0, 16, 25));

positionOption.Add(new Vector3(0, 27, 25));

positionOption.Add(new Vector3(0, 30, -25));

focusCamera.gameObject.SetActive(true);

focusCamera.position = focusCameraTarget.position + positionOption[Random.Range(0, positionOption.Count - 1)];

focusCamera.LookAt(focusCameraTarget.GetComponent<RobotAI>().chest);

focusCameraDelayTimer = Time.time;

}

if (focusCameraTarget == null && focusCamera.gameObject.activeSelf)

{

const float focusCameraDelay = 3;

if (Time.time > focusCameraDelayTimer + focusCameraDelay)

focusCamera.gameObject.SetActive(false);

}

}

void MouseClick()

{

// not allow to click object behind ui

if (!EventSystem.current.IsPointerOverGameObject())

{

if (Input.GetMouseButtonDown(0))

{

Ray ray = mainCamera.GetComponent<Camera>().ScreenPointToRay(Input.mousePosition);

if (Physics.Raycast(ray, out hit))

{

switch (uiMode)

{

case UIMode.Idle:

if (hit.transform.root.GetComponent<RobotAI>())

{

currentSelectedRobot = hit.transform.root;

currentSelectedRobotAI = hit.transform.root.GetComponent<RobotAI>();

}

if (hit.transform.root.CompareTag(Tag.PlayerRobot.ToString()))

{

if (!Data.playerRobot[hit.transform.root.GetComponent<RobotAI>().robotIndex].movedThisTurn)

{

currentSelectedRobot = hit.transform.root;

currentSelectedRobotAI = hit.transform.root.GetComponent<RobotAI>();

currentSelectedRobot.GetComponent<NavMeshAgent>().enabled = true;

uiMode = UIMode.PlayerRobotMove;

}

else if (!Data.playerRobot[hit.transform.root.GetComponent<RobotAI>().robotIndex].attackedThisTurn)

{

currentSelectedRobot = hit.transform.root;

currentSelectedRobotAI = hit.transform.root.GetComponent<RobotAI>();

uiMode = UIMode.WaitingRobotAttack;

}

}

else if (hit.transform.root.CompareTag(Tag.Facility.ToString()))

{

// hide map, disable mesh, collider

terrain.SetActive(false);

hit.transform.root.GetComponent<FacilityManager>().Focus(true);

//cameraTargetPoint = hit.transform.root.GetComponent<FacilityManager>().cameraPoint;

currentSelectedRBLauncher = hit.transform.root;

uiMode = UIMode.RBLauncher;

}

break;

case UIMode.RBLauncher:

switch (subuiMode)

{

case SubUIMode.Null:

// When player click robot directly

if (hit.transform.root.CompareTag(Tag.PlayerRobot.ToString()))

{

// Show status, edit, color button near mouse

//currentSelectedRobot = hit.transform.root;

}

// When player click on the plate of the robot fixture

else

{

Transform whatToCheck = null;

int platformID = 99;

// Use name to decide what is clicked, better than put a script in each object

if (hit.transform.name.Contains("Platform"))

whatToCheck = hit.transform;

else if (hit.transform.name.Contains("Launch"))

whatToCheck = hit.transform.parent; // = platform

else if (hit.transform.name.Contains("StatusPanel"))

whatToCheck = hit.transform.parent.parent; // = platform

// 1. find out if the click platform is in the RBLauncherPlatform

for (int i = 0; i < RBLauncherPlatform.Count; i++)

if (GameObject.ReferenceEquals(RBLauncherPlatform[i], whatToCheck))

{

platformID = i;

// also reset currentSelectedRBLauncher, the reason is player may click a RBlaucnher, and then click platform in other RBLauncher

currentSelectedRBLauncher.GetComponent<FacilityManager>().Focus(false);

currentSelectedRBLauncher = RBLauncherPlatform[i].root;

}

// 2. If not, break

if (platformID == 99)

break;

if (hit.transform.name.Contains("Platform"))

LoadRobotEditor(platformID);

else if (hit.transform.name.Contains("Launch"))

LaunchRobot(platformID);

else if (hit.transform.name.Contains("StatusPanel"))// 3. Load robot editor

{

// need to assign currentRobot

for (int i = 0; i < Data.playerRobot.Count; i++)

if (Data.playerRobot[i].onRBLauncher && Data.playerRobot[i].RBLauncherPlatformID == platformID)

{

currentSelectedRobot = playerRobotTransformList[i];

currentSelectedRobotAI = playerRobotTransformList[i].GetComponent<RobotAI>();

RobotInfoWindow();

}

}

}

break;

}

break;

case UIMode.PlayerRobotMove:

float navAgentSphereCastRadius = currentSelectedRobot.GetComponent<NavMeshAgent>().radius;

// check the choice base on what really hit on destination

Physics.SphereCast(currentRobotDestination + new Vector3(0, 300, 0), navAgentSphereCastRadius, Vector3.down, out hit);

if (hit.transform.root.CompareTag(Tag.Facility.ToString()) && hit.transform.root.GetComponent<FacilityManager>().type == FacilityManager.Type.RBLauncher)

{

// Move from map to RBLauncher

{

if (RBLauncherPlatform[Data.playerRobot[currentSelectedRobotAI.robotIndex].RBLauncherPlatformID].IsChildOf(hit.transform.root))

{

walkLine.enabled = false;

//currentSelectedRoboIcon.transform.position = new Vector3(currentRobotDestination.x, currentSelectedRoboIcon.transform.position.y, currentRobotDestination.z);

currentRobotDestinationIcon.gameObject.SetActive(false);

uiMode = UIMode.WaitingRobotMove;

subuiMode = SubUIMode.RobotToRBLauncher;

currentSelectedRBLauncher = hit.transform.root;

hit.transform.root.GetComponent<FacilityManager>().launch = true;

}

}

}

else if (hit.transform.root.tag == Tag.Map.ToString())

{

walkLine.enabled = false;

SelectedRoboIcon(currentSelectedRobot, currentRobotDestination);

//currentSelectedRoboIcon.position = new Vector3(currentRobotDestination.x, currentSelectedRoboIcon.transform.position.y, currentRobotDestination.z);

currentRobotDestinationIcon.gameObject.SetActive(false);

uiMode = UIMode.WaitingRobotMove;

currentSelectedRobotAI.Move(currentRobotDestination, 1);

}

break;

case UIMode.WaitingRobotAttack:

// 3 case: Robot, robotTargetDummy(for nonRobotUnit), Turret(height is not too low for robot normal attack)

if (!Data.playerRobot[currentSelectedRobotAI.robotIndex].attackedThisTurn)

{

// click enemy robot (transform.root)

if (hit.transform.root.CompareTag(Tag.EnemyRobot.ToString()))

{

int weaponID = WeaponSelector(currentSelectedRobot, hit.transform.root);

// do not use shield attack

if (weaponID != 99 && currentSelectedRobotAI.weapon[weaponID].type != WeaponType.Shield)

{

currentSelectedRobotTarget = hit.transform.root;

skillManager.Attack(currentSelectedRobot, currentSelectedRobotTarget);

RobotAttack(currentSelectedRobot, currentSelectedRobotTarget, weaponID, true);

uiMode = UIMode.PlayerRobotAttack;

CutInCameraSelector(CameraMode.RobotAttackZoomIn);

currentSelectedRoboIcon.gameObject.SetActive(false);

}

else

{

Debug.Log("cannotattack");

}

}

// For nonrobot unit , when the unit is too big, we cannot use transform.position

// For turret, its pivot may not be at the terrain too

// need a special method:

// 1. place a dummy on the click position.

// 2. then robot attack this dummy in the same process as robot attack robot

else if (hit.transform.CompareTag(Tag.EnemyNonRobotUnit.ToString()))

{

// dummy position should be on terrain, so all melee attack will be correct

// hit should be the part that player trying to attack

// rootbody is the unit on scene, not a part

robotTargetDummy.GetComponent<RobotTargetDummy>().hitTransform = hit.transform;

robotTargetDummy.GetComponent<RobotTargetDummy>().hitPoint = hit.point;

robotTargetDummy.GetComponent<RobotTargetDummy>().hitRootTransfrom = hit.transform.root;

robotTargetDummy.position = hit.transform.GetComponent<Collider>().ClosestPointOnBounds(currentSelectedRobot.position);

// robotTargetDummy.position = new Vector3(hit.point.x, 0, hit.point.z);

int weaponID = WeaponSelector(currentSelectedRobot, robotTargetDummy);

if (weaponID != 99)

{

currentSelectedRobotTarget = robotTargetDummy;

RobotAttack(currentSelectedRobot, currentSelectedRobotTarget, weaponID, true);

uiMode = UIMode.PlayerRobotAttack;

CutInCameraSelector(CameraMode.RobotAttackZoomIn);

currentSelectedRoboIcon.gameObject.SetActive(false);

}

else

{

Debug.Log("cannotattack");

}

}

}

break;

case UIMode.PlayerRobotRotate:

// when robot move from launcher, but stay at the launcher tile, i.e. rotate mode at launcher tile

if (subuiMode == SubUIMode.WaitingRobotMoveFromLauncher)

{

//currentSelectedRobot.position = RBLauncherPlatform[Data.playerRobot[currentSelectedRobotAI.robotIndex].RBLauncherPlatformID].position;

//currentSelectedRobot.rotation = RBLauncherPlatform[Data.playerRobot[currentSelectedRobotAI.robotIndex].RBLauncherPlatformID].rotation;

Data.playerRobot[currentSelectedRobotAI.robotIndex].map = Map.MainMap;

}

uiMode = UIMode.Idle;

subuiMode = SubUIMode.Null;

if (currentSelectedRBLauncher != null)

currentSelectedRBLauncher.GetComponent<FacilityManager>().resume = true;

currentSelectedRBLauncher = null;

currentSelectedRobot = null;

currentSelectedRobotAI = null;

break;

}

}

}

else if (Input.GetMouseButtonDown(1))

{

// if cancel during launching, it will cause problem

if (subuiMode != SubUIMode.RobotFromRBLauncher)

{

if (uiMode == UIMode.WaitingRobotAttack)

{

currentSelectedRoboIcon.gameObject.SetActive(false);

Data.playerRobot[currentSelectedRobotAI.robotIndex].attackedThisTurn = true;

}

if (currentSelectedRBLauncher != null)

currentSelectedRBLauncher.GetComponent<FacilityManager>().Focus(false);

if (subuiMode == SubUIMode.WaitingRobotMoveFromLauncher)

{

currentSelectedRobot.position = RBLauncherPlatform[Data.playerRobot[currentSelectedRobotAI.robotIndex].RBLauncherPlatformID].position;

currentSelectedRobot.rotation = RBLauncherPlatform[Data.playerRobot[currentSelectedRobotAI.robotIndex].RBLauncherPlatformID].rotation;

currentSelectedRBLauncher.GetComponent<FacilityManager>().resume = true;

Data.playerRobot[currentSelectedRobotAI.robotIndex].onRBLauncher = false;

currentSelectedRBLauncher = null;

subuiMode = SubUIMode.Null;

}

currentSelectedRobot = null;

currentSelectedRobotAI = null;

terrain.SetActive(true);

uiMode = UIMode.Idle;

}

}

}

// ==============HotKey Section

if (Input.GetKeyDown(KeyCode.Escape))

{

if (optionMenu.gameObject.activeInHierarchy)

optionMenu.gameObject.SetActive(false);

else

optionMenu.gameObject.SetActive(true);

}

}

//----------------Facility Section----------------------------------------------------

// load robot to scene, 99 means edit old robot

// Data.robotIndexForRobotEditor need to be defined before calling this function

void LoadRobotEditor(int platformID)

{

// Find out this platform have robot or not by comparing Data.playerRobot.RBLaucnher Platform

for (int i = 0; i < Data.playerRobot.Count; i++)

if (Data.playerRobot[i].RBLauncherPlatformID == platformID)

{

// Only edit robot if it is on RBLauncher

if (Data.playerRobot[i].onRBLauncher)

{

// edit old robot

Data.robotIndexForRobotEditor = i;

SavePlayerRobotData();

SaveEnemyRobotData();

// Save camera

Data.cameraPosition = cameraHolder.position;

Data.cameraRotation = cameraHolder.rotation;

Data.cameraOrthographicSize = mainCamera.GetComponent<Camera>().orthographicSize;

SceneManager.LoadScene(SceneList.RobotEditor.ToString());

return;

}

else

return;

}

// If fail to loadscene above, it means it is a new robot

// Check if create new robot or not by the max allow player robot

if (playerRobotTransformList.Count < Data.playerRobotMax)

{

// Save transformList to Data

SavePlayerRobotData();

SaveEnemyRobotData();

Robot r = new Robot();

r.RBLauncherPlatformID = platformID;

r.map = map;

r.onRBLauncher = true;

r.position = RBLauncherPlatform[platformID].position;

r.rotation = RBLauncherPlatform[platformID].rotation;

r.armor = r.armorMax;

r.armorLastTurn = r.armor;

r.moveMaxDistance = Data.robotMoveMaxDistance;

// Create attackMatrix instance, Cannot init because no body parts yet

/* for (int i = 0; i < 5; i++)

{

Robot.AttackMatrix am = new Robot.AttackMatrix();

r.attackMatrix.Add(am);

}

*/

Data.playerRobot.Add(r);

Data.robotIndexForRobotEditor = Data.playerRobot.Count - 1;

// Save camera

Data.cameraPosition = cameraHolder.position;

Data.cameraRotation = cameraHolder.rotation;

Data.cameraOrthographicSize = mainCamera.GetComponent<Camera>().orthographicSize;

SceneManager.LoadScene(SceneList.RobotEditor.ToString());

}

}

// Launch robot from RBLauncher

void LaunchRobot(int platformID)

{

// Find out the robot is on Platform or not

for (int i = 0; i < Data.playerRobot.Count; i++)

if (Data.playerRobot[i].RBLauncherPlatformID == platformID)

{

// If robot is on Platform, launch

if (Data.playerRobot[i].onRBLauncher)

{

Data.playerRobot[i].onRBLauncher = false;

int transformListID = Data.playerRobot[i].transformListID;

playerRobotTransformList[transformListID].parent = currentSelectedRBLauncher.GetComponent<FacilityManager>().lift;

playerRobotTransformList[transformListID].localPosition = Vector3.zero;

playerRobotTransformList[transformListID].rotation = currentSelectedRBLauncher.GetComponent<FacilityManager>().lift.rotation;

currentSelectedRBLauncher.GetComponent<FacilityManager>().launch = true;

terrain.SetActive(true);

currentSelectedRBLauncher.GetComponent<FacilityManager>().Focus(false);

LaunchRobotRendererQueue(playerRobotTransformList[transformListID]);

// uiMode is still RBLaucnher

subuiMode = SubUIMode.RobotFromRBLauncher;

currentSelectedRobot = playerRobotTransformList[transformListID];

currentSelectedRobotAI = playerRobotTransformList[transformListID].GetComponent<RobotAI>();

currentSelectedRobotAI.Idle(false);

return;

}

// if robot not on Platform, do nothing

return;

}

}

// Set renderer queue, so robot can be visible under map

void LaunchRobotRendererQueue(Transform robot)

{

const int queue = 1500;

// Set render quene for all parts

Transform[] partList = robot.GetComponentsInChildren<Transform>();

for (int i = 0; i < partList.Length; i++)

if (partList[i].GetComponent<Renderer>())

partList[i].GetComponent<Renderer>().material.renderQueue = queue;

}

//----------------Facility Section End----------------------------------------------------

//------------Player Robot Section------------------------------------------------------

// Show player selected robot move Hex on map, only call after clicked robot

void DrawRobotMoveLine()

{

Vector3 checkPoint = Vector3.zero;

Vector3 hitPoint; // we dont use hit.point from raycast, because it may be any object in scene

RaycastHit hit2;

const float radiusBuffer = 1;

walkLine.enabled = true;

currentRobotDestinationIcon.gameObject.SetActive(true);

currentSelectedRoboIcon.gameObject.SetActive(true);

SelectedRoboIcon(currentSelectedRobot, currentSelectedRobot.position);

// currentSelectedRoboIcon.position = currentSelectedRobot.position + new Vector3(0, currentSelectedRoboIcon.transform.position.y, 0);

// 1. get mouse hit point

// 2. any collider block ?

Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);

if (Physics.Raycast(ray, out hit))

{

hitPoint = new Vector3(hit.point.x, 0, hit.point.z); // translate to a point on Terrain

NavMeshPath path = new NavMeshPath();

float navAgentSphereCastRadius = currentSelectedRobot.GetComponent<NavMeshAgent>().radius + radiusBuffer;

checkPoint = new Vector3(hitPoint.x, 300, hitPoint.z);

if (Vector3.Distance(currentSelectedRobot.position, hitPoint) <= currentSelectedRobotAI.moveDistanceMax)

{

currentSelectedRobot.GetComponent<NavMeshAgent>().CalculatePath(hitPoint, path);

// accept this hitpoint only if raycast hit the map, y=0, and the path complete

if (Physics.SphereCast(checkPoint, navAgentSphereCastRadius, Vector3.down, out hit2) && hit2.transform.tag == Tag.Map.ToString() && hit2.point.y == 0 && path.status == NavMeshPathStatus.PathComplete)

currentRobotDestination = hitPoint;

// click RBlauncher is allowed

else if (hit2.transform.root.name.Contains("RBLauncher"))

currentRobotDestination = new Vector3(hit2.transform.root.position.x, 0, hit2.transform.root.position.z);

// Debug.Log(hit2.transform + " " + currentSelectedRobot.GetComponent<NavMeshAgent>().CalculatePath(hitPoint, path));

}

else

{

// if distance between mouse point and robot bigger than move distance limit, decide the destination point by direction and length

Vector3 direction = hitPoint - currentSelectedRobot.position;

direction = direction.normalized * currentSelectedRobotAI.moveDistanceMax;

// in case mouse point on where is not walkable, need to find the closest walkable point along the direction

do

{

checkPoint = currentSelectedRobot.position + direction;

currentSelectedRobot.GetComponent<NavMeshAgent>().CalculatePath(checkPoint, path);

// y == 0 to make sure the point is not on mountain

if (Physics.SphereCast(checkPoint + new Vector3(0, 300, 0), navAgentSphereCastRadius, Vector3.down, out hit2) && hit2.transform.tag == Tag.Map.ToString() && hit2.point.y == 0 && path.status == NavMeshPathStatus.PathComplete)

break;

direction -= direction.normalized;

} while (direction.magnitude > 10);

currentRobotDestination = checkPoint;

}

// shift up, so not overlap with map

walkLine.SetPosition(0, currentSelectedRobot.position + Vector3.up);

walkLine.SetPosition(1, currentRobotDestination + Vector3.up);

currentRobotDestinationIcon.transform.position = new Vector3(currentRobotDestination.x, currentRobotDestinationIcon.transform.position.y, currentRobotDestination.z);

}

}

void RotatePlayerRobot()

{

Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);

int distance = 0;

if (Physics.Raycast(ray, out hit) && hit.transform.name == "Map")

{

distance = (int)Vector3.Distance(new Vector3(hit.point.x, 0, hit.point.z), new Vector3(currentSelectedRobot.transform.position.x, 0, currentSelectedRobot.transform.position.z));

if (distance != 0)

currentSelectedRobot.LookAt(new Vector3(hit.point.x, 0, hit.point.z));

}

}

void RobotAttack(Transform rb, Transform target, int weaponID, bool counter)

{

// the case that robot try to attack a dieing target, when the target is destoryed, it cause null error

if (target == null)

return;

int defendWpID = 99;

rb.GetComponent<RobotAI>().target = target;

if (target.GetComponent<RobotAI>())

rb.GetComponent<RobotAI>().targetCATRoot = target.GetComponent<RobotAI>().catRoot;

else if (target.GetComponent<RobotTargetDummy>())

rb.GetComponent<RobotAI>().targetCATRoot = target;

rb.LookAt(target);

rb.GetComponent<RobotAI>().WeaponFire(weaponID);

currentSelectedRobotWeaponID = weaponID;

// target defend

// robot can defend, but non robot unit cannot defend

if (counter)

{

if (target.CompareTag(Tag.PlayerRobot.ToString()) || target.CompareTag(Tag.EnemyRobot.ToString()))

{

// no matter whether target can defend or not, look at robot

target.LookAt(rb);

target.GetComponent<RobotAI>().target = rb;

target.GetComponent<RobotAI>().targetCATRoot = rb.GetComponent<RobotAI>().catRoot;

if (rb.tag == Tag.PlayerRobot.ToString())

defendWpID = WeaponSelector(target, rb);

else

defendWpID = WeaponSelector(target, rb);

if (defendWpID != 99)

{

target.GetComponent<RobotAI>().WeaponFire(defendWpID);

}

else

{

// weaponfire turn off both robots nav agent

// turn on NAV agent if target cannot attack

target.GetComponent<NavMeshAgent>().enabled = true;

}

}

}

else

{

if (rb.CompareTag(Tag.PlayerRobot.ToString()))

Data.playerRobot[rb.GetComponent<RobotAI>().robotIndex].thisIsAssistAttack = true;

else if(rb.CompareTag(Tag.EnemyRobot.ToString()))

Data.enemyRobot[rb.GetComponent<RobotAI>().robotIndex].thisIsAssistAttack = true;

// weaponfire turn off both robots nav agent

// turn on NAV agent if target cannot attack

target.GetComponent<NavMeshAgent>().enabled = true;

}

}

// Select weapon

// 1. Find weapon to attack

// 2. If weapon available, find shield to defend.

int WeaponSelector(Transform rb, Transform target)

{

Layer oldLayer = (Layer)rb.gameObject.layer;

// the case that robot try to attack a dieing target, when the target is destoryed, it cause null error

if (target == null)

return 99;

Vector3 direction = target.position - rb.position;

float distance = direction.magnitude;

int wpIDR;

int wpIDL;

// two cases: hand have weapon or not

// weapon list is already sort by range

// robot should use shortest range weapon, because it is unlikely to get interrupt

// by default, larger range, higher damage, but more animation to be interrupt

// Check hand weapon first

// Then normal weapon check loop, it will repeat checking on the hand weapon, but it should fail because of the range

// and it create a problem, that some weapon should not be allowed to use when weapon on hand

// need to add a check point in the weapon check loop if hand weapon exit

// ignore raycast on whole robot collider

SetLayer(rb.gameObject, Layer.IgnoreRayCast);

if (rb.GetComponent<RobotAI>().ExtraWpR != null || rb.GetComponent<RobotAI>().ExtraWpL != null)

{

// 1. check if robot can use hand weapon attack

// 2. if no, pick weapon from weapon list that is "Stand by" animation

wpIDR = rb.GetComponent<RobotAI>().weaponIDExtraWpR;

if (wpIDR != 99)

{

// Check Right Hand

if (target.GetComponent<RobotAI>())

{

if (Physics.SphereCast(rb.GetComponent<RobotAI>().chest.position, LOSSphereCastRadius, direction, out hit, rb.GetComponent<RobotAI>().weapon[wpIDR].range) && hit.transform.root == target)

{

SetLayer(rb.gameObject, oldLayer);

return wpIDR;

}

}

else if (target.GetComponent<RobotTargetDummy>())

{

if (Physics.SphereCast(rb.GetComponent<RobotAI>().chest.position, LOSSphereCastRadius, direction, out hit, rb.GetComponent<RobotAI>().weapon[wpIDR].range) && hit.transform.root == target.GetComponent<RobotTargetDummy>().hitRootTransfrom)

{

SetLayer(rb.gameObject, oldLayer);

return wpIDR;

}

}

}

// Check Left Hand, if right hand weapon out of range

wpIDL = rb.GetComponent<RobotAI>().weaponIDExtraWpL;

if (wpIDL != 99)

{

if (target.GetComponent<RobotAI>())

{

if (Physics.SphereCast(rb.GetComponent<RobotAI>().chest.position, LOSSphereCastRadius, direction, out hit, rb.GetComponent<RobotAI>().weapon[wpIDL].range) && hit.transform.root == target)

{

SetLayer(rb.gameObject, oldLayer);

return wpIDL;

}

}

else if (target.GetComponent<RobotTargetDummy>())

{

if (Physics.SphereCast(rb.GetComponent<RobotAI>().chest.position, LOSSphereCastRadius, direction, out hit, rb.GetComponent<RobotAI>().weapon[wpIDL].range) && hit.transform.root == target.GetComponent<RobotTargetDummy>().hitRootTransfrom)

{

SetLayer(rb.gameObject, oldLayer);

return wpIDL;

}

}

}

}

// standard weapon checking loop

// Special check condition for weapon on Hand:

// 1. if hand weapon exit, forearmhand and hand weapon should not be consider

// 2. some robot animation should be ban.

for (int i = 0; i < rb.GetComponent<RobotAI>().weapon.Count; i++)

{

if (rb.GetComponent<RobotAI>().ExtraWpR != null && rb.GetComponent<RobotAI>().weapon[i].parentID == ParentID.RobotForeArmR)

{

// Remove foreArmR weapon from choice

}

else if (rb.GetComponent<RobotAI>().ExtraWpL != null && rb.GetComponent<RobotAI>().weapon[i].parentID == ParentID.RobotForeArmL)

{

// Remove foreArmL weapon from choice

}

else if ((rb.GetComponent<RobotAI>().ExtraWpR != null || rb.GetComponent<RobotAI>().ExtraWpL != null) && !Data.ExtraWeaponAllowAnimationList.Contains(rb.GetComponent<RobotAI>().weapon[i].RA0))

{

// ban robot animation when either hand have weapon

}

else if (rb.GetComponent<RobotAI>().weapon[i].type == WeaponType.DefendTurret)

{

// remove defend turret from choice

}

else

{

// check CD, LOS(include range check)

// 3 case: Robot, robotTargetDummy(for nonRobotUnit), Turret(height is not too low for robot normal attack)

if (rb.GetComponent<RobotAI>().weapon[i].coolDownTimer + rb.GetComponent<RobotAI>().weapon[i].coolDown <= Data.currentTurn[(int)Data.currentMap])

{

if (target.GetComponent<RobotAI>())

{

/*

Physics.SphereCast(rb.GetComponent<RobotAI>().chest.position, LOSSphereCastRadius, direction, out hit, rb.GetComponent<RobotAI>().weapon[i].range);

if (hit.transform != null)

Debug.Log(hit.transform.root + " " + rb.GetComponent<RobotAI>().weapon[i].range + " " + hit.transform);

else

Debug.Log("nul" + " " + rb.GetComponent<RobotAI>().weapon[i].range);

*/

if (Physics.SphereCast(rb.GetComponent<RobotAI>().chest.position, LOSSphereCastRadius, direction, out hit, rb.GetComponent<RobotAI>().weapon[i].range) && hit.transform.root == target)

{

SetLayer(rb.gameObject, oldLayer);

return i;

}

}

else if (target.GetComponent<RobotTargetDummy>())

{

/*

Physics.SphereCast(rb.GetComponent<RobotAI>().chest.position, LOSSphereCastRadius, direction, out hit, rb.GetComponent<RobotAI>().weapon[i].range);

if (hit.transform != null)

Debug.Log(hit.transform.root + " " + rb.GetComponent<RobotAI>().weapon[i].range + " " + target.GetComponent<RobotTargetDummy>().hitRootTransfrom);

else

Debug.Log("nul" + " " + rb.GetComponent<RobotAI>().weapon[i].range);

*/

if (Physics.SphereCast(rb.GetComponent<RobotAI>().chest.position, LOSSphereCastRadius, direction, out hit, rb.GetComponent<RobotAI>().weapon[i].range) && hit.transform.root == target.GetComponent<RobotTargetDummy>().hitRootTransfrom)

{

SetLayer(rb.gameObject, oldLayer);

return i;

}

}

}

}

}

SetLayer(rb.gameObject, oldLayer);

// Step 2. Find Shield

// Shield range is 0, so the above loop will not select shield because of physic raycast failure

// shield already equip, use it

if (rb.GetComponent<RobotAI>().ExtraWpL != null && rb.GetComponent<RobotAI>().ExtraWpL.GetComponent<RobotBodyPartSpec>().weapon.type == WeaponType.Shield)

{

return rb.GetComponent<RobotAI>().weaponIDExtraWpL;

}

// shield not equip yet, check CD

for (int i = 0; i < rb.GetComponent<RobotAI>().weapon.Count; i++)

{

if (rb.GetComponent<RobotAI>().weapon[i].type == WeaponType.Shield && rb.GetComponent<RobotAI>().weapon[i].coolDownTimer + rb.GetComponent<RobotAI>().weapon[i].coolDown <= Data.currentTurn[(int)Data.currentMap])

{

return i;

}

}

return 99;

}

void AutoScrollWindow()

{

float deltaX, deltaZ;

deltaX = 0;

deltaZ = 0;

// Set scroll area

if (Input.mousePosition.x < screenAutoScrollLenght)

{

if (cameraHolder.position.x > 0)

deltaX = -cameraMoveSpeed;

}

else if (Input.mousePosition.x > screenW - screenAutoScrollLenght)

{

if (cameraHolder.position.x < 500)

deltaX = cameraMoveSpeed;

}

if (Input.mousePosition.y < screenAutoScrollLenght)

{

if (cameraHolder.position.z > 0)

deltaZ = -cameraMoveSpeed;

}

else if (Input.mousePosition.y > screenH - screenAutoScrollLenght)

{

if (cameraHolder.position.z < 500)

deltaZ = cameraMoveSpeed;

}

cameraHolder.Translate(new Vector3(deltaX, 0, deltaZ) * cameraMoveSpeed, Space.Self);

}

// Set object layer

void SetLayer(GameObject obj, Layer layerNumber)

{

Transform[] list = obj.GetComponentsInChildren<Transform>();

foreach (Transform child in list)

child.gameObject.layer = (int)layerNumber;

}

//----------------------Save Data------------------------

void SavePlayerRobotData()

{

int DataID;

for (int i = 0; i < playerRobotTransformList.Count; i++)

{

DataID = playerRobotTransformList[i].GetComponent<RobotAI>().robotIndex;

Data.playerRobot[DataID].position = playerRobotTransformList[i].position;

Data.playerRobot[DataID].rotation = playerRobotTransformList[i].rotation;

}

}

void SaveEnemyRobotData()

{

int DataID;

for (int i = 0; i < enemyRobotTransformList.Count; i++)

{

DataID = enemyRobotTransformList[i].GetComponent<RobotAI>().robotIndex;

Data.enemyRobot[DataID].position = enemyRobotTransformList[i].position;

Data.enemyRobot[DataID].rotation = enemyRobotTransformList[i].rotation;

}

}

//-------------------------Android Section-----------------

/*

void AndriodCameraControl()

{

//X & Z axis movement

if (Input.touchCount > 0 && Input.GetTouch(0).phase == TouchPhase.Moved)

if (Input.GetTouch(0).position.x > screenW / 2)

{

float x = cameraHolder.position.x + Input.GetTouch(0).deltaPosition.x;

float z = cameraHolder.position.z + Input.GetTouch(0).deltaPosition.y;

if (0 < x && x < 500 && -50 < z && z < 550)

cameraHolder.Translate(Input.GetTouch(0).deltaPosition.x, 0, Input.GetTouch(0).deltaPosition.y, Space.Self);

}

// Rotate camera

else

{

// rotate left/right

cameraHolder.Rotate(Vector3.up * Input.GetTouch(0).deltaPosition.x, Space.Self);

// rotate up/down

Camera.main.transform.Rotate(Vector3.right * -Input.GetTouch(0).deltaPosition.y, Space.Self);

}

}

*/

//-------------------Enemy Generator--------------

// Add new enemy geenerator to scene

void AddEnemyRobot()

{

Vector3 position = Vector3.zero;

/* do

{

position = new Vector3(Random.Range(50, 2000), 400, Random.Range(50, 2000));

} while (Physics.SphereCast(position, 30, Vector3.down, out h, 600) && h.transform.tag != Tag.Map.ToString() && h.point.y != 0);

*/

position = new Vector3(1000, 400, 1100);

GameObject obj = Instantiate(enemyRobotSpherePrefab);

obj.transform.position = position;

enemyRobotSphereList.Add(obj.transform);

}

//===============================UI==============================

//-----------------RobotInfo Section----------------------------

// Set currentRobot by battleManager before call

void RobotInfoWindow()

{

uiMode = UIMode.RobotInfoWindow;

robotInfoWindow.gameObject.SetActive(true);

robotInfoWindow.GetComponent<RobotInfoManager>().currentRobot = currentSelectedRobot;

robotInfoWindow.GetComponent<RobotInfoManager>().RobotInfoWindow();

}

// End Turn

public void EndTurn()

{

if (uiMode == UIMode.Idle)

{

uiMode = UIMode.EnemyTurn;

subuiMode = SubUIMode.EnemyMove;

}

}

// Show robot health bar

// or hide them when using cut in camera

void ShowHealth()

{

const float delta = 20;

if (Data.canvas.GetComponent<BattleManager>().mainCamera.gameObject.activeInHierarchy)

{

for (int i = 0; i < playerRobotTransformList.Count; i++)

{

Vector3 screenPoint = mainCamera.GetComponent<Camera>().WorldToScreenPoint(playerRobotTransformList[i].position) - Vector3.up * delta;

playerRobotHealthBarList[i].gameObject.SetActive(true);

playerRobotHealthBarList[i].position = screenPoint;

playerRobotHealthBarList[i].GetComponent<Slider>().value = (float)(Data.playerRobot[i].armorMax - Data.playerRobot[i].armor) / Data.playerRobot[i].armorMax;

}

for (int i = 0; i < enemyRobotTransformList.Count; i++)

{

Vector3 screenPoint = mainCamera.GetComponent<Camera>().WorldToScreenPoint(enemyRobotTransformList[i].position) - Vector3.up * delta;

enemyRobotHealthBarList[i].gameObject.SetActive(true);

enemyRobotHealthBarList[i].position = screenPoint;

enemyRobotHealthBarList[i].GetComponent<Slider>().value = (float)(Data.enemyRobot[i].armorMax - Data.enemyRobot[i].armor) / Data.enemyRobot[i].armorMax;

}

}

else

{

for (int i = 0; i < playerRobotTransformList.Count; i++)

playerRobotHealthBarList[i].gameObject.SetActive(false);

for (int i = 0; i < enemyRobotTransformList.Count; i++)

enemyRobotHealthBarList[i].gameObject.SetActive(false);

}

}

// Update mini Map

void MiniMap()

{

Vector3 position = Vector3.zero;

GameObject obj;

// destory old dot

for (int i = 0; i < dotList.Count; i++)

Destroy(dotList[i].gameObject);

dotList.Clear();

// create new dot

// player robot, enemy robot

for (int i = 0; i < playerRobotTransformList.Count; i++)

{

// miniMap size / terrain size = 100/2500 = 0.04

position.x = playerRobotTransformList[i].position.x * 0.04f;

position.y = playerRobotTransformList[i].position.z * 0.04f; // y->z

obj = Instantiate(dotPlayerPrefab, position, transform.rotation);

obj.transform.SetParent(miniMap);

obj.transform.localPosition = position;

dotList.Add(obj);

}

for (int i = 0; i < enemyRobotTransformList.Count; i++)

{

position.x = enemyRobotTransformList[i].position.x * 0.04f;

position.y = enemyRobotTransformList[i].position.z * 0.04f; // y->z

obj = Instantiate(dotEnemyPrefab, position, transform.rotation);

obj.transform.SetParent(miniMap);

obj.transform.localPosition = position;

dotList.Add(obj);

}

// update camera icon

position.x = cameraHolder.position.x * 0.04f;

position.y = cameraHolder.position.z * 0.04f;

miniMapCamera.localPosition = position;

miniMapCamera.localRotation = Quaternion.Euler(0, 0, -cameraHolder.eulerAngles.y);

}

void SelectedRoboIcon(Transform rb, Vector3 position)

{

// Put icon at the robot position

// find out ready weapon range.

List<int> rangeCount = new List<int>{ 0, 0, 0, 0, 0 };

currentSelectedRoboIcon.position = new Vector3(position.x, currentSelectedRoboIcon.position.y, position.z);

foreach (Weapon w in rb.GetComponent<RobotAI>().weapon)

{

if(w.type != WeaponType.DefendTurret)

switch (w.range)

{

case 50:

if (w.coolDown+w.coolDownTimer <= Data.currentTurn[(int)Data.currentMap])

rangeCount[0]++;

break;

case 100:

if (w.coolDown + w.coolDownTimer <= Data.currentTurn[(int)Data.currentMap])

rangeCount[1]++;

break;

case 150: if (w.coolDown + w.coolDownTimer <= Data.currentTurn[(int)Data.currentMap])

rangeCount[2]++; break;

case 200: if (w.coolDown + w.coolDownTimer <= Data.currentTurn[(int)Data.currentMap])

rangeCount[3]++; break;

case 250: if (w.coolDown + w.coolDownTimer <= Data.currentTurn[(int)Data.currentMap])

rangeCount[4]++; break;

}

}

for (int i = 0; i < rangeCount.Count; i++)

iconRangeText[i].text = rangeCount[i].ToString();

}

void MousePointTo()

{

if (Camera.current != null)

{

RaycastHit h;

Ray ray = Camera.current.ScreenPointToRay(Input.mousePosition);

if (Physics.Raycast(ray, out h))

mousePointTo.GetComponent<Text>().text = h.transform.name;

}

}

/*

void ShowUnitBattleInfo()

{

if (Camera.current != null)

{

RaycastHit h;

Ray ray = Camera.current.ScreenPointToRay(Input.mousePosition);

if (Physics.Raycast(ray, out h) && h.transform.root.GetComponent<RobotAI>())

{

Robot rbData = new Robot();

int id = 0;

if (h.transform.root.gameObject.CompareTag(Tag.PlayerRobot.ToString()))

{

id = h.transform.root.GetComponent<RobotAI>().robotIndex;

rbData = Data.playerRobot[id];

}

else if (h.transform.root.gameObject.CompareTag(Tag.EnemyRobot.ToString()))

{

id = h.transform.root.GetComponent<RobotAI>().robotIndex;

rbData = Data.enemyRobot[id];

}

unitBattleInfo.name.text = rbData.name.ToString();

unitBattleInfo.armor.text = rbData.armor.ToString("N0") + "/" + rbData.armorMax.ToString("N0");

unitBattleInfo.damage.text = rbData.damageFactor.ToString("N2");

// Get vaild Attack Range

int max = 0, min = 500;

foreach (Weapon w in h.transform.root.GetComponent<RobotAI>().weapon)

{

if (w.coolDown + w.coolDownTimer < Data.currentTurn[(int)Data.currentMap] && w.type != WeaponType.DefendTurret)

{

if (w.range > max)

max = w.range;

if (w.range < min)

min = w.range;

}

}

if (min == 500)

min = 0;

unitBattleInfo.range.text = min.ToString() + "-" + max.ToString();

}

}

}

*/

//---------------Event System---------------

// 1. Create Event Randomly

// 2. Setup event Button on UI

// 3. Wait player to enter event

void EventGenerator()

{

}

//-------------Transform List Reset when robot die---------

// 1. robot die

// 2. robot ai lock on death mode

// 3. clear up battle manager UI mode if the dying robot is the controlled robot or target

// 4. Reset transform list

// 5. destroy weapon effect dummy (dummy that do not use robot or target transform is not affected, e.g. machine gun subprojectile)

public void RobotDeath(Transform dyingRB)

{

ResetProjectile(dyingRB);

ResetUIMode(dyingRB);

ResetTransformList(dyingRB);

skillManager.KillAllEffect();

}

void ResetProjectile(Transform dyingRB)

{

if (uiMode == UIMode.PlayerRobotAttack || uiMode == UIMode.PlayerRobotMove || uiMode == UIMode.PlayerRobotRotate)

{

// destory dying robot projectile, and cancel the other side projectile

if (dyingRB == currentSelectedRobot)

{

currentSelectedRobotAI.CancelProjectileInScene(true);

currentSelectedRobotTarget.GetComponent<RobotAI>().CancelProjectileInScene(false);

}

else if (dyingRB == currentSelectedRobotTarget)

{

currentSelectedRobotAI.CancelProjectileInScene(false);

currentSelectedRobotTarget.GetComponent<RobotAI>().CancelProjectileInScene(true);

}

}

else if (uiMode == UIMode.EnemyTurn)

{

if (dyingRB == enemyRobotTransformList[currentEnemyRobotIndex])

{

enemyRobotTransformList[currentEnemyRobotIndex].GetComponent<RobotAI>().CancelProjectileInScene(true);

AI.targetSelected.GetComponent<RobotAI>().CancelProjectileInScene(false);

}

else if (dyingRB == AI.targetSelected)

{

enemyRobotTransformList[currentEnemyRobotIndex].GetComponent<RobotAI>().CancelProjectileInScene(false);

AI.targetSelected.GetComponent<RobotAI>().CancelProjectileInScene(true);

}

}

}

void ResetUIMode(Transform dyingRobot)

{

if (uiMode == UIMode.PlayerRobotAttack || uiMode == UIMode.PlayerRobotMove || uiMode == UIMode.PlayerRobotRotate)

{

if (dyingRobot == currentSelectedRobot || dyingRobot == currentSelectedRobotTarget)

{

currentSelectedRobot = null;

currentSelectedRobotAI = null;

currentSelectedRobotTarget = null;

uiMode = UIMode.Idle;

CutInCameraSelector(CameraMode.Idle);

}

}

else if (uiMode == UIMode.EnemyTurn)

{

// 0 1 2 3 4 5

// 2 die, current id = 2

// 0 1 3 4 5

// reset transform list

// 0 1 2 3 4

// next id(current id) = 2

if (dyingRobot == enemyRobotTransformList[currentEnemyRobotIndex])

{

subuiMode = SubUIMode.EnemyMove;

}

else if (dyingRobot == AI.targetSelected)

{

// if target die, enemy transform list will not be reset, so enemy robot index need to ++ to avoid the same robot take action again.

currentEnemyRobotIndex++;

subuiMode = SubUIMode.EnemyMove;

}

}

}

void ResetTransformList(Transform member)

{

Transform healthbar = null;

int memberTFIndex, memberDataIndex;

// remove robot from all list, destory robot

// remove healthbar from this, and destory health bar

// transform list in battle manager, health list in battle manager, unit list in Data

if (member.tag == Tag.PlayerRobot.ToString())

{

// transform list index = health bar list index

// transform list index != data list index

// need to reassign robotIndex, because it shift

// get index and health bar

memberTFIndex = Data.canvas.GetComponent<BattleManager>().playerRobotTransformList.IndexOf(member);

memberDataIndex = member.GetComponent<RobotAI>().robotIndex;

healthbar = Data.canvas.GetComponent<BattleManager>().playerRobotHealthBarList[memberTFIndex];

// remove them from transfrom list

Data.canvas.GetComponent<BattleManager>().playerRobotHealthBarList.RemoveAt(memberTFIndex);

Data.canvas.GetComponent<BattleManager>().playerRobotTransformList.RemoveAt(memberTFIndex);

// remove from Data list

Data.playerRobot.RemoveAt(memberDataIndex);

ShiftRobotID(memberDataIndex, Data.canvas.GetComponent<BattleManager>().playerRobotTransformList);

// if the destory member is currentselected robot, it become null after destroy

}

else if (member.tag == Tag.EnemyRobot.ToString())

{

//Transform previousRB = Data.canvas.GetComponent<BattleManager>().enemyRobotTransformList[Data.canvas.GetComponent<BattleManager>().currentEnemyRobotIndex];

memberTFIndex = Data.canvas.GetComponent<BattleManager>().enemyRobotTransformList.IndexOf(member);

memberDataIndex = member.GetComponent<RobotAI>().robotIndex;

healthbar = Data.canvas.GetComponent<BattleManager>().enemyRobotHealthBarList[memberTFIndex];

Data.canvas.GetComponent<BattleManager>().enemyRobotHealthBarList.RemoveAt(memberTFIndex);

Data.canvas.GetComponent<BattleManager>().enemyRobotTransformList.RemoveAt(memberTFIndex);

Data.enemyRobot.RemoveAt(memberDataIndex);

ShiftRobotID(memberDataIndex, Data.canvas.GetComponent<BattleManager>().enemyRobotTransformList);

}

// member destoy in explosion killer, health bar destory here

Destroy(healthbar.gameObject, 1);

}

//transform list 0 1 2 3 4 5

// data list 0 1 2 3 4 5

// kill 2, then

// TF 0 1 2 3 4

// Data 0 1 2 3 4

// but robot ID in RobotAI is 0 1 3 4 5

// should be 0 1 2 3 4

void ShiftRobotID(int removeID, List<Transform> rbList)

{

for (int i = 0; i < rbList.Count; i++)

if (rbList[i].GetComponent<RobotAI>().robotIndex >= removeID)

rbList[i].GetComponent<RobotAI>().robotIndex--;

}

//--------------Testing----------

public void AddSkillTest()

{

for (int i = 0; i < Data.playerRobot.Count; i++)

{

Data.playerRobot[i].skill.Add( RobotSkill.Assist_Attack_I);

Data.playerRobot[i].skill.Add(RobotSkill.Assist_Attack_II);

Data.playerRobot[i].skill.Add(RobotSkill.Repeat_Attack);

Data.playerRobot[i].skill.Add(RobotSkill.Taunt);

}

}

public void SendRobotToOtherMap()

{

int transformListID = 0;

// Set robot location in Data List

int DataListID = playerRobotTransformList[transformListID].GetComponent<RobotAI>().robotIndex;

Data.playerRobot[DataListID].map = Map.BossSpaceMap;

Data.playerRobot[DataListID].onRBLauncher = false;

// kick this robot from the fixedUpdate loop

Data.playerRobot[DataListID].attackedThisTurn = true;

Data.playerRobot[DataListID].movedThisTurn = true;

// remove robot from transform list in battle manager,

// remove relative healthBar

Destroy(playerRobotTransformList[transformListID].gameObject);

playerRobotTransformList.RemoveAt(transformListID);

Destroy(playerRobotHealthBarList[transformListID].gameObject);

playerRobotHealthBarList.RemoveAt(transformListID);

// Now, robotIndex of RobotAi is correct, but transfromListID of Data is wrong

for (int i = 0; i < playerRobotTransformList.Count; i++)

{

DataListID = playerRobotTransformList[i].GetComponent<RobotAI>().robotIndex;

Data.playerRobot[DataListID].transformListID = i;

}

}

public void LoadOtherMap()

{

// when sub map is generated, start turn should be record

// change map should not affect start turn of the map

// test only

Data.startTurn[(int)Map.BossSpaceMap] = Data.currentTurn[(int)Map.MainMap];

Data.currentTurn[(int)Map.BossSpaceMap] = Data.currentTurn[(int)Map.MainMap];

SceneManager.LoadScene(SceneList.BossSpaceMap.ToString());

}

}

Baste · Sep 3, 2018

Yup, that's wrong. You're instantiating a new RobotAI, which is a MonoBehaviour. That'll not be a valid RobotAI.

Not quite sure why the stack trace points you down to the array creation.

Xhitman · Sep 4, 2018

Baste said: ↑

Yup, that's wrong. You're instantiating a new RobotAI, which is a MonoBehaviour. That'll not be a valid RobotAI.

Not quite sure why the stack trace points you down to the array creation.
Click to expand...

I think I understand a bit after looking at https://answers.unity.com/questions/653904/you-are-trying-to-create-a-monobehaviour-using-the-2.html

But how can I have a global reference for currentSelectedRobot.GetComponent<RobotAI>() which use often in script?

When player click the robot:
currentSelectedRobot = hit.transform.root;
currentSelectedRobotAI = hit.transform.root.GetComponent<RobotAI>();

ezjm427 · Sep 4, 2018

Instead of doing RobotAI currentSelectedRobotAI = new RobotAI();, you have to do

Code (CSharp):

RobotAI currentSelectedRobotAI = gameObject.AddComponent<RobotAI>().

The only downside is it'll be added to the GameObject's components in the inspector, but AddComponent will return the newly created RobotAI so it'll work. That's how you're supposed to make new objects that are Monobehaviors, something with how Monobehaviors work is restricting them so they have to be added to GameObjects.

Xhitman · Sep 4, 2018

ezjm427 said: ↑

Instead of doing RobotAI currentSelectedRobotAI = new RobotAI();, you have to do

Code (CSharp):

RobotAI currentSelectedRobotAI = gameObject.AddComponent<RobotAI>().

The only downside is it'll be added to the GameObject's components in the inspector, but AddComponent will return the newly created RobotAI so it'll work. That's how you're supposed to make new objects that are Monobehaviors, something with how Monobehaviors work is restricting them so they have to be added to GameObjects.
Click to expand...

It don't work for global variable.

The problem is I cannot put

Code (CSharp):

RobotAI currentSelectedRobotAI = gameObject.AddComponent<RobotAI>().

in global. What I need is a global reference directly to RobotAI such that I dont need to access currentselectrobot and then access GetComponent<RobotAI>() everywhere. I think it reduce 50% workLoad?

ezjm427 · Sep 4, 2018

S***man said: ↑

It don't work for global variable.

The problem is I cannot put

Code (CSharp):

RobotAI currentSelectedRobotAI = gameObject.AddComponent<RobotAI>().

in global. What I need is a global reference directly to RobotAI such that I dont need to access currentselectrobot and then access GetComponent<RobotAI>() everywhere. I think it reduce 50% workLoad?
Click to expand...

Attach it to a static GameObject that all robot AI's are contained in. If you just try to create a new one it won't work properly

Xhitman · Sep 4, 2018

No any warning when I use

Code (CSharp):

RobotAI currentSelectedRobotAI;

although I don't know why.

bobisgod234 · Sep 4, 2018

Just declaring currentSelectedRobotAI doesn't actually create an instance of RobotAI. Assuming that you can have no selected robot AI, you should be able to initialize currentSelectedRobotAI to null and set/unset it as needed.

Baste · Sep 4, 2018

S***man said: ↑

No any warning when I use

Code (CSharp):

RobotAI currentSelectedRobotAI;

although I don't know why.
Click to expand...

When you declare a variable without setting it to something, as you're doing there, it gets set to the default value for that type. For classes, that's null, so it's equivalent to
 RobotAI currentSelectedRobotAI = null; 

Search Unity

Unity ID

Useful Searches

Can I ignore "You are trying to create a MonoBehaviour using the 'new' keyword"?