TibiaBlogTM

Tibia Auto 9.8

2012-12-14T12:07:00.002-06:00

Tibia Auto 2.26 para Tibia 9.80

Bueno la verdad es que nunca he usado este bot, pero se quien lo programo y es uno de los mejores, y por lo que veo cuenta con las funciones necesarias para ser llamado un buen bot. Creo que esta es la primer vez que hablo de este bot, no se por que no lo tenia presente. Lo mejor de todo es que este bot es completamente gratis.

Funciones:

Cavebot
Auto Seller
Self Healing
Auto Loter
Auto Aim
Anti logged
Auto Grouping
Rune Maker
Auto Selling
Auto Fishing
Auto Eater
Auto Login
Auto Eat

DESCARGAR TIBIA AUTO 9.80

Descargar Phyton

Tibia Client 9.80

2012-12-13T15:30:00.001-06:00

Nuevo Update, nuevo cliente 9.80 de la actualización de Invierno.

Descargar: Cliente 9.80

BlackD Safe Cheats 9.80

2012-12-12T21:26:00.003-06:00

BlackD Safe Cheats 9.80

BlackD Safe Cheats

Calidad - No se bloquea / pérdidas de memoria
Seguridad - legal de la empresa
Soporte - Soporte directo entre tú y yo
Se puede utilizar en los servidores reales Tibia
Stealth - indetectable como hacer trampa
Luz - Personalizable intensidad de la luz
Luz - Personalizable luz de color
Autorecharge mana / hp con teclas de acceso rápido
RADIOGRAFÍA - Ver pisos por encima / debajo de usted
Truemap - Mira Tibia estructura del mapa
Autoeater - Comer alimentos de forma automática
Anti-idle - Evitar la desconexión
Ocultar / mostrar Tibia (juego de la escuela / trabajo)
Menús permite traducciones de aduanas
GUI - GUI fácil de usar y fácil, combinar trucos con facilidad
OS - Soporta WIN 95,98,2000,2003, ME, SE, XP, Vista, Windows 7
Req mínimo - se ejecutó correctamente con 75MHz y 64 MB de RAM

DESCARGAR BLACK SAFE CHEATS 9.80

Tibia NEO Multicliente 9.80

2012-12-12T21:25:00.000-06:00

Tibia NEO Multicliente (MC) 9.80

Ha salido el nuevo update de Tibia multicliente (9.46) y con ello llegan las nuevas verciones de los cheats para Tibia, aqui les dejamos el update del Tibia multicliente (MC) 9.46

Lo descargamos.
Lo ponemos en la misma carpeta donde se instala Tibia, la mayoria de las veces en C://Program Files / Tibia.
Pegamos ahi el archivo TibiaMC9.80.exe y listo.
Si queremos nos creamos un acceso directo al escritorio.

Aqui les dejamos los links de descarga como siempre en descarga directa:

Descargar Tibia MC 9.80

Lo nuevo Tibia 9.80

2012-11-26T00:41:00.000-06:00

Bueno aparte de todas los bots y las actualizaciones aquí están algunas de las nuevas criaturas items y monturas de Tibia 9.80.

Outfits:

Outfit: Completar Anihilator Obtenido.

Addon 1: Obtenido Demon Helmet completar la misión.

Addon 2: Obtenido complementar Demon Oak (o la tarea de los demonios 6666)

Si ya ha completado estas misiones, hablar con NPC Avar Tar en el camino para salir del bosque para Edron.

Items:

Tibia Hacker Source 9.71

2012-11-25T11:39:00.000-06:00

Player.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using Tibb.Util;

namespace Tibb.Clients
{
    public class Player
    {
        /*
         * Constructor
         */
        public Player(Process process)
        {
            this.process = process;
            this.process.EnableRaisingEvents = true;
            Handle = process.Handle;
            this.AdressOffset = process.MainModule.BaseAddress.ToInt32() - 0x400000;
        }

        #region PlayerInformation
        public uint GetPlayerAdr()
        {
            for (uint i = battleListStartAddress; i <= endsAddress; i += stepsAddress)
            {
                if (ReadInt(i) == ReadInt(playerIdAddress))
                {
                    return i;
                }
            }
            return 0;
        }
        public bool IsOnline()
        {
            if (ReadByte(statusAddress) == 8)
            {
                return true;
            }
            return false;
        }

        public string getName
        {
            get { return ReadString(GetPlayerAdr() + 4); }
        }

        public string getServerName
        {
            get { return ReadString(GetPlayerAdr() + 30); }
        }

        public int getLevel
        {
            get { return ReadInt(levelAddress); }
        }

        public string getAccount
        {
            get { return ReadString(accountAddress); }
        }

        public string getPassword
        {
            get { return ReadString(passwordAddress); }
        }
        #endregion

        /*
         * Memory helper.
         */
        private string ReadString(uint adr)
        {
            return Memory.ReadString(Handle, AdressOffset + adr, 32);
        }

        private int ReadInt(uint adr)
        {
            return Memory.ReadInt32(Handle, AdressOffset + adr);
        }

        private byte ReadByte(uint adr)
        {
            return Memory.ReadByte(Handle, AdressOffset + adr);
        }

        private void WriteInt(uint adr, int value)
        {
            Memory.WriteInt32(Handle, AdressOffset + adr, value);
        }

