设为首页收藏本站喵玉殿官方微博

 找回密码
 少女注册中
搜索
喵玉殿论坛 · 喵玉汉化组»喵玉殿 › ◣喵玉の後宮◥ › 喵玉技术馆 › 【寻找逆向大佬中】关于HMX ecl opcode的求助 ...
返回列表 发新帖
查看: 487|回复: 7

[编程算法] 【寻找逆向大佬中】关于HMX ecl opcode的求助

[复制链接]
Jar387
发表于 2025-2-13 18:52:36 | 显示全部楼层 |阅读模式
本人技术宅，上个暑假写了个STG游戏的框架，准备把HMX移植到64位通用c99上（SDL2+openAL).
本体已经做完 在github repo但是对于opcode的一些细节产生了困难 比如
  1. #include <openstg.h>

  3. #define VOID enemy_data* enm
  4. #define P1 enemy_data* enm, param_t *p1
  5. #define P2 enemy_data* enm, param_t *p1, param_t *p2
  6. #define P3 enemy_data* enm, param_t *p1, param_t *p2, param_t *p3
  7. #define P4 enemy_data* enm, param_t *p1, param_t *p2, param_t *p3, param_t *p4
  8. #define P5 enemy_data* enm, param_t *p1, param_t *p2, param_t *p3, param_t *p4, param_t *p5
  9. #define P6 enemy_data* enm, param_t *p1, param_t *p2, param_t *p3, param_t *p4, param_t *p5, param_t *p6
  10. #define P7 enemy_data* enm, param_t *p1, param_t *p2, param_t *p3, param_t *p4, param_t *p5, param_t *p6, param_t *p7
  11. #define P8 enemy_data* enm, param_t *p1, param_t *p2, param_t *p3, param_t *p4, param_t *p5, param_t *p6, param_t *p7, param_t *p8
  12. #define P9 enemy_data* enm, param_t *p1, param_t *p2, param_t *p3, param_t *p4, param_t *p5, param_t *p6, param_t *p7, param_t *p8, param_t *p9
  13. #define P14 enemy_data* enm, param_t *p1, param_t *p2, param_t *p3, param_t *p4, param_t *p5, param_t *p6, param_t *p7, param_t *p8, param_t *p9, param_t *p10, param_t *p11, param_t *p12, param_t *p13, param_t *p14

  15. #define ECL_INS void

  17. // only void, 1, 2, 3, 4, 5, 6, 7, 8, 9, 14
  18. int ins_arg_count[] =
  19.     { 0, 1, 2, 3, 2, 2, 2, 3, 2, 3, 1, 1, 1, 3, 3, 3, 3, 3, 1, 1, 3, 3, 3, 3, 3,
  20.         5, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 0, 5, 5, 5, 5, 5, 5, 3, 3, 2, 1, 1, 1,
  21.         2, 2, 3, 3, 3,
  22.         3, 3, 3, 3, 3, 3, 3, 1, 1, 1, 1, 4, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 1, 1,
  23.         0, 0, 0, 3, 8,
  24.         0, 1, 14, 14, 1, 2, 2, 4, 1, 1, 3, 0, 7, 0, 1, 5, 2, 1, 1, 5, 3, 1, 1,
  25.         1, 1, 1, 2, 1,
  26.         1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 2, 1, 1, 1, 0, 1, 1, 1, 2, 1, 6, 1, 0, 0,
  27.         1, 0
  28. };

  30. int read_int_var(enemy_data * enm, int var_id)
  31. {                                // only used to get int
  32.         if (var_id >= 0 && var_id < FIELD_RANK_ID) {
  33.                 // local var
  34.                 ecl_stack_frame *frame = &(enm->stack[enm->sp]);
  35.                 if (var_id <= 3) {
  36.                         return frame->i_local_grp_1[var_id];
  37.                 } else if (var_id <= 7) {
  38.                         return -1;
  39.                 } else {
  40.                         var_id -= 8;
  41.                         return frame->i_local_grp_2[var_id];
  42.                 }
  43.         }
  44.         switch (var_id) {
  45.         case FIELD_RANK_ID:{
  46.                         return rank;
  47.                 }
  48.         case FIELD_DIFFICULTY_ID:{
  49.                         return difficulty;
  50.                 }
  51.         case FIELD_TIME_ID:{
  52.                         return enm->tick;
  53.                 }
  54.         case FIELD_LIFE_ID:{
  55.                         return enm->life;
  56.                 }
  57.         case FIELD_SHOT_TYPE_ID:{
  58.                         return shot_type;
  59.                 }
  60.         }
  61.         return -1;
  62. }

  64. float read_float_var(enemy_data * enm, int var_id)
  65. {                                // only used to get float
  66.         if (var_id >= 0 && var_id < FIELD_RANK_ID) {
  67.                 // local var
  68.                 ecl_stack_frame *frame = &(enm->stack[enm->sp]);
  69.                 if (var_id <= 3) {
  70.                         return -NAN;
  71.                 } else if (var_id <= 7) {
  72.                         var_id -= 4;
  73.                         return frame->f_local_grp_1[var_id];
  74.                 } else {
  75.                         return -NAN;
  76.                 }
  77.         }
  78.         switch (var_id) {
  79.         case FIELD_X_ID:{
  80.                         return enm->x;
  81.                 }
  82.         case FIELD_Y_ID:{
  83.                         return enm->y;
  84.                 }
  85.         case FIELD_Z_ID:{
  86.                         return enm->z;
  87.                 }
  88.         case FIELD_PLAYER_X_ID:{
  89.                         return player_x;
  90.                 }
  91.         case FIELD_PLAYER_Y_ID:{
  92.                         return player_y;
  93.                 }
  94.         case FIELD_PLAYER_Z_ID:{
  95.                         return player_z;
  96.                 }
  97.         case FIELD_AIM_ID:{
  98.                         return enm->aim;
  99.                 }
  100.         case FIELD_DIST_ID:{
  101.                         return enm->dist;
  102.                 }
  103.         }
  104.         return -NAN;
  105. }

  107. void write_int_var(enemy_data * enm, int var_id, int data)
  108. {                                // only used to put int
  109.         if (var_id >= 0 && var_id < FIELD_RANK_ID) {
  110.                 // local var
  111.                 ecl_stack_frame *frame = &(enm->stack[enm->sp]);
  112.                 if (var_id <= 3) {
  113.                         frame->i_local_grp_1[var_id] = data;
  114.                         return;
  115.                 } else if (var_id <= 7) {
  116.                         return;
  117.                 } else {
  118.                         var_id -= 8;
  119.                         frame->i_local_grp_2[var_id] = data;
  120.                         return;
  121.                 }
  122.         }
  123.         switch (var_id) {
  124.         case FIELD_TIME_ID:{
  125.                         enm->tick = data;
  126.                         return;
  127.                 }
  128.         case FIELD_LIFE_ID:{
  129.                         enm->life = data;
  130.                         return;
  131.                 }
  132.         }
  133. }

  135. void write_float_var(enemy_data * enm, int var_id, float data)
  136. {                                // only used to put float
  137.         if (var_id >= 0 && var_id < FIELD_RANK_ID) {
  138.                 // local var
  139.                 ecl_stack_frame *frame = &(enm->stack[enm->sp]);
  140.                 if (var_id <= 3) {
  141.                         return;
  142.                 } else if (var_id <= 7) {
  143.                         var_id -= 4;
  144.                         frame->f_local_grp_1[var_id] = data;
  145.                         return;
  146.                 } else {
  147.                         return;
  148.                 }
  149.         }
  150.         switch (var_id) {
  151.         case FIELD_X_ID:{
  152.                         enm->x = data;
  153.                         return;
  154.                 }
  155.         case FIELD_Y_ID:{
  156.                         enm->y = data;
  157.                         return;
  158.                 }
  159.         case FIELD_Z_ID:{
  160.                         enm->z = data;
  161.                         return;
  162.                 }
  163.         case FIELD_PLAYER_X_ID:{
  164.                         player_x = data;
  165.                         return;
  166.                 }
  167.         case FIELD_PLAYER_Y_ID:{
  168.                         player_y = data;
  169.                         return;
  170.                 }
  171.         case FIELD_PLAYER_Z_ID:{
  172.                         player_z = data;
  173.                         return;
  174.                 }
  175.         }
  176. }

  178. ECL_INS nop(VOID)
  179. {
  180. }

  182. ECL_INS delete(P1)
  183. {
  184.         // TODO: finish this after bossrush finished
  185.         info("multi enemy not supported yet");
  186. }

  188. ECL_INS jmp(P2)
  189. {
  190.         write_int_var(enm, FIELD_TIME_ID, p1->i);
  191.         int ip = search_symbol(enm, p2->hash);
  192.         if (ip == -1) {
  193.                 ABORT("bad symbol");
  194.         }
  195.         enm->ip = ip - 1;
  196. }

  198. ECL_INS loop(P3)
  199. {
  200.         int cx = read_int_var(enm, p3->var_id);
  201.         if (cx == 0) {
  202.                 return;
  203.         }
  204.         write_int_var(enm, p3->var_id, cx - 1);
  205.         jmp(enm, p1, p2);
  206. }

  208. ECL_INS iset(P2)
  209. {
  210.         write_int_var(enm, p1->var_id, p2->i);
  211. }

  213. ECL_INS fset(P2)
  214. {
  215.         write_float_var(enm, p1->var_id, p2->f);
  216. }

  218. ECL_INS iset_r(P2)
  219. {
  220.         write_int_var(enm, p1->var_id, zundom_i(p2->i));
  221. }

  223. ECL_INS iset_r2(P3)
  224. {
  225.         write_int_var(enm, p1->var_id, zundom_i2(p2->i, p3->i));
  226. }

  228. ECL_INS fset_r(P2)
  229. {
  230.         write_float_var(enm, p1->var_id, zundom_f(p2->f));
  231. }

  233. ECL_INS fset_r2(P3)
  234. {
  235.         write_float_var(enm, p1->var_id, zundom_f2(p2->f, p3->f));
  236. }

  238. ECL_INS get_x(P1)
  239. {
  240.         write_float_var(enm, p1->var_id, enm->x);
  241. }

  243. ECL_INS get_y(P1)
  244. {
  245.         write_float_var(enm, p1->var_id, enm->y);
  246. }

  248. ECL_INS get_z(P1)
  249. {
  250.         write_float_var(enm, p1->var_id, enm->z);
  251. }

  253. ECL_INS iadd(P3)
  254. {
  255.         write_int_var(enm, p1->var_id, (p2->i) + (p3->i));
  256. }

  258. ECL_INS isub(P3)
  259. {
  260.         write_int_var(enm, p1->var_id, (p2->i) - (p3->i));
  261. }

  263. ECL_INS imul(P3)
  264. {
  265.         write_int_var(enm, p1->var_id, (p2->i) * (p3->i));
  266. }

  268. ECL_INS idiv(P3)
  269. {
  270.         write_int_var(enm, p1->var_id, (p2->i) / (p3->i));
  271. }

  273. ECL_INS imod(P3)
  274. {
  275.         write_int_var(enm, p1->var_id, (p2->i) % (p3->i));
  276. }

  278. ECL_INS inc(P1)
  279. {
  280.         if (p1->type == PARAM_TYPE_INT) {
  281.                 write_int_var(enm, p1->var_id,
  282.                               read_int_var(enm, p1->var_id) + 1);
  283.         } else if (p1->type == PARAM_TYPE_FLOAT) {
  284.                 write_float_var(enm, p1->var_id,
  285.                                 read_float_var(enm, p1->var_id) + 1.0f);
  286.         }
  287. }

  289. ECL_INS dec(P1)
  290. {
  291.         if (p1->type == PARAM_TYPE_INT) {
  292.                 write_int_var(enm, p1->var_id,
  293.                               read_int_var(enm, p1->var_id) - 1);
  294.         } else if (p1->type == PARAM_TYPE_FLOAT) {
  295.                 write_float_var(enm, p1->var_id,
  296.                                 read_float_var(enm, p1->var_id) - 1.0f);
  297.         }
  298. }

  300. ECL_INS fadd(P3)
  301. {
  302.         write_float_var(enm, p1->var_id, (p2->f) + (p3->f));
  303. }

  305. ECL_INS fsub(P3)
  306. {
  307.         write_float_var(enm, p1->var_id, (p2->f) - (p3->f));
  308. }

  310. ECL_INS fmul(P3)
  311. {
  312.         write_float_var(enm, p1->var_id, (p2->f) * (p3->f));
  313. }

  315. ECL_INS fdiv(P3)
  316. {
  317.         write_float_var(enm, p1->var_id, (p2->f) / (p3->f));
  318. }

  320. ECL_INS ecl_fmod(P3)                // name conflict by libm
  321. {                                // IEEE 754 remainder
  322.         write_float_var(enm, p1->var_id, IEEE_754_remainder(p2->f, p3->f));
  323. }

  325. ECL_INS ecl_atan2(P5)                // name conflict by libm
  326. {
  327.         write_float_var(enm, p1->var_id,
  328.                         atan((p4->f - p2->f) / (p5->f - p3->f)));
  329. }

  331. ECL_INS norm_r(P1)
  332. {
  333.         float f = read_float_var(enm, p1->var_id);
  334.         int pi_count = (int)(f / M_PI);
  335.         if (f <= 0.0f) {
  336.                 f += pi_count * M_PI;
  337.         } else {
  338.                 f -= pi_count * M_PI;
  339.         }
  340.         write_float_var(enm, p1->var_id, f);
  341. }

  343. ECL_INS itest(P2)
  344. {
  345.         if (p1->i < p2->i) {
  346.                 enm->cmp_reg = -1;
  347.         } else if (p1->i == p2->i) {
  348.                 enm->cmp_reg = 0;
  349.         } else {
  350.                 enm->cmp_reg = 1;
  351.         }
  352. }

  354. ECL_INS ftest(P2)
  355. {
  356.         if (p1->f < p2->f) {
  357.                 enm->cmp_reg = -1;
  358.         } else if (p1->f == p2->f) {
  359.                 enm->cmp_reg = 0;
  360.         } else if (p1->f > p2->f) {
  361.                 enm->cmp_reg = 1;
  362.         }
  363. }

  365. ECL_INS jmp_l(P2)
  366. {
  367.         if (enm->cmp_reg == -1) {
  368.                 jmp(enm, p1, p2);
  369.         }
  370. }

  372. ECL_INS jmp_le(P2)
  373. {
  374.         if (enm->cmp_reg == -1 || enm->cmp_reg == 0) {
  375.                 jmp(enm, p1, p2);
  376.         }
  377. }

  379. ECL_INS jmp_e(P2)
  380. {
  381.         if (enm->cmp_reg == 0) {
  382.                 jmp(enm, p1, p2);
  383.         }
  384. }

  386. ECL_INS jmp_g(P2)
  387. {
  388.         if (enm->cmp_reg == 1) {
  389.                 jmp(enm, p1, p2);
  390.         }
  391. }

  393. ECL_INS jmp_ge(P2)
  394. {
  395.         if (enm->cmp_reg == 0 || enm->cmp_reg == 1) {
  396.                 jmp(enm, p1, p2);
  397.         }
  398. }

  400. ECL_INS jmp_n(P2)
  401. {
  402.         if (enm->cmp_reg == -1 || enm->cmp_reg == 1) {
  403.                 jmp(enm, p1, p2);
  404.         }
  405. }

  407. ECL_INS call(P3)
  408. {
  409.         enm->sp++;
  410.         if (enm->sp >= MAX_STACK_DEPTH) {
  411.                 ABORT("stack overflow");
  412.         }
  413.         ecl_stack_frame *curr_stack = &(enm->stack[enm->sp]);
  414.         // enm->ip always point to currently executing instruction
  415.         // as ip will automaticly increase by 1 after any instruction exection
  416.         // point return addr to currently "call" and after "return", ip will point to the next ins after "call"
  417.         curr_stack->return_address = enm->ip;
  418.         // set param
  419.         curr_stack->i_local_grp_1[0] = p2->i;
  420.         curr_stack->f_local_grp_1[0] = p3->f;
  421.         curr_stack->return_function = enm->fp;
  422.         int ip = search_sub(p1->hash, &enm->fp);
  423.         if (ip == -1) {
  424.                 ABORT("bad sub");
  425.         }
  426.         enm->ip = ip - 1;
  427. }

  429. ECL_INS ret(VOID)
  430. {
  431.         if (enm->sp == 0 || (enm->stack)[enm->sp].return_address == -1
  432.             || (enm->stack)[enm->sp].return_function == -1) {
  433.                 ABORT("stack underflow");
  434.         }
  435.         enm->ip = (enm->stack)[enm->sp].return_address;
  436.         enm->fp = (enm->stack)[enm->sp].return_function;
  437.         enm->sp--;
  438.         info("%i %i", enm->fp, enm->ip);
  439. }

  441. ECL_INS call_l(P3)
  442. {
  443.         if (enm->cmp_reg == -1) {
  444.                 call(enm, p1, p2, p3);
  445.         }
  446. }

  448. ECL_INS call_le(P3)
  449. {
  450.         if (enm->cmp_reg == -1 || enm->cmp_reg == 0) {
  451.                 call(enm, p1, p2, p3);
  452.         }
  453. }

  455. ECL_INS call_e(P3)
  456. {
  457.         if (enm->cmp_reg == 0) {
  458.                 call(enm, p1, p2, p3);
  459.         }
  460. }

  462. ECL_INS call_g(P3)
  463. {
  464.         if (enm->cmp_reg == 1) {
  465.                 call(enm, p1, p2, p3);
  466.         }
  467. }

  469. ECL_INS call_ge(P3)
  470. {
  471.         if (enm->cmp_reg == 0 || enm->cmp_reg == 1) {
  472.                 call(enm, p1, p2, p3);
  473.         }
  474. }

  476. ECL_INS call_n(P3)
  477. {
  478.         if (enm->cmp_reg == -1 || enm->cmp_reg == 1) {
  479.                 call(enm, p1, p2, p3);
  480.         }
  481. }

  483. ECL_INS pos(P3)
  484. {
  485.         enm->x = p1->f;
  486.         enm->y = p2->f;
  487.         enm->z = p3->f;
  488. }

  490. ECL_INS dir(P2)
  491. {
  492.         enm->dir = p1->f;
  493.         enm->v = p2->f;
  494. }

  496. ECL_INS rot(P1)
  497. {
  498.         enm->delta_dir = p1->f;
  499. }

  501. ECL_INS spd(P1)
  502. {
  503.         enm->v = p1->f;
  504. }

  506. ECL_INS acc(P1)
  507. {
  508.         enm->deltav = p1->f;
  509. }

  511. ECL_INS rot_r(P2)
  512. {
  513.         enm->dir = zundom_f2(p1->f, p2->f);
  514. }

  516. ECL_INS rot_r2(P2)
  517. {
  518.         enm->dir = zundom_f2(p1->f, p2->f);
  519. }

  521. ECL_INS rot_aim(P2)
  522. {                                // document conflict between pytouhou(P2) and touhouwiki(P3)
  523.         enm->dir = player_angle((v2d) {
  524.                                 enm->x, enm->y}
  525.         ) + p1->f;
  526.         enm->v = p2->f;
  527. }

  529. // all acc and dec need test to match original game behavior
  530. ECL_INS it_dec(P3)
  531. {
  532.         enm->dir = p2->f;
  533.         enm->v = p3->f;
  534.         enm->deltav = -abs_f(enm->deltav);
  535. }

  537. ECL_INS it_dec2(P3)
  538. {

  540. }

  542. ECL_INS it_acc(P3)
  543. {

  545. }

  547. ECL_INS it_acc2(P3)
  548. {

  550. }

  552. ECL_INS it_pt_lin(P4)
  553. {

  555. }

  557. ECL_INS it_pt_dec(P4)
  558. {

  560. }

  562. ECL_INS it_pt_dec2(P4)
  563. {

  565. }

  567. ECL_INS it_pt_acc(P4)
  568. {

  570. }

  572. ECL_INS it_pt_acc2(P4)
  573. {

  575. }

  577. ECL_INS it_t_dec(P4)
  578. {

  580. }

  582. ECL_INS it_t_dec2(P4)
  583. {

  585. }

  587. ECL_INS it_t_acc(P4)
  588. {

  590. }

  592. ECL_INS it_t_acc2(P4)
  593. {

  595. }

  597. ECL_INS clip(P4)
  598. {
  599.         enm->is_clip = 1;
  600.         enm->clip_lu.x = p1->f;
  601.         enm->clip_lu.y = p2->f;
  602.         enm->clip_rd.x = p3->f;
  603.         enm->clip_rd.y = p4->f;
  604. }

  606. ECL_INS unclip(VOID)
  607. {
  608.         enm->is_clip = 0;
  609. }

  611. ECL_INS et_on_fan_aim(P9)
  612. {
  613.         create_buman();
  614.         bstyle(TRACE);
  615.         bshape(p2->i, p1->i);
  616.         boffset(enm->x + enm->launch_off_x, enm->y + enm->launch_off_y);
  617.         bamount(p3->i, p4->i);
  618.         bspeed(p5->f, p6->f);
  619.         bangle(rad2ang(p7->f), rad2ang(p8->f));
  620. }

  622. ECL_INS et_on_fan(P9)
  623. {
  624.         create_buman();
  625.         bstyle(DEFAULT);
  626.         bshape(p2->i, p1->i);
  627.         boffset(enm->x + enm->launch_off_x, enm->y + enm->launch_off_y);
  628.         bamount(p3->i, p4->i);
  629.         bspeed(p5->f, p6->f);
  630.         bangle(rad2ang(p7->f), rad2ang(p8->f));
  631. }

  633. ECL_INS et_on_cir_aim(P9)
  634. {
  635.         create_buman();
  636.         bstyle(LAYER_DIF_TRACE);
  637.         bshape(p2->i, p1->i);
  638.         boffset(enm->x + enm->launch_off_x, enm->y + enm->launch_off_y);
  639.         bamount(p3->i, p4->i);
  640.         bspeed(p5->f, p6->f);
  641.         bangle(rad2ang(p7->f), rad2ang(p8->f));
  642. }

  644. ECL_INS et_on_cir(P9)
  645. {
  646.         create_buman();
  647.         bstyle(LAYER_DIF);
  648.         bshape(p2->i, p1->i);
  649.         boffset(enm->x + enm->launch_off_x, enm->y + enm->launch_off_y);
  650.         bamount(p3->i, p4->i);
  651.         bspeed(p5->f, p6->f);
  652.         bangle(rad2ang(p7->f), rad2ang(p8->f));
  653. }

  655. ECL_INS et_on_random_r(P9)
  656. {
  657.         create_buman();
  658.         bstyle(RANDOM_DIR);
  659.         bshape(p2->i, p1->i);
  660.         boffset(enm->x + enm->launch_off_x, enm->y + enm->launch_off_y);
  661.         bamount(p3->i, p4->i);
  662.         bspeed(p5->f, p6->f);
  663.         bangle(rad2ang(p7->f), rad2ang(p8->f));
  664. }

  666. ECL_INS et_on_random_sp(P9)
  667. {
  668.         create_buman();
  669.         bstyle(RANDOM_SPEED);
  670.         bshape(p2->i, p1->i);
  671.         boffset(enm->x + enm->launch_off_x, enm->y + enm->launch_off_y);
  672.         bamount(p3->i, p4->i);
  673.         bspeed(p5->f, p6->f);
  674.         bangle(rad2ang(p7->f), rad2ang(p8->f));
  675. }

  677. ECL_INS et_on_random(P9)
  678. {
  679.         create_buman();
  680.         bstyle(RANDOM);
  681.         bshape(p2->i, p1->i);
  682.         boffset(enm->x + enm->launch_off_x, enm->y + enm->launch_off_y);
  683.         bamount(p3->i, p4->i);
  684.         bspeed(p5->f, p6->f);
  685.         bangle(rad2ang(p7->f), rad2ang(p8->f));
  686. }

  688. ECL_INS interrupt(P2)
  689. {
  690.         // int behave as jmp to sub
  691.         int ip = search_sub(p1->hash, &enm->fp);
  692.         if (ip == -1) {
  693.                 ABORT("bad sub")
  694.         }
  695.         enm->ip = ip - 1;
  696. }

  698. ECL_INS breakpoint(VOID)
  699. {
  700.         printf("STOP AT MAGIC BREAKPOINT\n");
  701.         is_step = 1;
  702. }

  704. void *ins_prg[] =
  705.     { nop, delete, jmp, loop, iset, fset, iset_r, iset_r2, fset_r, fset_r2,
  706.         get_x, get_y,
  707.         get_z, iadd, isub, imul, idiv, imod, inc, dec, fadd, fsub, fmul, fdiv,
  708.         fmod,
  709.         ecl_atan2, norm_r, itest, ftest, jmp_l, jmp_le, jmp_e, jmp_g, jmp_ge,
  710.         jmp_n, call, ret,
  711.         call_l, call_le,        // spectre instruction
  712.         call_e, call_g, call_ge, call_n, pos, NULL, dir, rot, spd, acc, rot_r,
  713.         rot_r2, rot_aim,
  714.         it_dec, it_dec2,
  715.         it_acc, it_acc2, it_pt_lin, it_pt_dec, it_pt_dec2, it_pt_acc,
  716.         it_pt_acc2, it_t_dec, it_t_dec2, it_t_acc, it_t_acc2, clip,
  717.         unclip, et_on_fan_aim,
  718.         et_on_fan, et_on_cir_aim, et_on_cir, NULL, NULL, et_on_random_r,
  719.         et_on_random_sp, et_on_random, NULL, NULL, NULL, NULL, NULL, NULL,
  720.         NULL, NULL, NULL,
  721.         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  722.         NULL, NULL, NULL,
  723.         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, interrupt, NULL,
  724.         NULL,
  725.         NULL, NULL, NULL,
  726.         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  727.         NULL, NULL, NULL, NULL,
  728.         NULL, NULL, NULL, NULL, NULL, breakpoint
  729. };
