База данных IDA от void17

AlexSpl писал(а):

Кстати, сейчас переименовал в bbb(). Пока не слетает

А если написать ft0l, будет работать?

Факт в том, что если переименовать в ftol() слетает. Очень странно.

* * *
Ещё одно "открытие". Всё указывает на то, что type_enchant_data входит в состав структуры type_spell_choice:

Код: Выделить всё

#pragma pack(push, 4)
struct type_spell_choice
{
  type_enchant_data enchantData;
  int hex;
  int f_24;
  int spellValue;
  char shouldAttackNow;
};
#pragma pack(pop)

Вот пример того случая, когда Вы очень захотите себе новый ftol(). Оригинальная функция:

Код: Выделить всё

int __thiscall type_monster_data::cast_resurrection(
        type_monster_data *this,
        type_spell_choice *spellChoice,
        hero *hero)
{
  double v3; // st7
  type_spell_choice *spell_choice; // esi
  type_monster_data *v5; // ebx
  int v6; // edi
  int v7; // ecx
  int hex; // esi
  type_monster_data *Monster_Data; // eax
  hero *v10; // ebx
  __int64 v12; // rax
  type_monster_data *v13; // ebx
  vector *v14; // ecx
  type_monster_data *v16; // eax
  int v17; // ecx
  int v18; // ecx
  int v19; // edx
  int v20; // edi
  char *v21; // edi
  int v22; // eax
  type_monster_data *v24; // edi
  __int64 v25; // rax
  type_monster_data *v26; // edi
  vector *v27; // ecx
  bool v29; // zf
  type_monster_data *v39; // [esp+20h] [ebp-14h]
  int v40; // [esp+24h] [ebp-10h]
  int v41; // [esp+24h] [ebp-10h]
  int v43; // [esp+28h] [ebp-Ch]
  int v44; // [esp+28h] [ebp-Ch]
  vector *vector; // [esp+28h] [ebp-Ch]
  int v47; // [esp+2Ch] [ebp-8h]
  int spellDuration; // [esp+30h] [ebp-4h]
  int v49; // [esp+30h] [ebp-4h]
  int spell_duration; // [esp+3Ch] [ebp+8h]
  hero *Herob; // [esp+40h] [ebp+Ch]
  hero *Herod; // [esp+40h] [ebp+Ch]
  hero *Heroa; // [esp+40h] [ebp+Ch]
  char v55; // [esp+44h] [ebp+10h]

  spell_choice = spellChoice;
  v5 = this;
  if ( SpellTargetsASingleArmy(spellChoice->enchantData.spellID, spellChoice->enchantData.skillMastery) )
  {
    v6 = &v5->Monster_Data[6 * spellChoice->hex];
    if ( *(v6 + 64) )
    {
      spell_duration = spellChoice->enchantData.spellDuration;
      if ( spell_choice->enchantData.spellDuration > 5 )
        spell_duration = 5;
      v40 = akSpelltraits[spell_choice->enchantData.spellID].AIValue[spell_choice->enchantData.skillMastery];
      get_spell_work_chance(spell_choice->enchantData.spellID, *(v6 + 4), hero, v5[3].vector);
      __asm { fstp    [ebp+var_C]; Store Real and Pop }
      Herob = (spell_duration * v40 * *(v6 + 64));
      __asm
      {
        fild    [ebp+Hero]; Load Integer
        fstp    [ebp+Hero]; Store Real and Pop
        fld     [ebp+Hero]; Load Real
        fmul    [ebp+var_C]; Multiply Real
        fdiv    ds:float_500_0; Divide Real
      }
      v7 = ftol(v3);
    }
    else
    {
      v7 = 0;
    }
    hex = spell_choice->hex;
    Monster_Data = v5->Monster_Data;
    v10 = Monster_Data[6 * hex + 5].Monster_Data;
    _ESI = &Monster_Data[6 * hex];
    Herod = v10;
    __asm { fild    [ebp+Hero]; Load Integer }
    Heroa = _ESI[5].vector;
    __asm
    {
      fstp    qword ptr [ebp-20h]; Store Real and Pop
      fld     qword ptr [ebp-20h]; Load Real
      fmul    qword ptr [esi+30h]; Multiply Real
      fstp    [ebp+var_18]; Store Real and Pop
    }
    v12 = v7 * Heroa / v10;
    if ( v55 )
    {
      v13 = (v10 + v7);
      v14 = (Heroa + v12);
    }
    else
    {
      v13 = (v10 - v7);
      v14 = (Heroa - v12);
    }
    _ESI[5].Monster_Data = v13;
    __asm { fild    dword ptr [esi+40h]; Load Integer }
    _ESI[5].vector = v14;
    __asm
    {
      fstp    qword ptr [ebp-20h]; Store Real and Pop
      fld     qword ptr [ebp-20h]; Load Real
      fdiv    [ebp+var_18]; Divide Real
      fstp    qword ptr [esi+30h]; Store Real and Pop
    }
    *&_ESI[4].vector = _RT1;
  }
  else
  {
    v16 = v5->Monster_Data;
    if ( v16 )
    {
      v17 = v5->field_8 - v16;
      LODWORD(v12) = ((954437177i64 * v17) >> 32) >> 31;
      HIDWORD(v12) = v17 / 72;
    }
    else
    {
      v12 = 0i64;
    }
    v18 = HIDWORD(v12);
    v19 = HIDWORD(v12) - 1;
    if ( v18 > 0 )
    {
      v20 = 72 * v19;
      v47 = 6 * v19;
      v41 = v19 + 1;
      do
      {
        v21 = v5->Monster_Data + v20;
        if ( *(v21 + 16) )
        {
          spellDuration = spell_choice->enchantData.spellDuration;
          if ( spellDuration > 5 )
            spellDuration = 5;
          v43 = akSpelltraits[spell_choice->enchantData.spellID].AIValue[spell_choice->enchantData.skillMastery];
          get_spell_work_chance(spell_choice->enchantData.spellID, *(v21 + 1), hero, v5[3].vector);
          __asm { fstp    dword ptr [ebp+var_18+4]; Store Real and Pop }
          v44 = spellDuration * v43 * *(v21 + 16);
          __asm
          {
            fild    [ebp+var_C]; Load Integer
            fstp    [ebp+var_C]; Store Real and Pop
            fld     [ebp+var_C]; Load Real
            fmul    dword ptr [ebp+var_18+4]; Multiply Real
            fdiv    ds:float_500_0; Divide Real
          }
          v22 = ftol(v3);
          v49 = v22;
          if ( v22 > 0 )
          {
            _ESI = &v5->Monster_Data[v47];
            v24 = _ESI[5].Monster_Data;
            vector = _ESI[5].vector;
            v39 = v24;
            __asm
            {
              fild    dword ptr [ebp+var_18+4]; Load Integer
              fstp    [ebp+var_18]; Store Real and Pop
              fld     [ebp+var_18]; Load Real
              fmul    qword ptr [esi+30h]; Multiply Real
              fstp    qword ptr [ebp-28h]; Store Real and Pop
            }
            v25 = v22 * vector / v24;
            if ( v55 )
            {
              v26 = (v24 + v49);
              v27 = (vector + v25);
            }
            else
            {
              v26 = (v24 - v49);
              v27 = (vector - v25);
            }
            _ESI[5].Monster_Data = v26;
            __asm { fild    dword ptr [esi+40h]; Load Integer }
            v5 = this;
            _ESI[5].vector = v27;
            __asm
            {
              fstp    [ebp+var_18]; Store Real and Pop
              fld     [ebp+var_18]; Load Real
              fdiv    qword ptr [ebp-28h]; Divide Real
              fstp    qword ptr [esi+30h]; Store Real and Pop
            }
            *&_ESI[4].vector = _RT1;
            spell_choice = spellChoice;
          }
        }
        LODWORD(v12) = v41 - 1;
        v20 = v47 * 12 - 72;
        v29 = v41-- == 1;
        v47 -= 6;
      }
      while ( !v29 );
    }
  }
  return v12;
}

