Выдать предмет GF PTS Vanganth

ZombieXLX

Путник
Участник
Сообщения
32
Розыгрыши
0
Репутация
0
Реакции
8
Баллы
88
Искал искал, и не как не нашел как можно выдать предмет, в базе прописывал но он не появляется, пытался найти примеры работы с cached, нашел но именно выдача предмета не работает зато работает:
Python:
import socket
import struct
import logging

# Настроим логирование
logging.basicConfig(level=logging.DEBUG)

class CacheD:
    def __init__(self, cached_ip, cached_port, webadmin='Admin'):
        self.cached_ip = cached_ip
        self.cached_port = cached_port
        self.webadmin = webadmin
        self.connected = False
        self.fsockerror = False
        self.socketerrors = {
            "1": True, "01": False, "02": False, "03": False, "04": False,
            "05": False, "06": False, "07": False, "08": False, "09": False,
            "010": False, "011": False, "012": False, "013": False, "014": False,
            "015": False, "016": False, "017": False, "018": False, "019": False,
            "020": False, "021": False, "022": False, "023": False, "024": False,
            "025": False, "026": False
        }

    def tounicode(self, string):
        return string.encode('utf-16le') + b'\x00\x00'

    def CacheDInteractive(self, buf):
        try:
            with socket.create_connection((self.cached_ip, self.cached_port), timeout=5) as sock:
                self.connected = True

                packet_length = struct.pack("<h", len(buf) + 2)
                packet = packet_length + buf
                sock.sendall(packet)
                logging.debug(f"Packet sent: {packet.hex()}")

                length_data = sock.recv(2)
                length = struct.unpack("<h", length_data)[0]
                logging.debug(f"Response length: {length} (raw: {length_data.hex()})")

                response_id_data = sock.recv(1)
                response_id = struct.unpack("<b", response_id_data)[0]
                logging.debug(f"Response ID: {response_id} (raw: {response_id_data.hex()})")

                remaining_length = length - 3
                response_data = sock.recv(remaining_length)
                logging.debug(f"Raw response data: {response_data.hex()}")

                rs = ''
                for i in range(0, len(response_data), 4):
                    read_data = response_data[i:i+4]
                    if len(read_data) < 4:
                        break
                    read = struct.unpack("<i", read_data)[0]
                    rs += str(read)
                    logging.debug(f"Read: {read} (raw: {read_data.hex()})")

                logging.debug(f"Response: {rs}")

                result = self.socketerrors.get(rs, False)
                return result
        except socket.error as e:
            logging.error(f"Socket error: {e}")
            self.connected = False
            return self.fsockerror

    def CheckCharacterPacket(self, char_id):
        buf = struct.pack("<B", 1) + struct.pack("<I", char_id) + self.tounicode(self.webadmin)
        logging.debug(f"Buffer: {buf.hex()}")
        return self.CacheDInteractive(buf)

    def SetCharacterLocationPacket(self, char_id, xloc, yloc, zloc):
        buf = struct.pack("<B", 2) + struct.pack("<I", char_id) + struct.pack("<I", 1) + struct.pack("<I", xloc) + struct.pack("<I", yloc) + struct.pack("<I", zloc) + self.tounicode(self.webadmin)
        logging.debug(f"Buffer: {buf.hex()}")
        return self.CacheDInteractive(buf)


if __name__ == "__main__":
    cached_ip = '127.0.0.1'
    cached_port = 2012
    cacheD = CacheD(cached_ip, cached_port)
    
    # Проверка метода CheckCharacterPacket
    result = cacheD.CheckCharacterPacket(IDCHAR)
    print("CheckCharacterPacket result:", result)
    
    # Проверка метода SetCharacterLocationPacket
    result = cacheD.SetCharacterLocationPacket(IDCHAR, 100, 200, 300)
    print("SetCharacterLocationPacket result:", result)
Поделитесь идеями как выдать предмет.
 

//summon не работает команда?
 
Пообщался с ZombieXLX в лс , выяснил что ему надо найти инструмент для выдачи предмета не находясь в игре, соответственно команды //summon и //giveitem ему не подходят, тут варианты: личный кабинет, либо off-panel
 
Пообщался с ZombieXLX в лс , выяснил что ему надо найти инструмент для выдачи предмета не находясь в игре, соответственно команды //summon и //giveitem ему не подходят, тут варианты: личный кабинет, либо off-panel
Спасибо но ты опоздал буквально на минут 15.
Разобрался немного, выдача итема работает если чар не в онлайне, можно находится на этапе выбора персонажа но не в игровом мире.
Python:
import socket
import struct
import logging
# Настроим логирование
logging.basicConfig(level=logging.DEBUG)