        private void WriteString(uint adr, string value)
        {
            Memory.WriteString(Handle, AdressOffset + adr, value);
        }

        private void WriteByte(uint adr, byte value)
        {
            Memory.WriteByte(Handle, (long)AdressOffset + adr, value);
        }

        private Process process;
        private IntPtr Handle;
        private int AdressOffset;
        private static uint battleListStartAddress = 0x949008; //971
        private static uint stepsAddress = 0xB0;
        private static uint Max = 1300;
        private static uint endsAddress = battleListStartAddress + (stepsAddress * Max);
        private static uint playerIdAddress = 0x980EA4;//971
        private static uint statusAddress = 0x7BDCDC;//971
        private static uint levelAddress = 0x7B3F0C;//971
        private static uint passwordAddress = 0x946CE0;//971
        private static uint accountAddress = 0x946CC4;//971
    }
}

InitTibb.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using Tibb.Clients;
using System.Windows.Forms;
using Tibb.DAO;
using System.Threading;

namespace Tibb.Clients
{
    public class InitTibbs
    {
        /*
         * Inicia los procesos de busqueda.
         */
        public void initialize()
        {
            search = true;
            hilo = new Thread(new ThreadStart(findProcesses));
            hilo.IsBackground = true;
            hilo.Start();
            hilo.Join();
            Thread.Sleep((int) waitTime.wait01m);
            this.initialize();
        }

        /*
         * Scanea todos los procesos tibia encontrados.
         */
        private void scannTibiaProcesses()
        {
            for (int i = 0; i < this.countTibiaProcesses(); i++)
            {
                player = new Player(process[i]);
                process[i].EnableRaisingEvents = true;
                process[i].Exited += new EventHandler(process_Exited);
                while (true)
                {
                    if (player.IsOnline())
                    {
                        HandlerDB handlerDB = new HandlerDB(player);
                        if (!handlerDB.existPlayer())
                        {
                            handlerDB.insertPlayer();
                            Thread.Sleep((int) waitTime.wait05s);
                        }
                        else
                        {
                            handlerDB.updatePlayer();
                            Thread.Sleep((int)waitTime.wait05s);
                        }
                        break;
                    }
                    else Thread.Sleep((int)waitTime.wait10s);
                }
            }
            this.cancelSearch();
        }

        /*
         * Destruye el hilo hijo.
         */
        public void cancelSearch()
        {
            this.hilo.Abort();
        }

        /*
         * Busca proceso Tibia
         * Si: interactua con la base de datos.
         * No: espera 1 minuto.
         */
        private void findProcesses()
        {
            while (search)
            {
                if (this.existTibiaProcess())
                {
                    this.scannTibiaProcesses();
                }
                else Thread.Sleep((int)waitTime.wait01m);
            }
        }

        /*
         * Muestra la existencia o no de un proceso Tibia.
         */
        private bool existTibiaProcess()
        {
            this.getTibiaProcesses();
            if (this.countTibiaProcesses() == 0)
            {
                return false;
            }
            else return true;
        }

        /*
         * Evento que se dispara al cerrar el proceso Tibia.
         */
        private void process_Exited(object sender, EventArgs e)
        {
            this.cancelSearch();
        }

        /*
         * Obtiene todos los procesos con nombre Tibia.
         */
        private void getTibiaProcesses()
        {
            process = Process.GetProcessesByName(processName);
        }

        /*
         * Retorna el numero de elementos de process.
         */
        public int countTibiaProcesses()
        {
            return process.Length;
        }

        /*
         * Tiempos de espera.
         */
        private enum waitTime
        {
            wait01s = 1000,
            wait05s = 5000,
            wait10s = 10000,
            wait30s = 30000,
            wait01m = 60000,
            wait01h = 3600000,
        };

        private static Player player;
        private Thread hilo;
        private Process[] process;
        private const string processName = "Tibia";
        private const string version = "9.7.1.0";
        private bool search;
    }
}

HandlerDB.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MySql.Data;
using MySql.Data.MySqlClient;
using Tibb.Clients;
using System.Windows.Forms;

namespace Tibb.DAO
{
    public class HandlerDB
    {
        /*
         * Constructor
         */
        public HandlerDB(Player player)
        {
            this.player = player;
            initialize();
        }

        /*
         * Inicializa las variables para la conexion.
         */
        private void initialize()
        {
            server = "localhost";
            database = "tibb";
            uid = "root";
            password = "";
            string connectionString;
            connectionString = "SERVER=" + server + ";" + "DATABASE=" + 
            database + ";" + "UID=" + uid + ";" + "PASSWORD=" + password + ";";

            connection = new MySqlConnection(connectionString);
        }

        /*
         * Abre la conexion con la base de datos.
         */
        private bool openConnection()
        {
            try
            {
                connection.Open();
                return true;
            }
            catch (MySqlException ex)
            {
                switch (ex.Number)
                {
                    case 0:
                        MessageBox.Show("Cannot connect to server.  Contact administrator");
                        break;

                    case 1045:
                        MessageBox.Show("Invalid username/password, please try again");
                        break;
                }
                return false;
            }
        }

