Heroes of Might & Magic 2 (Исходный код)

Привет всем. Загорелось желание, сделать что-нибудь со вторыми героями. Может монстров новых добавить, или еще чего. Вот думаю здорово бы было иметь исходный код игры. Наверняка все знают или слышали о "Hex Rays" для "IDA". Он может Ассемблер декомпилировать в C# псевдокод. Вот хотелось бы узнать, на сколько реально из Этого кода сделать рабочий исходный код ?
Может-быть у кого есть опыт, знает какие-нибудь нюансы.
Чисто теоретический, будет-ли вообще этот код работать в VISUAL STUDIO, если его наладить ?

 

Теоретически реверсинжиниринг движка возможен, но на практике на это уйдут человеко-годы. Да и не ясен смысл, когда есть fheroes2.

 

Разве fheroes2 не является результатом реверсинга и дружбы с дебагером? А зачем кому-то могут понадобиться непортабельные, написанные в спешке исходники оригинала - выше меня.

Хотя есть проект для Might & Magic 6-8, декомпилированный полностью с HexRays:
http://www.celestialheavens.com/forums/viewtopic.php?p=290950
https://www.assembla.com/code/bb7/subversion/nodes#open

попробуйте уж лучше его доработать для начала.

 

free heroes 2 по началу меня вдохновил. Но вот присмотревшись получше, начинаешь замечать, что все немного по другому. Ну вот к примеру динамика боя.

---------- Сообщение добавлено в 17:56 ---------- Предыдущее сообщение размещено в 17:50 ----------

Ты его компилировать пытался? У меня не работает.

Разработчиков не было почти два года.. Это настораживает. Нужен человек, который может объяснить и показать что к чему..

---------- Сообщение добавлено в 18:54 ---------- Предыдущее сообщение размещено в 17:56 ----------

Ну вообщем, немного покопался. Ничего так и не разобрался толком. Опыт в "VS" и "С" у меня нулевой.
Сначала пытался скомпилировать целиком .c фаил, декомпилированный с помощью Hex Rays. Посыпалось куча ошибок. 95 процентов, это Неизвестный тип переменной.. Не хватило сил в ручную это все править.
Теперь по внимательней посмотрел в IDA, в Исполняемом файле еще куча ресурсов - текста и еще не знаю чего. Но разумеется этого в декомпилированном файле нету.
Так что, без хорошего опыта в этом деле не обойтись. Нужно понимать, как все это устроить..
Вот, для начала предлагаю рассмотреть этот код.
Если есть, умельцы, которые хотят и могут, сделать его рабочим, то попробуем еще.

Код:

//----- (004C6120) --------------------------------------------------------
void __thiscall LogStr(void *this)
{
  const char *v1; // edi@1
  FILE *v2; // ebx@2
  signed int v3; // ecx@3
  char *v4; // edi@3
  char v5; // zf@5
  char OutputString; // [sp+Ch] [bp-1F4h]@3

  v1 = (const char *)this;
  if ( giDebugLevel >= 2 )
  {
    v2 = fopen("KB.LOG", "at+");
    if ( v2 )
    {
      v4 = strcpy(&OutputString, v1);
      v3 = -1;
      do
      {
        if ( !v3 )
          break;
        v5 = *v4++ == 0;
        --v3;
      }
      while ( !v5 );
      *(_WORD *)(v4 - 1) = word_51E7A8;
      fputs(&OutputString, v2);
      fclose(v2);
      if ( giDebugLevel == 4 )
        OutputDebugStringA(&OutputString);
    }
  }
}

 

Что мешает сделать такую, какая угодна лично тебе?

Оригинальные исходники на том же C/C++.

 

Ну вот, сравни. fheroes2 писала(пишет) команда и нескольких человек. Мастеров. И то, получается, что да конца еще не доделали.
И я один - "незнайка".
Я понимаю всю сложность работы такого рода. Поэтому было-бы здорово адаптировать несколько функции из декомпилированного кода. Ради опыта хотя бы.
Может кто-нибудь сумеет показать и объяснить что к чему.
Вот кстати вопрос.

Код:

      v2 = *(_DWORD *)(this + 62119);
      v5 = *(_DWORD *)(this + 1154 * v2 + 24234 * *(_DWORD *)(this + 62115) + 13765);

v2, v5 это переменные. А что дальше за непонятные конструкции.. _DWORD и числа слишком большие.. Это можно как-то упростить, записать в более понятной форме ?

 

fheroes2 пишет один человек - Andrey Afletdinov и keeperfx пишет один человек и xlengine тоже.

Поэтому сперва запаситесь базовыми знаниями: С в объеме хотя бы K&R, прочитайте Art of Assembly Language, книгу Касперски по ida...

 

