internal override void HandleEnvelope(object sender, EnvelopeEventArgs e)
{
ChatEnvelope chatEnvelope = e.Envelope;
ChatMessage chatMessage = chatEnvelope.Message;
var cmdInvoker = new CommandsInvoker();
var chatUserSession = base.chatRoom.UserSession;
cmdInvoker.AddCommand(new CmdChatRegister(chatUserSession, chatMessage));
cmdInvoker.AddCommand(new CmdReceiveChat(chatUserSession, chatMessage));
cmdInvoker.AddCommand(new CmdReceiveBroadcastNewUser(chatUserSession, chatMessage));
cmdInvoker.AddCommand(new CmdReceiveBroadcastEndSession(chatUserSession, chatMessage));
cmdInvoker.InvokeAll();
}
// Way IN: Receiving information
public void Client_ReceiveReady(object sender, NetMQSocketEventArgs e)
{
string msgJson = e.Socket.ReceiveFrameString();
if (!string.IsNullOrEmpty(msgJson))
{
ChatMessage chatMessage = msgJson.ToChatMessage();
var cmdInvoker = new CommandsInvoker();
var chatUserSession = this.ChatRoom.UserSession;
cmdInvoker.AddCommand(new CmdChatRegister(chatUserSession, chatMessage));
cmdInvoker.AddCommand(new CmdReceiveChat(chatUserSession, chatMessage));
cmdInvoker.AddCommand(new CmdReceiveBroadcastNewUser(chatUserSession, chatMessage));
cmdInvoker.AddCommand(new CmdReceiveBroadcastEndSession(chatUserSession, chatMessage));
cmdInvoker.InvokeAll();
}
}
private void HandleCloner(Army allies, int unitIndex)
{
var cloner = allies[unitIndex] as IClonerUnit;
if (Random.Next(100) > cloner.CloneChance)
{
return;
}
var target = Strategy.FindRandomUnitInRange(allies, unitIndex, cloner.CloneRange,
unit => unit.CurrentHealth > 0 && unit is IClonableUnit);
if (!target.HasValue)
{
return;
}
CommandsInvoker.Execute(new CloneCommand(allies, unitIndex, allies, target.Value,
Random.Next(allies.Count + 1)));
}
private void HandleBuffer(Army allies, int unitIndex)
{
var buffer = allies[unitIndex] as IBufferUnit;
if (Random.Next(100) > buffer.BuffChance)
{
return;
}
var buff = BuffTypes[Random.Next(BuffTypes.Length)];
var target = Strategy.FindRandomUnitInRange(allies, unitIndex, buffer.BuffRange,
unit => unit.CurrentHealth > 0 && unit is IBuffableUnit buffable && buffable.CanBeBuffed(buff));
if (!target.HasValue)
{
return;
}
CommandsInvoker.Execute(new BuffCommand(allies, unitIndex, allies, target.Value, buff));
}
public void Turn()
{
if (GameEnded)
{
return;
}
var magics = Strategy.GetMagicUnits(Army1, Army2);
foreach (var tuple in magics)
{
HandleCommands(tuple.allies, tuple.enemies, tuple.alliesIndex);
}
var melees = Strategy.GetMeleeAttacks(Army1, Army2);
foreach (var tuple in melees)
{
MakeDamage(tuple.allies, tuple.alliesIndex, tuple.enemies,
tuple.targetIndex, tuple.allies[tuple.alliesIndex].Attack);
}
var unitsBefore = Army1.Count + Army2.Count;
CommandsInvoker.Execute(Army1.CollectDead());
CommandsInvoker.Execute(Army2.CollectDead());
CommandsInvoker.EndTurn();
if (Army1.Count + Army2.Count == unitsBefore)
{
_turnsWithoutDeath++;
}
else
{
_turnsWithoutDeath = 0;
}
if (++_turns == DrawLimit || _turnsWithoutDeath == DrawLimitTurnsWithoutDeaths ||
Army1.Count == 0 || Army2.Count == 0)
{
GameEnded = true;
}
}
private static void MakeDamage(Army sourceArmy, int?sourceUnitIndex,
Army targetArmy, int targetUnitIndex, int damage)
{
if (damage <= 0 ||
(sourceUnitIndex.HasValue && sourceArmy[sourceUnitIndex.Value].CurrentHealth <= 0))
{
return;
}
var target = targetArmy[targetUnitIndex];
if (target.CurrentHealth <= 0)
{
return;
}
double CountDamage(int defense)
{
return(1.0 * damage * (100 - defense) / 100);
}
var resultDamage = (int)CountDamage(target.Defense);
var dmgCommand = new DamageCommand(sourceArmy, sourceUnitIndex, targetArmy, targetUnitIndex, resultDamage);
CommandsInvoker.Execute(dmgCommand);
if (target.CurrentHealth <= 0 || !(target is BuffedUnit buffUnit))
{
return;
}
var removeBuff = new RemoveBuffCommand(sourceArmy, sourceUnitIndex,
targetArmy, targetUnitIndex, Random.Next(buffUnit.BuffCount));
CommandsInvoker.Execute(removeBuff);
}
private void HandleHealer(Army allies, int unitIndex)
{
var healer = allies[unitIndex] as IHealerUnit;
if (Random.Next(100) > healer.HealChance)
{
return;
}
var target = Strategy.FindRandomUnitInRange(allies, unitIndex, healer.HealRange,
unit => unit.CurrentHealth > 0 && unit is IHealableUnit);
if (!target.HasValue)
{
return;
}
var targetUnit = allies[target.Value];
var endHealth = Math.Min(targetUnit.MaxHealth, targetUnit.CurrentHealth + healer.Heal);
int heal = endHealth - targetUnit.CurrentHealth;
if (heal > 0)
{
CommandsInvoker.Execute(new HealCommand(allies, unitIndex, allies, target.Value, heal));
}
}
private static void Main(string[] args)
{
CommandsInvoker.Logger = new ConsoleLogger();
var unitFabric = new RandomUnitFactory();
var gui = StackWarsGUIFactory.GetGUI();
var armyCost = 500;
var engine = GEngine.StartNewGame(unitFabric, armyCost);
while (true)
{
gui.UndoAvailable = CommandsInvoker.CanUndo;
gui.RedoAvailable = CommandsInvoker.CanRedo;
gui.GameEnded = engine.GameEnded;
var input = gui.GetUserInput();
switch (input)
{
case UserInput.CreateNewGame:
{
var strategy = engine.Strategy;
engine = GEngine.StartNewGame(unitFabric, armyCost);
engine.Strategy = strategy;
}
break;
case UserInput.MakeTurn:
engine.Turn();
break;
case UserInput.PlayToEnd:
while (!engine.GameEnded)
{
engine.Turn();
}
break;
case UserInput.ShowArmies:
Console.WriteLine(engine.Army1);
Console.WriteLine(engine.Army2);
break;
case UserInput.SelectStrategy1vs1:
engine.Strategy = FightStrategy1Vs1.Singleton;
gui.ShowMessage("Strategy changed to 1 vs 1");
break;
case UserInput.SelectStrategy3vs3:
engine.Strategy = FightStrategy3Vs3.Singleton;
gui.ShowMessage("Strategy changed to 3 vs 3");
break;
case UserInput.SelectStrategyAllvsAll:
engine.Strategy = FightStrategyAllVsAll.Singleton;
gui.ShowMessage("Strategy changed to all vs all");
break;
case UserInput.Undo:
CommandsInvoker.Undo();
engine.GameEnded = false;
gui.ShowMessage("Undo done");
break;
case UserInput.Redo:
CommandsInvoker.Redo();
gui.ShowMessage("Redo done");
break;
case UserInput.Exit:
return;
}
if (!engine.GameEnded)
{
continue;
}
if (engine.Army1.Count == 0)
{
gui.ShowMessage(engine.Army2.Name + " wins");
}
else if (engine.Army2.Count == 0)
{
gui.ShowMessage(engine.Army1.Name + " wins");
}
else
{
gui.ShowMessage("Draw");
}
}
}
public void Setup()
{
calkPage = new CalkulyatorPage(new ChromeDriver());
calkPage.Init();
invoker = new CommandsInvoker(calkPage);
}
