public void TestHistory()
{
IPieceProvider pieceProvider = CreatePieceProvider();
pieceProvider.Occurancies = () => new[] {
new PieceOccurancy
{
Occurancy = 25,
Value = Pieces.TetriminoI
},
new PieceOccurancy
{
Occurancy = 25,
Value = Pieces.TetriminoJ
},
new PieceOccurancy
{
Occurancy = 25,
Value = Pieces.TetriminoL
},
new PieceOccurancy
{
Occurancy = 25,
Value = Pieces.TetriminoO
}
};
Pieces piece1 = pieceProvider[0];
Pieces piece2 = pieceProvider[1];
Pieces piece3 = pieceProvider[2];
Pieces piece4 = pieceProvider[3];
Pieces piece5 = pieceProvider[4];
Assert.AreEqual(piece5, Pieces.Invalid);
}
public Game(IActionQueue actionQueue, IPieceProvider pieceProvider, string name, int maxPlayers, int maxSpectators, GameRules rule, GameOptions options, string password = null)
{
if (actionQueue == null)
throw new ArgumentNullException("actionQueue");
if (pieceProvider == null)
throw new ArgumentNullException("pieceProvider");
if (name == null)
throw new ArgumentNullException("name");
if (maxPlayers <= 0)
throw new ArgumentOutOfRangeException("maxPlayers", "maxPlayers must be strictly positive");
if (maxSpectators <= 0)
throw new ArgumentOutOfRangeException("maxSpectators", "maxSpectators must be strictly positive");
if (options == null)
throw new ArgumentNullException("options");
Id = Guid.NewGuid();
_actionQueue = actionQueue;
_pieceProvider = pieceProvider;
_pieceProvider.Occurancies = () => options.PieceOccurancies;
Name = name;
CreationTime = DateTime.Now;
MaxPlayers = maxPlayers;
MaxSpectators = maxSpectators;
Rule = rule;
Options = options;
Password = password;
State = GameStates.Created;
_specialId = 0;
_isSuddenDeathActive = false;
_gameStatistics = new Dictionary<string, GameStatisticsByPlayer>();
_winList = new List<WinEntry>();
_suddenDeathTimer = new Timer(SuddenDeathCallback, null, Timeout.Infinite, 0);
_voteKickTimer = new Timer(VoteKickCallback, null, Timeout.Infinite, 0);
}
public Server(IPlayerManager playerManager, ISpectatorManager spectatorManager, IPieceProvider pieceProvider, IActionQueue gameActionQueue)
{
if (playerManager == null)
{
throw new ArgumentNullException(nameof(playerManager));
}
Options = new GameOptions();
Options.ResetToDefault();
_pieceProvider = pieceProvider;
_pieceProvider.Occurancies = () => Options.PieceOccurancies;
_playerManager = playerManager;
_spectatorManager = spectatorManager;
_gameActionQueue = gameActionQueue;
_hosts = new List <IHost>();
Assembly entryAssembly = Assembly.GetEntryAssembly();
if (entryAssembly != null)
{
Version version = entryAssembly.GetName().Version;
Version = new Versioning
{
Major = version.Major,
Minor = version.Minor,
};
}// else, we suppose SetVersion will be called later, before connecting
_gameStatistics = new Dictionary <string, GameStatisticsByPlayer>();
_winList = new List <WinEntry>();
State = ServerStates.WaitingStartServer;
}
public Board(int width, int height, IPieceProvider pieceProvider)
{
this.width = width;
this.height = height;
this.pieceProvider = pieceProvider;
top = height - 1;
}
private void Construct(EventManager eventManager,
IWallVerifier wallVerifier,
ICaptureVerifier captureVerifier,
IPieceProvider pieceProvider)
{
_eventManager = eventManager;
_wallVerifier = wallVerifier;
_captureVerifier = captureVerifier;
_pieceProvider = pieceProvider;
}
public void TestGetFirstPieceIsValid()
{
IPieceProvider pieceProvider = CreatePieceProvider();
pieceProvider.Occurancies = () => new[] { new PieceOccurancy
{
Occurancy = 100,
Value = Pieces.TetriminoI
} };
Pieces piece = pieceProvider[0];
Assert.AreEqual(piece, Pieces.TetriminoI);
}
private IServer CreateServerWithHost()
{
_factory = new FactoryMock();
IPlayerManager playerManager = _factory.CreatePlayerManager(6);
ISpectatorManager spectatorManager = _factory.CreateSpectatorManager(10);
IBanManager banManager = _factory.CreateBanManager();
IPieceProvider pieceProvider = _factory.CreatePieceProvider();
_host = new HostBaseMock(playerManager, spectatorManager, banManager, _factory);
_actionQueue = _factory.CreateActionQueue() as ActionQueueMock;
IServer server = new TetriNET.Server.Server(playerManager, spectatorManager, pieceProvider, _actionQueue);
server.AddHost(_host);
return(server);
}
public void TestExceptionIfOccuranciesIsNull()
{
IPieceProvider pieceProvider = CreatePieceProvider();
try
{
Pieces piece = pieceProvider[0];
Assert.Fail("No Exception raised");
}
catch (Exception ex)
{
Assert.IsTrue(true);
}
}
private void ServiceMainLoop()
{
//
IFactory factory = new Factory();
//
IBanManager banManager = factory.CreateBanManager();
//
IPlayerManager playerManager = factory.CreatePlayerManager(6);
ISpectatorManager spectatorManager = factory.CreateSpectatorManager(10);
//
IHost wcfHost = new Server.WCFHost.WCFHost(
playerManager,
spectatorManager,
banManager,
factory)
{
Port = ConfigurationManager.AppSettings["port"]
};
//
IActionQueue actionQueue = new BlockingActionQueue();
//
IPieceProvider pieceProvider = factory.CreatePieceProvider();
//
IServer server = new Server.Server(playerManager, spectatorManager, pieceProvider, actionQueue);
server.AddHost(wcfHost);
//
try
{
server.StartServer();
while (!_cancellationTokenSource.IsCancellationRequested)
{
Thread.Sleep(250);
}
server.StopServer();
}
catch (Exception ex)
{
Log.Default.WriteLine(LogLevels.Error, "Error while running server. Exception {0}", ex);
}
}
public void TestReset()
{
IPieceProvider pieceProvider = CreatePieceProvider();
pieceProvider.Occurancies = () => new[] {
new PieceOccurancy
{
Occurancy = 25,
Value = Pieces.TetriminoI
},
new PieceOccurancy
{
Occurancy = 25,
Value = Pieces.TetriminoJ
},
new PieceOccurancy
{
Occurancy = 25,
Value = Pieces.TetriminoL
},
new PieceOccurancy
{
Occurancy = 25,
Value = Pieces.TetriminoO
}
};
Pieces p1 = pieceProvider[0];
Pieces p2 = pieceProvider[1];
Pieces p3 = pieceProvider[2];
Pieces p4 = pieceProvider[3];
Reset(pieceProvider);
Pieces piece1 = pieceProvider[0];
Pieces piece2 = pieceProvider[1];
Pieces piece3 = pieceProvider[2];
Pieces piece4 = pieceProvider[3];
Assert.AreEqual(piece1, Pieces.TetriminoI);
Assert.AreEqual(piece2, Pieces.TetriminoJ);
Assert.AreEqual(piece3, Pieces.TetriminoL);
Assert.AreEqual(piece4, Pieces.TetriminoO);
}
private void Construct(PhysicsCache physicsCache,
EventManager eventManager,
IRayProvider rayProvider,
ISelector2D selector,
IPieceProvider pieceProvider,
IGameFinisher gameFinisher,
IPhaseManager phaseManager,
ITurnManager turnManager,
IMovementValidator movementValidator)
{
_physicsCache = physicsCache;
_eventManager = eventManager;
_rayProvider = rayProvider;
_selector = selector;
_pieceProvider = pieceProvider;
_gameFinisher = gameFinisher;
_phaseManager = phaseManager;
_turnManager = turnManager;
_movementValidator = movementValidator;
}
private void Construct(PhysicsCache physicsCache,
EventManager eventManager,
IRayProvider rayProvider,
ISelector selector,
IFieldProvider fieldProvider,
IPieceProvider pieceProvider,
ICaptureVerifier captureVerifier,
IGameFinisher gameFinisher,
IPhaseManager phaseManager,
ITurnManager turnManager,
IWallVerifier wallVerifier)
{
_physicsCache = physicsCache;
_eventManager = eventManager;
_rayProvider = rayProvider;
_selector = selector;
_fieldProvider = fieldProvider;
_pieceProvider = pieceProvider;
_captureVerifier = captureVerifier;
_gameFinisher = gameFinisher;
_phaseManager = phaseManager;
_turnManager = turnManager;
_wallVerifier = wallVerifier;
}
static void Main(string[] args)
{
Log.Default.Initialize(ConfigurationManager.AppSettings["logpath"], "server.log");
Version version = Assembly.GetEntryAssembly().GetName().Version;
string company = ((AssemblyCompanyAttribute)Attribute.GetCustomAttribute(Assembly.GetExecutingAssembly(), typeof(AssemblyCompanyAttribute), false)).Company;
string product = ((AssemblyProductAttribute)Attribute.GetCustomAttribute(Assembly.GetExecutingAssembly(), typeof(AssemblyProductAttribute), false)).Product;
Log.Default.WriteLine(LogLevels.Info, "{0} {1}.{2} by {3}", product, version.Major, version.Minor, company);
//
IFactory factory = new Factory();
//
IBanManager banManager = factory.CreateBanManager();
//
IPlayerManager playerManager = factory.CreatePlayerManager(6);
ISpectatorManager spectatorManager = factory.CreateSpectatorManager(10);
//
IHost wcfHost = new Server.WCFHost.WCFHost(
playerManager,
spectatorManager,
banManager,
factory)
{
Port = ConfigurationManager.AppSettings["port"]
};
//
IHost builtInHost = new BuiltInHostBase(
playerManager,
spectatorManager,
banManager,
factory);
IHost socketHost = new TCPHostBase(playerManager,
spectatorManager,
banManager,
factory)
{
Port = 5656
};
//
List <DummyBuiltInClient> clients = new List <DummyBuiltInClient>
{
//new DummyBuiltInClient("BuiltIn-Joel" + Guid.NewGuid().ToString().Substring(0, 5), () => builtInHost),
//new DummyBuiltInClient("BuiltIn-Celine" + Guid.NewGuid().ToString().Substring(0, 5), () => builtInHost)
};
//
IActionQueue actionQueue = factory.CreateActionQueue();
//
IPieceProvider pieceProvider = factory.CreatePieceProvider();
//
IServer server = new Server.Server(playerManager, spectatorManager, pieceProvider, actionQueue);
server.AddHost(wcfHost);
server.AddHost(builtInHost);
server.AddHost(socketHost);
//
try
{
server.StartServer();
}
catch (Exception ex)
{
Log.Default.WriteLine(LogLevels.Error, "Cannot start server. Exception: {0}", ex);
return;
}
DisplayHelp();
bool stopped = false;
while (!stopped)
{
if (Console.KeyAvailable)
{
ConsoleKeyInfo cki = Console.ReadKey(true);
switch (cki.Key)
{
default:
DisplayHelp();
break;
case ConsoleKey.X:
server.StopServer();
stopped = true;
break;
case ConsoleKey.S:
server.StartGame();
break;
case ConsoleKey.T:
server.StopGame();
break;
case ConsoleKey.P:
server.PauseGame();
break;
case ConsoleKey.R:
server.ResumeGame();
break;
case ConsoleKey.Add:
clients.Add(new DummyBuiltInClient("BuiltIn-" + Guid.NewGuid().ToString().Substring(0, 5), () => builtInHost));
break;
case ConsoleKey.Subtract:
{
DummyBuiltInClient client = clients.LastOrDefault();
if (client != null)
{
client.DisconnectFromServer();
clients.Remove(client);
}
break;
}
case ConsoleKey.L:
{
DummyBuiltInClient client = clients.LastOrDefault();
client?.Lose();
break;
}
case ConsoleKey.D:
Console.WriteLine("Players:");
foreach (IPlayer p in playerManager.Players)
{
Console.WriteLine("{0}) {1} [{2}] {3} {4} {5:HH:mm:ss.fff} {6:HH:mm:ss.fff}", p.Id, p.Name, p.Team, p.State, p.PieceIndex, p.LastActionFromClient, p.LastActionToClient);
}
Console.WriteLine("Spectators:");
foreach (ISpectator s in spectatorManager.Spectators)
{
Console.WriteLine("{0}) {1} {2:HH:mm:ss.fff} {3:HH:mm:ss.fff}", s.Id, s.Name, s.LastActionFromClient, s.LastActionToClient);
}
break;
case ConsoleKey.W:
foreach (WinEntry e in server.WinList)
{
Console.WriteLine("{0}[{1}]: {2} pts", e.PlayerName, e.Team, e.Score);
}
break;
case ConsoleKey.Q:
server.ResetWinList();
break;
case ConsoleKey.O:
{
GameOptions options = server.Options;
foreach (PieceOccurancy occurancy in options.PieceOccurancies)
{
Console.WriteLine("{0}:{1}", occurancy.Value, occurancy.Occurancy);
}
foreach (SpecialOccurancy occurancy in options.SpecialOccurancies)
{
Console.WriteLine("{0}:{1}", occurancy.Value, occurancy.Occurancy);
}
}
break;
case ConsoleKey.I:
{
foreach (KeyValuePair <string, GameStatisticsByPlayer> byPlayer in server.GameStatistics)
{
GameStatisticsByPlayer stats = byPlayer.Value;
string playerName = byPlayer.Key;
Console.WriteLine("{0}) {1} : 1:{2} 2:{3} 3:{4} 4:{5}", byPlayer.Key, playerName, stats.SingleCount, stats.DoubleCount, stats.TripleCount, stats.TetrisCount);
foreach (KeyValuePair <Specials, Dictionary <string, int> > bySpecial in stats.SpecialsUsed)
{
Console.WriteLine("Special {0}", bySpecial.Key);
foreach (KeyValuePair <string, int> kv in bySpecial.Value)
{
string otherName = kv.Key;
Console.WriteLine("\t{0}:{1}", otherName, kv.Value);
}
}
}
break;
}
}
}
else
{
System.Threading.Thread.Sleep(100);
Parallel.ForEach(
clients,
client => client.Test());
}
}
}
protected IGame CreateGame(IActionQueue actionQueue, IPieceProvider pieceProvider, string name, int maxPlayers, int maxSpectators, GameRules rule, GameOptions options, string password = null)
{
ActionQueue = actionQueue as ActionQueueMock;
PieceProvider = pieceProvider as PieceProviderMock;
return new Game(actionQueue, pieceProvider, name, maxPlayers, maxSpectators, rule, options, password);
}
protected virtual void Reset(IPieceProvider provider)
{
provider.Reset();
}
protected virtual void Reset(IPieceProvider provider)
{
provider.Reset();
}
protected override void Reset(IPieceProvider provider)
{
_index = 0;
base.Reset(provider);
}
