예제 #1
0
파일: Switch.cs 프로젝트: toddw123/KRelay
        public void Swap(Client client, SlotObject sobj1, SlotObject sobj2, bool all = false)
        {
            //Console.WriteLine("Swap called with {0} and {1}", sobj1.SlotId, sobj2.SlotId);
            InvSwapPacket invSwapPacket = (InvSwapPacket)Packet.Create(PacketType.INVSWAP);

            invSwapPacket.Time        = client.Time;
            invSwapPacket.Position    = client.PlayerData.Pos;
            invSwapPacket.SlotObject1 = sobj1;
            invSwapPacket.SlotObject2 = sobj2;
            client.SendToServer(invSwapPacket);

            if (all)
            {
                if (sobj1.SlotId < 11)
                {
                    PluginUtils.Delay(600, () =>
                    {
                        Swap(client,
                             new SlotObject
                        {
                            ObjectId   = client.ObjectId,
                            SlotId     = (byte)(sobj1.SlotId + 1),
                            ObjectType = client.PlayerData.Slot[sobj1.SlotId + 1]
                        },
                             new SlotObject
                        {
                            ObjectId   = client.ObjectId,
                            SlotId     = (byte)(sobj1.SlotId + 9),
                            ObjectType = client.PlayerData.BackPack[(sobj1.SlotId + 1) - 4]
                        }, true);
                    });
                }
            }
        }
예제 #2
0
 public void CancelTimerStart()
 {
     PluginUtils.Delay(30000, new Action(() => { if (this.InTrade)
                                                 {
                                                     client.SendToServer(Packet.Create(PacketType.CANCELTRADE)); InTrade = false;
                                                 }
                                         }));
 }
예제 #3
0
        private static void GiveItemRetry(PZClient giver, PZClient reciever, PZItem item, int start, int no)
        {
            int na = no + 1;

            bool[]             sel = PZClient.GetToSel(giver.client, item);
            RequestTradePacket req = (RequestTradePacket)Packet.Create(PacketType.REQUESTTRADE);

            req.Name = reciever.ToString();
            giver.client.SendToServer(req);

            req.Name = giver.ToString();
            reciever.client.SendToServer(req);

            ChangeTradePacket cht = (ChangeTradePacket)Packet.Create(PacketType.CHANGETRADE);

            cht.Offers = sel;
            giver.client.SendToServer(cht);

            AcceptTradePacket atpkt = (AcceptTradePacket)Packet.Create(PacketType.ACCEPTTRADE);

            atpkt.MyOffers   = sel;
            atpkt.YourOffers = new bool[12];
            giver.client.SendToServer(atpkt);

            atpkt.MyOffers   = new bool[12];
            atpkt.YourOffers = sel;
            reciever.client.SendToServer(atpkt);
            Console.WriteLine(giver.ToString() + " gave " + item + " to " + reciever);
            PluginUtils.Delay(2000, new Action(() =>
            {
                int now      = reciever.CountItem(item.ID);
                int addition = now - start;
                if (addition < item.amount)
                {
                    Console.WriteLine("[ERROR]" + (item.amount - addition) + " " + item.ActualName() + " failed to be recieved so trying again");
                    if (na <= 7)
                    {
                        PluginUtils.Delay(500, new Action(() => GiveItemRetry(giver, reciever, item, start, na)));
                    }
                    else
                    {
                        Console.WriteLine("Tried over 7 times, give up!");
                    }
                }
                else
                {
                    Console.WriteLine("Recieve success!");
                    PluginUtils.Delay(500, new Action(() =>
                    {
                        giver.enabled        = true;
                        reciever.enabled     = true;
                        reciever.spamenabled = true;
                        giver.spamenabled    = true;
                    }));
                }
            }));
            na++;
        }
예제 #4
0
 private void OnCreateSuccess(Client client, Packet packet)
 {
     if (_enabled)
     {
         PluginUtils.Delay(2100, () =>
                           client.SendToClient(PluginUtils.CreateOryxNotification(
                                                   "Auto Ability", "Use your ability to Activate Auto Ability")));
     }
 }
예제 #5
0
        private void OnCreateSuccess(Client client, CreateSuccessPacket packet)
        {
            PluginUtils.Delay(1000, () =>
            {
                string message = "Welcome to K Relay!";
                string server  = "";
                if (GameData.GameData.Servers.Map.Where(s => s.Value.Address == client.State.ConTargetAddress).Any())
                {
                    server = GameData.GameData.Servers.Match(s => s.Address == client.State.ConTargetAddress).Name;
                }

                if (server != "")
                {
                    message += "\\n" + server;
                }

                client.SendToClient(PluginUtils.CreateNotification(client.ObjectId, message));
            });
        }
