/// <summary>
/// Creates a GameWindow containing the given game View control.
/// </summary>
public GameWindow(IWpfGameFactory factory, NumberOfPlayers players)
{
// Set the DynamicResource named GameView to the given control.
var gameView = factory.CreateGameView(players);
this.Resources.Add("GameView", gameView.ViewControl);
this.Resources.Add("ViewModel", gameView.ViewModel);
// Register an event handler for when the game is finished.
gameView.ViewModel.GameFinished += ViewModel_GameFinished;
InitializeComponent();
// Set up bindings manually -- there are ways to do this in XAML, but I want to demonstrate the C# equivalent.
mAdvantageLabel.SetBinding(Label.ContentProperty,
new Binding()
{
Path = new PropertyPath("BoardAdvantage"),
Converter = factory.CreateBoardAdvantageConverter()
}
);
mPlayerLabel.SetBinding(Label.ContentProperty,
new Binding()
{
Path = new PropertyPath("CurrentPlayer"),
Converter = factory.CreateCurrentPlayerConverter()
}
);
}
public StartGamePayload(int agentId,
int[] alliesIds,
int leaderId,
int[] enemiesIds,
TeamId teamId,
Point boardSize,
int goalAreaHeight,
int numberOfAllies,
int numberOfEnemies,
int numberOfPieces,
int numberOfGoals,
Dictionary <ActionType, TimeSpan> penalties,
float shamPieceProbability,
Point position)
{
NumberOfPlayers = new NumberOfPlayers();
AgentId = agentId;
AlliesIds = alliesIds;
LeaderId = leaderId;
EnemiesIds = enemiesIds;
TeamId = teamId;
BoardSize = boardSize;
GoalAreaHeight = goalAreaHeight;
NumberOfPlayers.Allies = numberOfAllies;
NumberOfPlayers.Enemies = numberOfEnemies;
NumberOfPieces = numberOfPieces;
NumberOfGoals = numberOfGoals;
Penalties = penalties;
ShamPieceProbability = shamPieceProbability;
Position = position;
}
public IWpfGameView CreateGameView(NumberOfPlayers players)
{
var view = new OthelloView();
view.OthelloViewModel.Players = players;
return(view);
}
public IWpfGameView CreateGameView(NumberOfPlayers players)
{
var view = new UserControl1();
view.ChessViewModel.Players = players;
return(view);
}
public IWpfGameView CreateGameView(NumberOfPlayers players)
{
var view = new TicTacToeView();
view.TicTacToeViewModel.Players = players;
return(view);
}
public MainWindow(IGameType gameType, NumberOfPlayers players)
{
var viewAndViewModel = gameType.CreateViewAndViewModel(players);
this.Resources.Add("GameView", viewAndViewModel.Item1);
this.Resources.Add("ViewModel", viewAndViewModel.Item2);
InitializeComponent();
mScoreLabel.SetBinding(Label.ContentProperty,
new Binding()
{
Path = new PropertyPath("BoardValue"),
Converter = gameType.CreateBoardValueConverter()
}
);
mPlayerLabel.SetBinding(Label.ContentProperty,
new Binding()
{
Path = new PropertyPath("CurrentPlayer"),
Converter = gameType.CreateCurrentPlayerConverter()
}
);
viewAndViewModel.Item2.GameFinished += ViewModel_GameFinished;
}
public Tuple <Control, IGameViewModel> CreateViewAndViewModel(NumberOfPlayers players)
{
var view = new OthelloView();
var model = view.Model;
model.Players = players;
return(new Tuple <Control, IGameViewModel>(view, model));
}
// Private Constructor
private SceneManager()
: base()
{
this.activeScene = null;
this.totalNumberOfPlayers = NumberOfPlayers.One;
this.colliderToggleKey = Azul.AZUL_KEYS.KEY_D;
this.internalClock = 0.0f;
this.globalHighScore = 0;
this.cachedPlayerOneScore = 0;
this.cachedPlayerTwoScore = 0;
}
public Game(NumberOfPlayers numPlayers)
{
NumberOfPlayers = numPlayers;
CurrentRound = 1;
CurrentPhase = Phase.Placement;
Players = new List<Player>();
for (int i = 0; i < (int)numPlayers; i++)
{
Players.Add(new Player());
}
StartPlayer = Players[0];
CurrentTurnPlayer = StartPlayer;
}
void OnMouseUp()
{
if (!IsTimed)
{
if (numberOfPlayers != null)
{
NumberOfPlayers numPlayerScript = (NumberOfPlayers)numberOfPlayers.GetComponent <NumberOfPlayers>();
numPlayerScript.twoPlayer = twoPlayer;
}
Application.LoadLevel(WhichLevel); // if it starts over destroy score and numberofplayers objects
if (WhichLevel == 0)
{
Destroy(GameObject.Find("Score"));
Destroy(numberOfPlayers);
}
}
}
public async Task TestAcceptMessageStartGameShouldSetFields()
{
int agentID = 1;
int leaderId = 1;
Team teamId = Team.Red;
int[] alliesId = new int[1] {
2
};
int[] enemiesId = new int[2] {
3, 4
};
BoardSize boardSize = new BoardSize {
X = 3, Y = 3
};
int goalAreaSize = 1;
NumberOfPlayers numberOfPlayers = new NumberOfPlayers {
Allies = 2, Enemies = 2
};
int numberOfPieces = 2;
int numberOfGoals = 2;
Penalties penalties = new Penalties()
{
Move = 100,
Ask = 100,
Response = 100,
Discovery = 100,
Pickup = 100,
CheckForSham = 100,
PutPiece = 100,
DestroyPiece = 100,
};
float shanProbability = 0.5f;
Position position = new Position {
X = 1, Y = 1
};
// Arrange
StartGamePayload startGamePayload = new StartGamePayload
{
AgentID = agentID,
AlliesIDs = alliesId,
LeaderID = leaderId,
EnemiesIDs = enemiesId,
TeamID = teamId,
BoardSize = boardSize,
GoalAreaSize = goalAreaSize,
NumberOfPlayers = numberOfPlayers,
NumberOfPieces = numberOfPieces,
NumberOfGoals = numberOfGoals,
Penalties = penalties,
ShamPieceProbability = shanProbability,
Position = position
};
Message startMessage = new Message(MessageID.StartGame, agentID, startGamePayload);
BufferBlock <Message> inputBuffer = new BufferBlock <Message>();
inputBuffer.Post(startMessage);
PlayerConfiguration configuration = GenerateSampleConfiguration();
var player = new Player.Models.Player(configuration, inputBuffer, new TcpSocketClient <Message, Message>(logger), logger);
// Act
bool expectedisLeader = true;
(int, int)expectedBoardSize = (boardSize.X, boardSize.Y);
(int, int)expectedPosition = (position.X, position.Y);
await player.AcceptMessage(CancellationToken.None);
var agentIDResult = player.GetValue <Player.Models.Player, int>("id");
var leaderIdResult = player.LeaderId;
var teamMatesResult = player.TeamMatesIds;
var isLeaderResult = player.IsLeader;
var teamResult = player.Team;
var boardSizeResult = player.BoardSize;
var penaltiesResult = player.PenaltiesTimes;
var positionResult = player.Position;
var enemiesResult = player.EnemiesIds;
var goalAreaSizeResult = player.GoalAreaSize;
var numOfPlayersResult = player.NumberOfPlayers;
var numOfPiecesResult = player.NumberOfPieces;
var numOfGoalsResult = player.NumberOfGoals;
var shamProbabilityResult = player.ShamPieceProbability;
// Assert
Assert.Equal(agentID, agentIDResult);
Assert.Equal(leaderId, leaderIdResult);
Assert.Equal(alliesId, teamMatesResult);
Assert.Equal(expectedisLeader, isLeaderResult);
Assert.Equal(teamId, teamResult);
Assert.Equal(expectedBoardSize, boardSizeResult);
Assert.True(penalties.AreAllPropertiesTheSame(penaltiesResult),
$"Penalties should be the same,\n expected: {penalties},\n actual {penaltiesResult}");
Assert.Equal(expectedPosition, positionResult);
Assert.Equal(enemiesId, enemiesResult);
Assert.Equal(goalAreaSize, goalAreaSizeResult);
Assert.True(numberOfPlayers.Allies == numOfPlayersResult.Allies &&
numberOfPlayers.Enemies == numOfPlayersResult.Enemies);
Assert.Equal(numberOfPieces, numOfPiecesResult);
Assert.Equal(numberOfGoals, numOfGoalsResult);
Assert.Equal(shanProbability, shamProbabilityResult);
}
/// <summary>
/// Sets the total number of players. This should only
/// be called by PlayerSelectScreen scene!
/// </summary>
/// <param name="howMany"></param>
public void SetNumberOfPlayers(NumberOfPlayers howMany)
{
this.totalNumberOfPlayers = howMany;
}
public void StartGame(NumberOfPlayers numberOfPlayers)
{
Game = new Game(numberOfPlayers);
}
private void Button_Click(object sender, RoutedEventArgs e)
{
NumberOfPlayers test = canvas1.Resources["numberOfPlayers"] as NumberOfPlayers;
test.Add(4);
}
// Use this for initialization
void Start()
{
numPlayers = FindObjectOfType <NumberOfPlayers>();
countDown = GetComponent <AudioSource>();
countDown.Play();
}
