Xentales

#!/usr/bin/env python

import thread
from Queue import Queue
import socket
import sys
import time
from inc import *

# 64.34.166.5
host = '64.34.163.8'
port = 5050
account = 12345678 # Replace with account
password = 'password' # Replace with password
packet_queue = Queue()
character = ''
char_id = 0
loggedin = False

####################################
# FUNCTIONS                        #
####################################
def recv_handler( sock ):
   while( 1 ):
      try:
         d = sock.recvfrom( 1024 )
         reply = crypto.decrypt( d[0], len( d[0] ))
         addr = d[1]
         packet_handler( reply )
      except socket.error, msg:
         print 'Error code: ' + str( msg[0] ) + ' Message: ' + msg[1]


def send_handler( sock, host, port ):
   while 1:
      if( not packet_queue.empty() ):
         message = packet_queue.get()
         print 'Send: '
         print ':'.join( '{:02x}'.format(x) for x in message )
         sock.sendto( message, ( host, port ))
         packet_queue.task_done()


def packet_handler( packet ):
   packet = bytearray( packet )
   global character, char_id, loggedin
   print 'Recv:'
   print ':'.join( '{:02x}'.format(x) for x in packet )
   # Login
   if( packet[0] == 0x0F ):
      char_id = [ packet[2], packet[3] ]
      pos = 6
      while( packet[ pos ] != 0 ):
         character += chr( packet[ pos ] )
         pos += 1
   # Entering the world
   elif( packet[0] == 0x1F ):
      loggedin = True
   # Update packet
   elif( packet[0] == 0x03 ):
      handle_update( packet )


def queue_packet( packet ):
   packet = bytearray( packet )
   packet = crypto.encrypt( packet, len( packet ))
   packet_queue.put( packet )

def do_login( account, password ):
   # Define an empty login packet
   login = [0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xef,0x00,0x00,0x00,0x00,0x00]
   # Place the account number into the packet
   login[2] = ( account & 0xFF )
   login[3] = ( account >> 8 ) & 0xFF
   login[4] = ( account >> 16 ) & 0xFF
   login[5] = ( account >> 24 ) & 0xFF
   # Place the password into the packet
   pos = 10
   for x in password:
      login[ pos ] = ord( x )
      pos += 1
   # Add to the queue
   queue_packet( login )

def enter_world( charid, password ):
   enter = [0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00]
   # Place character id into packet
   enter[2] = charid[0]
   enter[3] = charid[1]
   # Place the password into the packet
   pos = 10
   for x in password:
      enter[ pos ] = ord( x )
      pos += 1
   # Add to queue
   queue_packet( enter )

def handle_update( packet ):
   #TODO: handle the packet duh
   print ''

####################################
# MAIN THREAD                      #
####################################

# Create the socket
try:
   xSock = socket.socket( socket.AF_INET, socket.SOCK_DGRAM )
except socket.error:
   print 'Failed to create socket'
   sys.exit()

# Create worker threads
try:
  thread.start_new_thread( recv_handler, ( xSock, ) )
  #rworker.deamon = True
 # rworker.start()

  thread.start_new_thread( send_handler, ( xSock, host, port, ) )
  #sworker.deamon = True
  #sworker.start()
except:
   print "Error: unable to start thread"


ping = "\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"

#while 1:
time.sleep( 1 )
queue_packet( ping )
time.sleep( 2 )
do_login( account, password )
time.sleep( 2 )
print character
print char_id
time.sleep( 2 )
enter_world( char_id, password )
time.sleep( 15 )

from random import randint

