public void OnActorCorpseOpen(CM_ACTOR_CORPSE_OPEN p)
        {
            ActorCorpse corspe = map.GetActor(p.ActorID) as ActorCorpse;

            if (corspe == null && map.MapObjects.ContainsKey(p.ActorID))
            {
                corspe = map.MapObjects[p.ActorID];
            }
            if (corspe != null)
            {
                if (corspe.CurrentPickingPlayer != 0 || currentCorpse != null || (corspe.Owner != chara && corspe.Owner != null && !Party.PartyManager.Instance.PartyCanLoot(chara, corspe.Owner as ActorPC)))
                {
                    SM_ACTOR_CORPSE_OPEN_FAILED p1 = new SM_ACTOR_CORPSE_OPEN_FAILED();
                    Network.SendPacket(p1);
                }
                else
                {
                    currentCorpse = corspe;
                    corspe.CurrentPickingPlayer = chara.ActorID;
                    SM_ACTOR_CORPSE_ITEM_LIST p1 = new SM_ACTOR_CORPSE_ITEM_LIST()
                    {
                        ActorID = corspe.ActorID,
                        Gold    = corspe.Gold,
                        Items   = corspe.AvailableItems
                    };
                    Network.SendPacket(p1);

                    UpdateEvent evt = new UpdateEvent()
                    {
                        Actor      = chara,
                        Target     = chara,
                        UpdateType = UpdateTypes.Actor
                    };
                    //evt.AddActorPara(PacketParameter.PickingUp, 1);
                    map.SendEventToAllActorsWhoCanSeeActor(MapEvents.EVENT_BROADCAST, evt, chara, true);

                    evt = new UpdateEvent()
                    {
                        Actor      = chara,
                        Target     = corspe,
                        UpdateType = UpdateTypes.CorpseInteraction,
                        UserData   = (byte)0
                    };
                    map.SendEventToAllActorsWhoCanSeeActor(MapEvents.EVENT_BROADCAST, evt, chara, true);
                }
            }
            else
            {
                SM_ACTOR_CORPSE_OPEN_FAILED p1 = new SM_ACTOR_CORPSE_OPEN_FAILED();
                Network.SendPacket(p1);
            }
        }
Example #2
0
        public override void OnActorDisappears(Actor dActor)
        {
            if (client.BroadcastService == null)
            {
                return;
            }

            ActorCorpse corpse = dActor as ActorCorpse;
            ActorItem   item   = dActor as ActorItem;

            if (corpse != null)
            {
                UpdateEvent evt = new UpdateEvent()
                {
                    Actor      = dActor,
                    UpdateType = UpdateTypes.DeleteCorpse
                };
                client.BroadcastService.EnqueueUpdateEvent(evt);
            }
            else if (item != null)
            {
                UpdateEvent evt = new UpdateEvent()
                {
                    Actor      = item.Creator,
                    Target     = item,
                    UpdateType = UpdateTypes.ItemDisappear
                };
                client.BroadcastService.EnqueueUpdateEvent(evt);
            }
            else
            {
                UpdateEvent evt = new UpdateEvent()
                {
                    UpdateType = UpdateTypes.Disappear,
                    Actor      = dActor
                };
                client.BroadcastService.EnqueueUpdateEvent(evt);
            }
        }