Скорее всего у вас неверно прописаны пути к библиотекам, которые необходимы для сборки проектов в солюшене.

На последней (в данный момент) странице первый пост датирован семнадцатым июля. Пользователь, который его оставил, зарегистрировался 8 января 2011 года, если продолжать верить базе данных того форума в отношении дат. Думаю, вы не станете спорить, что оставить пост раньше даты регистрации он не мог? Следовательно, пост был оставлен либо в 2011-м году, либо в 2012-м году.
Если продолжать сравнивать даты регистрации и даты постов после поста автора темы за одиннадцатое января, то можно с большой степенью вероятности предположить, что этот его последний пост был одиннадцатого января 2012-го года.

Судя по всему эта функция создаёт логи для отладки. Что действительно настораживает - создаваемый файл называется "KB.LOG". Логичным было бы встретить вместо этого "heroes.log", "debug.log" или что-то ещё в таком роде. Вы уверенны, что это именно исходный код, сгенерированный из дизассемблированных вторых Героев?

В первой строчке значение "this" (указатель на объект, которому принадлежит данный метод), к которому добавили 62119, преобразуется к типу указатель на DWORD (двойное слово, или целочисленный тип размером в 8 UPD:4 байт) и затем разименуется.
Подробно описывать происходящее во второй строке не буду, должно быть и так понятно.
Работа с указателями является пусть и не первой, но совершенно необходимой ступенью при обучении C++. Если хотите сами понять как всё работает, то, боюсь, вам придётся учить этот язык.

 

Тем, кто надеется на HexRays, я бы посоветовал дать ему какую-нибудь простую, желательно _свою_ программку, строк так из тысячи. И потом оценить трудозатраты на проект вроде HoMM2.
Энтузиазм быстро поиссякнет, уверяю.

 

Зачем из тысячи? Я и из пяти строк могу дать:

Код:

huff Xs -> Xs,sort,([X@Xs Ys:_:@(nb X)]->[[Xs,len+1 X]@Ys,r]) | sort by=lhd
  | ([[A X] [B Y] @Xs]->hIns A+B [X Y] Xs | r; [[_ X]]->X)
  | (Bs [A B]->[@(r [@Bs 0] A) @(r [@Bs 1] B)]; Bs X->[[X Bs]]) []
huffEnc Xs -> Fs:(sort Xs,huff by=lhd) mapc (bget ? Fs) Xs
huffEnc "The algorithm for generating a Huffman tree is very simple." | say

 

Это интересный вопрос, будет ли ассемблерный листинг хафмана более читаем после ghc или последнего gcc/clang с -O2. Впрочем использование известных алгоритмов в качестве теста некоректно, в случае их опознания сложность реверсинжиниринга сильно падает.

 

Простая программа на C, «поедатель» памяти:

Код:

// valloc.c

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

int main(int argc, char **argv)
{
	SIZE_T mem, m = 1;
	char lastchar;
	void *p;

	if(argc < 2)
	{
		printf("Usage: VALLOC <n>\n   or: VALLOC <nK>\n   or: VALLOC <nM>\n");
		return 0;
	}

	lastchar = argv[1][strlen(argv[1])-1];
	if(lastchar == 'k' || lastchar == 'K')
	{
		m = 1024;
		argv[1][strlen(argv[1])-1] = 0;
	}
	if(lastchar == 'm' || lastchar == 'M')
	{
		m = 1048576;
		argv[1][strlen(argv[1])-1] = 0;
	}
	mem = atoll(argv[1]) * m;

	printf("Allocating %llu bytes ...", mem);
	p = VirtualAlloc(NULL, mem, MEM_COMMIT, PAGE_READWRITE);
	if(p)
	{
		printf(" success");
		ZeroMemory(p, mem);
		printf(" - press <ENTER> to free memory.\n");
		getchar();
		VirtualFree(p, 0, MEM_RELEASE);
	}
	else printf(" failed.\n");

	return 0;
}

А вот что выдаёт декомпилятор:

Код:

/* This file has been generated by the Hex-Rays decompiler.
   Copyright (c) 2007-2011 Hex-Rays <info@hex-rays.com>

   Detected compiler: Visual C++
*/

#include <windows.h>
#include <defs.h>


//-------------------------------------------------------------------------
// Data declarations

extern int dword_401770[]; // weak
extern int dword_402000; // weak
extern int (*off_402004)[33]; // weak
extern int dword_402010; // weak
extern int dword_402020; // weak
extern int dword_402030; // weak
extern char aLibgcj_s_dll[13]; // weak
extern char a_jv_registercl[20]; // weak
extern _UNKNOWN unk_4030B0; // weak
extern int dword_404000; // weak
extern int dword_404004; // weak
extern int dword_404010; // weak
extern int dword_404020; // weak
// extern FILE *iob; idb

