static void Main(string[] args)
{
var numberOfTimesToPlay = ConsoleUtils.PromptForValue<int>("How many games do you want to play?");
WarGame game = new WarGame(
new WarPlayer() { Name = "Player 1" },
new WarPlayer() { Name = "Player 2" });
Debug.Listeners.Add(new ConsoleTraceListener());
try
{
for (int i = 1; i <= numberOfTimesToPlay; i++)
{
do
{
game.AdvancePlay();
Debug.WriteLine(string.Empty);
if (game.GameState == WarGameState.GameOver)
{
Debug.WriteLine("Winner: " + game.Winner.Name);
}
} while (game.GameState != WarGameState.GameOver);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
Debug.WriteLine("Done");
Console.ReadLine();
}
}
static void Main(string[] args)
{
//CardDeck cardDeck = new CardDeck();
//Console.WriteLine("Reading from textfile...");
//Thread.Sleep(2000);
//var deck = cardDeck.cardList;
//foreach (var card in deck)
//{
// Console.WriteLine(card);
//}
//Thread.Sleep(2000);
//Console.WriteLine("--------------------");
//Console.Clear(); Console.WriteLine("Shuffling deck..."); Console.WriteLine();
//Thread.Sleep(2000);
//cardDeck.Shuffel(new Random(), cardDeck.cardList);
//foreach (var item in cardDeck.shuffledCardList)
//{
// Console.WriteLine(item);
//}
Player A = new Player("Jonas");
Player B = new Player("Valde");
WarGame fiveHundred = new WarGame(A, B);
fiveHundred.play();
Console.ReadLine();
}
static object LoadShape(MiniYaml yaml)
{
IHitShape ret;
var shapeNode = yaml.Nodes.Find(n => n.Key == "Shape");
var shape = shapeNode != null ? shapeNode.Value.Value : string.Empty;
if (!string.IsNullOrEmpty(shape))
{
ret = WarGame.CreateObject <IHitShape>(shape + "Shape");
try
{
FieldLoader.Load(ret, shapeNode.Value);
}
catch (YamlException e)
{
throw new YamlException("HitShape {0}:{1}".F(shape, e.Message));
}
}
else
{
ret = new CircleShape();
}
ret.Initialize();
return(ret);
}
public void CheckModVersion()
{
Action <DownloadDataCompletedEventArgs> onComplete = i =>
{
if (i.Error != null)
{
return;
}
try
{
var data = Encoding.UTF8.GetString(i.Result);
var status = ModVersionStatus.Latest;
switch (data)
{
case "outdated": status = ModVersionStatus.Outdated; break;
case "unknown": status = ModVersionStatus.Unknown; break;
case "playtest": status = ModVersionStatus.PlaytestAvailable; break;
}
WarGame.RunAfterTick(() => ModVersionStatus = status);
}
catch { }
};
var queryURL = VersionCheck + "?protocol={0}&engine={1}&mod={2}&version={3}".F(
VersionCheckProtocol,
Uri.EscapeUriString(WarGame.EngineVersion),
Uri.EscapeUriString(WarGame.ModData.Manifest.Id),
Uri.EscapeUriString(WarGame.ModData.Manifest.Metadata.Version));
new Download(queryURL, _ => { }, onComplete);
}
public LoadIngamePlayerOrObserverUILogic(Widget widget, World world)
{
var ingameRoot = widget.Get("INGAME_ROOT");
var worldRoot = widget.Get("WORLD_ROOT");
var playerRoot = worldRoot.Get("PLAYER_ROOT");
//if(world.LocalPlayer != null){
// WarGame.LoadWidget(world, "OBSERVER_WIDGETS", playerRoot, new WidgetArgs());
//}
//else{
var playerWidgets = WarGame.LoadWidget(world, "PLAYER_WIDGETS", playerRoot, new WidgetArgs());
var sidebarTicker = playerWidgets.Get <LogicTickerWidget>("SIDEBAR_TICKER");
//}
world.GameOver += () =>
{
UI.CloseWindow();
if (world.LocalPlayer != null)
{
var scriptContext = world.WorldActor.TraitOrDefault <LuaScript>();
//var missionData = world.WorldActor.Info.TraitInfoOrDefault<>()
}
};
}
void StartSkirmishGame()
{
var map = WarGame.ModData.MapCache.ChooseInitialMap(WarGame.Settings.Server.Map, WarGame.CosmeticRandom);
WarGame.Settings.Server.Map = map;
ConnectionLogic.Connect(IPAddress.Loopback.ToString(),
WarGame.CreateLocalServer(map), "", OpenSkirmishLobbyPanel, () => { WarGame.CloseServer(); SwitchMenu(MenuType.Main); });
}
void OpenSkirmishLobbyPanel()
{
SwitchMenu(MenuType.None);
WarGame.OpenWindow("SERVER_LOBBY", new WidgetArgs
{
{ "onExit", () => { WarGame.Disconnect(); SwitchMenu(MenuType.Singleplayer); } },
{ "onStart", RemoveShellmapUI },
{ "skirmishMode", true }
});
}
void UpdateCurrentMap()
{
var uid = orderManager.LobbyInfo.GlobalSettings.Map;
if (map.Uid == uid)
{
return;
}
map = modData.MapCache[uid];
if (map.Status == MapStatus.Available)
{
// Maps need to be validated and pre-loaded before they can be accessed
var currentMap = map;
new Task(() =>
{
// Force map rules to be loaded on this background thread
currentMap.PreloadRules();
WarGame.RunAfterTick(() =>
{
// Map may have changed in the meantime
if (currentMap != map)
{
return;
}
// Tell the server that we have the map
if (!currentMap.InvalidCustomRules)
{
orderManager.IssueOrder(Order.Command("state {0}".F(Session.ClientState.NotReady)));
}
if (addBotOnMapLoad)
{
var slot = orderManager.LobbyInfo.FirstEmptySlot();
var bot = currentMap.Rules.Actors["player"].TraitInfos <IBotInfo>().Select(t => t.Type).FirstOrDefault();
var botController = orderManager.LobbyInfo.Clients.FirstOrDefault(c => c.IsAdmin);
if (slot != null && bot != null)
{
orderManager.IssueOrder(Order.Command("slot_bot {0} {1} {2}".F(slot, botController.Index, bot)));
}
addBotOnMapLoad = false;
}
});
}).Start();
}
}
public void PlayerBattle_FailesWithoutCards()
{
WarPlayer[] players = new WarPlayer[] {
new WarPlayer()
{
Name = "Player 1"
}
};
var target = new WarGame(players);
target.PlayerBattle(players[0]);
Assert.Fail();
}
void IWorldLoaded.WorldLoaded(World w, WorldRenderer render)
{
if (info.ClearRoot)
{
UI.ResetAll();
}
//WarGame.LoadWidget(w,info.IngameRoot,UI.Root,new WidgetArgs());
var widget = w.Type == WorldT.Shellmap ? info.ShellmapRoot : w.Type == WorldT.Editor ? info.EditorRoot : info.IngameRoot;
WarGame.LoadWidget(w, widget, UI.Root, new WidgetArgs());
}
public static void Connect(string host, int port, string password, Action onConnect, Action onAbort)
{
WarGame.JoinServer(host, port, password);
Action <string> onRetry = newPassword => Connect(host, port, newPassword, onConnect, onAbort);
UI.OpenWindow("CONNECTING_PANEL", new WidgetArgs()
{
{ "host", host },
{ "port", port },
{ "onConnect", onConnect },
{ "onAbort", onAbort },
{ "onRetry", onRetry },
});
}
public void SelectGame()
{
string[] options = { "Blackjack", "Durak", "Rummy", "War" };
bool loop = true;
Console.WriteLine(" ");
Console.WriteLine("\t\t\t\t\tWelcome to Card Game Simulator");
Console.WriteLine("\t\t\t\t\t------------------------------");
Console.WriteLine(" ");
do
{
Console.WriteLine("What game would you like to play?");
Console.WriteLine("---------------------------------");
int menuSelection = CIO.PromptForMenuSelection(options, true);
switch (menuSelection)
{
case 1:
Blackjack.BlackjackLogic run = new Blackjack.BlackjackLogic();
run.RunGame();
break;
case 2:
Durak.GameRunner play = new Durak.GameRunner();
play.Run();
break;
case 3:
//run rummy
Rummy.RummyDriver rumDriver = new Rummy.RummyDriver();
rumDriver.Drive();
break;
case 4:
//run war
WarGame war = new WarGame();
war.Run();
break;
case 0:
Console.WriteLine("Thanks for playing!");
loop = false;
break;
}
} while (loop);
}
public AlienBuilding(WarGame game, Vector3 _position, MainScene _scene)
: base(game, _scene, _position)
{
gameObjectModel = game.alienBaseModel;
scale = new Vector3(0.5f, 0.5f, 0.5f);
maxForce = 0;
maxSpeed = 0;
mass = 1000;
currentSB = SBNames.None;
currentWorld = Matrix.CreateScale(scale) * Matrix.CreateWorld(Position, lastNonZeroVelocity, Vector3.Up);
boundingBox = new Bbox(this, game, scene);
scene.SceneComponents.Add(boundingBox);
boundingBox.RecalculateBoundingBox();
}
void ConnectionStateChanged(OrderManager om)
{
if (om.Connection.ConnectionState == ConnectionState.NotConnected)
{
UI.CloseWindow();
Action onConnect = () =>
{
WarGame.OpenWindow("SERVER_LOBBY", new WidgetArgs()
{
{ "onExit", onExit },
{ "onStart", onStart },
{ "skirmishMode", false }
});
};
}
}
public IDisposable Reserve(Actor self, Actor forActor, Aircraft forAircraft)
{
if (reservedForAircraft != null && reservedForAircraft.MayYieldReservation)
{
reservedForAircraft.UnReserve();
}
reservedFor = forActor;
reservedForAircraft = forAircraft;
return(new DisposableAction(() => { reservedFor = null; reservedForAircraft = null; }, () => WarGame.RunAfterTick(() =>
{
if (WarGame.IsCurrentWorld(self.World))
{
throw new InvalidOperationException("Attempted to finalize an undisposed DisposableAction.{0} ({1}) reserved {2} ({3}) "
.F(forActor.Info.Name, forActor.ActorID, self.Info.Name, self.ActorID));
}
})));
}
public void StartGame(Arguments args)
{
Launch = new LaunchArguments(args);
if (Launch.Benchmark)
{
}
var connect = Launch.GetConnectAddress();
if (!string.IsNullOrEmpty(connect))
{
}
//Load a replay directly
if (!string.IsNullOrEmpty(Launch.Replay))
{
}
WarGame.LoadShellMap();
}
public void PlayerPickWarAttackTwiceTest()
{
WarPlayer[] players = new WarPlayer[] {
new WarPlayer()
{
Name = "Player 1"
}
};
players[0].Cards.Add(Card.TwoOfDiamonds);
players[0].Cards.Add(Card.ThreeOfDiamonds);
players[0].Cards.Add(Card.FourOfDiamonds);
WarGame target = new WarGame(players);
target.PlayerDeclareWar(players[0]);
target.PlayerPickWarAttack(players[0], 1);
target.PlayerPickWarAttack(players[0], 1);
Assert.Fail();
}
static void Main(string[] args)
{
var numberOfTimesToPlay = ConsoleUtils.PromptForValue <int>("How many games do you want to play?");
WarGame game = new WarGame(
new WarPlayer()
{
Name = "Player 1"
},
new WarPlayer()
{
Name = "Player 2"
});
Debug.Listeners.Add(new ConsoleTraceListener());
try
{
for (int i = 1; i <= numberOfTimesToPlay; i++)
{
do
{
game.AdvancePlay();
Debug.WriteLine(string.Empty);
if (game.GameState == WarGameState.GameOver)
{
Debug.WriteLine("Winner: " + game.Winner.Name);
}
} while (game.GameState != WarGameState.GameOver);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
Debug.WriteLine("Done");
Console.ReadLine();
}
}
/// <summary>
/// Processes the order.
/// </summary>
/// <param name="orderManager">Order manager.</param>
/// <param name="world">World.</param>
/// <param name="clientId">Client identifier.</param>
/// <param name="order">Order.</param>
internal static void ProcessOrder(OrderManager orderManager, World world, int clientId, Order order)
{
if (world != null)
{
if (!world.WorldActor.TraitsImplementing <IValidateOrder>().All(vo => vo.OrderValidation(orderManager, world, clientId, order)))
{
return;
}
}
switch (order.OrderString)
{
case "Message":
{
break;
}
case "Disconnected":
{
var client = orderManager.LobbyInfo.ClientWithIndex(clientId);
if (client != null)
{
client.State = Session.ClientState.Disconnected;
}
break;
}
case "StartGame":
{
if (WarGame.ModData.MapCache[orderManager.LobbyInfo.GlobalSettings.Map].Status != MapStatus.Available)
{
WarGame.Disconnect();
WarGame.LoadShellMap();
break;
}
WarGame.StartGame(orderManager.LobbyInfo.GlobalSettings.Map, WorldT.Regular);
break;
}
case "PauseGame":
{
var client = orderManager.LobbyInfo.ClientWithIndex(clientId);
if (client != null)
{
var pause = order.TargetString == "Pause";
if (orderManager.World.Paused != pause && world != null && world.LobbyInfo.NonBotClients.Count() > 1)
{
}
orderManager.World.Paused = pause;
orderManager.World.PredictedPaused = pause;
}
break;
}
case "HandshakeRequest":
{
var mod = WarGame.ModData.Manifest;
var request = HandshakeRequest.Deserialize(order.TargetString);
WarGame.Settings.Player.Name = Settings.SanitizedPlayerName(WarGame.Settings.Player.Name);
var info = new Session.Client()
{
Name = WarGame.Settings.Player.Name,
PreferredColor = WarGame.Settings.Player.Color,
Color = WarGame.Settings.Player.Color,
Faction = "Random",
SpawnPoint = 0,
Team = 0,
State = Session.ClientState.Invalid
};
var response = new HandshakeResponse()
{
Client = info,
Mod = mod.Id,
Version = mod.Metadata.Version,
Password = orderManager.Password,
};
orderManager.IssueOrder(Order.HandshakeResponse(response.Serialize()));
break;
}
case "ServerError":
{
orderManager.ServerError = order.TargetString;
orderManager.AuthenticationFailed = false;
break;
}
case "AuthenticationError": {
//
orderManager.ServerError = order.TargetString;
orderManager.AuthenticationFailed = false;
break;
}
case "SyncInfo":
{
orderManager.LobbyInfo = Session.Deserialize(order.TargetString);
SetOrderLag(orderManager);
WarGame.SyncLobbyInfo();
break;
}
case "SyncClientPings":
{
var pings = new List <Session.ClientPing>();
var nodes = MiniYaml.FromString(order.TargetString);
foreach (var node in nodes)
{
var strings = node.Key.Split('@');
if (strings[0] == "ClientPing")
{
pings.Add(Session.ClientPing.Deserialize(node.Value));
}
}
orderManager.LobbyInfo.ClientPings = pings;
break;
}
case "SyncLobbyGlobalSettings":
{
var nodes = MiniYaml.FromString(order.TargetString);
foreach (var node in nodes)
{
var strings = node.Key.Split('@');
if (strings[0] == "GlobalSettings")
{
orderManager.LobbyInfo.GlobalSettings = Session.Global.Deserialize(node.Value);
}
}
SetOrderLag(orderManager);
WarGame.SyncLobbyInfo();
break;
}
case "SyncLobbyClients":
{
var clients = new List <Session.Client>();
var nodes = MiniYaml.FromString(order.TargetString);
foreach (var node in nodes)
{
var strings = node.Key.Split('@');
if (strings[0] == "Client")
{
clients.Add(Session.Client.Deserialize(node.Value));
}
}
orderManager.LobbyInfo.Clients = clients;
WarGame.SyncLobbyInfo();
break;
}
case "SyncLobbySlots":
{
var slots = new Dictionary <string, Session.Slot>();
var nodes = MiniYaml.FromString(order.TargetString);
foreach (var node in nodes)
{
var strings = node.Key.Split('@');
if (strings[0] == "Slot")
{
var slot = Session.Slot.Deserialize(node.Value);
slots.Add(slot.PlayerReference, slot);
}
}
orderManager.LobbyInfo.Slots = slots;
WarGame.SyncLobbyInfo();
break;
}
case "Ping":
{
orderManager.IssueOrder(Order.Pong(order.TargetString));
break;
}
default:
{
if (!order.IsImmediate)
{
var self = order.Subject;
if (!self.IsDead)
{
foreach (var t in self.TraitsImplementing <IResolveOrder>())
{
t.ResolveOrder(self, order);
}
}
}
break;
}
}
}
static void Main(string[] args)
{
WarGame warGame = new WarGame();
}
