public override void OnTick(ConnectionBuffer buffer)
{
if (Active)
{
buffer.Add(new PlayerUpdatePacket(-1, Health, _sprite.Position, _playerController.Velocity, _playerController.Direction));
}
}
public override void OnUpdate(float deltatime, EntityManager entityManager, ConnectionBuffer buffer, RenderWindow window)
{
if (_target.HasDeletionMark())
{
MarkForDeletion();
}
}
public EchoServer(NetworkConfig config, IMessenger messenger)
{
_config = config;
_messenger = messenger;
_bufferedClient = new ConnectionBuffer(Guid.NewGuid(), _config.NumberOfThreads);
_messageDictionary = new Dictionary <MessageType, Action <Byte[]> >()
{
{ MessageType.Number, HandleNumberMessage },
{ MessageType.KeepAlive, (data) => { } },
{ MessageType.ConnectionRequest, (data) => { } },
{ MessageType.State, (data) => { } },
};
_messenger = messenger;
_messenger.Register <StartCommandEnteredMessage>(this, OnStartCommandEntered);
_messenger.Register <StopCommandEnteredMessage>(this, OnStopCommandEntered);
_messenger.Register <ExitCommandEnteredMessage>(this, OnExitCommandEntered);
_connectedMres = new ManualResetEventSlim(true);
_echoSendFileWriter = new FileWriter("echo_send.txt");
ThreadPool.QueueUserWorkItem(ConnectionControlThread);
ThreadPool.QueueUserWorkItem(ReadingMessagesThread);
_serverState = ServerState.Suspended;
_messenger.Send(new ConsoleMessage($"{Type}... {_serverState}"));
}
public void OnTick(ConnectionBuffer buffer)
{
foreach (IEntity e in _entities)
{
e.OnTick(buffer);
}
}
public static byte[] Read(this ConnectionBuffer buffer, int size)
{
byte[] result = new byte[size];
Buffer.BlockCopy(buffer.Data, buffer.ReadIndex, result, 0, size);
buffer.ReadIndex += size;
return(result);
}
public static int ReadShort(this ConnectionBuffer buffer)
{
int result = buffer.Data[buffer.ReadIndex++] << 8;
result += buffer.Data[buffer.ReadIndex++];
return(result);
}
public override void OnCreate()
{
_connectionBuffer = new ConnectionBuffer(_serverConnection);
font = new Font("res/fonts/defaultFont.ttf");
_curLevel = new TileMap("res/maps/test.tmx");
_entityManager._tilemap = (TileMap)_curLevel;
}
public override void OnUpdate(float deltatime, EntityManager entityManager, ConnectionBuffer buffer, RenderWindow window)
{
_time -= deltatime;
if (_time < 0.0f)
{
MarkForDeletion();
}
}
public GameClient(RootConfig config, IMessenger messenger, IPipeline <NetworkMessage> networkMessagePipe)
{
_config = config;
_messenger = messenger;
_networkMessagePipe = networkMessagePipe;
_bufferedClient = new ConnectionBuffer(false);
_messenger.Register <NumberGeneratedMessage>(this, OnNumberGenerated);
_workingMres = new ManualResetEventSlim(false);
_connectedMres = new ManualResetEventSlim(false);
ThreadPool.QueueUserWorkItem(ConnectionControlThread);
ThreadPool.QueueUserWorkItem(ReadingMessagesThread);
}
public void Update(float deltaTime, ConnectionBuffer buffer, RenderWindow window)
{
lock (_buffer)
while (_buffer.Count != 0)
{
_entities.Add(_buffer.Dequeue());
}
foreach (IEntity e in _entities)
{
e.OnUpdate(deltaTime, this, buffer, window);
}
DeleteMarkedEntities();
}
public void Setup()
{
var provider = new MockConnectionProvider (SocialProtocol.Instance);
provider.ConnectionMade += (sender, args) => server = new ConnectionBuffer (args.Connection);
provider.Start (MessageTypes.Reliable);
var c = new MockClientConnection (provider);
client = new ConnectionBuffer (c);
clientContext = new SerializationContext (c, new Dictionary<byte, Protocol> { { 2, SocialProtocol.Instance } });
var context = new TempestClient (c, MessageTypes.Reliable);
context.ConnectAsync (new Target (Target.LoopbackIP, 1)).Wait();
list = new WatchList (context);
}
public RoomMember(Guid sessionId, TcpClient client, String nickName, IMessenger roomMessenger, Boolean sendEcho)
{
SessionId = sessionId;
_nickName = nickName;
_roomMessenger = roomMessenger;
_sendEcho = sendEcho;
_buffer = new ConnectionBuffer(true);
_buffer.SetClient(client);
_messageDictionary = new Dictionary <MessageType, Action <Byte[]> >()
{
{ MessageType.Text, HandleTextMessage },
{ MessageType.KeepAlive, (data) => { } }
};
roomMessenger.Register <TextReceiveMessage>(this, RoomMessageTextReceived);
ThreadPool.QueueUserWorkItem(MessageProcessingThread);
}
public void FixedUpdate(float fixedDeltaTime, ConnectionBuffer buffer, RenderWindow window)
{
Vector2f prevPos = ActivePlayer.getPosition();
lock (_buffer)
while (_buffer.Count != 0)
{
_entities.Add(_buffer.Dequeue());
}
foreach (IEntity e in _entities)
{
e.OnFixedUpdate(fixedDeltaTime, this, buffer, window);
}
DeleteMarkedEntities();
}
private void CheckWhoIsIt(TcpClient client)
{
try
{
var stream = client.GetStream();
var responce = stream.ReadObject <NetworkMessage>();
if (responce.Type != MessageType.ConnectionRequest)
{
return;
}
if (responce.Data == null)
{
return;
}
var serverType = (ServerType)BitConverter.ToInt32(responce.Data, 0);
switch (serverType)
{
case ServerType.Initiator:
if (_initiatorClient == null)
{
_initiatorClient = new ConnectionBuffer(responce.SessionId.ToGuid(), _config.NumberOfThreads);
}
_initiatorClient.SetClient(client);
break;
case ServerType.Echo:
if (_initiatorClient == null)
{
_echoClient = new ConnectionBuffer(responce.SessionId.ToGuid(), _config.NumberOfThreads);
}
_echoClient.SetClient(client);
break;
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
throw;
}
}
public void Setup()
{
var provider = new MockConnectionProvider(SocialProtocol.Instance);
provider.ConnectionMade += (sender, args) => server = new ConnectionBuffer(args.Connection);
provider.Start(MessageTypes.Reliable);
var c = new MockClientConnection(provider);
client = new ConnectionBuffer(c);
clientContext = new SerializationContext(c, new Dictionary <byte, Protocol> {
{ 2, SocialProtocol.Instance }
});
var context = new TempestClient(c, MessageTypes.Reliable);
context.ConnectAsync(new Target(Target.LoopbackIP, 1)).Wait();
list = new WatchList(context);
}
public static int FindSequence(this ConnectionBuffer buffer, byte[] sequence)
{
for (int i = buffer.ReadIndex; i < buffer.WriteIndex - sequence.Length + 1; i++)
{
bool contains = true;
for (int j = 0; j < sequence.Length; j++)
{
if (buffer.Data[i + j] != sequence[j])
{
contains = false;
break;
}
}
if (contains)
{
return(i - buffer.ReadIndex);
}
}
return(-1);
}
private IUserInfo Join(bool loggedIn, ConnectionBuffer connection, string nickname, string serverPassword)
{
connection.SendAsync (new JoinMessage (nickname, serverPassword));
var joinResultMessage = connection.DequeueAndAssertMessage<JoinResultMessage>();
Assert.AreEqual (LoginResultState.Success, joinResultMessage.Result);
if (!loggedIn)
{
connection.DequeueAndAssertMessage<PermissionsMessage>();
}
var userJoinedMessage = connection.DequeueAndAssertMessage<UserJoinedMessage>();
IUserInfo user = userJoinedMessage.UserInfo;
Assert.AreEqual (nickname, userJoinedMessage.UserInfo.Nickname);
Assert.AreEqual (joinResultMessage.UserInfo.Username, userJoinedMessage.UserInfo.Username);
Assert.AreEqual (joinResultMessage.UserInfo.UserId, userJoinedMessage.UserInfo.UserId);
Assert.AreEqual (joinResultMessage.UserInfo.CurrentChannelId, userJoinedMessage.UserInfo.CurrentChannelId);
//connection.Client.DequeueAndAssertMessage<ChannelListMessage>();
//var usermsg = connection.Client.DequeueAndAssertMessage<UserInfoListMessage>();
//Assert.IsNotNull (usermsg.Users.FirstOrDefault (u => u.UserId == userJoinedMessage.UserInfo.UserId));
//connection.Client.DequeueAndAssertMessage<SourceListMessage>();
return user;
}
public void RequestChannelList()
{
var cs = provider.GetConnections (GablarskiProtocol.Instance);
var connection = new ConnectionBuffer (cs.Item1);
connection.SendAsync (new RequestChannelListMessage ());
Message message = connection.DequeueMessage ();
Assert.IsInstanceOf<ChannelListMessage> (message);
var list = (ChannelListMessage)message;
Assert.AreEqual (GenericResult.Success, list.Result);
Assert.IsNotNull (list.Channels);
CollectionAssert.IsNotEmpty (list.Channels);
}
private ConnectionBuffer Connect()
{
var cs = provider.GetConnections (GablarskiProtocol.Instance);
var connection = new ConnectionBuffer (cs.Item1);
connection.SendAsync (new ConnectMessage { ProtocolVersion = GablarskiProtocol.Instance.Version, Host = "test", Port = 42912 });
connection.DequeueAndAssertMessage<ServerInfoMessage>();
connection.DequeueAndAssertMessage<ChannelListMessage>();
connection.DequeueAndAssertMessage<UserInfoListMessage>();
connection.DequeueAndAssertMessage<SourceListMessage>();
return connection;
}
public void SetCommentSameComment()
{
JoinAsGuest (server, client, "Nickname");
var cs = provider.GetConnections (GablarskiProtocol.Instance);
var s = new ConnectionBuffer (cs.Item2);
var c = new ConnectionBuffer (cs.Item1);
JoinAsGuest (s, c, "Nickname2");
client.DequeueAndAssertMessage<UserJoinedMessage>();
handler.OnSetCommentMessage (new MessageEventArgs<SetCommentMessage> (server,
new SetCommentMessage ("comment")));
var update = c.DequeueAndAssertMessage<UserUpdatedMessage>();
Assert.AreEqual ("comment", update.User.Comment);
handler.OnSetCommentMessage (new MessageEventArgs<SetCommentMessage> (server,
new SetCommentMessage ("comment")));
c.AssertNoMessage();
}
public void RedirectMatch()
{
server.AddRedirector (new MockRedirector ("monkeys.com", new IPEndPoint (IPAddress.Any, 6113)));
var cs = provider.GetConnections (GablarskiProtocol.Instance);
var connection = new ConnectionBuffer (cs.Item1);
connection.SendAsync (new ConnectMessage { ProtocolVersion = GablarskiProtocol.Instance.Version,
Host = "monkeys.com", Port = 42912 });
var msg = connection.DequeueAndAssertMessage<RedirectMessage>();
Assert.AreEqual (IPAddress.Any.ToString(), msg.Host);
Assert.AreEqual (6113, msg.Port);
}
public void SetPermissionsNotConnected()
{
permissions.UpdatedSupported = true;
var u = UserInfoTests.GetTestUser();
permissions.EnablePermissions (u.UserId, PermissionName.ModifyPermissions);
var cs = provider.GetConnections (GablarskiProtocol.Instance);
var c = new ConnectionBuffer (cs.Item1);
cs.Item2.DisconnectAsync().Wait();
handler.OnSetPermissionsMessage (new MessageEventArgs<SetPermissionsMessage> (c,
new SetPermissionsMessage (u, new Permission[0])));
c.AssertNoMessage();
}
public void ManagerSetup()
{
this.provider = new MockConnectionProvider (GablarskiProtocol.Instance);
this.provider.Start (MessageTypes.All);
var cs = this.provider.GetConnections (GablarskiProtocol.Instance);
this.server = new ConnectionBuffer (cs.Item2);
this.manager = new ClientChannelManager (new MockClientContext (cs.Item1));
}
public async Task RegisterNotConnected()
{
var cs = provider.GetConnections (GablarskiProtocol.Instance);
var s = new ConnectionBuffer (cs.Item2);
var c = new ConnectionBuffer (cs.Item1);
await s.DisconnectAsync();
handler.OnRegisterMessage (new MessageEventArgs<RegisterMessage> (s,
new RegisterMessage ("username", "password")));
c.AssertNoMessage();
}
public void RegisterPreapprovedApproved()
{
var cs = provider.GetConnections (GablarskiProtocol.Instance);
var s = new ConnectionBuffer (cs.Item2);
var c = new ConnectionBuffer (cs.Item1);
var u = JoinAsGuest (s, c, "nick");
users.UpdateSupported = true;
users.RegistrationMode = UserRegistrationMode.PreApproved;
handler.ApproveRegistration (u);
handler.OnRegisterMessage (new MessageEventArgs<RegisterMessage> (s,
new RegisterMessage ("username", "password")));
var msg = c.DequeueAndAssertMessage<RegisterResultMessage>();
Assert.AreEqual (RegisterResult.Success, msg.Result);
}
public void SetPermissionsOtherConnected()
{
var cs = provider.GetConnections (GablarskiProtocol.Instance);
var s1 = new ConnectionBuffer (cs.Item2);
var c1 = new ConnectionBuffer (cs.Item1);
var u1 = JoinAsGuest (s1, c1, "nick");
permissions.UpdatedSupported = true;
permissions.EnablePermissions (u1.UserId, PermissionName.ModifyPermissions);
cs = provider.GetConnections (GablarskiProtocol.Instance);
var s2 = new ConnectionBuffer (cs.Item2);
var c2 = new ConnectionBuffer (cs.Item1);
var u2 = JoinAsGuest (s2, c2, "nick2");
handler.OnSetPermissionsMessage (new MessageEventArgs<SetPermissionsMessage> (s1,
new SetPermissionsMessage (u2, new []
{
new Permission (PermissionName.SendAudio, true),
new Permission (PermissionName.SendAudioToMultipleTargets, false),
new Permission (PermissionName.KickPlayerFromChannel, true) { ChannelId = 1 },
})));
var msg = c2.DequeueAndAssertMessage<PermissionsMessage>();
Assert.AreEqual (u2.UserId, msg.OwnerId);
var perms = msg.Permissions.ToList();
perms.Single (p => p.ChannelId == 0 && p.Name == PermissionName.SendAudio && p.IsAllowed);
perms.Single (p => p.ChannelId == 0 && p.Name == PermissionName.SendAudioToMultipleTargets && !p.IsAllowed);
perms.Single (p => p.ChannelId == 1 && p.Name == PermissionName.KickPlayerFromChannel && p.IsAllowed);
}
public void Setup()
{
permissions = new MockPermissionsProvider();
users = new MockUserProvider();
provider = new MockConnectionProvider (GablarskiProtocol.Instance);
context = new MockServerContext (provider)
{
Settings = new ServerSettings(),
UserProvider = users,
PermissionsProvider = permissions,
ChannelsProvider = new LobbyChannelProvider(),
};
context.Sources = new ServerSourceHandler (context, new ServerSourceManager (context));
context.Channels = new ServerChannelHandler (context);
context.UserManager = new ServerUserManager();
context.Users = handler = new ServerUserHandler (context, context.UserManager);
context.Start();
var cs = provider.GetConnections (GablarskiProtocol.Instance);
server = new ServerConnectionBuffer (cs.Item2);
client = new ConnectionBuffer (cs.Item1);
var observers = provider.GetConnections (GablarskiProtocol.Instance);
sobserver = observers.Item2;
observer = new ConnectionBuffer (observers.Item1);
}
public void SetPermissionsUnsupported()
{
var cs = provider.GetConnections (GablarskiProtocol.Instance);
var s = new ConnectionBuffer (cs.Item2);
var c = new ConnectionBuffer (cs.Item1);
var u = JoinAsGuest (s, c, "nick");
permissions.EnablePermissions (u.UserId, PermissionName.ModifyPermissions);
handler.OnSetPermissionsMessage (new MessageEventArgs<SetPermissionsMessage> (s,
new SetPermissionsMessage (u, new []
{
new Permission (PermissionName.SendAudio, true),
new Permission (PermissionName.SendAudioToMultipleTargets, false),
new Permission (PermissionName.KickPlayerFromChannel, true) { ChannelId = 1 },
})));
c.AssertNoMessage();
}
public void SetPermissionsNoPermissions()
{
permissions.UpdatedSupported = true;
var cs = provider.GetConnections (GablarskiProtocol.Instance);
var s = new ConnectionBuffer (cs.Item2);
var c = new ConnectionBuffer (cs.Item1);
var u = JoinAsGuest (s, c, "nick");
permissions.EnablePermissions (u.UserId, PermissionName.ModifyPermissions);
handler.OnSetPermissionsMessage (new MessageEventArgs<SetPermissionsMessage> (s,
new SetPermissionsMessage (u, new Permission[0])));
c.AssertNoMessage();
}
public void SetPermissionsNotAllowed()
{
permissions.UpdatedSupported = true;
var cs = provider.GetConnections (GablarskiProtocol.Instance);
var s = new ConnectionBuffer (cs.Item2);
var c = new ConnectionBuffer (cs.Item1);
var u = JoinAsGuest (s, c, "nick");
handler.OnSetPermissionsMessage (new MessageEventArgs<SetPermissionsMessage> (s,
new SetPermissionsMessage (u, new Permission[0])));
Assert.AreEqual (GablarskiMessageType.SetPermissions, c.DequeueAndAssertMessage<PermissionDeniedMessage>().DeniedMessage);
}
public void ManagerSetup()
{
this.provider = new MockConnectionProvider (GablarskiProtocol.Instance);
this.provider.Start (MessageTypes.All);
var connections = this.provider.GetConnections (GablarskiProtocol.Instance);
this.server = new ConnectionBuffer (connections.Item2);
this.client = connections.Item1;
context = new MockClientContext (this.client);
var channels = new ClientChannelManager (context);
ClientChannelManagerTests.PopulateChannels (channels, server);
context.Users = new ClientUserHandler (context, new ClientUserManager());
context.Channels = channels;
context.CurrentUser = new CurrentUser (context, 1, "Foo", channels.First().ChannelId);
this.manager = new ClientSourceManager (context);
}
public void PreApproveRegistrationUnsupported()
{
var cs = provider.GetConnections (GablarskiProtocol.Instance);
var s = new ConnectionBuffer (cs.Item2);
var c = new ConnectionBuffer (cs.Item1);
var u = JoinAsGuest (s, c, "nick");
users.UpdateSupported = false;
users.RegistrationMode = UserRegistrationMode.None;
Assert.Throws<NotSupportedException> (() => handler.ApproveRegistration (u));
}
public override void OnFixedUpdate(float fixedDeltatime, EntityManager entityManager, ConnectionBuffer buffer, RenderWindow window)
{
// Update the player controller
_playerController.Position = _sprite.Position;
_playerController.FixedUpdate(window, fixedDeltatime);
_sprite.Position = _playerController.Position;
if (_playerController.DeletionMark)
{
MarkForDeletion();
}
}
public static byte Read(this ConnectionBuffer buffer)
{
return(buffer.Data[buffer.ReadIndex++]);
}
public abstract void OnTick(ConnectionBuffer buffer);
public void KickUserNotConnected()
{
var cs = provider.GetConnections (GablarskiProtocol.Instance);
var s = new ConnectionBuffer (cs.Item2);
var c = new ConnectionBuffer (cs.Item1);
var u = JoinAsGuest (s, c, "nick");
handler.OnKickUserMessage (new MessageEventArgs<KickUserMessage> (server,
new KickUserMessage (u, true)));
c.AssertNoMessage();
}
public void SetStatus ()
{
JoinAsGuest (server, client, "Nickname");
var cs = provider.GetConnections (GablarskiProtocol.Instance);
var s = new ConnectionBuffer (cs.Item2);
var c = new ConnectionBuffer (cs.Item1);
JoinAsGuest (s, c, "Nickname2");
client.DequeueAndAssertMessage<UserJoinedMessage>();
handler.OnSetStatusMessage (new MessageEventArgs<SetStatusMessage> (server,
new SetStatusMessage (UserStatus.MutedMicrophone)));
var update = c.DequeueAndAssertMessage<UserUpdatedMessage>();
Assert.AreEqual (UserStatus.MutedMicrophone, update.User.Status);
}
public void KickUserChannelNotAllowed()
{
var cs = provider.GetConnections (GablarskiProtocol.Instance);
var s = new ConnectionBuffer (cs.Item2);
var c = new ConnectionBuffer (cs.Item1);
var admin = JoinAsGuest (s, c, "admin");
client.DequeueAndAssertMessage<UserJoinedMessage>();
var target = JoinAsGuest (server, client, "target");
c.DequeueAndAssertMessage<UserJoinedMessage>();
handler.OnKickUserMessage (new MessageEventArgs<KickUserMessage> (s,
new KickUserMessage (target, false)));
Assert.AreEqual (GablarskiMessageType.KickUser, c.DequeueAndAssertMessage<PermissionDeniedMessage>().DeniedMessage);
permissions.EnablePermissions (admin.UserId, PermissionName.KickPlayerFromServer);
handler.OnKickUserMessage (new MessageEventArgs<KickUserMessage> (s,
new KickUserMessage (target, false)));
Assert.AreEqual (GablarskiMessageType.KickUser, c.DequeueAndAssertMessage<PermissionDeniedMessage>().DeniedMessage);
}
public void OldVersionReject()
{
var cs = provider.GetConnections (GablarskiProtocol.Instance);
var connection = new ConnectionBuffer (cs.Item1);
connection.SendAsync (new ConnectMessage { ProtocolVersion = 0 });
Message message = connection.DequeueMessage ();
Assert.IsInstanceOf<ConnectionRejectedMessage> (message);
var rejected = (ConnectionRejectedMessage)message;
Assert.AreEqual (ConnectionRejectedReason.IncompatibleVersion, rejected.Reason);
}
public void Teardown()
{
handler = null;
server = null;
observer = null;
context = null;
}
public void RedirectNoMatch()
{
server.AddRedirector (new MockRedirector ("monkeys.com", new IPEndPoint (IPAddress.Any, 6113)));
var cs = provider.GetConnections (GablarskiProtocol.Instance);
var connection = new ConnectionBuffer (cs.Item1);
connection.SendAsync (new ConnectMessage { ProtocolVersion = GablarskiProtocol.Instance.Version,
Host = "monkeys2.com", Port = 42912 });
var msg = connection.DequeueAndAssertMessage<ServerInfoMessage>();
Assert.AreEqual (this.settings.Name, msg.ServerInfo.Name);
Assert.AreEqual (this.settings.Description, msg.ServerInfo.Description);
Assert.IsNull (msg.ServerInfo.Logo);
}
public void RequestAllUserList()
{
permissions.EnablePermissions (-1, PermissionName.RequestFullUserList);
var u1 = JoinAsGuest (server, client, "Nickname");
var cs = provider.GetConnections (GablarskiProtocol.Instance);
var s = new ConnectionBuffer (cs.Item2);
var c = new ConnectionBuffer (cs.Item1);
var u2 = JoinAsGuest (s, c, "Nickname2");
client.DequeueAndAssertMessage<UserJoinedMessage>();
handler.OnRequestUserListMessage (new MessageEventArgs<RequestUserListMessage> (server,
new RequestUserListMessage (UserListMode.All)));
var list = client.DequeueAndAssertMessage<UserListMessage>().Users.ToList();
Assert.AreEqual (0, list.Count);
}
public void ServerInfo()
{
var cs = provider.GetConnections (GablarskiProtocol.Instance);
var connection = new ConnectionBuffer (cs.Item1);
connection.SendAsync (new ConnectMessage { ProtocolVersion = GablarskiProtocol.Instance.Version });
var msg = connection.DequeueAndAssertMessage<ServerInfoMessage>();
Assert.AreEqual (this.settings.Name, msg.ServerInfo.Name);
Assert.AreEqual (this.settings.Description, msg.ServerInfo.Description);
Assert.IsNull (msg.ServerInfo.Logo);
}
public void RequestOnlineUserList()
{
permissions.EnablePermissions (-1, PermissionName.RequestChannelList);
var u1 = JoinAsGuest (server, client, "Nickname");
var cs = provider.GetConnections (GablarskiProtocol.Instance);
var s = new ConnectionBuffer (cs.Item2);
var c = new ConnectionBuffer (cs.Item1);
var u2 = JoinAsGuest (s, c, "Nickname2");
client.DequeueAndAssertMessage<UserJoinedMessage>();
handler.OnRequestUserListMessage (new MessageEventArgs<RequestUserListMessage> (server,
new RequestUserListMessage (UserListMode.Current)));
var list = client.DequeueAndAssertMessage<UserInfoListMessage>().Users.ToList();
Assert.AreEqual (2, list.Count);
Assert.IsTrue (list.Any (u => u.Nickname == "Nickname"), "User was not in returned list.");
Assert.IsTrue (list.Any (u => u.Nickname == "Nickname2"), "User was not in returned list.");
}
private IUserInfo Join(bool loggedIn, ConnectionBuffer connection, string nickname)
{
return Join (loggedIn, connection, nickname, null);
}
public override void OnFixedUpdate(float fixedDeltatime, EntityManager entityManager, ConnectionBuffer buffer, RenderWindow window)
{
}
public IUserInfo JoinAsGuest (ConnectionBuffer sc, ConnectionBuffer cc, bool connect, bool shouldWork, bool allowGuests, string serverPassword, string nickname, string userServerpassword)
{
context.Settings.AllowGuestLogins = allowGuests;
context.Settings.ServerPassword = serverPassword;
if (connect)
{
handler.Manager.Connect (sobserver);
handler.Manager.Connect (sc);
}
handler.OnJoinMessage (new MessageEventArgs<JoinMessage> (sc,
new JoinMessage (nickname, userServerpassword)));
if (shouldWork)
{
Assert.IsTrue (handler.Manager.GetIsJoined (sc), "User is not joined");
var msg = cc.DequeueAndAssertMessage<JoinResultMessage>();
Assert.AreEqual (nickname, msg.UserInfo.Nickname);
cc.DequeueAndAssertMessage<PermissionsMessage>();
cc.DequeueAndAssertMessage<UserJoinedMessage>();
observer.DequeueAndAssertMessage<UserJoinedMessage>();
return msg.UserInfo;
}
else
{
Assert.IsFalse (handler.Manager.GetIsJoined (sc), "User joined");
observer.AssertNoMessage();
return null;
}
}
public override void OnTick(ConnectionBuffer buffer)
{
}
public override void OnUpdate(float deltatime, EntityManager entityManager, ConnectionBuffer buffer, RenderWindow window)
{
Direction previousDirection = _currentDirection;
// Update the player controller
_playerController.Position = _sprite.Position;
_playerController.Update(window, deltatime, Camera);
_sprite.Position = _playerController.Position;
// Update the direction
float angle = (float)-Math.Atan2(_playerController.Direction.Y, _playerController.Direction.X);
while (angle < 0.0f)
{
angle += 2.0f * (float)Math.PI;
}
while (angle > 2.0f * (float)Math.PI)
{
angle -= 2.0f * (float)Math.PI;
}
_currentDirection = Direction.RIGHT;
if (angle > Math.PI * 0.25f)
{
_currentDirection = Direction.UP;
}
if (angle > Math.PI * 0.75f)
{
_currentDirection = Direction.LEFT;
}
if (angle > Math.PI * 1.25f)
{
_currentDirection = Direction.DOWN;
}
if (angle > Math.PI * 1.75f)
{
_currentDirection = Direction.RIGHT;
}
float speed = (float)Math.Sqrt(_playerController.Velocity.X * _playerController.Velocity.X +
_playerController.Velocity.Y * _playerController.Velocity.Y);
// Update animation
if (_playerController.Velocity.X == 0.0f && _playerController.Velocity.Y == 0.0f)
{
_animations[(int)_currentDirection].SetFrame(0.0f);
}
else
{
if (_currentDirection != previousDirection)
{
_animations[(int)_currentDirection].SetFrame(0.0f);
}
_animations[(int)_currentDirection].Update(deltatime * speed * 2.0f);
}
// Shoot a bullet
if (_playerController.ShotOrigin.HasValue)
{
entityManager.ShootBullet(true, -1,
new Bullet.Bullet(_playerController.ShotOrigin.Value, _playerController.ShotDirection), 800.0f);
buffer.Add(new PlayerShootPacket(-1, _playerController.ShotOrigin.Value, _playerController.ShotDirection));
}
_sprite.TextureRect = _animations[(int)_currentDirection].GetShape();
if (_playerController.DeletionMark)
{
MarkForDeletion();
}
if (!Active)
{
if (_playerController.Health != Health)
{
Hit();
}
Health = _playerController.Health;
}
}
public abstract void OnFixedUpdate(float fixedDeltatime, EntityManager entityManager, ConnectionBuffer buffer, RenderWindow window);
public void RegistrationApprovalMessageUnknownUser()
{
var cs = provider.GetConnections (GablarskiProtocol.Instance);
var s = new ConnectionBuffer (cs.Item2);
var c = new ConnectionBuffer (cs.Item1);
var u = JoinAsGuest (s, c, "nick");
users.UpdateSupported = true;
users.RegistrationMode = UserRegistrationMode.PreApproved;
permissions.UpdatedSupported = true;
permissions.EnablePermissions (u.UserId, PermissionName.ApproveRegistrations);
handler.OnRegistrationApprovalMessage (new MessageEventArgs<RegistrationApprovalMessage> (s,
new RegistrationApprovalMessage { Approved = true, UserId = 2 }));
c.AssertNoMessage();
}
public void RequestAllUserListWithoutPermission()
{
var u1 = JoinAsGuest (server, client, "Nickname");
var cs = provider.GetConnections (GablarskiProtocol.Instance);
var s = new ConnectionBuffer (cs.Item2);
var c = new ConnectionBuffer (cs.Item1);
var u2 = JoinAsGuest (s, c, "Nickname2");
client.DequeueAndAssertMessage<UserJoinedMessage>();
handler.OnRequestUserListMessage (new MessageEventArgs<RequestUserListMessage> (server,
new RequestUserListMessage (UserListMode.All)));
Assert.AreEqual (GablarskiMessageType.RequestUserList,
client.DequeueAndAssertMessage<PermissionDeniedMessage>().DeniedMessage);
}