m_key = [
   0x0B, 0xB3, 0x49, 0x4C, 0xA7, 0x53, 0x44, 0x09, 0xAA, 0xE4, 0x0A, 0x8D, 0xD9, 0x5D, 0xC5, 0x28,
   0xDA, 0x25, 0x4F, 0x25, 0xA0, 0xE2, 0x67, 0x69, 0x61, 0x73, 0x84, 0xEA, 0x97, 0xE2, 0x41, 0xD5,
   0xB6, 0x28, 0xC6, 0x7D, 0x53, 0xD5, 0x73, 0x98, 0x12, 0x9F, 0x80, 0xB0, 0x5A, 0xA1, 0x29, 0xE7,
   0x5E, 0xD0, 0x2A, 0x7F, 0x09, 0xBF, 0xD6, 0x4B, 0x6B, 0x83, 0x01, 0xAA, 0x7B, 0x67, 0x1B, 0x0D,
   0xBC, 0x0E, 0x26, 0x2E, 0xD5, 0x8F, 0x7E, 0xCE, 0x33, 0xF2, 0x1C, 0xD8, 0xAD, 0x03, 0xB4, 0xFC,
   0x40, 0x8D, 0x0B, 0xD0, 0x78, 0x01, 0x60, 0x26, 0xBB, 0x38, 0x36, 0x52, 0x6C, 0xBD, 0x1E, 0x6F,
   0xD2, 0x92, 0xC4, 0x4B, 0xFA, 0x25, 0x30, 0xDE, 0x16, 0x98, 0xC0, 0xAA, 0x79, 0x56, 0x10, 0x61,
   0xA1, 0x39, 0x9E, 0x57, 0x23, 0xCC, 0xD5, 0x19, 0x2A, 0xA7, 0xF4, 0x2A, 0xE3, 0x9C, 0xF5, 0xCF,
   0x3D, 0xF0, 0x12, 0x6A, 0xDD, 0x01, 0x49, 0xD0, 0xCE, 0x02, 0x0A, 0x7D, 0x10, 0x2D, 0x47, 0x11,
   0x15, 0xD7, 0x54, 0xFA, 0x63, 0x07, 0xB3, 0x58, 0x1E, 0xA6, 0xB0, 0x14, 0x0E, 0xA1, 0x93, 0x28,
   0xFE, 0x12, 0x3C, 0x02, 0x94, 0x1E, 0xEE, 0xA7, 0xAF, 0xED, 0x63, 0xDE, 0x8A, 0x1D, 0xD6, 0xC1,
   0x68, 0x34, 0xBF, 0xC0, 0x1E, 0x7B, 0x2C, 0x31, 0x86, 0x49, 0xE9, 0xC0, 0xC5, 0x06, 0x8B, 0x9A,
   0x3A, 0xE2, 0x85, 0x36, 0x10, 0xAB, 0x8A, 0x47, 0x0D, 0xE6, 0xFC, 0x43, 0x8A, 0x57, 0x36, 0x33,
   0x21, 0x9A, 0x95, 0xDB, 0x16, 0x33, 0xA2, 0x75, 0x49, 0xD5, 0x4E, 0xF8, 0x65, 0xCA, 0xCD, 0x9B,
   0x5B, 0x95, 0xA8, 0x95, 0x0F, 0xD6, 0x0F, 0x27, 0x51, 0x6F, 0x6C, 0xDA, 0x0E, 0xE5, 0x3D, 0x0D,
   0xC7, 0x09, 0x23, 0xAB, 0x43, 0xD7, 0x36, 0x3A, 0x81, 0x9E, 0x9B, 0x1A, 0xF0, 0x62, 0x59, 0x0A];

def decrypt( packet, size ):
   packet = bytearray( packet )

   key = packet[0] + packet[1]
   key &= 0xff
   
   packet[0] ^= 0xAA

   startkeyval = m_key[ key ]
   startkeyval &= 0x24
   startkeyval |= 1
   
   writepos = 2;
   while( writepos < size ):
      keyval = m_key[ key ]
      if( writepos & startkeyval ):
         if( (keyval & startkeyval) == 0 ):
            packet[ writepos ] = ( packet[ writepos ] - keyval ) & 0xff
         else:
            packet[ writepos ] = ( packet[ writepos ] ^ keyval ) & 0xff
      else:
         if( keyval & startkeyval ):
            packet[ writepos ] = ( ~packet[ writepos ] ) & 0xff
         else:
            packet[ writepos ] = ( packet[ writepos ] + keyval ) & 0xff
      key += 1
      key &= 0xff
      writepos += 1
   return packet

