public void unRegisUnit(unitHitbox unit)
{
if (inUnit.Contains(unit))
{
inUnit.Remove(unit);
}
}
public void doActionADD(unitHitbox attacker, unitHitbox target, damageHitbox damageHB)
{
// bomb damage is 1/3 of attack power
if (Bomb != null && maxitemChange > 0)
{
int bombDamage = unitOwner.damageManager.damageDataList[0].damage / 3;
damageHitbox damageHb = Bomb.GetComponent <damageHitbox>();
damageHb.setOwner(unitOwner);
damageHb.setDamage(bombDamage);
GameObject BombInstance = Instantiate(Bomb);
BombInstance.transform.position = target.transform.position;
BombInstance.SetActive(true);
itemCharge--;
if (itemCharge <= 0)
{
var unitItem = unitOwner.GetComponent <ItemOnPlayer>();
if (unitItem != null)
{
unitItem.RemoveItem(mainItem);
}
}
}
}
public void setOwner(unitHitbox owner)
{
this.ownerUnit = owner;
if (owner != null)
{
isFriendly = owner.tag == "Player";
isUnFriendly = owner.tag == "Enemy";
if (isUnFriendly)
{
if (tag == "Heal")
{
gameObject.layer = friendlyDamageLayer;
}
else
{
gameObject.layer = unfriendlyDamageLayer;
}
}
if (isFriendly)
{
if (tag == "Heal")
{
gameObject.layer = unfriendlyDamageLayer;
}
else
{
gameObject.layer = friendlyDamageLayer;
}
}
}
}
public override void doActionAPI(unitHitbox player)
{
// base.doActionAPI(player);
GameObject attackUp = Instantiate(AttackUpObject, player.transform, false);
attackUp.GetComponent <AttackUpTemporary>().SetUnitAttackUp(player);
}
public void SetOwnerInstance(unitHitbox unit)
{
unitOwner = unit;
unitOwner.damageManager.addAfterDoneDamageToAll(this);
maxitemChange = 1;
itemCharge = bombHitPerCharge;
}
public void doActionATD(int damageTaken, unitHitbox takenFrom)
{
if (knightControl.stamina > knightControl.stamina * 0.2f)
{
isTakenDamage = true;
}
}
public void regisUnit(unitHitbox unit)
{
if (!inUnit.Contains(unit))
{
inUnit.Add(unit);
}
}
public override void removeItemEffectOnPlayer(unitHitbox player)
{
base.removeItemEffectOnPlayer(player);
StatContol stat = player.GetComponent <StatContol>();
stat.RemoveIncreaseAttackDamage(percent);
}
public void doActionADD(unitHitbox attacker, unitHitbox target, damageHitbox damageHB)
{
SlowInstance slow = Instantiate(slowInstance, target.transform);
slow.transform.position = target.transform.position;
slow.SetSlowTarget(target);
}
public override void doActionAPI(unitHitbox unitHitbox)
{
base.doActionAPI(unitHitbox);
StatContol stat = unitHitbox.GetComponent <StatContol>();
int newDamage = stat.IncreaseAttackDamage(percent);
// Debug.Log("Increase Attack To " + newDamage);
}
public void SetOwnerInstance(unitHitbox unit)
{
owner = unit;
transform.position = owner.transform.position;
owner.damageManager.addAfterDoneDamageToAll(this);
GetMoreItem();
}
public void doActionADD(unitHitbox attacker, unitHitbox target, damageHitbox damageHB)
{
foreach (chainAtk atk in chainList)
{
StartCoroutine(delaySpawn(atk.model, atk.prefabHitbox, transform, attacker, atk.delay));
//spawnAtk(atk.model, atk.hitbox, transform, attacker);
}
}
public override void doActionAPI(unitHitbox unitHitbox)
{
base.doActionAPI(unitHitbox);
int upBy = unitHitbox.hpMax + increaseHp;
unitHitbox.GetComponent <StatContol>().IncreaseAllHp(upBy);
}
public void SetOwnerInstance(unitHitbox unit)
{
owner = unit;
transform.position = owner.transform.position;
owner.addAfterHeal(this);
owner.addAfterTakenDamage(this);
GetMoreItem();
}
private void Start()
{
player = GetComponent <unitHitbox>();
if (player == null)
{
Debug.LogError("Can't find unithitbox on this instance");
}
}
public virtual void removeItemEffectOnPlayer(unitHitbox player)
{
if (player.id >= 0)
{
// Debug.Log("Remove " + gameObject + " on player");
sendRemoveThisItemToClient(player.id);
}
}
void doAtk()
{
if (enemyAI.target != null)
{
unitHitbox unitHB = enemyAI.target.GetComponent <unitHitbox>();
unitHB.takenDamage(statContol.damage, myHitbox);
}
}
public override void doActionAPI(unitHitbox unitHitbox)
{
base.doActionAPI(unitHitbox);
// So Ugly, Will change Later
StatContol stat = unitHitbox.GetComponent <StatContol>();
stat.IncreaseMaxSpeed(speedUp);
}
public void SetOwnerInstance(unitHitbox unit)
{
owner = unit;
transform.position = unit.transform.position;
continueDamage.DamageHitbox.setOwner(unit);
continueDamage.damagePeriod = peroid;
GetMoreItem();
}
public override bool checkPickItemCondition(unitHitbox picker)
{
if (picker.hpCurrent == picker.hpMax)
{
return(false);
}
return(true);
}
// Use this for initialization
void Start()
{
stat = GetComponent <StatContol>();
agent = gameObject.GetComponent <NavMeshAgent>();
anim = gameObject.GetComponent <Animator>();
enemyAI = gameObject.GetComponent <EnemyAI>();
myHitbox = gameObject.GetComponent <unitHitbox>();
}
public void SetUnitAttackUp(unitHitbox unit)
{
owner = unit;
int newAttack = owner.statContol.IncreaseAttackDamage(attackUpPercent);
StartCoroutine(DelayDestroy());
// Debug.Log("Increase attack to " + newAttack);
}
public void SetSlowTarget(unitHitbox target)
{
if (target != null && target.statContol != null)
{
targetSlowed = target;
targetSlowed.statContol.ChangeSpeedPercent(-speedSlowPercent);
Destroy(gameObject, slowTime);
}
}
public override bool checkPickItemCondition(unitHitbox picker)
{
if (picker.ultimateManager.isFull())
{
return(false);
}
return(true);
}
public void shootArrowAct()
{
damageHitbox dambox;
unitHitbox myHitbox = gameObject.GetComponent <unitHitbox>();
if (!isUltimate)
{
switch (mode)
{
case MODE.SINGLE:
//for (int i = 0; i < pinArrowNum; i++)
//{
// dambox = pinArrow.spawnDuplicate(shootSpot);
// dambox.transform.localPosition = new Vector3(0.5f * (Mathf.Pow(-1, i)) * (Mathf.Floor(((float)i + 1) / 2)), 0, 0);
//}
spawnArrow(normalShoot);
break;
case MODE.SPREAD:
for (int i = 0; i < spreadShotArrow; i++)
{
dambox = spawnArrow(spreadShoot);
spreadAngle = spreadShotArrow * 8;
dambox.transform.eulerAngles += new Vector3(0, -(spreadAngle / 2) + (i * 8), 0);
/*dambox = Instantiate(arrowModel);
* dambox.transform.position = shootSpot.position;
* dambox.transform.eulerAngles = spreadShoot.transform.eulerAngles;
* dambox.transform.eulerAngles += new Vector3(0,-(spreadAngle/2)+ (i* spreadAngle/4),0);
*
* dambox.setDamage(spreadShoot.damage);
* dambox.duplicateAfterDoneDamage(spreadShoot);
* dambox.GetComponent<Bullet>().setSpeed(spreadShoot.speed);
* dambox.setOwner(myHitbox);*/
}
break;
case MODE.TRIPLE:
StartCoroutine(TripleShoot());
break;
case MODE.BOMB:
damageHitbox damHB = bombShoot.spawnDuplicate(shootSpot);
ChainAttack CATK = damHB.gameObject.GetComponent <ChainAttack>();
CATK.chainList[0].model = bomb;
break;
}
}
else if (isUltimate)
{
fireUltiArrow();
}
anim.SetBool("isTrail", false);
}
public void doActionADD(unitHitbox attacker, unitHitbox target, damageHitbox dhb)
{
unitCount++;
if (unitCount >= maxUnit && isActive && maxUnit != 0)
{
speed = 0;
damageHitbox.deActiveHitbox();
Debug.Log("Destroy Arrow");
damageHitbox.setDestroy();
}
}
// Use this for initialization
void Start()
{
stamina = maxStamina = baseStamina;
updateStamina();
hitbox = gameObject.GetComponent <unitHitbox>();
source = GetComponent <AudioSource>();
anim = GetComponent <Animator>();
isReceiving = true;
// normalAtkDH.deActiveHitbox();
//StartCoroutine(regenStamina());
}
void Start()
{
hitbox = GetComponent <unitHitbox>();
statContol = GetComponent <StatContol>();
speedReal = statContol.speedCurrent;
manaRing.updateGaugeImediate(manaMax, 0);
manaUltiRing.updateGaugeImediate(manaMax, 0);
manaRing.gameObject.SetActive(false);
wizardAnimAvatar.gameObject.SetActive(false);
myRigibody = gameObject.GetComponent <Rigidbody>();
}
public void getItem(unitHitbox player)
{
if (isFriendly)
{
foreach (afterPickItem aft in afterPickItemsList)
{
aft.doActionAPI(player);
}
player.showParticleEffect(particle);
Destroy(gameObject);
}
}
public bool CanPlayerPickItem(unitHitbox picker)
{
foreach (afterPickItem aft in afterPickItemsList)
{
if (!aft.checkPickItemCondition(picker))
{
return(false);
}
}
return(true);
}
