// Use this for initialization
void Start()
{
XmasWorldBuilder builder = retreiveBuilderFromMap();
EventManager evtman = new EventManager();
ActionManager actman = new ActionManager(evtman);
XmasFactory factory = new GameFactory(actman);
engine = new XmasModel(builder, actman, evtman, factory);
}
// Use this for initialization
void Start()
{
gps = GameObject.Find ("GamePanelHolder").GetComponent<GamePanelScript> ();
gf = gameObject.GetComponent<GameFactory> ();
xreader = new XMLReader ();
taad = gameObject.GetComponent<TestAddAndDestroy> ();
gamesActive = new List<string> {"Auditiv","Kinæstetisk","Visuel","Taktil"};
tagFilter = new TagFilter ();
LoadAllXML ();
}
public SetupGameStuff(IDbContextLocator locator, IDbContextFactory factory,
INetworkContentSyncer networkContentSyncer, /* ICacheManager cacheMan, */
IGameLocker gameLocker, IStateHandler stateHandler, IAssemblyService ass) {
_locator = locator;
_factory = factory;
_networkContentSyncer = networkContentSyncer;
//_cacheMan = cacheMan;
_gameLocker = gameLocker;
_stateHandler = stateHandler;
_timer = new TimerWithElapsedCancellationAsync(TimeSpan.FromMinutes(30), onElapsedNonBool: OnElapsed);
_gameFactory = new GameFactory(ass);
}
public void RookCanMoveVertically()
{
for (int y = 1; y <= 8; y++)
{
if (y == 4)
{
continue;
}
char t = (char)(((int)'a') + (y - 1));
//Arrange
string testString = "WRd5";
var game = GameFactory.NewCustomGame(testString);
//Act
var updatedgame = game.Move("d5", string.Format("{0}5", t));
//Assert
var rook = updatedgame.GetBoard().Single(p => p.GetColor() == PieceColor.White && p.GetSymbol() == PieceSymbol.Rook && p.GetRank() == 5 && p.GetFile() == string.Format("{0}", t));
Assert.IsNotNull(rook);
}
}
public void PlayersJoinsLobby()
{
Randomizer rng = TestContext.CurrentContext.Random;
int gameId = rng.Next(1, 50000);
int gameOwnerId = rng.Next(1, 50000);
int secondPlayerId = rng.Next(1, 50000);
while (secondPlayerId == gameOwnerId)
{
secondPlayerId = rng.Next(1, 50000);
}
var gameInfo = CreateGameInfo(gameId, gameOwnerId);
var messenger = Substitute.For <IGameMessenger>();
var game = GameFactory.CreateNewGame(gameInfo);
game.JoinGame(secondPlayerId, messenger);
var state = game.GetGameState(gameOwnerId);
Assert.NotNull(state.LobbyState);
Assert.NotNull(state.LobbyState.ConnectedPlayers);
Assert.Contains(secondPlayerId, state.LobbyState.ConnectedPlayers);
}
public void moveScene()
{
if (GameFactory.getGame().localData.debug_room)
{
SceneManager.LoadScene("debug_room");
return;
}
switch (GameFactory.getGame().shareData.field.state)
{
case game.FIELD_STATE.EARLY_MORNING: SceneManager.LoadScene("early_morning"); break;
case game.FIELD_STATE.MORNING: SceneManager.LoadScene("morning"); break;
case game.FIELD_STATE.NOON: SceneManager.LoadScene("noon"); break;
case game.FIELD_STATE.NIGHT: SceneManager.LoadScene("night"); break;
case game.FIELD_STATE.MIDNIGHT: SceneManager.LoadScene("midnight"); break;
default:
break;
}
}
public void night_vote(Player myp)
{
List <int> koho = new List <int>();
foreach (var p in GameFactory.getGame().shareData.players.players)
{
if (p.fdead)
{
continue;
}
if (p.id == myp.id)
{
continue;
}
koho.Add(p.id);
}
int rand = MyRandom.rand(0, koho.Count - 1);
var dat = net.CreateStoryCode.NightVote(myp.id, koho[rand]);
new story.game2.Night().run(dat);
}
static void Main(string[] args)
{
Console.WriteLine("Game Starting");
_game = GameFactory.CreateGame(8, 8, "player 1", "player 2");
handlePlayerShipInput();
PrintBoard(true);
handlePlayerShipInput();
PrintBoard(false);
while (!_game.IsGameOver)
{
handlePlayerHitInput();
PrintBoard(true);
PrintBoard(false);
}
Console.WriteLine("Game over");
Console.WriteLine("Congratulation {0} , you are the winner", _game.CurrentPlayerName);
}
public ProfitAndLossReport(List <int> gameCodes) : base(null)
{
this.gameCodeList = gameCodes;
this.claimDetailsList = new Dictionary <string, object>();
this.earliestBetTimeYouMade = DateTime.Now;
this.latestBetTimeYouMade = DateTime.Now;
this.whenWasLastTimeYouWon = DateTimeConverterUtils.GetYear2011();
this.timesWonPerBetCombinationDict = new Dictionary <string, object>();
this.allBetsInTabularMode = new List <double[]>();
this.allBetsInTabularModeDaysOfWeek = new List <String[]>();
this.allBetsInTabularModePickGen = new List <String[]>();
this.allBetsInTabularModeOutlet = new List <String[]>();
this.allBetsInTabularModeWinningBet = new List <String[]>();
foreach (int gameCode in this.gameCodeList)
{
InitializesAllValues(new LotteryDataServices(GameFactory.GetInstance(gameCode)));
}
GetTallyAllBetsInTabularMode(this.gameCodeList);
GetDaysOfWeekTallyAllBetsInTabularMode(this.gameCodeList);
GetDaysOfWeekTallyPickGen(this.gameCodeList);
GetOutletTally(this.gameCodeList);
GetWinningBetDigitTally(this.gameCodeList);
}
//=====================================
// state
//=====================================
public void updateDraw()
{
updateItemList();
updatePlayerList();
updateLog();
// dust box
{
string s = "";
s += "ダストボックス(" + game.db.Player.getStr(GameFactory.getGame().shareData.field.dustItem) + ")：";
s += "" + GameFactory.getGame().shareData.field.dustItems[(int)GameFactory.getGame().shareData.field.dustItem] + "枚";
GameObject.Find("MainUI/DustBox").GetComponent <Text>().text = s;
}
//start button
if (GameFactory.getGame().localData.fgm)
{
nextTurn.SetActive(true);
}
else
{
nextTurn.SetActive(false);
}
}
public void Remove_Board_From_DB()
{
using var db = new TestDatabase();
using var context = db.CreateContext();
var board = GameFactory.CreateBoard("myTestBoard");
board.Id = 1;
var greenPlayer = GameFactory.NewPlayer("greenPlayer", board, TokenColor.Green);
greenPlayer.Id = 1;
board.Players.Add(greenPlayer);
board.Players[0].Tokens[0].Id = 1;
context.Boards.Add(board);
context.SaveChanges();
context.Boards.Remove(board);
context.SaveChanges();
Assert.Null(context.Boards.FirstOrDefault());
Assert.Null(context.Players.FirstOrDefault());
Assert.Null(context.Tokens.FirstOrDefault());
}
// Use this for initialization
void Start()
{
GameFactory.getUnityManager().debug_room = this;
GameFactory.getGame().localData.debug_room = true;
GameObject canvasObject = GameObject.Find("Canvas");
GameObject original = GameObject.Find("Canvas/Player");
//var vec = original.transform.position;
//for (int i = 0; i < 10; i++)
for (int i = 0; i < GameFactory.getGame().shareData.players.players.Count; i++)
{
//GameObject copied = Instantiate(original, vec2, Quaternion.identity) as GameObject;
GameObject copied = Instantiate(original) as GameObject;
copied.transform.SetParent(canvasObject.transform, false);
//copied.transform.localPosition = Camera.main.ScreenToWorldPoint(copied.transform.localPosition);
copied.name = "Player" + i;
//copied.transform.Translate(0, - copied.GetComponent<SpriteRenderer>().bounds.size.y /10 * i, 0);
Vector3 v = copied.transform.position;
v.y -= 100.0f * i;
copied.transform.position = v;
//copied.transform.Translate(0, -5 * i, 0, Camera.main.transform);
// copied.transform.Translate(0, -5 * i, 0, Space.World);
//GameObject childObject = copied.transform.FindChild("Name").gameObject;
//childObject.transform.Translate(0, -i*10, 0);
objs.Add(copied);
var p = GameFactory.getGame().shareData.players.players[i];
updateDrawPlayer(copied, p);
}
original.SetActive(false);
updateDraw();
}
public void BishopCannotMoveAnywhereElse()
{
string[] validMoves = { "a4", "b5", "d7", "e8", "a8", "b7", "c6", "d5", "e4", "f3", "g2", "h1" };
//Arrange
string testString = "WBc6";
for (var r = 1; r <= 8; r++)
{
for (var f = 1; f <= 8; f++)
{
var game = GameFactory.NewCustomGame(testString);
var targetrank = r;
var targetfilenr = f;
char targetfile = (char)(((int)'a') + (targetfilenr - 1));
var target = string.Format("{0}{1}", targetfile, targetrank);
if (validMoves.Contains(target))
{
continue;
}
try
{
//Act
var updatedgame = game.Move("c6", target);
}
catch (Exception)
{
continue;
}
//Assert
Assert.Fail("No exception thrown");
}
}
}
public void GameCanLoadFile()
{
IPokerGame game;
Table table = new Table();
string fileName = "savedGame.txt";
string[] names = new string[2] {
"Test1", "Test2"
};
int[] wins = new int[2] {
7, 3
};
string json = JsonConvert.SerializeObject(names);
json += (" " + JsonConvert.SerializeObject(wins));
File.WriteAllText(fileName, json);
string Json = File.ReadAllText(fileName);
string[] data = Json.Split(' ');
string[] Names = JsonConvert.DeserializeObject <String[]>(data[0]);
int[] Wins = JsonConvert.DeserializeObject <int[]>(data[1]);
for (int i = 0; i < names.Length; i++)
{
table.AddPlayerToTable(names[i], wins[i]);
}
game = GameFactory.LoadGame(fileName);
Assert.AreEqual(game.Players[0].Name, "Test1");
Assert.AreEqual(game.Players[1].Name, "Test2");
Assert.AreEqual(game.Players[0].Wins, 7);
Assert.AreEqual(game.Players[1].Wins, 3);
}
public void FanRankFileAmbiguationPositiveTest()
{
// Tests both knights moving to same square for Rank ambiguity
const string fen = "8/6k1/8/8/8/8/1K1N1N2/8 w - - 0 1";
const MoveNotations notation = MoveNotations.Fan;
var movingPiece = new Piece(Pieces.WhiteKnight);
var fromOneSquare = new Square(Squares.d2);
var fromTwoSquare = new Square(Squares.f2);
var toSquare = new Square(Squares.e4);
var uniChar = movingPiece.GetUnicodeChar();
var toSquareString = toSquare.ToString();
var expectedPrimary = $"{uniChar}{fromOneSquare.FileChar}{toSquareString}";
var expectedSecondary = $"{uniChar}{fromTwoSquare.FileChar}{toSquareString}";
var board = new Board();
var pieceValue = new PieceValue();
var pos = new Position(board, pieceValue);
var g = GameFactory.Create(pos);
g.NewGame(fen);
var w1 = new Move(fromOneSquare, toSquare);
var w2 = new Move(fromTwoSquare, toSquare);
var ambiguity = new MoveAmbiguity(pos);
var actualPrimary = ambiguity.ToNotation(w1, notation);
var actualSecondary = ambiguity.ToNotation(w2, notation);
Assert.Equal(expectedPrimary, actualPrimary);
Assert.Equal(expectedSecondary, actualSecondary);
}
private void onKeyPress(object sender, KeyPressEventArgs e)
{
if (e.KeyChar == 'h')
{
serverGameFactory.Listen(Width, Height, newGame =>
{
this.gameFactory = serverGameFactory;
this.game = newGame;
});
MessageBox.Show("Waiting for second player.\nPlease. press ok to proceeded");
}
if (e.KeyChar == 'j')
{
JoinWindow joinWindow = new JoinWindow();
joinWindow.ShowDialog();
String address = joinWindow.HostAddress;
clientGameFactory.Join(Width, Height, address, newGame =>
{
this.gameFactory = clientGameFactory;
this.game = newGame;
});
}
if (e.KeyChar == 'r')
{
DialogResult result = MessageBox.Show("Are you sure want to restart game?", "Game restart", MessageBoxButtons.OKCancel);
if (result == DialogResult.OK)
{
restart();
}
}
}
public void GameIsOverOnlyWhenNeitherPlayerCanMoveOrPass()
{
var game1 = GameFactory.GetGame(2, 2);
Assert.IsTrue(game1.IsGameOver());
var game2 = GameFactory.GetGame(2, 4);
game2.LoadSerializedBoardState(
"0122" +
"1212");
Assert.AreEqual(0, game2.Moves.Count);
Assert.IsTrue(game2.IsPassValid());
game2.PassAsync().AsTask().Wait();
Assert.AreEqual(1, game2.Moves.Count);
Assert.AreEqual(null, game2.Moves[0]);
Assert.IsFalse(game2.IsGameOver());
Assert.IsFalse(game2.IsPassValid());
game2.MoveAsync(0, 0).AsTask().Wait();
Assert.AreEqual(2, game2.Moves.Count);
Assert.AreEqual(new Space(0, 0), game2.Moves[1]);
Assert.IsFalse(game2.IsPassValid());
Assert.IsTrue(game2.IsGameOver());
}
public void GameSaveAndExitAfterSave()
{
string fileName = "savedGame.txt";
IPokerGame Game;
Game = GameFactory.NewGame(new string[2] {
"Test1", "Test2"
});
game = (Game)Game;
Assert.IsTrue(game.GameIsRunning);
//act
game.SaveGameAndExit(fileName);
string Json = File.ReadAllText(fileName);
string[] data = Json.Split(' ');
string[] Names = JsonConvert.DeserializeObject <String[]>(data[0]);
int[] Wins = JsonConvert.DeserializeObject <int[]>(data[1]);
//assert
Assert.IsFalse(game.GameIsRunning);
Assert.AreEqual(Names[0], "Test1");
Assert.AreEqual(Names[1], "Test2");
Assert.AreEqual(Wins[0], 0);
Assert.AreEqual(Wins[1], 0);
}
public static void AddStandardEnemyQuater(string bulletType, int num)
{
Random _rand = new Random();
int direction = _rand.Next(2) % 2;
List <StandardEnemy> ses = new List <StandardEnemy>();
switch (direction)
{
case 0:
ses = GameFactory.CreateStandardEnemyQuaterRight("", 5);
break;
case 1:
ses = GameFactory.CreateStandardEnemyQuaterLeft("", 5);
break;
default:
break;
}
if (!IsUpdating)
{
foreach (var se in ses)
{
Entities.Add(se);
se.Add(Instance);
}
}
else
{
foreach (var se in ses)
{
AddedEntities.Add(se);
}
}
}
// create a new game for the connecting client
private void Communicate(IAsyncResult ar)
{
allDone.Set();
Console.WriteLine("Accepting new client");
Socket listener = (Socket)ar.AsyncState;
Socket handler = listener.EndAccept(ar);
Console.WriteLine($"Accept successful: {handler.RemoteEndPoint.ToString()}");
var boardState = BoardFactory.Standard();
var gameState = GameFactory.NewGame(boardState, serviceProvider);
try
{
ProcessRound(gameState, handler);
}
catch (SocketException e)
{
Console.WriteLine(e);
handler.Close();
}
}
/// <summary>
/// Reads the specified file and parses it to a game
/// </summary>
/// <param name="filePath">The filepath of the file to read</param>
/// <returns>A playable game</returns>
/// <exception cref="JsonException">Thrown if the provided level file is invalid</exception>
public static IGame Read(string filePath)
{
try
{
var rooms = new Dictionary <int, IRoom>();
var json = JObject.Parse(File.ReadAllText(filePath));
var connections = new Dictionary <int, List <IConnection> >();
SetRooms(json, connections, rooms);
SetConnections(json, connections, rooms);
var playerJToken = json["player"];
var playerStartLocation = EntityLocationFactory.CreateEntityLocation(rooms, playerJToken);
var player = PlayerFactory.CreatePlayer(playerJToken, playerStartLocation);
return(GameFactory.CreateGame(player));
}
catch (Exception e)
{
throw new JsonException("The provided JSON level file is not valid.", e);
}
}
public void PawnCannotMoveAnywhereElse()
{
//Arrange
string testString = "W d3";
for (var r = 1; r <= 8; r++)
{
for (var f = 1; f <= 8; f++)
{
var game = GameFactory.NewCustomGame(testString);
var targetrank = r;
var targetfilenr = f;
char targetfile = (char)(((int)'a') + (targetfilenr - 1));
var target = string.Format("{0}{1}", targetfile, targetrank);
if (target != "d4" && target != "d5")
{
continue;
}
try
{
//Act
var updatedgame = game.Move("d3", target);
}
catch (Exception)
{
continue;
}
//Assert
Assert.Fail("No exception thrown");
}
}
}
public JsonResult Play(Game game, int playCount = 1)
{
var serviceProvider = ServiceProviderFactory.GetServiceProvider(_messageSenderconfiguration);
var playerConfiguration = new PlayerConfiguration {
PlayerCount = 2
};
IGameState gameState = null;
for (var gamesPlayed = 0; gamesPlayed < playCount; gamesPlayed++)
{
switch (game)
{
case Game.Pandemic:
gameState = GameFactory.CreateGame <IPandemicState, IPandemicTurn>(serviceProvider, playerConfiguration).Play();
break;
case Game.ForSale:
gameState = GameFactory.CreateGame <IForSaleGameState, IForSaleGameTurn>(serviceProvider, playerConfiguration).Play();
break;
}
}
return(new JsonResult(gameState));;
}
public void init()
{
if (GameFactory.getNetworkManager().connected)
{
return;
}
if (GameFactory.getNetworkManager().fserver)
{
GameFactory.getNetworkManager().addMessage("サーバの作成開始");
//サーバーを立てる
// 接続可能人数,port,false
Network.InitializeServer(10, int.Parse(port), false);
Logger.info("NetworkManager.init():サーバを立てました。port=" + port);
}
else
{
GameFactory.getNetworkManager().addMessage("サーバへの接続開始");
Logger.info("NetworkManager.init():サーバへ接続開始。ip=" + ip + " port=" + port);
// クライアントの接続
Network.Connect(ip, int.Parse(port));
}
}
public KensikitResult usedKensikit(Player p)
{
if (p.fdead)
{
return(null);
}
if (p.getUseItem() != ITEM.KENSIKIT)
{
return(null);
}
KensikitResult result = new KensikitResult();
result.target = GameFactory.getGame().shareData.players.getPlayer(p.net_opp);
if (result.target.fdead)
{
result.reason = result.target.deadReason;
}
else
{
result.reason = DEAD_REASON.LIVE;
}
return(result);
}
public void MakeGame()
{
view = new View();
GameFactory factory = null;
bool modeSelected = false;
while (!modeSelected)
{
view.DrawString("enter 1 for mankala and 2 for wari");
int mode = 0;
try { mode = InputHelper.GetNumber(); view.Clear(); }
catch { view.DrawString("not a valid game mode"); }
switch (mode)
{
case 1:
factory = new MankalaFactory(); modeSelected = true; break;
case 2:
factory = new WariFactory(); modeSelected = true; break;
default:
view.DrawString("not a valid game mode"); break;
}
}
board = factory.MakeBoard(6);
players = factory.MakePlayers(board);
score = factory.MakeScore();
ruleset = factory.MakeRuleSet();
view.setBoard(board);
currentPlayer = 0;
}
public void FullBoardDeepCloneIsFull()
{
var context = new BoardProperties(4, 4, 5);
var positions = new PositionFactory().Create(context);
var patterns = new PatternFactory().Create();
var matcher = new PatternMatcher(patterns);
var boardFactories = new IBoardFactory[]
{
new BoardFactory(context, positions),
new PatternBoardFactory(context, positions, matcher)
};
foreach (var boardFactory in boardFactories)
{
IGame game = new GameFactory().CreateGame(
boardFactory,
new NextAvailablePlayer(positions),
new NextAvailablePlayer(positions),
new BasicJudge(context, positions)
);
game.Start();
foreach (var i in Enumerable.Range(0, context.RowSize * context.ColSize))
{
Assert.AreEqual(game.GameStatus, GameStatus.NotEnd);
game.Run();
}
Assert.AreEqual(game.GameStatus, GameStatus.Tie);
Assert.IsTrue(game.Board.IsFull());
var board2 = game.Board.DeepClone();
Assert.IsTrue(board2.IsFull());
}
}
static void Main(string[] args)
{
string mode = "";
Factory GameFactory;
// Instruction
Console.WriteLine("RAMPANT ROBOTS");
Console.WriteLine("Use the wasd-keys to move the mechanic (M) " +
"and try to oil all of the robots (R) in the factory!" + Environment.NewLine);
// Set difficulty
while (mode != "1" & mode != "2" & mode != "3")
{
Console.WriteLine("Choose 1 for Easy-Mode, 2 for Hard-Mode and 3 for Expert-Mode");
mode = Console.ReadLine();
}
if (mode == "1")
{
GameFactory = new Factory(5, 5, 3, 10, true);
}
else if (mode == "2")
{
GameFactory = new Factory(10, 10, 5, 10, true);
}
else
{
GameFactory = new Factory(25, 25, 10, 10, true);
}
// Start game
GameFactory.Run();
// Close application
Console.WriteLine("Press Enter to close");
Console.ReadLine();
}
// Use this for initialization
void Start()
{
GameFactory.getUnityManager().noon = this;
noon1_chara = new MyDropdownUnity(GameObject.Find("Canvas/Noon/Noon1/chara").GetComponent <Dropdown>());
noon4_item = new MyDropdownUnity(GameObject.Find("Canvas/Noon/Noon4/item").GetComponent <Dropdown>());
noon1 = GameObject.Find("Noon1");
noon2 = GameObject.Find("Noon2");
noon3 = GameObject.Find("Noon3");
noon4 = GameObject.Find("Noon4");
noon1.SetActive(false);
noon2.SetActive(false);
noon3.SetActive(false);
noon4.SetActive(false);
if (GameFactory.getGame().shareData.field.state != game.FIELD_STATE.NONE)
{
updateDraw(GameFactory.getUnityManager().firstUpdate);
}
}
// Use this for initialization
void Start()
{
GameFactory.getUnityManager().midnight = this;
mid1_item = new MyDropdownUnity(GameObject.Find("Canvas/Midnight/Midnight1/item").GetComponent<Dropdown>());
mid1_chara = new MyDropdownUnity(GameObject.Find("Canvas/Midnight/Midnight1/chara").GetComponent<Dropdown>());
for(int i=0;i< mid2_item.Length; i++)
{
mid2_item[i] = new MyDropdownUnity(GameObject.Find("Canvas/Midnight/Midnight2/item" + (i + 1)).GetComponent<Dropdown>());
}
midnight1 = GameObject.Find("Midnight1");
midnight2 = GameObject.Find("Midnight2");
midnight1.SetActive(false);
midnight2.SetActive(false);
if (GameFactory.getGame().shareData.field.state != game.FIELD_STATE.NONE)
{
updateDraw(GameFactory.getUnityManager().firstUpdate);
}
}
public async void StartGame()
{
GameOver = false;
if (clb_GameLevel.SelectedItem != null)
{
//Sets the level
switch (clb_GameLevel.SelectedItem.ToString())
{
case "Easy":
GameOverTime = new TimeSpan(0, 0, 0);
SequenceSpeed = 2;
LightIds = new List <int> {
10, 2, 3
};
LightSequence = new List <int>();
factory = new EasyGameFactory(GameOverTime, SequenceSpeed, LightIds, LightSequence);
break;
case "Normal":
GameOverTime = new TimeSpan(0, 0, 5);
SequenceSpeed = 1;
LightIds = new List <int> {
10, 2, 3, 4, 5, 6
};
LightSequence = new List <int>();
factory = new NormalGameFactory(GameOverTime, SequenceSpeed, LightIds, LightSequence);
break;
case "Hard":
GameOverTime = new TimeSpan(0, 0, 2);
SequenceSpeed = 0.5;
LightIds = new List <int> {
10, 2, 3, 4, 5, 6, 7, 8, 9
};
LightSequence = new List <int>();
factory = new HardGameFactory(GameOverTime, SequenceSpeed, LightIds, LightSequence);
break;
default:
break;
}
Game game = factory.GetGame();
//MessageBox.Show("Starting " + game.GameLevel + " game");
//Generate Light-Sequence
for (int i = 0; i < 3; i++)
{
int index = Random.Next(LightIds.Count);
game.LightSequence.Add(LightIds[index]);
//LightSequence.Add(Lights[index]);
}
/*Displays Light-Sequence
* string message = "";
* foreach (int num in LightSequence)
* {
* message += num.ToString();
* message += " ";
* }
* MessageBox.Show(message);*/
//While GameOver is false, keep playing
while (!GameOver)
{
//Executes LightSequence
foreach (int lightId in game.LightSequence)
{
Light light = new Light();
light.LightId = lightId;
light.SetLightOn();
await Task.Delay(new TimeSpan(0, 0, Convert.ToInt32(SequenceSpeed)));
light.SetLightOff();
}
//Trac Button-Sequence
//Code die de input van de speler checkt:
bool Mistake = false;
//--------------------------------------
if (!Mistake)
{
int index = Random.Next(LightIds.Count);
game.LightSequence.Add(LightIds[index]);
//LightSequence.Add(Lights[index]);
ScorePoints += 1;
lbl_ScorePoints.Text = ScorePoints.ToString();
}
else
{
GameOver = true;
EndGame();
}
}
}
else
{
MessageBox.Show("No level selected... Select a level to start the game");
}
}
public MainPage()
{
InitializeComponent();
factory = null;
}
public DungeonMaster()
{
this.gameData = GameFactory.GetInstance().TheData;
this.gameClient = GameFactory.GetInstance().TheClient;
playerTurnHandler = new CommandHandler();
}
public GameRepository(GameFactory gameFactory)
{
this._gameFactory = gameFactory;
this._games = new ConcurrentDictionary<string, IGame>();
}
