private void SendGamePlayersHp(NetworkClient client)
{
SendToClient(
client,
$"GAME_PLAYERS_HP_UPDATE:{string.Join(' ', GamePlayers.Select(player => player.Hp))}"
);
}
/// <summary>
/// Возвращает карты игрока
/// </summary>
/// <param name="playerId"></param>
/// <param name="cardIds"></param>
/// <returns></returns>
public IReadOnlyCollection <IPlayingCardInfo> GetPlayerCards(Guid playerId, IReadOnlyCollection <int> cardIds = null)
{
if (cardIds == null)
{
throw new ArgumentNullException(nameof(cardIds));
}
if (!IsStarted)
{
throw new TrueFalseGameException("Игра еще не началась. Карты не розданы");
}
if (IsEnded)
{
throw new TrueFalseGameException("Игра уже закончилась");
}
var gamePlayer = GamePlayers.FirstOrDefault(gp => gp.Player.Id == playerId);
if (gamePlayer == null)
{
throw new TrueFalseGameException($"Игрока с Id = {playerId} нет за игровым столом");
}
if (cardIds != null)
{
return(gamePlayer.Cards.Where(c => cardIds.Contains(c.Id)).ToList());
}
return(gamePlayer.Cards);
}
public override void OnStopServer()
{
OnServerStopped?.Invoke();
RoomPlayers.Clear();
GamePlayers.Clear();
}
public Player(string name, GamePlayers PlayerType)
{
this.Name = name;
this.PlayerType = PlayerType;
Score = 0;
Choice = GameChoices.None;
}
public void EndGame()
{
State = (int)GameState.Finished;
DateFinished = DateTime.Now;
DurationInSeconds = (DateFinished - DateStarted).TotalSeconds;
Winner = GamePlayers.Single(gp => gp.NumberOfDice > 0).Player.Username;
}
void SetPlayerNumbers()
{
string[] forcedPlayers = ForcePlayers.Split(',');
if (forcedPlayers.Length <= 1)
{
List <string> playersList = GamePlayers.Keys.ToList();
foreach (int akt in Enumerable.Range(1, playersList.Count))
{
int playerIdx;
do
{
playerIdx = R.Next(playersList.Count);
} while (GamePlayers[playersList[playerIdx]].PlayerNumber > 0);
GamePlayers[playersList[playerIdx]].PlayerNumber = akt;
}
}
else
{
for (int i = 0; i < forcedPlayers.Length; i++)
{
if (GamePlayers.ContainsKey(forcedPlayers[i]))
{
GamePlayers[forcedPlayers[i]].PlayerNumber = i + 1;
}
}
}
foreach (Player aktPlayer in GamePlayers.Values)
{
TakePlanets(aktPlayer);
}
}
private void OnServerNotification(object sender, NetComms.NotificationEventArgs e)
{
Logger.Log("NetClientWorld.OnServerNotification");
try
{
// Skip if no type
if (e.Notification.Length == 0)
{
return;
}
// Get the packet type
var type = e.Notification[0];
// Get the payload JSON
var payloadJson = Encoding.ASCII.GetString(e.Notification, 1, e.Notification.Length - 1);
lock (WorldLock)
{
switch (type)
{
case NetConstants.PlayersPacket:
{
var newPlayers = GamePlayers.FromJson(payloadJson);
Logger.Log("NetClientWorld.OnServerNotification - got players");
// If we have a local player then synchronize with new data
if (LocalPlayer != null)
{
// Find if the server has any new information
var serverPlayer = newPlayers.Players.FirstOrDefault(p => p.Guid == LocalPlayer.Guid);
if (serverPlayer != null)
{
LocalPlayer.Type = serverPlayer.Type;
}
}
// Write the new players
UpdatePlayers(newPlayers);
break;
}
case NetConstants.StatePacket:
{
var newState = GameState.FromJson(payloadJson);
Logger.Log("NetClientWorld.OnServerNotification - got state");
// Write the new game state
UpdateState(newState);
break;
}
}
}
}
catch (Exception ex)
{
Logger.Log($"NetClientWorld.OnServerNotification - failed with {ex}", ex);
}
}
public GameFlow()
{
gm = new GamePlayers()
{
IsPlayer1 = false, Player1 = new Player(), Player2 = new Player()
};
}
public virtual void Start(StartGameParameters parameters)
{
Calendar = new Calendar( );
GameRule = parameters.EnviromentSetting;
StartMoney = parameters.StartMoney;
GameLenth = parameters.GameTime;
foreach (Tuple <PlayerModelProxy, PlayerConsole> item in parameters.PlayerConfig)
{
Player player = new Player(item.Item1.Model, StartMoney);
player.BankruptcyEvent += OnPlayerBankruptcy;
GamePlayers.Add(player);
break;
}
Calendar = new Calendar( );
Map = parameters.Map;
StockMarket = new StockMarket( );
WinningCondition = parameters.WinningCondition;
Status = GameStatus.Playing;
}
public virtual void NextDay( )
{
#region End Today
foreach (Buff buff in GameBuffs)
{
buff.EndToday( );
}
foreach (Player player in GamePlayers)
{
player.EndToday( );
}
Map.EndToday( );
StockMarket.EndToday( );
Calendar.EndToday( );
#endregion
List <Player> winners = GamePlayers.Where(player => WinningCondition.IsWin(player)).ToList( );
if (winners.Any( ))
{
GameResult info = new GameResult {
Winers = winners
};
GameOver(info);
}
}
public async Task <IActionResult> Edit(Guid id, [Bind("Id")] GamePlayers gamePlayers)
{
if (id != gamePlayers.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(gamePlayers);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!GamePlayersExists(gamePlayers.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(gamePlayers));
}
public async Task <IActionResult> SavePoints(int id, [Bind("PlayerId,FirstName,LastName")] GamePlayers playerModel)
{
if (id != playerModel.PlayerId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_showViewsRepo._db.GamePlayers.Update(playerModel);
_showViewsRepo._db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
return(RedirectToAction(nameof(Index)));
}
return(View("Index", new RoundViewModel()
{
CurrentGame = playerModel.Game
}));
}
public ComputerPong()
{
myLatestSave = new SaveGame();
mySaveGameXML = new XMLHelper<SaveGame>();
myGameTime = DateTime.Now;
//Transition Time
TransitionOnTime = TimeSpan.FromSeconds(mySettings.TransitionOnTime);
TransitionOffTime = TimeSpan.FromSeconds(mySettings.TransitionOffTime);
//Load Player Info
myPlayers = new GamePlayers();
myPlayersXML = new XMLHelper<GamePlayers>();
myPlayersXML.Load(ref myPlayers);
//Load GameHistory
myGameHistoryXML = new XMLHelper<GameHistory>();
myGameList = new GameHistory();
myGameHistoryXML.Load(ref myGameList);
//Load Game Objects
ObstaclePosition = new Obstacle(mySettings.MaxWidth / 2 - 10, mySettings.MaxHeight / 2 - 80);
BallPosition = new Ball(mySettings.MaxWidth / 2 - 10, mySettings.MaxHeight / 2 - 10);
RightPaddlePosition = new Paddle(mySettings.MaxWidth - 25, mySettings.MaxHeight / 2 - 40, mySettings.PaddleMoveFactor);
LeftPaddlePosition = new Paddle(10, mySettings.MaxHeight / 2 - 40, mySettings.PaddleMoveFactor);
playerPosition = new Vector2(mySettings.InitPosX, mySettings.InitPosY);
enemyPosition = new Vector2(mySettings.InitPosX, mySettings.InitPosY);
//Check if Both Users are In System or if Quick Play is Enabled
if (myPlayers.myPlayers.Length != mySettings.NumberOfPlayers && !mySettings.QuickPlay)
throw new Exception("There Need to be " + mySettings.NumberOfPlayers + " Active users in the system");
}
public static void ResetScreen(Player[] player)
{
GamePlayers gs = new GamePlayers();
Console.Clear();
ControlOutput.ShowHeader();
ControlOutput.ShowPlayers(player);
}
public ReversedTicTacToe()
{
m_UI = new WindowsUI(k_WindowTitle, new PositiveRange(k_MinBoardSize, k_MaxBoardSize));
m_GamePlayers = GamePlayers.CreateFromGameType(m_UI.InitialParams.GameType, m_UI.InitialParams.PlayerNames);
m_UI.RegisterOnInput(this.windowsUI_BoardCellChosen);
m_UI.InitWindow(m_GamePlayers);
startNewGame();
}
public void AddPlayer(Player newPlayer)
{
if (newPlayer != null && newPlayer.PlayerClient != null)
{
newPlayer.InitMap(SizeX, SizeY);
newPlayer.PlayerClient.GiveMapSizeToClient(SizeX, SizeY);
GamePlayers.Add(newPlayer.PlayerClient.ClientName, newPlayer);
}
}
public void UpdatePlayersStats(GamePlayers i_GamePlayers)
{
for (uint i = 0; i < i_GamePlayers.Length; i++)
{
GamePlayer currPlayer = i_GamePlayers.Get(i);
r_GameWindow.UpdatePlayerStat(i, currPlayer.Score);
}
}
/// <summary>
/// Устанавливает следующего ходящего
/// </summary>
/// <param name="loser"></param>
private void SetNextMover(GamePlayer loser = null)
{
if (CurrentMover == null)
{
CurrentMover = GamePlayers.First(p => p.Priority == GamePlayers.Min(pm => pm.Priority)).Player;
}
else if (loser == null || loser.Player.Id == CurrentMover.Id)
{
CurrentMover = GetNextMover().Player;
}
}
/// <summary>
/// The current player takes. If the player is the second to play, also resets both player scores and adds the correct number of tokens.
/// </summary>
public void CurrentPlayerTakes()
{
Dice1.Checked = false;
Dice2.Checked = false;
Dice3.Checked = false;
// If both players played.
if (GamePlayers.GamePlayers[0].DiceRoll > 0 && GamePlayers.GamePlayers[1].DiceRoll > 0)
{
// If the first has the biggest combination.
if (GamePlayers.GamePlayers[0].Combi.Priority > GamePlayers.GamePlayers[1].Combi.Priority)
{
/*GamePlayers.GamePlayers[1].Tokens += GamePlayers.GamePlayers[0].Combi.TokenValue;
* Tokens -= GamePlayers.GamePlayers[0].Combi.TokenValue;*/
ProcessTokenMovement(GamePlayers.GamePlayers[1], GamePlayers.GamePlayers[0].Combi.TokenValue);
}
else if (GamePlayers.GamePlayers[0].Combi.Priority < GamePlayers.GamePlayers[1].Combi.Priority) // If the second has the biggest combination.
{
/*GamePlayers.GamePlayers[0].Tokens += GamePlayers.GamePlayers[0].Combi.TokenValue;
* Tokens -= GamePlayers.GamePlayers[0].Combi.TokenValue;*/
ProcessTokenMovement(GamePlayers.GamePlayers[0], GamePlayers.GamePlayers[1].Combi.TokenValue);
}
else // If they both have the same combination.
{
if (GamePlayers.GamePlayers[0].DiceRoll > GamePlayers.GamePlayers[1].DiceRoll)
{
/*GamePlayers.GamePlayers[1].Tokens += GamePlayers.GamePlayers[0].Combi.TokenValue;
* Tokens -= GamePlayers.GamePlayers[0].Combi.TokenValue;*/
ProcessTokenMovement(GamePlayers.GamePlayers[1], GamePlayers.GamePlayers[0].Combi.TokenValue);
}
else if (GamePlayers.GamePlayers[0].DiceRoll < GamePlayers.GamePlayers[1].DiceRoll)
{
/*GamePlayers.GamePlayers[0].Tokens += GamePlayers.GamePlayers[1].Combi.TokenValue;
* Tokens -= GamePlayers.GamePlayers[0].Combi.TokenValue;*/
ProcessTokenMovement(GamePlayers.GamePlayers[0], GamePlayers.GamePlayers[1].Combi.TokenValue);
}
}
Debug.Print("{0} & {1}", GamePlayers.GamePlayers[0].Combi.Name, GamePlayers.GamePlayers[1].Combi.Name);
GamePlayers.GamePlayers[0].LastRoll = GamePlayers.GamePlayers[0].DiceRoll;
GamePlayers.GamePlayers[1].LastRoll = GamePlayers.GamePlayers[1].DiceRoll;
GamePlayers.ResetRolls();
GamePlayers.CurrentPlayer.PlaysLeft = 3;
GamePlayers.GamePlayers[GamePlayers.CurrentPlayer.Id].PlaysLeft = 1;
ClickableDices();
ResetDices();
}
else
{
GamePlayers.NextPlayer();
UnclickableDices();
ResetDices();
}
}
public async Task <IActionResult> Create([Bind("Id")] GamePlayers gamePlayers)
{
if (ModelState.IsValid)
{
gamePlayers.Id = Guid.NewGuid();
_context.Add(gamePlayers);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(gamePlayers));
}
private void HideUnusedTiles(GamePlayers gamePlayers)
{
for (int yamaIndex = 0; yamaIndex < Walls.Length; yamaIndex++)
{
int count = GetYamaTotalTiles(yamaIndex, gamePlayers);
for (int i = count; i < Walls[yamaIndex].childCount; i++)
{
var t = Walls[yamaIndex].GetChild(i);
t.gameObject.SetActive(false);
}
}
}
public void MakeWrongAnswer_ShouldCall_GivePenaltyToCurrentPlayer_FromGamePlayers()
{
var gamePlayers = new GamePlayers();
gamePlayers.AddPlayer(new Player("A"));
var wrongAnswerBehaviour = new WrongAnswerBehaviour(gamePlayers);
Assert.AreEqual(false, gamePlayers.CurrentPlayerIsInPenalty);
wrongAnswerBehaviour.MakeWrongAnswer();
Assert.AreEqual(true, gamePlayers.CurrentPlayerIsInPenalty);
}
public void MakeCorrectAnswer_ShouldAddOnePointToPlayer_IfPlayerDidntHavePenalty()
{
var gamePlayers = new GamePlayers();
var player = new Player("A");
gamePlayers.AddPlayer(player);
CorrectAnswerBehaviour correctAnswerBehaviour = new CorrectAnswerBehaviour(gamePlayers);
correctAnswerBehaviour.MakeCorrectAnswer();
Assert.AreEqual(false, player.Penalty);
Assert.AreEqual(1, gamePlayers.CurrentPlayerPoints);
}
public void StartGame()
{
State = (int)GameState.InProgress;
DateStarted = DateTime.Now;
var startplayerId = GamePlayers
.OrderBy(gp => gp.TurnOrder)
.First()
.Id;
PlayerTurnId = startplayerId;
RoundStartPlayerId = startplayerId;
}
public IActionResult Post([FromBody] GamePlayers gamePlayers)
{
// UPDATE USER TRACKING INFORMATION
userTracker.UpdateUserActivity(Request);
// UPDATE GAME ID
userTracker.UpdateGameId(Request, gamePlayers.userId, gamePlayers.gameId);
_context.GamePlayers.Add(gamePlayers);
_context.SaveChanges();
return(Created("api/game/players/" + gamePlayers.Id, gamePlayers.Id));
}
private GamePlayer GetNextMover()
{
var gamePlayer = GamePlayers.First(gp => gp.Player.Id == CurrentMover.Id);
if (GamePlayers.Max(gp => gp.Priority) == gamePlayer.Priority)
{
return(GamePlayers.First(gp => gp.Priority == GamePlayers.Min(p => p.Priority)));
}
else
{
return(GamePlayers
.Where(gp => gp.Priority > gamePlayer.Priority)
.First(gp => gp.Priority == GamePlayers.Where(p => p.Priority > gamePlayer.Priority).Min(p => p.Priority)));
}
}
public void MakeCorrectAnswer_Should_Not_AddPointToPlayer_IfPlayerHavePenalty()
{
var gamePlayers = new GamePlayers();
var player = new Player("A");
gamePlayers.AddPlayer(player);
CorrectAnswerBehaviour correctAnswerBehaviour = new CorrectAnswerBehaviour(gamePlayers);
player.SetPenalty();
correctAnswerBehaviour.MakeCorrectAnswer();
Assert.AreEqual(true, player.Penalty);
Assert.AreEqual(0, gamePlayers.CurrentPlayerPoints);
}
public void GivenPlayerIsDidntHavePenalty_And_MakeRollAction_Should_AddRoll_ToPlayers_Place()
{
var gamePlayers = new GamePlayers();
var player = new Player("A");
gamePlayers.AddPlayer(player);
GameQuestions gameQuestions = new GameQuestions();
RollBehaviour rollBehaviour = new RollBehaviour(gamePlayers, gameQuestions);
Assert.AreEqual(0, player.Place);
rollBehaviour.MakeRollAction(new Roll(2));
Assert.AreEqual(2, player.Place);
}
public void PlayerDeath(GamePlayer gamePlayer)
{
GamePlayers.Remove(gamePlayer);
Destroy(gamePlayer.gameObject);
if (IsHost)
{
if (GamePlayers.Count == 0)
{
// 게임 종료
IsGameStart = false;
StartCoroutine(GameEnd());
}
}
}
public void EndGame()
{
if ("Assets/Scenes/" + SceneManager.GetActiveScene().name + ".unity" == gameScene)
{
ServerChangeScene("EndScene");
for (int i = 0; i < Players.Count; i++)
{
NetworkServer.Destroy(Players[i].gameObject);
NetworkServer.DestroyPlayerForConnection(Players[i].connectionToClient);
}
RoomPlayers.Clear();
GamePlayers.Clear();
Players.Clear();
}
}
public void GivenPlayerIsInPenaltyy_And_MakeRollAction_Should_Not_AddRoll_ToPlayers_Place_WhenPlayerMadeEvenRoll()
{
var gamePlayers = new GamePlayers();
var player = new Player("A");
gamePlayers.AddPlayer(player);
GameQuestions gameQuestions = new GameQuestions();
RollBehaviour rollBehaviour = new RollBehaviour(gamePlayers, gameQuestions);
player.SetPenalty();
Assert.AreEqual(0, player.Place);
rollBehaviour.MakeRollAction(new Roll(2));
Assert.AreEqual(0, player.Place);
}
void myProgram_GameEnded(Object obj)
{
if (this.InvokeRequired)
{
this.Invoke(new MethodInvoker(delegate { this.Visible = true; }));
txtPass2.Invoke(new MethodInvoker(delegate { txtPass2.Text = ""; }));
String Msg = "At this point ControlPasses back to the main Form, along with an object which represents the updated list of the two players that were playing the game";
MessageBox.Show(Msg);
GamePlayers myGame = new GamePlayers();
UserList myUserList = new UserList();
XMLHelper<GamePlayers> myXMLGame = new XMLHelper<GamePlayers>();
XMLHelper<UserList> myXMLUser = new XMLHelper<UserList>();
myXMLGame.Load(ref myGame);
myXMLUser.Load(ref myUserList);
if (myGame.myPlayers.Length > 0)
{
int one = myUserList.FindName(myGame.myPlayers[0].UserName);
int two = myUserList.FindName(myGame.myPlayers[1].UserName);
myUserList.myUsers[one].TotalWins = myUserList.myUsers[one].TotalWins + myGame.myPlayers[0].TotalWins;
myUserList.myUsers[one].TotalGames = myUserList.myUsers[one].TotalGames + myGame.myPlayers[0].TotalGames;
myUserList.myUsers[two].TotalWins = myUserList.myUsers[two].TotalWins + myGame.myPlayers[1].TotalWins;
myUserList.myUsers[two].TotalGames = myUserList.myUsers[two].TotalGames + myGame.myPlayers[1].TotalGames;
myXMLUser.Save(myUserList);
}
}
}
// Use this for initialization
void Start()
{
takeAttack = false;
DuelMode = false;
winwidth = Screen.width;
winheight = Screen.height;
Debug.Log(winwidth+" "+winheight);
// initialise 4player game
Vector3 st = new Vector3(0,5,0);
long amount = 250000;
startTime =0;
deltaTime = 0.5f;
pause = false;
rollyes = false;
totalPlayers = 4;
turn = 0;
for(int i=0;i<64;i++)
InfoBox[i]=-1;
float x=-0.08f,y=-0.095f,wx=0.23f,wy=0.2f;
Rect A = new Rect(x*winwidth,y*winheight,wx*winwidth,wy*winheight);
wx = 0.05f;
wy=0.1f;
y = -0.077f;
Rect B1 = new Rect(x*winwidth,y*winheight,wx*winwidth,wy*winheight);
float bX = -0.09f;
float bY = -0.1f;
float bH = 0.04f;
float bW = 0.02f;
Rect B2 = new Rect(bX*winwidth,bY*winheight,bW*winwidth,bH*winheight);
for(int i=0;i<totalPlayers;i++)
{
Players[i] = new GamePlayers();
Players[i].init(i, amount, st, 0, 0, 0, 0, 5,true);
PlayerTextures[i].pixelInset = A;
PlayerTextures[i].transform.Find("logo").guiTexture.pixelInset = B1;
PlayerTextures[i].transform.Find("cuff1").guiTexture.pixelInset = B2;
PlayerTextures[i].transform.Find("cuff2").guiTexture.pixelInset = B2;
PlayerTextures[i].transform.Find("cuff3").guiTexture.pixelInset = B2;
}
wx = 0.05f;
wy = 0.05f;
Rect D1 = new Rect(x*winwidth,y*winheight,wx*winwidth,wy*winwidth);
Dice1.pixelInset = D1;
y=0.0001f;
Rect D2 = new Rect(x*winwidth,y*winheight,wx*winwidth,wy*winwidth);
Dice2.pixelInset = D2;
Vector3 startpos = new Vector3(0,7.5f,0);
GobPlayer = new GameObject[4];
// GobPlayer = Resources.LoadAll("Player") as GameObject[];
float tosub=-1;
for(int i=0;i<totalPlayers;i++)
{
GameObject instanceg = new GameObject();
startpos.x = tosub + i;
instanceg = Instantiate(PlayerFab,startpos,transform.rotation) as GameObject;
GobPlayer[i] = instanceg;
for(int j=0;j<4;j++)
GobPlayer[i].transform.Find("Pcam"+j).camera.enabled = false;
gameObject.transform.Find("Camera"+i).camera.enabled = false;
/// gameObject.transform.Find("Camera"+i).camera.transform.Find("AmbientLight").light.enabled = false;
}
gameObject.transform.Find("Camera0").camera.enabled = true;
// gameObject.transform.Find("Camera0").camera.transform.Find("AmbientLight").light.enabled= true;
Plist = new PathList();
Plist.initList();
GameObject instance = new GameObject();
instance = Instantiate(Dicefab,instance.transform.position,instance.transform.rotation) as GameObject;
instance.name="Dicer1";
GameObject instance2 = new GameObject();
instance2 = Instantiate(Dice2fab,instance2.transform.position,transform.rotation) as GameObject;
instance2.name="Dicer2";
V1Dice = instance.GetComponent<DiceValue>();
V2Dice = instance2.GetComponent<DiceValue>();
Dice1 = Instantiate(Dice1) as GUITexture;
Dice2 = Instantiate (Dice2) as GUITexture;
initDepartments();
//
Debug.Log("gameinited");
}
public static GamePlayers CreateGamePlayers(int id)
{
GamePlayers gamePlayers = new GamePlayers();
gamePlayers.ID = id;
return gamePlayers;
}
public void AddToGamePlayers(GamePlayers gamePlayers)
{
base.AddObject("GamePlayers", gamePlayers);
}
private void btnLogin_Click(object sender, EventArgs e)
{
String Username = txtFirstUser.Text;
String Password = txtFirstPassword.Text;
if (Username.ToUpper().Equals("SA") && Password.ToUpper().Equals("SA"))
{
if (SALogin != null)
{
this.Dispose();
SALogin();
}
}
else
{
//Verify Username and Password from UserList
myUserXML.Load(ref myUserList);
Boolean UserFound = false;
for (int i = 0; i < myUserList.myUsers.Length; i++)
{
if (myUserList.myUsers[i].UserName.ToUpper().Equals(Username.ToUpper()) && myUserList.myUsers[i].Password.ToUpper().Equals(Password.ToUpper()))
{
if (myUserList.myUsers[i].IsApproved == false)
{
MessageBox.Show("User has not been approved by SA yet");
return;
}
if (LoginSuccessful != null)
{
UserFound = true;
UserOne = myUserList.myUsers[i];
myPRHome = new Main_XNA_Game.GUI.PR.frmHome(UserOne);
GamePlayers myGamePlayers = new GamePlayers();
XMLHelper<GamePlayers> myXMLGame = new XMLHelper<GamePlayers>();
myGamePlayers.AddItem(UserOne);
myXMLGame.Save(myGamePlayers);
//myPRHome.Visible = true;
this.Dispose();
LoginSuccessful(UserOne);
break;
}
break;
}
}
if (!UserFound)
MessageBox.Show("Login Unsuccessful");
}
}
