protected virtual void OnPixelCoordinatesChanged(CoordinatesEventArgs e)
{
EventHandler <CoordinatesEventArgs> handler = PixelCoordinatesChanged;
if (handler != null)
{
handler(this, e);
}
}
private void NewChar_PixelDown(object sender, CoordinatesEventArgs e)
{
if (currentChartTool != CharTool.None)
{
var newPoint = GetCoordinates(Array.IndexOf(chars, (CharEditor)sender));
newPoint.X = newPoint.X + e.Coordinates.X;
newPoint.Y = newPoint.Y + e.Coordinates.Y;
if (currentPoint == null)
{
currentPoint = newPoint;
set = e.Set;
}
else if (set != e.Set)
{
currentPoint = null;
}
else
{
List <Point> points = new List <Point>();
if (currentChartTool == CharTool.Line || currentChartTool == CharTool.Multiline)
{
points = ComputeLine(currentPoint.Value.X, currentPoint.Value.Y, newPoint.X, newPoint.Y);
}
else if (currentChartTool == CharTool.Circle)
{
points = ComputeCircle(currentPoint.Value.X, currentPoint.Value.Y, newPoint.X, newPoint.Y);
}
if (currentChartTool == CharTool.Circle)
{
int idx = GetIndexPixel(currentPoint.Value.X, currentPoint.Value.Y);
var edit = chars[idx];
edit.ClearPixel(currentPoint.Value.X % 8, currentPoint.Value.Y % 8);
idx = GetIndexPixel(newPoint.X, newPoint.Y);
edit = chars[idx];
edit.ClearPixel(newPoint.X % 8, newPoint.Y % 8);
}
foreach (var point in points)
{
if (point.X >= CharWidth * 8 || point.Y >= CharHeight * 8 || point.X < 0 || point.Y < 0)
{
continue;
}
int idx = GetIndexPixel(point.X, point.Y);
var edit = chars[idx];
if (set)
{
edit.SetPixel(point.X % 8, point.Y % 8);
}
else
{
edit.ClearPixel(point.X % 8, point.Y % 8);
}
}
if (currentChartTool == CharTool.Line || currentChartTool == CharTool.Circle)
{
currentPoint = null;
}
else
{
currentPoint = newPoint;
}
}
}
}
private void OpenDoor(object sender, CoordinatesEventArgs eventArgs)
{
Contract.Requires(CurrentState == State.WaitForPerformAction);
Contract.Requires(Player.Instance.HeroParty.Heroes[eventArgs.SenderId].MovementLeft >= 2);
Contract.Ensures(CurrentState == State.WaitForPerformAction);
Hero hero = Player.Instance.HeroParty.Heroes[eventArgs.SenderId];
FullModel.Board.OpenDoor(new Point(eventArgs.X, eventArgs.Y));
hero.RemoveMovement(2);
stateMachine.PlaceStates(State.OpenDoor);
stateMachine.ChangeToNextState();
ActionDone();
}
private void AttackSquare(object sender, CoordinatesEventArgs eventArgs)
{
Contract.Requires(eventArgs.SenderId == gameState.CurrentPlayer);
Contract.Requires(CurrentState == State.WaitForPerformAction);
Contract.Ensures(CurrentState == State.WaitForRollDice);
Figure attacker;
if (IsAHeroTurn())
{
attacker = Player.Instance.HeroParty.Heroes[gameState.CurrentPlayer];
}
else
{
attacker = currentMonster;
}
gameState.CurrentAttack = attacker.GetAttack(new Point(eventArgs.X, eventArgs.Y));
attacker.RemoveAttack();
stateMachine.PlaceStates(State.Attack, State.WaitForRollDice, State.WaitForDiceChoice, State.InflictWounds, State.WaitForPerformAction);
stateMachine.ChangeToNextState();
stateMachine.ChangeToNextState();
}
private void MoveTo(object sender, CoordinatesEventArgs eventArgs)
{
Contract.Requires(CurrentState == State.WaitForPerformAction);
Contract.Requires(IsAHeroTurn() ? Player.Instance.HeroParty.Heroes[eventArgs.SenderId].MovementLeft >= 1 :
currentMonster.MovementLeft >= 1);
Contract.Ensures(CurrentState == State.WaitForPerformAction);
Figure figure;
if (Player.Instance.HeroParty.Heroes.ContainsKey(eventArgs.SenderId))
{
figure = Player.Instance.HeroParty.Heroes[eventArgs.SenderId];
}
else
{
figure = currentMonster;
}
FullModel.Board.MoveFigure(figure, new Point(eventArgs.X, eventArgs.Y));
figure.RemoveMovement(1);
// The current monster should be marked both for overlord and player.
MarkMonsters();
stateMachine.PlaceStates(State.MoveAdjecent);
stateMachine.ChangeToNextState();
ActionDone();
}
private void WasKilled(object sender, CoordinatesEventArgs eventArgs)
{
Contract.Requires(CurrentState == State.InflictWounds);
Contract.Requires(FullModel.Board[eventArgs.X, eventArgs.Y].Figure != null);
Contract.Ensures(CurrentState == Contract.OldValue(CurrentState) || CurrentState == State.EndGameHeroParty || CurrentState == State.EndGameOverlord);
Figure figure = FullModel.Board[eventArgs.X, eventArgs.Y].Figure;
FullModel.Board.RemoveFigure(new Point(eventArgs.X, eventArgs.Y));
if (figure is Hero)
{
var hero = (Hero)figure;
hero.Initialize();
hero.Coins = (int)Math.Floor((double)hero.Coins / 2 / 25) * 25; // Floor to nearest % 25;
Player.Instance.HeroParty.RemoveConquestTokens(hero.Cost);
if (Player.Instance.HeroParty.IsConquestPoolEmpty)
{
GameWon(false);
return;
}
}
else
{
gameState.LegendaryMonsters.Remove((Monster)figure);
if (gameState.LegendaryMonsters.Count == 0)
{
GameWon(true);
return;
}
}
if (HasTurn())
{
DamageDone(new Point(eventArgs.X, eventArgs.Y));
}
}
private void StartMonsterTurn(object sender, CoordinatesEventArgs eventArgs)
{
Contract.Requires(CurrentState == State.WaitForOverlordChooseAction);
Contract.Ensures(CurrentState == State.WaitForPerformAction);
// Record monsterId
currentMonster = (Monster)FullModel.Board[eventArgs.X, eventArgs.Y].Figure;
stateMachine.PlaceStates(State.MonsterTurn);
stateMachine.ChangeToNextState();
MonsterTurnInitiation();
}
private void SquareMarked(object sender, CoordinatesEventArgs eventArgs)
{
if (!HasTurn() && CurrentState != State.WaitForChooseSquare)
{
return;
}
switch (CurrentState)
{
case State.WaitForChooseSquare:
if (playersRemainingTurn.Contains(Player.Instance.Id))
{
eventManager.QueueEvent(EventType.RequestPlacement, new CoordinatesEventArgs(eventArgs.X, eventArgs.Y));
}
break;
case State.WaitForPerformAction:
Figure figure;
if (Player.Instance.IsOverlord)
{
figure = currentMonster;
}
else
{
figure = Player.Instance.Hero;
}
Point standingPoint = FullModel.Board.FiguresOnBoard[figure];
if (FullModel.Board.IsSquareWithinBoard(new Point(eventArgs.X, eventArgs.Y)) && FullModel.Board.Distance(standingPoint, new Point(eventArgs.X, eventArgs.Y)) == 1)
{
// Move to adjecent
// If a an entire figure can move to the square
if (FullModel.Board.CanFigureMoveToPoint(figure, new Point(eventArgs.X, eventArgs.Y)) && figure.MovementLeft >= 1)
{
eventManager.QueueEvent(EventType.MoveTo, new CoordinatesEventArgs(eventArgs.X, eventArgs.Y));
}
// Open door
else if (figure is Hero && FullModel.Board.CanOpenDoor(new Point(eventArgs.X, eventArgs.Y)) &&
FullModel.Board.CanOpenDoor(standingPoint) && figure.MovementLeft >= 2)
{
eventManager.QueueEvent(EventType.OpenDoor, new CoordinatesEventArgs(eventArgs.X, eventArgs.Y));
}
}
else if (FullModel.Board.Distance(standingPoint, new Point(eventArgs.X, eventArgs.Y)) == 0 && figure is Hero && FullModel.Board[eventArgs.X, eventArgs.Y].Marker != null)
{
Marker marker = FullModel.Board[eventArgs.X, eventArgs.Y].Marker;
if (figure.MovementLeft >= marker.MovementPoints)
{
if (marker is PotionMarker)
{
if (!Player.Instance.Hero.Inventory.CanEquipPotion) return;
}
eventManager.QueueEvent(EventType.PickupMarker, new CoordinatesEventArgs(eventArgs.X, eventArgs.Y));
}
}
if (figure.AttacksLeft > 0 && FullModel.Board.IsSquareWithinBoard(new Point(eventArgs.X, eventArgs.Y)) &&
FullModel.Board.Distance(standingPoint, new Point(eventArgs.X, eventArgs.Y)) >= 1 &&
(FullModel.Board[eventArgs.X, eventArgs.Y] != null &&
(FullModel.Board[eventArgs.X, eventArgs.Y].Figure != null &&
FullModel.Board.IsThereLineOfSight(figure, FullModel.Board[eventArgs.X, eventArgs.Y].Figure, false))))
{
// A figure is trying to attack another figure.
if (Player.Instance.HeroParty.Heroes.ContainsKey(eventArgs.SenderId))
{
// A player is attacking
Hero hero = Player.Instance.HeroParty.Heroes[eventArgs.SenderId];
Figure target = FullModel.Board[eventArgs.X, eventArgs.Y].Figure;
if (target is Hero)
{
return; // Do not allow attack if target is hero.
}
if (hero.Inventory.Weapon == null)
{
return; // Do not allow attack if hero does not have weapon
}
if (hero.AttackType == EAttackType.MELEE)
{
// If the player has a melee weapon, he should be adjacent to the figure he is attacking.
if (FullModel.Board.Distance(FullModel.Board.FiguresOnBoard[hero], new Point(eventArgs.X, eventArgs.Y)) == 1)
{
// Hero is adjacent to target figure, carry on with attack.
eventManager.QueueEvent(EventType.AttackSquare, new CoordinatesEventArgs(eventArgs.X, eventArgs.Y));
}
}
else if (hero.AttackType == EAttackType.MAGIC || hero.AttackType == EAttackType.RANGED)
{
// If attack type is magic or ranged, always allow attack.
eventManager.QueueEvent(EventType.AttackSquare, new CoordinatesEventArgs(eventArgs.X, eventArgs.Y));
}
}
else
{
if (FullModel.Board[eventArgs.X, eventArgs.Y].Figure is Monster)
{
return; // A monster is trying to attack another monster. No go!
}
if (figure.AttackType == EAttackType.MELEE)
{
// If the monster has a melee weapon, he should be adjacent to the gero he is attacking.
if (FullModel.Board.Distance(FullModel.Board.FiguresOnBoard[figure], new Point(eventArgs.X, eventArgs.Y)) == 1)
{
// Monster is adjacent to target figure, carry on with attack.
eventManager.QueueEvent(EventType.AttackSquare, new CoordinatesEventArgs(eventArgs.X, eventArgs.Y));
}
}
else if (figure.AttackType == EAttackType.MAGIC || figure.AttackType == EAttackType.RANGED)
{
// If attack type is magic or ranged, always allow attack.
eventManager.QueueEvent(EventType.AttackSquare, new CoordinatesEventArgs(eventArgs.X, eventArgs.Y));
}
}
}
break;
case State.WaitForOverlordChooseAction:
if (FullModel.Board.IsSquareWithinBoard(eventArgs.X, eventArgs.Y))
{
Square s = FullModel.Board[eventArgs.X, eventArgs.Y];
// If a square with a monster is pressed in an overlord turn and we are the overlord, a monster turn should begin.
if (Player.Instance.IsOverlord && s.Figure != null && s.Figure is Monster && FullModel.Board.SquareVisibleByPlayers(eventArgs.X, eventArgs.Y) && monstersRemaining.Contains(s.Figure))
{
eventManager.QueueEvent(EventType.StartMonsterTurn, new CoordinatesEventArgs(eventArgs.X, eventArgs.Y));
}
}
break;
}
}
private void RequestPlacement(object sender, CoordinatesEventArgs eventArgs)
{
Contract.Requires(CurrentState == State.WaitForChooseSquare);
Contract.Ensures(CurrentState == State.WaitForChooseSquare);
if (Player.Instance.IsServer && FullModel.Board.IsValidStartSquare(new Point(eventArgs.X, eventArgs.Y)))
{
eventManager.QueueEvent(EventType.PlaceHero, new PlaceHeroEventArgs(eventArgs.SenderId, eventArgs.X, eventArgs.Y));
}
}
private void PickupMarker(object sender, CoordinatesEventArgs eventArgs)
{
Contract.Requires(CurrentState == State.WaitForPerformAction);
Contract.Ensures(CurrentState == State.WaitForPerformAction);
FullModel.Board[eventArgs.X, eventArgs.Y].Marker.PickUp(Player.Instance.HeroParty.Heroes[eventArgs.SenderId]);
if (!(FullModel.Board[eventArgs.X, eventArgs.Y].Marker is GlyphMarker))
{
FullModel.Board[eventArgs.X, eventArgs.Y].Marker = null;
}
}
