public bool Move(IBsActor actor, int slotId)
{
_slots[_actors[actor]] = null;
_actors[actor] = slotId;
_slots[slotId] = actor;
return(true);
}
public int Distance(IBsActor actor1, IBsActor actor2)
{
var slot1 = FindSlot(actor1);
var slot2 = FindSlot(actor2);
return(Math.Abs(slot1 - slot2));
}
public int Distance(IBsActor actor1, IBsActor actor2)
{
var slot1 = GetSlot(_actors[actor1]);
var slot2 = GetSlot(_actors[actor2]);
return(Math.Abs(slot1.X - slot2.X) + Math.Abs(slot1.Y - slot2.Y));
}
public void Heal(IBsActor source, IBsActor target, BsActionResult res)
{
if (!_factions.AreAllies(source, target))
{
res.Reason = "Cann't heal enemies";
return;
}
_healer.Heal(source, target, res);
}
private void OnActorAttack(IBsActor actor)
{
var res = _model.GetResult();
_model.Attack(_selection.SelectedActor(), actor, res);
UpdateLog(res);
UpdateActor(actor);
_model.ReleaseResult(res);
}
public void CheckAttackDst(IBsActor source, IBsActor target, BsActionResult res)
{
if (_board.Distance(source, target) > ResolveMaxDistance(source))
{
res.Reason = "Target out of range";
return;
}
res.Ok = true;
}
// Can be optimized
private int FindSlot(IBsActor actor)
{
for (int i = 0; i < _slots.Length; i++)
{
if (_slots[i] == actor)
{
return(i);
}
}
throw new Exception("Can not find a slot for Actor " + actor.Id());
}
public void Leave(IBsActor actor, BsFaction faction, BsActionResult res)
{
if (!Contains(actor, faction))
{
res.Reason = "Join a faction first";
return;
}
Remove(actor, faction);
res.Reason = "Left some fraction";
res.Ok = true;
}
public void Join(IBsActor actor, BsFaction faction, BsActionResult res)
{
if (Contains(actor, faction))
{
res.Reason = "Cann't join the same fraction twice";
return;
}
Add(actor, faction);
res.Reason = "Joined new fraction";
res.Ok = true;
}
public void SetDetails(IBsActor actor, int health, bool isDead, int level, ActorAttackType type,
BsFaction factions)
{
DetailsView.Id.text = "Player: " + actor.Id().ToString();
DetailsView.Attack.text = "Attack: " + actor.Config().BaseDamage().ToString();
DetailsView.Heal.text = "Heal: " + actor.Config().BaseHealing().ToString();
DetailsView.Helth.text = "Helth: " + health.ToString();
DetailsView.Level.text = "Level: " + level.ToString();
DetailsView.Dead.text = "Is Dead: " + isDead.ToString();
DetailsView.AttackType.text = "Type: " + type.ToString();
DetailsView.Factions.text = "Factions: " + factions.ToString();
}
private int ResolveMaxDistance(IBsActor actor)
{
switch (actor.Config().AttackType())
{
case ActorAttackType.Melee:
return(_config.MaxMeleeDistance());
case ActorAttackType.Range:
return(_config.MaxRangeDistance());
default:
throw new Exception("AttackType is not supported " + actor.Config().AttackType());
}
}
public IEnumerable <int> FreeSlotsInRange(IBsActor actor, int dst)
{
var slotId = FindSlot(actor);
for (var j = Math.Max(slotId - dst, 0); j < Math.Min(slotId + dst + 1, _slots.Length); j++)
{
if (_slots[j] != null)
{
continue;
}
yield return(j);
}
}
public void Attack(IBsActor source, IBsActor target, BsActionResult res)
{
if (_factions.AreAllies(source, target))
{
res.Reason = "Cann't attack aliies";
return;
}
_range.CheckAttackDst(source, target, res);
if (!res.Ok)
{
return;
}
_attacker.Attack(source, target, res);
}
public bool Add(IBsActor actor, int slotId)
{
if (_slots[slotId] != null)
{
return(false);
}
if (_actors.ContainsKey(actor))
{
return(false);
}
_slots[slotId] = actor;
_actors[actor] = slotId;
return(true);
}
public void Attack(IBsActor source, IBsActor target, BsActionResult res)
{
// Dead characters cannot be attacked
if (IsDead(target))
{
res.Reason = "Can't attack a dead character";
return;
}
var current = Value(target);
var diff = Diff(current, target.Config().MaxHealth(), -_stats.ResolveAttack(source, target));
SetValue(target, current + diff);
res.Ok = true;
res.Reason = "Successful Attack";
res.Value = diff;
}
public bool Add(IBsActor actor, int slotId)
{
if (FreeSlotsCount() == 0)
{
return(false);
}
if (slotId < 0 || slotId >= _slots.Length)
{
return(false);
}
if (_slots[slotId] != null)
{
return(false);
}
_slots[slotId] = actor;
_actorsCount++;
return(true);
}
public IEnumerable <int> FreeSlotsInRange(IBsActor actor, int dst)
{
var i = _actors[actor];
var minH = Math.Max(i / _width - dst, 0);
var maxH = Math.Min(i / _width + dst, _height - 1);
var minW = Math.Max(i % _width - dst, 0);
var diffW = Math.Min(i % _width + dst, _width - 1) - minW;
for (int y = minH; y <= maxH; y++)
{
var index = y * _width + minW;
var max = index + diffW;
while (index <= max)
{
if (_slots[index] == null)
{
yield return(index);
}
index++;
}
}
}
private void OnActorSelect(IBsActor actor)
{
_selection.Select(actor);
_view.SetClickableSlots(_model.Board().FreeSlotsInRange(actor, actor.Config().MoveDst()).ToArray());
UpdateActor(actor);
}
private void UpdateActor(IBsActor actor)
{
_hudView.SetDetails(actor, _model.Health().Health(actor), _model.Health().IsDead(actor),
_model.Levels().Level(actor), actor.Config().AttackType(), _model.Factions().Factions(actor));
}
private void OnAddHandler(IBsActor actor)
{
Add(actor);
OnAdd.Dispatch(Data[Data.Count - 1]);
}
private void Add(IBsActor actor)
{
Data.Add(_factory(actor));
}
public T Value(IBsActor actor)
{
return(Data[actor.Id()]);
}
public void SetValue(IBsActor actor, T value)
{
Data[actor.Id()] = value;
}
public int Health(IBsActor actor)
{
return(Value(actor));
}
private static int Build(IBsActor actor)
{
return(actor.Config().MaxHealth());
}
public void Join(IBsActor actor, BsFaction faction, BsActionResult res)
{
_factioner.Join(actor, faction, res);
}
public bool IsDead(IBsActor actor)
{
return(Value(actor) == 0);
}
public void Leave(IBsActor actor, BsFaction faction, BsActionResult res)
{
_factioner.Leave(actor, faction, res);
}
public void Select(IBsActor actor)
{
_selectedActor = actor;
}
public bool Move(IBsActor actor, int slotId)
{
return(_mover.Move(actor, slotId));
}
