craw/d2_functions.cpp

   1 #include <windows.h>
   2 #include <ail/array.hpp>
   3 #include <ail/string.hpp>
   4 #include <boost/foreach.hpp>
   5 #include "d2_functions.hpp"
   6 #include "utility.hpp"
   7
   8 class module_offset_handler
   9 {
  10 public:
  11         module_offset_handler(unsigned image_base, unsigned module_base):
  12                 image_base(image_base),
  13                 module_base(module_base)
  14         {
  15         }
  16
  17         template <typename type>
  18                 void fix(type & function, unsigned offset)
  19         {
  20                 function = reinterpret_cast<type>(module_base + offset - image_base);
  21         }
  22
  23         template <>
  24                 void fix<unsigned>(unsigned & function, unsigned offset)
  25         {
  26                 function = module_base + offset - image_base;
  27         }
  28
  29
  30 private:
  31         unsigned
  32                 image_base,
  33                 module_base;
  34 };
  35
  36 namespace
  37 {
  38         unsigned
  39                 d2win_base = 0x6F8E0000,
  40                 d2gfx_base = 0x6FA80000,
  41                 d2common_base = 0x6FD50000,
  42                 d2client_base = 0x6FAB0000,
  43                 d2net_base = 0x6FBF0000,
  44                 bnclient_base = 0x6FF20000;
  45
  46         bool d2client_has_been_loaded = false;
  47
  48         unsigned const life_mana_shift = 8;
  49
  50         unsigned data_tables;
  51         unsigned roster_list;
  52
  53         unsigned player_pointer;
  54         unsigned automap_layer_address;
  55
  56         unsigned initialise_automap_layer_address;
  57 }
  58
  59 //D2Win.dll
  60 set_font_size_type d2_set_font_size;
  61 draw_text_type d2_draw_text;
  62 get_text_width_type d2_get_text_width;
  63
  64 //D2Gfx.dll
  65 draw_line_type d2_draw_line;
  66
  67 //D2Common.dll
  68 get_unit_stat_type d2_get_unit_stat;
  69 get_level_type d2_get_level;
  70 get_layer_type d2_get_layer;
  71 add_room_data_tye d2_add_room_data;
  72 remove_room_data_type d2_remove_room_data;
  73 initialise_level_type d2_initialise_level;
  74 get_object_table_entry_type d2_get_object_table_entry;
  75 get_inventory_item_type d2_get_inventory_item;
  76 get_next_inventory_item_type d2_get_next_inventory_item;
  77 get_item_text_type d2_get_item_text;
  78 map_to_screen_coordinates_type d2_map_to_screen_coordinates;
  79 get_skill_level_type d2_get_skill_level;
  80 get_unit_state_type d2_get_unit_state;
  81
  82 //D2Client.dll
  83 get_player_unit_type d2_get_player_unit;
  84 get_difficulty_type d2_get_difficulty;
  85 reveal_automap_room_type d2_reveal_automap_room;
  86 new_automap_cell_type d2_new_automap_cell;
  87 add_automap_cell_type d2_add_automap_cell;
  88 leave_game_type d2_leave_game;
  89 get_unit_pointer_type d2_get_unit_pointer;
  90 get_item_name_type d2_get_item_name;
  91 click_map_type d2_click_map;
  92 find_server_side_unit_type d2_find_server_side_unit;
  93 find_client_side_unit_type d2_find_client_side_unit;
  94 get_unit_owner_type d2_get_unit_owner;
  95 print_chat_text_type d2_print_chat_text;
  96
  97 unsigned light_handler_address;
  98
  99 unsigned automap_handler_address;
 100 unsigned automap_loop_address;
 101
 102 unsigned get_unit_name_address;
 103
 104 unsigned
 105         add_unit_address1,
 106         add_unit_address2;
 107
 108 unsigned item_handler_call_address;
 109
 110 unsigned
 111         mouse_x_address,
 112         mouse_y_address;
 113
 114 unsigned server_side_unit_list_address;
 115
 116 unsigned
 117         unit_is_selectable_address,
 118         unit_selection_data_address;
 119
 120 //D2Net.dll
 121 send_packet_type d2_send_packet;
 122 receive_packet_type d2_receive_packet;
 123
 124 //Bnclient.dll
 125 unsigned server_token_address = 0;
 126
 127 void initialise_d2win_addresses(unsigned base)
 128 {
 129         module_offset_handler offset_handler(d2win_base, base);
 130
 131         offset_handler.fix(d2_set_font_size, 0x6F8F08D0);
 132         offset_handler.fix(d2_draw_text, 0x6F8F0890);
 133         offset_handler.fix(d2_get_text_width, 0x6F8EFFF0);
 134 }
 135
 136 void initialise_d2gfx_addresses(unsigned base)
 137 {
 138         module_offset_handler offset_handler(d2gfx_base, base);
 139
 140         offset_handler.fix(d2_draw_line, 0x6FA87CA0);
 141 }
 142
 143 void initialise_d2common_addresses(unsigned base)
 144 {
 145         module_offset_handler offset_handler(d2common_base, base);
 146
 147         offset_handler.fix(d2_get_unit_stat, 0x6FD84E20);
 148         offset_handler.fix(d2_get_level, 0x6FDC2520);
 149         offset_handler.fix(d2_get_layer, 0x6FDC3870);
 150         offset_handler.fix(d2_add_room_data, 0x6FDA68F0);
 151         offset_handler.fix(d2_remove_room_data, 0x6FDA6830);
 152         offset_handler.fix(d2_initialise_level, 0x6FDC2C40);
 153         offset_handler.fix(d2_get_object_table_entry, 0x6FD87300);
 154         offset_handler.fix(d2_get_inventory_item, 0x6FDB7500);
 155         offset_handler.fix(d2_get_next_inventory_item, 0x6FDB8400);
 156         offset_handler.fix(d2_get_item_text, 0x6FDAC980);
 157         offset_handler.fix(d2_map_to_screen_coordinates, 0x6FDABF50);
 158         offset_handler.fix(d2_get_skill_level, 0x6FD5E660);
 159         offset_handler.fix(d2_get_unit_state, 0x6FDC09A0);
 160
 161         offset_handler.fix(data_tables, 0x6FDEB500);
 162 }
 163
 164 void initialise_d2client_addresses(unsigned base)
 165 {
 166         module_offset_handler offset_handler(d2client_base, base);
 167
 168         offset_handler.fix(d2_get_player_unit, 0x6FACE490);
 169         offset_handler.fix(d2_get_difficulty, 0x6FB29CD0);
 170         offset_handler.fix(d2_reveal_automap_room, 0x6FAF04C0);
 171         offset_handler.fix(d2_new_automap_cell, 0x6FAED5B0);
 172         offset_handler.fix(d2_add_automap_cell, 0x6FAEF090);
 173         offset_handler.fix(d2_leave_game, 0x6FB2AB00);
 174         offset_handler.fix(d2_get_unit_pointer, 0x6FACF1C0);
 175         offset_handler.fix(d2_get_item_name, 0x6FB5B3C0);
 176         offset_handler.fix(d2_click_map, 0x6FB0CE80);
 177         offset_handler.fix(d2_find_server_side_unit, 0x6FACF1C0);
 178         offset_handler.fix(d2_find_client_side_unit, 0x6FACF1A0);
 179         offset_handler.fix(d2_get_unit_owner, 0x6FB73160);
 180         offset_handler.fix(d2_print_chat_text, 0x6FB21740);
 181
 182         offset_handler.fix(roster_list, 0x6FBCC080);
 183         offset_handler.fix(player_pointer, 0x6FBCC3D0);
 184         offset_handler.fix(automap_layer_address, 0x6FBCC2B4);
 185         offset_handler.fix(initialise_automap_layer_address, 0x6FAF0650);
 186
 187         offset_handler.fix(light_handler_address, 0x6FB0F8F0);
 188         offset_handler.fix(automap_handler_address, 0x6FAEF920);
 189         offset_handler.fix(automap_loop_address, 0x6FAF0350);
 190         offset_handler.fix(get_unit_name_address, 0x6FACF3D0);
 191
 192         offset_handler.fix(add_unit_address1, 0x6FACFD9B);
 193         offset_handler.fix(add_unit_address2, 0x6FACFD9E);
 194
 195         offset_handler.fix(item_handler_call_address, 0x6FB48635);
 196
 197         offset_handler.fix(mouse_x_address, 0x6FBC21D0);
 198         offset_handler.fix(mouse_y_address, 0x6FBC21CC);
 199
 200         offset_handler.fix(server_side_unit_list_address, 0x6FBCA964);
 201
 202         //offset_handler.fix(unit_is_selectable_address, 0x6FAD0010);
 203         offset_handler.fix(unit_is_selectable_address, 0x6FAD0071);
 204
 205         //offset_handler.fix(unit_selection_data_address, 0x6FBCC1D0);
 206
 207         d2client_has_been_loaded = true;
 208 }
 209
 210 void initialise_d2net_addresses(unsigned base)
 211 {
 212         module_offset_handler offset_handler(d2net_base, base);
 213
 214         offset_handler.fix(d2_send_packet, 0x6FBF6F90);
 215         offset_handler.fix(d2_receive_packet, 0x6FBF6510);
 216 }
 217
 218 void initialise_bnclient_addresses(unsigned base)
 219 {
 220         module_offset_handler offset_handler(bnclient_base, base);
 221
 222         offset_handler.fix(server_token_address, 0x6FF3F5D8);
 223 }
 224
 225 void draw_text(std::string const & text, int x, int y, unsigned colour, bool centered)
 226 {
 227         std::size_t buffer_size = text.size() + 1;
 228         wchar_t * wide_string_data = new wchar_t[buffer_size];
 229
 230         std::memset(wide_string_data, 0, buffer_size * 2);
 231         MultiByteToWideChar(0, MB_PRECOMPOSED, text.c_str(), text.length(), wide_string_data, buffer_size);
 232
 233         unsigned font_size = 6;
 234
 235         unsigned old_font_size = d2_set_font_size(font_size);
 236         if(centered)
 237         {
 238                 unsigned
 239                         width,
 240                         file_number;
 241
 242                 d2_get_text_width(wide_string_data, &width, &file_number);
 243
 244                 x -= width / 2;
 245         }
 246
 247         d2_draw_text(wide_string_data, x, y, colour, -1);
 248         d2_set_font_size(old_font_size);
 249
 250         delete wide_string_data;
 251 }
 252
 253 struct coordinate
 254 {
 255         int
 256                 x,
 257                 y;
 258
 259         coordinate(int x, int y):
 260                 x(x),
 261                 y(y)
 262         {
 263         }
 264 };
 265
 266 void __stdcall draw_box(int x, int y, unsigned colour)
 267 {
 268         bool const continuous = true;
 269
 270         int const square_size = 3;
 271
 272         coordinate const coordinates[] =
 273         {
 274                 coordinate(- square_size, square_size),
 275                 coordinate(square_size, square_size),
 276                 coordinate(square_size, - square_size),
 277                 coordinate(- square_size, - square_size),
 278                 coordinate(- square_size, square_size)
 279         };
 280
 281         std::size_t
 282                 limit,
 283                 increment;
 284
 285         if(continuous)
 286         {
 287                 limit = ail::countof(coordinates) - 1;
 288                 increment = 1;
 289         }
 290         else
 291         {
 292                 limit = ail::countof(coordinates);
 293                 increment = 2;
 294         }
 295
 296         for(std::size_t i = 0; i < limit; i += increment)
 297         {
 298                 coordinate const & start = coordinates[i];
 299                 coordinate const & end = coordinates[i + 1];
 300                 d2_draw_line(x + start.x, y + start.y, x + end.x, y + end.y, colour, 0xff);
 301         }
 302 }
 303
 304 bool get_life_or_mana(unsigned & current, unsigned & maximum, unsigned stat1, unsigned stat2)
 305 {
 306         unit * player_unit = d2_get_player_unit();
 307         if(player_unit == 0)
 308                 return false;
 309         current = d2_get_unit_stat(player_unit, stat1, 0) >> life_mana_shift;
 310         maximum = d2_get_unit_stat(player_unit, stat2, 0) >> life_mana_shift;
 311         return true;
 312 }
 313
 314 bool get_life(unsigned & current_life, unsigned & maximum_life)
 315 {
 316         return get_life_or_mana(current_life, maximum_life, 6, 7);
 317 }
 318
 319 bool get_mana(unsigned & current_mana, unsigned & maximum_mana)
 320 {
 321         return get_life_or_mana(current_mana, maximum_mana, 8, 9);
 322 }
 323
 324 monster_statistics & get_monster_statistics(std::size_t index)
 325 {
 326         char * root = *reinterpret_cast<char **>(data_tables);
 327         monster_statistics * table = *reinterpret_cast<monster_statistics **>(root + 0xA78);
 328         return table[index];
 329 }
 330
 331 roster_unit * get_player_roster(unsigned player_id)
 332 {
 333         for(roster_unit * i = reinterpret_cast<roster_unit *>(roster_list); i; i = i->next_roster)
 334         {
 335                 if(i->unit_id == player_id)
 336                         return i;
 337         }
 338         return 0;
 339 }
 340
 341 unit * get_player()
 342 {
 343         return *reinterpret_cast<unit **>(player_pointer);
 344 }
 345
 346 automap_layer * get_automap_layer()
 347 {
 348         return *reinterpret_cast<automap_layer **>(automap_layer_address);
 349 }
 350
 351 __declspec(naked) automap_layer_type_2 * __fastcall initialise_automap_layer_stub(unsigned layer_number)
 352 {
 353         __asm
 354         {
 355                 push eax
 356                 mov eax, ecx
 357                 call initialise_automap_layer_address
 358                 pop eax
 359                 ret
 360         }
 361 }
 362
 363 automap_layer_type_2 * initialise_automap_layer(unsigned level_number)
 364 {
 365         automap_layer_type_2 * layer = d2_get_layer(level_number);
 366         if(!layer)
 367                 return 0;
 368         return initialise_automap_layer_stub(layer->layer_number);
 369 }
 370
 371 automap_cell ** get_layer_objects_pointer()
 372 {
 373         return &(get_automap_layer()->objects);
 374 }
 375
 376 bool get_player_level_number(unsigned & output)
 377 {
 378         unit * unit_pointer = d2_get_player_unit();
 379
 380         //is this really necessary? Damn you, D2BS.
 381         if(
 382                 unit_pointer &&
 383                 unit_pointer->path_data_pointer &&
 384                 unit_pointer->path_data_pointer->room_1 &&
 385                 unit_pointer->path_data_pointer->room_1->room_2 &&
 386                 unit_pointer->path_data_pointer->room_1->room_2->level
 387         )
 388         {
 389                 output = unit_pointer->path_data_pointer->room_1->room_2->level->level_number;
 390                 return true;
 391         }
 392
 393         return false;
 394 }
 395
 396 bool get_player_id(unsigned & output)
 397 {
 398         unit * unit_pointer = d2_get_player_unit();
 399         if(unit_pointer == 0)
 400                 return false;
 401
 402         output = unit_pointer->id;
 403
 404         return true;
 405 }
 406
 407 wchar_t * get_unit_name(unit * unit_pointer)
 408 {
 409         wchar_t * output;
 410         __asm
 411         {
 412                 mov eax, unit_pointer
 413                 call get_unit_name_address
 414                 mov output, eax
 415         }
 416         return output;
 417 }
 418
 419 roster_vector get_roster_units()
 420 {
 421         roster_vector output;
 422
 423         roster_unit * roster_pointer = *reinterpret_cast<roster_unit **>(roster_list);
 424         while(roster_pointer)
 425         {
 426                 output.push_back(roster_unit(*roster_pointer));
 427                 roster_pointer = roster_pointer->next_roster;
 428         }
 429
 430         return output;
 431 }
 432
 433 bool get_name_by_id(unsigned id, std::string & output)
 434 {
 435         roster_vector roster_units = get_roster_units();
 436         BOOST_FOREACH(roster_unit & current_unit, roster_units)
 437         {
 438                 if(current_unit.unit_id == id)
 439                 {
 440                         output = current_unit.get_name();
 441                         return true;
 442                 }
 443         }
 444
 445         return false;
 446 }
 447
 448 bool get_non_empty_tp_tome_id(unsigned & output)
 449 {
 450         unit * unit_pointer = d2_get_player_unit();
 451         if(!unit_pointer)
 452                 return false;
 453
 454         inventory * inventory_pointer = unit_pointer->inventory_pointer;
 455         if(!inventory_pointer)
 456                 return false;
 457
 458         for(unit * current_item = d2_get_inventory_item(inventory_pointer); current_item != 0; current_item = d2_get_next_inventory_item(current_item))
 459         {
 460                 item_data * item_data_pointer = current_item->item_data_pointer;
 461                 if(!item_data_pointer)
 462                         continue;
 463
 464                 //inventory check
 465                 if(item_data_pointer->item_location != 0)
 466                         continue;
 467
 468                 item_text * item_text_pointer = d2_get_item_text(current_item->table_index);
 469                 if(item_text_pointer == 0)
 470                         continue;
 471
 472                 if(item_text_pointer->get_code() != "tbk")
 473                         continue;
 474
 475                 //retrieve quantity
 476                 unsigned count = d2_get_unit_stat(current_item, 70, 0);
 477                 if(count == 0)
 478                         continue;
 479
 480                 output = current_item->id;
 481                 return true;
 482         }
 483
 484         return false;
 485 }
 486
 487 bool player_is_in_game()
 488 {
 489         if(!d2client_has_been_loaded)
 490                 return false;
 491
 492         return d2_get_player_unit() != 0;
 493 }
 494
 495 bool get_item_name(unit * input, std::string & name, std::string & special_name)
 496 {
 497         wchar_t buffer[0x100];
 498         std::memset(buffer, 0, sizeof(buffer));
 499         attach_point();
 500         if(!d2_get_item_name(input, buffer, ail::countof(buffer)))
 501                 return false;
 502
 503         std::string data = wchar_to_string(buffer);
 504         string_vector tokens = ail::tokenise(data, "\n");
 505         switch(tokens.size())
 506         {
 507         default:
 508                 error("d2_get_item_name returned an invalid item name for item " + ail::hex_string_32(reinterpret_cast<unsigned>(input)) + ": \"" + data + "\"");
 509                 exit_process();
 510                 return false;
 511
 512         case 1:
 513                 name = data;
 514                 special_name.clear();
 515                 break;
 516
 517         case 2:
 518                 name = tokens[1];
 519                 special_name = tokens[0];
 520                 break;
 521         }
 522
 523         return true;
 524 }
 525
 526 void move_click(int x, int y)
 527 {
 528         d2_map_to_screen_coordinates(&x, &y);
 529         x -= *reinterpret_cast<int *>(mouse_x_address);
 530         y -= *reinterpret_cast<int *>(mouse_y_address);
 531         d2_click_map(0, x, y, 8);
 532 }
 533
 534 bool get_unit_by_id(unsigned id, unsigned type, unit * & output)
 535 {
 536         output = d2_find_server_side_unit(id, type);
 537         if(output != 0)
 538                 return true;
 539
 540         output = d2_find_client_side_unit(id, type);
 541
 542         return output != 0;
 543 }
 544
 545 bool get_skill_level(unsigned skill_id, unsigned & output)
 546 {
 547         unit * unit_pointer = d2_get_player_unit();
 548         if(!unit_pointer)
 549                 return false;
 550
 551         for(skill_data * current_skill = unit_pointer->skill_pointer->first_skill; current_skill; current_skill = current_skill->next_skill)
 552         {
 553                 if(current_skill->skill_information_pointer->identifier == skill_id)
 554                 {
 555                         output = d2_get_skill_level(unit_pointer, current_skill, true);
 556                         return true;
 557                 }
 558         }
 559
 560         return false;
 561 }
 562
 563 bool get_minions(unsigned player_id, std::vector<unit> & output)
 564 {
 565         unit * unit_pointer;
 566         if(!get_unit_by_id(player_id, unit_player, unit_pointer))
 567                 return false;
 568
 569         act_data * act_data_pointer = unit_pointer->act_data_pointer;
 570         if(act_data_pointer == 0)
 571                 return false;
 572
 573         for(room_data_type_1 * room_pointer = act_data_pointer->room_1; room_pointer; room_pointer = room_pointer->next_room)
 574         {
 575                 for(unit * unit_pointer = room_pointer->first_unit; unit_pointer; unit_pointer = unit_pointer->next_list_entry)
 576                 {
 577                         unit & current_unit = *unit_pointer;
 578                         if(current_unit.type == unit_monster && d2_get_unit_owner(current_unit.id) == player_id)
 579                                 output.push_back(current_unit);
 580                 }
 581         }
 582
 583         return true;
 584 }
 585
 586 void print_chat_text(std::string const & message)
 587 {
 588         //write_line(ail::hex_string(message));
 589         wchar_t * wide_string = string_to_wchar(message);
 590         //write_line(ail::hex_string(std::string((char *)wide_string, message.size() * 2)));
 591         d2_print_chat_text(wide_string, 0);
 592         delete wide_string;
 593 }