//-------------------------------------------------------------------------
// Function declarations

signed int __stdcall sub_401000(unsigned int **a1);
void __cdecl sub_401150();
void __cdecl start();
int __cdecl sub_4012C0(void (__cdecl *a1)());
HMODULE __cdecl sub_4012E0();
void (*__cdecl sub_401340())(void);
int __cdecl sub_401370();
_DWORD __cdecl sub_4013F0(char); // weak
int __cdecl sub_401520();
int __cdecl sub_401550();
void __cdecl sub_401650();
// int cexit(void); weak
// int _p__environ(void); weak
// int __cdecl signal(_DWORD, _DWORD); weak
// int _p__fmode(void); weak
// int __cdecl setmode(_DWORD, _DWORD); weak
// int __cdecl _getmainargs(_DWORD, _DWORD, _DWORD, _DWORD, _DWORD); weak
// int __cdecl puts(const char *Str);
// int __cdecl filbuf(FILE *File);
// int __cdecl atoi(const char *Str);
// int printf(const char *Format, ...);
// LPTOP_LEVEL_EXCEPTION_FILTER __stdcall SetUnhandledExceptionFilter(LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter);
// void __stdcall ExitProcess(UINT uExitCode);
// HMODULE __stdcall GetModuleHandleA(LPCSTR lpModuleName);
// FARPROC __stdcall GetProcAddress(HMODULE hModule, LPCSTR lpProcName);
// LPVOID __stdcall VirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect);
// BOOL __stdcall VirtualFree(LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType);
// int __cdecl _set_app_type(_DWORD); weak
// int __cdecl atexit(void (__cdecl *)());


//----- (00401000) --------------------------------------------------------
signed int __stdcall sub_401000(unsigned int **a1)
{
  int v1; // ebx@1
  signed int v2; // esi@1
  unsigned int v3; // eax@1
  int v4; // eax@4
  bool v6; // zf@14
  int v7; // eax@16
  int v8; // eax@22

  v1 = 0;
  v2 = 0;
  v3 = **a1;
  if ( v3 <= 0xC0000091 )
  {
    if ( v3 >= 0xC000008D )
    {
LABEL_3:
      v2 = 1;
      goto LABEL_4;
    }
    if ( v3 == -1073741819 )
    {
      v8 = signal(11, 0);
      if ( v8 == 1 )
      {
        signal(11, 1);
      }
      else
      {
        if ( !v8 )
          return v1;
        ((void (__cdecl *)(signed int))v8)(11);
      }
      return -1;
    }
    v6 = v3 == -1073741795;
LABEL_15:
    if ( !v6 )
      return v1;
    v7 = signal(4, 0);
    if ( v7 == 1 )
    {
      signal(4, 1);
    }
    else
    {
      if ( !v7 )
        return v1;
      ((void (__cdecl *)(signed int))v7)(4);
    }
    return -1;
  }
  if ( v3 == -1073741676 )
  {
LABEL_4:
    v4 = signal(8, 0);
    if ( v4 == 1 )
    {
      signal(8, 1);
      if ( v2 )
        sub_401650();
    }
    else
    {
      if ( !v4 )
        return v1;
      ((void (__cdecl *)(signed int))v4)(8);
    }
    return -1;
  }
  if ( v3 > 0xC0000094 )
  {
    v6 = v3 == -1073741674;
    goto LABEL_15;
  }
  if ( v3 == -1073741677 )
    goto LABEL_3;
  return 0;
}
// 401690: using guessed type int __cdecl signal(_DWORD, _DWORD);

