public virtual void UseSpecial(ITetriNETCallback callback, int targetId, Specials special)
{
Log.Default.WriteLine(LogLevels.Debug, "UseSpecial {0} {1}", targetId, special);
IPlayer player = PlayerManager[callback];
if (player != null)
{
//
player.ResetTimeout(); // player alive
//
IPlayer target = PlayerManager[targetId];
if (target != null)
{
//
HostUseSpecial?.Invoke(player, target, special);
}
else
{
Log.Default.WriteLine(LogLevels.Warning, "UseSpecial to unknown player {0} from {1}", targetId, player.Name);
}
}
else
{
Log.Default.WriteLine(LogLevels.Warning, "UseSpecial from unknown player");
}
}
public ISpectator this[ITetriNETCallback callback]
{
get
{
ISpectator spectator;
_spectators.TryGetValue(callback, out spectator);
return(spectator);
}
}
public Spectator(int id, string name, ITetriNETCallback callback)
{
Id = id;
Name = name;
Callback = callback;
LastActionToClient = DateTime.Now;
LastActionFromClient = DateTime.Now;
TimeoutCount = 0;
}
public IPlayer this[ITetriNETCallback callback]
{
get
{
IPlayer player;
_players.TryGetValue(callback, out player);
return(player);
}
}
public virtual void Heartbeat(ITetriNETCallback callback)
{
//Log.Default.WriteLine(LogLevels.Debug, "Heartbeat");
IPlayer player = PlayerManager[callback];
if (player != null)
{
//Log.Default.WriteLine("Heartbeat from {0}", player.Name);
player.ResetTimeout(); // player alive
}
else
{
Log.Default.WriteLine(LogLevels.Warning, "Heartbeat from unknown player");
}
}
public virtual void HeartbeatSpectator(ITetriNETCallback callback)
{
//Log.Default.WriteLine(LogLevels.Debug, "Heartbeat");
ISpectator spectator = SpectatorManager[callback];
if (spectator != null)
{
//Log.Default.WriteLine("Heartbeat from {0}", player.Name);
spectator.ResetTimeout(); // player alive
}
else
{
Log.Default.WriteLine(LogLevels.Warning, "HeartbeatSpectator from unknown spectator");
}
}
public TCPProxy(ITetriNETCallback callback, string address)
{
_readyToSend = false;
_packetToSendEvent = new ManualResetEvent(false);
IPAddress ip = IPAddress.Parse(address);
IPEndPoint endpoint = new IPEndPoint(ip, Port);
_packetsToSend = new Queue <byte[]>();
_cancellationTokenSource = new CancellationTokenSource();
_sendTask = new Task(SendTask, _cancellationTokenSource.Token);
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_socket.BeginConnect(endpoint, OnConnectedToServer, null);
}
public virtual void PlacePiece(ITetriNETCallback callback, int pieceIndex, int highestIndex, Pieces piece, int orientation, int posX, int posY, byte[] grid)
{
Log.Default.WriteLine(LogLevels.Debug, "PlacePiece {0} {1} {2} {3} {4},{5} {6}", pieceIndex, highestIndex, piece, orientation, posX, posY, grid?.Count(x => x > 0) ?? -1);
IPlayer player = PlayerManager[callback];
if (player != null)
{
player.ResetTimeout(); // player alive
//
HostPiecePlaced?.Invoke(player, pieceIndex, highestIndex, piece, orientation, posX, posY, grid);
}
else
{
Log.Default.WriteLine(LogLevels.Warning, "PlacePiece from unknown player");
}
}
public virtual void EarnAchievement(ITetriNETCallback callback, int achievementId, string achievementTitle)
{
Log.Default.WriteLine(LogLevels.Debug, "EarnAchievement {0} {1}", achievementId, achievementTitle);
IPlayer player = PlayerManager[callback];
if (player != null)
{
//
player.ResetTimeout(); // player alive
//
HostEarnAchievement?.Invoke(player, achievementId, achievementTitle);
}
else
{
Log.Default.WriteLine(LogLevels.Warning, "EarnAchievement from unknown player");
}
}
public virtual void ResetWinList(ITetriNETCallback callback)
{
Log.Default.WriteLine(LogLevels.Debug, "ResetWinList");
IPlayer player = PlayerManager[callback];
if (player != null)
{
//
player.ResetTimeout(); // player alive
//
HostResetWinList?.Invoke(player);
}
else
{
Log.Default.WriteLine(LogLevels.Warning, "ResetWinList from unknown player");
}
}
public virtual void BanPlayer(ITetriNETCallback callback, int playerId)
{
Log.Default.WriteLine(LogLevels.Debug, "BanPlayer {0}", playerId);
IPlayer player = PlayerManager[callback];
if (player != null)
{
//
player.ResetTimeout(); // player alive
//
HostBanPlayer?.Invoke(player, playerId);
}
else
{
Log.Default.WriteLine(LogLevels.Warning, "BanPlayer from unknown player");
}
}
public virtual void ChangeOptions(ITetriNETCallback callback, GameOptions options)
{
Log.Default.WriteLine(LogLevels.Debug, "ChangeOptions {0}", options);
IPlayer player = PlayerManager[callback];
if (player != null)
{
//
player.ResetTimeout(); // player alive
//
HostChangeOptions?.Invoke(player, options);
}
else
{
Log.Default.WriteLine(LogLevels.Warning, "ChangeOptions from unknown player");
}
}
public virtual void FinishContinuousSpecial(ITetriNETCallback callback, Specials special)
{
Log.Default.WriteLine(LogLevels.Debug, "FinishContinuousSpecial {0}", special);
IPlayer player = PlayerManager[callback];
if (player != null)
{
//
player.ResetTimeout(); // player alive
//
HostFinishContinuousSpecial?.Invoke(player, special);
}
else
{
Log.Default.WriteLine(LogLevels.Warning, "FinishContinuousSpecial from unknown player");
}
}
public virtual void ClearLines(ITetriNETCallback callback, int count)
{
Log.Default.WriteLine(LogLevels.Debug, "ClearLines {0}", count);
IPlayer player = PlayerManager[callback];
if (player != null)
{
//
player.ResetTimeout(); // player alive
//
HostClearLines?.Invoke(player, count);
}
else
{
Log.Default.WriteLine(LogLevels.Warning, "ClearLines from unknown player");
}
}
public virtual void PublishMessage(ITetriNETCallback callback, string msg)
{
Log.Default.WriteLine(LogLevels.Debug, "PublishMessage {0}", msg);
IPlayer player = PlayerManager[callback];
if (player != null)
{
//
player.ResetTimeout(); // player alive
//
HostMessagePublished?.Invoke(player, msg);
}
else
{
Log.Default.WriteLine(LogLevels.Warning, "PublishMessage from unknown player");
}
}
public virtual void PlayerTeam(ITetriNETCallback callback, string team)
{
Log.Default.WriteLine(LogLevels.Debug, "PlayerTeam {0}", team);
IPlayer player = PlayerManager[callback];
if (player != null)
{
//
player.ResetTimeout(); // player alive
//
HostPlayerTeamChanged?.Invoke(player, team);
}
else
{
Log.Default.WriteLine(LogLevels.Warning, "Heartbeat from unknown player");
}
}
public virtual void PublishSpectatorMessage(ITetriNETCallback callback, string msg)
{
Log.Default.WriteLine(LogLevels.Debug, "PublishMessage {0}", msg);
ISpectator spectator = SpectatorManager[callback];
if (spectator != null)
{
//
spectator.ResetTimeout(); // player alive
//
HostSpectatorMessagePublished?.Invoke(spectator, msg);
}
else
{
Log.Default.WriteLine(LogLevels.Warning, "OnSpectatorMessagePublished from unknown spectator");
}
}
public virtual void ModifyGrid(ITetriNETCallback callback, byte[] grid)
{
Log.Default.WriteLine(LogLevels.Debug, "ModifyGrid {0}", grid?.Count(x => x > 0) ?? -1);
IPlayer player = PlayerManager[callback];
if (player != null)
{
//
player.ResetTimeout(); // player alive
//
HostGridModified?.Invoke(player, grid);
}
else
{
Log.Default.WriteLine(LogLevels.Warning, "ModifyGrid from unknown player");
}
}
public virtual void UnregisterSpectator(ITetriNETCallback callback)
{
Log.Default.WriteLine(LogLevels.Debug, "UnregisterPlayer");
ISpectator spectator = SpectatorManager[callback];
if (spectator != null)
{
//
spectator.ResetTimeout(); // player alive
//
HostSpectatorUnregistered?.Invoke(spectator);
}
else
{
Log.Default.WriteLine(LogLevels.Warning, "UnregisterSpectator from unknown spectator");
}
}
public WCFProxy(ITetriNETCallback callback, string address)
{
if (callback == null)
{
throw new ArgumentNullException(nameof(callback));
}
if (address == null)
{
throw new ArgumentNullException(nameof(address));
}
LastActionToServer = DateTime.Now;
// Get WCF endpoint
EndpointAddress endpointAddress = null;
if (String.IsNullOrEmpty(address) || address.ToLower() == "auto")
{
List <EndpointAddress> addresses = DiscoverEndpoints().ToList();
if (addresses.Any())
{
endpointAddress = addresses[0];
}
}
else
{
endpointAddress = new EndpointAddress(address);
}
// Create WCF proxy from endpoint
if (endpointAddress != null)
{
Log.Default.WriteLine(LogLevels.Debug, "Connecting to server:{0}", endpointAddress.Uri);
Binding binding = new NetTcpBinding(SecurityMode.None);
InstanceContext instanceContext = new InstanceContext(callback);
_factory = new DuplexChannelFactory <IWCFTetriNET>(instanceContext, binding, endpointAddress);
_proxy = _factory.CreateChannel(instanceContext);
}
else
{
throw new Exception(String.Format("Server {0} not found", address));
}
}
public Player(int id, string name, ITetriNETCallback callback)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (callback == null)
{
throw new ArgumentNullException(nameof(callback));
}
Id = id;
Name = name;
Callback = callback;
PieceIndex = 0;
LastActionToClient = DateTime.Now;
LastActionFromClient = DateTime.Now;
TimeoutCount = 0;
State = PlayerStates.Registered;
}
public WCFSpectatorProxy(ITetriNETCallback callback, string address)
{
if (callback == null)
{
throw new ArgumentNullException(nameof(callback));
}
if (address == null)
{
throw new ArgumentNullException(nameof(address));
}
LastActionToServer = DateTime.Now;
EndpointAddress endpointAddress = new EndpointAddress(address);
// Create WCF proxy from endpoint
Log.Default.WriteLine(LogLevels.Debug, "Connecting to server:{0}", endpointAddress.Uri);
Binding binding = new NetTcpBinding(SecurityMode.None);
InstanceContext instanceContext = new InstanceContext(callback);
_factory = new DuplexChannelFactory <IWCFTetriNETSpectator>(instanceContext, binding, endpointAddress);
_proxy = _factory.CreateChannel(instanceContext);
}
public ISpectator CreateSpectator(int id, string name, ITetriNETCallback callback)
{
return(new Spectator(id, name, callback));
}
public IPlayer CreatePlayer(int id, string name, ITetriNETCallback callback)
{
return(new Player(id, name, callback));
}
public void HeartbeatSpectator(ITetriNETCallback callback)
{
ExceptionFreeAction(_proxy.HeartbeatSpectator);
}
public void UnregisterSpectator(ITetriNETCallback callback)
{
ExceptionFreeAction(_proxy.UnregisterSpectator);
}
public void RegisterSpectator(ITetriNETCallback callback, Versioning clientVersion, string spectatorName)
{
ExceptionFreeAction(() => _proxy.RegisterSpectator(clientVersion, spectatorName));
}
public void PublishSpectatorMessage(ITetriNETCallback callback, string msg)
{
ExceptionFreeAction(() => _proxy.PublishSpectatorMessage(msg));
}
public ISpectatorProxy CreateSpectatorProxy(ITetriNETCallback callback, string address)
{
return(new WCFSpectatorProxy(callback, address));
}
public IProxy CreatePlayerProxy(ITetriNETCallback callback, string address)
{
return(new WCFProxy(callback, address));
}
