public override void onDefence(BattleFighter attacker, BattleFighter owner)
{
if (!attacker.Hero)
{
return;
}
//˯Ãß״̬²»»á´ò»¤¶Ü
if (attacker.hasState(BattleConstants.ATTACK_ZERO_FLAG))
{
return;
}
BattleFighterBuff _buff = owner.BuffManager.getBattleBuff(this);
if (_buff == null)
{
// TODO: loggers.error
return;
}
int _shieldOrder = getCurShieldOrder(_buff);
if (isShieldOff(_shieldOrder))
{
Logger.Log(string.Format("shield off, index = {0:D}", owner.Index));
return;
}
int _resultShield = hitShield(attacker, _shieldOrder);
Logger.Log(string.Format("shield refresh, index = {0:D}, value = {1:D}", owner.Index, _resultShield));
_buff.setParam(BattleKeyConstants.BATTLE_BUFF_CUR_SHIELD_ORDER, _resultShield);
checkShieldBreak(owner, _buff, _resultShield);
}
public override List<BattleFighter> getTarget(BattleFighter attacker, BattleTeam defencerTeam)
{
List<BattleFighter> _curFighterList = new List<BattleFighter>();
BattleFighter _fighter = defencerTeam.getActor(index);
_curFighterList.Add(_fighter);
return _curFighterList;
}
public BattleHeroSkillManager(BattleFighter fighter, HeroTeam ownerTeam) : base(fighter)
{
// TODO: 这里之后是单例的Action
this.ownerTeam = ownerTeam;
init();
// TODO: 以后重构
}
public static int calcBattleFighterCurHpPercent(int percent, BattleFighter fighter)
{
float _totalHp = fighter.FighterCurHp;
float _percent = percent;
float _costHp = _totalHp * (_percent / BattleConstants.BATTLE_RATIO_BASE);
return (int) _costHp;
}
/// <summary>
/// S1=（武将战斗中攻击力*（1+无双技能加成倍数）-怪物防御力）*伤害加成倍数*弱点加成倍数*带盾减伤倍数*（1-减伤比）*攻击次数
/// </summary>
/// <param name="attacker"> </param>
/// <param name="defencer"> </param>
/// <param name="fightRecord"> </param>
public virtual void onAttack(BattleFighter attacker, BattleFighter defencer, BattleFightRecord fightRecord)
{
// TODO: afterAttack在其他effect也可能会涉及
SingleActionRecord _record = initDefenceRecord(defencer, fightRecord);
float _attack = getAttack(attacker);
float _spValMuti = this.attackValMuti / BattleConstants.BATTLE_RATIO_BASE;
float _defence = defencer.Defence;
float _indexValMuti = calcIndexRatio(attacker);
float _weakRatio = calcJobWeakValue(attacker, defencer);
float _damageMuti = calcDamageModify(attacker.DamageMuti);
float _damageFree = calcDamageModify(defencer.DamageFree);
_attack = calcSingleDamage(_attack, _defence, _indexValMuti, _spValMuti, _weakRatio, _damageMuti, _damageFree);
_attack = calcAttackerState(attacker, _attack);
_attack = calcDefencerState(defencer, _attack);
float _costHpFloat = _attack * this.hitCount;
// 四舍五入
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int _costHp = com.kx.sglm.core.util.MathUtils.float2Int(_costHpFloat);
int _costHp = MathUtils.float2Int(_costHpFloat);
costHp(_costHp, defencer, _record);
recordDamageInfo(attacker.Battle, (int) _attack, _record);
fightRecord.finishCurDefecner();
Console.WriteLine("Fighter fight costHp " + _costHp);
}
/// <summary>
/// 初始化必要的数据：攻击者动作类型，攻击者初始数据
/// </summary>
/// <param name="actType"> </param>
/// <param name="attacker"> </param>
/// <param name="fightRecord"> </param>
public static void initBattleFight(int actType, BattleFighter attacker, BattleFightRecord fightRecord)
{
fightRecord.SourceIndex = attacker.Index;
SingleActionRecord _attackAction = fightRecord.OrCreateAttack;
_attackAction.ActType = actType;
initSingleRecord(attacker, _attackAction);
}
protected internal override void onSingleAction(BattleFighter attacker, BattleFighter defencer, SkillDataHolder resultData)
{
foreach (int _buffId in buffIds)
{
defencer.addBuff(new BuffInfo(_buffId, buffCondition));
}
}
public override List<BattleFighter> getTarget(BattleFighter attacker, BattleTeam targetTeam)
{
List<BattleFighter> _curFighterList = new List<BattleFighter>();
_curFighterList.Add(attacker);
return _curFighterList;
}
/// <summary>
/// 核心方法，执行技能动作
/// </summary>
/// <param name="attacker"> </param>
/// <param name="record"> </param>
internal virtual void optionAction(BattleFighter attacker, BattleFightRecord record)
{
// 创建一个供不同动作之间数据沟通的记录
SkillDataHolder _holder = new SkillDataHolder();
// 动作分两步
// 准备数据
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.List<com.kx.sglm.gs.battle.share.actor.impl.BattleFighter> _enemyList = calcTargetList(attacker, true);
List<BattleFighter> _enemyList = calcTargetList(attacker, true);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.List<com.kx.sglm.gs.battle.share.actor.impl.BattleFighter> _friendList = calcTargetList(attacker, false);
List<BattleFighter> _friendList = calcTargetList(attacker, false);
List<ISkillEffect> _activeEffects = calcActiveEffectByRate();
_holder.Record = record;
_holder.Attacker = attacker;
_holder.EnemyList = _enemyList;
_holder.FriendList = _friendList;
_holder.ActiveEffect = _activeEffects;
// 执行动作内容
optionEffectAction(_holder);
// 执行动作后操作
optionAfterAction(_holder);
}
public BattleBuffManager(BattleFighter owner)
{
this.owner = owner;
allBuffs = new Dictionary<int, BattleFighterBuff>();
buffHolderMap = new Dictionary<int, BuffTypeHolder>();
debuffHolderMap = new Dictionary<int, BuffTypeHolder>();
}
public override List<BattleFighter> getTarget(BattleFighter attacker, BattleTeam targetTeam)
{
List<BattleFighter> _curFighterList = new List<BattleFighter>();
int _index = attacker.getOwnerTeam().getIntProp(BattleKeyConstants.BATTLE_KEY_HERO_TEAM_TARGET);
BattleFighter _fighter = targetTeam.getActor(_index);
_curFighterList.Add(_fighter);
return _curFighterList;
}
public BattleFighterBuff(BattleFighter owner, IBuffAction buffAction)
{
this.buffAction = buffAction;
this.owner = owner;
this.stackingList = new LinkedList<BuffStackInfo>();
this.paramMap = new Dictionary<int, int>();
this.permanent = buffAction.CDRound <= 0;
}
public virtual BattleFighterBuff putBuff(BattleFighter owner, BuffInfo info)
{
IBuffAction _buffAction = info.BuffAction;
BattleFighterBuff _buff = createBattleFighterBuff(owner, _buffAction);
buffMap[_buffAction.TypeB] = _buff;
_buff.stackingBuff(info);
return _buff;
}
public override List<BattleFighter> getTarget(BattleFighter attacker, BattleTeam targetTeam)
{
List<BattleFighter> _curFighterList = new List<BattleFighter>();
List<BattleFighter> _fighters = targetTeam.AllBattingFighter;
int _index = MathUtils.random(0, _fighters.Count - 1);
BattleFighter _fighter = _fighters[_index];
_curFighterList.Add(_fighter);
return _curFighterList;
}
public static void refreshState(BattleFighter fighter)
{
fighter.refreshState();
List<BattleFighterState> _stateList = fighter.BuffManager.AllFighterState;
foreach (BattleFighterState _state in _stateList)
{
fighter.addState(_state);
}
}
public override void onAction(BattleFighter attacker, List<BattleFighter> defencerList, SkillDataHolder resultData)
{
initRecord(attacker, resultData.Record);
foreach (BattleFighter _defencer in defencerList)
{
onSingleAction(attacker, _defencer, resultData);
}
}
protected internal override float recoverOption(BattleFighter attacker, BattleFighter defencer)
{
float _totalHp = attacker.BattleTotalHp;
float _ratio = percent / BattleConstants.BATTLE_RATIO_BASE;
float _recover = _totalHp * _ratio + baseValue;
_recover = BattleLogicHelper.calcAttackerState(attacker, _recover);
attacker.changeFighterHp((int)_recover);
return _totalHp * _ratio;
}
public static float calcAttackerState(BattleFighter attacker, float damage)
{
float _resultDamage = damage;
if (attacker.hasState(BattleConstants.ATTACK_ZERO_FLAG))
{
_resultDamage = 0;
}
return _resultDamage;
}
public override bool canOption(BattleFighter attacker)
{
if (attacker.Hero)
{
Logger.Log(string.Format("#AIHpLeftLessCondition.canOption, attacker is hero, uuid = {0:D}", attacker.Battle.BattleSource.Uuid));
return false;
}
return leftHpPercent >= attacker.FighterCurHpPercent;
}
public override bool canOptionSkill(BattleFighter attacker)
{
if (!attacker.Hero)
{
return false;
}
BattleTeam _team = attacker.getOwnerTeam();
int _curFighterCount = _team.CurTeamShotFighterCount;
return _curFighterCount >= pointCount;
}
protected internal override void onSingleAction(BattleFighter attacker, BattleFighter defencer, SkillDataHolder resultData)
{
HeroColor _color = HeroColor.getValue(colorIndex);
BattleFightRecord _record = resultData.Record;
SingleActionRecord _singleRecord = _record.OrCreateDefence;
_singleRecord.ActType = BattleRecordConstants.SINGLE_ACTION_TYPE_CHANGED_COLOR;
BattleRecordHelper.initSingleRecord(defencer, _singleRecord);
defencer.changeColor(_color, _singleRecord);
_record.finishCurDefecner();
}
public override void onTeamBeforeAttack(BattleFighter fighter)
{
//TODO: 这里要优化和调试，战斗Record还是有些不顺
BattleTeamFightRecord _teamRecord = fighter.Battle.Record.OrCreateTeamFighterRecord;
BattleFightRecord _record = _teamRecord.OrCreateRecord;
fighter.SkillManager.useSkill(skillId, _record);
_teamRecord.finishCurRecord();
}
protected internal virtual int hitShield(BattleFighter attacker, int shieldOrder)
{
HeroColor _curColor = attacker.getOwnerTeam().CurFightColor;
int _curShieldOrder = shieldOrder % 10;
int _resultValue = shieldOrder;
if (_curColor.Index == _curShieldOrder)
{
_resultValue = shieldOrder / 10;
}
return _resultValue;
}
public override bool canOptionSkill(BattleFighter attacker)
{
if (!attacker.Hero)
{
return false;
}
BattleTeam _fighterTeam = attacker.getOwnerTeam();
int _realIndex = _fighterTeam.getCurTeamShotFighterIndex(attacker);
return nIndex == _realIndex;
}
private int calcResultFlag(BattleFighter attacker, BattleTeam targetTeam)
{
int _targetFlag = 0xffff;
foreach (ISkillTargetGetter _targetGetter in targetGetterList)
{
List<BattleFighter> _targetFighterList = _targetGetter.getTarget(attacker, targetTeam);
int _curFlag = calcTargetFlag(_targetFighterList);
_targetFlag &= _curFlag;
}
return _targetFlag;
}
protected internal virtual List<BaseHeroBattleSkillAction> getSkillAction(int trigger, BattleFighter attacker)
{
List<BaseHeroBattleSkillAction> _actionList = new List<BaseHeroBattleSkillAction>();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final com.kx.sglm.gs.battle.share.skill.model.SkillActionHolder _holder = actionHolderArr[trigger];
SkillActionHolder _holder = actionHolderArr[trigger];
if (_holder != null)
{
_actionList.AddRange(_holder.getActAction(attacker));
}
return _actionList;
}
public virtual List<BaseHeroBattleSkillAction> getActAction(BattleFighter attacker)
{
List<BaseHeroBattleSkillAction> _toActList = new List<BaseHeroBattleSkillAction>();
foreach (BaseHeroBattleSkillAction _action in skillActionList)
{
if (_action.canOption(attacker))
{
_toActList.Add(_action);
}
}
return _toActList;
}
protected internal override void initRecord(BattleFighter attacker, BattleFightRecord fightRecord)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final com.kx.sglm.gs.battle.share.actor.impl.BattleTeam _attackerTeam = attacker.getOwnerTeam();
BattleTeam _attackerTeam = attacker.getOwnerTeam();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int _targetIndex = _attackerTeam.getIntProp((com.kx.sglm.gs.battle.share.BattleKeyConstants.BATTLE_KEY_HERO_TEAM_TARGET));
int _targetIndex = _attackerTeam.getIntProp((BattleKeyConstants.BATTLE_KEY_HERO_TEAM_TARGET));
BattleRecordHelper.initBattleFight(AttackType, attacker, fightRecord);
SingleActionRecord _attackAction = fightRecord.OrCreateAttack;
_attackAction.addProp(BattleRecordConstants.SINGLE_ACTION_PROP_ATTACK_TARGET, _targetIndex);
}
public override List<BattleFighter> getTarget(BattleFighter attacker, BattleTeam targetTeam)
{
List<BattleFighter> _fighterList = new List<BattleFighter>();
List<BattleFighter> _baseFighters = getBaseFighter(targetTeam);
foreach (BattleFighter _fighter in _baseFighters)
{
if (isFitFlag(_fighter))
{
_fighterList.Add(_fighter);
}
}
return _fighterList;
}
protected internal virtual List<BattleFighter> calcTargetList(BattleFighter attacker, BattleTeam targetTeam)
{
int _targetFlag = calcResultFlag(attacker, targetTeam);
List<BattleFighter> _resultTarget = new List<BattleFighter>();
int _teamSize = targetTeam.allActorSize();
for (int _i = 0; _i < _teamSize; _i++)
{
if (MathUtils.hasFlagIndex(_targetFlag, _i))
{
_resultTarget.Add(targetTeam.getActor(_i));
}
}
return _resultTarget;
}
