public async Task <User> ValidateUser(string username, string password)
{
User user = new User();
try
{
LoginMessage loginMessage = new LoginMessage {
username = username, password = _encryptor.Encrypt(password)
};
HttpClient client = new HttpClient();
string serialized = JsonSerializer.Serialize(loginMessage);
Console.WriteLine(serialized);
StringContent content = new StringContent(serialized, Encoding.UTF8, "application/json");
HttpResponseMessage responseMessage = await client.PostAsync(URI + "/auth", content);
var reponseContent = await responseMessage.Content.ReadAsStringAsync();
user = JsonSerializer.Deserialize <User>(reponseContent);
Console.WriteLine("Testing returns:");
Console.WriteLine(user.username);
Console.WriteLine(user.password);
Console.WriteLine(user.id);
}
catch (HttpRequestException e)
{
Console.WriteLine(e);
}
return(user);
}
void _OnHandleReceivedPacket(Transmitter transmitter, int idCommand, byte[] aPacketBuffer, int iPos)
{
ECommand eCommand = (ECommand)idCommand;
if (eCommand == ECommand.LOGIN)
{
LoginMessage msg = new LoginMessage();
msg.UnSealPacketBuffer(aPacketBuffer, iPos);
msg.Unserialize();
OnLoginMessage(transmitter, msg);
}
else if (eCommand == ECommand.EXIT)
{
ExitMessage msg = new ExitMessage();
msg.UnSealPacketBuffer(aPacketBuffer, iPos);
msg.Unserialize();
OnExitMessage(transmitter, msg);
}
else if (eCommand == ECommand.MOVEMENT)
{
MovementMessage msg = new MovementMessage();
msg.UnSealPacketBuffer(aPacketBuffer, iPos);
msg.Unserialize();
OnMovementMessage(transmitter, msg);
}
}
public static void SendLogin()
{
LoginMessage pmsg = new LoginMessage(Nickname);
string str = JsonConvert.SerializeObject(pmsg).ToString();
Common.doSend(clientSocket, str);
}
public static void LogInUser()
{
bool isUserLoggedIn = false;
var api = new API();
do
{
Console.Clear();
Console.Write("Enter user name:\n");
var userName = Console.ReadLine();
Console.Write("Enter password:\n");
var password = Console.ReadLine();
var result = api.Login(userName, password);
if (result == null)
{
var input = LoginMessage.Error();
if (input != "")
{
Console.Clear();
break;
}
}
else
{
LoginMessage.Success(userName);
isUserLoggedIn = true;
}
} while (isUserLoggedIn == false);
}
public override void ReceiveData(byte[] _bytes)
{
if (uid != -1)
{
BattleManager.Instance.ReceiveData(uid, _bytes);
}
else
{
using (MemoryStream ms = new MemoryStream(_bytes))
{
using (BinaryReader br = new BinaryReader(ms))
{
try
{
CsPackageTag tag = (CsPackageTag)br.ReadInt32();
if (tag == CsPackageTag.Login)
{
LoginMessage message = LoginMessage.Parser.ParseFrom(ms);
uid = int.Parse(message.Name);
PlayerUnitManager.Instance.Login(uid, this);
BattleManager.Instance.Login(uid);
}
}
catch (Exception e)
{
Log.Write(e.ToString());
}
}
}
}
}
public void ProcessLogin(LoginMessage msg)
{
Player player = _server.GetPlayerUnlogged(msg.UserId);
if (null == player || player.State == MenuState.Invalid)
{
return;
}
int unloggedkey = player.Id;
if (Login(msg.Login, msg.Password))
{
MenuState state = PlayerStateMachine.Transform(player.State, MenuAction.Login);
if (state == MenuState.Invalid)
{
SendMessage(MessageFactory.Create(MessageType.LoginUnsuccessful), player.Id);
return;
}
player.State = state;
player.SetData(LoadPlayerData(msg.Login));
}
_server.Chat.AddPlayer(player);
SendMessage((MessageFactory.Create(MessageType.LoginSuccessful)), player.Id);
}
public MainWinViewModel(LoginMessage msg, MainWin win)
{
this.Win = win;
this.User = msg;
Win.DataContext = msg;
OnInit();
}
private void OnLoginComplateHandle(LoginMessage data)
{
if (data.isOK)
{
/*
* if (data.data.tutorial < 18)
* {
* JumpOverTutorial(18 - (int)data.data.tutorial, () => {
*
* EventDispatcher.instance.DispatchEvent(new BaseEvent(EventEnum.LOGIN_COMPLATE));
* });
* }
* else
* {
* EventDispatcher.instance.DispatchEvent(new BaseEvent(EventEnum.LOGIN_COMPLATE));
* }
*/
EventDispatcher.instance.DispatchEvent(new LoadingEvent("Login", 1));
EventDispatcher.instance.DispatchEvent(new BaseEvent(EventEnum.LOGIN_COMPLATE));
}
else
{
Debug.Log("登录失败:" + data.errmsg);
}
}
public void Update(float time)
{
switch (this.m_state)
{
case ServerConnectionState.CONNECT:
if (this.m_messaging.IsConnected())
{
this.m_state = ServerConnectionState.LOGIN;
LoginMessage loginMessage = new LoginMessage();
loginMessage.SetAccountId(this.m_accountInfo.AccountId);
loginMessage.SetPassToken(this.m_accountInfo.PassToken);
loginMessage.SetClientMajorVersion(LogicVersion.MAJOR_VERSION);
loginMessage.SetClientBuildVersion(LogicVersion.BUILD_VERSION);
loginMessage.SetResourceSha(ResourceManager.FINGERPRINT_SHA);
loginMessage.SetDevice(Assembly.GetExecutingAssembly().FullName);
loginMessage.SetScramblerSeed(this.m_messaging.GetScramblerSeed());
this.m_messaging.Send(loginMessage);
}
break;
case ServerConnectionState.LOGIN:
case ServerConnectionState.LOGGED:
while (this.m_messaging.TryDequeueReceiveMessage(out PiranhaMessage piranhaMessage))
{
this.m_messageManager.ReceiveMessage(piranhaMessage);
}
this.m_messageManager.Update(time);
this.m_messaging.SendQueue();
break;
}
}
public static void CreateLoginTransaction(LoginMessage loginMessage)
{
tsNumberRangeModel newNumberRange = new tsNumberRangeModel()
{
login_id = (Int32.Parse(DatabaseConnection.querytsNumberRange().login_id) + 1).ToString()
};
tsLoginDetailModel tsLoginDetailModel = new tsLoginDetailModel()
{
login_id = newNumberRange.login_id,
login_account_id = loginMessage.zAccountDetailModel.account_id,
login_username = loginMessage.zAccountDetailModel.account_username,
login_time = DateTime.Now.ToString("HHmm"),
login_date = DateTime.Now.Date.ToString("ddMMyyyy"),
login_ip = GlobalFunctions.GetIPAddress(),
login_token = "null",
login_status = loginMessage.returnStatusModel.status.ToString()
};
DatabaseConnection.inserttsLoginDetail(tsLoginDetailModel);
returnStatusModel = DatabaseConnection.updatetsNumberRange(newNumberRange);
if (GlobalFunctions.isNotError(returnStatusModel.status))
{
GlobalFunctions.ShowDebug("COMPLETED");
}
}
public void Execute()
{
var channel = _contexts.session.clientSessionObjects.NetworkChannel;
var token = _contexts.session.clientSessionObjects.LoginToken;
if (channel != null && channel.IsConnected)
{
if (!_loginSended)
{
_loginSended = true;
var message = LoginMessage.Allocate();
message.Token = token;
message.LoginStage = ELoginStage.RequestSnapshot;
message.ComponentSerializerVersion = ComponentSerializerManager.HashMd5;
channel.SendReliable((int)EClient2ServerMessage.Login, message);
_logger.InfoFormat("Sending Login Message {0}", message);
message.ReleaseReference();
}
if (_loginSuccReceived)
{
_sessionState.FullfillExitCondition(typeof(RequestSnapshotSystem));
}
}
}
public async Task <IActionResult> Login([FromBody] LoginMessage loginMessage)
{
var invalidLoginOrPasswordResult = BadRequest("Invalid login or password");
if (loginMessage == null || String.IsNullOrEmpty(loginMessage.Login) || String.IsNullOrEmpty(loginMessage.Password))
{
return(invalidLoginOrPasswordResult);
}
UserAuthenticationInfo userAuthenticationInfo;
using (var tx = _transactionManager.CreateTransaction())
{
userAuthenticationInfo = await _users.ByIdAsync(tx, loginMessage.Login, loginMessage.Login);
}
if (userAuthenticationInfo == null)
{
return(invalidLoginOrPasswordResult);
}
string receivedHash = _passwordHasher.GetHash(userAuthenticationInfo.PasswordSalt, loginMessage.Password);
if (receivedHash != userAuthenticationInfo.PasswordHash)
{
return(invalidLoginOrPasswordResult);
}
string token = _jwtManager.GenerateToken(userAuthenticationInfo.Id);
return(Ok(new { id = userAuthenticationInfo.Id, token = token }));
}
void OnClientLogin(NetworkConnection conn, LoginMessage message)
{
Debug.Log("Client has logged in");
// Character character;
//using (StreamReader stream = new StreamReader(charPath + message.account + ".json"))
//{
// string json = stream.ReadToEnd();
// character = JsonUtility.FromJson<Character>(json);
//}
// playerPrefab is the one assigned in the inspector in Network
// Manager but you can use different prefabs per race for example
GameObject go = Instantiate(player);
Player playerComponent = go.GetComponent <Player>();
playerComponent.playerName = accountName;
// call this to use this gameobject as the primary controller
NetworkServer.AddPlayerForConnection(conn, go);
Debug.Log(conn.connectionId);
}
public void OnLogin(object sender, LoginMessage message)
{
if (_connections.ContainsKey(message.GetSource().RemoteUniqueIdentifier))
{
var connection = _connections[message.GetSource().RemoteUniqueIdentifier];
Guid playerId;
var player = ManagerPlayer.Instance.GetPlayerByConnectionId(message.GetSource().RemoteUniqueIdentifier);
if (player == null)
{
playerId = ManagerPlayer.Instance.AddPlayer(connection, message.UserName);
}
else
{
playerId = player.Player.Id;
message.Message = "Player already logged";
}
message.Result = true;
message.PlayerId = playerId;
message.SetDestinataires(new List <NetConnection>()
{
connection
});
ManagerNetwork.Instance.Login(message);
}
else
{
throw new Exception("Connection not finded");
}
}
/// <summary>
/// Returns whether we should handle this device or nah.
/// </summary>
private static bool Trusted(Device Device, LoginMessage Message)
{
Logging.Info(typeof(LoginHandler), "Trusted().");
if (Message.HighId < 0 || Message.LowId < 0)
{
throw new LogicException(typeof(LoginMessage), "HighId or LowId is inferior to zero.");
}
else
{
if (Message.MajorVersion == Config.ClientMajorVersion && Message.MinorVersion == 0 && Message.BuildVersion == Config.ClientBuildVersion)
{
if (Program.Initialized)
{
if (string.Equals(Message.MasterHash, Fingerprint.Masterhash))
{
return(true);
}
Device.NetworkManager.SendMessage(new LoginFailedMessage(Reason.Patch));
}
else
{
Device.NetworkManager.SendMessage(new LoginFailedMessage(Reason.Maintenance));
}
}
else
{
Device.NetworkManager.SendMessage(new LoginFailedMessage(Reason.Update));
}
}
return(false);
}
// -------------------------------------------------------------------------------
public void OnLoginMessage(NetworkConnection conn, LoginMessage msg)
{
if (Database.singleton.TryLogin(msg.authUsername, msg.authPassword))
{
manager.LoginPlayer(conn, msg.authUsername);
}
}
/// <summary>
/// send credentials to get user token
/// </summary>
/// <param name="username"></param>
/// <param name="password"></param>
/// <param name="facebookId"></param>
/// <returns></returns>
public string Login(string username, string password, string facebookId = "")
{
var message = new LoginMessage()
{
FacebookId = facebookId,
Username = username,
Password = password
};
var httpResponse = HttpRequestHelper.PostObjectAsync(Endpoint + "/login", message).Result;
var body = HttpRequestHelper.GetContent(httpResponse).Result;
var statusCode = HttpRequestHelper.GetStatusCode(httpResponse);
if (statusCode != HttpStatusCode.OK)
{
throw new Exception(body);
}
var token = JsonConvert.DeserializeObject <string>(body);
if (!string.IsNullOrWhiteSpace(token))
{
UserToken.Token = token;
}
return(token);
}
public void HandleMessage(MemoryStream memoryStream, Session session)
{
var login = ProtobufHelper.FromStream(typeof(LoginMessage), memoryStream) as LoginMessage;
var conn = DBHelper.Instance.GetConnection();
AccountDAO dao = new AccountDAO();
LoginMessage ms = new LoginMessage();
if (login == null)
{
ms.Message = "N";
}
else
{
Account result = dao.VerifyAccount(conn, login.Email, login.Password, null);
if (result == null)
{
ms.Message = "N";
}
else
{
ms.Message = "Y";
ms.Id = result.Id;
ms.Username = result.UserName;
ms.Password = result.Password;
ms.Email = result.Email;
ms.Phone = result.Phone;
}
}
ResponseMessage(ms, session);
}
public override void HandleMessage(BaseMessage message)
{
LoginMessage msg = (LoginMessage)message;
JobSystem.JobSystemManager.Manager.PlayerToJobSystem.Add(msg.PlayerID, new JobSystem.JobSystem(new Dictionary <Guid, Living>(), msg.PlayerID));//Need to handle game loads, saves, player connect, and player disconnect
JobSystem.JobSystemManager.Manager.EvaluateUnassigned();
}
private void HandleUserMessage(Message mex)
{
// Logical switch on mex type
if (mex is LoginMessage)
{
LoginMessage lgMex = (LoginMessage)mex;
Validate(lgMex.Username, lgMex.Password);
this.Username = lgMex.Username;
LoadData();
Write(new LoginReplyMessage(true, Ranking, Points));
ConnectionManager.Instance.NewLogin(this);
}
else if (mex is ShutdownMessage)
{
Log("User at " + Client.Remote + " has shutdown");
mex = (ShutdownMessage)mex;
ConnectionManager.Instance.DropUser(this);
}
else if (mex is ActionMessage)
{
this.HandleActionMessage((ActionMessage)mex);
}
// Default
else
{
Log("Unknown Message received (ignored)");
}
}
public void ProcessLoginMessage(LoginMessage lm)
{
if (_Client == null)
{
return;
}
Player p = new Player(lm.ComputerPlayer);
p.PlayerID = lm.Id;
p.Name = lm.Username;
p.Release = lm.Major;
p.Revision = lm.Minor;
p.Build = lm.Build;
p.LibRelease = lm.Lib_Major;
p.LibRevision = lm.Lib_Minor;
p.LibBuild = lm.Lib_Build;
p.ClientTitle = lm.Title;
p.FrameworkVersion = lm.Framework;
p.OSVersion = lm.Os;
if (lm.Ready)
{
p.ReadyToPlay = true;
}
_Client.AddPlayer(p);
if (_LoginMessageDelegate != null)
{
_LoginMessageDelegate(p, lm.Fresh);
}
}
private void Login(object sender, RoutedEventArgs e)
{
HomeUserControl _homeUserControl = new HomeUserControl();
MainWindow mainWindow = new MainWindow();
DatabaseConnection.SetConnection();
DatabaseConnection.querySystemDetail();
loginModel.login_username = usernameTextblock.Text;
loginModel.Login_password = passwordTextblock.Password;
loginMessage = LoginController.Login(loginModel);
GlobalFunctions.ShowDebug(loginMessage.returnStatusModel.error_message);
if (loginMessage.returnStatusModel.status == true)
{
//test solution store in GlobalVar but not recommend
//GlobalVariables._mainWindow.ListViewItemHome_Selected(sender, e);
//Change to Open Windows
mainWindow.Show();
this.Close();
}
else
{
passwordTextblock.Clear();
}
}
public override void Reset()
{
base.Reset();
Channel = null;
Message = null;
}
protected void LoginButton_Click(Object sender, EventArgs e)
{
LoginMessage LoginMsg = new LoginMessage();
LoginMsg.UserName = this.UserName.Text;
LoginMsg.Password = Password.Text;
//i9MessageManager.mIi9MessageManager = new InvertService.BusinessLib.i9MessageManagerBLL();
i9Message responseMsg = i9MessageManagerBLL.SendMessage(MobileMessageType.Admin, AdminType.Login, "LoginPage", LoginMsg.GetType(), LoginMsg);
if (responseMsg.ErrorStatus.IsError)
{
FailureText.Text = responseMsg.ErrorStatus.ErrorMsg;
return;
}
if (responseMsg.MsgBodyDataSet.Tables[0].Rows.Count <= 0)
{
FailureText.Text = "Wrong user name or password, please try again.";
return;
}
//Go To Main Window
Session.Add("Login", "true");
Session.Add("Badge", responseMsg.MsgBodyDataSet.Tables["i9SysPersonnel"].Rows[0]["BadgeNumber"].ToString());
Session.Add("LoginDataSet", responseMsg.MsgBodyDataSet);
Response.Redirect("~/");
}
public void OnClientConnected(NetworkMessage message)
{
Debug.Log("Connected to server2. " + client.isConnected);
LoginMessage login = new LoginMessage(username);
ClientScene.AddPlayer(message.conn, 2, login);
}
private void ShowLoginWindow(LoginMessage message)
{
var login = new LoginWindow();
var dialogResult = login.ShowDialog();
if (!dialogResult.HasValue || !dialogResult.Value)
Close();
}
/// <summary>
/// Creates the login message
/// </summary>
/// <param name="cred">Creates login message </param>
/// <returns></returns>
private AuctionLibrary.Message CreateLoginMessage(string args)
{
string search = args;
string[] result = search.Split(':');
AuctionLibrary.Message msg = new LoginMessage(result[0], result[1]);
return(msg);
}
public async Task <ApiResult> PostLogin(LoginMessage message)
{
User user = await _userService.LoginUser(message);
var userModel = _mapper.Map <Core.Models.User>(user);
return(userModel != null?ApiResult.Success(userModel) : ApiResult.BadRequest());
}
public static Message CreateLoginMessage(int i)
{
LoginMessage lm = MessageFactory.Create(MessageType.Login) as LoginMessage;
lm.Login = i.ToString();
lm.Password = i.ToString();
return(lm);
}
public void Execute()
{
if (SharedConfig.IsOffline)
{
if (!_loginSended)
{
_loginSended = true;
var sessionObjects = _contexts.session.commonSession;
IEntityIdGenerator idGenerator = sessionObjects.EntityIdGenerator;
var id = idGenerator.GetNextEntityId();
var _offlineSelector = new OfflineSnapshotSelector(new EntityKey(id, (int)EEntityType.Player),
_contexts.session.commonSession.GameContexts);
_contexts.session.clientSessionObjects.SnapshotSelectorContainer.SnapshotSelector =
_offlineSelector;
_contexts.session.clientSessionObjects.SimulationTimer.CurrentTime = 0;
_contexts.session.entityFactoryObject.SceneObjectEntityFactory = new ServerSceneObjectEntityFactory(
_contexts.sceneObject, _contexts.player, sessionObjects.EntityIdGenerator, sessionObjects.EntityIdGenerator,
_contexts.session.currentTimeObject);
_contexts.session.entityFactoryObject.MapObjectEntityFactory =
new ServerMapObjectEntityFactory(_contexts.mapObject, sessionObjects.EntityIdGenerator);
IPlayerInfo playerInfo = TestUtility.CreateTestPlayer();
playerInfo.EntityId = id;
var player = PlayerEntityFactory.CreateNewPlayerEntity(_contexts.player,
SingletonManager.Get <MapsDescription>().SceneParameters.PlayerBirthPosition, playerInfo, true, false);
_offlineSelector.Init();
_sessionState.FullfillExitCondition(typeof(RequestPlayerInfoSystem));
SingletonManager.Get <SubProgressBlackBoard>().Step();
}
}
else
{
var channel = _contexts.session.clientSessionObjects.NetworkChannel;
var token = _contexts.session.clientSessionObjects.LoginToken;
if (channel != null && channel.IsConnected)
{
if (!_loginSended)
{
_loginSended = true;
var message = LoginMessage.Allocate();
message.Token = token;
message.LoginStage = ELoginStage.GetPlayerInfo;
message.ComponentSerializerVersion = ComponentSerializerManager.HashMd5;
channel.SendReliable((int)EClient2ServerMessage.Login, message);
_logger.InfoFormat("Sending Login Message {0}", message);
message.ReleaseReference();
}
if (_loginSuccReceived)
{
_sessionState.FullfillExitCondition(typeof(RequestPlayerInfoSystem));
SingletonManager.Get <SubProgressBlackBoard>().Step();
}
}
}
}
public void OnLoginHandler(LoginMessage m)
{
SessionStorage.Instance.ProfileId = m.SessionInfo.ProfileId;
SessionStorage.Instance.SessionId = m.SessionInfo.SessionId;
IsViewVisible = true;
_appApplicationEnvironment.EventHub.Publish <NeedServerSyncMessage>(new NeedServerSyncMessage());
}
private void PageState(LoginMessage loginMessage)
{
switch (loginMessage.Reason)
{
case Messages.Enums.LoginMessageReason.InApp:
isInAppLogin = true;
break;
case Messages.Enums.LoginMessageReason.Splash:
isInAppLogin = false;
break;
}
}
static void Main(string[] args)
{
MessageFactory.Register<LoginMessage>();
Logger.OnInfo += Console.Write;
Logger.OnError += Console.Write;
var remoteIp = IPAddress.Parse("127.0.0.1");
TcpClientMessageService service = new TcpClientMessageService(remoteIp, 9013);
service.OnConnected += (o, eventArgs) =>
{
TcpClientMessageService service2 = o as TcpClientMessageService;
Logger.InfoLine("Connectd:{0}", service2.RemoteIPEndPoint);
LoginMessage lognMessage = new LoginMessage
{
Request =
{
Name = "Hello",
Order = 123
}
};
service2.Write(lognMessage);
};
service.OnDisconnected += (o, eventArgs) =>
{
TcpClientMessageService service2 = o as TcpClientMessageService;
Logger.InfoLine("Disconnected:{0}", service2.RemoteIPEndPoint);
};
service.OnRead += ServiceOnRead;
service.OnError += Service_OnError;
service.BeginConnect();
Console.Read();
}
/// <summary>
/// Sends a login to the master server.
/// </summary>
/// <param name="username">The name of the user logging in</param>
/// <remarks>
/// TODO: This only works for master server 0 right now. Must fix eventually.
/// </remarks>
private void SendLoginToMasterServer(string username)
{
idtomasterserver.Add(usernametoid[username], 0);
//Send a message to the master server to add the user
LoginMessage loginmessage = new LoginMessage(GetUser(usernametoid[username]));
NetOutgoingMessage messagetomaster = MasterServerConnections[(int)idtomasterserver[usernametoid[username]]].CreateMessage();
messagetomaster.Write((byte)CallSources.LoginServer);
messagetomaster.Write((byte)LoginServerRequests.Login);
messagetomaster.Write(Serialize(loginmessage));
Console.WriteLine(Encoding.ASCII.GetString(messagetomaster.PeekDataBuffer()));
messagetomaster.Encrypt(new NetXtea("DERPHERP"));
MasterServerConnections[(int)idtomasterserver[usernametoid[username]]].SendMessage(messagetomaster, NetDeliveryMethod.ReliableOrdered);
}
/// <summary>
/// Process all information coming from clients, and other servers.
/// </summary>
/// <remarks>
/// Connection Approval is enabled, so when a client connects to this server it must
/// provide the correct data. That is a username and id.
/// The login server gets a special case, in that its username is "lgn", and its id is Guid.Empty.
/// If the master server hasn't been notified by the login server that a user is logging in, it won't
/// know about this information and will reject the client.
/// </remarks>
public void Process()
{
NetIncomingMessage msg;
//Read what incoming messages we have from clients
while ((msg = LidgrenServer.ReadMessage()) != null)
{
switch (msg.MessageType)
{
//If it is a debug message, warning message, or status changed print the relevant information to the console
case NetIncomingMessageType.DebugMessage:
Console.WriteLine("Debug message: " + msg.ReadString());
break;
case NetIncomingMessageType.WarningMessage:
Console.WriteLine("Warning message: " + msg.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
Console.WriteLine("Status changed for " + msg.SenderEndpoint + " to " + msg.SenderConnection.Status);
break;
//Check the connection approval for an accepted username and userid
case NetIncomingMessageType.ConnectionApproval:
//Read the username an userid from the message
string username = msg.ReadString();
Guid userid = new Guid(msg.ReadBytes(msg.LengthBytes - msg.PositionInBytes));
//If the username is "lgn" and the userid is Guid.Empty, this is the login server's client. Let it connect regardless.
//We should probably validate this harder in the future
if (username == "lgn" && userid == Guid.Empty)
{
Console.WriteLine("Login accept");
msg.SenderConnection.Approve();
}
//If the user with the userid and username has already been accepted by the login server
//and their information has been sent here, let them be accepted.
else if (Users.ContainsKey(userid) && Users[userid].Username == username)
{
Console.WriteLine("User: "******" accept.");
Users[userid].Connection = msg.SenderConnection;
msg.SenderConnection.Approve();
}
//Otherwise, don't let them in here.
else
{
Console.WriteLine("User: "******" with userid " + userid + " reject.");
msg.SenderConnection.Deny();
}
break;
case NetIncomingMessageType.Data:
//We are decrypting data. All data sent to a master server is encrypted with key "DERPHERP".
msg.Decrypt(new NetXtea("DERPHERP"));
//Figure out where this data came from.
CallSources source = (CallSources)msg.ReadByte();
Console.WriteLine("Got data from " + source);
//If we got the data from a login server
if (source == CallSources.LoginServer)
{
//Figure out what kind of login server request it is.
LoginServerRequests request = (LoginServerRequests)msg.ReadByte();
//If a user logged in, deal with it.
if (request == LoginServerRequests.Login)
{
//Deserialize our login message from the login server
LoginMessage loginmessage = new LoginMessage();
loginmessage = Serializer.Deserialize<LoginMessage>(new MemoryStream(msg.ReadBytes(msg.LengthBytes - msg.PositionInBytes)));
//Create a new user with the relevant information.
User u = new User();
u.Connection = msg.SenderConnection;
u.Id = loginmessage.LoginUser.Id;
u.Username = loginmessage.LoginUser.Username;
//Add the user to our master server
Users.Add(loginmessage.LoginUser.Id, u);
Console.WriteLine(u.Username + " logged in.");
}
//If a user logged out, double deal with it.
else if (request == LoginServerRequests.Logout)
{
//Deserialize the logout message
LogoutMessage logoutmessage = new LogoutMessage();
logoutmessage = Serializer.Deserialize<LogoutMessage>(new MemoryStream(msg.ReadBytes(msg.LengthBytes - msg.PositionInBytes)));
Console.WriteLine(Users[logoutmessage.UserId].Username + " logged out.");
//If this user had an active character (that would be on a region server) send a message to the
//region server to remove the character.
if(Users[logoutmessage.UserId].ActiveCharacter != null)
SendRemoveCharacterMessage(Users[logoutmessage.UserId].ActiveCharacter.RegionId, logoutmessage.UserId);
//Remove the user from the master server.
Users.Remove(logoutmessage.UserId);
}
}
//If we got a message from the client
else if (source == CallSources.Client)
{
//It is a remote procedure call, so figure out what kind it is
RemoteProcedureCallCodes callcode = (RemoteProcedureCallCodes)msg.ReadByte();
//The user created a character.
if (callcode == RemoteProcedureCallCodes.CreateCharacter)
{
//Deserialize that message
CreateCharacterRequest createcharactersrequest = new CreateCharacterRequest();
createcharactersrequest = Serializer.Deserialize<CreateCharacterRequest>(new MemoryStream(msg.ReadBytes(msg.LengthBytes - msg.PositionInBytes)));
//See if a character with the name requested already exists.
if (!CharacterExists(createcharactersrequest.Name))
{
//Create a new character with a new guid.
Guid newguid = Guid.NewGuid();
//With arbitrary information about the character for now. Default regionid 0, default pos and rot, default race, height and weight.
Character character = new Character(createcharactersrequest.Name, RaceCode.human, 5, 170, newguid, new Vector3(0.0f, 10.0f, 0.0f), new Vector3(0.0f, 0.0f, 0.0f), 0, new Dictionary<ulong,int>());
//Add the character to be associated with this user id.
UserIdToCharacters[createcharactersrequest.UserId].Add(character);
//Send a resposne to the client saying the creation was successful
SendCreateCharacterResponse(msg.SenderConnection, true);
Console.WriteLine("User " + Users[createcharactersrequest.UserId].Username + " created a character named " + createcharactersrequest.Name);
}
else
{
//Otherwise send a response to the client saying the creation was unsuccessful
SendCreateCharacterResponse(msg.SenderConnection, false);
Console.WriteLine("User " + Users[createcharactersrequest.UserId].Username + " couldn't create a character named " + createcharactersrequest.Name);
}
}
//The user needs to get characters, so they can see which one to select
else if (callcode == RemoteProcedureCallCodes.GetCharacters)
{
//Deserialize the get characters request
GetCharactersRequest getcharactersrequest = new GetCharactersRequest();
getcharactersrequest = Serializer.Deserialize<GetCharactersRequest>(new MemoryStream(msg.ReadBytes(msg.LengthBytes - msg.PositionInBytes)));
//Make sure this user has a character list started
if (UserIdToCharacters.ContainsKey(getcharactersrequest.UserId))
{
//If so, send the get characters response
SendGetCharactersResponse(msg.SenderConnection, getcharactersrequest.UserId);
}
else
{
//Else make a new list, and send the get characters response
UserIdToCharacters.Add(getcharactersrequest.UserId, new List<Character>());
SendGetCharactersResponse(msg.SenderConnection, getcharactersrequest.UserId);
}
Console.WriteLine("Getting Characters for " + Users[getcharactersrequest.UserId].Username);
}
//The user selected a character and is entering the world.
else if (callcode == RemoteProcedureCallCodes.EnterWorld)
{
//Deserialize the enterworld request
EnterWorldRequest enterworldrequest = new EnterWorldRequest();
enterworldrequest = Serializer.Deserialize<EnterWorldRequest>(new MemoryStream(msg.ReadBytes(msg.LengthBytes - msg.PositionInBytes)));
//Set this users active character to the one selected.
Users[enterworldrequest.UserId].ActiveCharacter = UserIdToCharacters[enterworldrequest.UserId].Find(delegate(Character c) { return c.Id == enterworldrequest.CharacterId; });
//Send an Add Character Message to the appropriate region server
AddCharacterMessage(UserIdToCharacters[enterworldrequest.UserId].Find(delegate(Character c) { return c.Id == enterworldrequest.CharacterId; }), Users[enterworldrequest.UserId].ActiveCharacter.Position, null, enterworldrequest.UserId);
Console.WriteLine("User " + Users[enterworldrequest.UserId].Username + " made their character " + Users[enterworldrequest.UserId].ActiveCharacter.Name + " enter the world into region " + Users[enterworldrequest.UserId].ActiveCharacter.RegionId);
}
else if (callcode == RemoteProcedureCallCodes.Teleport)
{
TeleportRequest request = Serializer.Deserialize<TeleportRequest>(new MemoryStream(msg.ReadBytes(msg.LengthBytes - msg.PositionInBytes)));
TeleportMessage(Users[request.UserId].ActiveCharacter.RegionId, request.UserId, request.TeleportId);
Console.WriteLine("Teleport request.");
}
//The client sent a character snapshot (position, rotation, velocity)
else if (callcode == RemoteProcedureCallCodes.CharacterSnapshot)
{
CharacterSnapshot snapshot = new CharacterSnapshot();
snapshot = Serializer.Deserialize<CharacterSnapshot>(new MemoryStream(msg.ReadBytes(msg.LengthBytes - msg.PositionInBytes)));
SendCharacterSnapshotMessage(Users[snapshot.UserId].ActiveCharacter.RegionId, snapshot);
//Console.WriteLine("Snapshot for " + Users[snapshot.UserId].ActiveCharacter.Name);
}
else if (callcode == RemoteProcedureCallCodes.DropItem)
{
DropItemRequest request = Serializer.Deserialize<DropItemRequest>(new MemoryStream(msg.ReadBytes(msg.LengthBytes - msg.PositionInBytes)));
DropItemMessage(Users[request.UserId].ActiveCharacter.RegionId, request.ItemId, request.UserId);
Console.WriteLine("Drop Item request for " + Users[request.UserId].ActiveCharacter.Name);
}
else if (callcode == RemoteProcedureCallCodes.PickupItem)
{
PickupItemRequest request = Serializer.Deserialize<PickupItemRequest>(new MemoryStream(msg.ReadBytes(msg.LengthBytes - msg.PositionInBytes)));
//TODO
PickupItemMessage(Users[request.UserId].ActiveCharacter.RegionId, request.UserId, request.ItemSpawnId);
}
}
break;
}
LidgrenServer.Recycle(msg);
}
//Or we recieved a message from one of the many region servers
foreach (NetClient regionclient in RegionServers.Values)
{
NetIncomingMessage regionmessage;
//Read a message from the queue
while ((regionmessage = regionclient.ReadMessage()) != null)
{
switch (regionmessage.MessageType)
{
//If it is debug, warning, or status changed output to screen
case NetIncomingMessageType.DebugMessage:
Console.WriteLine("Region Debug: " + regionmessage.ReadString());
break;
case NetIncomingMessageType.WarningMessage:
Console.WriteLine("Region Warning: " + regionmessage.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
Console.WriteLine("Region status changed: " + regionmessage.SenderConnection.Status);
break;
//Or we got some actual data
case NetIncomingMessageType.Data:
//Figure out what kind of message it is
RegionMessages messagetype = (RegionMessages)regionmessage.ReadByte();
//A character was added to this region
if (messagetype == RegionMessages.AddCharacterBroadcast)
{
Console.WriteLine("Got an Add Character broadcast from a region.");
//Deserialize the broadcast
AddCharacterBroadcast addbroadcast = Serializer.Deserialize<AddCharacterBroadcast>(new MemoryStream(regionmessage.ReadBytes(regionmessage.LengthBytes - regionmessage.PositionInBytes)));
//Send an event to all the relevant users using their userid
foreach (Guid userid in addbroadcast.RecivingUserIds)
{
SendEnterRegionEvent(Users[userid].Connection, addbroadcast.EnteringCharacter, addbroadcast.UserId);
}
}
//A user asked what characters were in this region, so we relay it back via enter region response
else if (messagetype == RegionMessages.AddCharacterResponse)
{
Console.WriteLine("Relaying characters in region as well as position.");
AddCharacterResponseMessage message = Serializer.Deserialize<AddCharacterResponseMessage>(new MemoryStream(regionmessage.ReadBytes(regionmessage.LengthBytes - regionmessage.PositionInBytes)));
Console.WriteLine(message.Location.X + " " + message.Location.Y + " " + message.Location.Z);
SendEnterRegionResponse(Users[message.MeantForUserId].Connection, message.Characters, message.ItemSpawns, message.Location, message.RegionId);
}
//A character was removed from this region
else if (messagetype == RegionMessages.RemoveCharacterBroadcast)
{
Console.WriteLine("Got a Remove Character broadcast from a region.");
//Deserialize the broadcast
RemoveCharacterBroadcast exitregionbroadcast = Serializer.Deserialize<RemoveCharacterBroadcast>(new MemoryStream(regionmessage.ReadBytes(regionmessage.LengthBytes - regionmessage.PositionInBytes)));
//Send it to all relevant user ids
foreach (Guid userid in exitregionbroadcast.RecivingUserIds)
{
SendExitRegionEvent(Users[userid].Connection, exitregionbroadcast.UserId);
}
}
//A character sent a snapshot of their information to the region
else if (messagetype == RegionMessages.CharacterSnapshotBroadcast)
{
Console.WriteLine("Got a character snapshot broadcast from a region.");
CharacterSnapshotBroadcast charsnapbroadcast = Serializer.Deserialize<CharacterSnapshotBroadcast>(new MemoryStream(regionmessage.ReadBytes(regionmessage.LengthBytes - regionmessage.PositionInBytes)));
//Send the event to all relevant users
foreach (Guid userid in charsnapbroadcast.ReceivingUserIds)
SendCharacterSnapshotEvent(Users[userid].Connection, charsnapbroadcast.Snapshot);
}
else if (messagetype == RegionMessages.TeleportCharacterResponse)
{
TeleportResponseMessage message = Serializer.Deserialize<TeleportResponseMessage>(new MemoryStream(regionmessage.ReadBytes(regionmessage.LengthBytes - regionmessage.PositionInBytes)));
Users[message.UserId].ActiveCharacter.RegionId = message.ExitRegionId;
Console.WriteLine("Got teleport character response, and adding character.");
AddCharacterMessage(Users[message.UserId].ActiveCharacter, null, message.TeleportExitId, message.UserId);
}
else if (messagetype == RegionMessages.DropItemResponse)
{
DropItemResponseMessage message = Serializer.Deserialize<DropItemResponseMessage>(new MemoryStream(regionmessage.ReadBytes(regionmessage.LengthBytes - regionmessage.PositionInBytes)));
SendDropItemResponse(Users[message.UserId].Connection, message.Success, message.ItemId);
}
else if(messagetype == RegionMessages.DropItemBroadcast)
{
DropItemBroadcast broadcast = Serializer.Deserialize<DropItemBroadcast>(new MemoryStream(regionmessage.ReadBytes(regionmessage.LengthBytes - regionmessage.PositionInBytes)));
foreach (Guid userid in broadcast.ReceivingUserIds)
{
SendCreateItemSpawnEvent(Users[userid].Connection, broadcast.NewItemSpawn);
}
}
else if(messagetype == RegionMessages.PickupItemResponse)
{
PickupItemResponseMessage message = Serializer.Deserialize<PickupItemResponseMessage>(new MemoryStream(regionmessage.ReadBytes(regionmessage.LengthBytes - regionmessage.PositionInBytes)));
SendTakeItemResponse(Users[message.UserId].Connection, message.Success, message.ItemId);
}
else if(messagetype == RegionMessages.PickupItemBroadcast)
{
PickupItemBroadcast broadcast = Serializer.Deserialize<PickupItemBroadcast>(new MemoryStream(regionmessage.ReadBytes(regionmessage.LengthBytes - regionmessage.PositionInBytes)));
foreach(Guid userid in broadcast.Recipients)
{
SendTakeItemEvent(Users[userid].Connection, broadcast.ItemSpawnId);
}
}
else if (messagetype == RegionMessages.SpawnItemBroadcast)
{
SpawnItemBroadcast broadcast = Serializer.Deserialize<SpawnItemBroadcast>(new MemoryStream(regionmessage.ReadBytes(regionmessage.LengthBytes - regionmessage.PositionInBytes)));
foreach(Guid userid in broadcast.Recipients)
{
SendSpawnItemEvent(Users[userid].Connection, broadcast.SpawnId, broadcast.ItemId);
}
}
break;
}
LidgrenServer.Recycle(regionmessage);
}
}
}
private void OnLoginMessage(LoginMessage message)
{
if (message.Type == LoginType.LogIn)
{
if (message.Service == "vk")
{
ShowSidebar = true;
LoadUserInfo();
}
if (message.Service == "lastfm")
RaisePropertyChanged("LastFmUser");
}
else if (message.Type == LoginType.LogOut)
{
if (message.Service == "lastfm")
RaisePropertyChanged("LastFmUser");
}
}
/// <summary>
/// Static method that takes in an xml String and converts it to an AbstractMessage.
///
/// Will throw an XmlException if the xml String was in an unrecognized format.
/// </summary>
/// <param name="xml">A String with xml representing an AbstractMessage</param>
/// <returns>The AbstractMessage parsed from the XML String</returns>
public override AbstractMessage Parse(String xml)
{
XmlTextReader reader = new XmlTextReader(new StringReader(xml));
AbstractMessage returnee = null;
Int32 chatId = 0;
String element = "";
String textMessage = "";
String username = "";
String password = "";
String sender = "";
Boolean accepted = false;
Boolean isAlreadyLoggedOn = true;
Boolean alreadyExisted = false;
Boolean authenticationDisabled = false;
GroupChat chat = null;
ExtendedHashSet<String> hashSet = null;
try
{
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.CDATA:
switch (element)
{
case "Message":
textMessage = reader.Value;
break;
case "Username":
username = reader.Value;
break;
case "Password":
password = reader.Value;
break;
case "User":
hashSet.Add(reader.Value);
break;
case "Participant":
hashSet.Add(reader.Value);
break;
case "Sender":
sender = reader.Value;
break;
case "Name":
hashSet.Add(reader.Value);
break;
default:
break;
}
break;
case XmlNodeType.Element:
element = reader.Name; // define last known element
switch (element)
{
case "UserList":
hashSet = new ExtendedHashSet<String>();
break;
case "Participants":
hashSet = new ExtendedHashSet<String>();
break;
case "ToBeAdded":
hashSet = new ExtendedHashSet<String>();
break;
case "ToBeRemoved":
hashSet = new ExtendedHashSet<String>();
break;
}
break;
case XmlNodeType.EndElement:
switch (reader.Name)
{
case "TextMessage":
returnee = new TextMessage(textMessage);
break;
case "LoginMessage":
returnee = new LoginMessage(username, password);
break;
case "LoginResponseMessage":
returnee = new LoginResponseMessage(accepted, isAlreadyLoggedOn, username);
break;
case "AddToUserListMessage":
returnee = new AddToUserListMessage(hashSet);
break;
case "RemoveFromUserListMessage":
returnee = new RemoveFromUserListMessage(hashSet);
break;
case "GroupChatMessage":
returnee = new GroupChatMessage(chat, textMessage, sender);
break;
case "AddMemberToGroupChatMessage":
returnee = new AddMemberToGroupChatMessage(chatId, hashSet);
break;
case "RemoveMemberFromGroupChatMessage":
returnee = new RemoveMemberFromGroupChatMessage(chatId, hashSet);
break;
case "StartGroupChatRequestMessage":
returnee = new StartGroupChatRequestMessage(hashSet);
break;
case "StartGroupChatResponseMessage":
returnee = new StartGroupChatResponseMessage(chatId, alreadyExisted);
break;
case "GroupChatInfoRequestMessage":
returnee = new GroupChatInfoRequestMessage(chatId);
break;
case "GroupChatInfoResponseMessage":
returnee = new GroupChatInfoResponseMessage(chat);
break;
case "SignupRequestMessage":
returnee = new SignupRequestMessage(username, password);
break;
case "SignupResponseMessage":
returnee = new SignupResponseMessage(accepted, alreadyExisted, authenticationDisabled);
break;
case "GroupChat":
chat = new GroupChat(hashSet, chatId);
break;
default:
break;
}
break;
case XmlNodeType.Text:
switch (element)
{
case "Accepted":
accepted = Boolean.Parse(reader.Value);
break;
case "IsAlreadyLoggedOn":
isAlreadyLoggedOn = Boolean.Parse(reader.Value);
break;
case "ChatID":
chatId = int.Parse(reader.Value);
break;
case "AlreadyExisted":
alreadyExisted = Boolean.Parse(reader.Value);
break;
case "AuthenticationDisabled":
authenticationDisabled = Boolean.Parse(reader.Value);
break;
default:
break;
}
break;
default:
break;
}
}
}
catch
{
throw new XmlException("Unrecognized XML Format...");
}
reader.Close();
if (returnee != null)
{
return returnee;
}
else
{
throw new XmlException("Unrecognized XML Format...");
}
}
