public static void HandleSetStatPoint(ZoneClient client, Packet packet) { byte stat; if (!packet.TryReadByte(out stat)) { Log.WriteLine(LogLevel.Warn, "Couldn't read HandleSetStatPoint packet. {0}", client); return; } if (client.Character.Character.UsablePoints == 0) { Log.WriteLine(LogLevel.Warn, "User tried to set stat point while not having any left. {0}", client); } else { // LETS DO ET switch (stat) { case 0: client.Character.Str++; break; case 1: client.Character.Dex++; break; case 2: client.Character.End++; break; case 3: client.Character.Int++; break; case 4: client.Character.Spr++; break; default: { Log.WriteLine(LogLevel.Warn, "User tried to set stat point on unknown stat {0} {1}", stat, client); return; } } client.Character.Character.UsablePoints--; //Program.Entity.SaveChanges(); SendSetUsablePoint(client, stat); } }
public static void EquipHandler(ZoneClient client, Packet packet) { sbyte slot; if (!packet.TryReadSByte(out slot)) { Log.WriteLine(LogLevel.Warn, "Error reading equipping slot."); return; } Item item; if (client.Character.InventoryItems.TryGetValue(slot, out item)) { if (item is Equip) { if (((Equip)item).Info.Level > client.Character.Level) { FailedEquip(client.Character, 645); // 85 02 } else { client.Character.EquipItem((Equip)item); } } else { FailedEquip(client.Character); Log.WriteLine(LogLevel.Warn, "{0} equippped an item. What a moron.", client.Character.Name); } } }
public static void ClientReadyHandler(ZoneClient client, Packet packet) { if (client.Admin > 0) { client.Character.DropMessage("AdminLevel = {0}; ClientLoad = {1};", client.Admin, ClientManager.Instance.ZoneLoad); } Handler4.SendUsablePoints(client); if (!client.Character.IsDead) { // Just logged on. client.Character.Map.FinalizeAdd(client.Character); } else { // Reviving, not readding for this one! MapInfo mi; if (DataProvider.Instance.MapsByID.TryGetValue(client.Character.MapID, out mi)) { client.Character.State = PlayerState.Normal; client.Character.Map.SendCharacterLeftMap(client.Character, false); client.Character.Position.X = mi.RegenX; client.Character.Position.Y = mi.RegenY; client.Character.Map.SendCharacterEnteredMap(client.Character); } client.Character.SetHP(client.Character.MaxHP / 4); } }
public static void TradeAgree(ZoneClient pClient, Packet pPacket) { if (pClient.Character.Trade == null) return; pClient.Character.Trade.AcceptTrade(pClient.Character); }
public static void SendPing(ZoneClient character) { using (var packet = new Packet(SH2Type.Ping)) { character.SendPacket(packet); } }
public static void SendPartyMemberCordChange(ZoneClient client) { if (Program.Entity.Parties.Where(c => c.CharNo == client.Character.ID).Count() == 1) { Party PartyNo = Program.Entity.Parties.First(c => c.CharNo == client.Character.ID); foreach (Party party in Program.Entity.Parties.Where(c => c.PartyNo == PartyNo.PartyNo)) { using (var ppacket = new Packet(SH14Type.PartyLoginCord)) { Character Pcharacter = Program.Entity.Characters.First(c => c.ID == party.CharNo); ZoneClient otherLiveInfo = ClientManager.Instance.GetClientByName(Pcharacter.Name); if (otherLiveInfo != null) { if (otherLiveInfo.Character.MapID == client.Character.MapID) { ppacket.WriteByte(1); //unk ppacket.WriteString(client.Character.Name, 16); ppacket.WriteInt(client.Character.Position.X); ppacket.WriteInt(client.Character.Position.Y); otherLiveInfo.SendPacket(ppacket); } } } } } }
public static void TradeLock(ZoneClient pClient, Packet pPacket) { if (pClient.Character.Trade != null) { pClient.Character.Trade.TradeLock(pClient.Character); } }
public void AddTradeRequest(ZoneClient pClient,ushort MapObjectIDto) { Log.WriteLine(LogLevel.Debug, "{0} AddTradeReqest {1}", pClient.Character.Character.Name, MapObjectIDto); TradeReqest pRequest = new TradeReqest(pClient.Character, MapObjectIDto); this.TradeReqests.Add(pRequest); SendTradeRequest(pRequest); }
public static void ClientReadyHandler(ZoneClient client, Packet packet) { Handler4.SendUsablePoints(client); if (!client.Character.IsDead) { // Just logged on. client.Character.Map.FinalizeAdd(client.Character); //Handler27.SendGameMessage(client.Character, "GAMEPLAY NOT FINAL :: WELCOME TO OSMO, " + client.Character.Name.ToUpper(), "Universal_2"); Handler9.SendUpdateHP(client.Character); Handler9.SendUpdateSP(client.Character); if (client.Character.Job == Job.Crusader) { Handler9.SendUpdateLP(client.Character); } Handler14.SendPartyInformation(client); } else { // Reviving, not readding for this one! MapInfo mi; if (DataProvider.Instance.MapsByID.TryGetValue(client.Character.MapID, out mi)) { client.Character.State = PlayerState.Normal; client.Character.Map.SendCharacterLeftMap(client.Character, false); client.Character.Position.X = mi.RegenX; client.Character.Position.Y = mi.RegenY; client.Character.Map.SendCharacterEnteredMap(client.Character); } client.Character.SetHP(client.Character.MaxHP / 4); } }
public static void SelectObjectHandler(ZoneClient client, Packet packet) { ushort id; if (!packet.TryReadUShort(out id)) { Log.WriteLine(LogLevel.Warn, "Could not read entity select request."); return; } MapObject mo; // Try to see if there is a map object with this ID if (!client.Character.Map.Objects.TryGetValue(id, out mo)) { client.Character.CharacterInTarget = mo; return; // Nothing found. Just return lawl } mo.SelectedBy.Add(client.Character); if (mo is ZoneCharacter || mo is Mob) { client.Character.SelectedObject = mo; SendStatsUpdate(mo, client, false); } }
public static void TradeReqest(ZoneClient pClient, Packet pPacket) { ushort MapObjectID; if (!pPacket.TryReadUShort(out MapObjectID)) return; TradeManager.Instance.AddTradeRequest(pClient, MapObjectID); }
public override void OnClientConnect(Socket socket) { ZoneClient client = new ZoneClient(socket); // ClientManager.Instance.AddClient(client); //They register once authenticated now Log.WriteLine(LogLevel.Debug, "Client connected from {0}", client.Host); // ClientManager.Instance.AddClient(client); //They register once authenticated now }
public static void TradeBreak(ZoneClient pClient, Packet pPacket) { if (pClient.Character.Trade == null) return; pClient.Character.Trade.TradeBreak(pClient.Character); pClient.Character.Trade = null; }
public static void DeselectObjectHandler(ZoneClient client, Packet packet) { if (client.Character.SelectedObject != null) { client.Character.SelectedObject.SelectedBy.Remove(client.Character); client.Character.SelectedObject = null; } }
public void RemoveReqest(ZoneClient pClient) { TradeReqest Request = TradeReqests.Find(r => r.MapID == pClient.Character.MapID && r.pToTradeClient.MapObjectID== pClient.Character.MapObjectID); if (TradeReqests.Contains(Request)) { TradeReqests.Remove(Request); } }
public static void SendError(ZoneClient client, ServerError error) { using (Packet pack = new Packet(SH3Type.Error)) { pack.WriteShort((byte)error); client.SendPacket(pack); } }
public static void BackTo(ZoneClient client, Packet packet) { using(var iacket = new InterPacket(InterHeader.ClientDisconect)) { iacket.WriteString(client.Character.Character.Name, 16); InterServer.WorldConnector.Instance.SendPacket(iacket); } }
public void AcceptTrade(ZoneClient pClient) { TradeReqest Request = GetTradeRquestByChar(pClient.Character); if (Request != null) { TradeReqests.Remove(Request); Trade pTrade = new Trade(Request.pFromTradeClient, pClient.Character); } }
public static void SendTradeRequest(ZoneClient client, ushort ObjID) { using(var packet = new Packet(SH19Type.TradeRequest)) { ZoneClient otherclient = ClientManager.Instance.GetClientByObj(ObjID); packet.WriteUShort(client.Character.MapObjectID); otherclient.SendPacket(packet); } }
public static void TradeRemovitem(ZoneClient pClient, Packet pPacket) { byte pSlot; if (!pPacket.TryReadByte(out pSlot)) return; if (pClient.Character.Trade == null) return; pClient.Character.Trade.RemoveItemToHandel(pClient.Character, pSlot); }
public static void TradeChangeMoney(ZoneClient pClient, Packet pPacket) { long money; if(!pPacket.TryReadLong(out money)) return; if (pClient.Character.Trade != null) { pClient.Character.Trade.ChangeMoneyToTrade(pClient.Character, money); } }
public static void DropItemHandler(ZoneClient client, Packet packet) { sbyte slot; if (!packet.TryReadSByte(out slot)) { Log.WriteLine(LogLevel.Warn, "Invalid drop request."); return; } client.Character.DropItemRequest(slot); }
public static void EnhancementHandler(ZoneClient client, Packet packet) { sbyte weapslot, stoneslot; if (!packet.TryReadSByte(out weapslot) || !packet.TryReadSByte(out stoneslot)) { Log.WriteLine(LogLevel.Warn, "Invalid item enhance request."); return; } client.Character.UpgradeItem(weapslot, stoneslot); }
public static void MasterRequestAcceptCoper(ZoneClient client, Packet pPacket) { client.Character.Character.ReviveCoper = 0; InterServer.InterHandler.SendReciveCoper(client.Character.Character.Name, client.Character.Character.ReviveCoper,true); using(var packet = new Packet(37,65)) { packet.WriteUShort(7272);//unk packet.WriteLong(client.Character.RecviveCoper); client.SendPacket(packet); } }
public static void HandleReviveToTown(ZoneClient character, Packet packet) { if (character.Character.IsDead) { // Lets revive. MapInfo mi; if (DataProvider.Instance.MapsByID.TryGetValue(character.Character.MapID, out mi)) { SendRevive(character, mi.ID, mi.RegenX, mi.RegenY); // Will resend the loaded packet } } }
public static void MasterRequestCoper(ZoneClient client, Packet pPacket) { byte unk; if (!pPacket.TryReadByte(out unk)) return; using (var packet = new Packet(SH37Type.SendRecivveCopper)) { packet.WriteUShort(7264);//unk packet.WriteLong(client.Character.Character.ReviveCoper); client.SendPacket(packet); } }
public static void HandleTrade(ZoneClient client, Packet packet) { ushort PlayerObjID; if (!packet.TryReadUShort(out PlayerObjID)) { Packet ppacket = new Packet(SH19Type.TradeNotAccepted); ppacket.WriteUShort(client.Character.MapObjectID); client.SendPacket(ppacket); Log.WriteLine(LogLevel.Error, "TradeRequest :: Invalid Obj ID from {0}", client.Character.Name); } SendTradeRequest(client, PlayerObjID); }
public static void BySPStoneHandler(ZoneClient client, Packet packet) { short Amount; if (packet.TryReadShort(out Amount)) { client.Character.ChangeMoney(client.Character.Character.Money -= client.Character.BaseStats.PriceSPStone); short Am = Amount += client.Character.StonesSP; client.Character.StonesHP = Am; using (var p = new Packet(SH20Type.ChangeSPStones)) { p.WriteShort(Am); client.SendPacket(p); } } }
public static void GetPartyListFromCharserer(ZoneClient client, Packet packet) { // NOTE: seems as here just happens nothing I guess? // TODO: Implement if nesseccery // NOTE: This starts the update loop? if (client.Character.GroupMember == null) { // TODO: ask world for group return; } else { client.Character.GroupMember.IsReadyForUpdates = true; client.Character.Group.UpdateGroupStats(); } }
public static void AttackSkillHandler(ZoneClient client, Packet packet) { ushort skill; if (!packet.TryReadUShort(out skill)) { Log.WriteLine(LogLevel.Warn, "Could not read skillID from attack entity skill function. {0}", client); return; } if (!client.Character.SkillsActive.ContainsKey(skill)) { Log.WriteLine(LogLevel.Warn, "User tried to attack with a wrong skill. {0} {1} ", skill, client); return; } client.Character.AttackSkill(skill, null); }