public void sendAreaInit(Character character)
{
MartialClient connection = character.getAccount().mClient;
if (character.getInnitedAreas().Contains(this.aID))
{
return;
}
foreach (Character aCharacter in areaCharacters)
{
if (aCharacter == character)
{
continue;
}
try {
Console.WriteLine("AreaInt> Packet sent for {0} from {1}", character.getName(), aCharacter.getName());
connection.WriteRawPacket(CharacterPackets.extCharPacket(aCharacter));
} catch (Exception e) { Console.WriteLine(e); }
}
foreach (NPC aNPC in npcs)
{
try {
connection.WriteRawPacket(aNPC.npcSpawn(character));
} catch (Exception e) { Console.WriteLine(e); }
}
foreach (Mob aMob in mobs)
{
try {
connection.WriteRawPacket(aMob.getInitialPacket());
} catch (Exception e) { Console.WriteLine(e); }
}
}
public void sendTo3x3AreaLeave(Character character, Area area)
{
if (!this.areaExists(area))
{
return;
}
for (int i = 0; i < 3; i++)
{
for (int u = 0; u < 3; u++)
{
Area nearCentral = getArea(new int[] { area.getAreaPosition()[0] - 1 + i, area.getAreaPosition()[1] - 1 + u });
if (nearCentral == null)
{
continue;
}
foreach (Character characterAround in nearCentral.getCharacters())
{
if (characterAround == character)
{
continue;
}
try {
Console.WriteLine("AreaLeave> vanPacket from: {0} for {1}", character.getName(), characterAround.getName());
characterAround.getAccount().mClient.WriteRawPacket(CharacterPackets.vanCharPacket(character));
} catch (Exception e) { Console.WriteLine(e); }
}
}
}
character.getArea().removeCharacter(character);
character.removeInnitedAreas();
WMap.Instance.removeFromSynchronizedAreas(area);
}
public void Show(Npc npc)
{
Npc = npc;
Load();
Parent.Client.Send(CharacterPackets.StorageOpen(npc, this));
}
private void SetGenderTo(CharacterConstants.Gender value)
{
gender = value;
if (!Parent.IsInitialized)
{
return;
}
Parent.Client.Send(CharacterPackets.SetGenderPacket(gender));
}
public void sendTo3x3AreaMovement(Character character, Area area, byte[] packet)
{
if (!this.areaExists(area))
{
return;
}
List <int> relistInnitedAreas = new List <int>();
for (int i = 0; i < 3; i++)
{
for (int u = 0; u < 3; u++)
{
Area nearCentral = getArea(new int[] { area.getAreaPosition()[0] - 1 + i, area.getAreaPosition()[1] - 1 + u });
if (nearCentral == null)
{
continue;
}
foreach (Character characterAround in nearCentral.getCharacters())
{
if (characterAround == character)
{
continue;
}
if (!character.getInnitedAreas().Contains(nearCentral.getaID()))
{
characterAround.getAccount().mClient.WriteRawPacket(CharacterPackets.extCharPacket(character));
}
try {
Console.WriteLine("AreaMove> Packet sent for {0} from {1}", characterAround.getName(), character.getName());
characterAround.getAccount().mClient.WriteRawPacket(packet);
}
catch (Exception e) {
Console.WriteLine(e);
}
}
if (character.getInnitedAreas().Contains(nearCentral.getaID()))
{
relistInnitedAreas.Add(nearCentral.getaID());
continue;
}
nearCentral.sendAreaInit(character);
relistInnitedAreas.Add(nearCentral.getaID());
}
}
character.removeInnitedAreas();
character.setInnitedAreas(relistInnitedAreas);
}
private void SetSkinTo(byte value)
{
if (!DataProvider.Styles.Skins.Contains(value))
{
throw new StyleUnavailableException();
}
skin = value;
if (!Parent.IsInitialized)
{
return;
}
CharacterStats.Update(Parent, CharacterConstants.StatisticType.Skin);
Parent.Map.Broadcast(CharacterPackets.UpdateApperancePacket(Parent));
}
private void SetFaceTo(int value)
{
if (Gender == CharacterConstants.Gender.Male &&
!DataProvider.Styles.MaleFaces.Contains(value) || Gender == CharacterConstants.Gender.Female && !DataProvider.Styles.FemaleFaces.Contains(value))
{
throw new StyleUnavailableException();
}
face = value;
if (!Parent.IsInitialized)
{
return;
}
CharacterStats.Update(Parent, CharacterConstants.StatisticType.Face);
Parent.Map.Broadcast(CharacterPackets.UpdateApperancePacket(Parent));
}
public void sendTo3x3AreaSpawn(Character character, Area area, Boolean just_a_refresh_for_the_world = false)
{
if (!this.areaExists(area))
{
return;
}
character.removeInnitedAreas();
for (int i = 0; i < 3; i++)
{
for (int u = 0; u < 3; u++)
{
Area nearCentral = getArea(new int[] { area.getAreaPosition()[0] - 1 + i, area.getAreaPosition()[1] - 1 + u });
if (nearCentral == null)
{
continue;
}
if (!just_a_refresh_for_the_world)
{
nearCentral.sendAreaInit(character);
}
foreach (Character characterAround in nearCentral.getCharacters())
{
if (characterAround == character)
{
continue;
}
try {
Console.WriteLine("AreaSpawn> extCharPacket from: {0} for {1}", character.getName(), characterAround.getName());
characterAround.getAccount().mClient.WriteRawPacket(CharacterPackets.extCharPacket(character));
}
catch (Exception e) {
Console.WriteLine(e);
}
}
character.addInnitedArea(nearCentral.getaID());
WMap.Instance.addToSynchronizedAreas(area);
}
}
}
public static void Update(Character character, params CharacterConstants.StatisticType[] charStats)
{
character.Client.Send(CharacterPackets.UpdateStatsPacket(character, charStats));
}
public void CharStorageHandler(Packet inPacket)
{
NPCsConstants.StorageAction actionType = (NPCsConstants.StorageAction)inPacket.ReadByte();
switch (actionType)
{
case NPCsConstants.StorageAction.WithdrawItem:
{
// Read packet data
ItemConstants.ItemType itemType = (ItemConstants.ItemType)inPacket.ReadByte();
byte itemSlot = inPacket.ReadByte();
// First seek slot to find the item to withdraw in
if (itemSlot < 0 || itemSlot > Slots)
{
return;
// TODO: storage exceptions on wrongly received/read data from packet, CharacterStorageExceptions.WrongSlotRecieved
}
// Slot is valid thus seek an item on its position
Item item = Items[itemSlot];
if (item == null)
{
return;
// TODO: CharacterStorageExceptions.ItemCouldNotBeFound
}
// Do i actually have free inventory slot to place withdrawn item in?
if (Parent.Items.IsInventoryFull(item.ItemType))
{
Parent.Client.Send(CharacterPackets.StorageErrorPacket(Parent, NPCsConstants.StoragePacketType.ErrorPlayerInventoryFull));
return;
}
// Even if i do, still i may not have enough mesos to demand this payed service :(
int costToWithdraw = 1000; // TODO: how is the cost actually calculated?
if (Parent.Stats.Meso < costToWithdraw)
{
Parent.Client.Send(CharacterPackets.StorageErrorPacket(Parent, NPCsConstants.StoragePacketType.ErrorNotEnoughMesos));
return;
}
if (Parent.Stats.Meso >= costToWithdraw)
{
// Devour character mesos
Maple.Meso.giveMesos(Parent, costToWithdraw);
// Remove item from storage
Items.Remove(item);
// Delete item from Database
Item.DeleteItemFromDB(item);
// Set stored flag to false
item.IsStored = false;
// Add item to char. items
Parent.Items.AddItemToInventory(item, forceGetSlot: true);
// routine to get count of items of same type
List <Item> itemsByType = new List <Item>();
foreach (Item loopItem in Items)
{
if (loopItem.Type == item.Type)
{
itemsByType.Add(loopItem);
}
}
Parent.Client.Send(CharacterPackets.StorageRemoveItem(Parent, item, itemsByType));
}
}
break;
case NPCsConstants.StorageAction.DepositItem:
{
// Read packet data
short slot = inPacket.ReadShort();
int itemID = inPacket.ReadInt();
short quantity = inPacket.ReadShort();
// TODO: slot validation, quantity validation
// try to get item to deposit from slot in char. inventory
Item item = Parent.Items[itemID, slot];
// storage full cant deposit
if (IsFull)
{
Parent.Client.Send(CharacterPackets.StorageErrorPacket(Parent, NPCsConstants.StoragePacketType.ErrorStorageInventoryFull));
return;
}
// not enough mesos to pay for deposit
if (Parent.Stats.Meso <= Npc.StorageCost)
{
Parent.Client.Send(CharacterPackets.StorageErrorPacket(Parent, NPCsConstants.StoragePacketType.ErrorNotEnoughMesos));
return;
}
if (Parent.Stats.Meso >= Npc.StorageCost)
{
//devour character mesos
Parent.Stats.Meso -= Npc.StorageCost;
// remove item form inventory
Parent.Items.RemoveItemFromInventory(item, true);
// NOTE: This is needed because when we remove the item is sets parent to none.
item.Parent = Parent.Items;
// slot in storage is maxCount of items in it
item.Slot = (short)Items.Count;
// set flag on item
item.IsStored = true;
// add item to storage
Items.Add(item);
// routine to get count of items of same type
List <Item> itemsByType = new List <Item>();
foreach (Item loopItem in Items)
{
if (loopItem.Type == item.Type)
{
itemsByType.Add(loopItem);
}
}
Parent.Client.Send(CharacterPackets.StorageAddItem(Parent, item, itemsByType));
}
}
break;
case NPCsConstants.StorageAction.ArrangeItem:
{
Parent.Client.Send(CharacterPackets.StorageArrangeItems(Parent));
}
break;
case NPCsConstants.StorageAction.ChangeMesos:
{
int meso = inPacket.ReadInt();
if (meso > 0) // NOTE: Withdraw meso.
{
// TODO: Meso checks.
}
else // NOTE: Deposit meso.
{
// TODO: Meso checks.
}
Meso -= meso;
Parent.Stats.Meso += meso;
Parent.Client.Send(CharacterPackets.StorageChangeMesos(Parent));
}
break;
case NPCsConstants.StorageAction.CloseStorage:
{
Save();
}
break;
case NPCsConstants.StorageAction.OpenStorage:
break;
default: throw new ArgumentOutOfRangeException();
}
}
public static void Equip(MartialClient c, InPacket p)
{
if (c.getAccount().activeCharacter == null)
{
Logger.LogCheat(Logger.HackTypes.NullActive, c, "Attempted to hook equip while not being ingame.");
c.Close();
return;
}
Character chr = c.getAccount().activeCharacter;
byte changeType = p.ReadByte();
byte[] swapSlots = p.ReadBytes(2);
if (changeType == (byte)0x00)
{
if (!chr.getEquipment().swapEquips(swapSlots[0], swapSlots[1]))
{
Logger.LogCheat(Logger.HackTypes.Equip, c, "Attempted to swap weapons, while one of them or even both are null.");
c.Close();
return;
}
WMap.Instance.getGrid(chr.getMap()).sendTo3x3Area(chr, chr.getArea(), CharacterPackets.getExtEquipPacket(chr, swapSlots[0], chr.getEquipment().getEquipments()[swapSlots[0]].getItemID()));
WMap.Instance.getGrid(chr.getMap()).sendTo3x3Area(chr, chr.getArea(), CharacterPackets.getExtEquipPacket(chr, swapSlots[1], chr.getEquipment().getEquipments()[swapSlots[1]].getItemID()));
}
else
{
if (!chr.getInventory().equipItem(swapSlots[0], swapSlots[1], chr.getEquipment()))
{
Console.WriteLine("so sorz : >");
return;
}
WMap.Instance.getGrid(chr.getMap()).sendTo3x3Area(chr, chr.getArea(), CharacterPackets.getExtEquipPacket(chr, swapSlots[1], chr.getEquipment().getEquipments()[swapSlots[1]].getItemID()));
}
OutPacket op = new OutPacket(24);
op.WriteInt(24);
op.WriteShort(0x04);
op.WriteShort(0x0c);
op.WriteInt(135593729);
op.WriteInt(c.getAccount().activeCharacter.getuID());
op.WriteShort(0x01);
op.WriteByte(changeType);
op.WriteBytes(swapSlots);
c.WriteRawPacket(op.ToArray());
CharacterFunctions.calculateCharacterStatistics(chr);
}
public static void MoveOrUnequip(MartialClient c, InPacket p)
{
Console.WriteLine("move or unequip");
if (c.getAccount().activeCharacter == null)
{
Logger.LogCheat(Logger.HackTypes.NullActive, c, "Attempted to hook invManag while not being ingame.");
c.Close();
return;
}
Character chr = c.getAccount().activeCharacter;
byte[] decrypted = p.ReadBytes(12);
byte[] amountByte = { decrypted[8], decrypted[9], decrypted[10], decrypted[11] };
int amount = BitTools.byteArrayToInt(amountByte);
if (decrypted[0] == (byte)0x00)
{
if (!chr.getInventory().unequipItem(decrypted[1], decrypted[4], decrypted[3], chr.getEquipment()))
{
Console.WriteLine("problem with unequipItem");
return;
}
WMap.Instance.getGrid(chr.getMap()).sendTo3x3Area(chr, chr.getArea(), CharacterPackets.getExtEquipPacket(chr, decrypted[1], 0));
}
else
{
if (!chr.getInventory().moveItem(decrypted[1], decrypted[2], amount, decrypted[4], decrypted[3]))
{
Console.WriteLine("problem with move item");
return;
}
}
OutPacket op = new OutPacket(28);
op.WriteInt(28);
op.WriteShort(0x04);
op.WriteShort(0x10);
op.WriteInt();
op.WriteInt(c.getAccount().activeCharacter.getuID());
op.WriteShort(0x01);
op.WriteBytes(new byte[] { decrypted[0], decrypted[1], decrypted[2], decrypted[3], decrypted[4] });
op.WriteByte();
op.WriteBytes(new byte[] { decrypted[8], decrypted[9], decrypted[10], decrypted[11] });
c.WriteRawPacket(op.ToArray());
CharacterFunctions.calculateCharacterStatistics(chr);
}
public static void UpdateApperance(Character character)
{
character.Map.Broadcast(CharacterPackets.UpdateApperancePacket(character), character);
}
