public override void LevelUp(int levels)
{
for (int l = levels; l > 0; l--)
{
if (NTGBattleDataController.CanPlayerLevelUp(level))
{
exp -= expCap;
for (int i = passives.Count - 1; i >= 0; i--)
{
var pBehaviour = (NTGBattlePassiveSkillBehaviour)passives[i];
pBehaviour.Notify(NTGBattlePassive.Event.LevelUp, null);
}
foreach (var pSkill in pSkills)
{
pSkill.Notify(NTGBattlePassive.Event.LevelUp, null);
}
NTGBattleDataController.GrowPlayerMemberAttrs(ref baseAttrs, roleId);
ApplyBaseAttrs();
level++;
skillPoint++;
}
}
}
public void AddEquip(string equipId)
{
var equip = NTGBattleDataController.GetBattleMemberEquip(Convert.ToInt32(equipId));
equips.Add(equip);
AddAttrs(equip.Attrs);
var skillList = new ArrayList();
for (int i = 0; i < pSkills.Length; i++)
{
skillList.Add(pSkills[i]);
}
for (int i = 0; i < equip.Skills.Length; i++)
{
var skill = mainController.AddPlayerSkill(this, equip.Skills[i].Resource);
skill.Init(equip.Skills[i], new float[0], new string[0]);
(skill as NTGBattlePassiveSkillController).Respawn();
skillList.Add(skill);
}
pSkills = new NTGBattlePassiveSkillController[skillList.Count];
skillList.CopyTo(pSkills);
}
public void Upgrade()
{
if (level == 0)
{
level = 1;
}
else
{
Load(NTGBattleDataController.GetBattleMemberSkill(nextLevel));
}
}
private IEnumerator doReviveCountDown()
{
reviveCountDown = NTGBattleDataController.GetPlayerReviveDuration(level);
if (id == mainController.localId)
{
mainController.uiController.StartPlayerReviveCountdown(reviveCountDown);
}
while (reviveCountDown > 0)
{
reviveCountDown -= Time.deltaTime;
yield return(null);
}
viewController.Kill();
Respawn();
}
public override void Respawn()
{
base.Respawn();
sc = skillController as UTGBattlePassiveSkillControllerR60100080;
transform.parent = owner.transform;
transform.localPosition = Vector3.zero;
transform.localRotation = Quaternion.identity;
unitBuff = new NTGBattleUnitController.UnitBuff {
icon = skillController.icon, desc = NTGBattleDataController.GetSkillDesc(skillController.id), ratio = 0f
};
owner.unitBuffs.Add(unitBuff);
FXEA();
FXEB();
}
public NTGBattleUnitController SmartTarget(NTGBattleSkillController skill)
{
NTGBattleUnitController target = null;
var units = viewController.unitsInView;
float topScore = -1;
NTGBattleUnitController lowPlayer = null;
NTGBattleUnitController lowBuilding = null;
NTGBattleUnitController lowMob = null;
float lowPlayerHpPer = 1.0f;
float lowBuildingHpPer = 1.0f;
float lowMobHpPer = 1.0f;
float lowPlayerScore = NTGBattleDataController.GetConfig("skill_player_hp");
float lowBuildingScore = NTGBattleDataController.GetConfig("skill_building_hp");
float lowMobScore = NTGBattleDataController.GetConfig("skill_mob_hp");
if (skill.type != NTGBattleSkillType.Attack)
{
lowPlayerScore = NTGBattleDataController.GetConfig("atk_player_hp");
lowBuildingScore = NTGBattleDataController.GetConfig("atk_building_hp");
lowMobScore = NTGBattleDataController.GetConfig("atk_mob_hp");
}
for (int i = 0; i < units.Count; i++)
{
var unit = (NTGBattleUnitController)units[i];
if (!unit.Lockable(group))
{
continue;
}
if ((skill.mask & unit.mask) == 0)
{
continue;
}
if (unit.group == group)
{
continue;
}
var sqrDist = (unit.transform.position - transform.position).sqrMagnitude;
if (skill.reqTarget != 2 && sqrDist > skill.sqrRange)
{
continue;
}
float hpPercent = unit.hp / unit.hpMax;
if (unit is NTGBattlePlayerController)
{
if (hpPercent < lowPlayerHpPer)
{
lowPlayer = unit;
lowPlayerHpPer = hpPercent;
}
}
else if (unit is NTGBattleMobController && (unit as NTGBattleMobController).type == 3)
{
if (hpPercent < lowBuildingHpPer)
{
lowBuilding = unit;
lowBuildingHpPer = hpPercent;
}
}
else
{
if (hpPercent < lowMobHpPer)
{
lowMob = unit;
lowMobHpPer = hpPercent;
}
}
}
float sqrTopDist = float.MaxValue;
for (int i = 0; i < units.Count; i++)
{
var unit = (NTGBattleUnitController)units[i];
if (!unit.Lockable(group))
{
continue;
}
if ((skill.mask & unit.mask) == 0)
{
continue;
}
if (unit.group == group)
{
continue;
}
var sqrDist = (unit.transform.position - transform.position).sqrMagnitude;
if (skill.reqTarget != 2 && sqrDist > skill.sqrRange)
{
continue;
}
float score = 0;
if (skill.type == NTGBattleSkillType.Attack)
{
if (unit is NTGBattlePlayerController)
{
score = NTGBattleDataController.GetConfig("atk_player");
}
else if (unit is NTGBattleMobController && (unit as NTGBattleMobController).type == 3)
{
score = NTGBattleDataController.GetConfig("atk_building");
}
else
{
score = NTGBattleDataController.GetConfig("atk_mob");
}
}
else
{
if (unit is NTGBattlePlayerController)
{
score = NTGBattleDataController.GetConfig("skill_player");
}
else if (unit is NTGBattleMobController && (unit as NTGBattleMobController).type == 3)
{
score = NTGBattleDataController.GetConfig("skill_building");
}
else
{
score = NTGBattleDataController.GetConfig("skill_mob");
}
}
if (sqrDist > skill.sqrRange)
{
if (skill.type == NTGBattleSkillType.Attack)
{
score -= NTGBattleDataController.GetConfig("atk_move") * ((float)Math.Sqrt(sqrDist) - skill.range);
}
else
{
score -= NTGBattleDataController.GetConfig("skill_move") * ((float)Math.Sqrt(sqrDist) - skill.range);
}
}
if (unit == lowPlayer)
{
score += lowPlayerScore;
}
else if (unit == lowBuilding)
{
score += lowBuildingScore;
}
else if (unit == lowMob)
{
score += lowMobScore;
}
if (score > topScore || (score == topScore && sqrDist < sqrTopDist))
{
target = unit;
topScore = score;
sqrTopDist = sqrDist;
}
}
return(target);
}
public override void Kill(NTGBattleUnitController killer)
{
if (alive)
{
base.Kill(killer);
unitAnimator.SetBool("dead", true);
mainController.NotifyPlayerKill(this);
if (voiceController != null)
{
voiceController.Kill(killer);
}
var givecoinGrade = 0;
if (killSteak.Count > 0 && deathSteak.Count > 0)
{
Debug.LogError("Player KillSteak and DeathSteak Can not Both Has Value! " + id);
}
if (killSteak.Count > 0)
{
givecoinGrade = killSteak.Count;
}
else if (deathSteak.Count > 0)
{
givecoinGrade = -deathSteak.Count;
}
killSteak.Clear();
deathSteak.Enqueue(new DeathRecord()
{
time = Time.time, killer = killer
});
HitRecord lastPlayerHit = null;
NTGBattleUnitController lastHitter = killer;
ArrayList assistSet = new ArrayList();
while (hitRecords.Count > 0)
{
var hitRecord = hitRecords.Dequeue() as HitRecord;
if (hitRecord.hitType == NTGBattleSkillBehaviour.EffectType.HpRecover || hitRecord.hitType == NTGBattleSkillBehaviour.EffectType.MpRecover)
{
continue;
}
var a = hitRecord.shooter as NTGBattlePlayerController;
if (a != null)
{
if (!assistSet.Contains(a))
{
a.statistic.assist++;
assistSet.Add(a);
}
lastPlayerHit = hitRecord;
}
lastHitter = hitRecord.shooter;
}
if (lastPlayerHit != null && Time.time - lastPlayerHit.time < mainController.configX)
{
var k = lastPlayerHit.shooter as NTGBattlePlayerController;
k.statistic.assist--;
assistSet.Remove(k);
k.statistic.kill++;
k.deathSteak.Clear();
k.killSteak.Enqueue(new KillRecord()
{
time = Time.time, victim = this
});
if (k.killSteak.Count > k.statistic.maxKillSteak)
{
k.statistic.maxKillSteak = k.killSteak.Count;
}
lastHitter = k;
for (int i = k.passives.Count - 1; i >= 0; i--)
{
var pBehaviour = (NTGBattlePassiveSkillBehaviour)k.passives[i];
pBehaviour.Notify(NTGBattlePassive.Event.Kill, new NTGBattlePassive.EventKillParam()
{
victim = this
});
}
foreach (var pSkill in k.pSkills)
{
pSkill.Notify(NTGBattlePassive.Event.Kill, new NTGBattlePassive.EventKillParam {
victim = this
});
}
}
mainController.uiController.ShowPlayerKillMessage(lastHitter, this, new KillRecord()
{
time = Time.time, victim = this
});
var giveexpPlayers = new ArrayList();
foreach (NTGBattleUnitController unit in mainController.battleUnits)
{
if (unit is NTGBattlePlayerController && unit.group != group && (transform.position - unit.transform.position).sqrMagnitude < rewardRange * rewardRange)
{
giveexpPlayers.Add(unit);
}
}
foreach (NTGBattleUnitController assist in assistSet)
{
if (!giveexpPlayers.Contains(assist))
{
giveexpPlayers.Add(assist);
}
for (int i = assist.passives.Count - 1; i >= 0; i--)
{
var pBehaviour = (NTGBattlePassiveSkillBehaviour)assist.passives[i];
pBehaviour.Notify(NTGBattlePassive.Event.Assist, new NTGBattlePassive.EventAssistParam()
{
victim = this
});
}
foreach (var pSkill in assist.pSkills)
{
pSkill.Notify(NTGBattlePassive.Event.Assist, new NTGBattlePassive.EventAssistParam {
victim = this
});
}
}
var giveexp = NTGBattleDataController.GetPlayerGiveExp(level) / giveexpPlayers.Count;
foreach (NTGBattlePlayerController player in giveexpPlayers)
{
player.AddExp(giveexp);
if (mainController.firstBlood && player == lastHitter)
{
player.AddExp(mainController.sceneInfo.FirstBloodExp);
}
}
var lastPlayerHitter = lastHitter as NTGBattlePlayerController;
if (lastPlayerHitter != null)
{
var givecoin = NTGBattleDataController.GetPlayerGiveCoin(givecoinGrade);
if (mainController.firstBlood)
{
lastPlayerHitter.AddCoin(mainController.sceneInfo.FirstBloodCoin + givecoin);
mainController.uiController.ShowUnitCoin(this, lastPlayerHitter, mainController.sceneInfo.FirstBloodCoin + givecoin);
}
else
{
lastPlayerHitter.AddCoin(givecoin);
mainController.uiController.ShowUnitCoin(this, lastPlayerHitter, givecoin);
}
if (lastPlayerHitter == mainController.uiController.localPlayerController)
{
PlayFXOnce(UnitFX.Coin);
}
assistSet.Remove(lastPlayerHitter);
if (assistSet.Count > 0)
{
givecoin *= mainController.configYPlayer / assistSet.Count;
foreach (NTGBattlePlayerController assist in assistSet)
{
assist.AddCoin(givecoin);
mainController.uiController.ShowUnitCoin(this, assist, givecoin);
}
}
}
if (mainController.firstBlood)
{
mainController.firstBlood = false;
}
if (navAgent.enabled)
{
navAgent.ResetPath();
navAgent.enabled = false;
}
mainController.uiController.HideUnitUI(this, false);
mainController.uiController.MiniMapDestory(this);
AddPassive("Revive");
}
}
