protected virtual bool UnEffectTarget(IBoostEffect effect, ISkill srcSkill, ISkillPlayer caster, List <T> targets)
{
if (null != effect.SrcModelSetting && null != caster)
{
effect.RemoveShowModel(srcSkill, caster, false);
}
foreach (var target in targets)
{
target.RemoveBoost(effect);
}
return(true);
}
public bool Repeat(ISkillPlayer caster)
{
if (this.RedoEffectors.Count == 0)
{
return(false);
}
if (this.SkillState != EnumSkillState.Effecting)
{
return(false);
}
return(this.RepeatCore(caster, true));
}
protected List <T> Locate(ISkill srcSkill, ISkillPlayer caster, byte undoFlag)
{
var targets = this._targets;
if (null != caster)
{
targets = GetTargets(caster);
if (null == targets)
{
targets = new List <T>();
_castTargets[caster] = targets;
}
}
if (undoFlag > 0)
{
_undoTargets.Clear();
_undoTargets.AddRange(targets);
}
if (!this._locator.Locate(targets, srcSkill, caster))
{
return(null);
}
if (undoFlag == 0)
{
return(targets);
}
if (undoFlag == 1 && _undoTargets.Count == 0)
{
undoFlag = 2;
}
GetUndoTargets(targets, this._undoTargets, this._newTargets, undoFlag);
if (this._undoTargets.Count == 0)
{
return(targets);
}
foreach (var effect in this._effects)
{
if (!effect.Recycle)
{
continue;
}
if (effect is IBoostEffect)
{
this.UnEffectTarget((IBoostEffect)effect, srcSkill, caster, this._undoTargets);
}
else if (effect is INormalEffect)
{
this.UnEffectTarget((INormalEffect)effect, srcSkill, caster, this._undoTargets);
}
}
return(targets);
}
public bool EffectManager(ISkill srcSkill, ISkillPlayer caster, IList <ISkillManager> dstManagers)
{
if (null == dstManagers || dstManagers.Count == 0)
{
return(false);
}
this.StartEffect(srcSkill, caster);
foreach (var item in dstManagers)
{
((IBoostCore)item).AddBoost(this);
}
return(true);
}
public bool EffectPlayers(ISkill srcSkill, ISkillPlayer caster, IList <ISkillPlayer> dstPlayers)
{
if (null == dstPlayers || dstPlayers.Count == 0)
{
return(false);
}
this.StartEffect(srcSkill);
foreach (var item in dstPlayers)
{
((ISpecBuffCore)item).AddSpecBuff(this);
}
return(true);
}
protected bool FoulPlayer(ISkill srcSkill, ISkillPlayer caster, ISkillPlayer target, int buffId, int rate, int depth)
{
int foulType = this.FoulType;
if (null == target)
{
return(false);
}
if (null == caster || caster == target)
{
caster = target.OppSkillPlayer;
}
if (null == caster)
{
return(false);
}
if (!this.PureFlag)
{
//反弹犯规
if (depth > 0 && BoostUtil.IfAntiDebuff(this, srcSkill, target, (int)EnumBoostRootType.TurnFoul))
{
return(FoulPlayer(srcSkill, target, caster, buffId, rate, --depth));
}
//免疫犯规
if (BoostUtil.IfAntiDebuff(this, srcSkill, target, (int)EnumBoostRootType.AntiFoul))
{
return(true);
}
//降低犯规概率
BoostUtil.GetEaseRate(out rate, rate, target, (int)EnumBoostRootType.FoulRate, buffId);
}
if (srcSkill.Context.RandomPercent(SkillDefines.MAXStorePercent) > rate)
{
return(true);
}
//一定概率降低犯规等级
int point, percent;
if (BoostUtil.GetEaseValue(out point, out percent, target, (int)EnumBoostRootType.FoulValue))
{
if (srcSkill.Context.RandomPercent(SkillDefines.MAXStorePercent) <= percent)
{
foulType -= point;
}
}
if (foulType >= 0)
{
InnerFoul(srcSkill, target, foulType);
}
return(true);
}
public bool Trigger(ISkill srcSkill, ISkillPlayer caster)
{
var trigger = null != caster ? caster.SkillManager : srcSkill.Owner as ISkillManager;
if (null == trigger)
{
return(false);
}
if (Side == EnumOwnSide.Opp)
{
trigger = trigger.OppSkillManager;
}
return(CheckValue(trigger.GetStatInt((int)StatType)));
}
protected void GetAmp(ISkill srcSkill, ISkillPlayer caster, bool pureFlag, out int last, out int rate)
{
//ISkillOwner owner = caster ?? srcSkill.Owner;
BoostUtil.GetAmpRate(out rate, this.Rate, srcSkill, (int)EnumBoostRootType.BlurRate, this.BlurCode);
last = this.Last;
if (last > 0)
{
BoostUtil.GetAmpLast(out last, last, srcSkill, (int)EnumBoostRootType.BlurLast, this.BlurCode);
}
if (pureFlag || this.Last <= 0)
{
last = srcSkill.Context.GetBuffLast(srcSkill, caster, last);
}
}
protected void GetAmp(ISkill srcSkill, ISkillPlayer caster, int buffId, bool pureFlag, out int last, out int point, out int percent)
{
//ISkillOwner owner = caster ?? srcSkill.Owner;
BoostUtil.GetAmpValue(out point, out percent, this.Point, this.Percent, srcSkill, ValueBuffUnits(buffId));
last = this.Last;
if (last > 0)
{
BoostUtil.GetAmpLast(out last, last, srcSkill, LastBuffUnits(buffId));
}
if (pureFlag || this.Last <= 0)
{
last = srcSkill.Context.GetBuffLast(srcSkill, caster, last);
}
}
bool CheckCore(ISkillPlayer dstPlayer, ISkillManager srcManager)
{
if (this.BallSide == EnumBallSide.None && this.BallState == EnumBallState.None)
{
return(true);
}
var holder = srcManager.SkillMatch.SkillBallHandler;
if (null == holder || null == srcManager)
{
return(false);
}
bool atkFlag = srcManager.SkillSide == holder.SkillSide;
bool holdFlag = null != dstPlayer && dstPlayer.SkillHoldBall;
switch (this.BallSide)
{
case EnumBallSide.Atk:
if (!atkFlag)
{
return(false);
}
break;
case EnumBallSide.Def:
if (atkFlag)
{
return(false);
}
break;
}
switch (this.BallState)
{
case EnumBallState.HoldBall:
if (!holdFlag)
{
return(false);
}
break;
case EnumBallState.OffBall:
if (holdFlag)
{
return(false);
}
break;
}
return(true);
}
public bool Locate(List <ISkill> targets, ISkill srcSkill, ISkillPlayer caster)
{
targets.Clear();
var srcManager = null != caster ? caster.SkillManager : srcSkill.Owner as ISkillManager;
List <ISkill> skills = null;
if (null != this.ManagerSeeker)
{
skills = this.ManagerSeeker.Seek(srcManager);
if (null != skills && skills.Count > 0)
{
targets.AddRange(skills);
}
}
List <ISkillPlayer> dstPlayers = null;
if (null != this.PlayerLocator)
{
dstPlayers = this.PlayerLocator.Locate(srcSkill, caster);
}
if (null == dstPlayers && null == caster)
{
return(true);
}
if (null == dstPlayers)
{
dstPlayers = new List <ISkillPlayer>(1);
dstPlayers.Add(caster);
}
if (null == this.PlayerSeeker)
{
foreach (var dstPlayer in dstPlayers)
{
if (null != dstPlayer.SkillCore.SkillList)
{
targets.AddRange(dstPlayer.SkillCore.SkillList);
}
}
}
else
{
skills = this.PlayerSeeker.Seek(dstPlayers);
if (null != skills && skills.Count > 0)
{
targets.AddRange(skills);
}
}
return(true);
}
public bool Trigger(ISkill srcSkill, ISkillPlayer caster)
{
if (TimeStep <= 0)
{
return(true);
}
int round = srcSkill.Context.MatchRound;
int weight = BuffUtil.GetTimeWeight(srcSkill.Context, TimeType);
if (weight * TimeStep <= 1)
{
return(true);
}
return(round % (weight * TimeStep) == 1);
}
public bool Trigger(ISkill srcSkill, ISkillPlayer caster)
{
if (null == this.Locator)
{
return(false);
}
var players = this.Locator.Locate(srcSkill, caster);
int cnt = 0;
if (null != players)
{
cnt = players.Count;
}
return(MinNum <= cnt && cnt <= MaxNum);
}
public List <ISkillPlayer> Seek(ISkill srcSkill, ISkillPlayer caster)
{
var srcManager = null != caster ? caster.SkillManager : srcSkill.Owner as ISkillManager;
var players = InnerSeek(srcSkill, srcManager, caster);
if (null == players || players.Count == 0)
{
return(null);
}
if (null == Filters || Filters.Count == 0)
{
for (int i = players.Count - 1; i >= 0; --i)
{
if (players[i].Disable)
{
players.RemoveAt(i);
}
}
return(players);
}
var idxes = srcManager.SkillMatch.ArrayBuffer(100);
for (int i = 0; i < players.Count; ++i)
{
idxes[i] = 0;
if (players[i].Disable)
{
idxes[i] = 1;
continue;
}
foreach (var filter in Filters)
{
if (!filter.Check(srcManager, caster, players[i]))
{
idxes[i] = 1;
break;
}
}
}
for (int i = players.Count - 1; i >= 0; --i)
{
if (idxes[i] > 0)
{
players.RemoveAt(i);
}
}
return(players);
}
public override bool EffectSkills(ISkill srcSkill, ISkillPlayer caster, IList <ISkill> dstSkills)
{
if (null == dstSkills || dstSkills.Count == 0)
{
return(false);
}
this.StartEffect(srcSkill, caster);
foreach (var item in dstSkills)
{
((IBoostCore)item).AddBoost(this);
if (this.Last <= (short)EnumBuffLast.TillWaitEnd && null != item.Owner)
{
item.Owner.AddBoostToSkill(item);
}
}
return(true);
}
public void AddSrcShowModel(ISkill srcSkill, ISkillPlayer caster, int last)
{
if (null == caster || null == caster.SkillCore)
{
return;
}
var model = this.SrcModelSetting;
if (null == model || model.ModelId <= 0)
{
return;
}
if (model.ModelLast > 0)
{
last = srcSkill.Context.GetBuffLast(srcSkill, caster, model.ModelLast);
}
caster.SkillCore.AddShowModel(srcSkill, model.ModelId, last);
}
protected override bool CheckCore(ISkillPlayer dstPlayer)
{
if (null != Ids && Ids.Length > 0)
{
for (int i = 0; i < Ids.Length; i++)
{
if (Ids[i] == dstPlayer.SkillPlayerId)
{
break;
}
if (i == Ids.Length - 1)
{
return(false);
}
}
}
return(base.CheckCore(dstPlayer));
}
protected override byte[] GetClipTargets(ISkillPlayer caster)
{
var targets = GetTargets(caster);
if (null == targets || targets.Count == 0)
{
return(null);
}
var players = targets[0].SkillPlayerList;
int cnt = players.Count;
var array = new byte[cnt];
for (int i = 0; i < cnt; i++)
{
array[i] = players[i].SkillClientId;
}
return(array);
}
protected virtual bool AddBuff(ISkill srcSkill, ISkillPlayer caster, ISkillPlayer target, bool pureFlag, int last, int rate)
{
if (!pureFlag)
{
if (BoostUtil.IfAntiDebuff(this, srcSkill, target, true, (int)EnumBoostRootType.AntiBlur, this.BlurCode))
{
return(true);
}
BoostUtil.GetEaseRate(out rate, rate, target, (int)EnumBoostRootType.BlurRate, this.BlurCode);
if (this.Last > 0)
{
BoostUtil.GetEaseLast(out last, last, target, (int)EnumBoostRootType.BlurLast, this.BlurCode);
last = srcSkill.Context.GetBuffLast(srcSkill, caster, last);
}
}
if (!BuffUtil.ExecRate(out rate, rate, srcSkill.Context, this.ExecType))
{
return(false);
}
if (rate <= 0)
{
return(true);
}
int buffId = this.BuffId[0];
if (buffId == (int)EnumBlurType.BanMan)
{
target.DisableState = (int)this.BlurCode;
}
else
{
if (buffId == (int)EnumBlurType.LockMotion)
{
target.RemoveBuff(buffId, 0);
}
if (!target.AddBuff(InnerCreateBuff(srcSkill, target, (short)last, rate)))
{
return(false);
}
}
this.AddTgtShowModel(srcSkill, target, last);
return(true);
}
protected virtual bool RevokeCore(ISkill srcSkill, ISkillPlayer caster, List <T> targets)
{
if (null == targets || targets.Count == 0)
{
return(true);
}
if (null != this._booster && this._booster.Count > 0)
{
this.RevokeBoost(srcSkill, caster, targets);
}
if (null != this._buffFeeder && this._buffFeeder.Count > 0)
{
foreach (var effect in this._buffFeeder)
{
this.RevokeEffect(effect, srcSkill, caster, targets);
}
}
return(true);
}
public bool EffectPlayers(ISkill srcSkill, ISkillPlayer caster, IList <ISkillPlayer> dstPlayers)
{
if (null == dstPlayers || dstPlayers.Count == 0)
{
return(false);
}
bool pureFlag = this.PureFlag;
bool rtnVal = false;
foreach (var target in dstPlayers)
{
rtnVal |= AddBuff(srcSkill, caster, target, pureFlag);
}
if (rtnVal)
{
this.AddSrcShowModel(srcSkill, caster, this.Last);
}
return(rtnVal);
}
protected virtual bool CheckCore(ISkillPlayer dstPlayer)
{
bool doingFlag = false;
switch (this.StateType)
{
case EnumDoneStateFlag.None:
doingFlag = true;
break;
case EnumDoneStateFlag.Over:
if (dstPlayer.DoneStateFlag == EnumDoneStateFlag.None)
{
return(false);
}
break;
case EnumDoneStateFlag.Fail:
case EnumDoneStateFlag.Succ:
if (dstPlayer.DoneStateFlag != this.StateType)
{
return(false);
}
break;
}
if (!CheckValue(doingFlag ? dstPlayer.DoingState : dstPlayer.DoneState))
{
return(false);
}
if (this.GroundType == EnumGroundType.All)
{
return(true);
}
bool homeFlag = dstPlayer.SkillManager.SkillSide == EnumMatchSide.Home;
if (this.GroundType == EnumGroundType.Opp)
{
homeFlag = !homeFlag;
}
Region area = homeFlag ? FootballPitchDefines.HOMERegion : FootballPitchDefines.AwayRegion;
return(area.IsCoordinateInRegion(((IPlayer)dstPlayer).Status.Current));
}
public override bool EffectSkills(ISkill srcSkill, ISkillPlayer caster, IList <ISkill> dstSkills)
{
if (null == dstSkills || dstSkills.Count == 0)
{
return(false);
}
int rate = this.Rate;
int maxRate = SkillDefines.MAXStorePercent;
if (rate <= 0 || rate < maxRate && srcSkill.Context.RandomPercent(maxRate) > rate)
{
return(false);
}
foreach (var skill in dstSkills)
{
skill.SkillState = EnumSkillState.Activate;
}
return(true);
}
public bool EffectPlayers(ISkill srcSkill, ISkillPlayer caster, IList <ISkillPlayer> dstPlayers)
{
if (null == dstPlayers || dstPlayers.Count == 0)
{
return(false);
}
short last = srcSkill.Context.GetBuffLast(srcSkill, caster, this.Last);
bool rtnVal = false;
foreach (var target in dstPlayers)
{
rtnVal |= AddBuff(srcSkill, target, last);
}
if (rtnVal)
{
this.AddSrcShowModel(srcSkill, caster, last);
}
return(rtnVal);
}
ISkillOwner GetTarget(ISkillPlayer ownPlayer, ISkillPlayer oppPlayer)
{
switch (Side)
{
case EnumEventTargetSide.OwnPlayer:
return(ownPlayer);
case EnumEventTargetSide.OppPlayer:
return(oppPlayer ?? ownPlayer.OppSkillPlayer);
case EnumEventTargetSide.OwnManager:
return(ownPlayer.SkillManager);
case EnumEventTargetSide.OppManager:
return(ownPlayer.SkillManager.OppSkillManager);
default:
return(ownPlayer);
}
}
protected override void GetBuffFact(ISkill srcSkill, ISkillPlayer caster, out double multiFact, out double addFact)
{
multiFact = 1;
addFact = 0;
var srcManager = null != caster ? caster.SkillManager : srcSkill.Owner as ISkillManager;
if (null == srcManager)
{
return;
}
switch (this.FactType)
{
case EnumBuffFact.ColourQty:
if (null == this.Values || Values.Length == 0)
{
return;
}
var players = Side == EnumOwnSide.Own ? srcManager.SkillPlayerList : srcManager.OppSkillManager.SkillPlayerList;
int qty = 0;
foreach (var player in players)
{
foreach (int val in Values)
{
if (player.SkillColour == val)
{
qty++;
}
}
}
multiFact = qty;
return;
case EnumBuffFact.IncDribbleMinutes:
multiFact = srcManager.GetStatInt((int)EnumManagerStat.IncDribbleMinutes);
return;
case EnumBuffFact.CombDribbleMinutes:
multiFact = srcManager.GetStatInt((int)EnumManagerStat.CombDribbleMinutes);
return;
}
}
public bool EffectManager(ISkill srcSkill, ISkillPlayer caster, IList <ISkillManager> dstManagers)
{
if (null == dstManagers || dstManagers.Count == 0)
{
return(false);
}
bool pureFlag = this.PureFlag;
bool rtnVal = false;
double multiFact, addFact;
GetBuffFact(srcSkill, caster, out multiFact, out addFact);
foreach (var target in dstManagers)
{
rtnVal |= AddBuff(srcSkill, caster, target, pureFlag, multiFact, addFact);
}
if (rtnVal)
{
this.AddSrcShowModel(srcSkill, caster, this.Last);
}
return(rtnVal);
}
public void AddShowClip(ISkill srcSkill, ISkillPlayer caster)
{
var clip = this.ClipSetting;
if (null == clip || clip.ClipId <= 0)
{
return;
}
ISkillOwner owner = caster ?? srcSkill.Owner;
if (null == owner.SkillCore)
{
return;
}
byte[] targets = null;
if (clip.ClipType > 0)
{
targets = GetClipTargets(caster);
}
owner.SkillCore.AddShowClip(srcSkill, clip, targets);
}
protected override IBuff InnerCreateBuff(ISkill srcSkill, ISkillPlayer target, short last, int rate)
{
if (last > 0)
{
last += srcSkill.Context.MatchRound;
}
IBuff buff = null;
if (this.BuffId[0] == (int)EnumBlurType.BanMan)
{
buff = new FootballDisableBuff(srcSkill, (EnumBlurBuffCode)this.BlurCode);
}
else
{
buff = new FootballBlurBuff(srcSkill, (EnumBlurType)this.BuffId[0], (EnumBlurBuffCode)this.BlurCode);
}
buff.Rate = rate;
buff.TimeEnd = last;
buff.Times = this.Repeat;
return(buff);
}
public bool Trigger(ISkill srcSkill, ISkillPlayer caster)
{
var srcManager = null == caster ? srcSkill.Owner as ISkillManager : caster.SkillManager;
var players = InnerSeekMulti(srcManager);
if (null != players)
{
foreach (var player in players)
{
if (CheckCore(player))
{
return(true);
}
}
if (this.SeekType == EnumMotionSeekType.BothTeam)
{
players = InnerSeekMulti(srcManager.OppSkillManager);
if (null == players)
{
return(false);
}
foreach (var player in players)
{
if (CheckCore(player))
{
return(true);
}
}
}
return(false);
}
var dstPlayer = InnerSeek(srcManager, caster);
if (null == dstPlayer)
{
return(false);
}
return(CheckCore(dstPlayer));
}
