public static void StartLogin()
{
ushort loginPort = ServerConstants.LoginPort;
byte[] loginIp;
if (ServerConstants.LocalHost)
{
loginIp = ServerConstants.LocalHostIp;
}
else
{
loginIp = new byte[] { 0, 0, 0, 0 }
};
int i = 1;
Console.ForegroundColor = ConsoleColor.White;
Server server = new Server();
server.OnClientConnected += MapleClientConnect;
server.Start(new IPAddress(loginIp), loginPort);
LoginServers.Add(server);
ServerConsole.Info(String.Format("LoginServer[{0}] is running", i));
server = new Server();
server.Start(new IPAddress(loginIp), (ushort)(loginPort + 1)); //server for pinging, we dont rly want it to log everything
i++;
}
public static void StartCashShop()
{
CashShopServer = new Server();
CashShopServer.OnClientConnected += MapleClientConnect;
CashShopServer.Start(ServerConstants.LocalHost ? new IPAddress(ServerConstants.LocalHostIp) : IPAddress.Any, (ushort)ServerConstants.CashShopPort);
ServerConsole.Info("CashShopServer is running");
}
public static void LoadDataBuffers()
{
//DisabledQuikEdit();
Stopwatch allData = new Stopwatch();
allData.Start();
int count = 0;
count += DataProvider.LoadEtc(@".\NX\Etc.nx");
ManualResetEvent[] handles = new ManualResetEvent[6];
for (int i = 0; i < handles.Count(); i++)
{
handles[i] = new ManualResetEvent(false);
}
ThreadPool.QueueUserWorkItem(new WaitCallback(LoadMobs), handles[2]);
ThreadPool.QueueUserWorkItem(new WaitCallback(LoadEquips), handles[0]);
ThreadPool.QueueUserWorkItem(new WaitCallback(LoadItems), handles[1]);
ThreadPool.QueueUserWorkItem(new WaitCallback(LoadSkills), handles[3]);
ThreadPool.QueueUserWorkItem(new WaitCallback(LoadQuests), handles[4]);
handles[2].WaitOne(); //Wait for mob thread to finish
ThreadPool.QueueUserWorkItem(new WaitCallback(LoadMaps), handles[5]); //Map needs mob wz info, so wait until mobs finished
WaitHandle.WaitAll(handles);
//Always do strings after the other WZs!
count += DataProvider.LoadStrings(@".\NX\String.nx");
ServerConsole.Info("{0} Strings loaded", count);
ServerConsole.Info("Finished loading .NX in {0} ms", (int)allData.ElapsedMilliseconds);
Stopwatch sw = new Stopwatch();
sw.Start();
count = DataProvider.LoadScripts();
ServerConsole.Info("{0} Scripts loaded in {1} ms", count, (int)sw.ElapsedMilliseconds);
sw.Reset();
/*
* sw.Start();
* Count = LoadCashShopItems();
* ServerConsole.Info(String.Format("{0} CashShop items loaded in {1} ms", Count, (int)sw.ElapsedMilliseconds));
* sw.Reset();
*/
sw.Start();
count = AdminCommands.ReloadCommands();
count += GMCommands.ReloadCommands();
count += PlayerCommands.ReloadCommands();
count += DonorCommands.ReloadCommands();
ServerConsole.Info("{0} Commands loaded in {1} ms", count, (int)sw.ElapsedMilliseconds);
sw.Reset();
LoadMonsterDrops();
allData.Stop();
ServerConsole.Info("All data loaded in {0} ms", (int)allData.ElapsedMilliseconds);
ServerConsole.Info("==============================================");
}
public static void ReceivePacket(string[] split, MapleClient c)
{
string packet = split.Fuse(1);
PacketWriter pw = new PacketWriter();
pw.WriteHexString(packet);
c.SendPacket(pw);
ServerConsole.Info("Player sent packet to himself: " + pw.ToString());
}
public static void LoadQuests(object r)
{
Stopwatch sw = Stopwatch.StartNew();
int count = DataProvider.LoadQuests(@".\NX\Quest.nx");
ServerConsole.Info("{0} Quests loaded in {1} ms", count, sw.ElapsedMilliseconds);
sw.Stop();
((ManualResetEvent)r).Set();
}
public static void Select(MapleClient c, PacketReader pr)
{
if (pr.Available == 0)
{
return;
}
byte Type = pr.ReadByte();
switch (Type)
{
case 0x65: //Select cat
int Cat = pr.ReadInt();
Cat %= 1000000;
int subCat = Cat;
subCat %= 10000;
Cat = (int)Math.Floor((decimal)Cat / 10000);
subCat = (int)Math.Floor((decimal)subCat / 100);
if (Cat == 0)
{
return;
}
if (subCat == 1)
{
return;
}
ShowCatItems(c, Cat, subCat);
break;
case 0x66: //Leave CashShop
byte Channel = c.Account.MigrationData.ReturnChannel;
ChangeChannelHandler.Handle(c, new PacketReader(new byte[] { (byte)(Channel) }));
break;
case 0x67: //Add Fav
case 0x68: //Remove Fav
pr.ReadByte();
AddFav(c, pr.ReadInt());
break;
case 0x69: //Like
int SN = pr.ReadInt();
AddLike(c, SN);
break;
case 0x6D: //Select fav
ShowFav(c);
break;
default:
ServerConsole.Warning("Unknow CashshopSelectType : {0}", Type);
ServerConsole.Info(Functions.ByteArrayToStr(pr.ToArray()));
break;
}
}
public static void LoadMonsterDrops()
{
Stopwatch sw = new Stopwatch();
sw.Start();
int count = 0;
count = DataProvider.LoadMobDrops();
count += DataProvider.LoadGlobalDrops();
sw.Stop();
ServerConsole.Info(String.Format("{0} Monsterdrops loaded in {1} ms", count, (int)sw.ElapsedMilliseconds));
}
private static void StartDataApi()
{
HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(ServerConstants.dataApiUrl);
config.Routes.MapHttpRoute(
"DataApi", "{controller}/{action}/{param}",
new { param = RouteParameter.Optional });
dataApi = new HttpSelfHostServer(config);
//dataApi.OpenAsync().Wait();
ServerConsole.Info(String.Format("DataApi running on {0}", ServerConstants.dataApiUrl));
}
public MapleClient(Socket session)
{
SClient = new CClientSocket(this, session);
Host = SClient.Host;
Port = SClient.Port;
ServerConsole.Info(String.Format("{0}:{1} Connnected", Host, Port));
Channel = 1;
Connected = true;
LastPacketsSent = new LimitedQueue <PacketWriter>(10);
CheatTracker = new OffenceTracker()
{
Client = this
};
}
public void SendPacket(PacketWriter packet)
{
if (ServerConstants.PrintPackets)
{
ServerConsole.Info(String.Format("Sending: {0}", Functions.ByteArrayToStr(packet.ToArray())));
}
if (SClient == null)
{
return;
}
SClient.SendPacket(packet);
//LastPacketsSent.Enqueue(packet);
}
public static void Initialize()
{
ServerConsole.Info("\t# loading Skill Tree...");
Stopwatch watch = Stopwatch.StartNew();
string filepath = Core.Conf.ConfigDir + "/Database/CharacterSkillTree.xml";
Tree = new SkillTree();
Tree = Parser.ParseSkillTree(filepath);
ServerConsole.WriteLine(EConsoleColor.Status, " done in " + watch.ElapsedMilliseconds + "ms");
watch.Stop();
watch = null;
}
public static void Initialize()
{
ServerConsole.Info("\t# loading fame lists...");
// TODO: some sort of dynamic class lists would be nice to have..
string jobsBlacksmith = string.Concat((int)EClass.Blacksmith, ',', (int)EClass.BabyBlacksmith, ',', (int)EClass.Whitesmith);
string jobsAlchemist = string.Concat((int)EClass.Alchemist, ',', (int)EClass.BabyAlchemist, ',', (int)EClass.Creator);
string jobsTaekwon = string.Concat((int)EClass.Taekwon);
int size = 10;
// Load from database
Blacksmith = ReadFameList(jobsBlacksmith, size);
Alchemist = ReadFameList(jobsAlchemist, size);
Taekwon = ReadFameList(jobsTaekwon, size);
ServerConsole.WriteLine(EConsoleColor.Status, " Done (" + Blacksmith.Count + " blacksmith, " + Alchemist.Count + " Alchemist, " + Taekwon.Count + " Taekwon)");
}
internal void Disconnected()
{
MapleCharacter save = null;
if (Account != null)
{
save = Account.Character;
}
try
{
if (Account != null)
{
Account.Release(); //It is imperative to release the account before removing the client from the server.
}
}
catch { }
try
{
if (Connected)
{
ServerConsole.Info(String.Format("{0}:{1} Disconnected", Host, Port));
}
Connected = false;
Program.RemoveClient(this);
if (save != null)
{
save.LoggedOut();
}
}
catch { }
try
{
if (NpcEngine != null)
{
NpcEngine.Dispose();
}
}
catch { }
try
{
SClient.Dispose();
}
catch { }
}
public static void StartChannels()
{
ushort channelStartPort = ServerConstants.ChannelStartPort;
byte i = 0;
byte channelCount = ServerConstants.Channels;
while (i < channelCount)
{
ChannelServer channelServer = new ChannelServer(i);
channelServer.OnClientConnected += MapleClientConnect;
ushort port = (ushort)(channelStartPort + i);
channelServer.Start(ServerConstants.LocalHost ? new IPAddress(ServerConstants.LocalHostIp) : IPAddress.Any, port);
ChannelServers.Add((byte)(i), channelServer);
ServerConsole.Info(String.Format("ChannelServer[{0}] is running on port {1}", i + 1, port));
i++;
}
ServerConsole.Info("Server and channels are running.");
ServerConsole.Info("To safely stop the server type 'exit'");
}
public static void Handle(PacketReader packet, MapleClient c)
{
if (packet.Length >= 2)
{
if (ServerConstants.PrintPackets)
{
ServerConsole.Info("Receiving: {0}", Functions.ByteArrayToStr(packet.ToArray()));
}
RecvHeader header = (RecvHeader)packet.ReadHeader();
if (header <= RecvHeader.ErrorCode)
{
switch (header)
{
#region Miscellaneous
case RecvHeader.ErrorCode:
ErrorCodeHandler.Handle(c, packet);
break;
case RecvHeader.BlackCipher:
BlackCipherHandler.Handle(packet.ReadInt(), c);
break;
case RecvHeader.HandShake:
ReceiveHandShakeHandler.Handle(c, packet);
break;
case RecvHeader.CrashReport:
break;
case RecvHeader.Pong:
PongHandler.Handle(c);
break;
#endregion
#region Login Server
case RecvHeader.EnteredLoginScreen:
EnteredLoginScreenHandler.Handle(c);
break;
case RecvHeader.ClientLoaded:
ClientLoadedHandler.Handle(c);
break;
case RecvHeader.ShowServerList:
case RecvHeader.ReShowServerList:
ServerlistRequestHandler.Handle(c);
break;
case RecvHeader.WorldSelect:
WorldSelectHandler.Handle(packet.ReadShort(), c);
break;
case RecvHeader.CheckCharacterName:
CheckCharnameHandler.Handle(c, packet.ReadMapleString());
break;
case RecvHeader.CreateCharacter:
CreateCharHandler.Handle(c, packet);
break;
case RecvHeader.DeleteCharacter:
DeleteCharacterHandler.Handle(c, packet);
break;
case RecvHeader.SetAccountPic:
SetAccountPicHandler.Handle(c, packet);
break;
case RecvHeader.ChooseCharacterWithPic:
ChooseCharWithPicHandler.Handle(c, packet);
break;
case RecvHeader.EnterMap:
CharacterLoginHandler.Handle(c, packet);
break;
case RecvHeader.AccountLogin:
LoginAccountHandler.Handle(c, packet);
break;
case RecvHeader.ChooseChannel:
ChooseChannelHandler.Handle(c, packet);
break;
#endregion
default:
#if DEBUG
ServerConsole.Debug("Unhandled recv packet: {0}", Functions.ByteArrayToStr(packet.ToArray()));
#endif
break;
}
}
else
{
if (c.Account?.Character?.Map == null)
{
return;
}
switch (header)
{
#region GameServer
// Spam packets:
case RecvHeader.ClickDialog:
case RecvHeader.AttackSpam:
case RecvHeader.FinalPactEnd:
break;
case RecvHeader.PartyResponse:
PartyResponseHandler.Handle(c, packet);
break;
case RecvHeader.PartyOperation:
PartyHandler.Handle(c, packet);
break;
case RecvHeader.RequestRecommendedPartyMembers:
RecommendedPartyMembersHandler.Handle(c, packet);
break;
case RecvHeader.CharacterReceiveDamage:
CharacterReceiveDamage.Handle(c, packet);
break;
case RecvHeader.PlayerChat:
PlayerChatHandler.Handle(c, packet);
break;
case RecvHeader.SpecialChat:
SpecialChatHandler.Handle(c, packet);
break;
case RecvHeader.RequestWeeklyMapleStar:
WeeklyMapleStarHandler.Handle(c, packet);
return;
case RecvHeader.MoveCharacter:
MoveCharacterHandler.Handle(c, packet);
break;
case RecvHeader.EnterMapPortal:
EnterMapPortalHandler.Handle(c, packet);
break;
case RecvHeader.EnterDoor:
EnterDoorHandler.Handle(c, packet);
break;
case RecvHeader.MoveMob:
MoveMobHandler.Handle(c, packet);
break;
case RecvHeader.NpcChat:
NpcChatHandler.Handle(c, packet);
break;
case RecvHeader.NpcShopAction:
NpcShopActionHandler.Handle(c, packet);
break;
case RecvHeader.NpcAnimation:
NpcAnimationHandler.Handle(c, packet);
break;
case RecvHeader.NpcChatMore:
NpcChatMoreHandler.Handle(c, packet);
break;
case RecvHeader.FacialExpression:
FacialExpressionHandler.Handle(c, packet);
break;
case RecvHeader.MeleeAttack:
DealDamageHandler.HandleMelee(c, packet, header);
break;
case RecvHeader.RangedAttack:
DealDamageHandler.HandleRanged(c, packet);
break;
case RecvHeader.PassiveAttack:
case RecvHeader.MagicAttack:
DealDamageHandler.HandleMagic(c, packet);
break;
case RecvHeader.DistributeAp:
DistributeAPHandler.HandleSingle(c, packet);
break;
case RecvHeader.AutoAssignAp:
DistributeAPHandler.HandleDistribute(c, packet);
break;
case RecvHeader.DistributeSp:
DistributeSPHandler.Handle(c, packet);
break;
case RecvHeader.UseSkill:
UseSkillHandler.Handle(c, packet);
break;
case RecvHeader.MoveItem:
MoveItemHandler.Handle(c, packet);
break;
case RecvHeader.SlotMerge:
InventorySortHandler.HandleSlotMerge(c, packet);
break;
case RecvHeader.ItemSort:
InventorySortHandler.HandleItemSort(c, packet);
break;
case RecvHeader.ChangeChannel:
ChangeChannelHandler.Handle(c, packet);
break;
case RecvHeader.EnterCashShop:
EnterCSHandler.Handle(c, packet);
break;
case RecvHeader.AutoAggroMob:
AutoAggroHandler.Handle(c, packet);
break;
case RecvHeader.LootMapItem:
LootItemHandler.HandlePlayer(c, packet);
break;
case RecvHeader.RegenerateHpMp:
RegenerateHPMPHandler.Handle(c, packet);
break;
case RecvHeader.ChangeKeybind:
KeybindHandler.HandleKeyMapChange(c, packet);
break;
case RecvHeader.QuickSlotKeyMap:
KeybindHandler.HandleQuickSlotKeysChange(c, packet);
break;
case RecvHeader.CancelBuff:
CancelBuffHandler.Handle(c, packet);
break;
case RecvHeader.CharacterInfoRequest:
CharacterInfoRequest.Handle(c, packet);
break;
case RecvHeader.QuestAction:
QuestActionHandler.Handle(c, packet);
break;
case RecvHeader.EnterMapPortalSpecial:
EnterMapPortalSpecialHandler.Handle(c, packet);
break;
case RecvHeader.GuildAction:
GuildActionHandler.Handle(c, packet);
break;
case RecvHeader.DropMeso:
DropMesoHandler.Handle(c, packet);
break;
case RecvHeader.Trade:
TradeHandler.Handle(c, packet);
break;
case RecvHeader.UseConsumable:
UseItemHandler.Handle(c, packet);
break;
case RecvHeader.UseReturnScroll:
UseItemHandler.HandleReturnScroll(c, packet);
break;
case RecvHeader.UseEquipScroll:
UseScrollHandler.HandleRegularEquipScroll(c, packet);
break;
case RecvHeader.UseSpecialEquipScroll:
UseScrollHandler.HandleSpecialEquipScroll(c, packet);
break;
case RecvHeader.UseEquipEnhancementScroll:
UseScrollHandler.HandleEquipEnhancementScroll(c, packet);
break;
case RecvHeader.UseCashItem:
UseSpecialItemHandler.Handle(c, packet);
break;
case RecvHeader.UsePotentialScroll:
UseScrollHandler.HandlePotentialScroll(c, packet);
break;
case RecvHeader.UseBonusPotentialScroll:
UseScrollHandler.HandleBonusPotentialScroll(c, packet);
break;
case RecvHeader.UseCube:
UseScrollHandler.HandleCube(c, packet);
break;
case RecvHeader.UseMagnifyGlass:
UseMagnifyingGlassHandler.Handle(c, packet);
break;
case RecvHeader.SetSkillMacro:
SetSkillMacroHandler.Handle(c, packet);
break;
case RecvHeader.ProffesionReactorAction:
ProfessionReactorActionHandler.Handle(c, packet);
break;
case RecvHeader.ProffesionReactorDestroy:
ProfessionReactorActionHandler.HandleDestroy(c, packet);
break;
case RecvHeader.ReactorAction:
ReactorActionHandler.Handle(c, packet);
break;
case RecvHeader.CraftDone:
CraftHandler.HandleCraftDone(c, packet);
break;
case RecvHeader.CraftEffect:
CraftHandler.HandleCraftEffect(c, packet);
break;
case RecvHeader.CraftMake:
CraftHandler.HandleCraftMake(c, packet);
break;
case RecvHeader.CraftUnk:
CraftHandler.HandleUnk(c, packet);
break;
case RecvHeader.GainAranCombo:
AranComboHandler.HandleGain(c);
break;
case RecvHeader.DecayAranCombo:
AranComboHandler.HandleDecay(c);
break;
case RecvHeader.BlackBlessing:
BlackBlessingHandler.Handle(c);
break;
case RecvHeader.RequestHyperskillInfo:
HyperskillInfoRequestHandler.Handle(c, packet);
return;
case RecvHeader.SkillSwipe:
StealSkillHandler.HandleSkillSwipe(c, packet);
break;
case RecvHeader.ChooseStolenSkill:
StealSkillHandler.HandleChooseSkill(c, packet);
break;
case RecvHeader.StealSkill:
StealSkillHandler.HandleStealSkill(c, packet);
break;
case RecvHeader.MessengerOperation:
MapleMessengerHandler.Handle(c, packet);
break;
case RecvHeader.MoveSummon:
SummonHandler.HandleMove(c, packet);
break;
case RecvHeader.SummonAttack:
SummonHandler.HandleAttack(c, packet);
break;
case RecvHeader.SummonUseSkill:
SummonHandler.HandleSkill(c, packet);
break;
case RecvHeader.RemoveSummon:
SummonHandler.HandleRemove(c, packet);
break;
case RecvHeader.FindPlayer:
FindPlayerHandler.Handle(c, packet);
break;
case RecvHeader.BuddyOperation:
BuddyOperationHandler.Handle(c, packet);
break;
case RecvHeader.UseGoldenHammer:
UseGoldenHammerHandler.Handle(c, packet);
break;
#endregion
#region CashShop
case RecvHeader.CashshopSelect:
CashShop.Select(c, packet);
break;
#endregion
default:
#if DEBUG
ServerConsole.Debug("Unhandled recv packet: {0}", Functions.ByteArrayToStr(packet.ToArray()));
#endif
c.Account.Character.EnableActions();
break;
}
}
}
}
public static void Handle(MapleClient c, PacketReader pr)
{
try
{
if (c.NpcEngine != null && c.NpcEngine.IsShop)
{
byte mode = pr.ReadByte();
int NpcId = c.NpcEngine.NpcId;
switch (mode)
{
case 0:
{
short shopIndex = pr.ReadShort();
int itemId = pr.ReadInt();
short amount = pr.ReadShort();
c.NpcEngine.BuyItem(itemId, shopIndex, amount);
break;
}
case 1: //sell
{
short inventoryIndex = pr.ReadShort();
int itemId = pr.ReadInt();
short qty = pr.ReadShort();
MapleInventoryType invType = ItemConstants.GetInventoryType(itemId);
switch (invType)
{
case MapleInventoryType.Equip:
case MapleInventoryType.Etc:
case MapleInventoryType.Setup:
case MapleInventoryType.Use:
break;
default:
return; // Not a valid item
}
WzItem wzitem = DataBuffer.GetItemById(itemId);
if (wzitem == null)
{
wzitem = DataBuffer.GetEquipById(itemId);
}
if (wzitem == null) // Item doesnt exist (anymore?)
{
return;
}
if (wzitem.NotSale || wzitem.IsCashItem || wzitem.IsQuestItem)
{
return;
}
byte response = 0;
if (!wzitem.IsQuestItem)
{
MapleInventory inventory = c.Account.Character.Inventory;
MapleItem item = inventory.GetItemSlotFromInventory(invType, inventoryIndex);
if (item?.ItemId == itemId && item.Quantity >= qty)
{
if (inventory.Mesos + wzitem.Price > GameConstants.MAX_MESOS)
{
response = 2; // You do not have enough mesos
}
else
{
inventory.RemoveItemsFromSlot(item.InventoryType, item.Position, qty, true);
inventory.GainMesos(wzitem.Price * qty, false, false);
}
// TODO: buyback
}
}
PacketWriter pw = new PacketWriter();
pw.WriteHeader(SendHeader.NpcTransaction);
pw.WriteByte(response);
pw.WriteByte(0);
pw.WriteByte(0);
c.SendPacket(pw);
break;
}
case 3:
{
c.NpcEngine.Dispose();
break;
}
default:
{
c.NpcEngine.ScriptInstance = null;
ServerConsole.Warning("Unkown NpcShopActionHandler mode:" + mode);
ServerConsole.Info(Functions.ByteArrayToStr(pr.ToArray()));
break;
}
}
}
}
catch (Exception ex)
{
ServerConsole.Error("NpcShopActionHandler Failure");
ServerConsole.Error(ex.Message);
if (c.NpcEngine != null)
{
c.NpcEngine.Dispose();
}
}
}
public static void Load()
{
if (Loaded == true || Loading == true)
{
return;
}
Loading = true;
// Trigger events for scripts
Events.InvokeWorldLoadStart();
// Our object manager for databsae objects
Database = new DatabaseObjectManager();
// Our object manager for world objects (spawned objects)
Objects = new WorldObjectManager();
// Delegate for Send() Method
mForeachInRangeCallback = new ForeachInRangeVoidDelegate(SendSub);
mAddQueue = new Queue <DatabaseObject>();
mDelQueue = new Queue <DatabaseObject>();
// Load globals from config, initialize packets ect
ServerConsole.InfoLine("Initialize game symantics...");
Global.Initialize();
WorldObjectStatus.Initialize();
ChatHelper.Initialize();
PlayerCommandHelper.Initialize();
PathHelper.Initialize();
SkillTree.Initialize();
FameListHelper.Initialize();
CharacterJobBonus.Initialize();
CharacterJobModifer.Initialize();
// Real database loading
ServerConsole.InfoLine("Begin World loading...");
DataTable table = null;
Stopwatch watchAll = Stopwatch.StartNew();
Stopwatch watch = Stopwatch.StartNew();
//------------- loading start -------------
#region Mapcache
ServerConsole.Info("\t# loading Maps from mapcache...");
watch.Reset();
watch.Start();
Mapcache.Initialize();
watch.Stop();
ServerConsole.WriteLine(EConsoleColor.Status, " done (" + Mapcache.Maps.Count + " Maps in " + watch.ElapsedMilliseconds + "ms)");
#endregion
#region Items
ServerConsole.Info("\t# loading Items...");
watch.Reset();
watch.Start();
table = Core.Database.Query("SELECT * FROM dbitem");
table.TableName = "ItemDB Table";
if (table == null || table.Rows.Count == 0)
{
if (Core.Database.LastError != null)
{
ServerConsole.ErrorLine("failed to load Item Database!");
ServerConsole.WriteLine(Core.Database.LastError.ToString());
}
}
else
{
ItemDatabaseData item;
for (int i = 0; i < table.Rows.Count; i++)
{
item = ItemDatabaseData.Load(table.Rows[i]);
if (item == null)
{
ServerConsole.WarningLine("Failed to load item {0}: #{1} {2}", i, table.Rows[i].Field <int>("itemID"), table.Rows[i].Field <string>("nameEnglish"));
continue;
}
Database.Add(item);
//ServerConsole.DebugLine("\tLoad: #{0} {1}", item.NameID.ToString().PadLeft(5), item.Name);
}
}
watch.Stop();
ServerConsole.WriteLine(EConsoleColor.Status, " done (" + Database.Items.Count + " Items in " + watch.ElapsedMilliseconds + "ms)");
#endregion
#region Monster
ServerConsole.Info("\t# loading Mobs...");
watch.Reset();
watch.Start();
table = Core.Database.Query("SELECT * FROM dbmob");
table.TableName = "MobDB Table";
if (table == null || table.Rows.Count == 0)
{
if (Core.Database.LastError != null)
{
ServerConsole.ErrorLine("failed to load Monster Database!");
ServerConsole.WriteLine(Core.Database.LastError.ToString());
}
}
else
{
MonsterDatabaseData mob;
for (int i = 0; i < table.Rows.Count; i++)
{
mob = MonsterDatabaseData.Load(table.Rows[i]);
if (mob == null)
{
ServerConsole.WarningLine("Failed to load mob {0}: #{1} {2}", i, table.Rows[i].Field <int>("mobID"), table.Rows[i].Field <string>("nameInter"));
continue;
}
Database.Add(mob);
//ServerConsole.DebugLine("\tLoad: #{0} {1} ({2} drops, {3} skills)", mob.ID.ToString().PadLeft(5), mob.NameInter, mob.Drops.Count, mob.Skills.Count);
}
}
watch.Stop();
ServerConsole.WriteLine(EConsoleColor.Status, " done (" + Database.Monster.Count + " Mobs in " + watch.ElapsedMilliseconds + "ms)");
ServerConsole.Info("\t# loading Mob Skills...");
watch.Reset();
watch.Start();
table = Core.Database.Query("SELECT * FROM dbmob_skill ORDER BY mobID ASC");
table.TableName = "MobDB Skill Table";
if (table == null || table.Rows.Count == 0)
{
if (Core.Database.LastError != null)
{
ServerConsole.ErrorLine("failed to load Mob Skill Database!");
ServerConsole.WriteLine(Core.Database.LastError.ToString());
}
}
else
{
MonsterSkill mobSkill;
for (int i = 0; i < table.Rows.Count; i++)
{
mobSkill = MonsterSkill.Load(table.Rows[i]);
if (mobSkill == null)
{
throw new Exception(string.Format("Failed to load mob skill #{0}: {1}", table.Rows[i].Field <int>("mobID"), table.Rows[i].Field <string>("info")));
}
(Database[EDatabaseType.Mob, mobSkill.MobID] as MonsterDatabaseData).Skills.Add(mobSkill);
//ServerConsole.DebugLine("\tLoad: #{0} {1} ({2} level)", skill.ID.ToString().PadLeft(5), skill.Name, skill.Level.Count);
}
}
watch.Stop();
ServerConsole.WriteLine(EConsoleColor.Status, " done in " + watch.ElapsedMilliseconds + "ms");
ServerConsole.Info("\t# loading Mob Drops...");
watch.Reset();
watch.Start();
table = Core.Database.Query("SELECT * FROM dbmob_drop ORDER BY mobID ASC");
table.TableName = "MobDB Drop Table";
if (table == null || table.Rows.Count == 0)
{
if (Core.Database.LastError != null)
{
ServerConsole.ErrorLine("failed to load Mob Drop Database!");
ServerConsole.WriteLine(Core.Database.LastError.ToString());
}
}
else
{
MonsterDrop drop;
for (int i = 0; i < table.Rows.Count; i++)
{
drop = MonsterDrop.Load(table.Rows[i]);
(Database[EDatabaseType.Mob, drop.MobID] as MonsterDatabaseData).Drops.Add(drop);
//ServerConsole.DebugLine("\tLoad: #{0} {1} ({2} level)", skill.ID.ToString().PadLeft(5), skill.Name, skill.Level.Count);
}
}
watch.Stop();
ServerConsole.WriteLine(EConsoleColor.Status, " done in " + watch.ElapsedMilliseconds + "ms");
#endregion
#region General Skills
ServerConsole.Info("\t# loading Skills...");
watch.Reset();
watch.Start();
table = Core.Database.Query("SELECT * FROM dbskill");
table.TableName = "SkillDB Table";
if (table == null || table.Rows.Count == 0)
{
if (Core.Database.LastError != null)
{
ServerConsole.ErrorLine("failed to load Skill Database!");
ServerConsole.WriteLine(Core.Database.LastError.ToString());
}
}
else
{
SkillDatabaseData skill;
for (int i = 0; i < table.Rows.Count; i++)
{
skill = SkillDatabaseData.Load(table.Rows[i]);
if (skill == null)
{
ServerConsole.WarningLine("Failed to load skill {0}: #{1} {2}", i, table.Rows[i].Field <int>("skillID"), table.Rows[i].Field <string>("name"));
continue;
}
Database.Add(skill.Index, skill);
//ServerConsole.DebugLine("\tLoad: #{0} {1} ({2} level)", skill.ID.ToString().PadLeft(5), skill.Name, skill.Level.Count);
}
}
watch.Stop();
ServerConsole.WriteLine(EConsoleColor.Status, " done (" + Database.Skill.Count + " Skills in " + watch.ElapsedMilliseconds + "ms)");
#endregion
// Loading other shit
// o.o
//------------- loading end -------------
// Trigger event for scripts
Events.InvokeWorldLoadFinish();
Loading = false;
Loaded = true;
ProcessSafetyQueues();
// TODO: Initialize save timer
ServerConsole.InfoLine("Finished World loading! Needed {0:F2} sec", watchAll.Elapsed.TotalSeconds);
watch.Stop();
watch = null;
watchAll.Stop();
watchAll = null;
}
public static void LoadFromFile()
{
const string path = "./ServerConstants.ini";
if (File.Exists(path))
{
string[] lines = File.ReadAllLines(path);
Dictionary <string, string> properties = new Dictionary <string, string>();
foreach (string line in lines)
{
if (line.Length > 2 && line.Contains('=') && !line.StartsWith(";"))
{
string[] splittedLine = line.Split('=');
if (splittedLine.Length == 2)
{
properties.Add(splittedLine[0], splittedLine[1]);
}
else if (splittedLine.Length > 2)
{
properties.Add(splittedLine[0], splittedLine.Fuse(1, "="));
}
}
}
//set settings
if (properties.ContainsKey(TAG_EXPRATE))
{
ExpRate = GetInt(properties, TAG_EXPRATE);
}
if (properties.ContainsKey(TAG_MESORATE))
{
MesoRate = GetInt(properties, TAG_MESORATE);
}
if (properties.ContainsKey(TAG_DROPRATE))
{
DropRate = GetInt(properties, TAG_DROPRATE);
}
if (properties.ContainsKey(TAG_QUEST_EXPRATE))
{
QuestExpRate = GetInt(properties, TAG_QUEST_EXPRATE);
}
if (properties.ContainsKey(TAG_MOBSPAWN))
{
MonsterSpawnInterval = GetInt(properties, TAG_MOBSPAWN);
}
if (properties.ContainsKey(TAG_LOGINPORT))
{
LoginPort = (ushort)GetInt(properties, TAG_LOGINPORT);
}
if (properties.ContainsKey(TAG_CHANNEL_START_PORT))
{
ChannelStartPort = (ushort)GetInt(properties, TAG_CHANNEL_START_PORT);
}
if (properties.ContainsKey(TAG_CHANNEL_COUNT))
{
Channels = (byte)GetInt(properties, TAG_CHANNEL_COUNT);
}
if (properties.ContainsKey(TAG_PRINT_PACKETS))
{
PrintPackets = GetBool(properties, TAG_PRINT_PACKETS);
}
if (properties.ContainsKey(TAG_LOCALHOST))
{
LocalHost = GetBool(properties, TAG_LOCALHOST);
}
if (properties.ContainsKey(TAG_DB_CONNECTION_STRING))
{
DatabaseString = GetString(properties, TAG_DB_CONNECTION_STRING);
}
ServerConsole.Info("ServerConstants.ini loaded");
}
else
{
ServerConsole.Warning("ServerConstants.ini not found, using default values");
}
}
public static void Main(string[] args)
{
// If we set the exceptionhandler also in debug, VS wont throw them and i cant react in Debug-mode
// They will be printed to the console interface
#if !DEBUG
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
#endif
AppDomain.CurrentDomain.ProcessExit += new EventHandler(CurrentDomain_ProcessExit);
#if !DEBUG
try {
#endif
// Cleanup before loading any other data
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
// Save some infos about our thread and assembly
mThread = Thread.CurrentThread;
mProcess = Process.GetCurrentProcess();
mAssembly = Assembly.GetEntryAssembly();
if (mThread != null)
{
// We set a name on our core thread
mThread.Name = "Core Thread";
}
// Initialize our timer manager
TimerThread ttObj = new TimerThread();
mTimerThread = new Thread(new ThreadStart(ttObj.TimerMain));
mTimerThread.Name = "Timer Thread";
// Prepare console for a large output
int width = Math.Min(100, Console.LargestWindowWidth - 2);
Console.CursorVisible = false;
Console.Clear();
Console.WindowLeft = Console.WindowTop = 0;
if (Console.WindowWidth < width)
{
Console.WindowWidth = width;
}
// Real fullscreen mode *_*
#if REAL_FULLSCREEN
IntPtr hConsole = GetStdHandle(-11);
SetConsoleDisplayMode(hConsole, 0);
#endif
// Set colors for the logo printer
LogoPrinter.PrefixColor = EConsoleColor.Blue;
LogoPrinter.SufixColor = EConsoleColor.Blue;
LogoPrinter.TextColor = EConsoleColor.Gray;
LogoPrinter.CopyrightColor = EConsoleColor.Status;
LogoPrinter.PrintLogo();
// Output some infos about version and that
Version ver = mAssembly.GetName().Version;
ServerConsole.StatusLine("Rovolution Server - Version {0}.{1}.{2}.{3}", ver.Major, ver.Minor, ver.Build, ver.Revision);
// Set error and exception handler (dll import)
mConsoleEventHandler = new ConsoleEventHandler(OnConsoleEvent);
SetConsoleCtrlHandler(mConsoleEventHandler, true);
// Read server config
mAppConf = new ApplicationSettings();
mAppConf.ReadAll();
// Mysql init
Stopwatch watch = Stopwatch.StartNew();
ServerConsole.Info("Connecting to SQL Server {0}...", mAppConf.Connection["DB Server"]);
mDatabase = new RovolutionDatabase(Conf.Connection["DB Server"], int.Parse(Conf.Connection["DB Port"]), Conf.Connection["DB User"], Conf.Connection["DB Password"], Conf.Connection["DB Database"]);
GodLesZ.Library.MySql.EMysqlConnectionError conRes = mDatabase.Prepare();
if (conRes != GodLesZ.Library.MySql.EMysqlConnectionError.None)
{
ServerConsole.WriteLine(EConsoleColor.Error, " failed!");
throw new Exception("Failed to open Database Connection! Type: " + conRes.ToString() + Environment.NewLine + (mDatabase.LastError != null ? ", Message: " + mDatabase.LastError.Message : ""));
}
watch.Stop();
ServerConsole.WriteLine(EConsoleColor.Status, " done! Needed {0:F2} sec", watch.Elapsed.TotalSeconds);
watch = null;
// Load scripts (including events & that)
ScriptDatabase.Initialize(@"Scripts\ScriptList.xml");
ScriptCompiler.Compile(AppDomain.CurrentDomain.BaseDirectory + Path.Combine(Settings.Default.MainConfDir, Settings.Default.ScriptAssemblies), true, true);
// Load assemblies for debug
// TODO: we should load the assemblies for debugging
// so VS could hijack them and we could debug them at runtime
// also need the *.pdb files for this..
// Packets handler
PacketLoader.Initialize();
// Initialize World events
ScriptCompiler.Initialize("Rovolution.Server.Scripts");
// Now we are able load our ressources
World.Load();
// Content init done, load Socket pool
SocketPool.Create();
mSocketConnector = new SocketConnector(mAppConf.Connection["Server IP"], mAppConf.Connection.GetInt("Server Port"));
PacketHandlers.Initialize();
// Start Timer Thread
mTimerThread.Start();
// Start timer for checking connections
NetState.Initialize();
// Initialize & load finished
// Clean
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
// Trigger ServerStarted event
Events.InvokeServerStarted();
DateTime now, last = DateTime.Now;
const int sampleInterval = 100;
const float ticksPerSecond = (float)(TimeSpan.TicksPerSecond * sampleInterval);
int sample = 0;
// The server loop
// - looks for new sockets and process all packets
while (mSignal.WaitOne())
{
// Refresh timer
Timer.Slice();
// Kick out old connections
NetState.FlushAll();
NetState.ProcessDisposedQueue();
// Catch new connections
mSocketConnector.Slice();
if (Slice != null)
{
Slice();
}
// just for Diagnostics
if ((++sample % sampleInterval) == 0)
{
now = DateTime.Now;
mCyclesPerSecond[mCycleIndex++ % mCyclesPerSecond.Length] = ticksPerSecond / (now.Ticks - last.Ticks);
last = now;
}
}
#if !DEBUG
}
catch (Exception e) {
CurrentDomain_UnhandledException(null, new UnhandledExceptionEventArgs(e, true));
}
#endif
}
static void Main(string[] args)
{
Console.ForegroundColor = ConsoleColor.White;
Console.Title = "Leatty " + ServerConstants.Version;
ServerConstants.LoadFromFile();
InitializeDatabase();
LoadDataBuffers();
CustomNpcs = DataProvider.LoadCustomNpcs();
StartCashShop();
StartLogin();
StartChannels();
PingTimer.Elapsed += (sender, e) => PingClients();
StartDataApi();
GC.Collect();
string line = string.Empty;
while (!(line = Console.ReadLine().ToLower()).Contains("stop") && !line.Contains("exit"))
{
string[] split = line.Split(' ');
if (split.Length > 0)
{
switch (split[0])
{
case "login":
if (ServerConstants.LocalHost && Program.Clients.Any())
{
MapleClient c = Program.Clients.First().Value;
MapleAccount acc = MapleAccount.GetAccountFromDatabase("Nuclear");
c.SendPacket(LoginAccountHandler.LoginAccountSuccess(acc));
}
break;
case "mapleshark":
case "maplesharkconfig":
MapleSharkConfigCreator.GenerateConfigFile();
break;
case "dumpskills":
Functions.DumpSkillConstants();
break;
case "dumpitems":
Functions.DumpItems();
break;
case "send":
if (split.Length > 4)
{
MapleCharacter chr = GetCharacterByName(split[1]);
if (chr == null)
{
ServerConsole.Info("Player " + split[1] + "not found");
}
else
{
PacketWriter pw = new PacketWriter();
pw.WriteHexString(split.Fuse(2));
chr.Client.SendPacket(pw);
}
}
break;
case "notice":
if (split.Length > 1)
{
string message = "[Notice] " + split.Fuse(1);
BroadCastWorldPacket(MapleCharacter.ServerNotice(message, 6));
}
break;
default:
ServerConsole.Info("Unknown command: " + line);
break;
}
}
}
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("Shutting down...");
Quit();
}
public static void Load()
{
if (Loaded == true || Loading == true)
{
return;
}
Loading = true;
// Trigger events for scripts
Events.Call("worldLoadStart");
// Our object manager for world objects (spawned objects)
Objects = new WorldObjectManager();
// Delegate for Send() Method
//mForeachInRangeCallback = new ForeachInRangeVoidDelegate(SendSub);
mAddQueue = new Queue <WorldObject>();
mDelQueue = new Queue <WorldObject>();
// Load globals from config, initialize packets ect
ServerConsole.InfoLine("Initialize game symantics...");
Global.Initialize();
PathHelper.Initialize();
// Real database loading
ServerConsole.InfoLine("Begin World loading...");
DataTable table = null;
Stopwatch watchAll = Stopwatch.StartNew();
Stopwatch watch = Stopwatch.StartNew();
//------------- loading start -------------
#region Mapcache
ServerConsole.Info("\t# loading Maps from mapcache...");
watch.Reset();
watch.Start();
Mapcache.Initialize();
watch.Stop();
ServerConsole.WriteLine(EConsoleColor.Status, " done (" + Mapcache.Maps.Count + " Maps in " + watch.ElapsedMilliseconds + "ms)");
#endregion
// Loading other shit
// o.o
//------------- loading end -------------
// Trigger event for scripts
Events.Call("worldLoadFinish");
Loading = false;
Loaded = true;
ProcessSafetyQueues();
// TODO: Initialize save timer
ServerConsole.InfoLine("Finished World loading! Needed {0:F2} sec", watchAll.Elapsed.TotalSeconds);
watch.Stop();
watch = null;
watchAll.Stop();
watchAll = null;
}
public static void Handle(MapleClient c, PacketReader pr)
{
int tickCount = pr.ReadInt();
string message = pr.ReadMapleString();
byte show = pr.ReadByte();
ServerConsole.Info(c.Account.Character.Name + ": " + message);
if (message[0] == '@')
{
if (PlayerCommands.ProcessCommand(message.Substring(1).Split(' '), c))
{
return;
}
}
else if (message[0] == '!')
{
if (c.Account.IsGM)
{
string[] split = message.Substring(1).Split(' ');
if (GMCommands.ProcessCommand(split, c))
{
return;
}
if (c.Account.IsAdmin)
{
if (AdminCommands.ProcessCommand(split, c))
{
return;
}
else
{
c.Account.Character.SendBlueMessage("Unrecognized Admin command");
return;
}
}
else
{
c.Account.Character.SendBlueMessage("Unrecognized GM command");
return;
}
}
}
else if (message[0] == '#')
{
if (c.Account.IsGM || c.Account.IsDonor)
{
string[] split = message.Substring(1).Split(' ');
if (DonorCommands.ProcessCommand(split, c))
{
return;
}
else
{
c.Account.Character.SendBlueMessage("Unrecognized Donor command");
return;
}
}
}
PacketWriter packet = PlayerChatPacket(c.Account.Character.Id, message, show, c.Account.IsGM);
c.Account.Character.Map.BroadcastPacket(packet);
}
public static void Main(string[] args)
{
// Try access a config
var serverConfiguration = Factory.Create <Provider>("conf/server.xml");
var dynamicConfig = serverConfiguration.FirstAsExpando().configuration;
// Prepare console for a large output
#if WINDOWS
var width = Math.Min(100, Console.LargestWindowWidth - 2);
Console.CursorVisible = false;
Console.Clear();
Console.WindowLeft = Console.WindowTop = 0;
if (Console.WindowWidth < width)
{
Console.WindowWidth = width;
}
#endif
var ver = Assembly.GetExecutingAssembly().GetName().Version;
Console.Title = string.Format("Zeus auth-server v{0}.{1}", ver.Major, ver.Minor);
ServerConsole.StatusLine(Console.Title);
// Create inter-server listener service
string interServerEndPointAddress = string.Format("tcp://{0}:{1}", dynamicConfig.network.inter_server.host, dynamicConfig.network.inter_server.port);
var interServerEndPoint = ProtocolEndPointBase.CreateEndPoint(interServerEndPointAddress);
ServerConsole.Info("Start connecting to inter-server..");
// @TODO: Is any action coming from inter-server to auth-server?
// @TODO: Create inter -> auth service (character goes back to char select)
_interClient = ServiceClientBuilder.CreateClient <IAuthService>(interServerEndPoint, new ServerServiceImplementation());
_interClient.Connected += (o, a) => {
ServerConsole.WriteLine(ServerConsoleColor.Status, " successfull!");
// AuthServerLogin
_interClient.ServiceProxy.AuthServerLogin((string)dynamicConfig.network.inter_server.password);
};
_interClient.Disconnected += delegate {
ServerConsole.ErrorLine("Connection to inter-server lost.");
// @TODO: Reconnect?
};
_interClient.ConnectTimeout = 30;
_interClient.Connect();
// Create a client listener service
string endPointAddress = string.Format("tcp://{0}:{1}", dynamicConfig.network.host, dynamicConfig.network.port);
_clientService = ServiceBuilder.CreateService(ProtocolEndPointBase.CreateEndPoint(endPointAddress));
_clientService.ClientConnected += (sender, clientEventArgs) => ServerConsole.DebugLine("Client connected #{0}", clientEventArgs.Client.ClientId);
_clientService.ClientDisconnected += (sender, clientEventArgs) => ServerConsole.DebugLine("Client disconnected #{0}", clientEventArgs.Client.ClientId);
// Add interface for client connections
var clientService = new ClientServiceImplementation(_interClient.ServiceProxy);
_clientService.AddService <IClientService, ClientServiceImplementation>(clientService);
// Start listener service
_clientService.Start();
ServerConsole.StatusLine("Auth-server is listening to: {0}", endPointAddress);
do
{
var cmd = Console.ReadLine();
if (cmd == "exit")
{
_clientService.Stop();
}
} while (_clientService.Connected);
ServerConsole.WarningLine("Press any key to exit.");
Console.Read();
}
