void OnChangedMenu(LobbyState state)
{
if (state != LobbyState.HeroGuild)
{
Close();
}
}
void RegisterToTheLobbyServer()
{
//PlayerData playerData = new PlayerData();
//playerData.name = "John";
//playerData.externalId = "1234567890";
NetworkClient.Lobby.Register(nickname, (successful, reply, error) => { //playerData umisto nickname, za to je potreban seriazible klasa playerData, pogledat dokumentaciju
if (successful)
{
Debug.Log("Lobby registered " + reply);
if (string.IsNullOrEmpty(reply.roomId))
{
JoinOrCreateRoom();
}
else if (reply.started)
{
State = LobbyState.JoinedRoom;
ConnectToRoom();
}
else
{
State = LobbyState.JoinedRoom;
ShowJoinedRoomPopover();
GetPlayersInTheRoom();
}
}
else
{
Debug.Log("Lobby failed to register " + reply);
}
});
}
/// <summary>
/// Performs common operations when moving to preparing phase
/// </summary>
public void LockShips()
{
currentState = LobbyState.Preparing;
shipSelectContainer.SetActive(false);
preparingContainer.SetActive(true);
timer = 10;
List <Player> playerList = manager.playerList;
int redIndex = 0;
int blueIndex = 0;
for (int i = 0; i < playerList.Count; i++)
{
Player player = playerList[i];
if (player.team == 0)
{
redIcons[redIndex].transform.Find("Image").GetComponent <Image>().sprite = shipIcons[(short)player.ship];
redIcons[redIndex].GetComponentInChildren <Text>().text = player.name;
redIndex++;
}
else
{
blueIcons[blueIndex].transform.Find("Image").GetComponent <Image>().sprite = shipIcons[(short)player.ship];
blueIcons[blueIndex].GetComponentInChildren <Text>().text = player.name;
blueIndex++;
}
}
}
/// <summary>
/// Menu For Enter Name for UI 4.6 WIP
/// </summary>
public void EnterName()
{
playerName = playerName.Replace("\n", "");
GUILayout.BeginArea(new Rect(Screen.width / 2 - 175, Screen.height / 2 - 57, 375, 135), "<color=black>Player Name</color>", "window");
GUILayout.Space(10);
GUILayout.BeginHorizontal("box");
GUILayout.Label("Player Name : ");
GUILayout.Space(5);
GUI.SetNextControlName("user");
playerName = playerName.Replace("\n", "");
playerName = GUILayout.TextField(playerName, 20, GUILayout.Width(223), GUILayout.Height(33));
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
GUILayout.Space(10);
GUILayout.BeginHorizontal();
if (GUILayout.Button("Quit", GUILayout.Width(100), GUILayout.Height(33)))
{
PlayAudioClip(backSound, transform.position, 1.0f);
m_state = LobbyState.Quit;
}
GUILayout.Space(100);
if (GUILayout.Button("Continue", GUILayout.Width(150), GUILayout.Height(33)))
{
if (playerName != string.Empty && playerName.Length > 3)
{
PlayAudioClip(a_Click, transform.position, 1.0f);
StartCoroutine(Fade(LobbyState.MainMenu));
StartCoroutine(RefresListIE());
}
}
GUILayout.EndHorizontal();
GUILayout.EndArea();
}
void OnChangedMenu(LobbyState state)
{
if (state != LobbyState.Shop)
{
Close();
}
}
void OnChangedMenu(LobbyState state)
{
if (state != LobbyState.HeroTraining)
{
Close();
}
}
/// <summary>
/// This is where it all begins!
/// </summary>
/// <param name="photonPlugin"></param>
/// <param name="messenger"></param>
/// <param name="playerManager"></param>
/// <returns></returns>
public ITAlertRoomStateController Create(PluginBase photonPlugin,
Messenger messenger,
ITAlertPlayerManager playerManager,
ExceptionHandler exceptionHandler)
{
var sugarAnalytics = new AnalyticsServiceAdapter();
var analytics = new AnalyticsServiceManager(sugarAnalytics);
var roomSettings = new RoomSettings(photonPlugin);
var exceptionTransition = new EventTransition(ErrorState.StateName);
exceptionHandler.ExceptionEvent += e => exceptionTransition.ChangeState();
var lobbyState = new LobbyState(photonPlugin, messenger, playerManager, roomSettings, analytics);
var gameStartedTransition = new EventTransition(GameState.StateName);
lobbyState.GameStartedEvent += gameStartedTransition.ChangeState;
lobbyState.AddTransitions(gameStartedTransition);
var gameState = new GameState(photonPlugin, messenger, playerManager, roomSettings, analytics, exceptionHandler);
gameState.AddTransitions(exceptionTransition);
var errorState = new ErrorState(photonPlugin, messenger, playerManager, roomSettings, analytics, exceptionHandler);
var controller = new ITAlertRoomStateController(lobbyState, gameState, errorState);
gameState.ParentStateController = controller;
return(controller);
}
public void ChangeLobbyState(LobbyState newState)
{
switch (newState)
{
// Make login UI canvas visible
case LobbyState.LOGIN:
_loginCanvas.transform.SetAsLastSibling();
_lobbyState = LobbyState.LOGIN;
break;
// Make lobby UI canvas visible
case LobbyState.LOBBY:
_lobbyCanvas.transform.SetAsLastSibling();
_lobbyState = LobbyState.LOBBY;
break;
// Make Room UI canvas visible
case LobbyState.ROOM:
_roomCanvas.transform.SetAsLastSibling();
_lobbyState = LobbyState.ROOM;
break;
default:
Debug.LogError("Invalid lobby state");
break;
}
}
void OnChangedMenu(LobbyState state)
{
if (SceneLobby.currentSubMenuState != SubMenuState.UserQuest)
{
Close();
}
}
/// <summary>
/// Performs some common operations when moving to ship select phase
/// </summary>
public void LockTeams()
{
currentState = LobbyState.ShipSelect;
teamSelectContainer.SetActive(false);
shipSelectContainer.SetActive(true);
timer = 60;
}
public void ChangeState(LobbyState newState)
{
switch (newState)
{
// Login
case LobbyState.LOGIN:
Debug.Log("Entered Login State");
_canvasManager.ChangeLobbyState(LobbyState.LOGIN);
break;
// Main Lobby
case LobbyState.LOBBY:
Debug.Log("Entering Lobby State");
PhotonNetwork.JoinLobby(TypedLobby.Default);
_canvasManager.ChangeLobbyState(LobbyState.LOBBY);
break;
// Room Lobby
case LobbyState.ROOM:
Debug.Log("Entering Room State");
_canvasManager.ChangeLobbyState(LobbyState.ROOM);
break;
// In Game
case LobbyState.GAME:
Debug.Log("Entering Game State");
break;
}
}
/// <summary>
/// Starts the server and begins listening on the given port
/// Will reject any connections with the incorrect password
/// </summary>
/// <param name="port"></param>
/// <param name="password"></param>
public void StartServer(int port, string password)
{
// init properties
BannedAddresses = new HashSet <string>();
ServerPassword = password;
ServerState = ServerState.Lobby;
LobbyState = new LobbyState();
server = new NetServer();
// register events
server.PacketRecieved += Server_PacketRecieved;
server.ConnectionLost += Server_ConnectionLost;
// setart the net server
server.Start(port);
// init game controllers and register events
controllers = new ControllerManager();
controllers.Board.TilesUpdated += Board_TilesUpdated;
controllers.City.CityCaptured += City_CityCaptured;
controllers.City.CitySettled += City_CitySettled;
controllers.City.CityUpdated += City_CityUpdated;
controllers.City.CityBorderExpanded += City_CityBorderExpanded;
controllers.Player.PlayerAdded += Player_PlayerAdded;
controllers.Player.PlayerRemoved += Player_PlayerRemoved;
controllers.Player.PlayerUpdated += Player_PlayerUpdated;
controllers.Player.PlayerTurnStateChanged += Player_TurnStateChanged;
controllers.Unit.UnitAdded += Unit_UnitAdded;
controllers.Unit.UnitRemoved += Unit_UnitRemoved;
controllers.Unit.UnitUpdated += Unit_UnitUpdated;
}
IEnumerator DelayedMenuSwitch(LobbyState desiredState, float delay)
{
yield return(new WaitForSeconds(delay));
//Debug.Log("Delayed Menu switch");
if (desiredState == LobbyState.CONTROLLERASSIGNMENT)
{
//Debug.Log("Delayed Menu switch - controller assignmet");
//Find the next user to assign a controller to
//If there is no users to assign controllers to, go to signin screen
Dictionary <int, PlayerInfo> players = SessionManager.Singleton.networkedGameState.GetAllPlayers();
desiredState = LobbyState.SIGNIN;
foreach (KeyValuePair <int, PlayerInfo> player in players)
{
if (player.Value.assignedController < 0 && player.Value.username != null)
{
Debug.Log("Still have another user without a controller: " + player.Value.username);
desiredState = LobbyState.CONTROLLERASSIGNMENT;
currentUser = player.Value.username;
break;
}
}
}
SetNextState(desiredState, currentUser);
}
void OnChangedMenu(LobbyState state)
{
if (state != LobbyState.Shop || SceneLobby.currentSubMenuState != SubMenuState.PackageBox)
{
Close();
}
}
public void ReportResult()
{
UpdatePlayerRatings();
UpdateWinLosses();
State = LobbyState.Complete;
}
void OnChangedMenu(LobbyState state)
{
if (state != LobbyState.SubMenu && SceneLobby.currentSubMenuState != SubMenuState.Mail)
{
Close();
}
}
void OnChangedMenu(LobbyState state)
{
if (SceneLobby.currentSubMenuState != SubMenuState.Option)
{
Close();
}
}
void OnChagedMenu(LobbyState state)
{
if (SceneLobby.currentSubMenuState != SubMenuState.Attendance)
{
Close();
}
}
public GameManager(GameplayState gameplayState, PauseState pauseState, LobbyState lobbyState, EndgameState endgameState)
{
_gameplayState = gameplayState;
_pauseState = pauseState;
_lobbyState = lobbyState;
_endgameState = endgameState;
}
private void UpdateLobbyState(LobbyState state)
{
// Lerp to current target
if (SwitchLobbyTime != 0)
{
var realanim = UILobbyContainers[(int)LobbyState.AnimReal];
var real = UILobbyContainers[(int)LobbyState.Real];
float progress = ((Time.time - SwitchLobbyTime) / LobbyAnimDuration);
progress = Mathf.Clamp(progress, 0, 1);
float halfprogress = Mathf.Clamp(progress * 2, 0, 1);
// Resize the reals
foreach (Transform section in real.transform)
{
RectTransform from = LobbyAnimateFrom.transform.GetChild(section.GetSiblingIndex()) as RectTransform;
RectTransform targ = LobbyAnimateTarget.transform.GetChild(section.GetSiblingIndex()) as RectTransform;
RectTransform rect = section as RectTransform;
rect.position = Vector3.Lerp(from.position, targ.position, progress);
rect.sizeDelta = Vector2.Lerp(from.sizeDelta, targ.sizeDelta, Mathf.Max(0, halfprogress - 0.5f) * 2);
}
foreach (Transform section in realanim.transform)
{
RectTransform from = LobbyAnimateFrom.transform.GetChild(section.GetSiblingIndex()) as RectTransform;
RectTransform targ = LobbyAnimateTarget.transform.GetChild(section.GetSiblingIndex()) as RectTransform;
RectTransform rect = section as RectTransform;
rect.position = Vector3.Lerp(from.position, targ.position, progress);
rect.sizeDelta = Vector2.Lerp(from.sizeDelta, targ.sizeDelta, Mathf.Max(0, halfprogress - 0.5f) * 2);
}
// Flip both gradually
var zero = new Vector3(0, 0, 0);
var opposite = new Vector3(0, 180, 0);
realanim.transform.rotation = Quaternion.Lerp(Quaternion.Euler(opposite), Quaternion.Euler(zero), progress);
real.transform.rotation = Quaternion.Lerp(Quaternion.Euler(zero), Quaternion.Euler(opposite), progress);
// Switch scene order at half way
if (progress >= 0.5f)
{
if (realanim.transform.GetSiblingIndex() < real.transform.GetSiblingIndex())
{
realanim.transform.SetAsLastSibling();
// Clear the real
foreach (Transform section in real.transform)
{
foreach (Transform child in section)
{
Destroy(child.gameObject);
}
}
}
}
// Finish
if (progress >= 1)
{
FinishLobbyAnim();
}
}
}
public void StartTurn()
{
if (GameLobby.CurrentGame == null)
{
return;
}
if (GameLobby.CurrentGame.IsGameOver())
{
EndGame();
return;
}
// Begin the timer to the end of the turn
GameLobby.CurrentGame.StartTurn();
// Check for sudden death
if (GameLobby.CurrentGame.NumPlayersLeft() == 2)
{
StartSuddenDeath();
return;
}
// Tell all clients the turn is starting
LobbyState state = GameLobby.getLobbyState();
Clients.All.turnStart(state);
turnTimer = new Timer(ProcessGameTurn, null, GameLobby.CurrentGame.TurnTime, TimeSpan.FromMilliseconds(-1));
}
void StartRoom()
{
NetworkClient.Lobby.StartRoom((successful, error) =>
{
if (successful)
{
Debug.Log("Started room");
State = LobbyState.Default;
}
else
{
Debug.Log("Failed to start room" + error);
}
});
/* NetworkClient.Lobby.ChangeRoomSettings(5, false, (bool successful, SWLobbyError error) => {
* if (successful)
* {
* Debug.Log("Changed room settings.");
* }
* else
* {
* Debug.Log("Failed to change room settings " + error);
* }
* });*/
}
void RegisterToTheLobbyServer()
{
NetworkClient.Lobby.Register(nickname, (successful, reply, error) => {
if (successful)
{
Debug.Log("Lobby registered " + reply);
if (string.IsNullOrEmpty(reply.roomId))
{
JoinOrCreateRoom();
}
else if (reply.started)
{
State = LobbyState.JoinedRoom;
ConnectToRoom();
}
else
{
State = LobbyState.JoinedRoom;
ShowJoinedRoomPopover();
GetPlayersInTheRoom();
}
}
else
{
Debug.Log("Lobby failed to registered " + reply);
}
});
}
void OnChangedMenu(LobbyState state)
{
if (SceneLobby.currentSubMenuState != SubMenuState.Achievement)
{
Close();
}
}
void OnChangedMenu(LobbyState state)
{
if (state != LobbyState.Territory)
{
Close();
}
}
public void OnJoinLobby(JoinLobby joinLobby)
{
_log.Output($"Player [{joinLobby.ClientId}] joining lobby [{joinLobby.LobbyId}]");
LobbyState state = GetLobbyById(joinLobby.LobbyId);
if (state == null)
{
// try geting lobby by name, will return the first match
state = GetLobbyByName(joinLobby.LobbyId);
if (state == null)
{
// TODO - need to send feed back to player that cannot connect
return;
}
}
// Add player if not already added
if (!state.ContainsPlayerId(joinLobby.ClientId))
{
state.AddPlayer(joinLobby.ClientId, joinLobby.PlayerDisplayName);
}
// send all players connected to this lobby a lobby update
Broadcast(state, new UpdateLobbyState(state));
}
/// <summary>
///
/// </summary>
void MainMenu()
{
GUILayout.BeginArea(new Rect(0, 0, Screen.width, 60));
GUILayout.BeginHorizontal();
if (GUILayout.Button("Search Room", GUILayout.Height(GetButtonSize(LobbyState.Join))))
{
m_state = LobbyState.Join;
StartCoroutine(RefresListIE());
PlayAudioClip(a_Click, transform.position, 1.0f);
}
if (GUILayout.Button("Host Room", GUILayout.Height(GetButtonSize(LobbyState.Host))))
{
m_state = LobbyState.Host;
PlayAudioClip(a_Click, transform.position, 1.0f);
}
if (GUILayout.Button("Setting", GUILayout.Height(GetButtonSize(LobbyState.Settings))))
{
m_state = LobbyState.Settings;
PlayAudioClip(a_Click, transform.position, 1.0f);
}
if (GUILayout.Button("Change Server", GUILayout.Height(GetButtonSize(LobbyState.ChangeServer))))
{
m_state = LobbyState.ChangeServer;
PlayAudioClip(a_Click, transform.position, 1.0f);
}
if (GUILayout.Button("Quit", GUILayout.Height(GetButtonSize(LobbyState.Quit))))
{
m_state = LobbyState.Quit;
PlayAudioClip(a_Click, transform.position, 1.0f);
}
GUILayout.EndHorizontal();
GUILayout.EndArea();
}
public void Create(bool inviteOnly, CallResult <LobbyCreated_t> .APIDispatchDelegate callResult)
{
SteamAPICall_t hAPICall = SteamMatchmaking.CreateLobby((!inviteOnly) ? ELobbyType.k_ELobbyTypeFriendsOnly : ELobbyType.k_ELobbyTypePrivate, 17);
_lobbyCreatedExternalCallback = callResult;
_lobbyCreated.Set(hAPICall);
State = LobbyState.Creating;
}
public void Create(bool inviteOnly, CallResult <LobbyCreated_t> .APIDispatchDelegate callResult)
{
SteamAPICall_t lobby = SteamMatchmaking.CreateLobby(inviteOnly ? (ELobbyType)0 : (ELobbyType)1, 256);
this._lobbyCreatedExternalCallback = callResult;
this._lobbyCreated.Set(lobby, (CallResult <LobbyCreated_t> .APIDispatchDelegate)null);
this.State = LobbyState.Creating;
}
private void Broadcast(LobbyState state, DediToClientMessage netMessage)
{
_log.Output($"Lobby:[{state.Id}] [{state.DisplayName}]\nPlayers: {state.Players.Count}/{state.MaxPlayers}");
for (int i = 0; i < state.Players.Count; i++)
{
_server.Send(state.Players[i].Id, netMessage);
}
}
public override void BoltStartDone()
{
IndexMap = new PlayerIndexMap();
if (GameManager.instance.CurrentUserName == "") GameManager.instance.CurrentUserName = "******";
PlayerRegistry.CreatePlayer(null, GameManager.instance.CurrentUserName);
IndexMap.AddPlayer(GameManager.instance.CurrentUserName);
lobby = BoltNetwork.Instantiate(BoltPrefabs.LobbyList).GetComponent<LobbyState>();
lobby.InitializeLobby();
}
private int GetButtonSize(LobbyState t_state)
{
if (m_state == t_state)
return 55;
else
return 40;
}
IEnumerator Fade(LobbyState t_state, float t = 2.0f)
{
alpha = 0.0f;
m_state = t_state;
while (alpha < t)
{
alpha += Time.deltaTime;
CanvasGroupRoot.alpha = alpha;
yield return null;
}
}
void Start()
{
lobby = FindObjectOfType<LobbyState>();
}