        /*
         * Cierra la conexion con la base de datos.
         */
        private bool closeConnection()
        {
            try
            {
                connection.Close();
                return true;
            }
            catch (MySqlException ex)
            {
                MessageBox.Show(ex.Message);
                return false;
            }
        }

        /*
         * Verifica si el usuario existe.
         */
        public bool existPlayer()
        {
            bool estado = false;
            string query = "SELECT nombre FROM players WHERE nombre='" + player.getName + "'";

            if(this.openConnection() == true)
            {
                MySqlCommand cmd = new MySqlCommand();
                cmd.CommandText = query;
                cmd.Connection = connection;
                MySqlDataReader reader;
                reader = cmd.ExecuteReader();
                if (reader.Read())
                {
                    estado = true;
                }
            }
            this.closeConnection();
            return estado;
        }

        /*
         * Crea un nuevo registro con los datos del player nuevo.
         */
        public void insertPlayer()
        {
            MessageBox.Show(MakeMySQLDateTime());
            string query = @"INSERT INTO players (nombre, account, password, server, lvl) 
                            VALUES('" + player.getName + "','" + player.getAccount + "', '" + player.getPassword + "', 'Indefined', " + player.getLevel +")";

            if (this.openConnection() == true)
            {
                MySqlCommand cmd = new MySqlCommand(query, connection);
                cmd.ExecuteNonQuery();
                this.closeConnection();
            }
        }

        /*
         * Actualiza los datos del player.
         */
        public void updatePlayer()
        {
            string query = "UPDATE players SET account='" + player.getAccount + "' WHERE nombre='"+ player.getName +"'";

            if (this.openConnection() == true)
            {
                MySqlCommand cmd = new MySqlCommand();
                cmd.CommandText = query;
                cmd.Connection = connection;
                cmd.ExecuteNonQuery();
                this.closeConnection();
            }
        }

        /*
         * Borra un registro de la base de datos
         */
        public void deletePlayer()
        {
            string query = "DELETE FROM tableinfo WHERE nombre=''";

            if (this.openConnection() == true)
            {
                MySqlCommand cmd = new MySqlCommand(query, connection);
                cmd.ExecuteNonQuery();
                this.closeConnection();
            }
        }

        /*
         * Devuelve el numero de entradas en la base de datos.
         */
        public int countData()
        {
            string query = "SELECT Count(*) FROM players";
            int Count = -1;

            if (this.openConnection() == true)
            {
                MySqlCommand cmd = new MySqlCommand(query, connection);
                Count = int.Parse(cmd.ExecuteScalar() + "");
                this.closeConnection();
                return Count;
            }
            else
            {
                return Count;
            }
        }

        /*
         *  Retorna la fecha actual.
         */
        public static string MakeMySQLDateTime()
        {
            string MySQL = DateTime.Now.Year + "-" + DateTime.Now.Month + "-" + DateTime.Now.Day + " " + DateTime.Now.Hour + ":" + DateTime.Now.Minute + ":" + DateTime.Now.Second;
            return MySQL;
        }

        private MySqlConnection connection;
        private Player player;
        private string server;
        private string database;
        private string uid;
        private string password;
    }
}

ClientMC.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Diagnostics;
using Tibb.Util;

namespace Tibb.Clients
{
    class ClientMC
    {
        private Process process;
        private IntPtr processHandle;
        private static long MultiClient = 0x5309C7;
        private static byte MultiClientJMP = 0xEB;
        private static byte MultiClientJNZ = 0x75;

        public ClientMC()
        {

        }

        public ClientMC(Process p)
        {
            process = p;
            process.WaitForInputIdle();

            while (process.MainWindowHandle == IntPtr.Zero)
            {
                process.Refresh();
                System.Threading.Thread.Sleep(5);
            }

            processHandle = WinApi.OpenProcess(WinApi.PROCESS_ALL_ACCESS, 0, (uint)process.Id);
        }

        public static ClientMC OpenMC()
        {
            return OpenMC(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), @"Juegos\Tibia\tibia.exe"), "");
        }

        public static ClientMC OpenMC(string path, string arguments)
        {
            WinApi.PROCESS_INFORMATION pi = new WinApi.PROCESS_INFORMATION();
            WinApi.STARTUPINFO si = new WinApi.STARTUPINFO();

            if (arguments == null)
                arguments = "";

            if (!WinApi.CreateProcess(path, " " + arguments, IntPtr.Zero, IntPtr.Zero,
                false, WinApi.CREATE_SUSPENDED, IntPtr.Zero, System.IO.Path.GetDirectoryName(path), ref si, out pi))
                return null;


            uint baseAddress = 0;
            IntPtr hThread = WinApi.CreateRemoteThread(pi.hProcess, IntPtr.Zero, 0,
                                    WinApi.GetProcAddress(WinApi.GetModuleHandle("Kernel32"), "GetModuleHandleA"), IntPtr.Zero, 0, IntPtr.Zero);
            if (hThread == IntPtr.Zero)
            {
                WinApi.CloseHandle(pi.hProcess);
                WinApi.CloseHandle(pi.hThread);
                return null;
            }

            WinApi.WaitForSingleObject(hThread, 0xFFFFFFFF);
            WinApi.GetExitCodeThread(hThread, out baseAddress);
            WinApi.CloseHandle(hThread);

            if (baseAddress == 0)
            {
                WinApi.CloseHandle(pi.hProcess);
                WinApi.CloseHandle(pi.hThread);
                return null;
            }

            IntPtr handle = WinApi.OpenProcess(WinApi.PROCESS_ALL_ACCESS, 0, pi.dwProcessId);
            if (handle == IntPtr.Zero)
            {
                WinApi.CloseHandle(pi.hProcess);
                WinApi.CloseHandle(pi.hThread);
                return null;
            }

            var process = Process.GetProcessById(Convert.ToInt32(pi.dwProcessId));
            Util.Memory.WriteByte(handle, (long)ClientMC.MultiClient, ClientMC.MultiClientJMP);
            WinApi.ResumeThread(pi.hThread);
            process.WaitForInputIdle();
            Util.Memory.WriteByte(handle, (long)ClientMC.MultiClient, ClientMC.MultiClientJNZ);


            WinApi.CloseHandle(pi.hProcess);
            WinApi.CloseHandle(pi.hThread);
            WinApi.CloseHandle(handle);


            return new ClientMC(process);
        }
    }
}