예제 #6
0
        public void OnTradeStart(Client client, Packet packet)
        {
            TradeStartPacket start = (TradeStartPacket)packet;

            if (_Enabled[client] && _Started[client])
            {
                Console.WriteLine("Trade Started with \"" + start.YourName + "\"");
                //CurrentTrade = new Trade(client, start);
                CurrentTrades[client] = new Trade(client, start);

                //if (CurrentTrade.HasItems())
                if (CurrentTrades[client].HasItems())
                {
                    Console.WriteLine("Have Item!");
                    // Wait 30 seconds and then cancel the trade if it is still going
                    PluginUtils.Delay(30000, new Action(() =>
                    {
                        if (CurrentTrades[client].isTrading)
                        {
                            client.SendToServer(Packet.Create(PacketType.CANCELTRADE));
                            CurrentTrades[client].isTrading = false;
                            Console.WriteLine("Canceling Trade Due To Time!");
                        }
                    }));
                }
                else
                {
                    Console.WriteLine("No Have Item!");
                    // Wait 4 seconds and then cancel the trade
                    PluginUtils.Delay(4000, new Action(() =>
                    {
                        if (CurrentTrades[client].isTrading)
                        {
                            client.SendToServer(Packet.Create(PacketType.CANCELTRADE));
                            CurrentTrades[client].isTrading = false;
                            Console.WriteLine("Canceling Trade Due To Missing Items!");
                        }
                    }));
                }
            }
        }
예제 #7
0
        private void OnUpdate(Client client, UpdatePacket p)
        {
            // If the plugin is enabled, player is on a new map and the client is connected
            if (enabled && newMap && client.Connected)
            {
                // Correct map
                if (currentMapName == "Nexus Explanation")
                {
                    // Start moving towards the target on a background thread
                    Log("Starting to move");
                    new Task(() => MoveToTarget(client)).Start();
                }
                // Any other map
                else
                {
                    // There needs to be some delay before the teleport to avoid an exception in K-Relay
                    Log("Teleporting to Nexus Explanation");
                    PluginUtils.Delay(1000, () => client?.SendChatMessage("/nexustutorial"));
                }

                // This is no longer a new map
                newMap = false;
            }
        }
예제 #8
0
        private void OnUpdate(Client client, Packet p)
        {
            UpdatePacket packet = p as UpdatePacket;

            foreach (Entity obj in packet.NewObjs)
            {
                if (Enum.IsDefined(typeof(Classes), (short)obj.ObjectType))
                {
                    PlayerData playerData = new PlayerData(obj.Status.ObjectId);
                    playerData.Class = (Classes)obj.ObjectType;
                    playerData.Pos   = obj.Status.Position;
                    foreach (var data in obj.Status.Data)
                    {
                        playerData.Parse(data.Id, data.IntValue, data.StringValue);
                    }

                    if (playerData.Stars < Settings.Default.starsToCluster)
                    {
                        continue;
                    }

                    if (playerPositions.ContainsKey(obj.Status.ObjectId))
                    {
                        playerPositions.Remove(obj.Status.ObjectId);
                    }
                    playerPositions.Add(obj.Status.ObjectId, new Target(obj.Status.ObjectId, playerData.Name, playerData.Pos));
                }
                if (obj.ObjectType == 1810)
                {
                    foreach (var data in obj.Status.Data)
                    {
                        if (data.StringValue != null)
                        {
                            string pattern = @"\.(\w+) \((\d+)";
                            var    match   = Regex.Match(data.StringValue, pattern);

                            var portal = new Portal(obj.Status.ObjectId, int.Parse(match.Groups[2].Value), match.Groups[1].Value, obj.Status.Position);
                            if (portals.Exists(ptl => ptl.ObjectId == obj.Status.ObjectId))
                            {
                                portals.RemoveAll(ptl => ptl.ObjectId == obj.Status.ObjectId);
                            }
                            portals.Add(portal);
                        }
                    }
                }
                if (currentMapName != "Nexus" /*&& Settings.Default.walkToBags*/)
                {
                    if (
                        (obj.ObjectType == Orange || obj.ObjectType == OrangeBoosted ||
                         obj.ObjectType == Red || obj.ObjectType == RedBoosted ||
                         obj.ObjectType == Blue || obj.ObjectType == BlueBoosted ||
                         obj.ObjectType == Gold || obj.ObjectType == GoldBoosted ||
                         obj.ObjectType == White || obj.ObjectType == WhiteBoosted))
                    {
                        followTarget = false;
                        targets.Clear();

                        target_   = obj.Status.Position;
                        gotoRealm = true;
                        MoveToRealms(connectedClient);
                        PluginUtils.Delay(3000, () => followTarget = true);
                        PluginUtils.Delay(3000, () => gotoRealm    = false);
                        PluginUtils.Delay(3000, () => followTarget = true);
                    }
                }
                if (Enum.IsDefined(typeof(EnemyId), (int)obj.ObjectType) && config.EnableEnemyAvoidance)
                {
                    if (enemies.Exists(en => en.ObjectId == obj.Status.ObjectId))
                    {
                        enemies.RemoveAll(en => en.ObjectId == obj.Status.ObjectId);
                    }
                    enemies.Add(new Enemy(obj.Status.ObjectId, obj.Status.Position));
                }

                if (obstacleIds.Contains(obj.ObjectType))
                {
                    if (!obstacles.Exists(obstacle => obstacle.ObjectId == obj.Status.ObjectId))
                    {
                        obstacles.Add(new Obstacle(obj.Status.ObjectId, obj.Status.Position));
                    }
                }
            }

            foreach (int dropId in packet.Drops)
            {
                if (playerPositions.ContainsKey(dropId))
                {
                    if (followTarget && targets.Exists(t => t.ObjectId == dropId))
                    {
                        targets.Remove(targets.Find(t => t.ObjectId == dropId));
                        Log(string.Format("Dropping \"{0}\" from targets.", playerPositions[dropId].Name));
                        if (targets.Count == 0)
                        {
                            Log("No targets left in target list.");
                            if (config.EscapeIfNoTargets)
                            {
                                Escape(client);
                            }
                        }
                    }
                    playerPositions.Remove(dropId);
                }

                if (enemies.Exists(en => en.ObjectId == dropId))
                {
                    enemies.RemoveAll(en => en.ObjectId == dropId);
                }

                if (portals.Exists(ptl => ptl.ObjectId == dropId))
                {
                    portals.RemoveAll(ptl => ptl.ObjectId == dropId);
                }
            }
        }
