public override void OnAttack(BaseCharacterController Attacker)
{
bool dying = character.CheckControlState(ControlFlags.Dying);
if (dying)
{
return;
}
CombatController enemy = Attacker.combatController;
CombatController combat = character.combatController;
PlayerStats stats = character.playerStats;
if (!enemy)
{
Debug.Log("Attacking with no enemy!");
return;
}
combat.Damage(enemy.CurrentDamage());
combat.EnterCombat();
character.OnKnockback(Attacker, 2.5f, .2f);
if (stats.currentHealth < 1f)
{
stats.currentHealth = 0f;
character.SetControlState(ControlFlags.Dying);
UIMessage.ShowMessage("You Have Died", Color.red, 0f);
AnimationController anim = character.animationController;
anim.animationReference.SetBool("dying", true);
Pause.Go();
character.movementController.StopMovement();
character.movementController.enabled = false;
character.combatController.enabled = false;
}
}
public void Init(Transform shootPointTransform)
{
if (updateOrderSpeed > minUpdateOrderNum)
{
updateOrderSpeed = minUpdateOrderNum;
//throw new System.ArgumentException("updateOrderSpeed can not be greater than minUpdateOrderNum");
}
mTransform = transform;
this.ownerTransform = shootPointTransform.parent; //ownerTransform;
ownerController = ownerTransform.gameObject.GetComponent <BaseCharacterController> ();
hookStartTransform = shootPointTransform; //ownerTransform.gameObject.transform.FindChild("HookShootPoint");
// Instantiate hook
Vector3 position = nextPosition(mTransform.transform);
Quaternion rotation = nextRotation(mTransform.transform, position);
hook = Instantiate(hookPrefab, position, rotation) as GameObject;
Hook hookScript = hook.GetComponent <Hook> ();
hookScript.setOwnerTrans(ownerTransform);
hookScript.hookEventListener.StartTakeBackHook += StartTakeBackHook;
hookScript.hookEventListener.HookSomething += HookSomething;
Physics.IgnoreCollision(hook.collider, ownerTransform.gameObject.collider);
// Slow down owner speed
ownerController.SlowDownMovingSpeed();
}
private void Awake()
{
if (killVFX != null)
{
_explosionId = killVFX.GetInstanceID();
ObjectPool.GetOrInitPool(killVFX);
}
if (impactVFX != null)
{
_impactId = impactVFX.GetInstanceID();
ObjectPool.GetOrInitPool(impactVFX);
}
if (lootableItem != null)
{
_lootableGO = lootableItem.gameObject;
_lootableItemId = _lootableGO.GetInstanceID();
ObjectPool.GetOrInitPool(_lootableGO);
}
_character = GetComponent <BaseCharacterController>();
if (_character != null)
{
_character.OnDying += OnCharacterDying;
}
}
public void SetCharacter(BaseCharacterController character)
{
_character = character;
_character.OnDamaged += CharacterOnDamaged;
_character.OnDied += CharacterOnDied;
}
public AIBattleState(BaseCharacterController basecharactercontroller)
{
Debug.LogWarning("[AI State]: Battle");
m_Character = basecharactercontroller;
Enter();
}
public override void OnHit(BaseCharacterController Attacker)
{
int dmg = 1;
if (Dying)
{
return;
}
combatController.Damage(Attacker.combatController.CurrentDamage());
if (combatController.TestForDying())
{
Levelable levelup = Attacker.GetComponent <Levelable>();
if (levelup)
{
levelup.currentxp += this.experiencePerKill;
}
DisableUI();
movementController.StopMovement();
animationController.DoDeathAnimation();
Rigidbody2D rbod = gameObject.transform.parent.GetComponent <Rigidbody2D>();
BoxCollider2D box = gameObject.transform.parent.GetComponent <BoxCollider2D>();
box.enabled = false;
rbod.isKinematic = true;
DestroyObject(gameObject.transform.parent.gameObject, 1.5f);
}
else
{
CreateCombatText(dmg.ToString());
OnKnockback(Attacker, 1.5f, .4f);
}
}
private void OnDie(BaseCharacterController obj)
{
if (!_deadCharacters.Find(character => obj == character))
{
_deadCharacters.Add(obj);
}
}
void Awake()
{
if (m_Character == null && Root.Instance != null)
{
m_Character = Root.Instance.m_Character;
}
}
public BackState(BaseCharacterController basecharactercontroller, IComboBaseState laststate)
{
Debug.Log("[Input State]: Back");
m_Character = basecharactercontroller;
m_LastState = laststate;
Enter();
}
public AIMovementIdle(BaseCharacterController basecharactercontroller)
: base(basecharactercontroller)
{
decisionTreeAI = m_Character.GetComponent<DecisionTreeAI>();
Debug.LogWarning("[AI Movement State]: Idle");
Enter();
}
void Awake()
{
if (m_Character == null && Root.Instance != null)
{
m_Character = Root.Instance.m_Character;
}
}
public AIMovementIdle(BaseCharacterController basecharactercontroller)
: base(basecharactercontroller)
{
decisionTreeAI = m_Character.GetComponent <DecisionTreeAI>();
Debug.LogWarning("[AI Movement State]: Idle");
Enter();
}
public BackState(BaseCharacterController basecharactercontroller, IComboBaseState laststate)
{
Debug.Log("[Input State]: Back");
m_Character = basecharactercontroller;
m_LastState = laststate;
Enter();
}
public void Init(Transform shootPointTransform)
{
if (updateOrderSpeed > minUpdateOrderNum) {
updateOrderSpeed = minUpdateOrderNum;
//throw new System.ArgumentException("updateOrderSpeed can not be greater than minUpdateOrderNum");
}
mTransform = transform;
this.ownerTransform = shootPointTransform.parent;//ownerTransform;
ownerController = ownerTransform.gameObject.GetComponent<BaseCharacterController> ();
hookStartTransform = shootPointTransform;//ownerTransform.gameObject.transform.FindChild("HookShootPoint");
// Instantiate hook
Vector3 position = nextPosition(mTransform.transform);
Quaternion rotation = nextRotation(mTransform.transform, position);
hook = Instantiate (hookPrefab, position, rotation) as GameObject;
Hook hookScript = hook.GetComponent<Hook> ();
hookScript.setOwnerTrans (ownerTransform);
hookScript.hookEventListener.StartTakeBackHook += StartTakeBackHook;
hookScript.hookEventListener.HookSomething += HookSomething;
Physics.IgnoreCollision (hook.collider, ownerTransform.gameObject.collider);
// Slow down owner speed
ownerController.SlowDownMovingSpeed ();
}
public void AddCriminal(BaseCharacterController criminal)
{
if (!Criminals.Contains(criminal))
{
criminal.Health.OnDied += OnCriminalDie;
Criminals.Add(criminal);
}
}
void Awake()
{
if (m_Character == null && Root.Instance != null)
{
m_Character = Root.Instance.m_Character;
m_PlaneshiftScript = m_Character.gameObject.GetComponentInChildren<GenerateParticles>();
}
}
void Start()
{
mTransform = transform;
// This gameObject's parent is the owner
whoShootTransform = mTransform.parent;
// Reference to the owner's controller.
characterController = whoShootTransform.gameObject.GetComponent <BaseCharacterController> ();
}
void Awake()
{
if (m_Character == null && Root.Instance != null)
{
m_Character = Root.Instance.m_Character;
m_PlaneshiftScript = m_Character.gameObject.GetComponentInChildren <GenerateParticles>();
}
}
public override void OnAttack(BaseCharacterController Attacker)
{
if (colliderReference)
{
colliderReference.enabled = false;
}
renderReference.sprite = breakSprite;
}
private void OnCharacterSpawn(BaseCharacterController character)
{
if (character is PlayerController)
{
return;
}
character.Health.OnDied += OnDie;
}
public void Spawn(GameObject prefab, int damage, int points, ObjectPool pool, BaseCharacterController controller)
{
if (spawnerPath.playerHealth.Alive())
{
GameObject x = pool.acquireReusable(prefab);
x.transform.position = spawnerPath.GetPosition(0);
x.transform.rotation = Quaternion.LookRotation(spawnerPath.GetPosition(1) - spawnerPath.GetPosition(0)) * Quaternion.Euler(0, -90, 0);
x.GetComponent <Character>().SetUp(spawnerPath, damage, points, points, controller);
}
}
public void SetUp(Path _path, int _damage, int _points, float _addSpeed, BaseCharacterController _controller)
{
Alive = true;
path = _path;
Damage = _damage;
Points = _points;
addspeed = _addSpeed * 2;
controller = _controller;
controller.SetUp(this.gameObject);
}
public void InstantiateHB()
{
GameObject healtBarGO = Instantiate(HealthBarPrefab, transform.position, Quaternion.identity); //instantiate new prefab instance
BaseCharacterController character = GetComponent <BaseCharacterController>(); //Get character component from current game object
HealthBar healthBar = healtBarGO.GetComponent <HealthBar>(); //Get HealthBar component from new instance
healthBar.SetCharacter(character); //Bind healthBar with character
}
public override void WeaponCollide(Collider other)
{
BaseCharacterController EnemyController = other.gameObject.GetComponentInParent <BaseCharacterController>();
if (m_NextState == this)
{
if (other.gameObject.layer == LayerMask.NameToLayer("CharacterWeapon"))
{
FMOD_StudioSystem.instance.PlayOneShot("event:/Weapons/weapon_impact", m_Character.transform.position);
if (m_Character.m_Opponent.m_CurrentState is IAttackState)
{
m_NextState = new AIBattleAttackDeflected(m_Character);
}
if (m_Character.m_Opponent.m_CurrentState is AIBattleParryUp)
{
m_NextState = new AIBattleCounterAttacked(m_Character);
m_Character.m_Opponent.m_CurrentState.m_NextState = new AIBattleCounterAttackUp(m_Character.m_Opponent);
}
if (m_Character.m_Opponent.m_CurrentState is AIBattleBlockUp)
{
//m_NextState = new AIBattleBlocked(m_Character);
m_Character.GetHit(5);
m_Character.m_Opponent.m_CurrentState.m_NextState = new AIBattleIdle(m_Character.m_Opponent);
m_Character.m_Opponent.GetComponent <Animator>().SetBool("BlockUp", false);
}
}
else if (other.gameObject.layer == LayerMask.NameToLayer("CharacterBody") && m_Character != EnemyController)
{
FMOD_StudioSystem.instance.PlayOneShot("event:/Weapons/weapon_impact", m_Character.transform.position);
if (m_Character.m_Opponent.m_CurrentState is AIBattleParryUp)
{
m_NextState = new AIBattleCounterAttacked(m_Character);
m_Character.m_Opponent.m_CurrentState.m_NextState = new AIBattleCounterAttackUp(m_Character.m_Opponent);
}
else if (m_Character.m_Opponent.m_CurrentState is AIBattleBlockUp)
{
m_Character.GetHit(5);
//m_NextState = new AIBattleBlocked(m_Character);
m_Character.m_Opponent.m_CurrentState.m_NextState = new AIBattleIdle(m_Character.m_Opponent);
m_Character.m_Opponent.GetComponent <Animator>().SetBool("BlockUp", false);
}
else
{
m_NextState = new AIBattleSuccessfulAttack(m_Character);
m_Character.m_Opponent.GetHit(5);
}
}
}
}
//void MoveToPlayer()
//{
// float deltaMoving = MovingSpeed * Time.deltaTime;
// transform.position += transform.right * deltaMoving;
//}
void OnTriggerEnter2D(Collider2D col)
{
BaseCharacterController character = col.GetComponent <BaseCharacterController>();
if (character != null)
{
Destroy(gameObject);
character.Damage(Damage);
}
}
void OnTriggerEnter(Collider other)
{
m_Character = GetComponentInParent <BaseCharacterController>();
if (m_Character != null && other.gameObject.layer == LayerMask.NameToLayer("Climb"))
{
m_TargetPosition = other.transform.GetChild(0).transform;
if (m_Character.m_CurrentState is MovementJump)
{
(m_Character.m_CurrentState as MovementJump).GrabLedgeMiddle();
}
}
}
void OnTriggerEnter(Collider other)
{
m_Character = GetComponentInParent<BaseCharacterController>();
if (m_Character != null && other.gameObject.layer == LayerMask.NameToLayer("Climb"))
{
m_TargetPosition = other.transform.GetChild(0).transform;
if (m_Character.m_CurrentState is MovementJump)
{
(m_Character.m_CurrentState as MovementJump).GrabLedgeMiddle();
}
}
}
public MovementJump(BaseCharacterController basecharactercontroller) : base(basecharactercontroller)
{
Debug.Log("[Movement State]: Jump");
Enter();
if (!(m_Character as PlayerCharacterController).m_StandsInWater)
{
FMOD_StudioSystem.instance.PlayOneShot("event:/Darien/darien_jump", m_Character.transform.position);
}
else
{
FMOD_StudioSystem.instance.PlayOneShot("event:/Darien/darien_waterjump", m_Character.transform.position);
}
}
protected virtual void Awake()
{
stateMachine = GetComponent <StateMachine>();
if (stateMachine == null)
{
stateMachine = gameObject.AddComponent <StateMachine>();
}
characterController = GetComponent <BaseCharacterController>();
stateMachine.OnStateBegin = OnStateBegin;
stateMachine.OnStateEnd = OnStateEnd;
}
public bool CharactersAreHostile(BaseCharacterController characterA, BaseCharacterController characterB)
{
CharacterFaction factionA = characterA.Config.Faction;
CharacterFaction factionB = characterB.Config.Faction;
if (factionA == CharacterFaction.Player || factionB == CharacterFaction.Player)
{
AgentController agent = factionA == CharacterFaction.Player ? characterB as AgentController : characterA as AgentController;
return(_hostileToPlayer[agent]);
}
//All factions are hostile to one another
return(factionA != factionB);
}
public static void MoveTowards(BaseCharacterController owner, Vector3 target)
{
float horizontalMovement = 0.0f;
Vector3 position = owner.transform.position;
if (position.x < target.x)
{
horizontalMovement = 1.0f;
}
else
{
horizontalMovement = -1.0f;
}
owner.CharacterYoke.Movement = new Vector2(horizontalMovement, 0.0f);
}
private void Start()
{
// get the transform of the main camera
if (Camera.main != null)
{
m_Cam = Camera.main.transform;
}
else
{
Debug.LogWarning(
"Warning: no main camera found. Third person character needs a Camera tagged \"MainCamera\", for camera-relative controls.");
// we use self-relative controls in this case, which probably isn't what the user wants, but hey, we warned them!
}
// get the third person character ( this should never be null due to require component )
m_Character = GetComponent<BaseCharacterController>();
}
public override void WeaponCollide(Collider other)
{
BaseCharacterController EnemyController = other.gameObject.GetComponentInParent <BaseCharacterController>();
if (m_NextState == this)
{
if (other.gameObject.layer == LayerMask.NameToLayer("CharacterWeapon") && m_Character != other.transform.parent.parent.gameObject.GetComponent <BaseCharacterController>())
{
if (m_Character.m_Opponent.m_CurrentState is AIBattleParryDown)
{
m_NextState = new BattleCounterAttacked(m_Character);
m_Character.m_Opponent.m_CurrentState.m_NextState = new AIBattleCounterAttackDown(m_Character.m_Opponent);
}
if (m_Character.m_Opponent.m_CurrentState is AIBattleBlockDown)
{
m_NextState = new BattleBlocked(m_Character);
}
if (m_Character.m_Opponent.m_CurrentState is IAttackState)
{
m_Character.m_CurrentState = new BattleAttackDeflected(m_Character);
}
}
else if (other.gameObject.layer == LayerMask.NameToLayer("CharacterBody") && m_Character != EnemyController)
{
if (m_Character.m_Opponent.m_CurrentState is AIBattleParryDown)
{
m_NextState = new BattleCounterAttacked(m_Character);
m_Character.m_Opponent.m_CurrentState.m_NextState = new AIBattleCounterAttackDown(m_Character.m_Opponent);
}
else if (m_Character.m_Opponent.m_CurrentState is AIBattleBlockDown)
{
m_NextState = new BattleBlocked(m_Character);
}
else
{
m_NextState = new BattleSuccessfulAttack(m_Character);
m_Character.m_Opponent.GetHit(10);
}
}
}
}
public IEnumerator DeathCharacter()
{
m_IsDead = true;
FMOD_StudioSystem.instance.PlayOneShot("event:/Darien/darien_death", transform.position);
float timer = 0.0f;
GetComponent <Animator>().SetTrigger("Die");
m_CurrentHealth = 100;
bool played = false;
while (timer <= GetComponent <Animator>().GetCurrentAnimatorStateInfo(0).length)
{
if (timer >= 2.0f && !played)
{
Root.Instance.m_LoadingScreen.gameObject.SetActive(true);
Root.Instance.StartCoroutine(Root.Instance.m_LoadingScreen.FadeIn(false));
played = true;
}
if (GetComponent <Animator>().GetCurrentAnimatorStateInfo(0).IsName("Death"))
{
timer += Time.deltaTime;
}
yield return(new WaitForFixedUpdate());
}
transform.position = Root.Instance.m_StartPosition.position;
Root.Instance.m_Character.m_TotalForce = Vector3.zero;
m_Opponent = null;
yield return(new WaitForSeconds(3.0f));
Root.Instance.StartCoroutine(Root.Instance.m_LoadingScreen.FadeOut());
yield return(new WaitForSeconds(1.0f));
m_IsDead = false;
}
void OnTriggerEnter(Collider other)
{
m_Character = GetComponentInParent <BaseCharacterController>();
if (m_Character != null && other.gameObject.layer == LayerMask.NameToLayer("Climb"))
{
m_TargetPosition = other.transform.GetChild(0).transform;
if (m_Character.m_CurrentState is MovementJump)
{
Vector3 newPosition = (m_Character.transform.position - transform.position) + other.transform.position;
newPosition.z = m_Character.transform.position.z;
m_Character.transform.position = newPosition;
(m_Character.m_CurrentState as MovementJump).GrabLedgeTop();
}
if (m_Character.m_CurrentState.m_NextState is MovementGrabTop)
{
(m_Character.m_CurrentState.m_NextState as MovementGrabTop).m_TargetPosition = m_TargetPosition.position;
(m_Character.m_CurrentState.m_NextState as MovementGrabTop).m_TargetPosition.z = m_Character.transform.position.z;
}
}
}
public IEnumerator DeathCharacter()
{
m_IsDead = true;
FMOD_StudioSystem.instance.PlayOneShot("event:/Darien/darien_death", transform.position);
float timer = 0.0f;
GetComponent<Animator>().SetTrigger("Die");
m_CurrentHealth = 100;
bool played = false;
while (timer <= GetComponent<Animator>().GetCurrentAnimatorStateInfo(0).length)
{
if (timer >= 2.0f && !played)
{
Root.Instance.m_LoadingScreen.gameObject.SetActive(true);
Root.Instance.StartCoroutine(Root.Instance.m_LoadingScreen.FadeIn(false));
played = true;
}
if (GetComponent<Animator>().GetCurrentAnimatorStateInfo(0).IsName("Death"))
timer += Time.deltaTime;
yield return new WaitForFixedUpdate();
}
transform.position = Root.Instance.m_StartPosition.position;
Root.Instance.m_Character.m_TotalForce = Vector3.zero;
m_Opponent = null;
yield return new WaitForSeconds(3.0f);
Root.Instance.StartCoroutine(Root.Instance.m_LoadingScreen.FadeOut());
yield return new WaitForSeconds(1.0f);
m_IsDead = false;
}
private void OnCharacterSpawned(BaseCharacterController character)
{
AgentController agent = character as AgentController;
if (agent != null)
{
CharacterFaction faction = agent.Config.Faction;
if (!_agentsByFaction[faction].Contains(agent))
{
_agentsByFaction[faction].Add(agent);
}
if (!_hostileToPlayer.ContainsKey(agent))
{
_hostileToPlayer[agent] = false;
}
}
else if (Player == null)
{
//Must be a player
Player = character as PlayerController;
Debug.Assert(Player != null);
}
}
public BaseBattleHeavyAttackDown(BaseCharacterController basecharactercontroller)
: base(basecharactercontroller)
{
Enter();
}
public MovementHeavyAttackDown(BaseCharacterController basecharactercontroller)
: base(basecharactercontroller)
{
Debug.Log("[Movement State]: Heavy Attack Down");
Enter();
}
public BattleIdle(BaseCharacterController basecharactercontroller)
: base(basecharactercontroller)
{
Debug.Log("[Battle State]: Idle");
Enter();
}
public InputValues(BaseCharacterController owner)
{
Owner = owner;
Owner.InputValues = this;
}
public AIBattleRetreat(BaseCharacterController basecharactercontroller)
: base(basecharactercontroller)
{
Debug.LogWarning("[AI Battle State]: Retreat");
Enter();
}
public MovementGrabMiddle(BaseCharacterController basecharactercontroller)
: base(basecharactercontroller)
{
Debug.Log("[Movement State]: Grab Middle");
Enter();
}
public BattlePlaneShift(BaseCharacterController basecharactercontroller)
: base(basecharactercontroller)
{
Debug.Log("[Battle State]: Plane Shift");
Enter();
}
public BaseBattleCounterAttackUp(BaseCharacterController basecharactercontroller)
: base(basecharactercontroller)
{
Enter();
}
public MovementPreBegin(BaseCharacterController basecharactercontroller)
: base(basecharactercontroller)
{
Debug.Log("[Movement State]: Pre Begin");
Enter();
}
void Start()
{
rb = GetComponent <Rigidbody>();
hands = GetComponent <CharacterHands>();
character = GetComponent <BaseCharacterController>();
}
public MovementWalk(BaseCharacterController basecharactercontroller)
: base(basecharactercontroller)
{
Debug.Log("[Movement State]: Walk");
Enter();
}
public BaseBattleWalk(BaseCharacterController basecharactercontroller)
: base(basecharactercontroller)
{
Enter();
}
public BaseBattleBlocked(BaseCharacterController basecharactercontroller)
: base(basecharactercontroller)
{
Enter();
}
public BattleWallWalk(BaseCharacterController basecharactercontroller)
: base(basecharactercontroller)
{
Debug.Log("[Battle State]: Wall Walk");
Enter();
}
public MovementPlaneShift(BaseCharacterController basecharactercontroller)
: base(basecharactercontroller)
{
Debug.Log("[Movement State]: Plane Shift");
Enter();
}
public BaseBattlePlaneShift(BaseCharacterController basecharactercontroller)
: base(basecharactercontroller)
{
Enter();
}
public MovementPlaneTransition(BaseCharacterController basecharactercontroller)
: base(basecharactercontroller)
{
Debug.Log("[Movement State]: Plane Transition");
Enter();
}
public AIBattleBlockDown(BaseCharacterController basecharactercontroller)
: base(basecharactercontroller)
{
Debug.LogWarning("[AI Battle State]: Block Down");
Enter();
}
public AIBattleLightAttackUp(BaseCharacterController basecharactercontroller)
: base(basecharactercontroller)
{
Debug.LogWarning("[AI Battle State]: Light Attack Up");
Enter();
}
public BattleCounterAttacked(BaseCharacterController basecharactercontroller)
: base(basecharactercontroller)
{
Debug.Log("[Battle State]: Counter Attacked");
Enter();
}
public BattleHeavyAttackUp(BaseCharacterController basecharactercontroller)
: base(basecharactercontroller)
{
Debug.Log("[Battle State]: Heavy Attack Up");
Enter();
}
public BaseBattleGetsHit(BaseCharacterController basecharactercontroller)
: base(basecharactercontroller)
{
Enter();
}
public BattleHit(BaseCharacterController basecharactercontroller)
: base(basecharactercontroller)
{
Debug.Log("[Battle State]: Block");
Enter();
}