Заметили __asm?

Функция с новым ftol() (не обращайте внимание на отсутствие типов, ещё не задавал):

Код: Выделить всё

int __thiscall sub_4258A0(_DWORD *this, _DWORD *a2, int a3, char a4)
{
  _DWORD *v4; // esi
  _DWORD *v5; // ebx
  int v6; // edi
  int v7; // ecx
  int v8; // esi
  int v9; // eax
  int v10; // ebx
  int v11; // esi
  __int64 v12; // rax
  int v13; // ebx
  int v14; // ecx
  double v15; // st7
  int v16; // eax
  int v17; // ecx
  int v18; // ecx
  int v19; // edx
  int v20; // edi
  int v21; // edi
  int v22; // eax
  int v23; // esi
  int v24; // edi
  __int64 v25; // rax
  int v26; // edi
  int v27; // ecx
  double v28; // st7
  bool v29; // zf
  double v31; // [esp+Ch] [ebp-28h]
  double v33; // [esp+1Ch] [ebp-18h]
  float v34; // [esp+20h] [ebp-14h]
  int v35; // [esp+24h] [ebp-10h]
  int v36; // [esp+24h] [ebp-10h]
  float v37; // [esp+28h] [ebp-Ch]
  int v38; // [esp+28h] [ebp-Ch]
  float v39; // [esp+28h] [ebp-Ch]
  int v40; // [esp+28h] [ebp-Ch]
  int v41; // [esp+2Ch] [ebp-8h]
  int v42; // [esp+30h] [ebp-4h]
  int v43; // [esp+30h] [ebp-4h]
  int v44; // [esp+3Ch] [ebp+8h]
  float v45; // [esp+40h] [ebp+Ch]
  int v46; // [esp+40h] [ebp+Ch]

  v4 = a2;
  v5 = this;
  if ( sub_59E360(*a2, a2[1]) )
  {
    v6 = v5[1] + 72 * a2[5];
    if ( *(v6 + 64) )
    {
      v44 = a2[3];
      if ( v4[3] > 5 )
        v44 = 5;
      v35 = *(off_687FA8 + 34 * *v4 + v4[1] + 26);
      v37 = sub_44A1A0(a3, v5[9]);
      v45 = (v44 * v35 * *(v6 + 64));
      v7 = bbb(v45 * v37 / 500.0);
    }
    else
    {
      v7 = 0;
    }
    v8 = v4[5];
    v9 = v5[1];
    v10 = *(v9 + 72 * v8 + 64);
    v11 = v9 + 72 * v8;
    v46 = *(v11 + 60);
    v33 = v10 * *(v11 + 48);
    v12 = v7 * v46 / v10;
    if ( a4 )
    {
      v13 = v7 + v10;
      v14 = v12 + v46;
    }
    else
    {
      v13 = v10 - v7;
      v14 = v46 - v12;
    }
    *(v11 + 64) = v13;
    v15 = *(v11 + 64);
    *(v11 + 60) = v14;
    *(v11 + 48) = v15 / v33;
  }
  else
  {
    v16 = v5[1];
    if ( v16 )
    {
      v17 = v5[2] - v16;
      LODWORD(v12) = ((954437177i64 * v17) >> 32) >> 31;
      HIDWORD(v12) = v17 / 72;
    }
    else
    {
      v12 = 0i64;
    }
    v18 = HIDWORD(v12);
    v19 = HIDWORD(v12) - 1;
    if ( v18 > 0 )
    {
      v20 = 72 * v19;
      v41 = 72 * v19;
      v36 = v19 + 1;
      do
      {
        v21 = v5[1] + v20;
        if ( *(v21 + 64) )
        {
          v42 = v4[3];
          if ( v42 > 5 )
            v42 = 5;
          v38 = *(off_687FA8 + 34 * *v4 + v4[1] + 26);
          v34 = sub_44A1A0(a3, v5[9]);
          v39 = (v42 * v38 * *(v21 + 64));
          v22 = bbb(v39 * v34 / 500.0);
          v43 = v22;
          if ( v22 > 0 )
          {
            v23 = v5[1] + v41;
            v24 = *(v23 + 64);
            v40 = *(v23 + 60);
            v31 = v24 * *(v23 + 48);
            v25 = v22 * v40 / v24;
            if ( a4 )
            {
              v26 = v43 + v24;
              v27 = v25 + v40;
            }
            else
            {
              v26 = v24 - v43;
              v27 = v40 - v25;
            }
            *(v23 + 64) = v26;
            v28 = *(v23 + 64);
            v5 = this;
            *(v23 + 60) = v27;
            *(v23 + 48) = v28 / v31;
            v4 = a2;
          }
        }
        LODWORD(v12) = v36 - 1;
        v20 = v41 - 72;
        v29 = v36-- == 1;
        v41 -= 72;
      }
      while ( !v29 );
    }
  }
  return v12;
}

