public void Sit()
{
State.IsSitted = !State.IsSitted;
if (State.IsSitted)
{
State.SitStartTime = Environment.TickCount;
NClient.Send("ILS1000");
}
else
{
int regenerated = (int)(Environment.TickCount - State.SitStartTime) / 1000;
int missing = Stats.GetStat(StatEnum.MaxLife).Total - Life;
if (regenerated > missing)
{
regenerated = missing;
}
NClient.Player.Life += regenerated;
NClient.Send("ILF" + regenerated);
NClient.Send("ILS360000");
}
}
public void LoginGoogle_Invalid([ValueSource("BlankCases")] string oauthToken)
{
ManualResetEvent evt = new ManualResetEvent(false);
INError result = null;
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Google(oauthToken);
client.Login(message, (INSession session) =>
{
evt.Set();
}, (INError error) =>
{
result = error;
evt.Set();
});
evt.WaitOne(500, false);
Assert.NotNull(result);
if (oauthToken == string.Empty)
{
Assert.AreEqual("Access token is required", result.Message);
}
else
{
Assert.AreEqual("Invalid Google access token, no spaces or control characters allowed", result.Message);
}
}
public void LoginEmail_Valid()
{
ManualResetEvent evt = new ManualResetEvent(false);
INSession result = null;
string piece = random.GetString().Substring(8);
string email = String.Format("{0}@{0}.com", piece);
string password = TestContext.CurrentContext.Random.GetString();
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Email(email, password);
client.Register(message, (INSession _) =>
{
client.Login(message, (INSession session) =>
{
result = session;
evt.Set();
}, (INError error) =>
{
evt.Set();
});
}, (INError error) =>
{
evt.Set();
});
evt.WaitOne(1000, false);
Assert.NotNull(result);
Assert.NotNull(result.Token);
}
public void RegisterCustom_Invalid([ValueSource("BlankCases")] string id)
{
ManualResetEvent evt = new ManualResetEvent(false);
INError result = null;
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Custom(id);
client.Register(message, (INSession session) =>
{
evt.Set();
}, (INError error) =>
{
result = error;
evt.Set();
});
evt.WaitOne(500, false);
Assert.NotNull(result);
if (id == string.Empty)
{
Assert.AreEqual("Custom ID is required", result.Message);
}
else
{
Assert.AreEqual("Invalid custom ID, no spaces or control characters allowed", result.Message);
}
}
public void LoginEmail_Invalid([ValueSource("BlankCases")] string email,
[ValueSource("BlankCases")] string password)
{
ManualResetEvent evt = new ManualResetEvent(false);
INError result = null;
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Email(email, password);
client.Login(message, (INSession session) =>
{
evt.Set();
}, (INError error) =>
{
result = error;
evt.Set();
});
evt.WaitOne(500, false);
Assert.NotNull(result);
if (email == string.Empty)
{
Assert.AreEqual("Email address is required", result.Message);
}
else
{
Assert.AreEqual("Invalid email address, no spaces or control characters allowed", result.Message);
}
}
public void LoginDevice_Valid()
{
ManualResetEvent evt = new ManualResetEvent(false);
INSession result = null;
string id = random.GetString();
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Device(id);
client.Register(message, (INSession _) =>
{
client.Login(message, (INSession session) =>
{
result = session;
evt.Set();
}, (INError error) =>
{
evt.Set();
});
}, (INError error) =>
{
evt.Set();
});
evt.WaitOne(1000, false);
Assert.NotNull(result);
Assert.NotNull(result.Token);
}
private void LevelUp()
{
if (this.Level == Entities.Requests.LevelsRequests.MaxLevel())
{
return;
}
if (Exp >= Entities.Requests.LevelsRequests.ReturnLevel(Level + 1).Character)
{
while (Exp >= Entities.Requests.LevelsRequests.ReturnLevel(Level + 1).Character)
{
if (this.Level == Entities.Requests.LevelsRequests.MaxLevel())
{
break;
}
Level++;
SpellPoint++;
CharactPoint += 5;
}
if (IsConnected)
{
NClient.Send(string.Concat("AN", Level));
}
SpellsInventary.LearnSpells();
SendChararacterStats();
}
}
public void TeleportNewMap(int _mapID, int _cell)
{
NClient.Send(string.Format("GA;2;{0};", ID));
GetMap().DelPlayer(this);
var map = Entities.Requests.MapsRequests.MapsList.First(x => x.Model.ID == _mapID);
MapID = map.Model.ID;
MapCell = _cell;
LoadMap();
}
public void LoadMap()
{
if (Entities.Requests.MapsRequests.MapsList.Any(x => x.Model.ID == this.MapID))
{
var map = Entities.Requests.MapsRequests.MapsList.First(x => x.Model.ID == this.MapID);
NClient.Send(string.Format("GDM|{0}|{1}|{2}", map.Model.ID, map.Model.Date, map.Model.Key));
if (this.State.IsFollow)
{
foreach (var character in this.State.Followers)
{
character.NClient.Send(string.Format("IC{0}|{1}", GetMap().Model.PosX, GetMap().Model.PosY));
}
}
}
}
public void AddLife(int _life)
{
if (Life == Stats.GetStat(StatEnum.MaxLife).Total)
{
NClient.SendMessage("Im119");
}
else if ((Life + _life) > Stats.GetStat(StatEnum.MaxLife).Total)
{
NClient.SendMessage(string.Concat("Im01;", (Stats.GetStat(StatEnum.MaxLife).Total - Life)));
Life = Stats.GetStat(StatEnum.MaxLife).Total;
}
else
{
NClient.SendMessage(string.Concat("Im01;", _life));
Life += _life;
}
}
public static void StartNMonitor()
{
NClient me = new NClient();
me.AssignSetupDetails();
me.StartDomain();
int authLoops = 0;
while (me.Active & ClientSettings.KeepAlive)
{
Console.WriteLine($"We're up and running!! | Domain: {ClientSettings.domainName}");
Console.WriteLine("Sending auth step 0!");
me.AuthDomain();
me.WaitForDad();
Thread.Sleep(700);
}
}
private void btnConnect_Click(object sender, EventArgs e)
{
tbxStatus.Text = "Connecting ... ";
port = GetPort();
if (port == 0)
{
MessageBox.Show("The port is invalid", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
ip = GetIP();
if (ip == IPAddress.None)
{
MessageBox.Show("The IP address is invalid", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
Nclient = new NClient(ip, port);
Nclient.SetMessage = new NClient.SetTextToControl(SetMessage);
Nclient.SetStatus = new NClient.SetTextToControl(SetStatus);
Nclient.Connect();
}
private static INError RegisterEmailError(string email, string password)
{
ManualResetEvent evt = new ManualResetEvent(false);
INError result = null;
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Email(email, password);
client.Register(message, (INSession session) =>
{
evt.Set();
}, (INError error) =>
{
result = error;
evt.Set();
});
evt.WaitOne(500, false);
return(result);
}
public void LoginSteam_Invalid([ValueSource("BlankCases")] string sessionToken)
{
ManualResetEvent evt = new ManualResetEvent(false);
INError result = null;
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Steam(sessionToken);
client.Login(message, (INSession session) =>
{
evt.Set();
}, (INError error) =>
{
result = error;
evt.Set();
});
evt.WaitOne(500, false);
Assert.NotNull(result);
Assert.AreEqual("Steam login not available", result.Message);
}
//[TestMethod]
public void TestMethod2()
{
string fileName = @"C:\Users\Fernando\Desktop\boletoLicenciamento.pdf";
byte[] bytes = File.ReadAllBytes(fileName);
var naturezas = Task.Run(() => NClient.Listar()).Result?.ToList();
var natureza = naturezas?.Find(x => x.Name.Equals("Recursos Humanos2"));
var propriedades = Task.Run(() => PClient.Listar()).Result?.ToList();
var propriedadeE = propriedades?.Find(x => x.Name.Equals("Email Usuario"));
var propriedadeT = propriedades?.Find(x => x.Name.Equals("Tipo Documento"));
var dic = new Dictionary <string, string>();
dic.Add($"{propriedadeE.Id}", "*****@*****.**");
dic.Add($"{propriedadeT.Id}", "RG");
//bool adicionado = Task.Run(() => PClient.AddValor(propriedadeT.Id, "RG")).Result;
bool resp = Task.Run(() => Client.Upload(bytes, "indice.jpg", natureza.Id, dic)).Result;
Assert.IsTrue(resp);
}
public void RegisterCustom_Valid()
{
ManualResetEvent evt = new ManualResetEvent(false);
INSession result = null;
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Custom(random.GetString());
client.Register(message, (INSession session) =>
{
result = session;
evt.Set();
}, (INError error) =>
{
evt.Set();
});
evt.WaitOne(500, false);
Assert.NotNull(result);
Assert.NotNull(result.Token);
}
public void LoginDevice_Invalid_NoId()
{
ManualResetEvent evt = new ManualResetEvent(false);
INError result = null;
string id = random.GetString();
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Device(id);
client.Login(message, (INSession session) =>
{
evt.Set();
}, (INError error) =>
{
result = error;
evt.Set();
});
evt.WaitOne(500, false);
Assert.NotNull(result);
Assert.AreEqual("ID not found", result.Message);
}
public void GetServerTime_Valid()
{
ManualResetEvent evt = new ManualResetEvent(false);
long serverTime = 0;
string id = TestContext.CurrentContext.Random.GetString();
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Device(id);
client.Register(message, (INSession session) =>
{
client.Connect(session);
Thread.Sleep(500);
serverTime = client.ServerTime;
evt.Set();
}, (INError _) => {
evt.Set();
});
evt.WaitOne(1000, false);
Assert.That(serverTime, Is.Not.EqualTo(0));
client.Disconnect();
}
public void Connect_Valid()
{
ManualResetEvent evt = new ManualResetEvent(false);
var connected = false;
string id = TestContext.CurrentContext.Random.GetString();
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Device(id);
client.Register(message, (INSession session) =>
{
client.Connect(session, (bool _) => {
connected = true;
evt.Set();
});
}, (INError _) => {
evt.Set();
});
evt.WaitOne(500, false);
Assert.IsTrue(connected);
client.Disconnect();
}
public void LoginEmail_Invalid_Email()
{
ManualResetEvent evt = new ManualResetEvent(false);
INError result = null;
string email = random.GetString();
string password = random.GetString();
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Email(email, password);
client.Login(message, (INSession session) =>
{
evt.Set();
}, (INError error) =>
{
result = error;
evt.Set();
});
evt.WaitOne(500, false);
Assert.NotNull(result);
Assert.AreEqual("Invalid email address format", result.Message);
}
public void SendPods()
{
NClient.Send(string.Format("Ow{0}|{1}", Pods, Stats.GetStat(StatEnum.MaxPods).Total));
}
public void SendChararacterStats()
{
NClient.Send(string.Concat("As", this.ToString()));
}
// clear all application cached data
public static void clear()
{
session = null;
client = null;
data = new Dictionary <string, Object> ();
}
