public void LoadObjects()
{
List <DB_WorldObject> objects;
if (ServerDB.SelectAllMapObjects(_mapID, out objects) && objects != null)
{
uint guid;
foreach (var item in objects)
{
if (item.ObjectID < 0)
{
guid = CreateNSObject(item);
}
else
{
guid = CreateNVObject(item);
}
ServerLogger.Log($"{_server.Name}({_mapID}): Created {(item.ObjectID < 0 ? "NS" : "NV")} object guid {guid:X8} at {item.Position}");
}
}
if (!_nsObjects.ContainsKey(0))
{
ServerLogger.LogWarn($"{_server.Name}({_mapID}) default spawn point not found");
}
}
public async void LoadObjects()
{
var objects = await ServerDB.SelectAllMapObjectsAsync(_mapID);
if (objects?.Any() ?? false)
{
uint guid;
foreach (var item in objects)
{
if (item.ObjectID < 0)
{
guid = CreateNSObject(item);
}
else
{
guid = CreateNVObject(item);
}
ServerLogger.Log($"{_server.Name}({_mapID}): Created {(item.ObjectID < 0 ? "NS" : "NV")} object guid {guid:X8} at {item.Position}");
}
}
if (!_nsObjects.ContainsKey(0))
{
ServerLogger.LogWarning($"{_server.Name}({_mapID}) default spawn point not found");
}
}
public long GetIdFromNickname(string nickname)
{
using var db = new ServerDB();
var user = db.Users.Single(u => u.Nickname == nickname);
return(user is null ? 0 : user.UserId);
}
public bool UpdateCharacter(int index, PonyData pony)
{
if (_data == null || index >= _data.Count)
{
return(false);
}
Character character;
if (index == -1)
{
if (_data.Count >= CharsMgr.MaxChars)
{
return(false);
}
if (!CharsMgr.CreateCharacter(_user.ID, pony, out character))
{
return(false);
}
_data.Add(character);
}
else
{
character = _data[index];
character.Pony = pony;
if (!ServerDB.UpdatePony(character))
{
return(false);
}
}
return(true);
}
public static async void SaveCharacter(Character entry)
{
if (!await ServerDB.UpdateCharacterAsync(entry))
{
ServerLogger.LogWarning($"Couldn't save character {entry.Id}");
}
}
public string GetNicknameFromId(long userId)
{
using var db = new ServerDB();
var user = db.Users.Single(u => u.UserId == userId);
return(user is null ? null : user.Nickname);
}
private async void Player_NetUserDataChanged(Player obj)
{
if (_char != null)
{
return;
}
_char = await ServerDB.SelectCharacterAsync(_user.Char);
if (_char == null)
{
_player.Error($"Error while retrieving pony");
}
else
{
_player.SetBounds();
_player.SetVersion();
_object = new WO_Player(this);
_save = new AutoSaveChar(this);
_items = _object.GetComponent <ItemsMgr>();
_trade = _object.GetComponent <TradeMgr>();
_skills = _object.GetComponent <SkillsMgr>();
SetPet();
_user.Map = _server.Map.Id;
_char.Map = _user.Map;
_player.SynchNetData();
await CharsMgr.SaveCharacterAsync(_char);
}
}
// Servers:
public static int InsertServer(string name, string hostUsername, string offerData)
{
ServerDB serverDB = new ServerDB();
Server server = new Server();
int room_id = -1;
if (server != null)
{
server.Name = name;
server.HostUsername = hostUsername;
server.OfferData = offerData;
if (serverDB.InsertServer(server))
{
Servers servers = serverDB.SelectByUsername(hostUsername);
for (int i = 0; i < servers.Count; i++)
{
Server ser = servers[i];
if (ser.Name == name && ser.HostUsername == hostUsername && ser.OfferData == offerData)
{
room_id = ser.ID;
}
}
}
}
return(room_id);
}
public async Task <bool> UpdateCharacter(int index, PonyData pony)
{
if (m_data == null || index >= m_data.Count)
{
return(false);
}
CharsMgr.ValidatePonyData(pony);
if (index == -1)
{
if (m_data.Count >= CharsMgr.MaxChars)
{
return(false);
}
var character = await ServerDB.CreateCharacterAsync(_user.ID, pony);
if (character == null)
{
return(false);
}
m_data.Add(character);
}
else
{
var character = m_data[index];
character.Pony = pony;
if (!await ServerDB.UpdatePonyAsync(character))
{
return(false);
}
}
return(true);
}
private void MasterServer_VerifyPlayer(Player arg1, NetMessage arg2)
{
UserData sr_user = arg1.TnUser <UserData>(); DB_User user;
var Name = arg2.ReadString();
var SID = arg2.ReadString();
var id = arg2.ReadInt32();
MasterPlayer player;
if (_users.ContainsKey(id) && TryGetByUserId(id, out player))
{
player.Player.Disconnect("Only one session!");
}
if (ServerDB.SelectUser(id, out user))
{
if (user.SID == SID && user.Name == Name)
{
sr_user.ID = user.ID;
sr_user.Name = user.Name;
sr_user.Access = user.Access;
arg1.AllowConnect();
return;
}
else
{
arg1.Disconnect("Access Denied!");
}
}
else
{
arg1.Disconnect($"User {Name} not found!");
}
}
public static async Task saveStats(ServerDB sDB)
{
using (var DbContext = new DBServer())
{
DbContext.Update(sDB);
await DbContext.SaveChangesAsync();
}
}
public static async Task <bool> SaveCharacterAsync(Character entry)
{
if (await ServerDB.UpdateCharacterAsync(entry))
{
return(true);
}
ServerLogger.LogWarning($"Couldn't save character {entry.Id}");
return(false);
}
public static bool CreateCharacter(int user, PonyData pony, out Character entry)
{
if (!ServerDB.CreateCharacter(user, pony, out entry))
{
return(false);
}
_chars[entry.ID] = entry;
return(true);
}
public static bool SaveCharacter(Character entry)
{
if (ServerDB.UpdateCharacter(entry))
{
return(true);
}
ServerLogger.LogError($"Couldn't save character {entry.ID}");
return(false);
}
private async Task Connection()
{
string connectionString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
ServerDB.ConnectionToWorkers();
ServerDB.ConnectionToDepartments();
ListViewName.ItemsSource = ServerDB.dtWorkers.DefaultView;
ComboBoxName.ItemsSource = ServerDB.dtDepartments.DefaultView;
}
private async Task _client_UserJoined(SocketGuildUser arg)
{
ServerDB server = await DBServerData.getStats(arg.Guild.Id);
if (server.AutoroleSwitch)
{
if (server.Autorole != null && server.Autorole != "")
{
string[] roles = server.Autorole.Split(',');
foreach (string role in roles)
{
if (role != "")
{
await arg.AddRoleAsync(arg.Guild.Roles.Where(x => x.Id == ulong.Parse(role)).First());
}
}
}
}
if (server.WelcomeChannel == 0)
{
return;
}
string welcome = server.Welcome;
if (welcome.Contains("[username]"))
{
welcome = welcome.Replace("[username]", $"{arg.Username}");
}
if (welcome.Contains("[servername]"))
{
welcome = welcome.Replace("[servername]", $"{arg.Guild.Name}");
}
if (welcome.Contains("[@username]"))
{
welcome = welcome.Replace("[@username]", $"<@{arg.Id}>");
}
if (welcome.Contains("[@everyone]"))
{
welcome = welcome.Replace("[@everyone]", "@everyone");
}
if (welcome.Contains("[@here]"))
{
welcome = welcome.Replace("[@here]", "@here");
}
if (welcome.Contains("[@here]"))
{
welcome = welcome.Replace("[@here]", "@here");
}
if (welcome.Contains("[useravatar]"))
{
welcome = welcome.Replace("[useravatar]", $"{arg.GetAvatarUrl()}");
}
var channel = arg.Guild.GetChannel(server.WelcomeChannel) as IMessageChannel;
await channel.SendMessageAsync(welcome);
}
public async Task <DB_Ban> IsMuted()
{
var now = DateTime.Now;
if (now >= m_mute_chek)
{
m_mute = await ServerDB.SelectBanAsync(_user.ID, _player.EndPoint.Address, BanType.Mute, now);
m_mute_chek = now.AddSeconds(Constants.MuteCheckDelay);
}
return(m_mute);
}
public static bool DeleteCharacter(int id)
{
lock (_chars)
{
if (!ServerDB.DeleteCharacter(id))
{
return(false);
}
_chars.Remove(id);
return(true);
}
}
public async Task <bool> DeleteCharacter(int index)
{
if (index >= m_data.Count || index < 0)
{
return(false);
}
if (!await ServerDB.DeleteCharacterAsync(m_data[index].Id))
{
return(false);
}
m_data.RemoveAt(index);
return(true);
}
static DataMgr()
{
_loaded = true;
_loaded &= ServerDB.SelectAllMaps(out _maps);
_loaded &= ServerDB.SelectAllNPCs(out _npcs);
_loaded &= ServerDB.SelectAllItems(out _items);
_loaded &= ServerDB.SelectAllLoots(out _loots);
_loaded &= ServerDB.SelectAllSpells(out _spells);
_loaded &= ServerDB.SelectAllDialogs(out _dialogs);
_loaded &= ServerDB.SelectAllMessages(out _messages);
_loaded &= ServerDB.SelectAllResources(out _resources);
_loaded &= ServerDB.SelectAllCreatures(out _creatures);
_loaded &= ServerDB.SelectAllMovements(out _movements);
}
public bool SetUser(User user)
{
using var db = new ServerDB();
try
{
var currentUser = db.Users.Single(u => u.UserId == user.UserId);
currentUser = user;
db.SaveChanges();
return(true);
}catch (Exception e)
{
return(false);
}
}
private bool Load()
{
if (ServerDB.Connected && ServerDB.Ping())
{
ServerLogger.LogInfo($"Connected to database");
}
else
{
ServerLogger.LogError($"Couldn't connect to database: {Environment.NewLine}{ServerDB.ConnectionString}");
return(false);
}
ServerLogger.LogInfo($"Data loaded: {DataMgr.Info}");
return(true);
}
public async Task Welcome(string _switch, ulong channelId, params string[] message)
{
if (Context.IsPrivate)
{
await Context.Channel.SendMessageAsync(":x: **You must in a guild to use that command!**"); return;
}
if (!(Context.User as IGuildUser).GuildPermissions.Administrator)
{
await Context.Channel.SendMessageAsync(":x: **You must be an administrator to use that command!**"); return;
}
switch (_switch.ToLower())
{
case "on":
{
ServerDB server = await DBServerData.getStats(Context.Guild.Id);
string _message = new Addons()._out(message);
server.Welcome = _message;
server.WelcomeChannel = channelId;
await DBServerData.saveStats(server);
await Context.Channel.SendMessageAsync($"Welcome message has been successfully turned on.");
break;
}
case "off":
{
ServerDB server = await DBServerData.getStats(Context.Guild.Id);
server.WelcomeChannel = 0;
server.Welcome = "";
await DBServerData.saveStats(server);
await Context.Channel.SendMessageAsync($"Welcome message has been successfully turned off.");
return;
}
default:
{
await Context.Channel.SendMessageAsync(":x: **You can't use that command without arguments.**" + Environment.NewLine +
"**To see the command information type d!help wm**");
break;
}
}
}
public static string GetServerById(int Id)
{
ServerDB serverDB = new ServerDB();
Server server = serverDB.SelectById(Id);
string str = null;
if (server != null)
{
str = "{\"ID\":\"" + server.ID + "\",\"Name\":\"" + server.Name + "\",\"HostUsername\":\"" + server.HostUsername + "\",\"OfferData\":[" + server.OfferData + "]" + "}";
}
else
{
return(null);
}
return(str);
}
private async Task <bool> LoadAsync()
{
if (await ServerDB.PingAsync())
{
ServerLogger.LogInfo($"Connected to database");
}
else
{
ServerLogger.LogError($"Couldn't connect to database: {Environment.NewLine}{ServerDB.ConnectionString}");
return(false);
}
await DataMgr.LoadAllAsync();
ServerLogger.LogInfo($"Data loaded: {DataMgr.Info}");
return(true);
}
public static int DeleteServer(int ID)
{
int flag = 0;
ServerDB serverDB = new ServerDB();
bool s = serverDB.DeleteServer(ID);
if (s)
{
flag = 1;
}
else
{
flag = 0;
}
return(flag);
}
public static int DeleteServer(string HosterName)
{
int flag = 0;
ServerDB serverDB = new ServerDB();
bool s = serverDB.DeleteServer(HosterName);
if (s)
{
flag = 1;
}
else
{
flag = 0;
}
return(flag);
}
public static bool SelectAllUserCharacters(int user, out List <Character> data)
{
lock (_chars)
if (_chars.Any(x => x.Value.User == user))
{
data = _chars.Values.Where(x => x.User == user).ToList();
return(true);
}
if (ServerDB.SelectAllUserCharacters(user, out data))
{
lock (_chars) foreach (var item in data)
{
_chars[item.ID] = item;
}
return(true);
}
return(false);
}
public static bool SelectCharacter(int id, out Character entry)
{
lock (_chars)
{
if (_chars.TryGetValue(id, out entry))
{
return(true);
}
else if (ServerDB.SelectCharacter(id, out entry))
{
_chars[id] = entry;
}
else
{
return(false);
}
return(true);
}
}
public static void LoadAll()
{
if (!ServerDB.SelectAllMaps(out m_maps))
{
throw new Exception($"Failed to load: {nameof(m_maps)}");
}
if (!ServerDB.SelectAllNPCs(out m_npcs))
{
throw new Exception($"Failed to load: {nameof(m_npcs)}");
}
if (!ServerDB.SelectAllItems(out m_items))
{
throw new Exception($"Failed to load: {nameof(m_items)}");
}
if (!ServerDB.SelectAllLoots(out m_loots))
{
throw new Exception($"Failed to load: {nameof(m_loots)}");
}
if (!ServerDB.SelectAllSpells(out m_spells))
{
throw new Exception($"Failed to load: {nameof(m_spells)}");
}
if (!ServerDB.SelectAllDialogs(out m_dialogs))
{
throw new Exception($"Failed to load: {nameof(m_dialogs)}");
}
if (!ServerDB.SelectAllMessages(out m_messages))
{
throw new Exception($"Failed to load: {nameof(m_messages)}");
}
if (!ServerDB.SelectAllResources(out m_resources))
{
throw new Exception($"Failed to load: {nameof(m_resources)}");
}
if (!ServerDB.SelectAllCreatures(out m_creatures))
{
throw new Exception($"Failed to load: {nameof(m_creatures)}");
}
if (!ServerDB.SelectAllMovements(out m_movements))
{
throw new Exception($"Failed to load: {nameof(m_movements)}");
}
}
public TUObjects(DbConnection dbConnection, ServerDB server)
{
this.dbConnection = dbConnection;
this.dbServer = server;
switch (dbServer)
{
case ServerDB.MSSqlServer:
{
dbCommand = new SqlCommand();
dbCommand.Connection = dbConnection;
break;
}
case ServerDB.FireBird:
{
dbCommand = new FbCommand();
dbCommand.Connection = dbConnection;
break;
}
default:
break;
}
}
public Aspirants(DbConnection dbConnection, ServerDB server)
: base(dbConnection, server)
{
}
public Workers(DbConnection dbConnection, ServerDB server)
: base(dbConnection, server)
{
}
public Teachers(DbConnection dbConnection, ServerDB server)
: base(dbConnection, server)
{
}
public Learners(DbConnection dbConnection, ServerDB server)
: base(dbConnection, server)
{
}
public People(DbConnection dbConnection, ServerDB server)
: base(dbConnection, server)
{
}
public AuxiliaryWorkers(DbConnection dbConnection, ServerDB server)
: base(dbConnection, server)
{
}
public BudgetStudents(DbConnection dbConnection, ServerDB server)
: base(dbConnection, server)
{
}
public PaidStudents(DbConnection dbConnection, ServerDB server)
: base(dbConnection, server)
{
}