class CacheD:
    def __init__(self, cached_ip, cached_port, webadmin='Admin'):
        self.cached_ip = cached_ip
        self.cached_port = cached_port
        self.webadmin = webadmin
        self.connected = False
        self.fsockerror = False
        self.socketerrors = {
            "1": True,
            "01": False,
            "02": False,
            "03": False,
            "04": False,
            "05": False,
            "06": False,
            "07": False,
            "08": False,
            "09": False,
            "010": False,
            "011": False,
            "012": False,
            "013": False,
            "014": False,
            "015": False,
            "016": False,
            "017": False,
            "018": False,
            "019": False,
            "020": False,
            "021": False,
            "022": False,
            "023": False,
            "024": False,
            "025": False,
            "026": False
        }
    def tounicode(self, string):
        rs = ""
        for char in string:
            rs += char + '\x00'
        rs += '\x00\x00'
        return rs.encode('utf-16le')
    def CacheDInteractive(self, buf):
        try:
            with socket.create_connection((self.cached_ip, self.cached_port),
                                          timeout=5) as sock:
                self.connected = True
                packet_length = struct.pack("<h", len(buf) + 2)
                packet = packet_length + buf
                sock.sendall(packet)
                logging.debug(f"Packet sent: {packet.hex()}")
                length_data = sock.recv(2)
                length = struct.unpack("<h", length_data)[0]
                logging.debug(
                    f"Response length: {length} (raw: {length_data.hex()})")
                response_id_data = sock.recv(1)
                response_id = struct.unpack("<b", response_id_data)[0]
                logging.debug(
                    f"Response ID: {response_id} (raw: {response_id_data.hex()})"
                )
                remaining_length = length - 3
                response_data = sock.recv(remaining_length)
                logging.debug(f"Raw response data: {response_data.hex()}")
                rs = ''
                for i in range(0, len(response_data), 4):
                    read_data = response_data[i:i + 4]
                    if len(read_data) < 4:
                        break
                    read = struct.unpack("<i", read_data)[0]
                    rs += str(read)
                    logging.debug(f"Read: {read} (raw: {read_data.hex()})")
                logging.debug(f"Response: {rs}")
                result = self.socketerrors.get(rs, False)
                return result
        except socket.error as e:
            logging.error(f"Socket error: {e}")
            self.connected = False
            return self.fsockerror
    def AddItem2Packet(self, char_id, warehouse, item_type, q, enchant, eroded,
                       bless, wished):
        bless = 0
        q_h = int(q / 0x100000000)
        if q_h < 0:
            q_h = 0
        else:
            q = q - (q_h * 0x100000000)
        buf = struct.pack("B", 55)
        buf += struct.pack("I", char_id)
        buf += struct.pack("I", warehouse)
        buf += struct.pack("I", item_type)
        buf += struct.pack("I", q)
        buf += struct.pack("I", q_h)
        buf += struct.pack("I", enchant)
        buf += struct.pack("I", eroded)
        buf += struct.pack("I", bless)
        buf += struct.pack("I", wished)
        buf += struct.pack("I", 1)
        buf += struct.pack("I", 0)
        buf += struct.pack("I", 0)
        buf += struct.pack("I", 0)
        buf += struct.pack("I", 0)
        buf += self.tounicode(self.webadmin)
        logging.debug(f"Buffer after packing: {buf.hex()}")
        return self.CacheDInteractive(buf)

if __name__ == "__main__":
    cached_ip = '127.0.0.1'
    cached_port = 2012
    char_id = 5
    item_id = 57
    cacheD = CacheD(cached_ip, cached_port)
    # Проверка метода AddItem2Packet
    result = cacheD.AddItem2Packet(char_id, 0, item_id, 1, 0, 0, 0, 0)
    print("AddItem2Packet result:", result)

p.s. это всё ещё не то, что хотел но начало уже есть
 
Ну так писать свой экст, что бы он добавлял предметы, либо слать 2 пакета с киком персонажа, а потом выдачей предмета
 
Ну так писать свой экст, что бы он добавлял предметы, либо слать 2 пакета с киком персонажа, а потом выдачей предмета
Где про это почитать за эксты? Тоже думал на крайняк описать: проверил онлайн/кикнул/выдал
 
Где про это почитать за эксты
Ну так, тут уже экстендер от Vanganth, нужно лишь реализовать, что бы выдавало предмет персонажу. т.е писать код к нему и перекомпилировать.
 
Ну так, тут уже экстендер от Vanganth, нужно лишь реализовать, что бы выдавало предмет персонажу. т.е писать код к нему и перекомпилировать.
Буду гуглить/читать, спасибо за объяснение ну и конечно же плодить темы 😁
 
Выдача предмета должна рботать через Cached, в том же кабинете mmoweb это есть


PHP:
 static public function addItem(){


        $login = isset($GLOBALS["post"]["login"]) ? F::filtr($GLOBALS["post"]["login"]) : exit;
        $char_id = isset($GLOBALS["post"]["char_id"]) ? intval($GLOBALS["post"]["char_id"]) : exit;
        $item_id = isset($GLOBALS["post"]["item_id"]) ? intval($GLOBALS["post"]["item_id"]) : exit;
        $amount = isset($GLOBALS["post"]["amount"]) ? intval($GLOBALS["post"]["amount"]) : exit;
        $enchant = isset($GLOBALS["post"]["enchant"]) ? intval($GLOBALS["post"]["enchant"]) : 0;

        if($enchant > 20)
            exit;


        if (user::checkChar($login, $char_id)) {


            if (!Cached::factory()->send("CheckCharacter", (int)$char_id)) {
                Cached::factory()->send("KickCharacter", (int)$char_id);

                Cached::factory()->send("AddItem2", (int)$char_id, (int)0, (int)$item_id, (int)$amount, (int)$enchant, (int)0, (int)0, (int)0, (int)0, (int)0);

                api::send(array('ok' => 'ok'));
            } else
                api::send(array('error' => '1'));

        } else
            api::send(array('error' => '2'));


    }
}
 