复制代码
中530行后有很多敌人移动等opcode在thwiki与外文wiki中没有对具体加速/速度的像素数作出解释
求逆向大佬可不可以翻出原版游戏的具体数值 谢谢
PS：当然我知道这种帖子肯定没人会看的了 只是希望出现奇迹（笑）

回复

使用道具 举报

发表于 2025-2-13 20:06:03 | 显示全部楼层
不懂帮顶，或许你可以尝试用THTK自己拆包看看？
回复

使用道具 举报

Jar387
 楼主| 发表于 2025-2-13 21:20:00 | 显示全部楼层
定难军节度使 发表于 2025-2-13 20:06
不懂帮顶，或许你可以尝试用THTK自己拆包看看？

这个不是ECL或者THTK可以拆出来的 是属于游戏EXE内的硬编码

点评

定难军节度使
那就爱莫能助了，或许有其他的exe解包软件？  发表于 2025-2-13 21:27
回复

使用道具 举报

ROCO2017
发表于 2025-3-11 01:03:28 | 显示全部楼层
Jar387 发表于 2025-2-13 21:20
这个不是ECL或者THTK可以拆出来的 是属于游戏EXE内的硬编码

目前来说对原作ecl比较有研究的佬在魔改群里，您可以来这个群里讨论一下：489710775
这群里的伙计很多对thbwiki上ecl代码资料的完善做出不少贡献，应该能解答你的问题。

