public ClientInitializationView(GameStartMode startMode)
{
InitializeComponent();
this.startMode = startMode;
pnlDeck.Visible = startMode == GameStartMode.NewGame;
btnBrowseDecks.Click += new EventHandler(btnBrowseDecks_Click);
btnOk.Click += new EventHandler(btnOk_Click);
btnCancel.Click += new EventHandler(btnCancel_Click);
Localize();
}
public static void Start(GameStartMode mode)
{
switch (mode)
{
case GameStartMode.SinglePlayer:
MSGBox.ShowMSGBox("New singleplayer game", "Size:", MSGBoxType.SizeInput, new EventHandler <string>(delegate(object s, string inp)
{
int input = int.Parse(inp);
if (input > 5)
{
GameRenderer.Panel.CreateGraphics().FillRectangle(new SolidBrush(Color.Black), new Rectangle(new Point(), GameRenderer.Panel.Size));
//int xy = GameRenderer.Panel.Size.Width / input;
//GameSize = new Point(xy, xy);
if (GameRenderer.Panel.Size.Width / input < 3 || GameRenderer.Panel.Size.Height / input < 3)
{
Game.Paused = true;
return;
}
GameSize = new Point(GameRenderer.Panel.Size.Width / input, GameRenderer.Panel.Size.Height / input);
Game.Reset();
Form1.TimerEnabled = true;
}
else
{
Game.Paused = true;
}
}));
break;
case GameStartMode.MultiPlayer:
if (Game.Player.Name == "Player")
{
MSGBox.ShowMSGBox("Please change your username from default.", "", MSGBoxType.Text);
break;
}
MSGBox.ShowMSGBox("New multiplayer game", "Name:\nMax. players:", MSGBoxType.MultipleInput, new EventHandler <string>(delegate(object s, string input)
{
string[] strs = input.Split('\n');
int num = 0;
if (int.TryParse(strs[1], out num))
{
var match = new NetMatch {
Name = strs[0], MaxPlayers = num, OwnerIP = Network.GetIPs(), OwnerName = Player.Name
};
match.Players.Add(Game.Player);
Game.Reset();
Network.CreateGame(match);
}
else
{
Game.Paused = true;
}
}));
break;
case GameStartMode.Connect:
if (Game.Player.Name == "Player")
{
MSGBox.ShowMSGBox("Please change your username from default.", "", MSGBoxType.Text);
break;
}
//string matches = Network.Matches.Combine<NetMatch, string>((match, combiner) => combiner += match.Name + " " + match.Players.Count + "/" + match.MaxPlayers + " " + match.OwnerName + "\n");
string inputs = "IP:";
MSGBox.ShowMSGBox("Connect to game", inputs, MSGBoxType.MultipleInput, new EventHandler <string>(delegate(object s, string input)
{
IPAddress address;
if (IPAddress.TryParse(input.Replace("\n", ""), out address))
{
Game.Reset();
Network.Connect(new NetMatch {
OwnerIP = new IPAddress[] { address }
});
//Game.Reset(false); - On successfull connect event
}
else
{
Game.Paused = true;
}
}));
break;
default:
throw new ArgumentException();
}
}
public IClientInitializationView CreateClientInitializationView(GameStartMode startMode)
{
return new ClientInitializationView(startMode);
}
private void btnExercise_ClickAnimationFinished(object sender)
{
GameMode = GameStartMode.exercise;
SwitchScreen(screenGameSettings);
}
private void btnStartBattle_ClickAnimationFinished(object sender)
{
GameMode = GameStartMode.battle;
SwitchScreen(screenGameSettings);
}
public void StartServerGame(GameStartMode startMode)
{
PlayerInfo thisPlayer = CreateLocalPlayerInfo();
// ---------------------------------------------------------------
// choose game parameters or pick a saved game and start to listen
// ---------------------------------------------------------------
ServerStartNewGameModel newGameData = null;
ServerStartSavedGameModel savedGameData = null;
ServerListener listener = new ServerListener(thisPlayer, servicesProvider, SettingsManager.Settings.ListenPort);
try
{
bool proceed = false;
switch(startMode)
{
case GameStartMode.NewGame:
{
var initView = viewFactory.CreateServerStartNewGameView();
var initModel = new ServerStartNewGameModel();
var initController = new ServerStartNewGameController(initModel, initView, listener, servicesProvider);
initController.DeckRoomRequest += new Func<DeckItem>(initController_DeckRoomRequest);
if(initView.ShowModal() == ViewResult.Ok)
{
proceed = true;
initModel.Deck.MainCards.Shuffle();
newGameData = initModel;
}
}
break;
case GameStartMode.SavedGame:
{
var initView = viewFactory.CreateServerStartSavedGameView();
var initModel = new ServerStartSavedGameModel();
var initController = new ServerStartSavedGameController(initModel, initView, listener, servicesProvider);
if(initView.ShowModal() == ViewResult.Ok)
{
proceed = true;
savedGameData = initModel;
}
}
break;
}
if(proceed)
{
// ---------------------------------------------------------------------------------
// open room, wait other players and chat (obtain clients channels and players list)
// ---------------------------------------------------------------------------------
var serverStarterModel = new ServerStarterModel(thisPlayer);
var serverStarterView = viewFactory.CreateServerStarterView();
proceed = false;
using(NetCommandHandler<IGameStarterModel> commandHandler = new NetCommandHandler<IGameStarterModel>(serverStarterModel, thisPlayer.NickName))
{
var serverStarterController = new ServerStarterController(commandHandler, serverStarterModel, listener,
serverStarterView, thisPlayer, servicesProvider, startMode, newGameData, savedGameData);
listener.Console = serverStarterModel.Console;
proceed = serverStarterView.ShowModal() == ViewResult.Ok;
}
if(proceed)
{
// ----------
// start game
// ----------
listener.Console = null;
listener.GameIsRunning = true;
switch(startMode)
{
case GameStartMode.NewGame:
{
var players = CreatePlayerAccounts(thisPlayer.NickName, serverStarterModel.Players.ToList());
for(int i = 0; i < listener.PlayerConnections.Count; i++)
players[i+1].Channel = listener.PlayerConnections[i].NetClient;
StartGame(players, null, GameType.Host);
}
break;
case GameStartMode.SavedGame:
{
var players = CreatePlayerAccounts(thisPlayer.NickName, serverStarterModel.SavedGame);
for(int i = 0; i < listener.PlayerConnections.Count; i++)
players[i+1].Channel = listener.PlayerConnections[i].NetClient;
StartGame(players, serverStarterModel.SavedGame, GameType.Host);
}
break;
}
}
}
}
finally
{
if(listener.IsStarted)
listener.Stop();
}
}
public void StartClientGame(GameStartMode startMode)
{
PlayerInfo thisPlayer = CreateLocalPlayerInfo();
// ----------------------------------------------------------
// choose game parameters and connect (obtain server channel)
// ----------------------------------------------------------
ClientConnector connector = new ClientConnector(thisPlayer, servicesProvider);
try
{
var initView = viewFactory.CreateClientInitializationView(startMode);
var initModel = new ClientInitializationModel();
var initController = new ClientInitializationController(initModel, initView, thisPlayer, connector, servicesProvider);
initController.DeckRoomRequest += new Func<DeckItem>(initController_DeckRoomRequest);
if(initView.ShowModal() == ViewResult.Ok)
{
// ------------------------------------------------------------
// open room, wait other players and chat (obtain players list)
// ------------------------------------------------------------
var clientStarterModel = new ClientStarterModel(thisPlayer, initModel.Deck, servicesProvider);
var clientStarterView = viewFactory.CreateClientStarterView();
bool proceed = false;
using(var commandHandler = new NetCommandHandler<IGameStarterModel>(clientStarterModel, thisPlayer.NickName))
{
commandHandler.AddChannel(initModel.ServerData.Channel, initModel.ServerData.Player.NickName);
var clientStarterController = new ClientStarterController(commandHandler, clientStarterModel, connector, clientStarterView, servicesProvider, initModel);
proceed = clientStarterView.ShowModal() == ViewResult.Ok;
}
if(proceed)
{
// ----------
// start game
// ----------
switch(startMode)
{
case GameStartMode.NewGame:
{
var players = CreatePlayerAccounts(thisPlayer.NickName, clientStarterModel.Players.ToList());
players.Single(e => e.Info.NickName == initModel.ServerData.Player.NickName).Channel = initModel.ServerData.Channel;
StartGame(players, null, GameType.Client);
}
break;
case GameStartMode.SavedGame:
{
var players = CreatePlayerAccounts(thisPlayer.NickName, clientStarterModel.SavedGame);
players.Single(e => e.Info.NickName == initModel.ServerData.Player.NickName).Channel = initModel.ServerData.Channel;
StartGame(players, clientStarterModel.SavedGame, GameType.Client);
}
break;
}
}
}
}
finally
{
if(connector.IsConnected)
connector.Disconnect();
}
}
public void Start(bool passwordRequired, DeckItem deck, GameStartMode startMode)
{
this.startMode = startMode;
this.passwordRequired = passwordRequired;
this.deck = deck;
netMessageService.ClientConnected += new Action<object, ServiceNetClient>(netMessageService_ClientConnected);
netMessageService.Start();
}
public bool Connect(IPAddress address, int port, string password, GameStartMode startMode, DeckItem deck,
out string errorMessage, out ServerData opponentData)
{
bool confirmed = false;
errorMessage = string.Empty;
opponentData = null;
ServiceNetClient client = new ServiceNetClient(address, port);
client.Disconnected += new EventHandler(client_Disconnected);
connectionMessagesHandler = new ClientConnectionMessagesHandler(client);
try
{
client.Subscribe();
Version clientVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
HandshakeRequest handshake = new HandshakeRequest()
{
PlayerInfo = playerInfo,
Deck = new DeckDataContract(deck),
StartMode = startMode,
GameDatabaseCRC = servicesProvider.GameDatabaseCrc,
CardDatabaseCRC = servicesProvider.CardDatabaseCrc,
ClientVersion = clientVersion.ToString(),
Password = password,
};
Thread.Sleep(100);
client.SendMessage(handshake);
if(!WaitForHandshakeResponse())
throw new Exception("Opponent handshake not received!");
if(connectionMessagesHandler.Handshake.ConnectionResult != ConnectionResult.Accepted)
{
switch(connectionMessagesHandler.Handshake.ConnectionResult)
{
case ConnectionResult.VersionMismatch:
errorMessage = servicesProvider.SystemStringsService.GetString("NEW_SERVER_GAME_DIALOG", "MSG_CONNECTIONREFUSED_VERSIONMISMATCH");
break;
case ConnectionResult.GameIsRunning:
errorMessage = servicesProvider.SystemStringsService.GetString("NEW_SERVER_GAME_DIALOG", "MSG_CONNECTIONREFUSED_GAMEISRUNNING");
break;
case ConnectionResult.InvalidStartMode:
errorMessage = servicesProvider.SystemStringsService.GetString("NEW_SERVER_GAME_DIALOG", "MSG_CONNECTIONREFUSED_INVALIDSTARTMODE");
break;
case ConnectionResult.NicknameDuplicated:
errorMessage = servicesProvider.SystemStringsService.GetString("NEW_SERVER_GAME_DIALOG", "MSG_CONNECTIONREFUSED_NICKNAMEDUPLICATED");
break;
case ConnectionResult.GameDatabaseMismatch:
errorMessage = servicesProvider.SystemStringsService.GetString("NEW_SERVER_GAME_DIALOG", "MSG_CONNECTIONREFUSED_GAMEDATAMISMATCH");
break;
case ConnectionResult.CardDatabaseMismatch:
errorMessage = servicesProvider.SystemStringsService.GetString("NEW_SERVER_GAME_DIALOG", "MSG_CONNECTIONREFUSED_CARDDATAMISMATCH");
break;
case ConnectionResult.PasswordRequired:
errorMessage = servicesProvider.SystemStringsService.GetString("NEW_SERVER_GAME_DIALOG", "MSG_CONNECTIONREFUSED_PASSWORDREQUIRED");
break;
}
}
else
{
Thread.Sleep(100);
client.SendMessage(new ConfirmMessage());
opponentData = new ServerData()
{
Channel = client,
Player = connectionMessagesHandler.Handshake.PlayerInfo,
Deck = new DeckItem(connectionMessagesHandler.Handshake.Deck)
};
confirmed = true;
}
}
catch(Exception ex)
{
errorMessage = ex.Message;
}
finally
{
connectionMessagesHandler.Dispose();
}
return confirmed;
}