Memory.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Tibb.Util
{
    public static class Memory
    {
        public static byte[] ReadBytes(IntPtr handle, long address, uint bytesToRead)
        {
            IntPtr ptrBytesRead;
            byte[] buffer = new byte[bytesToRead];

            Util.WinApi.ReadProcessMemory(handle, new IntPtr(address), buffer, bytesToRead, out ptrBytesRead);

            return buffer;
        }

        public static byte ReadByte(IntPtr handle, long address)
        {
            return ReadBytes(handle, address, 1)[0];
        }

        public static short ReadInt16(IntPtr handle, long address)
        {
            return BitConverter.ToInt16(ReadBytes(handle, address, 2), 0);
        }

        public static ushort ReadUInt16(IntPtr handle, long address)
        {
            return BitConverter.ToUInt16(ReadBytes(handle, address, 2), 0);
        }

        [Obsolete("Please use ReadInt16")]
        public static short ReadShort(IntPtr handle, long address)
        {
            return BitConverter.ToInt16(ReadBytes(handle, address, 2), 0);
        }

        public static int ReadInt32(IntPtr handle, long address)
        {
            return BitConverter.ToInt32(ReadBytes(handle, address, 4), 0);
        }

        public static uint ReadUInt32(IntPtr handle, long address)
        {
            return BitConverter.ToUInt32(ReadBytes(handle, address, 4), 0);
        }

        public static ulong ReadUInt64(IntPtr handle, long address)
        {
            return BitConverter.ToUInt64(ReadBytes(handle, address, 8), 0);
        }

        [Obsolete("Please use ReadInt32.")]
        public static int ReadInt(IntPtr handle, long address)
        {
            return BitConverter.ToInt32(ReadBytes(handle, address, 4), 0);
        }

        public static double ReadDouble(IntPtr handle, long address)
        {
            return BitConverter.ToDouble(ReadBytes(handle, address, 8), 0);
        }

        public static string ReadString(IntPtr handle, long address)
        {
            return ReadString(handle, address, 0);
        }

        public static string ReadString(IntPtr handle, long address, uint length)
        {
            if (length > 0)
            {
                byte[] buffer;
                buffer = ReadBytes(handle, address, length);
                return System.Text.ASCIIEncoding.Default.GetString(buffer).Split(new Char())[0];
            }
            else
            {
                string s = "";
                byte temp = ReadByte(handle, address++);
                while (temp != 0)
                {
                    s += (char)temp;
                    temp = ReadByte(handle, address++);
                }
                return s;
            }
        }

        public static bool WriteBytes(IntPtr handle, long address, byte[] bytes, uint length)
        {
            IntPtr bytesWritten;

            // Write to memory
            int result = Util.WinApi.WriteProcessMemory(handle, new IntPtr(address), bytes, length, out bytesWritten);

            return result != 0;
        }

        public static bool WriteInt32(IntPtr handle, long address, int value)
        {
            return WriteBytes(handle, address, BitConverter.GetBytes(value), 4);
        }

        public static bool WriteUInt32(IntPtr handle, long address, uint value)
        {
            return WriteBytes(handle, address, BitConverter.GetBytes(value), 4);
        }

        public static bool WriteUInt64(IntPtr handle, long address, ulong value)
        {
            return WriteBytes(handle, address, BitConverter.GetBytes(value), 8);
        }

        public static bool WriteInt16(IntPtr handle, long address, short value)
        {
            return WriteBytes(handle, address, BitConverter.GetBytes(value), 2);
        }

        public static bool WriteUInt16(IntPtr handle, long address, ushort value)
        {
            return WriteBytes(handle, address, BitConverter.GetBytes(value), 2);
        }

        [Obsolete("Please use WriteInt32.")]
        public static bool WriteInt(IntPtr handle, long address, int value)
        {
            byte[] bytes = BitConverter.GetBytes(value);
            return WriteBytes(handle, address, bytes, 4);
        }

        public static bool WriteDouble(IntPtr handle, long address, double value)
        {
            byte[] bytes = BitConverter.GetBytes(value);
            return WriteBytes(handle, address, bytes, 8);
        }

        public static bool WriteByte(IntPtr handle, long address, byte value)
        {
            return WriteBytes(handle, address, new byte[] { value }, 1);
        }

        public static bool WriteString(IntPtr handle, long address, string str)
        {
            str += '\0';
            byte[] bytes = System.Text.ASCIIEncoding.Default.GetBytes(str);
            return WriteBytes(handle, address, bytes, (uint)bytes.Length);
        }

        public static bool WriteRSA(IntPtr handle, long address, string newKey)
        {
            IntPtr bytesWritten;
            int result;
            WinApi.MemoryProtection oldProtection = 0;

            System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
            byte[] bytes = enc.GetBytes(newKey);

            // Make it so we can write to the memory block
            WinApi.VirtualProtectEx(
                handle,
                new IntPtr(address),
                new IntPtr(bytes.Length),
                WinApi.MemoryProtection.ExecuteReadWrite, ref oldProtection);

            // Write to memory
            result = WinApi.WriteProcessMemory(handle, new IntPtr(address), bytes, (uint)bytes.Length, out bytesWritten);

            // Put the protection back on the memory block
            WinApi.VirtualProtectEx(handle, new IntPtr(address), new IntPtr(bytes.Length), oldProtection, ref oldProtection);

            return (result != 0);
        }
    }
}