Ну так, тут уже экстендер от Vanganth, нужно лишь реализовать, что бы выдавало предмет персонажу. т.е писать код к нему и перекомпилировать.
Погуглил полистал, ничего не нашел, в моей сборке исходников нет никаких, состряпал вот такой
Python:
import socket
import struct
import time
class CacheD:
    def __init__(self, cached_ip, cached_port, webadmin='Admin'):
        self.cached_ip = cached_ip
        self.cached_port = cached_port
        self.webadmin = webadmin
        self.connected = False
        self.fsockerror = False
        self.socketerrors = {
            "1": True,
            "01": False,
            "02": False,
            "03": False,
            "04": False,
            "05": False,
            "06": False,
            "07": False,
            "08": False,
            "09": False,
            "010": False,
            "011": False,
            "012": False,
            "013": False,
            "014": False,
            "015": False,
            "016": False,
            "017": False,
            "018": False,
            "019": False,
            "020": False,
            "021": False,
            "022": False,
            "023": False,
            "024": False,
            "025": False,
            "026": False
        }
    def tounicode(self, string):
        rs = ""
        for char in string:
            rs += char + '\x00'
        rs += '\x00\x00'
        return rs.encode('utf-16le')
    def CacheDInteractive(self, buf):
        try:
            with socket.create_connection((self.cached_ip, self.cached_port),
                                          timeout=5) as sock:
                self.connected = True
                packet_length = struct.pack("<h", len(buf) + 2)
                packet = packet_length + buf
                sock.sendall(packet)
                length_data = sock.recv(2)
                length = struct.unpack("<h", length_data)[0]
                response_id_data = sock.recv(1)
                response_id = struct.unpack("<b", response_id_data)[0]
                remaining_length = length - 3
                response_data = sock.recv(remaining_length)
                rs = ''
                for i in range(0, len(response_data), 4):
                    read_data = response_data[i:i + 4]
                    if len(read_data) < 4:
                        break
                    read = struct.unpack("<i", read_data)[0]
                    rs += str(read)
                result = self.socketerrors.get(rs, False)
                return result
        except socket.error as e:
            self.connected = False
            return self.fsockerror
    def AddItem2Packet(self, char_id, warehouse, item_type, q, enchant, eroded,
                       bless, wished):
        bless = 0
        q_h = int(q / 0x100000000)
        if q_h < 0:
            q_h = 0
        else:
            q = q - (q_h * 0x100000000)
        buf = struct.pack("B", 55)
        buf += struct.pack("I", char_id)
        buf += struct.pack("I", warehouse)
        buf += struct.pack("I", item_type)
        buf += struct.pack("I", q)
        buf += struct.pack("I", q_h)
        buf += struct.pack("I", enchant)
        buf += struct.pack("I", eroded)
        buf += struct.pack("I", bless)
        buf += struct.pack("I", wished)
        buf += struct.pack("I", 0)
        buf += struct.pack("I", 0)
        buf += struct.pack("I", 0)
        buf += struct.pack("I", 0)
        buf += struct.pack("I", 0)
        buf += struct.pack("I", 0)
        buf += struct.pack("I", 0)
        buf += struct.pack("I", 0)
        buf += struct.pack("I", 0)
        buf += self.tounicode(self.webadmin)
        return self.CacheDInteractive(buf)
    def CheckCharacterPacket(self, char_id):
        buf = struct.pack("<B", 1) + struct.pack(
            "<I", char_id) + self.tounicode(self.webadmin)
        return self.CacheDInteractive(buf)
    def KickCharacterPacket(self, char_id):
        buf = struct.pack("<B", 5) + struct.pack(
            "<I", char_id) + self.tounicode(self.webadmin)
        return self.CacheDInteractive(buf)

if __name__ == "__main__":
    cached_ip = '127.0.0.1'
    cached_port = 2012
    char_id = 5
    item_id = 57
    cacheD = CacheD(cached_ip, cached_port)
    if cacheD.CheckCharacterPacket(char_id) == True:
        cacheD.KickCharacterPacket(char_id)
        time.sleep(1)
        cacheD.AddItem2Packet(char_id, 0, item_id, 1000, 0, 0, 0, 0)
    else:
        cacheD.AddItem2Packet(char_id, 0, item_id, 1000, 0, 0, 0, 0)
Мало ли пригодится кому.
 
Чего нету? Им уж как лет 8

Screenshot_20240701-211011.jpg
 
Последнее редактирование модератором:
Назад
Сверху Снизу