//----- (00401150) --------------------------------------------------------
void __cdecl sub_401150()
{
  FILE *v0; // edx@2
  int v1; // ST08_4@7
  UINT v2; // ebx@7
  char v3; // [sp+1Ch] [bp-Ch]@1
  int v4; // [sp+20h] [bp-8h]@1

  SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)sub_401000);
  sub_401550();
  sub_401650();
  v4 = 0;
  _getmainargs(&dword_404004, &dword_404000, &v3, dword_402010, &v4);
  if ( dword_404010 )
  {
    dword_402020 = dword_404010;
    v0 = iob;
    if ( iob )
    {
      setmode(*(&iob + 4), dword_404010);
      v0 = iob;
    }
    if ( v0 != (FILE *)-32 )
    {
      setmode(*(&iob + 12), dword_404010);
      v0 = iob;
    }
    if ( v0 != (FILE *)-64 )
      setmode(*(&iob + 20), dword_404010);
  }
  *(_DWORD *)_p__fmode() = dword_402020;
  sub_401520();
  sub_401370();
  v1 = *(_DWORD *)_p__environ();
  v2 = sub_4013F0(dword_404004);
  cexit();
  ExitProcess(v2);
}
// 4013F0: using guessed type _DWORD __cdecl sub_4013F0(char);
// 401670: using guessed type int cexit(void);
// 401680: using guessed type int _p__environ(void);
// 4016A0: using guessed type int _p__fmode(void);
// 4016B0: using guessed type int __cdecl setmode(_DWORD, _DWORD);
// 4016C0: using guessed type int __cdecl _getmainargs(_DWORD, _DWORD, _DWORD, _DWORD, _DWORD);
// 402010: using guessed type int dword_402010;
// 402020: using guessed type int dword_402020;
// 404000: using guessed type int dword_404000;
// 404004: using guessed type int dword_404004;
// 404010: using guessed type int dword_404010;

//----- (00401280) --------------------------------------------------------
void __cdecl start()
{
  _set_app_type(1);
  sub_401150();
}
// 4050CC: using guessed type int __cdecl _set_app_type(_DWORD);

//----- (004012C0) --------------------------------------------------------
int __cdecl sub_4012C0(void (__cdecl *a1)())
{
  return atexit(a1);
}

//----- (004012E0) --------------------------------------------------------
HMODULE __cdecl sub_4012E0()
{
  HMODULE result; // eax@1
  HMODULE v1; // edx@2

  result = (HMODULE)dword_402030;
  if ( dword_402030 )
  {
    result = GetModuleHandleA("libgcj_s.dll");
    v1 = 0;
    if ( result )
    {
      result = GetProcAddress(result, "_Jv_RegisterClasses");
      v1 = result;
    }
    if ( v1 )
      result = (HMODULE)((int (__cdecl *)(_DWORD))v1)(&dword_402030);
  }
  return result;
}
// 402030: using guessed type int dword_402030;

//----- (00401340) --------------------------------------------------------
void (*__cdecl sub_401340())(void)
{
  void (*result)(void); // eax@1
  int (*v1)[33]; // eax@2

  result = (void (*)(void))(*off_402004)[0];
  if ( (*off_402004)[0] )
  {
    do
    {
      result();
      v1 = (int (*)[33])((char *)off_402004 + 4);
      off_402004 = v1;
      result = (void (*)(void))(*v1)[0];
    }
    while ( result );
  }
  return result;
}
// 402004: using guessed type int (*off_402004)[33];

//----- (00401370) --------------------------------------------------------
int __cdecl sub_401370()
{
  int i; // ebx@2
  int v1; // esi@4
  int result; // eax@6

  if ( !dword_402000 )
  {
    i = dword_401770[0];
    dword_402000 = 1;
    sub_4012E0();
    if ( dword_401770[0] == -1 )
    {
      for ( i = 0; dword_401770[i + 1]; ++i )
        ;
    }
    if ( i )
    {
      v1 = 4 * i + 4200304;
      do
      {
        (*(void (**)(void))v1)();
        v1 -= 4;
        --i;
      }
      while ( i );
    }
    result = sub_4012C0(sub_401340);
  }
  return result;
}
// 401770: using guessed type int dword_401770[];
// 402000: using guessed type int dword_402000;

//----- (004013F0) --------------------------------------------------------
#error "401513: positive sp value has been found (funcsize=109)"

//----- (00401520) --------------------------------------------------------
int __cdecl sub_401520()
{
  unsigned int v0; // ecx@1
  int v1; // edx@2
  int result; // eax@2

  v0 = (unsigned int)&unk_4030B0;
  while ( v0 < (unsigned int)&unk_4030B0 )
  {
    v1 = *(_DWORD *)(v0 + 4);
    result = *(_DWORD *)v0;
    v0 += 8;
    *(_DWORD *)(v1 + 4194304) += result;
  }
  return result;
}

