public void CreateWithNoNoise_AddsOnlyRequiredDominoPieces()
{
var beginCategory = new DominoTile("Begin", "");
var endCategory = new DominoTile("End", "");
var middleCategory = new DominoTile("Middle", "");
A.CallTo(() => _pathFinder.FindPath(1, 1)).WithAnyArguments().Returns(new SuggestedPath { MinimumRequiredPieces = 2 });
A.CallTo(() => _categoriesProvider.DrawTile()).ReturnsNextFromSequence(beginCategory, endCategory, middleCategory);
A.CallTo(() => _categoriesProvider.DrawTileFromCategory("Begin")).Returns(beginCategory);
A.CallTo(() => _categoriesProvider.DrawTileFromCategory("End")).Returns(endCategory);
A.CallTo(() => _categoriesProvider.DrawTileFromCategory("Middle")).Returns(middleCategory);
var builder = new GameBuilder(_pathFinder);
var game = builder.Create(10, 10, 0, _categoriesProvider);
Assert.Equal(2, game.PlayerPieces.Length);
var firstPiece = game.PlayerPieces[0];
Assert.Equal(beginCategory.Category, firstPiece.FirstTile.Category);
Assert.Equal(middleCategory.Category, firstPiece.SecondTile.Category);
var secondPiece = game.PlayerPieces[1];
Assert.Equal(middleCategory.Category, secondPiece.FirstTile.Category);
Assert.Equal(endCategory.Category, secondPiece.SecondTile.Category);
}
public Game Construct()
{
Initialize();
GameObject gameHolder = new GameObject();
gameHolder.name = gameName;
gameHolder.transform.position = gameSetting.GridPosition;
List<IGroupPattern> groupPatterns = groupPatternConverter.Convert();
GameBuilder gameBuilder = new GameBuilder(gameHolder,
gameSetting,
particleSpawner,
blockColorRepository,
groupPatterns,
backgroundFactory,
cameraManager,
blockViewSpawner,
floatingTextRenderer);
Game game = gameBuilder.Build();
game.InitializeGrid();
return game;
}
/// <summary>
/// Constructor of a GameController object.
/// </summary>
/// <param name="gameBuilder">Defines the GameBuilder the GameController uses.</param>
/// <param name="gameHandler">Defines the GameHandler the GameController uses.</param>
public GameController(GameBuilder gameBuilder, GameHandler gameHandler)
{
this.gameBuilder = gameBuilder;
this.gameHandler = gameHandler;
this.gameBuilder.CollisionHandler = this;
this.gameBuilder.PlayerHandler = this;
}
public void GivenAGame(string gameName)
{
var game = new GameBuilder()
.WithName(gameName)
.Build();
SaveDomainObject(game);
}
public void TestSync()
{
//Arrange
var game = new GameBuilder(this.Session).Build();
//Act
this.scoreboard.AddGame(game);
this.Session.Derive();
//Assert
Assert.Equal(4, game.Scores.Count);
}
// Start is called before the first frame update
void Awake()
{
var buttons = GetComponentsInChildren <Button>();
startButton = buttons.Where(x => x.name == "StartButton").FirstOrDefault();
exitButton = buttons.Where(x => x.name == "ExitButton").FirstOrDefault();
choiceButton = buttons.Where(x => x.name == "ChoiceButton").FirstOrDefault();
choiceButton.onClick.AddListener(OnChoiceButtonClick);
startButton.onClick.AddListener(OnStartButtonClick);
exitButton.onClick.AddListener(OnExitButtonClick);
gameBuilder = FindObjectOfType <GameBuilder>();
}
/// <summary>
/// Saves the game to a file and show a success message.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void SaveClicked(object sender, RoutedEventArgs e)
{
try
{
GameBuilder.SaveGame(_gameName.Text, _game);
Window.GetWindow(this).Close();
}
catch (Exception ex)
{
NavigationService.Navigate(new InGameMenuErrorPage());
}
}
/// <summary>
/// Creates a new server process
/// </summary>
/// <param name="workingNetManager"></param>
/// <param name="gameName"></param>
/// <param name="sceneName"></param>
/// <param name="maxPlayers"></param>
/// <param name="userProvider"></param>
/// <param name="shutOnDisconnect"></param>
/// <param name="onServerStarted"></param>
/// <param name="onServerFailedToStart"></param>
internal static void CreateServerProcess(this NetworkManager workingNetManager,
string gameName, string sceneName, int maxPlayers, UserProvider userProvider, bool shutOnDisconnect,
Action onServerStarted, Action onServerFailedToStart = null)
{
#if UNITY_EDITOR
string serverOnlinePath =
$"{GameBuilder.GetBuildDirectory()}Team-Capture-Quick/{ServerOnlineFile}";
#else
string serverOnlinePath = $"{Game.GetGameExecutePath()}/{ServerOnlineFile}";
#endif
//Check to make sure the server online file doesn't already exist
if (File.Exists(serverOnlinePath))
{
onServerFailedToStart?.Invoke();
Logger.Error("A server is already running!");
return;
}
#if UNITY_EDITOR
string tcApp = $"{GameBuilder.GetBuildDirectory()}Team-Capture-Quick/";
#else
string tcApp = Game.GetGameExecutePath();
#endif
#if UNITY_EDITOR_WIN || UNITY_STANDALONE_WIN
tcApp += "/Team-Capture.exe";
#else
tcApp += "/Team-Capture";
#endif
string tcArguments =
$"-batchmode -nographics -gamename \"{gameName}\" -scene {sceneName} -maxplayers {maxPlayers} -auth-method {userProvider.ToString()}" +
$"{(shutOnDisconnect ? " -closeserveronfirstclientdisconnect" : string.Empty)} -high";
#if UNITY_EDITOR_LINUX || UNITY_STANDALONE_LINUX
ProcessHelper.LaunchLinuxTerminalAndLaunchProcess(tcApp, tcArguments);
#else
System.Diagnostics.Process tcProcess = new()
{
StartInfo = new System.Diagnostics.ProcessStartInfo
{
FileName = tcApp,
Arguments = tcArguments,
WorkingDirectory = Game.GetGameExecutePath()
}
};
tcProcess.Start();
#endif
//We need to wait for the server online file, and to not cause the game to freeze we run it async
WaitForServerOnlineFile(serverOnlinePath, onServerStarted, onServerFailedToStart).Forget();
}
public void Add_ShouldAssignAnIdToTheGameAndReturnTheSavedGame()
{
//Arrange
var newGame = new GameBuilder().Build();
//Act
var result = _repo.Add(newGame);
//Assert
Assert.That(result.Id, Is.Not.EqualTo(Guid.Empty));
Assert.That(result, Is.SameAs(newGame));
}
public void GivenNewBoardWithOneUser_WhenGamePlayed_ThenUserIsAdvanced()
{
//given
var gameBuilder = new GameBuilder();
var player = gameBuilder.AddPlayer(new Player());
var game = gameBuilder.Build();
//when
var diceThrow = game.Play();
//then
game.Players.ToList()[0].Place.Should().Be(diceThrow + 1);
}
/// <summary>
/// Usa el gameBuilder para crear los distintos elementos.
/// </summary>
/// <param name="loader"></param>
private void AsignarPlayersConMeshes(TgcSceneLoader loader)
{
GameBuilder gb = new GameBuilder(MediaDir, this, loader);
Autos = new List <Auto>();
//BosqueScene = gb.CrearBosque();
Velocimetro = new Velocimetro(this);
AutoJugador = gb.CrearHummer(MapScene, Velocimetro);
Autos.Add(AutoJugador);
gb.CrearLuces();
//sprites en pantalla
}
public void CreateFromGame_UsesAGameToGetTheInfoFromThePerspectiveOfThePlayer()
{
//Arrange
var settings = new GameSettingsBuilder().WithMustReportSunkenShip(true).Build();
Mock <IGame> gameMock = new GameBuilder().WithSettings(settings).BuildMock();
IGame game = gameMock.Object;
IGridInfo expectedPlayerGridInfo = new Mock <IGridInfo>().Object;
IGridInfo expectedOpponentGridInfo = new Mock <IGridInfo>().Object;
_gridInfoFactoryMock.Setup(f => f.CreateFromGrid(game.Player1.Grid)).Returns(expectedPlayerGridInfo);
_gridInfoFactoryMock.Setup(f => f.CreateFromGrid(game.Player2.Grid)).Returns(expectedOpponentGridInfo);
IList <IShipInfo> expectedPlayerShipInfos = new List <IShipInfo>();
_shipInfoFactoryMock.Setup(f => f.CreateMultipleFromFleet(game.Player1.Fleet)).Returns(expectedPlayerShipInfos);
IList <IShipInfo> expectedOpponentShipInfos = new List <IShipInfo>();
_shipInfoFactoryMock.Setup(f => f.CreateMultipleFromSunkenShipsOfFleet(game.Player2.Fleet)).Returns(expectedOpponentShipInfos);
//Act
IGameInfo gameInfo = _factory.CreateFromGame(game, game.Player1.Id);
//Assert
Assert.That(gameInfo, Is.Not.Null, "No instance of a class that implements IGame is returned.");
Assert.That(gameInfo.Id, Is.EqualTo(game.Id), "The Id should be the Id of the game.");
gameMock.Verify(g => g.GetPlayerById(game.Player1.Id), Times.Once,
"The player should be retrieved using the GetPlayerById method of the game correctly.");
Assert.That(gameInfo.IsReadyToStart,
Is.EqualTo(game.Player1.Fleet.IsPositionedOnGrid && game.Player2.Fleet.IsPositionedOnGrid),
"IsReadyToStart must be true when both the player fleet as the opponent fleet is positioned on the grid.");
Assert.That(gameInfo.HasBombsLoaded, Is.EqualTo(game.Player1.HasBombsLoaded), "HasBombsLoaded should be equal to HasBombsLoaded of the player");
Assert.That(gameInfo.OwnGrid, Is.SameAs(expectedPlayerGridInfo),
"The OwnGrid should be the instance returned by the IGridInfoFactory. " +
"The IGridInfoFactory should create the info from the Grid of the player.");
Assert.That(gameInfo.OwnShips, Is.SameAs(expectedPlayerShipInfos),
"The OwnShips should be the list returned by the IShipInfoFactory. " +
"The IShipInfoFactory should create the list from all the ships of the player.");
gameMock.Verify(g => g.GetOpponent(game.Player1), Times.Once,
"The opponent should be retrieved using the GetOpponent method of the game correctly.");
Assert.That(gameInfo.OpponentGrid, Is.SameAs(expectedOpponentGridInfo),
"The OpponentGrid should be the instance returned by the IGridInfoFactory. " +
"The IGridInfoFactory should create the info from the Grid of the opponent.");
Assert.That(gameInfo.SunkenOpponentShips, Is.SameAs(expectedOpponentShipInfos),
"The SunkenOpponentShips should be the list returned by the IShipInfoFactory. " +
"The IShipInfoFactory should create the list from all the sunken ships of the opponent.");
}
public ActionResult Configure(GameAdminVM vm)
{
if (ModelState.IsValid)
{
Configuration globalConf = new Configuration()
{
Key = ConfigurationKeys.GlobalGameConfiguration.GetName(),
Data = JsonConvert.SerializeObject(vm.GlobalGameConfiguration)
};
Configuration planetConf = new Configuration()
{
Key = ConfigurationKeys.GlobalPlanetConfiguration.GetName(),
Data = JsonConvert.SerializeObject(vm.GlobalPlanetConfiguration)
};
db.Configurations.Attach(globalConf);
db.Configurations.Attach(planetConf);
db.Entry(globalConf).State = EntityState.Modified;
db.Entry(planetConf).State = EntityState.Modified;
db.SaveChanges();
GameBuilder builder = new GameBuilder();
Universe universe = builder.AddGlobalGameConfiguration(vm.GlobalGameConfiguration).AddPlanetsOnSolarSystem(vm.GlobalPlanetConfiguration).BuildUniverse();
if (ValidationUtil.ValidateObject(universe))
{
try
{
db.ClearDatabase();
db.Universes.Add(universe);
db.SaveChanges();
}
catch (DbEntityValidationException ex)
{
var error = ex.EntityValidationErrors.First().ValidationErrors.First();
Console.WriteLine("error : " + error.PropertyName);
Console.WriteLine("message : " + error.ErrorMessage);
this.ModelState.AddModelError(error.PropertyName, error.ErrorMessage);
return(ReturnView(vm));
}
}
return(Redirect("/Home"));
}
else
{
return(ReturnView(vm));
}
}
public virtual async Task <SourceDemo> ParseAsync(byte[] content)
{
var demo = new SourceDemo();
var buf = new SourceBufferReader(content);
if (Options.ReadHeader)
{
await demo.ReadHeader(buf).ConfigureAwait(false);
}
if (Options.ReadMessages)
{
await Task.Run <SourceGame>(() => demo.Game = GameBuilder.Invoke(demo)).ConfigureAwait(false);
if (!Options.ReadHeader)
{
buf.SeekBytes(1072);
}
await demo.ReadMessagesAsync(buf).ConfigureAwait(false);
foreach (var message in demo.Messages)
{
if (Options.ReadPackets && message is Packet pa)
{
await demo.Read(pa).ConfigureAwait(false);
continue;
}
if (Options.ReadStringTables && message is StringTables st)
{
await demo.Read(st).ConfigureAwait(false);
continue;
}
if (Options.ReadDataTables && message is DataTables dt)
{
await demo.Read(dt).ConfigureAwait(false);
continue;
}
if (Options.ReadUserCmds && message is UserCmd uc)
{
await demo.Read(uc).ConfigureAwait(false);
continue;
}
}
}
return(demo);
}
public void PositionTest()
{
IGame game = new GameBuilder()
.SetTitle("Engine Test")
.SetExceptinDialog(true)
.SetDebugLogging(true)
.SetDefaultEvents()
.Build();
game.LoadScene(GetPositionScene());
game.Run(60.0d);
}
public GameBuilderTests()
{
var wordBuilder = A.Fake <IWordsRepository>(o => o.Strict());
_randomUtils = A.Fake <IRandomUtils>(o => o.Strict());
A.CallTo(() => wordBuilder.Get25RandomWords()).Returns(GetListOfWords());
A.CallTo(() => _randomUtils.GenerateCode()).Returns("aaa");
A.CallTo(() => _randomUtils.SingleValue(Color.Blue, Color.Red)).Returns(Color.Blue);
A.CallTo(() => _randomUtils.RandomizeList(A <List <Card> > .Ignored)).Invokes(() => { });
_gameBuilder = new GameBuilder(wordBuilder, _randomUtils);
}
public void GivenIHaveBeenDealtMyInitalTwoCards()
{
var game_builder = new GameBuilder().find_game_by_player_id(PlayerToken.player_id);
var game = game_builder.set_game_state_to(TableStatus.hands_dealt)
.mark_cards_as_dealt()
.add_dealers_hand()
.with_status_of(HandStatus.in_play)
.build()
.build();
DataBaseHelper.save_or_add(game);
}
public void UnitImplTest()
{
NewGameDataContext dataContext = new NewGameDataContext();
dataContext.FactionP1 = Units.Faction.Dwarves;
dataContext.FactionP2 = Units.Faction.Elves;
dataContext.NicknameP1 = "Player1";
dataContext.NicknameP2 = "Player2";
dataContext.SizeOfMap = Map.MapSize.medium;
GameBuilder gameBuilder = (GameBuilder) new PetitMonde.NewGame(dataContext);
gameBuilder.BuildGame();
}
public GameCreationScreenViewModel(IMessenger messenger)
{
MessengerInstance = messenger;
Builder = new GameBuilder();
OnValidationChanged += StartGameCommand.RaiseCanExecuteChanged;
PlayerBuilder1 = new PlayerBuilderViewModel(Builder.PlayerBuilder1, Colors.RoyalBlue, OnValidationChanged);
PlayerBuilder2 = new PlayerBuilderViewModel(Builder.PlayerBuilder2, Colors.DarkRed, OnValidationChanged);
var rng = new Random();
(Builder.PlayerBuilder1, Builder.PlayerBuilder2).ForEach(b => b.Name = GetDefaultPlayerName(rng));
}
public void NineInsteadOfTen()
{
var royalFlush = Helper.HearthsRoyalFlush();
var game = GameBuilder.Game(royalFlush).SwapLastCardWith(
CardBuilder.Nine().Hearths());
// ACT
var result = new RoyalFlush().Evaluate(game);
// ASSERT
Assert.IsFalse(result.Success());
}
public void StartGame(GameSettings settings)
{
GameBuilder gameBuilder = new GameBuilder(_ui, _rng, _species);
GameHandler gameHandler = gameBuilder.BuildGame(settings);
try {
gameHandler.Process();
} catch (Exception ex) {
Logger.Fatal($"Received error from GameHandler: {ex.Message}.");
Logger.Debug($"Stacktrace: {ex.StackTrace}.");
_ui.OnError(ex.Message);
}
}
private void saveAction()
{
GameBuilder builder = new GameBuilder();
try
{
builder.save("save.dat");
MessageBox.Show("The game has been saved.");
} catch (Exception e)
{
MessageBox.Show("Error while saving the game.");
}
}
public void SaveAndLoadTest()
{
IGame game = new GameBuilder().Build();
Scene scene = new Scene {
Name = "Test"
};
Guid tmp = scene.InstanceGuid;
scene.Save("testScene.json");
Assert.AreEqual(game.PreLoadScene <Scene>("testScene.json").Value, tmp);
}
public void SimpleBuilderPlayground()
{
var gb = GameBuilder.Create <String>()
.WithContext("a")
.HasNameAndDescription("name", "asdsadsa")
.HasEndState("name2", "asdsadsa")
.HasCheckerForStateChange(s => s == "").ThenGoToState("")
.HasCheckerForStateChange(s => s != "").ThenGoToState("")
.HasCheckerForContextDataChange(s => s == "").ThenDo(t => t.ToCharArray())
.EndHasState()
.HasStartState("", "")
.EndHasState();
}
public void CanDoBasicBuilderConstruction()
{
var builder = new GameBuilder()
.AddCommand <EmptyCommandInfo>("test")
.AddIOHandler(_ioHandler)
.AddSystem <EmptySystem>()
.ComposeSystems()
.AddEntity().WithComponent <EmptyComponent>()
.ComposeEntities()
.Build();
_runQuickGame(builder);
}
private async Task <bool> StartNew(string name, bool playWithBot)
{
if (games.ContainsKey(name))
{
return(false);
}
var game = GameBuilder.BuildGame(name);
games[name] = new Context
{
game = game,
Connections = { (Context.ConnectionId, 0) },
private static string GetBuildDir()
{
string buildDir = $"{GameBuilder.GetBuildDirectory()}Team-Capture-Quick/";
if (!Directory.Exists(buildDir))
{
return(null);
}
string fullPath = $"{buildDir}{ApplicationName}";
return(!File.Exists(fullPath) ? null : Path.GetFullPath(fullPath));
}
static void Main(string[] args)
{
Console.WriteLine("Sprint Ego!");
var gameBuilder = new GameBuilder();
var game = gameBuilder.WithDefaultPlayers().WithDefaultQuestions().StartGame();
while (!game.IsLastRound())
{
PlayTurn(game);
}
Console.WriteLine("LAST ROUND!");
PlayTurn(game);
}
public void CreateWithNoise_AdditionalPiecesAdded()
{
var minimumPathSize = 2;
var noiseCount = 5;
A.CallTo(() => _pathFinder.FindPath(1, 1)).WithAnyArguments().Returns(new SuggestedPath { MinimumRequiredPieces = minimumPathSize });
A.CallTo(() => _categoriesProvider.DrawTile()).WithAnyArguments().Returns(new DominoTile("", ""));
var builder = new GameBuilder(_pathFinder);
var game = builder.Create(10, 10, noiseCount, _categoriesProvider);
Assert.Equal(minimumPathSize + noiseCount, game.PlayerPieces.Length);
}
public void SceneTest()
{
IGame game = new GameBuilder().Build();
Scene sce = new Scene();
int count = 0;
game.SceneEvents.UnloadSceneEvent += (sender, args) =>
{
if (args.UnloadScene.GetHashCode() == sce.GetHashCode())
{
count++;
}
};
// ロードに成功
Assert.True(game.LoadScene(sce).IsSuccess);
// ロードに成功しているので取得に成功
Assert.True(game.GetScene(sce.InstanceGuid).IsSuccess);
Scene scene = new Scene();
Scene scene2 = new Scene();
Assert.True(game.LoadScene(scene).IsSuccess);
// 既に追加されているので失敗
Assert.False(game.LoadScene(scene).IsSuccess);
// ロードに成功しているので取得に成功
Assert.True(game.GetScene(scene.InstanceGuid).IsSuccess);
Assert.True(game.UnloadScene(scene).IsSuccess);
// 既にアンロードされているので失敗
Assert.False(game.UnloadScene(scene).IsSuccess);
// アンロードされているので取得に失敗
Assert.False(game.GetScene(scene.InstanceGuid).IsSuccess);
Assert.True(game.LoadScene(scene).IsSuccess);
Assert.True(game.GetScene(scene.InstanceGuid).IsSuccess);
Assert.True(game.LoadScene(scene2).IsSuccess);
Assert.True(game.GetScene(scene2.InstanceGuid).IsSuccess);
Assert.True(game.UnloadScenes());
// 全てアンロードしたので失敗
Assert.False(game.GetScene(scene.InstanceGuid).IsSuccess);
Assert.False(game.GetScene(scene2.InstanceGuid).IsSuccess);
game.LoadScene(scene);
game.LoadNextScene(scene2);
// 前にロードしたシーンの取得に失敗
Assert.False(game.GetScene(scene.InstanceGuid).IsSuccess);
// 新しくロードしたシーンの取得に成功
Assert.True(game.GetScene(scene2.InstanceGuid).IsSuccess);
// イベントの呼び出しチェック
Assert.True(count == 1);
}
private void bPlayLocal_Click(object sender, EventArgs e)
{
InGameForm ingameForm = new FormsPrototype.InGameForm(null, null, null);
LocalGame game = GameBuilder.CreateLocalGame()
.BlackPlayer(CreateAgentFromComboboxObject(ingameForm, this.cbBlack.SelectedItem, StoneColor.Black))
.WhitePlayer(CreateAgentFromComboboxObject(ingameForm, this.cbWhite.SelectedItem, StoneColor.White))
.Ruleset(RulesetType.Chinese)
.Komi(7.5f)
.BoardSize(new GameBoardSize((int)this.nLocalBoardSize.Value))
.Build();
ingameForm.LoadGame(game);
ingameForm.Show();
}
public void FinishGame_WrongGameId_GameIsNotRemoved()
{
// Arrange
var game = GameBuilder.Build("Team1", 4, "Team2", 3, 1);
service.ActiveGames.Add(game);
// Act
var result = service.FinishGame(game.Id + 1);
// Assert
Assert.False(result);
Assert.Single(service.ActiveGames);
}
public void TestBuilder()
{
GameBuilder g = GameBuilder.create();
g = g.board(GameBuilder.LitMap).player1("francois", "human").player2("aurelien", "orc");
Game tg = g.build();
Assert.IsNotNull(tg);
Assert.AreEqual(tg.current.name, "francois");
Assert.AreEqual(tg.map.tiles.Length, GameBuilder.LitMap * GameBuilder.LitMap);
Assert.AreEqual(tg.players[0].points, 0);
Assert.AreEqual(tg.saveStates.states.Count, 0);
}
private void InitializeTestData(out Game game, out Comment comment)
{
var gameBuilder = new GameBuilder();
var commentBuilder = new CommentBuilder();
game = gameBuilder.WithId(new Guid("2245390a-6aaa-4191-35f5-08d7223464b8")).WithKey("c21")
.WithName("Cry Souls").WithDescription("Cry Souls desc").WithUnitsInStock(10).WithPrice(10)
.WithPublisher("Unknown").Build();
comment = commentBuilder.WithId(new Guid("fec459ec-ede8-4ab9-b0e2-b3819f0a09b9")).WithName("CommentAuthor1")
.WithBody("Comment body1")
.WithGameId(new Guid("2245390a-6aaa-4191-35f5-08d7223464b8"))
.Build();
}
// Start is called before the first frame update
void Start()
{
// finds the game builder.
if (builder == null)
{
builder = FindObjectOfType <GameBuilder>();
}
// finds title object.
if (titleObject == null)
{
titleObject = GameObject.Find("Title");
}
}
public void Create_BuildsGameOfAGivenSize(int width, int height)
{
A.CallTo(() => _pathFinder.FindPath(width, height)).Returns(new SuggestedPath { MinimumRequiredPieces = 3 });
A.CallTo(() => _categoriesProvider.DrawTile()).WithAnyArguments().Returns(new DominoTile("FAKE", "FAKE"));
var builder = new GameBuilder(_pathFinder);
var game = builder.Create(width, height, 0, _categoriesProvider);
Assert.Equal(width, game.Width);
Assert.Equal(height, game.Height);
}