点评

ROCO2017
即便是问逆向相关的东西也可以来，因为写ecl资料本身就要对原作引擎作逆向，很多东西应该是可以帮你看一下。  发表于 2025-3-11 01:06
回复

使用道具 举报

Kuriyama_Mirai
发表于 2025-7-10 14:34:24 | 显示全部楼层
本帖最后由 Kuriyama_Mirai 于 2025-7-10 17:32 编辑

你听过 Happy Havoc 的 红魔乡逆向工程仓库 吗

帮你问了一些大佬，zero318 说“你可能需要迁就一些剩下的 opcode 而更改大量的代码，
尤其是 Patchy 用的 ‘call stack disable flag’”。

他还在 这里 写过一个更可读的 ECL 解析器，尽管那个解析器不是为了 100% 准确地模拟而写的；
不过，至少里面的 instructions 都是基于对原作代码基于比较良好的理解而命名的。

那里面的很多目前的文档，据他所说，不够完整，甚至在一些细节上有错误。
回复

使用道具 举报

Jar387
 楼主| 发表于 2025-7-14 07:31:07 来自手机 | 显示全部楼层
Kuriyama_Mirai 发表于 2025-7-10 14:34
你听过 Happy Havoc 的 红魔乡逆向工程仓库 吗

帮你问了一些大佬，zero318 说“你可能需要迁就一些剩下的  ...

非常感谢 不过有点晚了 我的那个项目已经2次重构 现在和原作ecl没关系 更像86汇编和一些渲染 弹幕utility的结合体
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 少女注册中

本版积分规则

合作与事务联系|无图版|手机版|小黑屋|喵玉殿

GMT+8, 2025-10-31 00:02

Powered by Discuz! X3.5

© 2001-2025 Discuz! Team.

快速回复 返回顶部 返回列表