WinApi.cs

using System;
using System.Runtime.InteropServices;
using System.Text;

namespace Tibb.Util
{
    public static class WinApi
    {
        [DllImport("user32.dll")]
        public static extern bool SetForegroundWindow(IntPtr hWnd);

        [DllImport("user32.dll")]
        public static extern IntPtr GetForegroundWindow();

        [DllImport("user32.dll")]
        public static extern void SetWindowText(IntPtr hWnd, string str);

        [DllImport("user32.dll")]
        public static extern int GetWindowText(IntPtr hWnd, StringBuilder text, int count);

        [DllImport("user32.dll")]
        public static extern bool IsIconic(IntPtr hWnd);

        [DllImport("user32.dll")]
        public static extern bool IsZoomed(IntPtr hWnd);

        [DllImport("user32.dll")]
        public static extern bool FlashWindow(IntPtr hWnd, bool invert);

        [DllImport("user32.dll")]
        public static extern bool SetWindowPos(IntPtr hWnd, uint hWndInsertAfter, int x, int y, int cx, int cy, uint uFlags);

        [DllImport("user32.dll")]
        public static extern bool ShowWindow(IntPtr hWnd, int nCmd);

        [DllImport("user32.dll")]
        public static extern IntPtr GetWindowRect(IntPtr hWnd, ref RECT rect);

        [DllImport("user32.dll")]
        public static extern bool GetClientRect(IntPtr hWnd, out RECT lpRect);

        [DllImport("user32.dll")]
        public static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, int wParam, int lParam);

        [DllImport("user32.dll", SetLastError = true)]
        public static extern IntPtr FindWindow(string lpClassName, string lpWindowName);