예제 #9
0
        public void Initialize(Proxy proxy)
        {
            targets         = new List <Target> ();
            playerPositions = new Dictionary <int, Target> ();
            portals         = new List <Portal> ();
            enemies         = new List <Enemy> ();
            obstacles       = new List <Obstacle> ();

            obstacleIds = new List <ushort> ();
            GameData.Objects.Map.ForEach((kvp) => {
                if (kvp.Value.FullOccupy || kvp.Value.OccupySquare)
                {
                    obstacleIds.Add(kvp.Key);
                }
            });
            PluginUtils.Log("FameBot", "Found {0} obstacles.", obstacleIds.Count);

            gui = new FameBotGUI();
            PluginUtils.ShowGUI(gui);

            config = ConfigManager.GetConfiguration();

            Process[] processes = Process.GetProcessesByName(config.FlashPlayerName);
            if (processes.Length == 1)
            {
                Log("Automatically bound to client.");
                flashPtr = processes[0].MainWindowHandle;
                gui?.SetHandle(flashPtr);
                if (config.AutoConnect)
                {
                    Start();
                }
            }
            else if (processes.Length > 1)
            {
                Log("Multiple flash players running. Use the /bind command on the client you want to use.");
            }
            else
            {
                Log("Couldn't find flash player. Use the /bind command in game, then start the bot.");
            }

            #region Proxy Hooks
            proxy.HookCommand("bind", ReceiveCommand);
            proxy.HookCommand("start", ReceiveCommand);
            proxy.HookCommand("gui", ReceiveCommand);
            proxy.HookCommand("famebot", ReceiveCommand);
            proxy.HookCommand("stop1", ReceiveCommand);
            proxy.HookCommand("options", ReceiveCommand);
            proxy.HookPacket(PacketType.RECONNECT, OnReconnect);
            proxy.HookPacket(PacketType.UPDATE, OnUpdate);
            proxy.HookPacket(PacketType.NEWTICK, OnNewTick);
            proxy.HookPacket(PacketType.PLAYERHIT, OnHit);
            proxy.HookPacket(PacketType.MAPINFO, OnMapInfo);
            proxy.HookPacket(PacketType.TEXT, OnText);
            proxy.HookPacket(PacketType.GOTOACK, (client, packet) => {
                if (blockNextAck)
                {
                    packet.Send  = false;
                    blockNextAck = false;
                }
            });
            #endregion

            proxy.ClientConnected += (client) => {
                connectedClient = client;
                targets.Clear();
                playerPositions.Clear();
                enemies.Clear();
                obstacles.Clear();
                followTarget = false;
                isInNexus    = false;
                ResetAllKeys();
            };

            proxy.ClientDisconnected += (client) => {
                Log("Client disconnected. Waiting a few seconds before trying to press play...");
                PressPlay();
            };

            guiEvent += (evt) => {
                switch (evt)
                {
                case GuiEvent.StartBot:
                    Start();
                    break;

                case GuiEvent.StopBot:
                    Stop();
                    break;

                case GuiEvent.SettingsChanged:
                    Log("Updated config");
                    config = ConfigManager.GetConfiguration();
                    break;
                }
            };

            sendMessage += (message) => {
                if (!(connectedClient?.Connected ?? false))
                {
                    return;
                }
                PlayerTextPacket packet = (PlayerTextPacket)Packet.Create(PacketType.PLAYERTEXT);
                packet.Text = message;
                connectedClient.SendToServer(packet);
            };

            proxy.HookPacket(PacketType.FAILURE, (client, packet) => {
                FailurePacket p = packet as FailurePacket;

                if (p.ErrorId != 9)
                {
                    Console.WriteLine("<FAILURE> ID: " + p.ErrorId + " Message: " + p.ErrorMessage);
                }

                if (p.ErrorMessage == "{\"key\":\"server.realm_full\"}")
                {
                    Attempts++;
                    if (Attempts >= 2 && bestName != "")
                    {
                        _bestName = bestName;
                        ReconnectPacket reconnect = (ReconnectPacket)Packet.Create(PacketType.RECONNECT);
                        reconnect.Name            = "{\"text\":\"server.realm_of_the_mad_god\"}";
                        reconnect.Host            = "";
                        reconnect.Stats           = "";
                        reconnect.Port            = -1;
                        reconnect.GameId          = -3;
                        reconnect.KeyTime         = -1;
                        reconnect.IsFromArena     = false;
                        reconnect.Key             = new byte[0];

                        connectedClient.SendToClient(reconnect);
                        Attempts        = 0;
                        loopingforrealm = true;
                    }
                }
            });

            proxy.HookPacket(PacketType.CREATESUCCESS, (client, packet) => {
                target_ = null;
                if (enabled)
                {
                    PluginUtils.Delay(200, () => Stop());
                    PluginUtils.Delay(500, () => Stop());
                    PluginUtils.Delay(1300, () => Stop());
                    PluginUtils.Delay(2200, () => Start());
                }
            });
        }
