public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
float hpPc = skill.GetFloatInput("hp_pc");
float hpTime = skill.GetFloatInput("hp_time");
bool mastery = RollMastery(source);
if (mastery)
{
hpTime *= 2;
}
Buff buff = new Buff(skill.data.Id.ToString(), null, Common.BonusType.increase_healing_speed_on_pc, hpTime, hpPc);
source.Bonuses().SetBuff(buff, source);
return(true);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
var sourceTarget = source.Target();
bool settedOnTarget = false;
float time = skill.GetFloatInput("time");
bool mastery = RollMastery(source);
if (mastery)
{
time *= 2;
}
if (sourceTarget.targetObject)
{
var targetCharacter = sourceTarget.targetObject.Character();
if (targetCharacter)
{
var sourceCharacter = source.Character();
if (sourceCharacter.RelationTo(targetCharacter) == Common.FractionRelation.Friend)
{
var sourceWeapon = source.Weapon();
if (source.transform.DistanceTo(sourceTarget.targetObject.transform) <= sourceWeapon.optimalDistance)
{
var targetBonuses = sourceTarget.targetObject.Bonuses();
if (targetBonuses)
{
Buff buff = new Buff(skill.data.Id.ToString(), null, Common.BonusType.speed_debuff_immunity, time);
targetBonuses.SetBuff(buff, source);
settedOnTarget = true;
}
}
}
}
}
if (!settedOnTarget)
{
Buff buff = new Buff(skill.data.Id.ToString(), null, Common.BonusType.speed_debuff_immunity, time);
source.Bonuses().SetBuff(buff, source);
}
return(true);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
if (NotEnemyCheck(source, skill, info))
{
return(false);
}
float dmgMult = skill.data.Inputs.Value <float>("dmg_mult");
float critChancePc = skill.data.Inputs.Value <float>("crit_chance_pc");
float critChanceTime = skill.data.Inputs.Value <float>("crit_chance_time");
int skillCount = skill.data.Inputs.Value <int>("skill_counter");
var sourceWeapon = source.GetComponent <BaseWeapon>();
var skills = source.GetComponent <PlayerSkills>();
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
critChanceTime *= 2;
}
WeaponHitInfo hit;
var shotInfo = sourceWeapon.Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
if ((skills.lastSkill != skill.data.Id) || (skills.lastSkill == skill.data.Id && skills.sequenceSkillCounter < skillCount))
{
Buff buff = new Buff(skill.data.Id.ToString() + skills.sequenceSkillCounter, null, BonusType.increase_crit_chance_on_cnt, critChanceTime, critChancePc);
source.GetComponent <PlayerBonuses>().SetBuff(buff, source);
}
source.GetComponent <MmoMessageComponent>().SendShot(EventReceiver.OwnerAndSubscriber, shotInfo);
return(true);
}
else
{
source.GetComponent <MmoMessageComponent>().SendShot(EventReceiver.OwnerAndSubscriber, shotInfo);
return(false);
}
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
info.SetSkillUseState(Common.SkillUseState.normal);
if (ShotToEnemyRestricted(source, skill))
{
info.SetSkillUseState(Common.SkillUseState.invalidTarget);
return(false);
}
if (NotCheckDistance(source))
{
info.SetSkillUseState(Common.SkillUseState.tooFar);
return(false);
}
var targetObject = source.Target().targetObject;
var sourceWeapon = source.Weapon();
var sourceBonuses = source.Bonuses();
WeaponHitInfo hit;
float dmgMult = skill.GetFloatInput("dmg_mult");
float hpPc = skill.GetFloatInput("hp_pc");
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
hpPc *= 2;
}
var shot = sourceWeapon.Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
sourceWeapon.Heal(source, source.Damagable().maximumHealth *hpPc);
source.MmoMessage().SendShot(Common.EventReceiver.OwnerAndSubscriber, shot);
return(true);
}
else
{
source.MmoMessage().SendShot(Common.EventReceiver.ItemOwner, shot);
return(false);
}
}
private void LoadPlayer(BasePlayer player)
{
if (player == null)
{
return;
}
PlayerData.PData pdata = PlayerData.Get(player);
if (pdata == null)
{
Puts($"Loading for [{player.UserIDString}] has been delayed, waiting for the PlayerData plugin");
timer.Once(1f, () => LoadPlayer(player));
return;
}
// Remove the old homes first
UnloadPlayer(player);
Database.Query(Database.Build("SELECT * FROM skills WHERE user_id = @0;", pdata.id), records =>
{
PlayerSkill pskill = new PlayerSkill();
string info = $"Player skills for [{pdata.id}:{player.UserIDString}]:\n";
foreach (var record in records)
{
string skill = Convert.ToString(record["skill"]);
int xp = Convert.ToInt32(record["xp"]);
int level = Convert.ToInt32(record["level"]);
pskill.SetLevel(skill, level);
pskill.SetXp(skill, xp);
info += $"{skill}: Lv. {level} / Xp. {xp}\n";
}
skills.Add(player.userID, pskill);
// Puts(info.TrimEnd('\n'));
CreateUI(player);
});
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
info.SetSkillUseState(SkillUseState.normal);
if (!CheckForShotEnemy(source, skill))
{
info.SetSkillUseState(SkillUseState.invalidTarget);
return(false);
}
if (NotCheckDistance(source))
{
info.SetSkillUseState(SkillUseState.tooFar);
return(false);
}
float dmgMult = skill.data.Inputs.GetValue <float>("dmg_mult", 0f);
float blockHealInterval = skill.data.Inputs.GetValue <float>("block_heal_interval", 0f);
var weapon = source.GetComponent <BaseWeapon>();
WeaponHitInfo hit;
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
}
var shot = weapon.Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
if (mastery)
{
blockHealInterval *= 2;
}
Buff buff = new Buff(skill.data.Id.ToString(), null, BonusType.block_heal, blockHealInterval);
source.GetComponent <PlayerTarget>().targetObject.GetComponent <PlayerBonuses>().SetBuff(buff, source);
source.GetComponent <MmoMessageComponent>().SendShot(EventReceiver.OwnerAndSubscriber, shot);
return(true);
}
else
{
source.GetComponent <MmoMessageComponent>().SendShot(EventReceiver.OwnerAndSubscriber, shot);
return(false);
}
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
info.SetSkillUseState(SkillUseState.normal);
if (ShotToEnemyRestricted(source, skill))
{
info.SetSkillUseState(SkillUseState.invalidTarget);
return(false);
}
if (NotCheckDistance(source))
{
info.SetSkillUseState(SkillUseState.tooFar);
return(false);
}
float dmgMult = skill.GetFloatInput("dmg_mult");
float dmgPc = skill.GetFloatInput("dmg_pc");
float dmgTime = skill.GetFloatInput("time");
bool mastery = RollMastery(source);
if (mastery)
{
dmgPc *= 2;
dmgTime *= 2;
info.SetMastery(true);
}
else
{
info.SetMastery(false);
}
WeaponHitInfo hit;
var shot = source.Weapon().Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
Buff critChanceDebuff = new Buff(skill.data.Id.ToString(), null, Common.BonusType.decrease_damage_on_pc, dmgTime, dmgPc);
source.Target().targetObject.Bonuses().SetBuff(critChanceDebuff, source);
source.MmoMessage().SendShot(Common.EventReceiver.OwnerAndSubscriber, shot);
return(true);
}
return(false);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
float time = skill.GetFloatInput("time");
bool mastery = RollMastery(source);
if (mastery)
{
time *= 2;
}
source.Damagable().SetIgnoreDamage(time);
Buff blockWeaponDebuff = new Buff(skill.id, null, Common.BonusType.block_weapon, time);
source.Bonuses().SetBuff(blockWeaponDebuff, source);
return(true);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
bool result = base.TryCast(source, skill, out info);
if (result)
{
var damagable = source.Damagable();
float hpPc = skill.GetFloatInput("hp_pc");
bool mastery = RollMastery(source);
if (mastery)
{
hpPc *= 2;
}
//damagable.RestoreHealth(source, damagable.maximumHealth * hpPc);
var heal = source.Weapon().HealSelf(damagable.maximumHealth * hpPc, skill.idInt);
source.MmoMessage().SendHeal(Common.EventReceiver.OwnerAndSubscriber, heal);
}
return(result);
}
/// <summary>
/// skill setup for projectiles
/// </summary>
public TempPlayerSkill(PlayerSkill pSkill)
{
Amount = pSkill.UpgradableSkill.Amount;
Range = pSkill.UpgradableSkill.Range;
Cooldown = pSkill.UpgradableSkill.Cooldown;
TargetAlly = pSkill.UpgradableSkill.TargetAlly;
ProjectileSpeed = pSkill.UpgradableSkill.ProjectileSpeed;
EnergyCost = pSkill.UpgradableSkill.EnergyCost;
Piercing = pSkill.UpgradableSkill.Piercing;
Bleed = pSkill.UpgradableSkill.Bleed;
HealthOnHit = pSkill.UpgradableSkill.HealthOnHit;
EnergyOnHit = pSkill.UpgradableSkill.EnergyOnHit;
BaseSkill = pSkill;
for (int i = 0; i < pSkill.Upgrades.Count; i++)
{
Upgrades.Add(pSkill.Upgrades[i], 0);
}
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
if (!source)
{
return(false);
}
float optimalDistancePc = skill.data.Inputs.Value <float>("optimal_distance_pc");
float optimalDistanceTime = skill.data.Inputs.Value <float>("optimal_distance_time");
float radius = skill.data.Inputs.Value <float>("radius");
bool mastery = RollMastery(source);
if (mastery)
{
optimalDistanceTime *= 2;
}
var sourceChar = source.GetComponent <CharacterObject>();
var items = (source.world as MmoWorld).GetItems((it) => {
if (it.GetComponent <PlayerBonuses>() && it.GetComponent <CharacterObject>())
{
float dist = source.transform.DistanceTo(it.transform);
if (dist < radius)
{
if (sourceChar.RelationTo(it.GetComponent <CharacterObject>()) == FractionRelation.Friend)
{
return(true);
}
}
}
return(false);
});
foreach (var p in items)
{
Buff buff = new Buff(skill.data.Id.ToString(), null, BonusType.increase_optimal_distance_on_pc, optimalDistanceTime, optimalDistancePc);
p.Value.GetComponent <PlayerBonuses>().SetBuff(buff, source);
}
return(true);
}
public static PlayerSkill LoadPlayerSkill()
{
string path = Application.persistentDataPath + "/skill.fun";
if (File.Exists(path))
{
BinaryFormatter formatter = new BinaryFormatter();
FileStream stream = new FileStream(path, FileMode.Open);
PlayerSkill data = formatter.Deserialize(stream) as PlayerSkill;
stream.Close();
return(data);
}
else
{
Debug.LogError("Save file not found in " + path);
return(null);
}
}
void Start()
{
inventoryActive = false;
isDelay = false;
isAttackable = true;
controllable = true;
status = GetComponent <PlayerStatus>();
playerMove = GetComponent <PlayerMove>();
playerAnimation = GetComponentInChildren <PlayerAnimation>();
playerAttack = GetComponentInChildren <PlayerAttack>();
playerSkill = GetComponentInChildren <PlayerSkill>();
ui = Camera.main.GetComponent <UI_Controller>();
moveDirection = Vector2.zero;
spriteDirection = Vector2.down;
firstDirection = Vector2.zero;
//플레이어와 적 간의 물리적 충돌 무시 (밀림현상 방지)
Physics2D.IgnoreLayerCollision(LayerMask.NameToLayer("Player"), LayerMask.NameToLayer("Enemy"), true);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
info.SetSkillUseState(Common.SkillUseState.normal);
if (ShotToEnemyRestricted(source, skill))
{
info.SetSkillUseState(Common.SkillUseState.invalidTarget);
return(false);
}
if (NotCheckDistance(source))
{
info.SetSkillUseState(Common.SkillUseState.tooFar);
return(false);
}
float speedPc = skill.GetFloatInput("speed_pc");
float speedTime = skill.GetFloatInput("speed_time");
var target = source.Target().targetObject;
var targetMovable = target.Movable();
if (!targetMovable)
{
return(false);
}
bool mastery = RollMastery(source);
if (mastery)
{
speedTime *= 2;
info.SetMastery(true);
}
else
{
info.SetMastery(false);
}
Buff buff = new Buff(skill.data.Id.ToString(), null, Common.BonusType.decrease_speed_on_pc, speedTime, speedPc);
target.Bonuses().SetBuff(buff, source);
return(true);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
if (NotEnemyCheck(source, skill, info))
{
return(false);
}
var sourceWeapon = source.Weapon();
var targetObject = source.Target().targetObject;
float damageMult = skill.GetFloatInput("dmg_mult");
bool mastery = RollMastery(source);
if (mastery)
{
damageMult *= 2;
}
WeaponHitInfo hit;
var shot = sourceWeapon.Fire(out hit, skill.data.Id, damageMult);
if (hit.normalOrMissed)
{
Vector3 center = (source.transform.position + targetObject.transform.position) * 0.5f;
float radius = source.transform.DistanceTo(targetObject.transform) * 0.5f;
var skillComponent = source.GetComponent <Skill_0000045E_Component>();
if (skillComponent == null)
{
skillComponent = source.AddComponent <Skill_0000045E_Component>();
}
skillComponent.SetSkill(center, radius, skill.data);
source.MmoMessage().SendShot(Common.EventReceiver.OwnerAndSubscriber, shot);
return(true);
}
else
{
source.MmoMessage().SendShot(Common.EventReceiver.ItemOwner, shot);
return(false);
}
}
public IHttpActionResult PostPlayerSkill(int playerId, int skillId)
{
try
{
var playerSkill = new PlayerSkill
{
PlayerId = playerId,
SkillId = skillId
};
_context.PlayerSkills.AddOrUpdate(playerSkill);
_context.SaveChanges();
return(Created("Ok", playerSkill));
}
catch (Exception e)
{
return(InternalServerError(e));
}
}
void sendToModerator(PlayerSkill ps)
{
float playerXPosition = transform.position.x;
foreach (GameObject monster in monsterList)
{
float skeletonXPosition = monster.transform.GetChild(1).position.x;
//Debug.Log(skeletonXPosition);
//if monster in x range
if (playerXPosition - skillXRange / 2 < skeletonXPosition &&
(playerXPosition + skillXRange > skeletonXPosition))
{
// Debug.Log(skeletonXPosition);
moderator.calculateDamage(ps, monster);
moderator.calculateEffect(ps, monster);
}
}
}
void Start()
{
player = GameObject.FindGameObjectsWithTag("Player")[0];
collider = gameObject.GetComponent <BoxCollider2D>() as BoxCollider2D;
if (player == null || collider == null)
{
return;
}
skill = player.GetComponent <PlayerSkill>() as PlayerSkill;
if (skill == null)
{
return;
}
collider.isTrigger = true;
isTriggered = false;
skill.switchTriggerEvent.AddListener(Trigger);
}
/// <summary>
/// NOTE : 버프형 스킬 실행중일때 버튼 이미지 fIllamount, 색상 변경 및 text 남은시간 표시
/// </summary>
/// <param name="_skilldata"></param>
/// <returns></returns>
IEnumerator isRunningSkillImage(PlayerSkill _skilldata)
{
playerSc.isRunningSkillCooltime = true;
skillCooltimeText.gameObject.SetActive(true);
skillCooltimeImage.gameObject.SetActive(true);
skillCooltimeImage.fillAmount = 0;
skillCooltimeImage.color = gColor;
float currentTime = _skilldata.durationTime;
while (currentTime > 0)
{
currentTime -= Time.fixedDeltaTime;
skillCooltimeText.text = "" + (int)currentTime;
skillCooltimeImage.fillAmount += 1 * Time.deltaTime / _skilldata.durationTime;
yield return(new WaitForFixedUpdate());
}
skillCooltimeText.gameObject.SetActive(false);
StartCoroutine(CoolTimeCoroutine(_skilldata.coolTime));
}
public void LearnSkill(string skillNum)
{
int levelNum = skillNum[0] - '0';
int chooseNum = skillNum[1] - '0';
if (skillTree[trace][levelNum] != 0)
{
return;
}
Debug.Log(skillTreeNum + " " + trace + " " + levelNum + " " + chooseNum);
skill = SaveSystem.LoadPlayerSkill();
switch (skillTreeNum)
{
case 0:
skill.RedTree[trace][levelNum] = chooseNum;
break;
case 1:
skill.YellowTree[trace][levelNum] = chooseNum;
break;
case 2:
skill.BlueTree[trace][levelNum] = chooseNum;
break;
}
SaveSystem.SavePlayerSkill(skill);
PlayerData player = SaveSystem.LoadPlayer();
Skill s = new Skill();
s.num = "" + skillTreeNum + trace + levelNum + chooseNum;
s.name = "new";
s.icon = "1";
player.ALLSkills.Add(s);
Debug.Log("add");
SaveSystem.SavePlayer(player);
SkillLearnedCanvas.GetComponent <SkillsShowManager>().showSkills();
SwitchTree(skillTreeNum);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
if (ShotToEnemyRestricted(source, skill))
{
return(false);
}
var targetObject = source.Target().targetObject;
var sourceShip = source.GetComponent <BaseShip>();
var targetShip = targetObject.GetComponent <BaseShip>();
if ((!sourceShip) || (!targetShip))
{
return(false);
}
var sourceBonuses = source.Bonuses();
var targetBonuses = targetObject.Bonuses();
float time = skill.GetFloatInput("time");
bool mastery = RollMastery(source);
if (mastery)
{
time *= 2;
}
//decrated skill do nothing (only for icons)
Buff sourceDebuff = new Buff(skill.id, null, Common.BonusType.block_resist, time);
sourceBonuses.SetBuff(sourceDebuff, source);
sourceShip.BlockResist(time);
//decorated skill do nothing (only for icons)
Buff targetDebuff = new Buff(skill.id, null, Common.BonusType.block_resist, time);
targetBonuses.SetBuff(targetDebuff, source);
targetShip.BlockResist(time);
return(true);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
if (!CheckForShotEnemy(source, skill))
{
return(false);
}
float dmgMult = skill.data.Inputs.Value <float>("dmg_mult");
float effectProb = skill.data.Inputs.Value <float>("effect_prob");
var sourceWeapon = source.GetComponent <BaseWeapon>();
var targetBonuses = source.GetComponent <PlayerTarget>().targetObject.GetComponent <PlayerBonuses>();
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
effectProb *= 2;
}
WeaponHitInfo hit;
var shotInfo = sourceWeapon.Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
if (Rand.Float01() < effectProb)
{
BuffParameter prm = CommonUtils.GetRandomEnumValue <BuffParameter>(new List <BuffParameter>());
BonusType[] debuffs = BuffUtils.GetBuffsForParameter(prm);
foreach (var dbf in debuffs)
{
targetBonuses.RemoveBuffs(dbf);
}
}
source.GetComponent <MmoMessageComponent>().SendShot(EventReceiver.OwnerAndSubscriber, shotInfo);
return(true);
}
else
{
source.GetComponent <MmoMessageComponent>().SendShot(EventReceiver.OwnerAndSubscriber, shotInfo);
return(false);
}
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
if (!source)
{
return(false);
}
float hpPc = skill.data.Inputs.Value <float>("hp_pc");
float hpTime = skill.data.Inputs.Value <float>("hp_time");
var sourceDamagable = source.GetComponent <DamagableObject>();
var hpVal = sourceDamagable.maximumHealth * hpPc;
bool mastery = RollMastery(source);
if (mastery)
{
hpTime *= 2;
}
sourceDamagable.SetRestoreHPPerSec(hpVal, hpTime, source.Id + skill.data.Id.ToString());
return(true);
}
public void ChangeEffect(int i)
{
switch (i)
{
case 0:
selectedSkill = PlayerSkill.Heal;
break;
case 1:
selectedSkill = PlayerSkill.Defence;
break;
case 2:
selectedSkill = PlayerSkill.Haste;
break;
default:
break;
}
}
public void Make(NebulaObject source, PlayerSkill skill, float hpPc)
{
float radius = skill.GetFloatInput("radius");
/*
* var items = GetHealTargets(source, source, skill.GetFloatInput("radius"));
* float restoredHp = hpPc * source.Weapon().GetDamage(false).totalDamage;
*
* foreach(var pItem in items) {
* pItem.Value.Damagable().RestoreHealth(source, restoredHp);
* }*/
var weapon = source.Weapon();
float hp = weapon.GetDamage().totalDamage *hpPc;
foreach (var pFriend in GetNearestFriends(source, radius))
{
weapon.Heal(pFriend.Value, hp, skill.idInt, generateCrit: false);
}
}
public static MiCharacterInventory.ItemType GetAmmoType(PlayerSkill skill)
{
switch (skill)
{
case SkillSnipe _:
return(MiCharacterInventory.ItemType.SnipeAmmo);
case SkillGunAttackPlayer _:
return(MiCharacterInventory.ItemType.GunAmmo);
case SkillThrowGrenadeStun _:
return(MiCharacterInventory.ItemType.KnockoutGrenade);
case SkillThrowStraightMindControlDart _:
return(MiCharacterInventory.ItemType.ControlDart);
default:
return(0);
}
}
public void InitSkillDict()
{
string path = "Assets/Text/SkillTable.csv";
var data = File.ReadLines(path).Select(x => x.Split(',')).ToArray();
for (int skill = 1; skill < data.Length; skill++)
{
Dictionary <PlayerAttribute, int> attributeConfRow = new Dictionary <PlayerAttribute, int>();
for (int attr = 1; attr < data[0].Length; attr++)
{
//the names of the attributes are in the first row
PlayerAttribute currentAttr = CsvNameToAttributeEnum[data[0][attr]];
attributeConfRow.Add(currentAttr, int.Parse(data[skill][attr]));
}
//the names of the akills are in the first column
PlayerSkill currentSkill = CsvNameToSkillEnum[data[skill][0]];
skillConfigurationDict.Add(currentSkill, attributeConfRow);
}
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
if (NotEnemyCheck(source, skill, info))
{
return(false);
}
float dmgMult = skill.data.Inputs.Value <float>("dmg_mult");
float enPc = skill.data.Inputs.Value <float>("en_pc");
var sourceWeapon = source.GetComponent <BaseWeapon>();
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
enPc *= 2;
}
WeaponHitInfo hit;
var shotInfo = sourceWeapon.Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
var energy = source.GetComponent <PlayerTarget>().targetObject.GetComponent <ShipEnergyBlock>();
if (energy)
{
float removedEnergy = energy.maximumEnergy * enPc;
energy.RemoveEnergy(removedEnergy);
}
source.GetComponent <MmoMessageComponent>().SendShot(EventReceiver.OwnerAndSubscriber, shotInfo);
return(true);
}
else
{
source.GetComponent <MmoMessageComponent>().SendShot(EventReceiver.OwnerAndSubscriber, shotInfo);
return(false);
}
}
// Use this for initialization
void Start()
{
layerActiveGround = 11;
layerActiveItem = 10;
layerActiveEnemy = 9;
destinationPosition = this.transform.position;
animationManager = this.GetComponent <AnimationManager>();
playerSkill = this.GetComponent <PlayerSkill>();
playerStatus = this.GetComponent <PlayerStatus>();
controller = this.GetComponent <CharacterController>();
flinchValue = 100; //Declare flinch value (if zero it will flinch)
delayAttack = 100; //Declare delay 100 sec
defaultColor = new Color[modelMesh.Count];
DeadSpawnPoint = GameObject.FindGameObjectWithTag("SpawnHero");
SetDefualtColor();
}
//For Special Enemies Checking
// public GameObject tempura1;
// public GameObject makiroll1;
void Start()
{
if (SceneManager.GetActiveScene().buildIndex == 2)
{
f1Manager = FindObjectOfType <Fight1Manager>();
}
else if (SceneManager.GetActiveScene().buildIndex == 4)
{
f2Manager = FindObjectOfType <Fight2Manager>();
}
comboUI = GetComponent <ComboCounter>();
consumeCheck = GetComponent <EnemyHealthManager>();
consuming = false;
healthCheck = gameObject.GetComponent <PlayerHealth>();
RightConsumeBox.SetActive(false);
anim = GetComponent <Animator> ();
skillScript = GetComponent <PlayerSkill> ();
GameObject iconsHolder = GameObject.Find("HUDCanvas/AbilityIcons");
consumeIcon = iconsHolder.transform.GetChild(4).GetComponent <IconCoolDown>();
}
public static string GetPlayerSkillName(PlayerSkill skill, int bonus)
{
int index = (int)skill + bonus;
if (index > 20) {
index = 20;
}
return (HM.Resources.Constants.EnumNames.PlayerSkillNames[index]);
}
private static void IncreasePlayerSkill(PlayerSkill pSkill, int value)
{
switch (pSkill)
{
case PlayerSkill.Knowledge:
{
Player.Instance.KnowledgeSkills += value;
break;
}
case PlayerSkill.Presentation:
{
Player.Instance.PresentationSkills += value;
break;
}
case PlayerSkill.Media:
{
Player.Instance.MediaSkills += value;
break;
}
default:
{
throw new ArgumentOutOfRangeException();
}
}
}
public PlayerProfileSkill(PlayerSkill playerSkill, ProfileSkillPriority profileSkillPriority)
{
Skill = playerSkill;
SkillPriority = profileSkillPriority;
}
public static string GetPlayerSkillName(PlayerSkill skill)
{
return (HM.Resources.Constants.EnumNames.PlayerSkillNames[(int)skill]);
}
