public bool IsMet(Aisling player, Action <string, bool> callbackMsg = null)
{
var result = new Dictionary <int, Tuple <bool, object> >();
var n = 0;
try
{
n = CheckSpellandSkillPredicates(player, result, n);
n = CHeckAttributePredicates(player, result, n);
n = CheckItemPredicates(player, result, n);
n = CheckQuestPredicates(player, result, n);
}
catch (Exception e)
{
player.Client.CloseDialog();
player.Client.SendMessage(0x02, "You cannot learn that yet. Not even close!");
player.SendAnimation(94, player, player);
ServerContextBase.Report(e);
//ignore
return(false);
}
var ready = CheckPredicates(callbackMsg, result);
{
if (ready)
{
player.SendAnimation(92, player, player);
}
}
return(ready);
}
/// <summary>
/// Clears the entire cache and disposes all active timers.
/// </summary>
public void Clear()
{
locker.EnterWriteLock();
try
{
try
{
foreach (var t in timers.Values)
{
t.Dispose();
}
}
catch (Exception e)
{
ServerContextBase.Report(e);
}
timers.Clear();
cache.Clear();
}
finally
{
locker.ExitWriteLock();
}
}
public int EndReceiveHeader(IAsyncResult result, out SocketError error)
{
try
{
var bytes = EndReceive(result, out error);
if (bytes == 0 ||
error != SocketError.Success)
{
return(0);
}
headerOffset += bytes;
if (!HeaderComplete)
{
return(bytes);
}
packetLength = (header[1] << 8) | header[2];
packetOffset = 0;
return(bytes);
}
catch (Exception e)
{
error = SocketError.SocketError;
ServerContextBase.Report(e);
ServerContextBase.Report(error);
}
return(0);
}
public void Save(Aisling obj)
{
if (ServerContextBase.Paused)
{
return;
}
try
{
var path = Path.Combine(StoragePath, $"{obj.Username.ToLower()}.json");
var objString = JsonConvert.SerializeObject(obj, Formatting.Indented, new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.All
});
File.WriteAllText(path, objString);
}
catch (Exception e)
{
ServerContextBase.Report(e);
/* Ignore */
}
}
public override void Serialize(NetworkPacketReader reader)
{
var data = CHeckData(reader);
reader.Position = 0;
Index = reader.ReadByte();
try
{
if (reader.GetCanRead())
{
Serial = reader.ReadUInt32();
}
if (reader.Position + 4 < reader.Packet.Data.Length)
{
Point = reader.ReadPosition();
}
}
catch (Exception e)
{
ServerContextBase.Report(e);
}
finally
{
Data = data.Trim('\0');
}
}
public Area Load(string Name)
{
var path = Path.Combine(StoragePath, $"{Name.ToLower()}.json");
if (!File.Exists(path))
{
return(null);
}
using (var s = File.OpenRead(path))
using (var f = new StreamReader(s))
{
var content = f.ReadToEnd();
var settings = StorageManager.Settings;
settings.TypeNameHandling = TypeNameHandling.None;
try
{
var obj = JsonConvert.DeserializeObject <Area>(content, settings);
ServerContextBase.Report(obj);
return(obj);
}
catch (Exception e)
{
ServerContextBase.Report(e);
return(null);
}
}
}
public void EndReceivePacket(IAsyncResult result)
{
try
{
if (!(result.AsyncState is TClient client))
{
return;
}
var bytes = client.ServerSocket.EndReceivePacket(result, out var error);
if (bytes == 0 ||
error != SocketError.Success)
{
ClientDisconnected(client);
return;
}
if (client.ServerSocket?.PacketComplete ?? false)
{
ClientDataReceived(client, client.ServerSocket?.ToPacket());
client.ServerSocket?.BeginReceiveHeader(EndReceiveHeader, out error, client);
}
else
{
client.ServerSocket?.BeginReceivePacket(EndReceivePacket, out error, client);
}
}
catch (Exception e)
{
ServerContextBase.Report(e);
//ignore
}
}
public override void ClientDisconnected(GameClient client)
{
if (client?.Aisling == null)
{
return;
}
try
{
if ((DateTime.UtcNow - client.LastSave).TotalSeconds > 2)
{
client.Save();
}
client.Aisling.LoggedIn = false;
client.Aisling.Remove(true);
}
catch (Exception e)
{
ServerContextBase.Report(e);
}
finally
{
base.ClientDisconnected(client);
}
}
private void LoadSpellScript(string spellscriptstr, bool primary = false)
{
try
{
if (ServerContextBase.GlobalSpellTemplateCache.ContainsKey(spellscriptstr))
{
var scripts = ScriptManager.Load <SpellScript>(spellscriptstr,
Spell.Create(1, ServerContextBase.GlobalSpellTemplateCache[spellscriptstr]));
foreach (var script in scripts.Values)
{
if (script != null)
{
script.IsScriptDefault = primary;
SpellScripts.Add(script);
}
}
}
}
catch (Exception e)
{
ServerContextBase.Report(e);
//ignore
}
}
static TemplateStorage()
{
if (ServerContextBase.StoragePath == null)
{
ServerContextBase.LoadConstants();
}
StoragePath = $@"{ServerContextBase.StoragePath}\templates";
var tmp = new T();
StoragePath = Path.Combine(StoragePath, "%");
if (tmp is SkillTemplate)
{
StoragePath = StoragePath.Replace("%", "Skills");
}
if (tmp is SpellTemplate)
{
StoragePath = StoragePath.Replace("%", "Spells");
}
if (tmp is MonsterTemplate)
{
StoragePath = StoragePath.Replace("%", "Monsters");
}
if (tmp is ItemTemplate)
{
StoragePath = StoragePath.Replace("%", "Items");
}
if (tmp is MundaneTemplate)
{
StoragePath = StoragePath.Replace("%", "Mundanes");
}
if (tmp is WorldMapTemplate)
{
StoragePath = StoragePath.Replace("%", "WorldMaps");
}
if (tmp is Reactor)
{
StoragePath = StoragePath.Replace("%", "Reactors");
}
if (tmp is PopupTemplate)
{
StoragePath = StoragePath.Replace("%", "Popups");
}
if (!Directory.Exists(StoragePath))
{
Directory.CreateDirectory(StoragePath);
}
}
public void LoadScriptInterpreter(GameClient client)
{
var parser = new YamlMenuParser();
var yamlPath = ServerContextBase.StoragePath + $@"\Scripts\Menus\{Mundane.Template.Name}.yaml";
if (File.Exists(yamlPath))
{
if (client.MenuInterpter == null)
{
client.MenuInterpter = parser.CreateInterpreterFromFile(yamlPath);
client.MenuInterpter.Client = client;
client.MenuInterpter.OnMovedToNextStep += MenuInterpreter_OnMovedToNextStep;
client.MenuInterpter.RegisterCheckpointHandler("QuestCompleted", (_client, res) =>
{
if (_client.Aisling.HasQuest(res.Value))
{
res.Result = _client.Aisling.HasCompletedQuest(res.Value);
}
});
client.MenuInterpter.RegisterCheckpointHandler("HasAForm",
(_client, res) => { res.Result = _client.Aisling.AnimalForm != AnimalForm.None; });
client.MenuInterpter.RegisterCheckpointHandler("LearnForm1",
(_client, res) => { _client.Aisling.AnimalForm = AnimalForm.Draco; });
client.MenuInterpter.RegisterCheckpointHandler("LearnForm2",
(_client, res) => { _client.Aisling.AnimalForm = AnimalForm.Kelberoth; });
client.MenuInterpter.RegisterCheckpointHandler("LearnForm3",
(_client, res) => { _client.Aisling.AnimalForm = AnimalForm.WhiteBat; });
client.MenuInterpter.RegisterCheckpointHandler("LearnForm4",
(_client, res) => { _client.Aisling.AnimalForm = AnimalForm.Scorpion; });
client.MenuInterpter.RegisterCheckpointHandler("HasKilled", (_client, res) =>
{
if (_client.Aisling.HasQuest(quest.Name))
{
if (_client.Aisling.HasKilled(res.Value, res.Amount))
{
if (!_client.Aisling.HasCompletedQuest(quest.Name))
{
_client.Aisling.CompleteQuest(quest.Name);
quest.OnCompleted(_client.Aisling);
}
res.Result = true;
}
}
});
ServerContextBase.Debug("Script Interpreter Created for Mundane: {0}", Mundane.Template.Name);
}
}
}
public override void Update(TimeSpan elapsedTime)
{
_timer.Update(elapsedTime);
if (_timer.Elapsed)
{
ServerContextBase.SaveCommunityAssets();
_timer.Reset();
}
}
public virtual void ClientDataReceived(TClient client, NetworkPacket packet)
{
if (client == null)
{
return;
}
if (!client.ServerSocket.Connected)
{
return;
}
if (packet == null)
{
return;
}
NetworkFormat format;
if (_formatCache.Exists(packet.Command))
{
format = _formatCache.Get(packet.Command);
}
else
{
format = NetworkFormatManager.GetClientFormat(packet.Command);
_formatCache.AddOrUpdate(packet.Command, format, Timeout.Infinite);
}
if (format == null)
{
return;
}
try
{
client.Read(packet, format);
if (_handlers[format.Command]?.Invoke(this,
new object[]
{
client,
format
}) != null)
{
}
}
catch (Exception e)
{
ServerContextBase.Report(e);
//Ignore
}
}
public override void Update(TimeSpan elapsedTime)
{
_timer.Update(elapsedTime);
if (_timer.Elapsed)
{
_timer.Reset();
ServerContextBase.Debug($"Server Running on {Process.GetCurrentProcess().Threads.Count} Threads.");
}
}
public void ReloadObjects(bool all = false)
{
var objs = GetObjects(null, i => i != null && i.Serial != Aisling.Serial,
all ? Get.All : Get.Items | Get.Money | Get.Monsters | Get.Mundanes);
foreach (var obj in objs)
{
obj.Remove();
}
ServerContextBase.LoadAndCacheStorage();
}
static WarpStorage()
{
if (ServerContextBase.StoragePath == null)
{
ServerContextBase.LoadConstants();
}
StoragePath = $@"{ServerContextBase.StoragePath}\templates\warps";
if (!Directory.Exists(StoragePath))
{
Directory.CreateDirectory(StoragePath);
}
}
static AreaStorage()
{
if (ServerContextBase.StoragePath == null)
{
ServerContextBase.LoadConstants();
}
StoragePath = $@"{ServerContextBase.StoragePath}\areas";
if (!Directory.Exists(StoragePath))
{
Directory.CreateDirectory(StoragePath);
}
}
public void Save(Area obj)
{
if (ServerContextBase.Paused)
{
return;
}
var path = Path.Combine(StoragePath, $"{obj.ContentName.ToLower()}.json");
var objString = JsonConvert.SerializeObject(obj, StorageManager.Settings);
File.WriteAllText(path, objString);
ServerContextBase.Report(obj);
}
/// <summary>
/// Login - Check username/password. Proceed to Game Client.
/// </summary>
protected override void Format03Handler(LoginClient client, ClientFormat03 format)
{
Aisling _aisling = null;
try
{
_aisling = StorageManager.AislingBucket.Load(format.Username);
if (_aisling != null)
{
if (_aisling.Password != format.Password)
{
client.SendMessageBox(0x02, "Sorry, Incorrect Password.");
return;
}
}
else
{
client.SendMessageBox(0x02,
$"{format.Username} does not exist in this world. You can make this hero by clicking on 'Create'.");
return;
}
}
catch (Exception e)
{
client.SendMessageBox(0x02,
$"{format.Username} is not supported by the new server. Please remake your character. This will not happen when the server goes to beta.");
ServerContextBase.Report(e);
return;
}
if (!ServerContextBase.GlobalConfig.MultiUserLogin)
{
var aislings = GetObjects <Aisling>(null,
i => i.Username.ToLower() == format.Username.ToLower() &&
format.Password == i.Password);
foreach (var aisling in aislings)
{
aisling.Client.Server.ClientDisconnected(aisling.Client);
}
}
LoginAsAisling(client, _aisling);
}
public TD Load <TD>(string name, string fixedPath = null) where TD : class, new()
{
var path = fixedPath ?? Path.Combine(StoragePath, $"{name.ToLower()}.json");
if (!File.Exists(path))
{
return(null);
}
using (var s = File.OpenRead(path))
{
using (var f = new StreamReader(s))
{
var obj = JsonConvert.DeserializeObject <TD>(f.ReadToEnd(), StorageManager.Settings);
ServerContextBase.Report(obj);
return(obj);
}
}
}
private async Task UpdateComponents(TimeSpan elapsedTime)
{
try
{
foreach (var component in Components.Values)
{
component.Update(elapsedTime);
}
}
catch (Exception e)
{
await Task.FromException(e);
ServerContextBase.Report(e);
throw;
}
await Task.CompletedTask;
}
public bool CastSpell(string spellName, Sprite caster, Sprite target)
{
if (ServerContextBase.GlobalSpellTemplateCache.ContainsKey(spellName))
{
var scripts = ScriptManager.Load <SpellScript>(spellName,
Spell.Create(1, ServerContextBase.GlobalSpellTemplateCache[spellName]));
{
foreach (var script in scripts.Values)
{
script.OnUse(caster, target);
ServerContextBase.Report(
$"[Spell {spellName} Casted By {caster.Serial} At Target {target.Serial}]");
}
return(true);
}
}
return(false);
}
private async Task UpdateAreas(TimeSpan elapsedTime)
{
var values = ServerContextBase.GlobalMapCache.Select(i => i.Value).ToArray();
try
{
foreach (var area in values)
{
area.Update(elapsedTime);
}
}
catch (Exception e)
{
await Task.FromException(e);
ServerContextBase.Report(e);
throw;
}
await Task.CompletedTask;
}
public static byte[] Inflate(byte[] buffer)
{
using (var iStream = new MemoryStream(buffer))
using (var oStream = new MemoryStream())
using (var zStream = new ZOutputStream(oStream))
{
try
{
CopyStream(iStream, zStream);
zStream.finish();
return(oStream.ToArray());
}
catch (Exception e)
{
ServerContextBase.Report(e);
return(null);
}
}
}
private async void MainServerLoop()
{
_lastHeavyUpdate = DateTime.UtcNow;
while (ServerContextBase.Running)
{
var elapsedTime = DateTime.UtcNow - _lastHeavyUpdate;
try
{
await UpdateClients(elapsedTime);
await UpdateComponents(elapsedTime);
await UpdateAreas(elapsedTime);
}
catch (Exception e)
{
ServerContextBase.Report(e);
}
_lastHeavyUpdate = DateTime.UtcNow;
await Task.Delay(_heavyUpdateSpan);
}
}
public PlayerClientContext(ServerContextBase application, IServerTransport transport) : base(application, transport)
{
}
public virtual void ClientConnected(TClient client)
{
ServerContextBase.Debug("Connection From {0} Established.",
client.ServerSocket.RemoteEndPoint.ToString());
}
public static void ApplyQuality(Item obj)
{
try
{
if (obj.Template == null)
{
return;
}
var template = (ItemTemplate)StorageManager.ItemBucket.LoadFromStorage(obj.Template);
if (template == null)
{
return;
}
obj.Template = new ItemTemplate();
obj.Template.AcModifer = template.AcModifer;
obj.Template.CanStack = template.CanStack;
obj.Template.CarryWeight = template.CarryWeight;
obj.Template.Class = template.Class;
obj.Template.Color = template.Color;
obj.Template.ConModifer = template.ConModifer;
obj.Template.DefenseElement = template.DefenseElement;
obj.Template.DexModifer = template.DexModifer;
obj.Template.DisplayImage = template.DisplayImage;
obj.Template.DmgMax = template.DmgMax;
obj.Template.DmgMin = template.DmgMin;
obj.Template.DmgModifer = template.DmgModifer;
obj.Template.DropRate = template.DropRate;
obj.Template.EquipmentSlot = template.EquipmentSlot;
obj.Template.Flags = template.Flags;
obj.Template.Gender = template.Gender;
obj.Template.HasPants = template.HasPants;
obj.Template.HealthModifer = template.HealthModifer;
obj.Template.HitModifer = template.HitModifer;
obj.Template.ID = template.ID;
obj.Template.Image = template.Image;
obj.Template.IntModifer = template.IntModifer;
obj.Template.LevelRequired = template.LevelRequired;
obj.Template.ManaModifer = template.ManaModifer;
obj.Template.MaxDurability = template.MaxDurability;
obj.Template.MaxStack = template.MaxStack;
obj.Template.MrModifer = template.MrModifer;
obj.Template.Name = template.Name;
obj.Template.NpcKey = template.NpcKey;
obj.Template.OffenseElement = template.OffenseElement;
obj.Template.ScriptName = template.ScriptName;
obj.Template.SpellOperator = template.SpellOperator;
obj.Template.StageRequired = template.StageRequired;
obj.Template.StrModifer = template.StrModifer;
obj.Template.Value = template.Value;
obj.Template.Weight = template.Weight;
obj.Template.WisModifer = template.WisModifer;
if (obj.Upgrades > 0)
{
if (obj.Template.AcModifer != null)
{
if (obj.Template.AcModifer.Option == Operator.Remove)
{
obj.Template.AcModifer.Value -= -obj.Upgrades;
}
}
if (obj.Template.MrModifer != null)
{
if (obj.Template.MrModifer.Option == Operator.Add)
{
obj.Template.MrModifer.Value += obj.Upgrades * 10;
}
}
if (obj.Template.HealthModifer != null)
{
if (obj.Template.HealthModifer.Option == Operator.Add)
{
obj.Template.HealthModifer.Value += 500 * obj.Upgrades;
}
}
if (obj.Template.ManaModifer != null)
{
if (obj.Template.ManaModifer.Option == Operator.Add)
{
obj.Template.ManaModifer.Value += 300 * obj.Upgrades;
}
}
if (obj.Template.StrModifer != null)
{
if (obj.Template.StrModifer.Option == Operator.Add)
{
obj.Template.StrModifer.Value += obj.Upgrades;
}
}
if (obj.Template.IntModifer != null)
{
if (obj.Template.IntModifer.Option == Operator.Add)
{
obj.Template.IntModifer.Value += obj.Upgrades;
}
}
if (obj.Template.WisModifer != null)
{
if (obj.Template.WisModifer.Option == Operator.Add)
{
obj.Template.WisModifer.Value += obj.Upgrades;
}
}
if (obj.Template.ConModifer != null)
{
if (obj.Template.ConModifer.Option == Operator.Add)
{
obj.Template.ConModifer.Value += obj.Upgrades;
}
}
if (obj.Template.DexModifer != null)
{
if (obj.Template.DexModifer.Option == Operator.Add)
{
obj.Template.DexModifer.Value += obj.Upgrades;
}
}
if (obj.Template.DmgModifer != null)
{
if (obj.Template.DmgModifer.Option == Operator.Add)
{
obj.Template.DmgModifer.Value += obj.Upgrades;
}
}
if (obj.Template.HitModifer != null)
{
if (obj.Template.HitModifer.Option == Operator.Add)
{
obj.Template.HitModifer.Value += obj.Upgrades;
}
}
obj.Template.LevelRequired -= (byte)obj.Upgrades;
obj.Template.Value *= (byte)obj.Upgrades;
obj.Template.MaxDurability += (byte)(1500 * obj.Upgrades);
obj.Template.DmgMax += 100 * obj.Upgrades;
obj.Template.DmgMin += 20 * obj.Upgrades;
if (obj.Template.LevelRequired <= 0 || obj.Template.LevelRequired > 99)
{
obj.Template.LevelRequired = 1;
}
}
}
catch (Exception e)
{
ServerContextBase.Report(e);
}
}
public InstanceClientContext(ServerContextBase application, IServerTransport transport) : base(application, transport)
{
}
private void OnError(SocketError error)
{
ServerContextBase.Report(error);
}