예제 #10
0
        private void inventorySwap(byte itemSlot)
        {
            if (DateTime.Now < lastSwapTime.AddSeconds(2))
            {
                return;
            }
            lastSwapTime = DateTime.Now;
            hotswapping  = true;
            byte equipSlotId = 0;

            if (_client.PlayerData.Slot[(int)itemSlot] == -1)
            {
                return;
            }
            switch (GameData.Items.ByID((ushort)_client.PlayerData.Slot[(int)itemSlot]).SlotType)
            {
            case 1:
            case 2:
            case 3:
            case 8:
            case 17:
            case 24:
                equipSlotId = 0;
                break;

            case 6:
            case 7:
            case 14:
                equipSlotId = 2;
                break;

            case 4:
            case 5:
            case 11:
            case 12:
            case 13:
            case 15:
            case 16:
            case 18:
            case 19:
            case 20:
            case 21:
            case 22:
            case 23:
            case 25:
            case 27:
                equipSlotId = 1;
                break;

            case 9:
                equipSlotId = 3;
                break;
            }
            InvSwapPacket invSwap = (InvSwapPacket)Packet.Create(PacketType.INVSWAP);

            invSwap.Time     = _client.Time + 10;
            invSwap.Position = _client.PlayerData.Pos;

            invSwap.SlotObject1            = new SlotObject();
            invSwap.SlotObject1.ObjectId   = _client.ObjectId;
            invSwap.SlotObject1.SlotId     = equipSlotId;
            invSwap.SlotObject1.ObjectType = _client.PlayerData.Slot[(int)equipSlotId];

            invSwap.SlotObject2            = new SlotObject();
            invSwap.SlotObject2.ObjectId   = _client.ObjectId;
            invSwap.SlotObject2.SlotId     = itemSlot;
            invSwap.SlotObject2.ObjectType = _client.PlayerData.Slot[(int)itemSlot];

            _client.SendToServer(invSwap);
            PluginUtils.Delay(1000, () => {
                hotswapping = false;
            });
        }