public void AcceptCallback(IAsyncResult ar)
{
// Signal the main thread to continue.
accpeting.Set();
try
{
Socket listener = (Socket)ar.AsyncState;
Socket handler = listener.EndAccept(ar);
NetworkPlayer player = new NetworkPlayer();
player.id = rand.Next(int.MaxValue);
player.workSocket = handler;
lock (players)
{
players.Add(player);
}
PlayerConnected?.Invoke(player);
handler.BeginReceive(player.buffer, 0, NetworkPlayer.BufferSize, 0, new AsyncCallback(ReadCallback), player);
}
catch (Exception e)
{
Logger.Debug(e.ToString());
}
}
private void Update()
{
if (exitMenu)
{
float alpha = title.color.a - 0.05f;
if (alpha <= 0)
{
alpha = 0;
}
title.color = new Color(1, 1, 1, alpha);
if (alpha == 0)
{
this.enabled = false;
}
return;
}
float horizMove = PlayerConnected.getSingularity().getPlayer(playerID).GetAxis("Move Horizontal");
float vertiMove = PlayerConnected.getSingularity().getPlayer(playerID).GetAxis("Move Vertical");
if (horizMove != 0 || horizMove != 0)
{
ActiveLevel();
}
}
private void AddPlayerReceived(Player player)
{
State.Players.Add(player);
NotifyPropertyChanged(nameof(State));
PlayerConnected?.Invoke(player);
}
public async Task AddPlayer(Player player)
{
lock (State)
{
State.Players.Add(player);
}
var @event = new Event
{
player_added_event = new Event.PlayerAddedEvent
{
Player = player
}
};
await Broadcast(new Packet
{
Event = @event
});
if (PlayerConnected != null)
{
await PlayerConnected.Invoke(player);
}
}
/// <summary>
/// Handles connecting player message.
/// </summary>
/// <param name="msg">Annoted player request.</param>
protected virtual void ConnectPlayer(AnnotedPlayerRequest msg)
{
// Check if it good time
if (Executor.CurrentPhase != GamePhase.BEFORE_START && !_Loaded)
{
throw new WrongGamePhaseException();
}
// Check if there is empty seat
if (_PlayerLimit == PlayersInGame.Count)
{
throw new PlayerLimitException();
}
// Check if color is enabled for the game
if (!_EnabledColors.Contains(msg.Request.Color))
{
throw new ColorDisabledException();
}
// Check if color is already selected
if (PlayersInGame.ContainsKey(msg.Request.Color))
{
throw new ColorAlreadySelectedException();
}
// Check if client is already connected
if (PlayersInGame.ContainsValue(msg.HandlerSocket))
{
throw new AlreadyConnectedException();
}
// Connect the player
PlayersInGame.Add(msg.Request.Color, msg.HandlerSocket);
PlayersNames.Add(msg.Request.Color, msg.Request.Name);
PlayerConnected.Invoke(msg.Request.Color, msg.Request.Name, msg.HandlerSocket);
}
/// <summary>
/// gère les inputs du jeu
/// </summary>
private void InputGame()
{
//if we win, just accept the changement scene
if (winned)
{
if (idLevel == idLevelMax && readyToRestart) //if this is the end and we can restart
{
if (PlayerConnected.getSingularity().getPlayer(0).GetButtonDown("FireB"))
{
SceneChangeManager.getSingleton().JumpToSceneWithFade("Level 1");
}
}
return;
}
if (loosed)
{
//if we loose, 1 inputs
if (PlayerConnected.getSingularity().getPlayer(0).GetButtonDown("FireA"))
{
if (gameover_retryText.color.a != 1)
{
gameover_canvas.GetComponent <Animator>().enabled = false;
gameover_trappedText.color = new Color(gameover_trappedText.color.r, gameover_trappedText.color.g, gameover_trappedText.color.b, 1);
gameover_retryText.color = new Color(gameover_trappedText.color.r, gameover_trappedText.color.g, gameover_trappedText.color.b, 1);
}
else
{
SceneChangeManager.getSingleton().JumpToSceneWithFade(SceneManager.GetActiveScene().name);
}
}
}
else
{
if (Time.unscaledTime < timeTmpForPauseEscape + 0.3f /* || transitionState*/)
{
return;
}
if (!paused && (PlayerConnected.getSingularity().getPlayer(0).GetButtonDown("Start") || PlayerConnected.getSingularity().getPlayer(0).GetButtonDown(0) || PlayerConnected.getSingularity().getPlayer(0).GetButtonDown(4) ||
PlayerConnected.getSingularity().getPlayer(0).GetButtonDown("Escape") || PlayerConnected.getSingularity().getPlayer(0).GetButtonDown(4)))
{
Paused();
}
else if (paused)
{
if (PlayerConnected.getSingularity().getPlayer(0).GetButtonDown("FireA") ||
PlayerConnected.getSingularity().getPlayer(0).GetButtonDown("Start"))
{
Resume();
}
if (PlayerConnected.getSingularity().getPlayer(0).GetButtonDown("FireB") ||
PlayerConnected.getSingularity().getPlayer(0).GetButtonDown("Escape"))
{
Time.timeScale = 1;
SceneChangeManager.getSingleton().JumpToSceneWithFade("Level 1");
}
}
}
}
//references
private void Awake()
{
setSingularity();
playerConnected = PlayerConnected.getSingularity(); //récupère les infos inputs
startPlayer();
updatePlayer();
}
public void AddPlayer(string playPath, Guid sessionId)
{
if (!Players.TryGetValue(playPath, out var players))
{
players = new List <Guid>();
Players.Add(playPath, players);
}
players.Add(sessionId);
PlayerConnected?.Invoke(this, new RtmpEventArgs(sessionId, playPath));
}
private void AddPlayerRecieved(Player player)
{
var newPlayers = State.Players.ToList();
newPlayers.Add(player);
State.Players = newPlayers.ToArray();
NotifyPropertyChanged(nameof(State));
PlayerConnected?.Invoke(player);
}
/// <summary>
/// test si on met le script en UNIQUE
/// </summary>
private void setSingleton()
{
if (playerConnected == null)
{
playerConnected = this;
}
else if (playerConnected != this)
{
Destroy(gameObject);
}
}
private IEnumerator ConnectedEventHandler()
{
Entity player = null;
while (true)
{
yield return(WaitTill("connected", new Action <Parameter[]>(param => player = param[0].As <Entity>())));
PlayerConnected?.Invoke(player);
}
}
/// <summary>
/// test si on met le script en UNIQUE
/// </summary>
public void SetSingleton()
{
if (instance == null)
{
instance = this;
}
else if (instance != this)
{
Destroy(gameObject);
}
}
private void PacketReceived(PlayerConnected packet)
{
if (PlayerId == packet.playerId)
{
return;
}
var p = CreatePlayer(packet.playerId);
UnityEngine.Debug.Log($"Id: {p.Id} joined");
}
public void RegisterPlayerClient(ulong pid, ulong steamid)
{
NetworkedObject netObj = SpawnManager.GetPlayerObject(pid);
if (netObj.IsOwnedByServer)
{
return;
}
AddPlayer(netObj, steamid);
PlayerConnected?.Invoke(pid);
}
//"Name<uid><wonid><>" connected, address "ip:port" [50]
protected virtual void OnConnection(DateTime Timestamp, string[] info)
{
string[] s = info[2].Split(':');
ConnectEventArgs eventArgs = new ConnectEventArgs()
{
Timestamp = Timestamp,
Player = GetPlayerInfo(info[0]),
Ip = s[0],
Port = ushort.Parse(s[1])
};
PlayerConnected.Fire(ServerEndPoint, eventArgs);
}
//"Name<uid><wonid><>" connected, address "ip:port" [50]
/// <summary>
/// Raises the <see cref="PlayerConnected"/> event.
/// </summary>
/// <param name="timestamp">Time at which <see cref="PlayerConnected"/> event was fired.</param>
/// <param name="info">Information about <see cref="PlayerConnected"/> event.</param>
protected virtual void OnConnection(DateTime timestamp, string[] info)
{
var s = info[2].Split(':');
var eventArgs = new ConnectEventArgs
{
Timestamp = timestamp,
Player = GetPlayerInfo(info[0]),
Ip = s[0],
Port = ushort.Parse(s[1], CultureInfo.InvariantCulture)
};
PlayerConnected.Fire(ServerEndPoint, eventArgs);
}
/// <summary>
/// Method called when the server sends a message that another player connected
/// </summary>
/// <param name="parts"></param>
private void PlayerConnectedResolve(string[] parts)
{
if (_serverStage != ServerStage.Lobby)
{
_pingTimer.Stop();
_pingTimer.Dispose();
throw new OutOfSyncException();
}
PlayerColor color = Enum.Parse <PlayerColor>(parts[1]);
string name = parts[2];
PlayerInfos[color] = new PlayerInfo(color, name, false);
PlayerConnected?.Invoke(this, new PlayerConnectedEventArgs(name, color));
}
private void OnDataMessage(NetIncomingMessage msg)
{
var type = (PacketType)msg.ReadByte();
if (type == PacketType.Connected)
{
InitializeFromServer(Packets.Connected.Read(msg));
}
if (!Loaded)
{
return;
}
switch (type)
{
case PacketType.PlayerPreferences:
PacketReceived(PlayerPreferences.Read(msg));
break;
case PacketType.PlayerConnected:
PacketReceived(PlayerConnected.Read(msg));
break;
case PacketType.PlayerDisconnected:
PacketReceived(PlayerDisconnected.Read(msg));
break;
case PacketType.WorldState:
AddWorldState(WorldState.Read(msg).worldState);
break;
case PacketType.PlayerDeath:
PacketReceived(Packets.PlayerDeath.Read(msg));
break;
case PacketType.PlayerShoot:
PacketReceived(PlayerShoot.Read(msg));
break;
case PacketType.ChangeLevel:
PacketReceived(ChangeLevel.Read(msg));
break;
case PacketType.GameOver:
PacketReceived(Packets.GameOver.Read(msg));
break;
}
}
private void Awake()
{
SetSingleton();
playerControllers = new PlayerController[4];
playersInGame = new bool[4];
playerConnect = PlayerConnected.GetSingleton;
tutoStart = GetComponent <TutoStart>();
winManager = GetComponent <WinManager>();
scoreManager = GetComponent <ScoreManager>();
itemManager = GetComponent <ItemManager>();
if (!objectDynamiclyCreated)
{
Debug.LogError("error");
}
}
/// <summary>
/// gère les inputs des manettes/clavier du joueurs en update
/// et défini si oui ou non on a bougé
/// </summary>
private void InputPlayer()
{
horizMove = PlayerConnected.getSingularity().getPlayer(idPlayer).GetAxis("Move Horizontal");
vertiMove = PlayerConnected.getSingularity().getPlayer(idPlayer).GetAxis("Move Vertical");
isJumping = PlayerConnected.getSingularity().getPlayer(idPlayer).GetButtonDown("FireA");
if (horizMove != 0 || vertiMove != 0)
{
hasMoved = true;
}
else
{
hasMoved = false;
}
}
public void Start(int port)
{
if (manager != null)
{
throw new InvalidOperationException();
}
var listener = new EventBasedNetListener();
manager = new NetManager(listener);
manager.Start(port);
listener.ConnectionRequestEvent += request =>
{
if (manager.GetPeersCount(ConnectionState.Any) < MaxConnections)
{
request.AcceptIfKey(nameof(MultiplayerTest));
}
else
{
request.Reject();
}
};
listener.PeerConnectedEvent += peer =>
{
PlayerConnected?.Invoke(peer.Id);
};
listener.NetworkReceiveEvent += (fromPeer, dataReader, deliveryMethod) =>
{
orders.Add(new Order()
{
Player = fromPeer.Id,
TargetX = dataReader.GetDouble(),
TargetY = dataReader.GetDouble(),
});
};
thread = new Thread(Run)
{
IsBackground = true
};
thread.Start();
}
internal void RegisterPlayer(ulong playerId)
{
try
{
playerForId.Clear();
MyAPIGateway.Multiplayer.Players.GetPlayers(playerForId, p => p.SteamUserId == playerId);
var player = playerForId.Count > 0 ? playerForId[0] : null;
playerForId.Clear();
players[playerId] = player;
PlayerConnected?.Invoke(playerId, player);
player.IdentityChanged += Player_IdentityChanged;
Player_IdentityChanged(player, player.Identity);
}
catch
{
}
}
/// <summary>
/// Registra um novo jogador dentro do servidor
/// </summary>
/// <param name="newId"></param>
private void NewPlayerOnServer(int newId)
{
if (_showDebugMessages)
{
Debug.Log("Registrando novo jogador com id: " + newId);
}
int myNewId = PlayersGamingNow;
PlayerConnected newPlayer = new PlayerConnected();
newPlayer.PlayerId = myNewId;
newPlayer.GameInstance = this.gameObject;
newPlayer.PlayerName = GetRandomName(myNewId);
newPlayer.IsConnected = true;
PlayersConnectedsList.Add(newPlayer);
CopyOfPlayersConnectedsList = PlayersConnectedsList;
_setupLocalPlayer.PlayerIdentity.SetPlayerId(myNewId);
}
private void OnConnected(SocketEndpoint obj)
{
string playerId = string.Empty;
lock (playerIds)
{
if (!playerIds.ContainsKey(obj.Address))
{
playerIds.Add(obj.Address, Guid.NewGuid().ToString());
}
playerId = playerIds[obj.Address];
}
if (playerId != string.Empty)
{
PlayerConnected?.Invoke(playerId);
}
}
/// <summary>
/// met en pause le jeu (affiche l'image selon si la manette / clavier est connecté)
/// </summary>
private void Paused()
{
timeTmpForPauseEscape = Time.unscaledTime;
if (PlayerConnected.getSingularity().playerArrayConnected[0])
{
canvasPause.transform.GetChild(0).gameObject.SetActive(false);
canvasPause.transform.GetChild(1).gameObject.SetActive(true);
}
else
{
canvasPause.transform.GetChild(0).gameObject.SetActive(true);
canvasPause.transform.GetChild(1).gameObject.SetActive(false);
}
canvasPause.SetActive(true);
paused = true;
Time.timeScale = 0;
}
public void AddPlayer(Player player)
{
lock (State)
{
var newPlayers = State.Players.ToList();
newPlayers.Add(player);
State.Players = newPlayers.ToArray();
}
NotifyPropertyChanged(nameof(State));
var @event = new Event();
@event.Type = Event.EventType.PlayerAdded;
@event.ChangedObject = player;
BroadcastToAllClients(new Packet(@event));
PlayerConnected?.Invoke(player);
}
private void OnDataRetrieved(AbstractDatagram datagram)
{
switch (datagram.GetDatagramId())
{
case RequestIdentifiers.PlayerConnected:
{
var userInfo = (datagram as PlayerConnectedRequestBody).UserInformation;
PlayerConnected?.Invoke(userInfo);
break;
}
case RequestIdentifiers.PlayerDisconnected:
{
var id = (datagram as PlayerDisconnectedRequestBody).UserIdentifier;
PlayerDisconnected?.Invoke(id);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
protected override void UpdateAfterSim(int tick)
{
for (int i = (JoinedIdentities.Count - 1); i >= 0; i--)
{
long identityId = JoinedIdentities[i];
IMyPlayer player = Utils.GetPlayerByIdentityId(identityId);
if (player == null)
{
ulong steamId = MyAPIGateway.Players.TryGetSteamId(identityId);
Log.Info($"Unknown player connected, identityId={identityId.ToString()}; alternate identifier: '{Utils.PrintPlayerName(Utils.GetPlayerByIdentityId(identityId))}' (steamId={steamId.ToString()}); trying again next tick...");
continue;
}
JoinedIdentities.RemoveAtFast(i);
OnlinePlayers.Add(player);
if (DebugLog)
{
Log.Info($"DEBUG: PlayerHandler :: {Utils.PrintPlayerName(player)} joined.");
}
try
{
PlayerConnected?.Invoke(player);
}
catch (Exception e)
{
Log.Error(e);
}
}
if (JoinedIdentities.Count <= 0)
{
SetUpdateMethods(UpdateFlags.UPDATE_AFTER_SIM, false);
}
}
public void SendGameState(Game.Models.Player[] playerModels, Game.Models.Blip[] blips)
{
//Send gamestate to all connected players
players.ForEach(x =>
{
if (x.id != 0) //If not the local player...
{
var gameState = new GameState();
gameState.blips = blips.ToArray();
gameState.players = playerModels.ToArray();
var packet = new Packet(gameState);
Send(x.id, packet.ToBytes());
}
});
//Remove the players that were marked for removal
players.RemoveAll(x => x.flagForRemoval);
//Add players who are waiting in the queue
players.AddRange(playersInQueue);
playersInQueue.Clear();
players.ForEach(x => PlayerConnected?.Invoke(x));
}
public void Lose(Transform ennemy)
{
if (loosed)
{
return;
}
loosed = true;
gameover_canvas.SetActive(true);
if (PlayerConnected.getSingularity().playerArrayConnected[0])
{
gameover_input_keyboard.gameObject.SetActive(false);
gameover_input_pad.gameObject.SetActive(true);
//textRestart.text = "Press A to restart";
}
else
{
gameover_input_keyboard.gameObject.SetActive(true);
gameover_input_pad.gameObject.SetActive(false);
//textRestart.text = "Press Space to restart";
}
cam.transform.SetParent(ennemy); //set la caméra à la racine
//cam.gameObject.GetComponent<PostProcessingBehaviour>().enabled = false;
cam.gameObject.GetComponent <ScreenShake>().Shake();
}