def encrypt( packet, size ):
   packet = bytearray( packet )

   packet[1] = randint( 0, 255 )

   packet[0] ^= 0xAA

   key = packet[0] + packet[1]
   key &= 0xff

   startkeyval = m_key[ key ]
   startkeyval &= 0x24
   startkeyval |= 1

   writepos = 2
   while( writepos < size ):
      keyval = m_key[ key ]
      if( writepos & startkeyval ):
         if( (keyval & startkeyval) == 0 ):
            packet[ writepos ] = ( packet[ writepos ] + keyval ) & 0xff
         else:
            packet[ writepos ] = ( packet[ writepos ] ^ keyval ) & 0xff
      else:
         if( (keyval & startkeyval) == 0 ):
            packet[ writepos ] = ( packet[ writepos ] - keyval ) & 0xff
         else:
            packet[ writepos ] = ( ~packet[ writepos ] ) & 0xff
      key += 1
      key &= 0xff
      writepos += 1
   return packet

      if (path[i].y != ups.positionY)
      {
         double startTime = GetTickCount();
         while (path[i].y != p_update.positionY)
         {
            double currentTime = GetTickCount() - startTime;

            if (currentTime >= 10000) //1 and a half seconds.
            {
               g_Log.Log("Out of time");
               return;
               //Reset the timer.
               startTime = GetTickCount();
            }
            UpdatePacketSelf ups = GetUpdateInfo();
            g_Log.Log("Not matching");
            PergereTrans(path[i].x, path[i].y);
            g_Log.Log("My position = %X", ((ups.positionY)));
            g_Log.Log("Path = %X", ((path[i].y)));
            Sleep(350);

      if (GetCurrentMP() < 150)
      {
         g_Log.Log("Low Mana");
         Sleep(250);
         PraesentisTrans(6);
         Sleep(4000);
         Walk(15723, 47188);
         Sleep(4000);
         return;
      }

void Player::Collect()
{
uint16 x = 0, y = 0;
ItemMap::GetItemPos(x, y);

uint16 slotNum = 1000;
if (x != 0xFFFF && y != 0xFFFF)
{
   g_Log.Log("Selected Item Position (%d %d)", x, y);
   PickItem(x, y);
}

return;
}

void Player::PickItem(uint16 x, uint16 y)
{
   PergereTrans(x*20+10, y*20+10); Sleep(50);
   Walk(x*20+10, y*20+10); Sleep(150);
   UpdatePacketSelf ups = GetUpdateInfo();
   Sleep(300);
   if(UnitMap::UnitsAlive(p_update.positionX, p_update.positionY, 120) > 1)
   {
      Sleep(200);
      FragorIpsum(0);
   }
   return;
}

void Player::OpenShopWindow()
{
   uint16 id = 7289;
   uint16 positionY = 0xFFFF;
   //UnitMap::LocateUnit(50, 2, 0, 0, 198, id, positionY);
   //UnitMap::LocateUnit(122, 22, 0, 0, 358, id, positionY);
   //UnitMap::LocateUnit(122, 22, 0, 0, 102, id, positionY);
   UnitMap::LocateUnit(61, 33, 0, 0, id, positionY);


   if (id != 0 && positionY != 0xFFFF)
   {
      g_Log.Log("NPC click");
      g_Log.Log("ID = %x, Y pos = %d", id, positionY);
      Attack(id, positionY);
      Packet other(0xC, 0xC);
      other << p_id;
      other << (uint16)0;
      other << (uint16)4;
      other << (uint16)0;
      other << id;
      other << (uint16)0;
      DWORD dword_10F4814 = 0x1AE6420;
      *(DWORD*)(dword_10F4814) = id;
      oSendPacket(other, other, other);
   }

void Player::SellItem(uint16 itemNumInInven, uint16 itemCntToSell, uint16 itemTypeOnInven)
{
   Packet sellItem(0x6, 0xC);
   sellItem << p_id;
   sellItem << (uint16)SELL;
   sellItem << itemNumInInven;
   sellItem << itemCntToSell;
   sellItem << itemTypeOnInven;
   sellItem << (uint16)0;

   oSendPacket(sellItem, sellItem, sellItem);
}

void Player::SellItem(uint16 itemNumInInven, uint16 itemCntToSell)
{
   
   Sleep(30);
      uint16 itemType = Inventory::GetItemType(itemNumInInven);
      SellItem(itemNumInInven, itemCntToSell, itemType); //sell 6th Item on Inventor
}

struct Spell {
   uint16 player_id;
   uint8 unk;
   uint8 counter;
   uint16 type; // ground/unit/self or 0x30 + mark for instaport
   uint16 spellid;
   uint16 target; // either positionX or unit id
   uint16 y;
};

Requesting 1 units model data:
uint16 your_player_id;
uint16 requesting_units_id;
uint16 blank;
uint16 blank;

Requesting 2 units model data:
uint16 your_player_id;
uint16 0xFDE8 (constant value, never changes)
uint16 requesting_unit1s_id;
uint16 requesting_unit2s_id;

bool Player::CalcBestTrans(float minrad, float maxrad)
{
   //get tile we're on
   int32 tilex = m_lastupdate.positionX / 20;
   int32 tiley = m_lastupdate.positionY / 20;
   //get tile of position + max radius
   int32 tilemaxx = (int32)((m_lastupdate.positionX + maxrad) / 20);

   std::vector<std::pair<int32, int32>> preferredTiles;
   std::vector<std::pair<int32, int32>> possibleTiles;

   int32 difftile = tilemaxx - tilex;

   for (int32 x = tilex - difftile; x <= tilex + difftile; ++x)
   {
      for (int32 y = tiley - difftile; y <= tiley + difftile; ++y)
      {
         float dist = GetDistance(float(x * 20 + 10), float(y * 20 + 10));

         if (dist < minrad)
            continue;
         if (dist > maxrad)
            continue;

         if (GetMapInterface()->GetMapLayer2(x, y) == 46) //safety square
            continue;

         //we need to be able to walk on it
         if (!GetMapInterface()->CanPass(x, y, PASS_FLAG_WALK))
            continue;
         //and teleport to it
         if (!Raycast(float(x * 20 + 10), float(y * 20 + 10), PASS_FLAG_GAS))
            continue;

         //if you can't walk to it, make it preferred spot :)
         if (!Raycast(float(x * 20 + 10), float(y * 20 + 10), PASS_FLAG_WALK))
            preferredTiles.push_back(std::make_pair(x, y));
         else
            possibleTiles.push_back(std::make_pair(x, y));
      }
   }

   if (possibleTiles.size() == 0 && preferredTiles.size() == 0)
      return false; //nowhere to teleport to, eek

   if (preferredTiles.size() > 0)
   {
      std::uniform_int_distribution<int> dist(0, preferredTiles.size() - 1);
      auto tile = preferredTiles[dist(g_mersenne)];

      m_bestTransX = tile.first * 20 + 10;
      m_bestTransY = tile.second * 20 + 10;
   }
   else
   {
      std::uniform_int_distribution<int> dist(0, possibleTiles.size() - 1);
      auto tile = possibleTiles[dist(g_mersenne)];

      m_bestTransX = tile.first * 20 + 10;
      m_bestTransY = tile.second * 20 + 10;
   }
   return true;
}

        public void UpdateTooltip()
        {
            string t = string.Format("{0} (ID {1} ItemLevel {2})", Name, (int)Id, (int)ItemLevel);

            if (IsWeapon)
                t += string.Format("\nDamage: {0} - {1}", (int)(BasePoints * 0.7), BasePoints);
            if (IsArmor && BasePoints > 0)
                t += string.Format("\nProtection: {0}", BasePoints);

            foreach (var b in OrderedBonuses)
            {
                var bonus = b.Value.Item1;
                var val = b.Value.Item2;

                switch (bonus)
                {
                    case 1: t += string.Format("\n+{0} to hit evil", val); break;
                    case 2: t += string.Format("\n+{0} dispell", val); break;
                    case 3: t += string.Format("\n+{0}% bonus MP", val); break;
                    case 4: t += string.Format("\n+{0} regen MP", val); break;
                    case 5: t += string.Format("\n+{0}% steal MP", val); break;
                    case 6: t += string.Format("\n+{0}% bonus HP", val); break;
                    case 7: t += string.Format("\n+{0} regen HP", val); break;
                    case 8: t += string.Format("\n+{0}% steal HP", val); break;
                    case 9: t += string.Format("\n+{0}% rage bonus", val); break;
                    case 10: t += string.Format("\n+{0} to hit", val); break;
                    case 11: t += string.Format("\n+{0} to defend", val); break;
                    case 12: t += string.Format("\n+{0}% ice damage", val); break;
                    case 13: t += string.Format("\n+{0}% ice damage", val); break;
                    case 14: t += string.Format("\n+{0}% fire damage", val); break;
                    case 15: t += string.Format("\n+{0}% acid damage", val); break;

                    case 20: t += string.Format("\n+{0}% reflect projectilr", val); break;
                    case 21: t += string.Format("\n+{0}% reflect damage", val); break;
                    case 22: t += string.Format("\n+{0}% ice protection", val); break;
                    case 23: t += string.Format("\n+{0}% fire protection", val); break;
                    case 24: t += string.Format("\n+{0}% shadow protection", val); break;
                    case 25: t += string.Format("\n+{0}% energy protection", val); break;
                    case 26: t += string.Format("\n+{0}% spirit protection", val); break;

                    case 29: t += string.Format("\n+{0}% all magic protection", val); break;
                    case 30: t += string.Format("\n+{0} armor bonus", val); break;

                    case 36: t += string.Format("\n+{0}% attack speed", val); break;

                    case 43: t += string.Format("\n+{0}% lethal", val); break;
                    case 44: t += string.Format("\n+{0}% cast speed", val); break;

                    case 49: t += string.Format("\n+{0}% fragor chance", val); break;
                    case 70: t += string.Format("\n+{0}% fragor chance", val); break;

                    case 51: t += string.Format("\n+{0} bonus level of abilities", val); break;

                    case 55: t += string.Format("\n+{0}% Fire magic bonus", val); break;
                    case 56: t += string.Format("\n+{0}% Ice magic bonus", val); break;
                    case 57: t += string.Format("\n+{0}% Energy magic bonus", val); break;
                    case 58: t += string.Format("\n+{0}% Shadow magic bonus", val); break;
                    case 59: t += string.Format("\n+{0}% Spirit magic bonus", val); break;

                    case 61: t += string.Format("\n+{0}% All magic bonus", val); break;

                    case 62: t += string.Format("\n+{0} points damage", val); break;
                    case 63: t += string.Format("\n+{0}% maximus chance", val); break;
                    case 64: t += string.Format("\n+{0}% reditus chance", val); break;

                    case 68: t += string.Format("\n+{0}% shot speed", val); break;

                    case 71: t += string.Format("\n+{0} to armor spells", val); break;

                    case 100: t += string.Format("\nRequires {0} read", val); break;
                }
            }

            var diffb = new InlineDiffBuilder(new Differ());
            var diff = diffb.BuildDiffModel(LastTooltip, t);

            int numdiffs = 0;

            string diff_str = "";

            foreach (var line in diff.Lines)
            {
                switch (line.Type)
                {
                    case DiffPlex.DiffBuilder.Model.ChangeType.Inserted:
                        diff_str += string.Format("+ {0}\n", line.Text);
                        numdiffs++;
                        break;
                    case DiffPlex.DiffBuilder.Model.ChangeType.Deleted:
                        diff_str += string.Format("- {0}\n", line.Text);
                        numdiffs++;
                        break;
                    default:
                        diff_str += string.Format("{0}\n", line.Text);
                        break;
                }
            }

            if (numdiffs > 0)
                Task.Run(() => PostItemChangeLog(diff_str));

            LastTooltip = t;
        }