private void handleData(DataPacket data)
{
switch (data.type)
{
case "LOGINRESPONSE":
{
DataPacket <LoginResponsePacket> d = data.GetData <LoginResponsePacket>();
if (d.data.status == "OK")
{
this._loggedIn = true;
OnLogin?.Invoke(this._loggedIn, d.data.chatLog);
Console.WriteLine("You are logged in!");
}
else if (d.data.status == ("ERROR"))
{
this._loggedIn = false;
OnLogin?.Invoke(this._loggedIn, d.data.chatLog);
Console.WriteLine("Your username and/or password is not valid!");
}
break;
}
case "REGISTERRESPONSE":
{
DataPacket <RegisterResponsePacket> d = data.GetData <RegisterResponsePacket>();
if (d.data.status == "OK")
{
this._registered = true;
OnRegister?.Invoke(this._registered);
Console.WriteLine("You are Registered");
this._loggedIn = true;
OnLogin?.Invoke(this._loggedIn, d.data.chatLog);
Console.WriteLine("You are logged in!");
}
else if (d.data.status == ("ERROR"))
{
this._registered = false;
OnRegister?.Invoke(this._registered);
Console.WriteLine("Your username is already taken");
}
break;
}
case "CHAT":
{
DataPacket <ChatPacket> d = data.GetData <ChatPacket>();
OnChatReceived?.Invoke($"{d.data.chatMessage}\r\n");
break;
}
default:
Console.WriteLine("Type is not valid");
break;
}
}
private void OnChatMessageReceived(string username, string timestamp, string message)
{
OnChatReceived?.Invoke(this, new OnChatReceivedEventArgs
{
ChatItem = new ChatItem
{
Username = username,
Timestamp = DateTime.Parse(timestamp),
Content = message,
}
});
}
private async Task _connection_Closed(Exception arg, string hostname)
{
OnChatReceived?.Invoke(this, new OnChatReceivedEventArgs
{
ChatItem = new ChatItem
{
Username = "******",
Timestamp = DateTime.UtcNow,
Content = "Connection lost... Attempting to reconnect...",
}
});
await Task.Delay(1000);
Start(_username);
}
public void SetGamePacketTransferEnabled(bool enabled, string macAddress)
{
_connection.InvokeAsync("RegisterMacAddress", _username, macAddress);
_enableGamePacketTransfer = enabled;
if (enabled)
{
OnChatReceived?.Invoke(this, new OnChatReceivedEventArgs
{
ChatItem = new ChatItem
{
Username = "******",
Timestamp = DateTime.UtcNow,
Content = "Device found! You are now ready to play!",
}
});
}
}
private void handleData(Sentence data)
{
try
{
switch (data.getMessageType())
{
case Sentence.Type.SERVER_MESSAGE:
{
OnChatReceived?.Invoke($"{data.getSender()}: {data.getData()}\r\n");
break;
}
case Sentence.Type.USERSMESSAGE:
{
OnClientListReceived?.Invoke(data.Data);
Console.WriteLine("All clients: ");
Console.WriteLine(data.Data);
break;
}
case Sentence.Type.DISCONNECT_REQUEST:
{
SendData("$DISCONNECT");
OnMessageBoxShow?.Invoke($"You got kicked!\nReason: {data.getData()}", MessageBoxButtons.OK);
break;
}
default:
break;
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
private void handleData(DataPacket data)
{
switch (data.type)
{
case "LOGINRESPONSE":
{
DataPacket <LoginResponse> d = data.GetData <LoginResponse>();
if (d.data.status == "OK" && !d.data.isClient)
{
this.loggedIn = true;
OnLogin?.Invoke(this.loggedIn);
Console.WriteLine("You are logged in!");
}
else if (d.data.status == ("ERROR"))
{
this.loggedIn = false;
OnLogin?.Invoke(this.loggedIn);
Console.WriteLine("Your username and/or password is not valid!");
}
break;
}
case "CHAT":
{
DataPacket <ChatPacket> d = data.GetData <ChatPacket>();
OnChatReceived?.Invoke(d.sender, d.data.receiver, $"{d.sender}: {d.data.chatMessage}\r\n", d.data.isDoctorMessage);
break;
}
case "RESPONSE_CLIENTLIST":
{
DataPacket <ClientListPacket> d = data.GetData <ClientListPacket>();
OnClientListReceived?.Invoke(d.data.clientList);
break;
}
case "BIKEDATA":
{
DataPacket <BikeDataPacket> d = data.GetData <BikeDataPacket>();
OnBikeDataReceived?.Invoke(d);
break;
}
case "RESPONSE_SESSIONSTATE":
{
DataPacket <ResponseSessionStatePacket> d = data.GetData <ResponseSessionStatePacket>();
OnSessionStateReceived?.Invoke(d.data.receiver, d.data.startTimeSession, d.data.sessionState);
break;
}
case "SESSIONSTATE_RESPONSE":
{
DataPacket <StartStopPacket> d = data.GetData <StartStopPacket>();
OnSessionStateMessageReceived?.Invoke(d.sender, d.data.startSession);
break;
}
case "RESPONSE_BIKE_STATE":
{
DataPacket <ResponseBikeState> d = data.GetData <ResponseBikeState>();
OnBikeStateChanged?.Invoke(d.sender, d.data.bikeIsConnected);
break;
}
case "SESSIONSTATE_EMERGENCYRESPONSE":
{
DataPacket <EmergencyResponsePacket> d = data.GetData <EmergencyResponsePacket>();
OnEmergencyResponse?.Invoke(d.sender, d.data.state);
break;
}
case "RESPONSE_TRAINING_LIST":
{
DataPacket <ResponseTrainingList> d = data.GetData <ResponseTrainingList>();
this.OnTrainingListReceived?.Invoke(d.data.forClient, d.data.trainingList);
break;
}
case "RESPONSE_TRAINING_DATA":
{
DataPacket <ResponseTrainingData> d = data.GetData <ResponseTrainingData>();
this.OnTrainingDataReceived?.Invoke(d.data.forClient, d.data.trainingName, d.data.trainingData);
break;
}
case "DISCONNECT_REQUEST":
{
DataPacket <ChatPacket> d = data.GetData <ChatPacket>();
Disconnect();
break;
}
default:
Console.WriteLine("Type is not valid");
break;
}
}
public bool Refresh()
{
if (ffxivProcess != null)
{
ffxivProcess.Refresh();
if (ffxivProcess.HasExited)
{
OnProcessLost?.Invoke(this, EventArgs.Empty);
ffxivProcess = null;
hasLost = true;
Reset();
Console.WriteLine("Exited game");
}
if (IsScanning() && !hasScanned)
{
Console.WriteLine("Scanning...");
while (IsScanning())
{
Thread.Sleep(100);
}
Console.WriteLine("Finished scanning");
OnProcessReady?.Invoke(this, ffxivProcess);
hasScanned = true;
}
}
if ((ffxivProcess == null) && hasLost)
{
OnProcessSeek?.Invoke(this, EventArgs.Empty);
hasLost = false;
return(false);
}
if (Reader.CanGetCharacterId())
{
string id = Reader.GetCharacterId();
if (!string.IsNullOrEmpty(id))
{
if (string.IsNullOrEmpty(CharacterID) ||
(!string.IsNullOrEmpty(CharacterID) && !CharacterID.Equals(id)))
{
CharacterID = id;
}
}
}
if (Reader.CanGetPlayerInfo())
{
CurrentPlayerResult res = Reader.GetCurrentPlayer();
if (res.CurrentPlayer.Job != currentPlayer.CurrentPlayer.Job)
{
if (currentPlayer.CurrentPlayer.Job == Sharlayan.Core.Enums.Actor.Job.Unknown)
{
// Logged in
OnCurrentPlayerLogin?.Invoke(this, res);
isLoggedIn = true;
}
else if (res.CurrentPlayer.Job == Sharlayan.Core.Enums.Actor.Job.Unknown)
{
// Logged out
OnCurrentPlayerLogout?.Invoke(this, currentPlayer);
isLoggedIn = false;
Reset();
}
else
{
OnCurrentPlayerJobChange?.Invoke(this, currentPlayer);
}
}
currentPlayer = res;
}
if (!isLoggedIn)
{
return(false);
}
if (Reader.CanGetPartyMembers())
{
PartyResult party2 = Reader.GetPartyMembers();
if (party2.NewPartyMembers.Count > 0 ||
party2.RemovedPartyMembers.Count > 0)
{
// Something changed
party = party2;
OnPartyChanged?.Invoke(this, party2);
}
int pcount = party.PartyMembers.Count;
int pcount2 = party2.PartyMembers.Count;
if (!(party is PartyResult) || (party is PartyResult && (pcount != pcount2)))
{
party = party2;
OnPartyChanged?.Invoke(this, party2);
}
}
if (Reader.CanGetPerformance())
{
List <uint> changedIds = new List <uint>();
PerformanceResult perf = Reader.GetPerformance();
if (!perf.Performances.IsEmpty && !performance.Performances.IsEmpty)
{
foreach (KeyValuePair <uint, PerformanceItem> pp in perf.Performances)
{
if (pp.Value.Status != performance.Performances[pp.Key].Status)
{
changedIds.Add(pp.Key);
}
}
}
if (changedIds.Count > 0)
{
List <uint> actorIds = new List <uint>();
if (Reader.CanGetActors())
{
foreach (ActorItem actor in Reader.GetActors().CurrentPCs.Values)
{
if (changedIds.Contains(actor.PerformanceID / 2))
{
actorIds.Add(actor.ID);
}
}
}
if (actorIds.Count > 0)
{
OnPerformanceChanged?.Invoke(this, actorIds);
}
}
//Update
performance = perf;
bool r = perf.Performances[0].IsReady();
if (r != performanceReady)
{
performanceReady = r;
OnPerformanceReadyChanged?.Invoke(this, performanceReady);
}
}
logItems.Clear();
if (Reader.CanGetChatLog())
{
ChatLogResult readResult = Reader.GetChatLog(_previousArrayIndex, _previousOffset);
_previousArrayIndex = readResult.PreviousArrayIndex;
_previousOffset = readResult.PreviousOffset;
foreach (ChatLogItem item in readResult.ChatLogItems)
{
logItems.Push(item);
completeLog.Add(item);
OnChatReceived?.Invoke(this, item);
}
}
if (Reader.CanGetActors())
{
int jobsum0 = 0;
if (actors != null)
{
jobsum0 = actors.CurrentPCs.Sum(e => (int)e.Value.Job);
}
ActorResult actorRes = Reader.GetActors();
if (actors != null)
{
if (actorRes.CurrentPCs.Count != actors.CurrentPCs.Count)
{
actors = actorRes;
OnPcChanged?.Invoke(this, actorRes.CurrentPCs.ToDictionary(k => k.Key, k => k.Value as ActorItemBase));
}
int jobsum1 = actorRes.CurrentPCs.Sum(e => (int)e.Value.Job);
if (jobsum0 != jobsum1)
{
actors = actorRes;
OnPcChanged?.Invoke(this, actorRes.CurrentPCs.ToDictionary(k => k.Key, k => k.Value as ActorItemBase));
}
}
else
{
actors = actorRes;
OnPcChanged?.Invoke(this, actorRes.CurrentPCs.ToDictionary(k => k.Key, k => k.Value as ActorItemBase));
}
}
return(true);
}
private void handleData(DataPacket data)
{
switch (data.type)
{
case "LOGINRESPONSE":
{
DataPacket <LoginResponse> d = data.GetData <LoginResponse>();
if (d.data.status == "OK" && d.data.isClient)
{
this.loggedIn = true;
OnLogin?.Invoke(this.loggedIn);
Console.WriteLine("You are logged in!");
}
else if (d.data.status == ("ERROR"))
{
this.loggedIn = false;
OnLogin?.Invoke(this.loggedIn);
Console.WriteLine("Your username and/or password is not valid!");
}
break;
}
case "CHAT":
{
DataPacket <ChatPacket> d = data.GetData <ChatPacket>();
OnChatReceived?.Invoke($"{d.sender}: {d.data.chatMessage}\r\n");
break;
}
case "USERNAME_RESPONSE":
{
DataPacket <UserNamePacketResponse> d = data.GetData <UserNamePacketResponse>();
this.doctorUserName = d.data.doctorUserName;
break;
}
case "DISCONNECT_LIVESESSION":
{
this.doctorUserName = null;
break;
}
case "RESISTANCE":
{
DataPacket <ResistancePacket> d = data.GetData <ResistancePacket>();
//TODO set Resistance of the bike
OnResistanceReceived?.Invoke(d.data.resistance);
break;
}
case "REQUEST_BIKE_STATE":
{
this.OnBikeStateRequested?.Invoke();
break;
}
case "START_SESSION":
{
DataPacket <StartStopPacket> d = data.GetData <StartStopPacket>();
this.doctorUserName = d.data.doctor;
OnStartStopSession?.Invoke(d.data.startSession);
break;
}
case "STOP_SESSION":
{
DataPacket <StartStopPacket> d = data.GetData <StartStopPacket>();
OnStartStopSession?.Invoke(d.data.startSession);
break;
}
case "EMERGENCY_STOP":
{
DataPacket <EmergencyStopPacket> d = data.GetData <EmergencyStopPacket>();
OnEmergencyStopSession?.Invoke(d.data.startSession, d.data.resistance);
break;
}
case "SERVER_MESSAGE":
{
DataPacket <ChatPacket> d = data.GetData <ChatPacket>();
OnChatReceived?.Invoke(d.data.chatMessage);
break;
}
case "DISCONNECT_REQUEST":
{
DataPacket <ChatPacket> d = data.GetData <ChatPacket>();
Disconnect();
break;
}
default:
Console.WriteLine("Type is not valid");
break;
}
}
public void PipeMessage(NamedPipeConnection <PipeData, PipeData> conn, PipeData message)
{
Type type = Type.GetType(message.id + ",FFMemoryParser");
if (type == null)
{
return;
}
Object obj = message.data.ToObject();
if (obj != null)
{
if (type.Name == "SignatureList")
{
Memory.SignatureList data = (obj as Memory.SignatureList);
if (data != null)
{
foreach (Signature item in data)
{
Console.WriteLine(string.Format("Signature {0} Not found!", item.Key));
}
}
}
if (type.Name == "SigWorldData")
{
SigWorldData data = (obj as SigWorldData);
if (data != null)
{
World = data.world;
}
}
if (type.Name == "SigCharIdData")
{
SigCharIdData data = (obj as SigCharIdData);
if (data != null)
{
CharacterID = data.id;
OnCharacterId?.Invoke(this, CharacterID);
}
}
// ...
if (type.Name == "SigPerfData")
{
SigPerfData data = (obj as SigPerfData);
if (data != null)
{
performanceData = data;
OnPerformanceChanged?.Invoke(this, performanceData);
}
}
if (type.Name == "SigActorsData")
{
SigActorsData data = (obj as SigActorsData);
if (data != null)
{
actorData = data;
ActorData local = null;
if (actorData.currentActors.Count > 0)
{
local = actorData.currentActors.First().Value;
}
if (localPlayer == null || local.name != localPlayer.name)
{
localPlayer = local;
if (localPlayer != null)
{
OnLocalPlayerLogin?.Invoke(this, localPlayer);
}
else
{
OnLocalPlayerLogout?.Invoke(this, localPlayer);
}
}
}
}
if (type.Name == "SigChatLogData")
{
SigChatLogData data = (obj as SigChatLogData);
if (data != null)
{
foreach (ChatLogItem item in data.chatMessages)
{
OnChatReceived?.Invoke(this, item);
}
}
}
if (type.Name == "SigChatInputData")
{
SigChatInputData data = (obj as SigChatInputData);
if (data != null)
{
ChatInputOpen = data.open;
if (data.open)
{
Console.WriteLine(data.text);
}
}
}
}
}
public async void CreateConnection(string hostname)
{
var token = SettingsHelper.GetSetting("Token");
_connection = new HubConnectionBuilder()
.WithUrl($"http://{hostname}/client", options =>
{
options.AccessTokenProvider = () => Task.FromResult(token);
})
.AddMessagePackProtocol()
.Build();
_connection.Closed += (exception) => _connection_Closed(exception, hostname);
_connection.HandshakeTimeout = TimeSpan.FromSeconds(30);
_connection.ServerTimeout = TimeSpan.FromSeconds(60);
_connection.On <List <string> >("ClientConnected", OnClientConnected);
_connection.On <string, string, string>("GlobalChat", OnChatMessageReceived);
_connection.On <string, byte[]>("GamePacket", OnGamePacketReceived);
SendDebugMessage("Connecting to network...");
try
{
await _connection.StartAsync();
await _connection.InvokeAsync("ClientConnected", _username);
if (!_userDataUpdateThread.IsAlive)
{
_userDataUpdateThread.Start();
}
OnChatReceived?.Invoke(this, new OnChatReceivedEventArgs
{
ChatItem = new ChatItem
{
Username = "******",
Timestamp = DateTime.UtcNow,
Content = "Connection to server established!",
}
});
SendDebugMessage("Connection established!");
}
catch (HubException e)
{
var content = "Connection lost... Please restart TunnelR.";
if (e.Message.Equals("Failed to invoke 'ClientConnected' because user is unauthorized"))
{
content = "You have been banned. Please contact an administrator.";
SetGamePacketTransferEnabled(false, null);
}
OnChatReceived?.Invoke(this, new OnChatReceivedEventArgs
{
ChatItem = new ChatItem
{
Username = "******",
Timestamp = DateTime.UtcNow,
Content = content,
}
});
}
catch
{
await Task.Delay(5000);
if (_connection.State != HubConnectionState.Connected)
{
Start(_username);
}
}
}