public void SendSpontaneousUpdate(Character receiver, bool visible, params UpdateFieldId[] indices)
{
var highestIndex = 0;
foreach (var index in indices)
{
if (index.RawId > highestIndex)
{
highestIndex = index.RawId;
}
}
var mask = new UpdateMask(highestIndex);
using (var packet = new UpdatePacket(1024))
{
packet.Position = 4; // jump over header
packet.Write(1); // Update Count
packet.Write((byte)UpdateType.Values);
EntityId.WritePacked(packet);
WriteSpontaneousUpdate(mask, packet, receiver, indices, visible);
receiver.Send(packet);
}
}
private void OnUpdate(Client client, Packet packet)
{
if (!MapFilterConfig.Default.Enabled)
{
return;
}
UpdatePacket update = (UpdatePacket)packet;
// New Objects
foreach (Entity entity in update.NewObjs)
{
if (ObjectFilters.ContainsKey((ushort)entity.ObjectType))
{
entity.ObjectType = (short)ObjectFilters[(ushort)entity.ObjectType];
}
}
// New Tiles
foreach (Tile tile in update.Tiles)
{
if (TileFilters.ContainsKey(tile.Type))
{
tile.Type = TileFilters[tile.Type];
}
}
}
public override void Run(Player _client, ConquerItem _item)
{
if (_client.PK < 30)
{
_client.SendMessage("You must have 30 Pk Points or more to use it.");
}
else
{
_client.PK -= 30;
_client.Send(UpdatePacket.Create(_client.UID, UpdateType.Pk, (ulong)_client.PK));
_client.Save();
_client.DeleteItem(_item);
//If Between 30 and 99 and does not have Red Name.....then Add redname
if (_client.PK >= 30 && _client.PK < 100 && !_client.HasEffect(ClientEffect.Red))
{
_client.RemoveEffect(ClientEffect.Black);
_client.AddEffect(ClientEffect.Red, ((_client.PK - 29) * 6) * 60000, true);//Adds red name
}
//If under 30 PK, remove redname
if (_client.PK < 30 && _client.HasEffect(ClientEffect.Red))
{
_client.RemoveEffect(ClientEffect.Red);
}
}
}
private void OnUpdate(Client client, Packet p)
{
UpdatePacket update = p as UpdatePacket;
foreach (Tile tile in update.Tiles)
{
CurrentMaps[client].Data[tile.X, tile.Y] = tile.Type;
}
if (Config.Default.enabled && SendQueues.ContainsKey(client))
{
if (SendQueues[client].Count > 0)
{
List <Tile> newTiles = new List <Tile>(update.Tiles);
SendQueues[client].Shift(Math.Min(MaxTilesPerPacket, Math.Max(0, MaxTilesPerPacket - newTiles.Count))).ForEach(tile => newTiles.Add(tile));
update.Tiles = newTiles.ToArray();
PluginUtils.Log("Map Cacher", "Cached map data sent.");
}
}
else
{
PluginUtils.Log("MapCacher", "Key not found!");
}
}
protected void WriteSpontaneousUpdate(UpdateMask mask, UpdatePacket packet, Character receiver, UpdateFieldId[] indices, bool visible)
{
// create mask
for (var i = 0; i < indices.Length; i++)
{
var index = indices[i].RawId;
var field = UpdateFieldMgr.Get(ObjectTypeId).Fields[index];
for (var j = 0; j < field.Size; j++)
{
mask.SetBit(index + j);
}
}
// write mask
mask.WriteTo(packet);
// write values
for (var i = mask.m_lowestIndex; i <= mask.m_highestIndex; i++)
{
if (mask.GetBit(i))
{
if (visible)
{
WriteUpdateValue(packet, receiver, i);
}
else
{
packet.Write(0);
}
}
}
}
public bool AddEffect(ClientEffect _effect, long _timeout, bool _sync = true)
{
if (_effect == ClientEffect.Fly && !Map.IsFlyEnabled)
{
return(false);
}
var timeout = _timeout > 0 ? Common.Clock + _timeout : 0;
bool success = true;
if (ClientEffects.ContainsKey(_effect))
{
ClientEffects[_effect] = timeout;
}
else
{
success = ClientEffects.TryAdd(_effect, timeout);
}
if (success && !(this is SOB))
{
SpawnPacket.StatusEffects |= _effect;
if (_sync)
{
Send(UpdatePacket.Create(UID, UpdateType.StatusEffects, (ulong)SpawnPacket.StatusEffects));
SendToScreen(SpawnPacket);
}
}
if (_effect == ClientEffect.Poison) //Added poison damage timer
{
LastPoisonDamage = Common.Clock;
}
return(success);
}
private static void OnUpdate(Client client, UpdatePacket packet)
{
if (client.Self() != null)
{
client.Self().Parse(packet);
}
}
protected void WriteSpontaneousUpdate(UpdateMask mask, UpdatePacket packet, Character receiver,
UpdateFieldId[] indices, bool visible)
{
for (int index1 = 0; index1 < indices.Length; ++index1)
{
int rawId = indices[index1].RawId;
UpdateField field = UpdateFieldMgr.Get(this.ObjectTypeId).Fields[rawId];
for (int index2 = 0; (long)index2 < (long)field.Size; ++index2)
{
mask.SetBit(rawId + index2);
}
}
mask.WriteTo((PrimitiveWriter)packet);
for (int lowestIndex = mask.m_lowestIndex; lowestIndex <= mask.m_highestIndex; ++lowestIndex)
{
if (mask.GetBit(lowestIndex))
{
if (visible)
{
this.WriteUpdateValue(packet, receiver, lowestIndex);
}
else
{
packet.Write(0);
}
}
}
}
protected UpdatePacket GetFieldUpdatePacket(UpdateFieldId field, byte[] value)
{
var blocks = (field.RawId >> 5) + 1;
var emptyBlockSize = (blocks - 1) * 4;
//UpdatePacket packet = new UpdatePacket(BufferManager.Small.CheckOut());
var packet = new UpdatePacket {
Position = 4
};
packet.Write(1); // Update Count
packet.Write((byte)UpdateType.Values);
EntityId.WritePacked(packet);
packet.Write((byte)blocks);
//packet.TotalLength += emptyBlockSize;
packet.Zero(emptyBlockSize);
packet.Write(1 << (field.RawId & 31));
packet.Write(value);
return(packet);
}
// Token: 0x060004A5 RID: 1189 RVA: 0x00019E98 File Offset: 0x00018098
public void Update(UpdatePacket update)
{
if (this._lootQuest != -1 && update.Drops.Contains(this._lootQuest))
{
this._lootQuest = -1;
if (this._lastQuest != -1)
{
QuestObjIdPacket questObjIdPacket = (QuestObjIdPacket)Packet.Create(PacketType.QUESTOBJID);
questObjIdPacket.ObjectId = this._lastQuest;
this._lastQuest = -1;
this.client.SendToClient(questObjIdPacket);
}
}
if (Settings.Default.AutoLootBigBags)
{
foreach (Entity entity in update.NewObjs)
{
if (Enum.IsDefined(typeof(Bags), entity.ObjectType))
{
foreach (StatData stat in entity.Status.Data)
{
if (StatsType.Id(stat.Id, StatsType.Size))
{
stat.IntValue = 175;
}
}
}
}
}
}
private void OnUpdate(Client client, UpdatePacket packet)
{
client.PlayerData.Parse(packet);
if (client.State.ACCID != null)
{
return;
}
State resolvedState = null;
foreach (var cstate in _proxy.States.Values.Where(cstate => cstate.ACCID == client.PlayerData.AccountId))
{
resolvedState = cstate;
}
if (resolvedState == null)
{
client.State.ACCID = client.PlayerData.AccountId;
}
else
{
// Info: I use a "cache" here in order to not make the application throw a "Collection Modified" exception and halt execution
Dictionary <string, dynamic> cache = client.State.States.ToDictionary(pair => pair.Key, pair => pair.Value);
foreach (var pair in cache)
{
resolvedState.States[pair.Key] = pair.Value;
}
client.State = resolvedState;
}
}
// Token: 0x0600051B RID: 1307 RVA: 0x0001E678 File Offset: 0x0001C878
public void Update(UpdatePacket update)
{
foreach (Entity entity in update.NewObjs)
{
ObjectStructure objectStructure = _JzyrOApzC09RC3fmb10FDURmyCl.Objects.ByID(entity.ObjectType);
if (objectStructure != null && objectStructure.ProtectFromGroundDamage)
{
this._7SgGAwTfaktiXrT3QCykHV9mnw7((int)entity.Status.Position._MFEyfKFQqtcdaBxZbAOPzXMB8iP, (int)entity.Status.Position._vwAmCOilfBfnOBAh94J77UFd0FV, true);
}
}
Tile[] ggcOirasY7xrclnb5yxgWCbeJam = update.Tiles;
for (int i = 0; i < ggcOirasY7xrclnb5yxgWCbeJam.Length; i++)
{
SafeWalk._g1WDWSAbzyUpKozUw6l3xkhhISDA g1WDWSAbzyUpKozUw6l3xkhhISDA = new SafeWalk._g1WDWSAbzyUpKozUw6l3xkhhISDA();
g1WDWSAbzyUpKozUw6l3xkhhISDA._mWe1fQ384BLZe9PnvAln1y7kKo = ggcOirasY7xrclnb5yxgWCbeJam[i];
Square q3lhvRoGxDHbe4DHt5QEvG37i6dA = this._W6Ov6AArxzTTDnCyBtZPqkqNaKf.TileAt((int)g1WDWSAbzyUpKozUw6l3xkhhISDA._mWe1fQ384BLZe9PnvAln1y7kKo.X, (int)g1WDWSAbzyUpKozUw6l3xkhhISDA._mWe1fQ384BLZe9PnvAln1y7kKo.Y);
if (Settings.Default.EnableSafeWalk && (!this._x042beur4ZH17DjAMLokZ55nUnB || Settings.Default.SafeWalkInShatters) && q3lhvRoGxDHbe4DHt5QEvG37i6dA.Tile.MinDamage > 0 && !this._tNVnGb7wT30wYHlyz5P26VK4N9A((int)g1WDWSAbzyUpKozUw6l3xkhhISDA._mWe1fQ384BLZe9PnvAln1y7kKo.X, (int)g1WDWSAbzyUpKozUw6l3xkhhISDA._mWe1fQ384BLZe9PnvAln1y7kKo.Y))
{
g1WDWSAbzyUpKozUw6l3xkhhISDA._mWe1fQ384BLZe9PnvAln1y7kKo.Type = this._ZxBRntkKcr5OaFN9gyfy49Kgo2C;
}
else if (Settings.Default.EnableCustomNexus && this._dTuaCU4AfnCs9pYZeRjpD63NJTo.Any(new Func <TileStructure, bool>(g1WDWSAbzyUpKozUw6l3xkhhISDA._cK3tqcFri6sqAZcZMXo2Hx0C43c)))
{
g1WDWSAbzyUpKozUw6l3xkhhISDA._mWe1fQ384BLZe9PnvAln1y7kKo.Type = this._z9AeFwUcnW6WFZFN9LXLmHkxRUn._ikFKebqGeYDppnRN94BtlHzztCC <System.UInt16> .ID;
}
}
}
private bool OnUpdatePacket(ref UpdatePacket packet)
{
foreach (var t in packet.Tiles)
{
this.map.Tiles[t.X][t.Y] = t.Tile;
}
foreach (var tileDef in packet.NewObjects)
{
var def = tileDef;
var objectClass = Singleton <XmlData> .Instance.ObjectTypeToElement[def.ObjectType].Element("Class").Value;
if (objectClass == "Player")
{
continue;
}
if (objectClass != "Enemy" && objectClass != "Character")
{
def.Stats.Position.X -= 0.5F;
def.Stats.Position.Y -= 0.5F;
}
int _x = (int)def.Stats.Position.X;
int _y = (int)def.Stats.Position.Y;
Array.Resize(ref map.Entities[_x][_y], map.Entities[_x][_y].Length + 1);
ObjectDef[] arr = map.Entities[_x][_y];
arr[arr.Length - 1] = def;
}
return(true);
}
private void OnUpdate(UpdatePacket update)
{
_net.SendPacket(new UpdateAckPacket());
foreach (var obj in update.NewObjects)
{
if (obj.Status.ObjectId == ObjectId)
{
PlayerData = PlayerData.processObjectStatus(obj.Status);
position = obj.Status.Pos;
}
else if (Classes.NamesToTypes.ContainsValue(obj.ObjectType))
{
if (Players.ContainsKey(obj.Status.ObjectId))
{
Players.Remove(obj.Status.ObjectId);
}
Players.Add(obj.Status.ObjectId, PlayerData.processObjectStatus(obj.Status));
if (_tracking != null)
{
_tracking.OnEnter?.Invoke(Players[obj.Status.ObjectId]);
}
}
}
foreach (var drop in update.Drops)
{
if (Players.ContainsKey(drop))
{
if (_tracking != null)
{
_tracking.OnLeave?.Invoke(Players[drop]);
}
Players.Remove(drop);
}
}
}
private void OnUpdatePacket(Client client, UpdatePacket packet)
{
if (_enabled)
{
this.m_map.Update(packet);
}
}
public void Update(UpdatePacket packet)
{
foreach (var t in (packet as UpdatePacket).Tiles)
{
this.Tiles[t.X][t.Y] = t.Type;
currentTiles++;
if (TilesAdded != null)
{
TilesAdded(this.currentTiles);
}
}
foreach (var tileDef in (packet as UpdatePacket).NewObjs)
{
var def = (Entity)tileDef.Clone();
if (isMapObject(def.ObjectType))
{
def.Status.Position.X -= 0.5F;
def.Status.Position.Y -= 0.5F;
int _x = (int)def.Status.Position.X;
int _y = (int)def.Status.Position.Y;
Array.Resize(ref this.Entities[_x][_y], this.Entities[_x][_y].Length + 1);
Entity[] arr = this.Entities[_x][_y];
arr[arr.Length - 1] = def;
}
}
}
private void OnUpdate(Client client, Packet packet)
{
UpdatePacket update = (UpdatePacket)packet;
TeleportState state = _states[client];
// New Objects
foreach (Entity entity in update.NewObjs)
{
if (_classes.Contains((short)entity.ObjectType))
{
state.PlayerLocations.Add(entity.Status.ObjectId, entity.Status.Position);
foreach (StatData statData in entity.Status.Data)
{
if (statData.Id == 31)
{
state.PlayerNames.Add(entity.Status.ObjectId, statData.StringValue);
}
}
}
else if (entity.Status.ObjectId == state.QuestId)
{
state.QuestLocation = entity.Status.Position;
}
}
// Removed Objects
foreach (int drop in update.Drops)
{
if (state.PlayerLocations.ContainsKey(drop))
{
state.PlayerLocations.Remove(drop);
state.PlayerNames.Remove(drop);
}
}
}
public override void Run(Player _client, ConquerItem _item)
{
_client.Character.HeavenBlessExpires = DateTime.Now.AddDays(30);
_client.Send(UpdatePacket.Create(_client.UID, Enum.UpdateType.HeavenBlessing, Common.SecondsFromNow(_client.Character.HeavenBlessExpires)));
_client.Send(UpdatePacket.Create(_client.UID, Enum.UpdateType.SizeAdd, 2));
_client.Send(UpdatePacket.Create(_client.UID, Enum.UpdateType.OnlineTraining, 0));
_client.DeleteItem(_item);
}
public UpdatePacket processInput(PlayerInputPacket pip)
{
UpdatePacket update = new UpdatePacket();
update.playerID = pip.playerID;
update.move = pip.move;
return(update);
}
// Token: 0x060004DC RID: 1244 RVA: 0x0001C02C File Offset: 0x0001A22C
public void Update(UpdatePacket update)
{
foreach (Entity entity in update.NewObjs)
{
this.AddCond(entity.Status);
this.HandleStatus(entity.Status);
}
}
public void TestUpdatePacket()
{
var mgr = new BufferManager(2, 128);
var segment1 = mgr.CheckOut(); // 1st buffer
Assert.AreEqual(1, mgr.AvailableSegmentsCount);
var segment2 = mgr.CheckOut(); // 1st buffer
Assert.AreEqual(1, mgr.TotalBufferCount);
Assert.AreEqual(0, mgr.AvailableSegmentsCount);
//Assert.AreEqual(2, segment2.Buffer.UsedSegmentCount);
var segment3 = mgr.CheckOut(); // 2nd buffer
Assert.AreEqual(2, mgr.TotalBufferCount);
Assert.AreEqual(1, mgr.AvailableSegmentsCount);
//Assert.AreEqual(1, segment3.Buffer.UsedSegmentCount);
segment3.DecrementUsage();
Assert.AreEqual(2, mgr.AvailableSegmentsCount);
//Assert.AreEqual(0, segment3.Buffer.UsedSegmentCount);
//using (var outPacket = new UpdatePacket(segment2))
using (var outPacket = new UpdatePacket(128))
{
Assert.AreEqual(outPacket.PacketId, (PacketId)RealmServerOpCode.SMSG_UPDATE_OBJECT);
outPacket.Write(15);
outPacket.WriteCString("abc");
using (var inPacket = DisposableRealmPacketIn.CreateFromOutPacket(segment1, outPacket))
{
Assert.AreEqual(0, inPacket.ReadInt32()); //update count
Assert.AreEqual(15, inPacket.ReadInt32());
Assert.AreEqual("abc", inPacket.ReadCString());
}
outPacket.Reset();
Assert.AreEqual(outPacket.PacketId, (PacketId)RealmServerOpCode.SMSG_UPDATE_OBJECT);
outPacket.WriteCString("def");
outPacket.WriteUShortBE(300);
using (var inPacket = DisposableRealmPacketIn.CreateFromOutPacket(segment1, outPacket))
{
Assert.AreEqual(0, inPacket.ReadInt32()); //update count
Assert.AreEqual((byte)0, inPacket.ReadByte()); //block count
Assert.AreEqual("def", inPacket.ReadCString());
Assert.AreEqual((ushort)300, inPacket.ReadUInt16BE());
}
}
}
public void SendClientActions(PlayerActions actions)
{
UpdatePacket up = new UpdatePacket()
{
PlayerAction = (int)actions
};
_packetProcessor.Send <UpdatePacket>(_server, up, DeliveryMethod.ReliableOrdered);
}
public void Update(UpdatePacket update)
{
foreach (Entity e in update.NewObjs)
{
if (!EnemyTypeMap.ContainsKey(e.Status.ObjectId))
{
EnemyTypeMap[e.Status.ObjectId] = (ushort)e.ObjectType;
}
}
}
private void OnServerPacketReceived(object sender, PacketEventArgs e)
{
var worker = (SocketProxyWorker)sender;
if ((int)worker.GameId != -5)
{
return;
}
if (e.ID == worker.PacketTable.UPDATE)
{
bool enabled = IsEnabled(worker);
if (!enabled)
{
return;
}
UpdatePacket packet = UpdatePacket.Read(new NBufferReader(e.Content));
bool updated = false;
for (int i = 0; i < packet.NewObjects.Length; i++)
{
if (packet.NewObjects[i].ObjectType == 0x0504) //Vault Chest
{
UpdateStats(ref packet.NewObjects[i].Stats);
updated = true;
}
}
if (updated)
{
e.Content = NWriter.Write(writer => packet.Write(writer));
}
}
else if (e.ID == worker.PacketTable.MAPINFO)
{
MapInfoPacket packet = MapInfoPacket.Read(new NBufferReader(e.Content));
packet.ClientXML = packet.ClientXML.Concat(new[]
{
@" <Objects>
<Object type=""0x0504"" id=""Vault Chest"">
<Class>Container</Class>
<Container/>
<CanPutNormalObjects/>
<CanPutSoulboundObjects/>
<ShowName/>
<Texture><File>lofiObj2</File><Index>0x0e</Index></Texture>
<SlotTypes>0, 0, 0, 0, 0, 0, 0, 0</SlotTypes>
</Object>
</Objects>"
}).ToArray();
e.Content = NWriter.Write(writer => packet.Write(writer));
}
}
protected void WriteUpdateValue(UpdatePacket packet, Character receiver, int index)
{
if (this._UpdateFieldInfos.FieldFlags[index].HasAnyFlag(UpdateFieldFlags.Dynamic))
{
this.DynamicUpdateFieldHandlers[index](this, receiver, packet);
}
else
{
packet.Write(this.m_updateValues[index].UInt32);
}
}
private void OnUpdate(Client client, UpdatePacket packet)
{
client.PlayerData.Parse(packet);
State resolvedState = null;
State randomRealmState = null;
foreach (State cstate in _proxy.States.Values.ToList())
{
if (cstate.ACCID == client.PlayerData.AccountId)
{
resolvedState = cstate;
randomRealmState = _proxy.States.Values.FirstOrDefault(x => x.LastHello != null && x.LastHello.GameId == -3);
if (randomRealmState != null)
{
resolvedState.ConTargetAddress = randomRealmState.LastRealm.Host;
resolvedState.LastRealm = randomRealmState.LastRealm;
_proxy.States.Remove(randomRealmState.GUID);
}
else if (resolvedState.LastHello.GameId == -2 && ((MapInfoPacket)client.State["MapInfo"]).Name == "Nexus")
{
resolvedState.ConTargetAddress = Proxy.DefaultServer;
}
}
}
if (resolvedState == null)
{
client.State.ACCID = client.PlayerData.AccountId;
}
else
{
foreach (var pair in client.State.States.ToList())
{
resolvedState[pair.Key] = pair.Value;
}
foreach (var pair in client.State.States.ToList())
{
resolvedState[pair.Key] = pair.Value;
}
client.State = resolvedState;
}
if (packet.NewObjs.Select(x => x.Status.ObjectId).Contains(client.PlayerData.OwnerObjectId))
{
_proxy.FireOnTouchDown(client);
client.State.RenderedEntities.Clear();
}
client.State.RenderedEntities.AddRange(packet.NewObjs.ToList());
client.State.RenderedEntities = client.State.RenderedEntities.Where(x => !packet.Drops.Contains(x.Status.ObjectId)).ToList();
}
//protected override void WriteMovementUpdate(PrimitiveWriter packet, UpdateFieldFlags relation)
//{
// base.WriteMovementUpdate(packet, relation);
//}
void SendOwnUpdates()
{
m_updatePacket.Position = m_updatePacket.HeaderSize;
m_updatePacket.Write(UpdateCount);
SendUpdatePacket(this, m_updatePacket);
//m_updatePacket.Reset();
m_updatePacket.Close();
m_updatePacket = new UpdatePacket();
UpdateCount = 0;
}
private static void Process_Update(Player client, string[] command)
{
if (client.Account.Permission < PlayerPermission.GM)
return;
try
{
var packet = UpdatePacket.Create(client.UID, (UpdateType)int.Parse(command[3]), uint.Parse(command[1]), uint.Parse(command[2]));
client.Send(packet);
}
catch (Exception p) { Console.WriteLine(p); }
}
public void OnUpdate(Client client, Packet packet)
{
UpdatePacket up = (UpdatePacket)packet;
foreach (Tile tile in up.Tiles)
{
if (listOfClients.ContainsKey(client))
{
listOfClients[client].map.Data[tile.X, tile.Y] = tile.Type;
}
}
}
public void OnUpdate(Client client, Packet packet)
{
if (!_dQuest.ContainsKey(client))
{
return;
}
if (DailyQuestConfig.Default.AutoRequest && !_dQuest[client].reqSent)
{
_dQuest[client].reqSent = true;
client.SendToServer(Packet.Create(PacketType.QUESTFETCHASK));
}
UpdatePacket update = (UpdatePacket)packet;
if (_dQuest[client].goal != 0)
{
foreach (Entity entity in update.NewObjs)
{
short type = entity.ObjectType;
if (_bags.Contains(type))
{
int bagId = entity.Status.ObjectId;
bool hasItem = false;
foreach (StatData statData in entity.Status.Data)
{
if (statData.Id >= 8 && statData.Id <= 15)
{
if (statData.IntValue == _dQuest[client].goal)
{
hasItem = true;
break;
}
}
}
if (hasItem)
{
if (!_dQuest[client].bagLocations.ContainsKey(bagId))
{
_dQuest[client].bagLocations.Add(bagId, entity.Status.Position);
}
else
{
_dQuest[client].bagLocations[bagId] = entity.Status.Position;
}
}
}
}
}
}