Убедительный аргумент в пользу нового ftol()?

Вот этого LODWORD(v12) = ((954437177i64 * v17) >> 32) >> 31; не пугайтесь. Должно исчезнуть после раздачи правильных типов. Такое с get_age_value() было, а там всего лишь деление на 3. Вы посмотрите, как красиво на 500.0 делит!

Так. Удалось поправить даже в оригинальной базе. У get_spell_work_chance() стоял неправильный возвращаемый тип

Красота

Да это простенькая свитч-функция, они впринципе все красивые

Тут уже отличие от RoE. В RoE третьим аргументом bool, а также в вызывающих эту функцию.

Это понятно, потому что следует учитывать нововведения SoD.

А Вы неподъёмную задачу, на первый взгляд, себе поставили. Декомпилировать вообще всё... А точно хватит энтузиазма? У меня вот задача-минимум - декомпилировать всё, что связано с заклинаниями. Больше мне пока не нужно (я уже могу написать относительно неплохие функции взвешивания). Но для остальных моддеров такая база безусловно станет подарком. С ней уже намного проще работать, чем со старой воговской. Респект, void_17

Я бы сделал акцент на AI и RMG как на двух самых неизученных областях Героев 3. Вы сейчас начнёте декомпилировать DirectPlay и растеряете весь энтузиазм. Посмотрите, сколько проектов дошли до финала, а сколько канули в Лету? Лучше уж не распыляться, мне кажется.

Цитата:

Да это простенькая свитч-функция, они впринципе все красивые

Забыл прокомментировать. Сложные - мрак. Пока не будет нормальных способов упорядочивать реюз переменных, листинги будут получаться не совсем читаемыми. Я в школе баловался реюзом: типа, зачем тратить переменные, если можно пользоваться одной-двумя? Вот такой реальный загон был А у компилятора, похоже, до сих пор такой, но у него хотя бы оправдание есть - скорость выполнения программы. Может, в IDA есть инструменты, позволяющие бороться с реюзом (особо достаёт, когда компилятор мешает вещественные типы и целые), но я о них не знаю. Было бы здорово как-нибудь упорядочить этот хаос.

Почему моя база выросла до 161 МБ? Так же не должно быть. Открывается, но размер какой-то уж слишком большой.

Так, выбрал deflate при сохранении и стала 18 МБ. Это что такое? Открывается нормально. Такой фишки я не знал. Первый раз выбрал deflate. А если выбрать Collect garbage, то вообще 15 МБ получилось