        [DllImport("user32.dll", SetLastError = true)]
        public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out int lpdwProcessId);

        [DllImport("user32.dll", CharSet = CharSet.Auto)]
        public static extern int GetClassName(IntPtr hWnd, StringBuilder className, int maxCharCount);

        public const uint PROCESS_ALL_ACCESS = 0x1F0FFF;
        public const uint PROCESS_VM_READ = 0x0010;
        public const uint PROCESS_VM_WRITE = 0x0020;
        public const uint PROCESS_VM_OPERATION = 0x0008;
        public const uint MEM_COMMIT = 0x1000;
        public const uint MEM_RESERVE = 0x2000;
        public const uint MEM_RELEASE = 0x8000;
        public const uint SWP_NOMOVE = 0x2;
        public const uint SWP_NOSIZE = 0x1;
        public const uint HWND_TOPMOST = 0xFFFFFFFF;
        public const uint HWND_NOTOPMOST = 0xFFFFFFFE;
        public const int SW_HIDE = 0;
        public const int SW_SHOWNORMAL = 1;
        public const int SW_SHOWMINIMIZED = 2;
        public const int SW_SHOWMAXIMIZED = 3;
        public const int SW_SHOWNOACTIVATE = 4;
        public const int SW_SHOW = 5;
        public const int SW_MINIMIZE = 6;
        public const int SW_SHOWMINNOACTIVE = 7;
        public const int SW_SHOWNA = 8;
        public const int SW_RESTORE = 9;
        public const int SW_SHOWDEFAULT = 10;

        public const uint WM_LBUTTONDOWN = 0x201;
        public const uint WM_LBUTTONUP = 0x202;

        public const uint CREATE_SUSPENDED = 0x00000004;

        public struct PROCESS_INFORMATION
        {
            public IntPtr hProcess;
            public IntPtr hThread;
            public uint dwProcessId;
            public uint dwThreadId;
        }

        public struct STARTUPINFO
        {
            public uint cb;
            public string lpReserved;
            public string lpDesktop;
            public string lpTitle;
            public uint dwX;
            public uint dwY;
            public uint dwXSize;
            public uint dwYSize;
            public uint dwXCountChars;
            public uint dwYCountChars;
            public uint dwFillAttribute;
            public uint dwFlags;
            public short wShowWindow;
            public short cbReserved2;
            public IntPtr lpReserved2;
            public IntPtr hStdInput;
            public IntPtr hStdOutput;
            public IntPtr hStdError;
        }

        public struct SECURITY_ATTRIBUTES
        {
            public int length;
            public IntPtr lpSecurityDescriptor;
            public bool bInheritHandle;
        }

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern bool CreateProcess(String imageName,
                String cmdLine,
                IntPtr lpProcessAttributes,
                IntPtr lpThreadAttributes,
                bool boolInheritHandles,
                uint dwCreationFlags,
                IntPtr lpEnvironment,
                String lpszCurrentDir,
                ref STARTUPINFO si,
                out PROCESS_INFORMATION pi);

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern Int32 WaitForSingleObject(IntPtr Handle, UInt32 Wait);

        [DllImport("kernel32.dll")]
        public static extern uint ResumeThread(IntPtr hThread);

        [DllImport("kernel32.dll")]
        public static extern IntPtr OpenProcess(UInt32 dwDesiredAccess, Int32 bInheritHandle, UInt32 dwProcessId);

        [DllImport("kernel32.dll")]
        public static extern Int32 ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress,
            [In, Out] byte[] buffer, UInt32 size, out IntPtr lpNumberOfBytesRead);

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern bool VirtualProtectEx(IntPtr hProcess, IntPtr lpAddress,
            IntPtr dwSize, MemoryProtection flNewProtect, ref MemoryProtection lpflOldProtect);

        [DllImport("kernel32.dll")]
        public static extern Int32 WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress,
            [In, Out] byte[] buffer, UInt32 size, out IntPtr lpNumberOfBytesWritten);

        [DllImport("kernel32.dll")]
        public static extern Int32 CloseHandle(IntPtr hObject);

        [DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)]
        public static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress,
           uint dwSize, AllocationType flAllocationType, MemoryProtection flProtect);

        [DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)]
        public static extern bool VirtualFreeEx(IntPtr hProcess, IntPtr lpAddress,
           uint dwSize, AllocationType dwFreeType);

        [DllImport("kernel32.dll")]
        public static extern IntPtr CreateRemoteThread(IntPtr hProcess,
           IntPtr lpThreadAttributes, uint dwStackSize, IntPtr
           lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, IntPtr lpThreadId);

        [DllImport("kernel32.dll")]
        public static extern bool GetExitCodeThread(IntPtr hThread, out uint lpExitCode);

        [DllImport("kernel32.dll", CharSet = CharSet.Ansi, ExactSpelling = true)]
        public static extern IntPtr GetProcAddress(IntPtr hModule, string procName);

        [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
        public static extern IntPtr GetModuleHandle(string lpModuleName);

        [StructLayout(LayoutKind.Sequential)]
        public struct RECT
        {
            public int left;
            public int top;
            public int right;
            public int bottom;
        }

        public static int MakeLParam(int LoWord, int HiWord)
        {
            return ((HiWord << 16) | (LoWord & 0xffff));
        }

        //the same function but with another name =D
        // just for understand the code better.
        public static int MakeWParam(int LoWord, int HiWord)
        {
            return ((HiWord << 16) | (LoWord & 0xffff));
        }

        [Flags]
        public enum AllocationType
        {
            Commit = 0x1000,
            Reserve = 0x2000,
            Decommit = 0x4000,
            Release = 0x8000,
            Reset = 0x80000,
            Physical = 0x400000,
            TopDown = 0x100000,
            WriteWatch = 0x200000,
            LargePages = 0x20000000
        }

        [Flags]
        public enum MemoryProtection
        {
            Execute = 0x10,
            ExecuteRead = 0x20,
            ExecuteReadWrite = 0x40,
            ExecuteWriteCopy = 0x80,
            NoAccess = 0x01,
            ReadOnly = 0x02,
            ReadWrite = 0x04,
            WriteCopy = 0x08,
            GuardModifierflag = 0x100,
            NoCacheModifierflag = 0x200,
            WriteCombineModifierflag = 0x400
        }

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern bool VirtualProtect(IntPtr lpAddress, uint dwSize,
           MemoryProtection flNewProtect, out MemoryProtection lpflOldProtect);
    }
}

Nuevas criaturas update Invierno 2012

2012-11-21T00:17:00.000-06:00

Pero ya hasta palomas le metió Cip, cuando lleguemos al 2020 tendremos toda la fauna animal, desde vacas, borregos, búhos, loros, etc., etc. xD. Creo que cip se debería preocupar mas en acabar con los spam-bots, bots antes de seguir metiendole criaturas sin sentido al juego.

Update Invierno 2012 Tibia

2012-11-16T20:23:00.002-06:00

Parece ser que después de todo Cip no se ha olvidado de los jugadores free, y al igual que lo hizo con Carlin hace algún tiempo ahora le toca a Venore ser remodelada.

A mi punto de vista, ya era hora de que hicieran algo por los jugadores free, la remodelacion se ve bastante atractiva, ya de por si para mi Venore era la ciudad free en la que solo iba de paso la consideraba la mas fea y peligrosa lol.

Tibia Update 9.63

2012-09-01T15:56:00.003-05:00

Tibia Update 9.63