//----- (00401550) --------------------------------------------------------
int __cdecl sub_401550()
{
  int result; // eax@1
  int v23; // [sp-8h] [bp-Ch]@0

  __asm { pushf }
  result = v23 ^ v23 ^ 0x200000;
  if ( result & 0x200000 )
  {
    _EAX = 0;
    __asm { cpuid }
    if ( result )
    {
      _EAX = 1;
      __asm { cpuid }
      if ( BYTE1(_EDX) & 1 )
        dword_404020 |= 1u;
      if ( _EDX & 0x8000 )
        dword_404020 |= 2u;
      if ( _EDX & 0x800000 )
        dword_404020 |= 4u;
      if ( _EDX & 0x1000000 )
        dword_404020 |= 8u;
      if ( _EDX & 0x2000000 )
        dword_404020 |= 0x10u;
      if ( _EDX & 0x4000000 )
        dword_404020 |= 0x20u;
      if ( _ECX & 1 )
        dword_404020 |= 0x40u;
      if ( BYTE1(_ECX) & 0x20 )
        dword_404020 |= 0x80u;
      _EAX = -2147483648;
      __asm { cpuid }
      if ( (unsigned int)result > 0x80000000 )
      {
        _EAX = -2147483647;
        __asm { cpuid }
        result = dword_404020;
        if ( _EDX & 0x40000000 )
        {
          result = dword_404020 | 0x300;
          dword_404020 |= 0x300u;
        }
        else
        {
          dword_404020 |= 0x100u;
        }
      }
    }
  }
  return result;
}
// 404020: using guessed type int dword_404020;

//----- (00401650) --------------------------------------------------------
void __cdecl sub_401650()
{
  __asm { fninit }
}

#error "There were 1 decompilation failure(s) on 11 function(s)"

Ну, как?

 

Вот неплохой обзор HexRays. Всё точки над i по сути расставлены. Отсюда видно, что, как минимум, надо неплохо знать и ассемблер и С. И уж тем более внутренности операционной системы (в данном случае виндовс). HexRays не работает с ресурсами и, соответственно не позволит получить "исходник" в прямом смысле этого слова. Отсюда вывод: надо или знать правила игры (что в случае героев не так то и сложно) и написать свой вариант. Или... просто изучить ассемблер и потратить пару недель на выдирание и осознание нужных алгоритмов и создание собственного кода на их основе. Попытка переложить "понимание" произвольных кусков кода на других людей - вообще бессмысленна.

 

Зачем декомпилировал стандартную библиотеку?

HexRays примитивен, но читать его вывод удобней чем чистые мнемоники. Для "this" указателей вам надо определить struct'ы (хороший декомпилятор это сделал бы автоматически) и по ходу реверсинга давать именам их полям.

 

Bato-San; дело в том что teremochek; озвучил прямо противоположные тенденции:

1)

2)

Первое требует понятных и легко-модифицируемых исходников.
Второе может предполагать получение точных параметров игры из оригинала.

Декомпилировав оригинал, получим невразумительный исходный код.
Вносить в него модификации и не вносить баги - это тот еще мазохизм.



Предположим напишем исходный код с нуля.
Выудим из оригинала все параметры игры и добьемся соответствия в своём коде.

Получим точную копию HoMM2

Боюсь, что этот труд не оценят - если можно поиграть в оригинал - зачем нужна ещё одна такая же игра?

Для модификации?
Не проще ли сразу делать по своему?

Имхо, этим и занимается разработчик free heroes 2

То есть такой проект уже есть.

Тогда зачем нужна эта тема?

 

daemolisher; Собственно это я и имел ввиду. С другой стороны - почему бы и не быть альтернативному проекту ? Хотя бы из соображений совместимости с современными операционными системами без неочевидных для многих манипуляций с Wing.

Хотя, как мне думается, тема свелась к обсуждению (не-)пригодности HexRays для нужд начинающих модеров.

 

Спасибо всем за ответы.

Да, абсолютно..
Спасибо, за объяснения.



На счет указателей. Кажется большая часть кода состоит из конструкции с такими-же указателями.
Если указатель, это число указывающее на адрес в памяти, для конкретного проекта. То следовательно не одна функция в отдельности работать не будет... Т.е. все эти указатели будут работать только в целом, не модифицируемом коде.
Значит, состряпать исходный код из этого в принципе не получится..
Правильно размышляю ?

 

teremochek; правильно. что бы использовать эти функции отдельно - надо понять их логику работы. просто их вставить куда то, в надежде, что и так заработает не получится.

 

Это мне вопрос? Спрашивайте у создателей HexRays.

---------- Сообщение добавлено в 01:33 ---------- Предыдущее сообщение размещено в 01:32 ----------

Большая часть кода, сгенерированного HexRays, важное уточнение.

 

teremochek, а вы не пробывали найти разработчика и попросить исходный код? Heroes of Might & Magic 2 не такие уж молодые и перспективные на сегодняшний день, что бы ожидать от них прибыль. Со своей колокольни я не вижу причин отказа. По крайней мере, если у вас действительно серьезные намерения, то вам найдется что предложить в замен лишним телодвежениям правообладателей.

Проблема только в поиске онных. Но, как говорится "Кто ищет, тот находит!"...