Example #3
0
        public override void OnDie(ActorExt killedBy)
        {
            if (npc.Tasks.TryGetValue("ActorCatch", out Task removed))
            {
                removed.Deactivate();
            }

            if (firstAttacker != null && npc.BaseData.QuestIDs.Count > 0)
            {
                ActorPC       pc      = firstAttacker;
                List <ushort> already = new List <ushort>();
                foreach (ushort i in npc.BaseData.QuestIDs)
                {
                    if (!already.Contains(i))
                    {
                        already.Add(i);
                    }
                    else
                    {
                        continue;
                    }

                    if (pc.Quests.TryGetValue(i, out Common.Quests.Quest q))
                    {
                        try
                        {
                            Quests.QuestManager.Instance.ProcessQuest(pc, i, q.NextStep, q, npc, false, true);
                        }
                        catch (Exception ex)
                        {
                            Logger.Log.Error(ex);
                        }
                    }
                }
            }
            if (ShouldRespawn != null)
            {
                ShouldRespawn();
            }

            AI.Deactivate();
            Map.Map     map    = MapManager.Instance.GetMap(npc.MapInstanceID);
            ActorCorpse corpse = new ActorCorpse(npc);

            if (firstAttacker != null)
            {
                corpse.Owner = Party.PartyManager.Instance.GetPartyLootOwner(firstAttacker);
            }

            corpse.MapID        = npc.MapID;
            corpse.X            = npc.X;
            corpse.Y            = npc.Y;
            corpse.Z            = npc.Z;
            corpse.EventHandler = new DummyEventHandler();

            if (firstAttacker != null)
            {
                uint exp = (uint)(npc.Level / 2 + 10);
                Manager.ExperienceManager.Instance.ApplyExp(firstAttacker, exp);
                List <Common.Item.Item> items = new List <Common.Item.Item>();
                foreach (uint i in npc.BaseData.Items.Keys)
                {
                    int rate = npc.BaseData.Items[i];
                    if (Global.Random.Next(0, 99) < rate)
                    {
                        Common.Item.Item item = Item.ItemFactory.Instance.CreateNewItem(i);
                        item.Count = npc.BaseData.ItemCounts[i];
                        items.Add(item);
                    }
                }
                //corpse.Gold = 200;
                corpse.Items = items.ToArray();
            }
            map.RegisterActor(corpse);
            npc.Status.CorpseActorID = corpse.ActorID;

            Tasks.Actor.CorpseDeleteTask task = new Tasks.Actor.CorpseDeleteTask(npc.BaseData.CorpseItemID > 0 ? 20000 : 10000, corpse);
            task.Activate();

            foreach (NPCDeathSpawn i in npc.BaseData.DeathSpawns)
            {
                for (int j = 0; j < i.Count; j++)
                {
                    short x = (short)Global.Random.Next(npc.X - 15, npc.X + 15);
                    short y = (short)Global.Random.Next(npc.Y - 15, npc.Y + 15);
                    short z = (short)npc.Z;
                    Scripting.Utils.SpawnNPC(map, i.NPCID, i.AppearEffect, x, y, z, 0, i.Motion);
                }
            }
            firstAttacker = null;
        }
        public void SendActorCorpseClose(ulong actorID)
        {
            if (currentCorpse != null && currentCorpse.ActorID == actorID)
            {
                ActorCorpse corpse = currentCorpse;
                currentCorpse = null;
                corpse.CurrentPickingPlayer = 0;
                UpdateEvent evt = new UpdateEvent()
                {
                    Actor      = chara,
                    Target     = chara,
                    UpdateType = UpdateTypes.Actor
                };
                //evt.AddActorPara(PacketParameter.PickingUp, 0);
                map.SendEventToAllActorsWhoCanSeeActor(MapEvents.EVENT_BROADCAST, evt, chara, true);

                evt = new UpdateEvent()
                {
                    Actor      = chara,
                    Target     = corpse,
                    UpdateType = UpdateTypes.CorpseInteraction,
                    UserData   = (byte)1
                };
                map.SendEventToAllActorsWhoCanSeeActor(MapEvents.EVENT_BROADCAST, evt, chara, true);

                if (corpse?.AvailableItems.Count == 0 && corpse.Gold == 0)
                {
                    if (corpse.ActorType == ActorType.MAPOBJECT)
                    {
                        evt = new UpdateEvent()
                        {
                            Actor      = corpse,
                            UpdateType = UpdateTypes.MapObjectVisibilityChange
                        };
                        map.SendEventToAllActorsWhoCanSeeActor(MapEvents.EVENT_BROADCAST, evt, chara, true);
                    }
                    else
                    {
                        if (corpse.NPC.BaseData.CorpseItemID == 0 && corpse.NPC.BaseData.QuestIDs.Count == 0)
                        {
                            if (corpse.Tasks.TryRemove("CorpseDelete", out Task task))
                            {
                                task.Deactivate();
                            }

                            map.DeleteActor(corpse);
                        }
                        else
                        {
                            evt = new UpdateEvent()
                            {
                                Actor      = corpse,
                                UpdateType = UpdateTypes.DeleteCorpse
                            };
                            map.SendEventToAllActorsWhoCanSeeActor(MapEvents.EVENT_BROADCAST, evt, chara, true);
                        }
                    }
                }
            }
            SM_ACTOR_CORPSE_CLOSE_RESULT p1 = new SM_ACTOR_CORPSE_CLOSE_RESULT()
            {
                ActorID = actorID
            };

            Network.SendPacket(p1);
        }