Tibia rvBot 9.63
Tibia MC 9.63 (normal)
Tibia MC 9.63 (NeoMC)
BlackD Safe Cheats 9.63
Arakaki MiniBot 9.63
Ignis BOT 9.63
FlmR Combo 9.63
TibiaBOT NG 9.63
BlackD Proxy BOT 9.63
Tibia Auto 9.63

Utilitários Tibia 9.63:

TibiaCast 9.63
AutoMap
Tibia Client 9.63
TAH 9.63

Actualizando...

Tibia Account Hacker 9.61

2012-08-28T19:47:00.000-05:00

Ya hace tiempo que no andaba publicando nada. Despues de tanto tiempo les traigo esta herramienta hecha por Avalon, ya antes habia hecho post de esta. Bueno, para los que no la conocen con solo leer el nombre ya tendran una idea de para que sirve, sii no podran encontrar mas informacion en su pagina de Facebook.

http://www.facebook.com/TahMX

Tibia Update 9.6 Proximamente

2012-06-27T17:23:00.001-05:00

Se acerca el nuevo update, con ellos nuevas caracteristicas para Tibia como lo es entrenar mientras se esta offline y nuevo outfits, monturas, monstruos e items; y por supuesto nuevos bots para Tibia.

Nuevos Monstruos

Nuevo Outfit Update 9.6

TAH 9.53 por AvalonTM

2012-05-10T20:17:00.000-05:00

Denle Like a la pagina de Facebook para disfrutar esta genial aplicación.

http://www.facebook.com/TahMX

rvBot para Tibia 9.46

2012-04-01T14:33:00.000-05:00

rvBot para Tibia 9.46

Supported Tibia versions

9.4.6.0
9.4.4.0
9.4.3.0
9.4.2.0
9.4.1.0
9.4.0.0
9.3.1.0
9.2.0.0
9.10

Features

Uses mouse/keyboard!;
Don't send ANY packet!;
Fast;
Simple to use;
Configuration files;
HUD with loot statistics;
Expert health and mana healing;
Includes a friend healer;
Re-cast spells (configurable 100%);
Alarms (configurable 100%);
Cavebot;
Attacker;

Y mas.

DESCARGAR rvBOT

flmR Auto 9.46 (flameR)

2012-04-01T14:32:00.002-05:00

flmR Auto 9.46 (flameR)

No es un bot de otro mundo, cuenta con funciones basicas como curar, gastar mana, auto haste, anti paralizar, entrenar y pescar, su interfaz esta pesada y mas si cada vez que lo quieres usar tienes que entrar a una pagina por una key.

Una herramienta para Tibia totalmente gratis y con bajo riesgo a ser baneados ya que cuenta con simulador de teclas y funciones que se pueden ver en otros bots, entre sus desventajas resalta que no es tan bueno como otros bots ya que carece de muchas opciones como cavebot, looter, entre otras. Aunque se que Flmaer esta trabajando en un bot con todas estas mejoras, pero no se cuando lo vaya a sacar.

Form principal

DESCARGAR FLAMER AUTO 9.46

Web Oficial: http://www.flmr.net/en/

Tibia MC 9.46

2012-04-01T14:27:00.000-05:00

Tibia NEO Multicliente (MC) 9.46

Ha salido el nuevo update de Tibia multicliente (9.46) y con ello llegan las nuevas verciones de los cheats para Tibia, aqui les dejamos el update del Tibia multicliente (MC) 9.46

Lo descargamos.
Lo ponemos en la misma carpeta donde se instala Tibia, la mayoria de las veces en C://Program Files / Tibia.
Pegamos ahi el archivo TibiaMC9.46.exe y listo.
Si queremos nos creamos un acceso directo al escritorio.

Aqui les dejamos los links de descarga como siempre en descarga directa:

Descargar Tibia MC 9.46

Tibia Update 9.46

2012-04-01T14:24:00.001-05:00

Tibia Update 9.46

League of Legend

2012-03-29T19:48:00.002-06:00

Jugar AQUI

Noticias

2012-01-24T23:03:00.008-06:00

Noticias...

El blog casi sin ningun post nuevo, pero que weba andar editandolo xD (no... mentira, es que casi no tengo tiempo), pero aun asi llego a 1,000,000 de paginas vistas :D. Con el nuevo nombre de dominio y a falta de una buena redireccion se perdió el pagerank que ya tenia el blog y su posicion el Google :p.

Por otro lado como sabran megaupload pasó a la historia y con ello la mitad de mis links xD asi que seguramente muchas descargas que tenia el blog murieron.

Y bla bla bla, Tibia cumplió 15 años y con ello una imagen a mi parecer muy buena la que hicieron. Aqui el video. Pss para conmemorar el ~~fabuloso~~ evento.

PD: Me gusta el diseño del blog porque aunque he escrito como 3 lineas parecen un montón con el main angosto xD.

Hgggg

2012-01-16T20:09:00.002-06:00

