public IActionResult CreateGame([FromBody] CreateGameParametersDTO createGameParametersDto)
{
if (createGameParametersDto == null)
{
return(BadRequest());
}
if (Guid.TryParse(Request.Cookies["userId"], out var userId))
{
var oldGame = _gameRepository.FindByUserId(userId);
if (oldGame != null)
{
_gameRepository.Delete(oldGame.GameId);
}
}
else
{
userId = Guid.NewGuid();
Response.Cookies.Append("userId", userId.ToString());
}
var gameField = _gameFieldGenerator.GenerateField(createGameParametersDto.Difficulty);
var game = new Game.Game(userId, gameField);
game = _gameRepository.Insert(game);
var gameDto = _mapper.Map <GameDto>(game);
return(Ok(gameDto));
}
public override void Initialize()
{
_game = new Game.Game();
_game.Initialize(this);
Window.AddFlags(WindowManagerFlags.KeepScreenOn);
}
public JsonResult Guess(string game_key, string code)
{
var game = new Game.Game();
var response = game.TryANewGuess(game_key, code);
var returnObject = new
{
colors = response.Colors,
code_length = response.Code_length,
game_key = response.Game_key,
num_guesses = response.Num_guesses,
result = new
{
exact = response.Result?.Exact,
near = response.Result?.Near
},
past_results = response.Past_results?.Select(x => new { exact = x.Exact, near = x.Near }).ToList(),
opponent_past_results = response.Opponent_Past_results?.Select(x => new { exact = x.Exact, near = x.Near }).ToList(),
solved = response.Solved,
error = response.Error,
multiplayer = response.Multiplayer,
winner = response.Winner
};
return(Json(returnObject, JsonRequestBehavior.DenyGet));
}
public void RenderStart(Game.Game game)
{
// Resize if necessary (required for first tick)
_display.Size(game.Width, game.Height + 5);
// Blank the rows outside of the board area
foreach (var row in new int[] { 0, 1, 2, game.Height + 3, game.Height + 4 })
{
ClearRow(row);
}
// Build the static background
RenderScore(game);
_ticks++;
if (game.Status == GameStatus.ChangingLevel && _ticks % 10 < 5)
{
FlashBoard();
}
else
{
RenderWalls(game);
RenderCoins(game);
RenderPowerPills(game);
RenderGhosts(game);
}
RenderFruit(game);
// Add the sprites
RenderPacMan(game);
RenderLives(game);
}
public void StartGame(string mapFile)
{
Console.WriteLine("Starting game.");
//TODO: We do not need to hold references to game objects in the service.
_map = Business.Maps.Map.LoadFromFile(mapFile);
_game = new Game.Game(_map);
_zombiesSystem = new ZombiesSystem(_game);
_zombiesSystem.Updated += new EventHandler(_zombiesSystem_Updated);
//Create some random zombies
for (int i = 0; i < 7; i++)
{
NonPlayerCharacter zombie = new NonPlayerCharacter(_game);
zombie.Location = new System.Drawing.Point(_random.Next(_map.Size.Width - 1), _random.Next(_map.Size.Height - 1));
zombie.MovementDistance = 2;
zombie.MovementSpeed = _random.Next(2) + 1;
_zombiesSystem.Zombies.Add(zombie);
}
_zombiesSystem.Start();
Console.WriteLine("Map loaded, zombies started.");
}
public Barrak(Game.Game game, Vector2 position, IPlacementService placementService)
: base(game, position, placementService)
{
Size = BuildingSize;
Health = MaxHealth = MaximumHealthConst;
ViewRadius = 3;
}
/*
* public GameForm(Game.Game G)
* {
* context = SynchronizationContext.Current;
*
* InitializeComponent();
* FormBorderStyle = FormBorderStyle.None;
* WindowState = FormWindowState.Maximized;
*
* RunningGame = G;
* RunningGame.Render.ImageUpdated += Render_ImageUpdated;
* RunningGame.Width = Screen.PrimaryScreen.WorkingArea.Width;
* RunningGame.Height = Screen.PrimaryScreen.WorkingArea.Height;
*
* //Player 1
* Player Player1 = new Player(30, 30, 'M' , RunningGame.Teams[0],true, RunningGame);
* Player1.KeyBindings.Add(Keys.W, new MoveState(Player1, Direction.Up));
* Player1.KeyBindings.Add(Keys.A, new MoveState(Player1, Direction.Left));
* Player1.KeyBindings.Add(Keys.S, new MoveState(Player1, Direction.Down));
* Player1.KeyBindings.Add(Keys.D, new MoveState(Player1, Direction.Right));
* AddPlayerToGame(Player1);
*
* //Player 2
* Player Player2 = new Player(RunningGame.Width - 40, RunningGame.Height - 40, 'C', RunningGame.Teams[1], true, RunningGame);
* Player2.KeyBindings.Add(Keys.Up, new MoveState(Player2, Direction.Up));
* Player2.KeyBindings.Add(Keys.Left, new MoveState(Player2, Direction.Left));
* Player2.KeyBindings.Add(Keys.Down, new MoveState(Player2, Direction.Down));
* Player2.KeyBindings.Add(Keys.Right, new MoveState(Player2, Direction.Right));
* AddPlayerToGame(Player2);
*
*
*
* }*/
public GameForm(Game.Game G, List <Player> Players, List <Fighter> Bots)
{
context = SynchronizationContext.Current;
InitializeComponent();
FormBorderStyle = FormBorderStyle.None;
WindowState = FormWindowState.Maximized;
RunningGame = G;
RunningGame.Render.ImageUpdated += Render_ImageUpdated;
RunningGame.Width = Screen.PrimaryScreen.WorkingArea.Width;
RunningGame.Height = Screen.PrimaryScreen.WorkingArea.Height;
foreach (Player p in Players)
{
AddPlayerToGame(p);
}
foreach (Fighter Bot in Bots)
{
RunningGame.InitialBots.Add(Bot);
}
RunningGame.Start();
}
public void ApplyCustomRules(Game.Game game)
{
foreach (ICustomRule customRule in _customRules)
{
customRule.ApplyCustomRule(game);
}
}
public Desk(Game.Game g) : base(sizeX, sizeY, true)
{
this.fields = new Stone[sizeX + 1, sizeY + 1];
this.game = g;
this.Pdesk = ((Game.Game)game).desk;
// inicialization of labels
this.fields[0, 0] = new Stone();
this.fields[0, 0].Sensitive = false;
for (uint i = 1; i < fields.GetLength(0); i++)
{
this.fields[i, 0] = new Stone();
this.Attach(fields[i, 0], i, i + 1, 0, 1);
this.fields[i, 0].Sensitive = false;
this.fields[i, 0].Show();
this.fields[i, 0].setChar(i.ToString());
this.fields[0, i] = new Stone();
this.Attach(fields[0, i], 0, 1, i, i + 1);
this.fields[0, i].Sensitive = false;
this.fields[0, i].Show();
this.fields[0, i].setChar(i.ToString());
}
for (uint j = 1; j < fields.GetLength(1); j++)
{
for (uint i = 1; i < fields.GetLength(0); i++)
{
fields[i, j] = new Stone();
this.Attach(fields[i, j], i, i + 1, j, j + 1);
}
}
this.Restart();
}
public UIUnitHealthBarView(Game.Game game, Unit unit) : base(UIPriorities.HUD)
{
_game = game;
_unit = unit;
_unit.OnTookDamage += Unit_OnTookDamage;
}
/// <summary>
/// 添加一个开发完毕游戏
/// </summary>
/// <param name="game"></param>
public void AddDevelopedGame(Game.Game game)
{
if (!StudioDevelopedGames.Contains(game))
{
StudioDevelopedGames.Add(game);
}
}
public void Go()
{
_game = new MyGame(_engineSystems, new GameSystemCollection());
_game.Init();
_activeWindow.Run();
}
public void moat_played_against_witch()
{
var playerA = new Player(1, "a");
var playerB = new Player(1, "b");
var players = new List <IPlayer>()
{
playerA, playerB
};
var supply = new Supply(
new List <Pile> {
new Pile(Card.Curse, 10)
},
new List <Pile>(),
new List <Pile>());
var vc = new VictoryCondition();
var game = new Game.Game(0, players, supply, vc);
playerA.GainToHand(Card.Witch);
playerB.GainToHand(Card.Moat);
playerA.PlayStatus = PlayStatus.ActionPhase;
game.Submit(playerA.PlayerName, PlayerAction.Play, Card.Witch);
game.Submit(playerB.PlayerName, ActionRequestType.SelectCards, new List <Card> {
Card.Moat
});
Assert.Empty(playerB.DiscardPile);
}
public void cellar_discard_success()
{
var player = new Player(1, "b");
var players = new List <IPlayer>()
{
player
};
var supply = new Supply(new List <Pile>(), new List <Pile>(), new List <Pile>());
var vc = new VictoryCondition();
var game = new Game.Game(0, players, supply, vc);
player.GainToHand(Card.Cellar);
player.Hand.AddRange(Enumerable.Repeat(Card.Copper, 4));
player.Deck.AddRange(Enumerable.Repeat(Card.Silver, 5));
player.PlayStatus = PlayStatus.ActionPhase;
game.Submit(player.PlayerName, PlayerAction.Play, Card.Cellar);
game.Submit(player.PlayerName, ActionRequestType.SelectCards, Enumerable.Repeat(Card.Copper, 3));
var coppersInHand = player.Hand.Count(x => x == Card.Copper);
var silversInHand = player.Hand.Count(x => x == Card.Silver);
var discardCount = player.DiscardPile.Count();
Assert.Equal(1, coppersInHand);
Assert.Equal(3, silversInHand);
Assert.Equal(3, discardCount);
Assert.Equal(1, player.PlayedCards.Count);
Assert.Equal(2, player.Deck.Count);
}
public void SetUp()
{
testgame = new Game.Game(new GameStartOptions {
Height = 2, Width = 2, StartingArmiesPerPlayer = 5
});
testgame.StartJoining();
player1Token = Guid.NewGuid().ToString();
player2Token = Guid.NewGuid().ToString();
testgame.AddPlayer(new ApiPlayer("player1", player1Token, null));
testgame.AddPlayer(new ApiPlayer("player2", player2Token, null));
testgame.StartGame();
//place 5 armies
testgame.TryPlaceArmy(player1Token, territory1.Location);
testgame.TryPlaceArmy(player1Token, territory1.Location);
testgame.TryPlaceArmy(player1Token, territory1.Location);
testgame.TryPlaceArmy(player1Token, territory1.Location);
testgame.TryPlaceArmy(player1Token, territory1.Location);
//player2 places 5 armies
testgame.TryPlaceArmy(player2Token, territory2.Location);
testgame.TryPlaceArmy(player2Token, territory2.Location);
testgame.TryPlaceArmy(player2Token, territory2.Location);
testgame.TryPlaceArmy(player2Token, territory2.Location);
testgame.TryPlaceArmy(player2Token, territory2.Location);
}
public Form1()
{
InitializeComponent();
var soundSet = new SoundSet();
_game = Game.Game.Create()
.Subscribe(GameNotification.Beginning, soundSet.Beginning)
.Subscribe(GameNotification.EatCoin, soundSet.Chomp)
.Subscribe(GameNotification.Respawning, soundSet.Death)
.Subscribe(GameNotification.EatFruit, soundSet.EatFruit)
.Subscribe(GameNotification.EatGhost, soundSet.EatGhost)
.Subscribe(GameNotification.ExtraPac, soundSet.ExtraPac)
.Subscribe(GameNotification.Intermission, soundSet.Intermission)
.StartGame();
_graphicsBuffers = new GraphicsBuffers(this)
{
ShowFps = true
};
this.StartPosition = FormStartPosition.CenterScreen;
this.Text = "PacMan";
this.WindowState = FormWindowState.Maximized;
this.KeyDown += Form1_KeyDown;
_renderLoop.Interval = 16; //40fps
_renderLoop.Enabled = true;
_renderLoop.Tick += _renderLoop_Tick;
}
public string Reset()
{
var guid = Guid.NewGuid();
games = new Game.Game(guid);
return(games.board.GetJson());
}
public void priest_is_played_with_trashing()
{
var player = new Player(1, "b");
var players = new List <IPlayer>()
{
player
};
var supply = new Supply(
new List <Pile>(),
new List <Pile>(),
new List <Pile>());
var vc = new VictoryCondition();
var game = new Game.Game(0, players, supply, vc);
player.PlayStatus = PlayStatus.ActionPhase;
player.GainToHand(Card.Copper);
player.GainToHand(Card.Copper);
player.GainToHand(Card.Copper);
player.GainToHand(Card.Priest);
player.GainToHand(Card.Chapel);
player.NumberOfActions = 2;
game.Submit(player.PlayerName, PlayerAction.Play, Card.Priest);
game.Submit(player.PlayerName, ActionRequestType.SelectCards, new List <Card> {
Card.Copper
});
game.Submit(player.PlayerName, PlayerAction.Play, Card.Chapel);
game.Submit(player.PlayerName, ActionRequestType.SelectCards, new List <Card> {
Card.Copper, Card.Copper
});
Assert.Equal(6, player.MoneyPlayed);
}
public void artisan_card_too_expensive()
{
const Card card = Card.Artisan;
const int supplyAmount = 10;
var player = new Player(1, "b");
var players = new List <IPlayer>()
{
player
};
var supply = new Supply(new List <Pile>(), new List <Pile>(),
new List <Pile>()
{
new Pile(card, supplyAmount),
new Pile(Card.Chapel, 10)
});
var vc = new VictoryCondition();
var game = new Game.Game(0, players, supply, vc);
player.GainToHand(Card.Artisan);
player.PlayStatus = PlayStatus.ActionPhase;
game.Submit(player.PlayerName, PlayerAction.Play, Card.Artisan);
game.Submit(player.PlayerName, ActionRequestType.SelectCards, new List <Card> {
card
});
var actualSupplyCount = game.Supply.KingdomSupply.First().Cards.Count;
Assert.Empty(player.DiscardPile);
Assert.Equal(actualSupplyCount, supplyAmount);
}
public void Setup()
{
int width = 2;
int height = 2;
IPlayer player = new ApiPlayer("Rusty", "bazookaJoe", null);
IPlayer player2 = new ApiPlayer("Emmanuel", "Macaco", null);
game = new Game.Game(new GameStartOptions {
Height = height, Width = width, StartingArmiesPerPlayer = 3
});
game.AddPlayer(new ApiPlayer("Rusty", "bazookaJoe", null));
game.AddPlayer(new ApiPlayer("Emmanuel", "Macaco", null));
Location attacker = new Location(1, 1);
Location attacker2 = new Location(0, 1);
Location defender = new Location(0, 0);
Location defender2 = new Location(1, 0);
game.StartGame();
game.TryPlaceArmy(player.Token, attacker);
game.TryPlaceArmy(player.Token, attacker);
game.TryPlaceArmy(player.Token, attacker2);
game.TryPlaceArmy(player2.Token, defender);
game.TryPlaceArmy(player2.Token, defender);
game.TryPlaceArmy(player2.Token, defender2);
}
public void _180SaveNew(Game.Game game, Player player)
{
var new180Query = $"INSERT INTO [{Table._180}] ({Column.Player},{Column.Game},{Column.Throw3},{Column.Throw2},{Column.Throw1}, {Column.Timestamp})" +
$" VALUES ('{player.Id}','{game.Id}','{player.HandThrows.Pop().Id}','{player.HandThrows.Pop().Id}','{player.HandThrows.Pop().Id}','{DateTime.Now}')";
ExecuteNonQueryInternal(new180Query);
}
public CustomizePlayerControl(Game.Game Game, Team CurrentTeam)
{
InitializeComponent();
UserKeys = new Keys[] { Keys.Up, Keys.Down, Keys.Left, Keys.Right };
WeaponToInt = new Dictionary <int, Bitmap>();
Random r = new Random();
weaponCounter = 0;
WeaponToInt.Add(0, Images.PistolPickup);
WeaponToInt.Add(1, Images.CannonPickup);
WeaponToInt.Add(2, Images.FlamethrowerPickup);
WeaponToInt.Add(3, Images.TentaclePickup);
WeaponToInt.Add(4, Images.RocketLauncherPickup);
WeaponToInt.Add(5, Images.TwisterPickup);
WeaponToInt.Add(6, Images.WingsPickup);
TheGame = Game;
player = new Player(r.Next(30, TheGame.Width - 40), r.Next(30, TheGame.Height - 40), Symbol.Text[0], CurrentTeam, true, TheGame);
player.Shielded = true;
IntToWeapon = new Dictionary <int, Weapon>();
IntToWeapon.Add(0, new Pistol(TheGame, player));
IntToWeapon.Add(1, new Cannon(TheGame, player));
IntToWeapon.Add(2, new Flamethrower(TheGame, player));
IntToWeapon.Add(3, new Tentacles(TheGame, player));
IntToWeapon.Add(4, new RocketLauncher(TheGame, player));
IntToWeapon.Add(5, new Twister(TheGame, player));
IntToWeapon.Add(6, new Wings(TheGame, player));
weapon.BackgroundImage = WeaponToInt[weaponCounter];
this.CurrentTeam = CurrentTeam;
}
public void cache_test_gain_during_action_phase()
{
var player = new Player(1, "b");
var players = new List <IPlayer>()
{
player
};
var supply = new Supply(
new List <Pile>()
{
new Pile(Card.Copper, 10)
},
new List <Pile>(),
new List <Pile>());
var vc = new VictoryCondition();
var game = new Game.Game(0, players, supply, vc);
player.PlayStatus = PlayStatus.ActionPhase;
player.Gain(Card.Cache);
game.CheckPlayStack(player);
var expected = new List <Card> {
Card.Cache, Card.Copper, Card.Copper
};
Assert.Equal(expected, player.DiscardPile);
}
/// <summary>
/// 移除一个开发完毕游戏
/// </summary>
/// <param name="game"></param>
public void RemoveDevelopedGame(Game.Game game)
{
if (StudioDevelopedGames.Contains(game))
{
StudioDevelopedGames.Remove(game);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Scrabble.Lexicon.PlayDesk"/> class.
/// Layout is classic Scrabble desk 15*15 + classic bonuses.
/// </summary>/
public PlayDesk(Game.Game g)
{
this.game = g;
this.desk = new char[15, 15];
this.wordBonus = new byte[15, 15];
this.charBonus = new byte[15, 15];
for (int j = 0; j < desk.GetLength(1); j++)
{
for (int i = 0; i < desk.GetLength(1); i++)
{
desk[i, j] = '_';
wordBonus[i, j] = 1;
charBonus[i, j] = 1;
}
}
byte[,] tripleW = { { 0, 0 }, { 7, 0 }, { 14, 0 }, { 0, 7 }, { 7, 14 }, { 0, 14 }, { 14, 0 }, { 14, 7 }, { 14, 14 } };
byte[,] doubleW = { { 1, 1 }, { 2, 2 }, { 3, 3 }, { 4, 4 }, { 7, 7 }, { 13, 1 }, { 12, 2 }, { 11, 3 }, { 10, 4 }, { 4, 10 }, { 3, 11 }, { 2, 12 }, { 1, 13 }, { 10, 10 }, { 11, 11 }, { 12, 12 }, { 13, 13 } };
byte[,] tripleCh = { { 5, 1 }, { 9, 1 }, { 5, 5 }, { 9, 5 }, { 1, 5 }, { 13, 5 }, { 5, 9 }, { 9, 9 }, { 5, 13 }, { 9, 13 }, { 1, 9 }, { 13, 9 } };
byte[,] doubleCh = { { 3, 0 }, { 11, 0 }, { 6, 6 }, { 8, 6 }, { 6, 8 }, { 8, 8 }, { 3, 14 }, { 11, 14 }, { 2, 6 }, { 3, 7 }, { 2, 8 }, { 6, 2 }, { 7, 3 }, { 8, 2 }, { 11, 7 }, { 12, 6 }, { 12, 8 }, { 6, 12 }, { 7, 11 }, { 8, 12 } };
LoadFromMemory(wordBonus, tripleW, 3);
LoadFromMemory(wordBonus, doubleW, 2);
LoadFromMemory(charBonus, tripleCh, 3);
LoadFromMemory(charBonus, doubleCh, 2);
}
/// <summary>
/// Initializes a new instance of the <see cref="Scrabble.GUI.Info"/> class.
/// </summary>
/// <param name='g'>
/// G.
/// </param>
public Info(Game.Game g)
{
this.Label = "Score";
this.BorderWidth = 5;
this.game = g;
this.HeightRequest = 99;
this.WidthRequest = 120;
scoresTable = new Gtk.Table(6, 2, true);
scoreValues = new Gtk.Label[6 * 2];
for (int i = 0; i < this.game.players.Length; i++)
{
scoreValues[i] = new Label(game.players[i].Name);
scoreValues[i + 6] = new Label("0");
scoresTable.Attach(scoreValues[i], 0, 1, (uint)i, (uint)i + 1);
scoresTable.Attach(scoreValues[i + 6], 1, 2, (uint)i, (uint)i + 1);
}
for (int i = this.game.players.Length; i < 6; i++)
{
scoreValues[i] = new Label( );
scoreValues[i + 6] = new Label( );
scoresTable.Attach(scoreValues[i], 0, 1, (uint)i, (uint)i + 1);
scoresTable.Attach(scoreValues[i + 6], 1, 2, (uint)i, (uint)i + 1);
}
scoresTable.BorderWidth = 3;
this.Add(scoresTable);
this.ShowAll();
}
/// <summary>
/// Create a matrix of map pieces from Game object
/// </summary>
/// <param name="game"></param>
private void GetWallsFromGame(Game.Game game, IReadOnlyCollection <CellLocation> doors)
{
// Populate the map matrix from the given list of walls
foreach (var item in game.Walls)
{
var x = item.X + 1;
var y = item.Y + 1;
_map[x, y] = new MapCellDetail(_map, x, y, BasicMapPiece.SingleWall);
}
foreach (var item in doors)
{
var x = item.X + 1;
var y = item.Y + 1;
_map[x, y] = new MapCellDetail(_map, x, y, BasicMapPiece.Door);
}
for (int y = 0; y < _height; y++)
{
for (int x = 0; x < _width; x++)
{
if (_map[x, y] == null)
{
_map[x, y] = new MapCellDetail(_map, x, y, BasicMapPiece.Space);
}
}
}
}
public Worker(Game.Game game, IPathFinder pathFinder, Vector2 position)
: base(game, pathFinder, position)
{
Speed = 1.8f;
MaxHealth = Health = 40;
ViewRadius = 3;
}
public static void HandleMessage(RegisterGame request, CommunicationServer server, Socket handler)
{
if (request == null)
{
return;
}
Game.Game g;
lock (joinLock)
{
g = new Game.Game(gameId: server.RegisteredGames.NextGameId(), name: request.NewGameInfo.gameName,
bluePlayers: request.NewGameInfo.blueTeamPlayers,
redPlayers: request.NewGameInfo.redTeamPlayers, gameMaster: handler
);
try
{
server.RegisteredGames.RegisterGame(g);
}
catch
{
return;
}
}
ConfirmGameRegistration gameRegistration = new ConfirmGameRegistration()
{
gameId = (ulong)g.Id
};
var response = XmlMessageConverter.ToXml(gameRegistration);
server.ConnectionEndpoint.SendFromServer(handler, response);
}
public static Game.Game AddKeyboard(this Game.Game game)
{
var keyboard = new Keyboard(game);
game.Subscribe(GameNotification.PreTick, keyboard.CheckForKeyPress);
return(game);
}
private void btn_CreateGame_Click(object sender, EventArgs e)
{
Game.Game game = new Game.Game();
game.data.name = this.tb_GameName.Text;
try
{
game.data.resourceModifier = Convert.ToDouble(this.tb_ResourceModifier.Text);
}
catch (Exception ex)
{
game.data.resourceModifier = 1.0;
}
try
{
game.data.startingPopulation = Convert.ToDouble(this.tb_StartingPopulation.Text);
}
catch (Exception ex)
{
game.data.startingPopulation = 1000;
}
int counter = 0;
for (int i = 0; i < packages.Length; i++)
{
if (packagesIn[i])
{
counter++;
}
}
Package[] packagesToUse = new Package[counter];
counter = 0;
for (int i = 0; i < packages.Length; i++)
{
if (packagesIn[i])
{
packagesToUse[counter] = packages[i];
counter++;
}
}
game.data.packages = packagesToUse;
Objects.game = game;
Objects.game.onePackage();
Objects.game.generate();
Objects.game.save();
Objects.game = null;
this.Close();
}
public void TestUpgradesWithCookers()
{
Game.Game g = new Game.Game();
Game.Buildings.Restaurant resto = new Game.Buildings.Restaurant(g.Villages[0], g.Villages[0].JobsList.Cooker);
int _initialCoeff = g.Villages[0].JobsList.Cooker.Coefficient;
g.AddOrTakeFromOfferings(200);
Assert.That(g.Offerings > 200);
Assert.That(g.Villages[0].BuildingsList.RestaurantList.Count > 0);
g.Villages[0].Upgrades.Level1.Buy();
Assert.That(g.Villages[0].Upgrades.Level1.IsPossible);
Assert.That(g.Villages[0].Upgrades.Level1.IsActivated);
Assert.That(_initialCoeff != g.Villages[0].JobsList.Cooker.Coefficient);
Assert.That(g.Villages[0].Upgrades.Scaffolding != null);
}
public static void RunAITournament(int numPlayers, int round)
{
DateTime startTime = DateTime.Now;
var stats = new Dictionary<string, TournamentPlayerStats>();
var simplexLearnedScores = SimplexLearnedScores.Load(SimplexLearning.FileName);
ColorConsole.WriteLine(ConsoleColor.Cyan, "Loaded parameters: {0}", simplexLearnedScores);
for (int i = 1; i <= round; ++i)
{
var game = new Game.Game((new SettlerBoardConstructor()).ConstructBoard(), numPlayers);
game.Round = i;
var improvedEmmAiPlayerNormal = new ImprovedEMN(new GameScores());
var improvedEmmAiPlayerExpansion = new ImprovedEMN(simplexLearnedScores);
var players = new IPlayer[numPlayers];
players.Fill(improvedEmmAiPlayerNormal);
players[RandomGenerator.Next(numPlayers)] = improvedEmmAiPlayerExpansion;
for (int j = 0; j < numPlayers; ++j)
{
string name = players[j].Name;
if (!stats.ContainsKey(name))
{
stats[name] = new TournamentPlayerStats
{
PlayerName = name
};
}
}
var controller = new GameController(new ConsoleViewer(), game, false, players);
int winnerIndex = controller.Run();
TournamentPlayerStats stat = stats[players[winnerIndex].Name];
ColorConsole.WriteLine(ConsoleColor.Yellow,
">>> University {0}, AI player '{1}' has won. <<<",
controller.Game.GetUniversityByIndex(winnerIndex).Color,
stat.PlayerName
);
stat.HasWon();
foreach (TournamentPlayerStats statForPrint in stats.Values)
{
statForPrint.PrintToConsole();
}
ColorConsole.WriteLine(ConsoleColor.Green, "Total time taken: " + (DateTime.Now - startTime));
}
}
public void fest()
{
var game = new Game.Game();
//new Game.SamhainFest(game.Villages[0]);
new Game.Buildings.PartyRoom(game.Villages[0]);
game.Villages[0].FestStart();
int argent = game.Villages[0].FamiliesList[0].GoldStash;
int argent2 = argent - game.Villages[0].FamiliesList[0].FamilyMembers.Count;
Game.Villager fa=game.Villages[0].FamiliesList[0].Father;
Assert.That(fa.ActivityStatus == Game.ActivityStatus.PARTYING);
Assert.That(!fa.IsWorking);
game.NextStep();
Assert.AreEqual(argent2, game.Villages[0].FamiliesList[0].GoldStash);
for (int i = 0; i < 20; i++)
{
game.NextStep();
}
Assert.That(game.Villages[0].FamiliesList[0].Father.ActivityStatus == Game.ActivityStatus.NONE);
}
public Render(ref Game.Game g, ref Settings s)
: base(s.GraphicsX, s.GraphicsY, OpenTK.Graphics.GraphicsMode.Default, "Raven")
{
theGame = g;
settings = s;
//in case some one else wants to acess this bit.Untitled event
Instance = this;
//bind events to the input handler.
Mouse.ButtonUp += InputHandler.OnMouseUp;
Mouse.ButtonDown += InputHandler.OnMouseDown;
Mouse.WheelChanged += InputHandler.OnMouseWheeled;
Keyboard.KeyDown+= InputHandler.OnKeyDown;
Keyboard.KeyUp+=InputHandler.OnKeyUp;
//setup vertex buttfer objects. heh
BaseRender.Init();
UnitRenderer.Init();
}
public static void PlayGame()
{
while (true)
{
var game = new Game.Game((new SettlerBoardConstructor()).ConstructBoard(), 4);
IPlayer improvedEMM_AIPlayer = new ImprovedEMN(new GameScores());
var players = new IPlayer[4];
players.Fill(improvedEMM_AIPlayer);
players[RandomGenerator.Next(4)] = _humanConsolePlayer;
var controller = new GameController(new ConsoleViewer(), game, true, players);
_humanConsolePlayer.GameController = controller;
controller.Run();
Console.WriteLine("Try again? y/n");
ConsoleKeyInfo key = Console.ReadKey();
Console.WriteLine();
if (key.KeyChar == 'n')
{
break;
}
}
}
void customMapsControl_OpenCustomMap(string mapFileName)
{
var oldProfileMenu = Program.Instance.ProfileMenuDefault;
Program.Instance.ProfileMenuDefault = ProfileMenuType.MainMenu;
Program.Instance.Profile = Profile.NewDeveloper();
var game = new Game.Game(mapFileName);
Program.Instance.ProgramState = game;
ProgramEventHandler p = null;
p = (e) => {
if (e.Type == ProgramEventType.ProgramStateChanged)
{
Program.Instance.ProfileMenuDefault = oldProfileMenu;
Program.Instance.ProgramEvent -= p;
}
};
Program.Instance.ProgramEvent += p;
}
public void SetGame(Game.Game game)
{
_game = game;
_board = game.Board;
InitialiseBuffer();
}
public void WhenISetUpTheCatanBeginnerSGame()
{
_game = new SettlerBeginnerGame();
}
public void Learn()
{
#region Fields
int runden = Rundefrage();
int zug;
string momsitcode = SitCodeHelper.GetEmpty(Length);
int[,] sit_codes = new int[runden, Length];
int[,] zuege = new int[runden, Length];
int[] wertungen = new int[runden];
GameStates state = GameStates.Laufend;
Game.Game game = new Game.Game(new Player('1'), new Player('2'), null, new Fields.SitCode(3, 3));
#endregion
OnShowMessageEvent("Berechne Daten..");
for (int currround = 0; currround < runden; currround++)
{
for (int i = 0; i < 9; i++)
{
momsitcode = SitCodeHelper.StringToSitCode(game.Field.ToString());
sit_codes[currround, i] = int.Parse(momsitcode);
zug = FieldHelper.GetRandomZug(game.Field);
zuege[currround, i] = zug;
game.Logik(Vector2i.FromIndex(zug, 3, 3));
state = FieldHelper.GetGameState(game.Field, game.Player);
// Wertungen
// Aufwerten
if (state == GameStates.Gewonnen)
wertungen[currround] = 1;
else if (state == GameStates.Verloren)
wertungen[currround] = -1;
else if (state == GameStates.Unentschieden)
wertungen[currround] = 0;
// Ist Spiel Zu Ende?
if (game.HasEnd())
{
game.NewGame();
}
}
if (currround % 100 == 0)
{
OnShowMessageEvent("Spielrunde Nr. " + currround);
}
}
OnShowMessageEvent("Fertig mit dem Berechnen der Daten.");
OnShowMessageEvent("Speichere Daten");
writerReader.Write(zuege, sit_codes, wertungen);
OnShowMessageEvent("Fertig, Taste drücken zum Beenden");
OnGetStringEvent();
}
private double RunTournament(double[] values)
{
DateTime startedTime = DateTime.Now;
_learnedScores.FromResult(values);
var stats = new Dictionary<string, TournamentPlayerStats>();
const int numPlayers = 2;
int round = 0;
var tournamentResult = new TournamentResult();
int challengerIndex = 0;
while (round < _roundsToWinInTournament)
{
++round;
challengerIndex = (challengerIndex + 1) % numPlayers;
var game = new Game.Game(_boardConstructor.ConstructBoard(), numPlayers) {Round = round};
var _improvedEMM_AIPlayer_normal = new ImprovedEMN(new GameScores());
var _improvedEMM_AIPlayer_expansion = new ImprovedEMN(_learnedScores);
var players = new IPlayer[numPlayers];
players.Fill(_improvedEMM_AIPlayer_normal);
players[challengerIndex] = _improvedEMM_AIPlayer_expansion;
for (var j = 0; j < numPlayers; ++j)
{
var name = players[j].Name;
if (!stats.ContainsKey(name))
{
stats[name] = new TournamentPlayerStats
{
PlayerName = name
};
}
}
var controller = new GameController(_gameViewer, game, false, players);
var winnerIndex = controller.Run();
var stat = stats[players[winnerIndex].Name];
ColorConsole.WriteLine(ConsoleColor.Yellow,
">>> University {0}, AI player '{1}' has won. <<<",
controller.Game.GetUniversityByIndex(winnerIndex).Color,
stat.PlayerName
);
stat.HasWon();
var challengerUni = game.GetUniversityByIndex(challengerIndex);
tournamentResult.AddRound(
new RoundResult(game.GetScore(challengerUni),
winnerIndex == challengerIndex,
game.Universities.Where(u => u != challengerUni).Select(game.GetScore)
));
foreach (var statForPrint in stats.Values)
{
statForPrint.PrintToConsole();
}
}
var totalScore = tournamentResult.CalculateTotalScore();
LogInfo(_learnedScores.ToString());
_touranmentCount++;
var remainingTimeSpan = GetEstimatedFinishedTime();
LogInfo("Got score: {0}. Challenger won {1} rounds. Time taken this tournament: {2}." +
" Total time taken: {3}. Estimated finished time: {4} ({5} to go)",
totalScore,
tournamentResult.ChallengerWinningCount,
DateTime.Now - startedTime,
DateTime.Now - _learningStartedDT,
DateTime.Now + remainingTimeSpan,
remainingTimeSpan);
return -totalScore; // return negative for function minimisation
}
public void SetGame( Game.Game g )
{
this.game = g;
}
