/// <summary>
///
/// </summary>
/// <param name="fight"></param>
/// <param name="fighter"></param>
/// <param name="currentCell"></param>
/// <param name="encodedPath"></param>
/// <returns></returns>
public static MovementPath IsValidPath(AbstractFight fight, AbstractFighter fighter, int currentCell, string encodedPath)
{
if (encodedPath == "")
{
return(null);
}
var decodedPath = DecodePath(fight.Map, currentCell, encodedPath);
var finalPath = new MovementPath();
var index = 0;
int transitCell = 0;
do
{
transitCell = decodedPath.TransitCells[index];
var length = Pathfinding.IsValidLine(fight, fighter, finalPath, transitCell, decodedPath.GetDirection(transitCell), decodedPath.TransitCells[index + 1]);
if (length == -1)
{
return(null);
}
else if (length == -2)
{
break;
}
index++;
}while (transitCell != decodedPath.LastStep);
return(finalPath);
}
protected override IEnumerable <AbstractFighter> GetAdditionalDroppers(AbstractFight fight)
{
if (fight.Map.SubArea.TaxCollector != null)
{
yield return(fight.Map.SubArea.TaxCollector);
}
}
public override void Execute(AbstractFight fight)
{
foreach (var fighter in fight.Fighters.Where(fighter => CanRegenerate(fight, fighter)))
{
fighter.Life = fighter.MaxLife;
}
}
/// <summary>
///
/// </summary>
public override void Dispose()
{
m_fight = null;
m_spectators.Clear();
m_spectators = null;
base.Dispose();
}
/// <summary>
///
/// </summary>
/// <param name="fight"></param>
private void Add(AbstractFight fight)
{
fight.Start();
FightCount++;
m_fightList.Add(fight.Id, fight);
m_map.Dispatch(WorldMessage.FIGHT_COUNT(FightCount));
AddHandler(fight.Dispatch);
AddUpdatable(fight);
}
/// <summary>
///
/// </summary>
/// <param name="fight"></param>
public void Remove(AbstractFight fight)
{
FightCount--;
m_fightList.Remove(fight.Id);
m_map.Dispatch(WorldMessage.FIGHT_COUNT(FightCount));
RemoveHandler(fight.Dispatch);
RemoveUpdatable(fight);
fight.Dispose();
}
public EndingArguments(AbstractFight fight, List <AbstractFighter> droppers, List <T> losers, long droppersTotalPP, List <ItemDAO> itemLoot, long kamasLoot)
{
Fight = fight;
Droppers = droppers;
Losers = losers;
DroppersTotalPP = droppersTotalPP;
ItemLoot = itemLoot;
KamasLoot = kamasLoot;
}
// Returns the list of points from p0 to p1
private static bool BresenhamLine(AbstractFight fight, int beginCell, int endCell)
{
if (beginCell == endCell)
{
return(true);
}
var begin = GetPoint(fight.Map, beginCell);
var end = GetPoint(fight.Map, endCell);
return(BresenhamLine(fight, beginCell, endCell, (int)begin.X, (int)begin.Y, (int)end.X, (int)end.Y));
}
public override void Execute(AbstractFight fight)
{
var winnersTotalLevel = fight.WinnerFighters.Sum(fighter => fighter.Level);
var losersTotalLevel = fight.LoserFighters.Sum(fighter => fighter.Level);
foreach (var fighter in fight.WinnerFighters)
{
var honour = 0;
var dishonour = 0;
if (fighter.Type == EntityTypeEnum.TYPE_CHARACTER)
{
var player = (CharacterEntity)fighter;
if (player.AlignmentId != (int)AlignmentTypeEnum.ALIGNMENT_NEUTRAL)
{
if (!fight.IsNeutralAgression || player.Team.AlignmentId == (int)AlignmentTypeEnum.ALIGNMENT_NEUTRAL)
{
honour = Util.CalculWinHonor(player.Level, winnersTotalLevel, losersTotalLevel);
player.SubstractDishonour(1);
}
else
{
dishonour = 1;
}
player.AddHonour(honour);
}
}
fight.Result.AddResult(fighter, FightEndTypeEnum.END_WINNER, false, 0, 0, honour, dishonour);
}
foreach (var fighter in fight.LoserFighters)
{
var honour = 0;
var dishonour = 0;
if (fighter.Type == EntityTypeEnum.TYPE_CHARACTER)
{
var player = (CharacterEntity)fighter;
if (player.AlignmentId != (int)AlignmentTypeEnum.ALIGNMENT_NEUTRAL)
{
if (!fight.IsNeutralAgression || player.Team.AlignmentId != (int)AlignmentTypeEnum.ALIGNMENT_NEUTRAL)
{
honour = Util.CalculWinHonor(player.Level, winnersTotalLevel, losersTotalLevel);
}
player.SubstractHonour(honour);
}
else
{
dishonour = 1;
}
}
fight.Result.AddResult(fighter, FightEndTypeEnum.END_LOSER, false, 0, 0, -honour, dishonour);
}
}
protected override long GetAdditionalKamas(AbstractFight fight)
{
var monsterFight = fight as MonsterFight;
if (monsterFight != null)
{
if (fight.WinnerTeam == fight.Team0)
{
return(monsterFight.MonsterGroup.Kamas);
}
}
return(0);
}
protected override IEnumerable <ItemDAO> GetAdditionalLoot(AbstractFight fight)
{
var monsterFight = fight as MonsterFight;
if (monsterFight != null)
{
if (fight.WinnerTeam == fight.Team0)
{
return(monsterFight.MonsterGroup.Inventory.RemoveItems());
}
}
return(Enumerable.Empty <ItemDAO>());
}
///// <summary>
/////
///// </summary>
///// <param name="cellId"></param>
///// <returns></returns>
public static bool IsStopCell(AbstractFight fight, FightTeam team, int cellId)
{
if (fight.GetCell(cellId).HasObject(FightObstacleTypeEnum.TYPE_TRAP))
{
return(true);
}
if (GetEnnemiesNear(fight, team, cellId).Count() > 0)
{
return(true);
}
return(false);
}
/// <summary>
///
/// </summary>
/// <param name="fight"></param>
/// <param name="beginCell"></param>
/// <param name="endCell"></param>
/// <returns></returns>
public static bool CheckView(AbstractFight fight, int beginCell, int endCell)
{
return(BresenhamLine(fight, beginCell, endCell));
var begin = GetPoint(fight.Map, beginCell);
var end = GetPoint(fight.Map, endCell);
var deltax = Math.Abs(end.X - begin.X);
var deltay = Math.Abs(end.Y - begin.Y);
var error = deltax / 2;
var ystep = 1;
if (end.Y < begin.Y)
{
ystep = -1;
}
var nextPoint = begin;
while (nextPoint.X < end.X)
{
if (!nextPoint.Equals(begin) && !nextPoint.Equals(end))
{
var fightCell = fight.GetCell(GetCell(fight.Map, nextPoint.X, nextPoint.Y));
if (fightCell == null)
{
return(false);
}
else if (!fightCell.LineOfSight)
{
return(false);
}
else if (fightCell.HasObject(FightObstacleTypeEnum.TYPE_FIGHTER))
{
return(false);
}
}
nextPoint.X++;
error -= deltay;
if (error < 0)
{
nextPoint.Y += ystep;
error += deltax;
}
}
return(true);
}
/// <summary>
///
/// </summary>
/// <param name="type"></param>
/// <param name="activeType"></param>
/// <param name="fight"></param>
/// <param name="caster"></param>
/// <param name="castInfos"></param>
/// <param name="cell"></param>
/// <param name="duration"></param>
/// <param name="actionId"></param>
/// <param name="canGoThrough"></param>
/// <param name="canStack"></param>
/// <param name="hide"></param>
protected AbstractActivableObject(FightObstacleTypeEnum type, ActiveType activeType, AbstractFight fight, AbstractFighter caster, CastInfos castInfos, int cell, int duration, int actionId, bool canGoThrough, bool canStack, bool hide = false)
{
m_fight = fight;
m_caster = caster;
m_spellId = castInfos.SpellId;
m_actionSpell = SpellManager.Instance.GetTemplate(castInfos.Value1);
m_actionEffect = m_actionSpell.GetLevel(castInfos.Value2);
Cell = fight.GetCell(cell);
ObstacleType = type;
ActivationType = activeType;
CanGoThrough = canGoThrough;
CanStack = canStack;
Color = castInfos.Value3;
Targets = new List <AbstractFighter>();
Length = Pathfinding.GetDirection(castInfos.RangeType[1]);
AffectedCells = new List <FightCell>();
Duration = duration;
ActionId = actionId;
Hide = hide;
foreach (var effect in m_actionEffect.Effects)
{
if (CastInfos.IsDamageEffect(effect.TypeEnum))
{
Priority--;
}
}
// On ajout l'objet a toutes les cells qu'il affecte
foreach (var cellId in CellZone.GetCircleCells(fight.Map, cell, Length))
{
var fightCell = m_fight.GetCell(cellId);
if (fightCell != null)
{
fightCell.AddObject(this);
AffectedCells.Add(fightCell);
}
}
if (Hide)
{
Appear(caster.Team);
}
else
{
AppearForAll();
}
}
public override void Execute(AbstractFight fight)
{
var winnersTotalLevel = fight.WinnerFighters.Sum(fighter => fighter.Level);
var losersTotalLevel = fight.LoserFighters.Sum(fighter => fighter.Level);
foreach (var fighter in fight.WinnerFighters)
{
var honour = 0;
var dishonour = 0;
if (fighter.Type == EntityTypeEnum.TYPE_CHARACTER)
{
var player = (CharacterEntity)fighter;
if (player.AlignmentId != (int)AlignmentTypeEnum.ALIGNMENT_NEUTRAL)
{
if (!fight.IsNeutralAgression || player.Team.AlignmentId == (int)AlignmentTypeEnum.ALIGNMENT_NEUTRAL)
{
honour = Util.CalculWinHonor(player.Level, winnersTotalLevel, losersTotalLevel);
player.SubstractDishonour(1);
}
else
dishonour = 1;
player.AddHonour(honour);
}
}
fight.Result.AddResult(fighter, FightEndTypeEnum.END_WINNER, false, 0, 0, honour, dishonour);
}
foreach (var fighter in fight.LoserFighters)
{
var honour = 0;
var dishonour = 0;
if (fighter.Type == EntityTypeEnum.TYPE_CHARACTER)
{
var player = (CharacterEntity)fighter;
if (player.AlignmentId != (int)AlignmentTypeEnum.ALIGNMENT_NEUTRAL)
{
if (!fight.IsNeutralAgression || player.Team.AlignmentId != (int)AlignmentTypeEnum.ALIGNMENT_NEUTRAL)
honour = Util.CalculWinHonor(player.Level, winnersTotalLevel, losersTotalLevel);
player.SubstractHonour(honour);
}
else
dishonour = 1;
}
fight.Result.AddResult(fighter, FightEndTypeEnum.END_LOSER, false, 0, 0, -honour, dishonour);
}
}
///// <summary>
/////
///// </summary>
///// <param name="fight"></param>
///// <param name="team"></param>
///// <param name="cellId"></param>
///// <returns></returns>
public static List <AbstractFighter> GetFightersNear(AbstractFight fight, int cellId)
{
List <AbstractFighter> fighters = new List <AbstractFighter>();
foreach (var direction in Pathfinding.FIGHT_DIRECTIONS)
{
var fighter = fight.GetFighterOnCell(Pathfinding.NextCell(fight.Map, cellId, direction));
if (fighter != null)
{
if (!fighter.IsFighterDead)
{
fighters.Add(fighter);
}
}
}
return(fighters);
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <param name="leaderId"></param>
/// <param name="alignment"></param>
/// <param name="flagCell"></param>
/// <param name="fight"></param>
/// <param name="places"></param>
public FightTeam(int id, long leaderId, int alignment, int flagCell, AbstractFight fight, List <FightCell> places)
{
Id = id;
Fight = fight;
LeaderId = leaderId;
AlignmentId = alignment;
FlagCellId = flagCell;
m_challenges = new List <AbstractChallenge>();
m_fighters = new List <AbstractFighter>();
m_places = places;
m_blockedOption = new Dictionary <FightOptionTypeEnum, bool>()
{
{ FightOptionTypeEnum.TYPE_NEW_PLAYER_BIS, false },
{ FightOptionTypeEnum.TYPE_HELP, false },
{ FightOptionTypeEnum.TYPE_PARTY, false },
{ FightOptionTypeEnum.TYPE_SPECTATOR, false },
};
}
/// <summary>
///
/// </summary>
/// <param name="fight"></param>
/// <param name="fighter"></param>
/// <param name="path"></param>
/// <param name="beginCell"></param>
/// <param name="direction"></param>
/// <param name="endCell"></param>
/// <returns></returns>
public static int IsValidLine(AbstractFight fight, AbstractFighter fighter, MovementPath path, int beginCell, int direction, int endCell)
{
var length = -1;
var actualCell = beginCell;
if (!Pathfinding.InLine(fight.Map, beginCell, endCell))
{
return(length);
}
length = (int)GoalDistance(fight.Map, beginCell, endCell);
path.AddCell(actualCell, direction);
for (int i = 0; i < length; i++)
{
actualCell = Pathfinding.NextCell(fight.Map, actualCell, direction);
if (!fight.Map.IsWalkable(actualCell))
{
return(-2);
}
if (fight.GetFighterOnCell(actualCell) != null)
{
return(-2);
}
path.AddCell(actualCell, direction);
path.MovementLength++;
if (Pathfinding.IsStopCell(fighter.Fight, fighter.Team, actualCell))
{
return(-2);
}
}
return(length);
}
/// <summary>
///
/// </summary>
public virtual void JoinFight(AbstractFight fight, FightTeam team)
{
BuffManager = new BuffEffectManager(this);
StateManager = new FighterStateManager(this);
SpellManager = new SpellCastManager();
DeclaredDead = false;
Orientation = 1;
Skin = SkinBase;
SkinSize = SkinSizeBase;
UsedAP = 0;
UsedMP = 0;
Fight = fight;
Team = team;
TurnReady = false;
TurnPass = false;
Team.AddFighter(this);
Team.AddUpdatable(this);
Team.AddHandler(Dispatch);
if (Life < 1)
{
Life = 1;
}
if (Fight.State == FightStateEnum.STATE_PLACEMENT)
{
SetCell(Team.FreePlace);
}
SetChatChannel(ChatChannelEnum.CHANNEL_TEAM, () => Team.Dispatch);
StartAction(GameActionTypeEnum.FIGHT);
}
public override void Execute(AbstractFight fight)
{
foreach (var fighter in fight.Fighters.Where(fighter => CanRegenerate(fight, fighter)))
fighter.Life = fighter.MaxLife;
}
public override void Execute(AbstractFight fight)
{
long kamasLoot = GetAdditionalKamas(fight);
var itemLoot = new List <ItemDAO>(GetAdditionalLoot(fight));
var droppers = fight
.WinnerTeam
.Fighters
.Where(fighter => fighter.CanDrop)
.Concat(GetAdditionalDroppers(fight))
.ToList();
var losers = fight
.LoserTeam
.Fighters
.OfType <T>()
.Where(fighter => fighter.Invocator == null)
.ToList();
var droppersTotalPP = droppers.Sum(fighter => fighter.Prospection);
var arguments = new EndingArguments <T>(fight, droppers, losers, droppersTotalPP, itemLoot, kamasLoot);
foreach (var loser in losers)
{
kamasLoot += GetTargetKamas(arguments, loser);
itemLoot.AddRange(GetTargetItems(arguments, loser));
}
var distributedDrop = DropManager.Instance.Distribute(droppers, droppersTotalPP, itemLoot);
foreach (var fighter in droppers)
{
fighter.CachedBuffer = true;
var itemWon = distributedDrop[fighter];
var kamasWon = GetKamasWon(arguments, fighter);
var xpWon = GetExperienceWon(arguments, fighter);
switch (fighter.Type)
{
case EntityTypeEnum.TYPE_CHARACTER:
var character = (CharacterEntity)fighter;
foreach (var item in itemWon)
{
character.Inventory.AddItem(item);
}
character.Inventory.AddKamas(kamasWon);
character.AddExperience(xpWon);
break;
case EntityTypeEnum.TYPE_MONSTER_FIGHTER:
var monsterFight = fight as MonsterFight;
// case of monster winning
if (monsterFight != null && fight.WinnerTeam == fight.Team0)
{
foreach (var item in itemWon)
{
monsterFight.MonsterGroup.Inventory.AddItem(item);
}
monsterFight.MonsterGroup.Inventory.AddKamas(kamasWon);
}
else
{
foreach (var item in itemWon)
{
var invocator = fighter.Invocator;
while (fighter.Invocator != null)
{
invocator = fighter.Invocator;
}
invocator?.Inventory?.AddItem(item);
invocator?.Inventory?.AddKamas(kamasWon);
}
}
break;
case EntityTypeEnum.TYPE_TAX_COLLECTOR:
var taxCollector = (TaxCollectorEntity)fighter;
taxCollector.Storage.AddKamas(kamasWon);
taxCollector.ExperienceGathered += xpWon;
foreach (var item in itemLoot)
{
taxCollector.Storage.AddItem(item);
}
break;
}
fight.Result.AddResult(fighter,
FightEndTypeEnum.END_WINNER,
false,
kamasWon,
xpWon,
0,
0,
0,
0,
itemWon
.GroupBy(item => item.TemplateId)
.Select(g => new { TemplateId = g.Key, Count = g.Count() })
.ToDictionary(g => g.TemplateId, g => g.Count));
fighter.CachedBuffer = false;
}
}
protected abstract IEnumerable <AbstractFighter> GetAdditionalDroppers(AbstractFight fight);
protected abstract IEnumerable <ItemDAO> GetAdditionalLoot(AbstractFight fight);
protected abstract long GetAdditionalKamas(AbstractFight fight);
protected abstract bool CanRegenerate(AbstractFight fight, AbstractFighter fighter);
/// <summary>
///
/// </summary>
/// <param name="fight"></param>
/// <param name="team"></param>
public override void JoinFight(AbstractFight fight, FightTeam team)
{
Life = MaxLife;
base.JoinFight(fight, team);
}
public override void JoinFight(AbstractFight fight, FightTeam team)
{
Life = MaxLife;
base.JoinFight(fight, team);
}
///// <summary>
/////
///// </summary>
///// <param name="fight"></param>
///// <param name="team"></param>
///// <param name="cellId"></param>
///// <returns></returns>
public static IEnumerable <AbstractFighter> GetEnnemiesNear(AbstractFight fight, FightTeam team, int cellId)
{
return(GetFightersNear(fight, cellId).Where(fighter => fighter.Team != team));
}
private static bool BresenhamLine(AbstractFight fight, int beginCell, int endCell, int x0, int y0, int x1, int y1)
{
bool steep = Math.Abs(y1 - y0) > Math.Abs(x1 - x0);
if (steep)
{
Swap(ref x0, ref y0);
Swap(ref x1, ref y1);
}
if (x0 > x1)
{
Swap(ref x0, ref x1);
Swap(ref y0, ref y1);
}
int deltax = x1 - x0;
int deltay = Math.Abs(y1 - y0);
int error = 0;
int ystep;
int y = y0;
if (y0 < y1)
{
ystep = 1;
}
else
{
ystep = -1;
}
for (int x = x0; x <= x1; x++)
{
int cellId = -1;
if (steep)
{
cellId = GetCell(fight.Map, y, x);
}
else
{
cellId = GetCell(fight.Map, x, y);
}
if (cellId != beginCell && cellId != endCell)
{
var fightCell = fight.GetCell(cellId);
if (fightCell == null)
{
return(false);
}
if (!fightCell.LineOfSight)
{
return(false);
}
if (fightCell.HasObject(FightObstacleTypeEnum.TYPE_FIGHTER))
{
return(false);
}
}
error += deltay;
if (2 * error >= deltax)
{
y += ystep;
error -= deltax;
}
}
return(true);
}
protected override bool CanRegenerate(AbstractFight fight, AbstractFighter fighter)
{
return fight.LoserFighters.Contains(fighter);
}
protected override bool CanRegenerate(AbstractFight fight, AbstractFighter fighter)
{
return(fight.WinnerFighters.Contains(fighter));
}
/// <summary>
///
/// </summary>
/// <param name="fight"></param>
/// <param name="caster"></param>
/// <param name="effect"></param>
/// <param name="cell"></param>
/// <param name="duration"></param>
public FightGlyph(AbstractFight fight, AbstractFighter caster, CastInfos effect, int cell, int duration)
: base(FightObstacleTypeEnum.TYPE_GLYPH, ActiveType.ACTIVE_BEGINTURN, fight, caster, effect, cell, duration, 307, true, true)
{
}
protected abstract bool CanRegenerate(AbstractFight fight, AbstractFighter fighter);
public abstract void Execute(AbstractFight fight);
/// <summary>
///
/// </summary>
/// <param name="fight"></param>
/// <param name="caster"></param>
/// <param name="effect"></param>
/// <param name="cell"></param>
public FightTrap(AbstractFight fight, AbstractFighter caster, CastInfos effect, int cell)
: base(FightObstacleTypeEnum.TYPE_TRAP, ActiveType.ACTIVE_ENDMOVE, fight, caster, effect, cell, 0, 306, true, false, true)
{
}