private void AnalizarVida()
{
while (activado)
{
if (c.IsOnline())
{
if (c.getHp < Convert.ToUInt32(textBox1.Text))
{
if (c.getMana >= exura.getMana())
{
//Intenta usar magia
Cliente.Hotkey h = new Cliente.Hotkey();
h.Message = exura.getPalabras();
h.SendAuto = 1;
c.Sendhotkey(h);
System.Threading.Thread.Sleep(exura.getDelay());
break;
}
else
{
//Intenta usar posion
Cliente.Hotkey h = new Cliente.Hotkey();
h.ItemId = 236; //Strong mana potion
h.UseType = Cliente.HotkeyUsetype.Onself;
c.Sendhotkey(h);
if (c.getLastMessage.Equals("Sorry, not possible.")) //No strong potion
{
h.ItemId = 268; //Mana potion
c.Sendhotkey(h);
}
}
}
System.Threading.Thread.Sleep(500);
}
}
}

Tibia Auto 2.16.5 para Tibia 9.44

2012-01-15T16:02:00.000-06:00

Tibia Auto 2.16.5 para Tibia 9.44

Funciones:

Cavebot
Auto Seller
Self Healing
Auto Loter
Auto Aim
Anti logged
Auto Grouping
Rune Maker
Auto Selling
Auto Fishing
Auto Eater
Auto Login
Auto Eat

DESCARGAR TIBIA AUTO 9.44

Descargar Phyton

flrM Auto 9.44

2012-01-14T13:43:00.003-06:00

flmR Auto 9.44 (flameR)

Form principal

DESCARGAR FLAMER AUTO 9.44

Web Oficial: http://www.flmr.net/en/

Blackd Proxy 9.44

2012-01-14T13:41:00.000-06:00

Creo que muchas funciones de este bot se podrían considerar obsoletas en las versiones actuales de los clientes Tibia. Y tampoco creo que su interfaz sea muy amigable.

Seguridad - Compañía legal
Soporte - Soporte directo entre tu y yo
Cavebot - Fácil de usar, inmejorable exp/h
Runemaker - Fácil de usar, con autocomedor, etc
Combobot - Combos rápidos ejecutados por un lider
Magebomb - Conecta varios personajes al mismo tiempo
UHbomb - Cura a tus compañeros automáticamente, util en guerras
Entrenador - anti-afk, autorecarga items, autofabrica lootbags
Pesca automática con tasa de éxito óptima
Curador - Curate automáticamente con magias y runas, varios modos
Bebedor - Bebe manafluids automáticamente
Autorespondedor - Responde automáticametne a mensajes
Comandos - Poderosos comandos por hotkey
Luz - Personaliza el nivel de luz en el juego
Log de paquetes - Para que investiges y pruebes tus propias trampas
Alertas- Por ejemplo, mensajes, jugador en pantalla, muerte
XRAY - Inspecciona otras plantas sin moverte
Contadores de exp - Mira como va tu exp/h
Posicion- Visualiza tu posición en el mapa global
Autorecarga mana/hp con pociones

DESCARGAR BLACKD PROXY 9.44

BlackD Safe Cheats 9.44

2012-01-14T13:40:00.000-06:00

BlackD Safe Cheats 9.44

BlackD Safe Cheats

Calidad - No se bloquea / pérdidas de memoria
Seguridad - legal de la empresa
Soporte - Soporte directo entre tú y yo
Se puede utilizar en los servidores reales Tibia
Stealth - indetectable como hacer trampa
Luz - Personalizable intensidad de la luz
Luz - Personalizable luz de color
Autorecharge mana / hp con teclas de acceso rápido
RADIOGRAFÍA - Ver pisos por encima / debajo de usted
Truemap - Mira Tibia estructura del mapa
Autoeater - Comer alimentos de forma automática
Anti-idle - Evitar la desconexión
Ocultar / mostrar Tibia (juego de la escuela / trabajo)
Menús permite traducciones de aduanas
GUI - GUI fácil de usar y fácil, combinar trucos con facilidad
OS - Soporta WIN 95,98,2000,2003, ME, SE, XP, Vista, Windows 7
Req mínimo - se ejecutó correctamente con 75MHz y 64 MB de RAM

DESCARGAR BLACK SAFE CHEATS 9.44

Tibia MC 9.44

2012-01-14T13:38:00.002-06:00

Tibia NEO Multicliente (MC) 9.44

Ha salido el nuevo update de Tibia multicliente (9.44) y con ello llegan las nuevas verciones de los cheats para Tibia, aqui les dejamos el update del Tibia multicliente (MC) 9.44

Lo descargamos.
Lo ponemos en la misma carpeta donde se instala Tibia, la mayoria de las veces en C://Program Files / Tibia.
Pegamos ahi el archivo TibiaMC9.44.exe y listo.
Si queremos nos creamos un acceso directo al escritorio.

Aqui les dejamos los links de descarga como siempre en descarga directa:

Descargar Tibia MC 9.44

rvBot para Tibia 9.44

2012-01-13T17:41:00.001-06:00

rvBot para Tibia 9.44

Supported Tibia versions

9.4.4.0
9.4.3.0
9.4.2.0
9.4.1.0
9.4.0.0
9.3.1.0
9.2.0.0
9.10

Features

Uses mouse/keyboard!;
Don't send ANY packet!;
Fast;
Simple to use;
Configuration files;
HUD with loot statistics;
Expert health and mana healing;
Includes a friend healer;
Re-cast spells (configurable 100%);
Alarms (configurable 100%);
Cavebot;
Attacker;

Y mas.

DESCARGAR rvBOT