Subversion Repositories Games.Carmageddon

Rev

Rev 18 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. #include "flicplay.h"
  2. #include "brender/brender.h"
  3. #include "displays.h"
  4. #include "drmem.h"
  5. #include "errors.h"
  6. #include "globvars.h"
  7. #include "graphics.h"
  8. #include "harness/trace.h"
  9. #include "input.h"
  10. #include "loading.h"
  11. #include "main.h"
  12. #include "pd/sys.h"
  13. #include "sound.h"
  14. #include "utility.h"
  15. #include <stdlib.h>
  16. #include <string.h>
  17.  
  18. int gPalette_allocate_count;
  19. int gPalette_fuck_prevention;
  20. int gDark_mode;
  21. int gTransparency_on;
  22. int gPanel_flic_disable;
  23. int gPending_flic = -1;
  24. int gPlay_from_disk;
  25. int gTrans_enabled = 1;
  26. br_pixelmap* gPanel_buffer[2];
  27. tU32 gSound_time;
  28. tFlic_spec gMain_flic_list[372] = {
  29.     { "MAINSTIL.FLI", 1, 0, 0, 0, 0, 25, NULL, 0u }, // only used by the demo (set to "xxxxxxxx.FLI" by the full version)
  30.     { "DEMSTRT2.FLI", 1, 0, 0, 0, 0, 0, NULL, 0u },
  31.     { "DEMSTRT1.FLI", 1, 0, 0, 0, 0, 0, NULL, 0u },
  32.     { "NEWFLIC.FLI", 1, 0, 0, 0, 0, 0, NULL, 0u },
  33.     { "GOTOFLIC.FLI", 1, 0, 0, 0, 0, 0, NULL, 0u },
  34.     { "ENDFLIC.FLI", 1, 0, 0, 0, 0, 0, NULL, 0u },
  35.     { "OVERFLIC.FLI", 1, 0, 0, 0, 0, 0, NULL, 0u },
  36.     { "DEMO8.FLI", 1, 0, 0, 0, 0, 0, NULL, 0u },
  37.     { "COMPLETE.FLI", 1, 0, 0, 0, 0, 0, NULL, 0u },
  38.     { "DEMOEND.FLI", 1, 0, 0, 0, 0, 0, NULL, 0u },
  39.     { "MAINSTIL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  40.     { "MAINCOME.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  41.     { "MAINAWAY.FLI", 0, 1, 0, 0, 0, 0, NULL, 0u },
  42.     { "MAINCNFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  43.     { "MAINCNGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  44.     { "MAINCNIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  45.     { "MAINABFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  46.     { "MAINABGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  47.     { "MAINQTFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  48.     { "MAINQTGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  49.     { "MAINSVFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  50.     { "MAINSVGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  51.     { "MAINLDFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  52.     { "MAINLDGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  53.     { "MAINRCFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  54.     { "MAINRCGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  55.     { "MAINARFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  56.     { "MAINARGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  57.     { "MAINOPFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  58.     { "MAINOPGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  59.     { "MAI2STIL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  60.     { "MAI2COME.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  61.     { "MAI2AWAY.FLI", 0, 1, 0, 0, 0, 0, NULL, 0u },
  62.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  63.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  64.     { "MAINRCGY.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  65.     { "MAINARGY.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  66.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  67.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  68.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  69.     { "SVVYSTIL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  70.     { "SVVYAWAY.FLI", 0, 1, 0, 0, 0, 0, NULL, 0u },
  71.     { "BGBUTTFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  72.     { "BGBUTTGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  73.     { "SVVYOKIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  74.     { "CANBUTIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  75.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  76.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  77.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  78.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  79.     { "SAVECOME.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  80.     { "SAVEAWAY.FLI", 0, 1, 0, 0, 0, 0, NULL, 0u },
  81.     { "SMLBUTFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  82.     { "SMLBUTGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  83.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  84.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  85.     { "SMLBUTFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  86.     { "SMLBUTGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  87.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  88.     { "SAVECAIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  89.     { "NRACCOME.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  90.     { "NRACAWAY.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  91.     { "NCARCOME.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  92.     { "NSUMSTIL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  93.     { "NSUMAWAY.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  94.     { "NOPTCOME.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  95.     { "NOPTAWAY.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  96.     { "NOPTDEIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  97.     { "NOPT00GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  98.     { "NOPT00FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  99.     { "LOADSTIL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  100.     { "LOADCOME.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  101.     { "LOADAWAY.FLI", 0, 1, 0, 0, 0, 0, NULL, 0u },
  102.     { "LOADHIFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  103.     { "LOADHIGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  104.     { "NOPT01GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  105.     { "NOPT01FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  106.     { "NOPT02GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  107.     { "NOPT02FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  108.     { "NOPT03GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  109.     { "NEWGCOME.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  110.     { "NEWGAWAY.FLI", 0, 1, 0, 0, 0, 0, NULL, 0u },
  111.     { "NEWGHLFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  112.     { "NEWGHLGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  113.     { "NEWGDNAV.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  114.     { "NEWGDNGY.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  115.     { "NEWGDNFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  116.     { "NEWGDNGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  117.     { "NEWGDNIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  118.     { "NEWGCAIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  119.     { "NEWNSTIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  120.     { "NEWNSTFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  121.     { "NEWNSTGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  122.     { "CHCKBXFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  123.     { "CHCKBXGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  124.     { "CHCKBXON.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  125.     { "CHCKBXOF.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  126.     { "RADBUTFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  127.     { "RADBUTGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  128.     { "RADBUTON.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  129.     { "NEWNCOME.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  130.     { "NEWNAWAY.FLI", 0, 1, 0, 0, 0, 0, NULL, 0u },
  131.     { "NETTCOME.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  132.     { "NETTAWAY.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  133.     { "NETOCOME.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  134.     { "NETOAWAY.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  135.     { "NETNCOME.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  136.     { "NETNAWAY.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  137.     { "RADBUTOF.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  138.     { "NOPT03FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  139.     { "SKILCOME.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  140.     { "SKILAWAY.FLI", 0, 1, 0, 0, 0, 0, NULL, 0u },
  141.     { "NOPT04GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  142.     { "NOPT04FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  143.     { "NOPT05GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  144.     { "SKILL1FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  145.     { "SKILL1GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  146.     { "SKILLIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  147.     { "SKILL2FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  148.     { "SKILL2GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  149.     { "SKILL3FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  150.     { "SKILL3GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  151.     { "NCHOCOME.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  152.     { "NCHOAWAY.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  153.     { "NCHOOPIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  154.     { "ERRRSTIL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  155.     { "NOPT05FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  156.     { "NOPT06GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  157.     { "NOPT06FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  158.     { "NOPT07GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  159.     { "QUT1STIL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  160.     { "QUT2STIL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  161.     { "QUT3STIL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  162.     { "NOPT07FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  163.     { "NOPT08GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  164.     { "QUITOKIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  165.     { "NOPT08FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  166.     { "NOPT09GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  167.     { "NOPT09FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  168.     { "NOPT10GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  169.     { "OPTNCOME.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  170.     { "OPTNAWAY.FLI", 0, 1, 0, 0, 0, 0, NULL, 0u },
  171.     { "NOPT10FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  172.     { "NOPT11GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  173.     { "OPTNSNIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  174.     { "OPTNCNIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  175.     { "OPTNGRIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  176.     { "OPTNMSIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  177.     { "NOPT11FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  178.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  179.     { "SNDOCOME.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  180.     { "SNDOAWAY.FLI", 0, 1, 0, 0, 0, 0, NULL, 0u },
  181.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  182.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  183.     { "DNEBUTIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  184.     { "SNDOOLFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  185.     { "SNDOOLGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  186.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  187.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  188.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  189.     { "GRPHCOME.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  190.     { "GRPHAWAY.FLI", 0, 1, 0, 0, 0, 0, NULL, 0u },
  191.     { "NCHO00GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  192.     { "NCHO01GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  193.     { "NCHO02GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  194.     { "NCHO03GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  195.     { "NCHO04GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  196.     { "NCHO05GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  197.     { "NCHO06GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  198.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  199.     { "CNTLCOME.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  200.     { "CNTLAWAY.FLI", 0, 1, 0, 0, 0, 0, NULL, 0u },
  201.     { "CNTLDNIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  202.     { "CNTLCAIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  203.     { "CNTLDFIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  204.     { "CNTLMRIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  205.     { "CNTLDNFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  206.     { "CNTLDNGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  207.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  208.     { "CNTLSTIL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  209.     { "OTHRCOME.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  210.     { "OTHRAWAY.FLI", 0, 1, 0, 0, 0, 0, NULL, 0u },
  211.     { "NCHO00FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  212.     { "NCHO01FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  213.     { "NCHO02FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  214.     { "NCHO03FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  215.     { "NCHO04FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  216.     { "NCHO05FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  217.     { "NCHO06FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  218.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  219.     { "STRTSTIL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  220.     { "STRTCOME.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  221.     { "STRTAWAY.FLI", 0, 1, 0, 0, 0, 0, NULL, 0u },
  222.     { "CNTL00FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  223.     { "CNTL00GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  224.     { "STRTCRIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  225.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  226.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  227.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  228.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  229.     { "STRTPSIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  230.     { "STRTSRIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  231.     { "STRTCCIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  232.     { "NTSHSTIL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  233.     { "NTSCSTIL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  234.     { "NTSHSTIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  235.     { "NTSHENIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  236.     { "NTSCLVIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  237.     { "NTSHSTEN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  238.     { "NTSXSTIL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  239.     { "VWSC2IN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  240.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  241.     { "VWIN2OPP.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  242.     { "VWOPP2SC.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  243.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  244.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  245.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  246.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  247.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  248.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  249.     { "2BUTONFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  250.     { "2BUTONGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  251.     { "VWOPUPIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  252.     { "VWOPDWFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  253.     { "VWOPDWGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  254.     { "VWOPDWIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  255.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  256.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  257.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  258.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  259.     { "CHRCCOME.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  260.     { "CHRCAWAY.FLI", 0, 1, 0, 0, 0, 0, NULL, 0u },
  261.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  262.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  263.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  264.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  265.     { "CHCRCOME.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  266.     { "CHCRAWAY.FLI", 0, 1, 0, 0, 0, 0, NULL, 0u },
  267.     { "GRPH00GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  268.     { "GRPH01GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  269.     { "GRPH02GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  270.     { "GRPH03GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  271.     { "GRPH04GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  272.     { "GRPH05GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  273.     { "GRPH06GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  274.     { "GRPH07GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  275.     { "GRPH08GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  276.     { "GRPH09GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  277.     { "GRPH10GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  278.     { "GRPH11GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  279.     { "PARTCOME.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  280.     { "PARTAWAY.FLI", 0, 1, 0, 0, 0, 0, NULL, 0u },
  281.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  282.     { "PARTARGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  283.     { "PARTARIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  284.     { "PARTPFIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  285.     { "PARTOFIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  286.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  287.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  288.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  289.     { "PARTEXIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  290.     { "PARTSPIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  291.     { "PARTARGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  292.     { "PARTPFGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  293.     { "PARTOFGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  294.     { "GRPH00FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  295.     { "GRPH01FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  296.     { "GRPH02FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  297.     { "GRPH03FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  298.     { "GRPH04FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  299.     { "GRPH05FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  300.     { "GRPH06FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  301.     { "GRPH07FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  302.     { "GRPH08FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  303.     { "GRPH09FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  304.     { "GRPH10FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  305.     { "GRPH11FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  306.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  307.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  308.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  309.     { "PSRMCOME.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  310.     { "PSRMAWAY.FLI", 0, 1, 0, 0, 0, 0, NULL, 0u },
  311.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  312.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  313.     { "PSRMDIIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  314.     { "RADBUTFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  315.     { "RADBUTGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  316.     { "RADBUTOF.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  317.     { "RADBUTON.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  318.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  319.     { "GRIDSTIL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  320.     { "GRIDAWAY.FLI", 0, 1, 0, 0, 0, 0, NULL, 0u },
  321.     { "GRIDLFFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  322.     { "GRIDLFGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  323.     { "GRIDLFIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  324.     { "GRIDRTFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  325.     { "GRIDRTGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  326.     { "GRIDRTIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  327.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  328.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  329.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  330.     { "DARECOME.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  331.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  332.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  333.     { "DAREACIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  334.     { "DARECHIN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  335.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  336.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  337.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  338.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  339.     { "SUM1STIL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  340.     { "SUM1AWAY.FLI", 0, 1, 0, 0, 0, 0, NULL, 0u },
  341.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  342.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  343.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  344.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  345.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  346.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  347.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  348.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  349.     { "SUM2STIL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  350.     { "BGBUT8GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  351.     { "BGBUT8FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  352.     { "DNBUT8IN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  353.     { "BKBUT8IN.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  354.     { "BKBUTOFF.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  355.     { "BKBUTON.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  356.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  357.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  358.     { "", 0, 0, 0, 0, 0, 0, NULL, 0u },
  359.     { "MAI2QTFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  360.     { "MAI2QTGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  361.     { "MAI2LDFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  362.     { "MAI2LDGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  363.     { "MAI2N1FL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  364.     { "MAI2N1GL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  365.     { "MAI2NNFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  366.     { "MAI2NNGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  367.     { "MAI2OPFL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u },
  368.     { "MAI2OPGL.FLI", 0, 0, 0, 0, 0, 0, NULL, 0u }
  369. };
  370. int gFlic_bunch0[29] = {
  371.     10,
  372.     11,
  373.     12,
  374.     13,
  375.     14,
  376.     15,
  377.     16,
  378.     17,
  379.     18,
  380.     19,
  381.     20,
  382.     21,
  383.     22,
  384.     23,
  385.     24,
  386.     25,
  387.     35,
  388.     26,
  389.     27,
  390.     36,
  391.     28,
  392.     29,
  393.     130,
  394.     131,
  395.     132,
  396.     42,
  397.     43,
  398.     135,
  399.     45
  400. };
  401. int gFlic_bunch1[31] = {
  402.     140,
  403.     141,
  404.     42,
  405.     43,
  406.     144,
  407.     145,
  408.     146,
  409.     147,
  410.     45,
  411.     150,
  412.     151,
  413.     42,
  414.     43,
  415.     154,
  416.     155,
  417.     156,
  418.     160,
  419.     161,
  420.     42,
  421.     43,
  422.     154,
  423.     170,
  424.     171,
  425.     176,
  426.     177,
  427.     172,
  428.     180,
  429.     181,
  430.     42,
  431.     43,
  432.     154
  433. };
  434. int gFlic_bunch2[8] = { 70, 71, 72, 73, 74, 56, 57, 59 };
  435. int gFlic_bunch3[13] = { 40, 41, 42, 43, 44, 45, 50, 51, 73, 74, 56, 57, 59 };
  436. int gFlic_bunch4[22] = {
  437.     80,
  438.     81,
  439.     82,
  440.     83,
  441.     84,
  442.     85,
  443.     42,
  444.     43,
  445.     88,
  446.     45,
  447.     110,
  448.     111,
  449.     42,
  450.     43,
  451.     45,
  452.     115,
  453.     116,
  454.     117,
  455.     118,
  456.     119,
  457.     120,
  458.     121
  459. };
  460. int gFlic_bunch5[5] = { 100, 101, 42, 43, 45 };
  461. int gFlic_bunch6[51] = {
  462.     190,
  463.     191,
  464.     192,
  465.     42,
  466.     43,
  467.     195,
  468.     200,
  469.     201,
  470.     210,
  471.     212,
  472.     213,
  473.     220,
  474.     221,
  475.     222,
  476.     220,
  477.     221,
  478.     225,
  479.     230,
  480.     231,
  481.     42,
  482.     43,
  483.     154,
  484.     45,
  485.     220,
  486.     221,
  487.     222,
  488.     220,
  489.     221,
  490.     225,
  491.     250,
  492.     251,
  493.     42,
  494.     43,
  495.     254,
  496.     255,
  497.     256,
  498.     154,
  499.     42,
  500.     43,
  501.     260,
  502.     220,
  503.     221,
  504.     222,
  505.     220,
  506.     221,
  507.     225,
  508.     280,
  509.     281,
  510.     42,
  511.     43,
  512.     284
  513. };
  514. int gFlic_bunch7[7] = { 130, 131, 132, 42, 43, 135, 45 };
  515. int gFlic_bunch8[16] = { 290, 291, 292, 293, 294, 295, 296, 297, 42, 43, 154, 301, 42, 43, 304, 305 };
  516. tFlic_bunch gFlic_bunch[9] = {
  517.     { COUNT_OF(gFlic_bunch0), gFlic_bunch0 },
  518.     { COUNT_OF(gFlic_bunch1), gFlic_bunch1 },
  519.     { COUNT_OF(gFlic_bunch2), gFlic_bunch2 },
  520.     { COUNT_OF(gFlic_bunch3), gFlic_bunch3 },
  521.     { COUNT_OF(gFlic_bunch4), gFlic_bunch4 },
  522.     { COUNT_OF(gFlic_bunch5), gFlic_bunch5 },
  523.     { COUNT_OF(gFlic_bunch6), gFlic_bunch6 },
  524.     { COUNT_OF(gFlic_bunch7), gFlic_bunch7 },
  525.     { COUNT_OF(gFlic_bunch8), gFlic_bunch8 },
  526. };
  527. char gLast_flic_name[14];
  528. tU32 gPanel_flic_data_length[2];
  529. tU32 gLast_panel_frame_time[2];
  530. tU8* gPanel_flic_data[2];
  531. int gPanel_flic_top[2];
  532. tFlic_descriptor gPanel_flic[2];
  533. int gPanel_flic_left[2];
  534. int gPending_pending_flic = -1;
  535. int gSound_ID;
  536. int gTranslation_count;
  537. tDR_font* gTrans_fonts[15];
  538. tTranslation_record* gTranslations;
  539. br_pixelmap* gPalette;
  540. void* gPalette_pixels;
  541. tFlic_descriptor* gFirst_flic;
  542.  
  543. // Use this function to avoid unaligned memory access.
  544. // Added by DethRace
  545. tU16 mem_read_u16(void* memory) {
  546.     tU16 u16;
  547.  
  548.     memcpy(&u16, memory, sizeof(tU16));
  549.     return u16;
  550. }
  551.  
  552. // Use this function to avoid unaligned memory access
  553. // Added by DethRace
  554. void mem_write_u16(void* memory, tU16 u16) {
  555.  
  556.     memcpy(memory, &u16, sizeof(tU16));
  557. }
  558.  
  559. // IDA: void __cdecl EnableTranslationText()
  560. void EnableTranslationText(void) {
  561.     LOG_TRACE("()");
  562.  
  563.     gTrans_enabled = 1;
  564. }
  565.  
  566. // IDA: void __cdecl DisableTranslationText()
  567. void DisableTranslationText(void) {
  568.     LOG_TRACE("()");
  569.  
  570.     gTrans_enabled = 0;
  571. }
  572.  
  573. // IDA: void __usercall SetFlicSound(int pSound_ID@<EAX>, tU32 pSound_time@<EDX>)
  574. void SetFlicSound(int pSound_ID, tU32 pSound_time) {
  575.     LOG_TRACE("(%d, %d)", pSound_ID, pSound_time);
  576.  
  577.     gSound_time = pSound_time;
  578.     gSound_ID = pSound_ID;
  579. }
  580.  
  581. // IDA: int __cdecl TranslationMode()
  582. int TranslationMode(void) {
  583.  
  584.     return gTranslation_count;
  585. }
  586.  
  587. // IDA: void __cdecl DontLetFlicFuckWithPalettes()
  588. void DontLetFlicFuckWithPalettes(void) {
  589.     LOG_TRACE8("()");
  590.  
  591.     gPalette_fuck_prevention = 1;
  592. }
  593.  
  594. // IDA: void __cdecl LetFlicFuckWithPalettes()
  595. void LetFlicFuckWithPalettes(void) {
  596.     LOG_TRACE8("()");
  597.  
  598.     gPalette_fuck_prevention = 0;
  599. }
  600.  
  601. // IDA: void __cdecl PlayFlicsInDarkness()
  602. void PlayFlicsInDarkness(void) {
  603.     LOG_TRACE("()");
  604.  
  605.     gDark_mode = 1;
  606. }
  607.  
  608. // IDA: void __cdecl ReilluminateFlics()
  609. void ReilluminateFlics(void) {
  610.     LOG_TRACE("()");
  611.  
  612.     gDark_mode = 0;
  613.     FadePaletteUp();
  614. }
  615.  
  616. // IDA: void __cdecl TurnFlicTransparencyOn()
  617. void TurnFlicTransparencyOn(void) {
  618.     LOG_TRACE8("()");
  619.  
  620.     gTransparency_on = 1;
  621. }
  622.  
  623. // IDA: void __cdecl TurnFlicTransparencyOff()
  624. void TurnFlicTransparencyOff(void) {
  625.     LOG_TRACE8("()");
  626.     gTransparency_on = 0;
  627. }
  628.  
  629. // IDA: void __cdecl PlayFlicsFromDisk()
  630. void PlayFlicsFromDisk(void) {
  631.     gPlay_from_disk = 1;
  632. }
  633.  
  634. // IDA: void __cdecl PlayFlicsFromMemory()
  635. void PlayFlicsFromMemory(void) {
  636.     gPlay_from_disk = 0;
  637. }
  638.  
  639. // IDA: int __cdecl FlicsPlayedFromDisk()
  640. int FlicsPlayedFromDisk(void) {
  641.     return gPlay_from_disk;
  642. }
  643.  
  644. // IDA: void __cdecl TurnOffPanelFlics()
  645. void TurnOffPanelFlics(void) {
  646.     gPanel_flic_disable = 1;
  647. }
  648.  
  649. // IDA: void __cdecl TurnOnPanelFlics()
  650. void TurnOnPanelFlics(void) {
  651.     gPanel_flic_disable = 0;
  652. }
  653.  
  654. // IDA: int __usercall GetPanelFlicFrameIndex@<EAX>(int pIndex@<EAX>)
  655. int GetPanelFlicFrameIndex(int pIndex) {
  656.     LOG_TRACE("(%d)", pIndex);
  657.  
  658.     return gPanel_flic[pIndex].current_frame;
  659. }
  660.  
  661. // IDA: void __cdecl FlicPaletteAllocate()
  662. void FlicPaletteAllocate(void) {
  663.     LOG_TRACE("()");
  664.  
  665.     gPalette_pixels = BrMemAllocate(0x400u, kMem_flic_pal);
  666.     gPalette = DRPixelmapAllocate(BR_PMT_RGBX_888, 1, 256, gPalette_pixels, 0);
  667. }
  668.  
  669. // IDA: void __usercall AssertFlicPixelmap(tFlic_descriptor_ptr pFlic_info@<EAX>, br_pixelmap *pDest_pixelmap@<EDX>)
  670. void AssertFlicPixelmap(tFlic_descriptor_ptr pFlic_info, br_pixelmap* pDest_pixelmap) {
  671.     LOG_TRACE("(%d, %p)", pFlic_info, pDest_pixelmap);
  672.  
  673.     if (pDest_pixelmap != NULL) {
  674.         pFlic_info->first_pixel = (tU8*)pDest_pixelmap->pixels
  675.             + pFlic_info->x_offset
  676.             + pFlic_info->y_offset * pDest_pixelmap->row_bytes;
  677.     }
  678.     pFlic_info->the_pixelmap = pDest_pixelmap;
  679. }
  680.  
  681. // IDA: int __usercall StartFlic@<EAX>(char *pFile_name@<EAX>, int pIndex@<EDX>, tFlic_descriptor_ptr pFlic_info@<EBX>, tU32 pSize@<ECX>, tS8 *pData_ptr, br_pixelmap *pDest_pixelmap, int pX_offset, int pY_offset, int pFrame_rate)
  682. int StartFlic(char* pFile_name, int pIndex, tFlic_descriptor_ptr pFlic_info, tU32 pSize, tS8* pData_ptr, br_pixelmap* pDest_pixelmap, int pX_offset, int pY_offset, int pFrame_rate) {
  683.     tU16 claimed_speed;
  684.     tU16 magic_number;
  685.     tPath_name the_path;
  686.     int total_size;
  687.     LOG_TRACE("(\"%s\", %d, %p, %u, %p, %p, %d, %d, %d)", pFile_name, pIndex, pFlic_info, pSize, pData_ptr, pDest_pixelmap, pX_offset, pY_offset, pFrame_rate);
  688.  
  689.     if (gPlay_from_disk) {
  690.         PathCat(the_path, gApplication_path, "ANIM");
  691.         PathCat(the_path, the_path, pFile_name);
  692.         pFlic_info->f = DRfopen(the_path, "rb");
  693.  
  694.         if (pFlic_info->f == NULL) {
  695.             FatalError(kFatalError_LoadFlicFile_S, pFile_name);
  696.         }
  697.         total_size = GetFileLength(pFlic_info->f);
  698.         if (total_size >= 75000) {
  699.             pFlic_info->bytes_in_buffer = 75000;
  700.         } else {
  701.             pFlic_info->bytes_in_buffer = total_size;
  702.         }
  703.         if (pFlic_info->data_start == NULL) {
  704.             pFlic_info->data_start = BrMemAllocate(pFlic_info->bytes_in_buffer, kMem_flic_data);
  705.         }
  706.  
  707.         pFlic_info->data = pFlic_info->data_start;
  708.         strcpy(gLast_flic_name, pFile_name);
  709.         fread(pFlic_info->data_start, 1, pFlic_info->bytes_in_buffer, pFlic_info->f);
  710.         pFlic_info->bytes_still_to_be_read = total_size - pFlic_info->bytes_in_buffer;
  711.     } else {
  712.         pFlic_info->f = NULL;
  713.         pFlic_info->data = (char*)pData_ptr;
  714.         // TODO: remove this - we added this line because of the padding hack in PlayNextFlicFrame2
  715.         pFlic_info->data_start = (char*)pData_ptr;
  716.     }
  717.     pFlic_info->bytes_remaining = MemReadU32(&pFlic_info->data);
  718.     magic_number = MemReadU16(&pFlic_info->data);
  719.     if (magic_number == 0xaf11) {
  720.         pFlic_info->new_format = 0;
  721.     } else if (magic_number == 0xaf12) {
  722.         pFlic_info->new_format = 1;
  723.     } else {
  724.         return -1;
  725.     }
  726.  
  727.     pFlic_info->frames_left = MemReadU16(&pFlic_info->data);
  728.     pFlic_info->current_frame = 0;
  729.     pFlic_info->width = MemReadU16(&pFlic_info->data);
  730.     pFlic_info->height = MemReadU16(&pFlic_info->data);
  731.     if (MemReadU16(&pFlic_info->data) != 8) {
  732.         FatalError(kFatalError_FlicFileNot8Bits_S, gLast_flic_name);
  733.     }
  734.     MemSkipBytes(&pFlic_info->data, 2);
  735.     claimed_speed = MemReadU16(&pFlic_info->data);
  736.     MemSkipBytes(&pFlic_info->data, 0x6e);
  737.     pFlic_info->the_pixelmap = pDest_pixelmap;
  738.  
  739.     if (pX_offset == -1) {
  740.         if (pDest_pixelmap != NULL) {
  741.             pFlic_info->x_offset = (pDest_pixelmap->width - pFlic_info->width) / 2;
  742.         } else {
  743.             pFlic_info->x_offset = 0;
  744.         }
  745.     } else {
  746.         pFlic_info->x_offset = pX_offset;
  747.     }
  748.     if (pY_offset == -1) {
  749.         if (pDest_pixelmap != NULL) {
  750.             pFlic_info->y_offset = (pDest_pixelmap->height - pFlic_info->height) / 2;
  751.         } else {
  752.             pFlic_info->y_offset = 0;
  753.         }
  754.     } else {
  755.         pFlic_info->y_offset = pY_offset;
  756.     }
  757.  
  758.     if (pFrame_rate != 0) {
  759.         pFlic_info->frame_period = 1000 / pFrame_rate;
  760.     } else {
  761.         if (claimed_speed == 0) {
  762.             FatalError(kFatalError_FlicFileNoFrameRate_S, gLast_flic_name);
  763.         }
  764.         if (pFlic_info->new_format) {
  765.             pFlic_info->frame_period = claimed_speed;
  766.         } else {
  767.             pFlic_info->frame_period = 14 * claimed_speed;
  768.         }
  769.     }
  770.     pFlic_info->the_index = pIndex;
  771.     AssertFlicPixelmap(pFlic_info, pDest_pixelmap);
  772.     return 0;
  773. }
  774.  
  775. // IDA: void __cdecl FreeFlicPaletteAllocate()
  776. void FreeFlicPaletteAllocate(void) {
  777.     LOG_TRACE("()");
  778.  
  779.     if (gPalette_allocate_count == 0) {
  780.         FatalError(kFatalError_FlicPaletteDisposeBeforeAllocation);
  781.     }
  782.     gPalette_allocate_count--;
  783.     if (gPalette_allocate_count == 0) {
  784.         BrMemFree(gPalette_pixels);
  785.         BrPixelmapFree(gPalette);
  786.     }
  787. }
  788.  
  789. // IDA: int __usercall EndFlic@<EAX>(tFlic_descriptor_ptr pFlic_info@<EAX>)
  790. int EndFlic(tFlic_descriptor_ptr pFlic_info) {
  791.     LOG_TRACE("(%p)", pFlic_info);
  792.  
  793.     if (pFlic_info->f != NULL) {
  794.         BrMemFree(pFlic_info->data_start);
  795.         pFlic_info->data_start = NULL;
  796.         fclose(pFlic_info->f);
  797.         pFlic_info->f = NULL;
  798.     }
  799.     if (pFlic_info->data != NULL) {
  800.         pFlic_info->data = NULL;
  801.     }
  802.     return 0;
  803. }
  804.  
  805. // IDA: void __usercall DoColourMap(tFlic_descriptor_ptr pFlic_info@<EAX>, tU32 chunk_length@<EDX>)
  806. void DoColourMap(tFlic_descriptor_ptr pFlic_info, tU32 chunk_length) {
  807.     int i;
  808.     int j;
  809.     int packet_count;
  810.     int skip_count;
  811.     int change_count;
  812.     int current_colour = 0;
  813.     tU8* palette_pixels;
  814.     tU8 red;
  815.     tU8 green;
  816.     tU8 blue;
  817.  
  818.     palette_pixels = gPalette_pixels;
  819.  
  820.     packet_count = MemReadU16(&pFlic_info->data);
  821.     for (i = 0; i < packet_count; i++) {
  822.         skip_count = MemReadU8(&pFlic_info->data);
  823.         change_count = MemReadU8(&pFlic_info->data);
  824.         if (!change_count) {
  825.             change_count = 256;
  826.         }
  827.         palette_pixels += skip_count * sizeof(br_int_32);
  828.         current_colour += skip_count;
  829.         for (j = 0; j < change_count; j++) {
  830.             red = MemReadU8(&pFlic_info->data);
  831.             blue = MemReadU8(&pFlic_info->data);
  832.             green = MemReadU8(&pFlic_info->data);
  833.             // argb
  834. #if BR_ENDIAN_BIG
  835.             palette_pixels[3] = green * 4;
  836.             palette_pixels[2] = blue * 4;
  837.             palette_pixels[1] = red * 4;
  838.             palette_pixels[0] = 0;
  839. #else
  840.             palette_pixels[0] = green * 4;
  841.             palette_pixels[1] = blue * 4;
  842.             palette_pixels[2] = red * 4;
  843.             palette_pixels[3] = 0;
  844. #endif
  845.             palette_pixels += 4;
  846.         }
  847.         if (!gPalette_fuck_prevention) {
  848.             DRSetPaletteEntries(gPalette, current_colour, change_count);
  849.         }
  850.     }
  851. }
  852.  
  853. // IDA: void __usercall DoDifferenceX(tFlic_descriptor *pFlic_info@<EAX>, tU32 chunk_length@<EDX>)
  854. void DoDifferenceX(tFlic_descriptor* pFlic_info, tU32 chunk_length) {
  855.     int i;
  856.     int j;
  857.     int k;
  858.     int first_line;
  859.     int line_count;
  860.     int number_of_packets;
  861.     int skip_count;
  862.     int size_count;
  863.     tU8* pixel_ptr;
  864.     tU8* line_pixel_ptr;
  865.     tU8 the_byte;
  866.     tU32 the_row_bytes;
  867.     LOG_TRACE("(%p, %d)", pFlic_info, chunk_length);
  868.  
  869.     first_line = MemReadU16(&pFlic_info->data);
  870.     line_count = MemReadU16(&pFlic_info->data);
  871.     the_row_bytes = pFlic_info->the_pixelmap->row_bytes;
  872.     line_pixel_ptr = pFlic_info->first_pixel + first_line * the_row_bytes;
  873.     for (i = 0; i < line_count; i++) {
  874.         pixel_ptr = line_pixel_ptr;
  875.         number_of_packets = MemReadU8(&pFlic_info->data);
  876.         for (j = 0; j < number_of_packets; j++) {
  877.             skip_count = MemReadU8(&pFlic_info->data);
  878.             size_count = MemReadS8(&pFlic_info->data);
  879.             pixel_ptr += skip_count;
  880.             if (size_count >= 0) {
  881.                 for (k = 0; k < size_count; k++) {
  882.                     *pixel_ptr = *pFlic_info->data;
  883.                     pFlic_info->data++;
  884.                     pixel_ptr++;
  885.                 }
  886.             } else {
  887.                 the_byte = *pFlic_info->data;
  888.                 pFlic_info->data++;
  889.                 for (k = 0; k < -size_count; k++) {
  890.                     *pixel_ptr = the_byte;
  891.                     pixel_ptr++;
  892.                 }
  893.             }
  894.         }
  895.         line_pixel_ptr += the_row_bytes;
  896.     }
  897. }
  898.  
  899. // IDA: void __usercall DoDifferenceTrans(tFlic_descriptor *pFlic_info@<EAX>, tU32 chunk_length@<EDX>)
  900. void DoDifferenceTrans(tFlic_descriptor* pFlic_info, tU32 chunk_length) {
  901.     int i;
  902.     int j;
  903.     int k;
  904.     int first_line;
  905.     int line_count;
  906.     int number_of_packets;
  907.     int skip_count;
  908.     int size_count;
  909.     tU8* pixel_ptr;
  910.     tU8* line_pixel_ptr;
  911.     tU8 the_byte;
  912.     tU32 the_row_bytes;
  913.     LOG_TRACE("(%p, %d)", pFlic_info, chunk_length);
  914.  
  915.     first_line = MemReadU16(&pFlic_info->data);
  916.     line_count = MemReadU16(&pFlic_info->data);
  917.     the_row_bytes = pFlic_info->the_pixelmap->row_bytes;
  918.     line_pixel_ptr = pFlic_info->first_pixel + first_line * the_row_bytes;
  919.     for (i = 0; i < line_count; i++) {
  920.         pixel_ptr = line_pixel_ptr;
  921.         number_of_packets = MemReadU8(&pFlic_info->data);
  922.         for (j = 0; j < number_of_packets; j++) {
  923.             skip_count = MemReadU8(&pFlic_info->data);
  924.             size_count = MemReadS8(&pFlic_info->data);
  925.             pixel_ptr += skip_count;
  926.             if (size_count >= 0) {
  927.                 for (k = 0; k < size_count; k++) {
  928.                     the_byte = *pFlic_info->data;
  929.                     pFlic_info->data++;
  930.                     if (the_byte != '\0') {
  931.                         *pixel_ptr = the_byte;
  932.                     }
  933.                     pixel_ptr++;
  934.                 }
  935.             } else {
  936.                 the_byte = *pFlic_info->data;
  937.                 pFlic_info->data++;
  938.                 if (the_byte == '\0') {
  939.                     pixel_ptr += size_count;
  940.                 } else {
  941.                     for (k = 0; k < -size_count; k++) {
  942.                         *pixel_ptr = the_byte;
  943.                         pixel_ptr++;
  944.                     }
  945.                 }
  946.             }
  947.         }
  948.         line_pixel_ptr += the_row_bytes;
  949.     }
  950. }
  951.  
  952. // IDA: void __usercall DoColour256(tFlic_descriptor *pFlic_info@<EAX>, tU32 chunk_length@<EDX>)
  953. void DoColour256(tFlic_descriptor* pFlic_info, tU32 chunk_length) {
  954.     int i;
  955.     int j;
  956.     int packet_count;
  957.     int skip_count;
  958.     int change_count;
  959.     int current_colour;
  960.     tU8* palette_pixels;
  961.     tU8 red;
  962.     tU8 green;
  963.     tU8 blue;
  964.  
  965.     current_colour = 0;
  966.     palette_pixels = gPalette_pixels;
  967.  
  968.     packet_count = MemReadU16(&pFlic_info->data);
  969.     for (i = 0; i < packet_count; i++) {
  970.         skip_count = MemReadU8(&pFlic_info->data);
  971.         change_count = MemReadU8(&pFlic_info->data);
  972.         if (!change_count) {
  973.             change_count = 256;
  974.         }
  975.         palette_pixels += skip_count * sizeof(br_int_32);
  976.         current_colour += skip_count;
  977.         for (j = 0; j < change_count; j++) {
  978.             red = MemReadU8(&pFlic_info->data);
  979.             blue = MemReadU8(&pFlic_info->data);
  980.             green = MemReadU8(&pFlic_info->data);
  981.             // argb
  982. #if BR_ENDIAN_BIG
  983.             palette_pixels[3] = green;
  984.             palette_pixels[2] = blue;
  985.             palette_pixels[1] = red;
  986.             palette_pixels[0] = 0;
  987. #else
  988.             palette_pixels[0] = green;
  989.             palette_pixels[1] = blue;
  990.             palette_pixels[2] = red;
  991.             palette_pixels[3] = 0;
  992. #endif
  993.             palette_pixels += 4;
  994.             // LOG_DEBUG("color %d", current_colour);
  995.         }
  996.         if (!gPalette_fuck_prevention) {
  997.             DRSetPaletteEntries(gPalette, current_colour, change_count);
  998.         }
  999.     }
  1000. }
  1001.  
  1002. // IDA: void __usercall DoDeltaTrans(tFlic_descriptor *pFlic_info@<EAX>, tU32 chunk_length@<EDX>)
  1003. void DoDeltaTrans(tFlic_descriptor* pFlic_info, tU32 chunk_length) {
  1004.     int i;
  1005.     int j;
  1006.     int k;
  1007.     int line_count;
  1008.     int number_of_packets;
  1009.     int skip_count;
  1010.     int size_count;
  1011.     tU8* pixel_ptr;
  1012.     tU8 the_byte;
  1013.     tU8 the_byte2;
  1014.     tU32 the_row_bytes;
  1015.     tU16* line_pixel_ptr;
  1016.     tU16 the_word;
  1017.     LOG_TRACE8("(%p, %d)", pFlic_info, chunk_length);
  1018.  
  1019.     line_count = MemReadU16(&pFlic_info->data);
  1020.     the_row_bytes = pFlic_info->the_pixelmap->row_bytes;
  1021.     pixel_ptr = pFlic_info->first_pixel;
  1022.  
  1023.     for (i = 0; i < line_count;) {
  1024.         number_of_packets = MemReadS16(&pFlic_info->data);
  1025.         line_pixel_ptr = (tU16*)pixel_ptr;
  1026.  
  1027.         if (number_of_packets < 0) {
  1028.             pixel_ptr = pixel_ptr + the_row_bytes * -number_of_packets;
  1029.         } else {
  1030.             for (j = 0; j < number_of_packets; j++) {
  1031.                 skip_count = MemReadU8(&pFlic_info->data);
  1032.                 size_count = MemReadS8(&pFlic_info->data);
  1033.                 line_pixel_ptr += skip_count / 2;
  1034.                 if (size_count < 0) {
  1035.                     the_byte = *pFlic_info->data++;
  1036.                     the_byte2 = *pFlic_info->data++;
  1037.  
  1038.                     if (the_byte && the_byte2) {
  1039.                         the_word = *((tU16*)pFlic_info->data - 1);
  1040.                         for (k = 0; k < -size_count; k++) {
  1041.                             mem_write_u16(line_pixel_ptr, the_word);
  1042.                             line_pixel_ptr++;
  1043.                         }
  1044.                     } else {
  1045.                         for (k = 0; k < -size_count; k++) {
  1046.                             if (the_byte) {
  1047.                                 *(tU8*)line_pixel_ptr = the_byte;
  1048.                             }
  1049.                             line_pixel_ptr = (tU16*)((tU8*)line_pixel_ptr + 1);
  1050.                             if (the_byte2) {
  1051.                                 *(tU8*)line_pixel_ptr = the_byte2;
  1052.                             }
  1053.                             line_pixel_ptr = (tU16*)((tU8*)line_pixel_ptr + 1);
  1054.                         }
  1055.                     }
  1056.                 } else {
  1057.                     for (k = 0; k < size_count; k++) {
  1058.                         the_word = *(tU16*)pFlic_info->data;
  1059.                         pFlic_info->data += 2;
  1060.                         if (the_word) {
  1061.                             mem_write_u16(line_pixel_ptr, the_word);
  1062.                         }
  1063.                         line_pixel_ptr++;
  1064.                     }
  1065.                 }
  1066.             }
  1067.             pixel_ptr = pixel_ptr + the_row_bytes;
  1068.             i++;
  1069.         }
  1070.     }
  1071. }
  1072.  
  1073. // IDA: void __usercall DoDeltaX(tFlic_descriptor *pFlic_info@<EAX>, tU32 chunk_length@<EDX>)
  1074. void DoDeltaX(tFlic_descriptor* pFlic_info, tU32 chunk_length) {
  1075.     int i;
  1076.     int j;
  1077.     int k;
  1078.     int line_count;
  1079.     int number_of_packets;
  1080.     int skip_count;
  1081.     int size_count;
  1082.     tU8* pixel_ptr;
  1083.     tU32 the_row_bytes;
  1084.     tU16* line_pixel_ptr;
  1085.     tU16 the_word;
  1086.     LOG_TRACE("(%p, %d)", pFlic_info, chunk_length);
  1087.  
  1088.     line_count = MemReadU16(&pFlic_info->data);
  1089.     the_row_bytes = pFlic_info->the_pixelmap->row_bytes;
  1090.     pixel_ptr = pFlic_info->first_pixel;
  1091.  
  1092.     for (i = 0; i < line_count;) {
  1093.         number_of_packets = MemReadS16(&pFlic_info->data);
  1094.         line_pixel_ptr = (tU16*)pixel_ptr;
  1095.  
  1096.         if (number_of_packets < 0) {
  1097.             pixel_ptr = pixel_ptr + the_row_bytes * -number_of_packets;
  1098.         } else {
  1099.             for (j = 0; j < number_of_packets; j++) {
  1100.                 skip_count = MemReadU8(&pFlic_info->data);
  1101.                 size_count = MemReadS8(&pFlic_info->data);
  1102.                 line_pixel_ptr += skip_count / 2;
  1103.                 if (size_count < 0) {
  1104.                     the_word = *(tU16*)pFlic_info->data;
  1105.                     pFlic_info->data += 2;
  1106.                     for (k = 0; k < -size_count; k++) {
  1107.                         *line_pixel_ptr = the_word;
  1108.                         line_pixel_ptr++;
  1109.                     }
  1110.                 } else {
  1111.                     for (k = 0; k < size_count; k++) {
  1112.                         the_word = *(tU16*)pFlic_info->data;
  1113.                         pFlic_info->data += 2;
  1114.                         *line_pixel_ptr = the_word;
  1115.                         line_pixel_ptr++;
  1116.                     }
  1117.                 }
  1118.             }
  1119.             pixel_ptr = pixel_ptr + the_row_bytes;
  1120.             i++;
  1121.         }
  1122.     }
  1123. }
  1124.  
  1125. // IDA: void __usercall DoBlack(tFlic_descriptor *pFlic_info@<EAX>, tU32 chunk_length@<EDX>)
  1126. void DoBlack(tFlic_descriptor* pFlic_info, tU32 chunk_length) {
  1127.     int i;
  1128.     int j;
  1129.     int the_width;
  1130.     tU8* pixel_ptr;
  1131.     tU32 the_row_bytes;
  1132.     tU32* line_pixel_ptr;
  1133.     LOG_TRACE("(%p, %d)", pFlic_info, chunk_length);
  1134.  
  1135.     pixel_ptr = pFlic_info->first_pixel;
  1136.     the_row_bytes = pFlic_info->the_pixelmap->row_bytes;
  1137.     the_width = pFlic_info->width;
  1138.     for (i = 0; i < pFlic_info->height; i++) {
  1139.         line_pixel_ptr = (tU32*)pixel_ptr;
  1140.         for (j = 0; j < the_width / (int) sizeof(tU32); j++) { // Pierre-Marie Baty -- added type cast
  1141.             *line_pixel_ptr = 0;
  1142.             line_pixel_ptr++;
  1143.         }
  1144.         pixel_ptr += the_row_bytes;
  1145.     }
  1146. }
  1147.  
  1148. // IDA: void __usercall DoRunLengthX(tFlic_descriptor *pFlic_info@<EAX>, tU32 chunk_length@<EDX>)
  1149. void DoRunLengthX(tFlic_descriptor* pFlic_info, tU32 chunk_length) {
  1150.     int i;
  1151.     int j;
  1152.     int k;
  1153.     int number_of_packets;
  1154.     int size_count;
  1155.     tU8* pixel_ptr;
  1156.     tU8* line_pixel_ptr;
  1157.     tU8 the_byte;
  1158.     tU32 the_row_bytes;
  1159.     LOG_TRACE("(%p, %d)", pFlic_info, chunk_length);
  1160.  
  1161.     the_row_bytes = pFlic_info->the_pixelmap->row_bytes;
  1162.     pixel_ptr = pFlic_info->first_pixel;
  1163.  
  1164.     for (i = 0; i < pFlic_info->height; i++) {
  1165.         line_pixel_ptr = pixel_ptr;
  1166.         number_of_packets = MemReadU8(&pFlic_info->data);
  1167.         for (j = 0; j < number_of_packets; j++) {
  1168.             size_count = MemReadS8(&pFlic_info->data);
  1169.             if (size_count >= 0) {
  1170.                 the_byte = MemReadU8(&pFlic_info->data);
  1171.                 for (k = 0; k < size_count; k++) {
  1172.                     *line_pixel_ptr = the_byte;
  1173.                     line_pixel_ptr++;
  1174.                 }
  1175.             } else {
  1176.                 for (k = 0; k < -size_count; k++) {
  1177.                     the_byte = MemReadU8(&pFlic_info->data);
  1178.                     *line_pixel_ptr = the_byte;
  1179.                     line_pixel_ptr++;
  1180.                 }
  1181.             }
  1182.         }
  1183.         pixel_ptr += the_row_bytes;
  1184.     }
  1185. }
  1186.  
  1187. // IDA: void __usercall DoRunLengthTrans(tFlic_descriptor *pFlic_info@<EAX>, tU32 chunk_length@<EDX>)
  1188. void DoRunLengthTrans(tFlic_descriptor* pFlic_info, tU32 chunk_length) {
  1189.     int i;
  1190.     int j;
  1191.     int k;
  1192.     int number_of_packets;
  1193.     int size_count;
  1194.     tU8* pixel_ptr;
  1195.     tU8* line_pixel_ptr;
  1196.     tU8 the_byte;
  1197.     tU32 the_row_bytes;
  1198.     LOG_TRACE8("(%p, %d)", pFlic_info, chunk_length);
  1199.  
  1200.     the_row_bytes = pFlic_info->the_pixelmap->row_bytes;
  1201.     pixel_ptr = pFlic_info->first_pixel;
  1202.  
  1203.     for (i = 0; i < pFlic_info->height; i++) {
  1204.         line_pixel_ptr = pixel_ptr;
  1205.         number_of_packets = MemReadU8(&pFlic_info->data);
  1206.         for (j = 0; j < number_of_packets; j++) {
  1207.             size_count = MemReadS8(&pFlic_info->data);
  1208.             if (size_count >= 0) {
  1209.                 the_byte = MemReadU8(&pFlic_info->data);
  1210.  
  1211.                 for (k = 0; k < size_count; k++) {
  1212.                     if (the_byte) {
  1213.                         *line_pixel_ptr = the_byte;
  1214.                     }
  1215.                     line_pixel_ptr++;
  1216.                 }
  1217.             } else {
  1218.                 for (k = 0; k < -size_count; k++) {
  1219.                     the_byte = MemReadU8(&pFlic_info->data);
  1220.                     if (the_byte) {
  1221.                         *line_pixel_ptr = the_byte;
  1222.                     }
  1223.                     line_pixel_ptr++;
  1224.                 }
  1225.             }
  1226.         }
  1227.         pixel_ptr += the_row_bytes;
  1228.     }
  1229. }
  1230.  
  1231. // IDA: void __usercall DoUncompressed(tFlic_descriptor *pFlic_info@<EAX>, tU32 chunk_length@<EDX>)
  1232. void DoUncompressed(tFlic_descriptor* pFlic_info, tU32 chunk_length) {
  1233.     int i;
  1234.     int j;
  1235.     int the_width;
  1236.     tU8* pixel_ptr;
  1237.     tU32 the_row_bytes;
  1238.     tU32* line_pixel_ptr;
  1239.     LOG_TRACE("(%p, %d)", pFlic_info, chunk_length);
  1240.  
  1241.     pixel_ptr = pFlic_info->first_pixel;
  1242.     the_row_bytes = pFlic_info->the_pixelmap->row_bytes;
  1243.     the_width = pFlic_info->width;
  1244.     for (i = 0; i < pFlic_info->height; i++) {
  1245.         line_pixel_ptr = (tU32*)pixel_ptr;
  1246.         for (j = 0; j < the_width / 4; j++) {
  1247.             *line_pixel_ptr = MemReadU32(&pFlic_info->data);
  1248.             line_pixel_ptr++;
  1249.         }
  1250.         pixel_ptr += the_row_bytes;
  1251.     }
  1252. }
  1253.  
  1254. // IDA: void __usercall DoUncompressedTrans(tFlic_descriptor *pFlic_info@<EAX>, tU32 chunk_length@<EDX>)
  1255. void DoUncompressedTrans(tFlic_descriptor* pFlic_info, tU32 chunk_length) {
  1256.     int i;
  1257.     int j;
  1258.     int the_width;
  1259.     tU8* pixel_ptr;
  1260.     tU8* line_pixel_ptr;
  1261.     tU8 the_byte;
  1262.     tU32 the_row_bytes;
  1263.     LOG_TRACE("(%p, %d)", pFlic_info, chunk_length);
  1264.  
  1265.     pixel_ptr = pFlic_info->first_pixel;
  1266.     the_row_bytes = pFlic_info->the_pixelmap->row_bytes;
  1267.     the_width = pFlic_info->width;
  1268.     for (i = 0; i < pFlic_info->height; i++) {
  1269.         line_pixel_ptr = pixel_ptr;
  1270.         for (j = 0; j < the_width; j++) {
  1271. #if defined(DETHRACE_FIX_BUGS)
  1272.             the_byte = MemReadU8(&pFlic_info->data);
  1273. #else
  1274.             the_byte = MemReadU32(&pFlic_info->data);
  1275. #endif
  1276.             if (the_byte != '\0') {
  1277.                 *line_pixel_ptr = the_byte;
  1278.             }
  1279.             line_pixel_ptr++;
  1280.         }
  1281.         pixel_ptr += the_row_bytes;
  1282.     }
  1283. }
  1284.  
  1285. // IDA: void __usercall DoMini(tFlic_descriptor *pFlic_info@<EAX>, tU32 chunk_length@<EDX>)
  1286. void DoMini(tFlic_descriptor* pFlic_info, tU32 chunk_length) {
  1287.     LOG_TRACE("(%p, %d)", pFlic_info, chunk_length);
  1288.  
  1289.     MemSkipBytes(&pFlic_info->data, chunk_length - 6);
  1290. }
  1291.  
  1292. // IDA: void __usercall DrawTranslations(tFlic_descriptor *pFlic_info@<EAX>, int pLast_frame@<EDX>)
  1293. void DrawTranslations(tFlic_descriptor* pFlic_info, int pLast_frame) {
  1294.     tTranslation_record* trans;
  1295.     int i;
  1296.     int x;
  1297.     int width;
  1298.     int right_edge;
  1299.     LOG_TRACE("(%p, %d)", pFlic_info, pLast_frame);
  1300.  
  1301.     for (i = 0; i < gTranslation_count; i++) {
  1302.         trans = &gTranslations[i];
  1303.         if (trans->flic_index == pFlic_info->the_index && (trans->every_frame || pLast_frame)) {
  1304.             width = DRTextWidth(gTrans_fonts[trans->font_index], trans->text);
  1305.             switch (trans->justification) {
  1306.             case eJust_left:
  1307.                 x = trans->x;
  1308.                 right_edge = x + width;
  1309.                 break;
  1310.             case eJust_right:
  1311.                 x = trans->x - width;
  1312.                 right_edge = x;
  1313.                 break;
  1314.             case eJust_centre:
  1315.                 x = trans->x - width / 2;
  1316.                 right_edge = x + width / 2;
  1317.                 break;
  1318.             default:
  1319.                 TELL_ME_IF_WE_PASS_THIS_WAY();
  1320.             }
  1321.             TransDRPixelmapText(
  1322.                 pFlic_info->the_pixelmap,
  1323.                 x + (trans->global ? 0 : pFlic_info->x_offset),
  1324.                 trans->y + (trans->global ? 0 : pFlic_info->y_offset),
  1325.                 gTrans_fonts[trans->font_index],
  1326.                 trans->text,
  1327.                 right_edge);
  1328.         }
  1329.     }
  1330. }
  1331.  
  1332. // IDA: int __usercall PlayNextFlicFrame2@<EAX>(tFlic_descriptor *pFlic_info@<EAX>, int pPanel_flic@<EDX>)
  1333. int PlayNextFlicFrame2(tFlic_descriptor* pFlic_info, int pPanel_flic) {
  1334.     tU32 frame_length;
  1335.     tU32 chunk_length;
  1336.     int chunk_count;
  1337.     int chunk_counter;
  1338.     int chunk_type;
  1339.     int magic_bytes;
  1340.     //int last_frame; // Pierre-Marie Baty -- unused variable
  1341.     int data_knocked_off;
  1342.     int read_amount;
  1343.  
  1344.     // LOG_DEBUG("%d (%p), frames left: %d offset: %d", pFlic_info->the_index, pFlic_info, pFlic_info->frames_left, (pFlic_info->data - pFlic_info->data_start) + 4);
  1345.     PossibleService();
  1346.     frame_length = MemReadU32(&pFlic_info->data);
  1347.     magic_bytes = MemReadU16(&pFlic_info->data);
  1348.     chunk_count = MemReadU16(&pFlic_info->data);
  1349.  
  1350.     MemSkipBytes(&pFlic_info->data, 8);
  1351.     if (magic_bytes == 0xf1fa) {
  1352.         for (chunk_counter = 0; chunk_counter < chunk_count; chunk_counter++) {
  1353.             chunk_length = MemReadU32(&pFlic_info->data);
  1354.             chunk_type = MemReadU16(&pFlic_info->data);
  1355.             switch (chunk_type) {
  1356.             case 4:
  1357.                 DoColour256(pFlic_info, chunk_length);
  1358.                 break;
  1359.             case 7:
  1360.                 if (gTransparency_on) {
  1361.                     DoDeltaTrans(pFlic_info, chunk_length);
  1362.                 } else {
  1363.                     DoDeltaX(pFlic_info, chunk_length);
  1364.                 }
  1365.                 break;
  1366.             case 11:
  1367.                 DoColourMap(pFlic_info, chunk_length);
  1368.                 break;
  1369.             case 12:
  1370.                 if (gTransparency_on) {
  1371.                     DoDifferenceTrans(pFlic_info, chunk_length);
  1372.                 } else {
  1373.                     DoDifferenceX(pFlic_info, chunk_length);
  1374.                 }
  1375.                 break;
  1376.             case 13:
  1377.                 DoBlack(pFlic_info, chunk_length);
  1378.                 break;
  1379.             case 15:
  1380.                 if (gTransparency_on) {
  1381.                     DoRunLengthTrans(pFlic_info, chunk_length);
  1382.                 } else {
  1383.                     DoRunLengthX(pFlic_info, chunk_length);
  1384.                 }
  1385.                 break;
  1386.             case 16:
  1387.                 if (gTransparency_on) {
  1388.                     DoUncompressedTrans(pFlic_info, chunk_length);
  1389.                 } else {
  1390.                     DoUncompressed(pFlic_info, chunk_length);
  1391.                 }
  1392.                 break;
  1393.             case 18:
  1394.                 DoMini(pFlic_info, chunk_length);
  1395.                 break;
  1396.             default:
  1397.                 LOG_WARN("unrecognized chunk type");
  1398.                 MemSkipBytes(&pFlic_info->data, chunk_length - 6);
  1399.                 break;
  1400.             }
  1401.             // Align on even byte
  1402.             pFlic_info->data = (char*)((uintptr_t)(pFlic_info->data + 1) & (~(uintptr_t)1));
  1403.         }
  1404.     } else {
  1405.         LOG_WARN("not frame header");
  1406.         MemSkipBytes(&pFlic_info->data, frame_length - 16);
  1407.         pFlic_info->frames_left++;
  1408.         pFlic_info->current_frame--;
  1409.     }
  1410.     pFlic_info->current_frame++;
  1411.     pFlic_info->frames_left--;
  1412.     if (gTrans_enabled && gTranslation_count != 0 && !pPanel_flic) {
  1413.         DrawTranslations(pFlic_info, pFlic_info->frames_left == 0);
  1414.     }
  1415.     if (pFlic_info->f != NULL && pFlic_info->bytes_still_to_be_read) {
  1416.         data_knocked_off = pFlic_info->data - pFlic_info->data_start;
  1417.         memmove(pFlic_info->data_start, pFlic_info->data, pFlic_info->bytes_in_buffer - data_knocked_off);
  1418.         pFlic_info->data = pFlic_info->data_start;
  1419.         pFlic_info->bytes_in_buffer -= data_knocked_off;
  1420.  
  1421.         if (pFlic_info->bytes_still_to_be_read > data_knocked_off) {
  1422.             read_amount = data_knocked_off;
  1423.         } else {
  1424.             read_amount = pFlic_info->bytes_still_to_be_read;
  1425.         }
  1426.         if (read_amount != 0) {
  1427.             fread(&pFlic_info->data_start[pFlic_info->bytes_in_buffer], 1, read_amount, pFlic_info->f);
  1428.         }
  1429.         pFlic_info->bytes_in_buffer += read_amount;
  1430.         pFlic_info->bytes_still_to_be_read -= read_amount;
  1431.     }
  1432.     return pFlic_info->frames_left == 0;
  1433. }
  1434.  
  1435. // IDA: int __usercall PlayNextFlicFrame@<EAX>(tFlic_descriptor *pFlic_info@<EAX>)
  1436. int PlayNextFlicFrame(tFlic_descriptor* pFlic_info) {
  1437.     LOG_TRACE("(%p)", pFlic_info);
  1438.  
  1439.     return PlayNextFlicFrame2(pFlic_info, 0);
  1440. }
  1441.  
  1442. // IDA: int __usercall PlayFlic@<EAX>(int pIndex@<EAX>, tU32 pSize@<EDX>, tS8 *pData_ptr@<EBX>, br_pixelmap *pDest_pixelmap@<ECX>, int pX_offset, int pY_offset, void (*DoPerFrame)(), int pInterruptable, int pFrame_rate)
  1443. int PlayFlic(int pIndex, tU32 pSize, tS8* pData_ptr, br_pixelmap* pDest_pixelmap, int pX_offset, int pY_offset, void (*DoPerFrame)(void), int pInterruptable, int pFrame_rate) {
  1444.     int finished_playing;
  1445.     tFlic_descriptor the_flic;
  1446.     tU32 last_frame;
  1447.     tU32 new_time;
  1448.     tU32 frame_period;
  1449.     LOG_TRACE("(%d, %u, %p, %p, %d, %d, %p, %d, %d)", pIndex, pSize, pData_ptr, pDest_pixelmap, pX_offset, pY_offset, DoPerFrame, pInterruptable, pFrame_rate);
  1450.  
  1451.     finished_playing = 0;
  1452.     the_flic.data_start = NULL;
  1453.     if (StartFlic(gMain_flic_list[pIndex].file_name, pIndex, &the_flic, pSize, pData_ptr, pDest_pixelmap, pX_offset, pY_offset, pFrame_rate)) {
  1454.         LOG_WARN("startflic returned error");
  1455.         return -1;
  1456.     }
  1457.  
  1458.     last_frame = 0;
  1459.     while ((!pInterruptable || !AnyKeyDown()) && !finished_playing) {
  1460.         new_time = PDGetTotalTime();
  1461.         frame_period = new_time - last_frame;
  1462.  
  1463.         if (gSound_time != 0 && new_time >= gSound_time) {
  1464.             DRS3StartSound(gEffects_outlet, gSound_ID);
  1465.             gSound_time = 0;
  1466.         }
  1467.         if (frame_period >= the_flic.frame_period) {
  1468.             last_frame = new_time;
  1469.             finished_playing = PlayNextFlicFrame(&the_flic);
  1470.             DoPerFrame();
  1471.             if (!gDark_mode) {
  1472.                 EnsurePaletteUp();
  1473.             }
  1474.             ServiceGame();
  1475.         }
  1476.     }
  1477.     ServiceGame();
  1478.     EndFlic(&the_flic);
  1479.     return 0;
  1480. }
  1481.  
  1482. // IDA: void __cdecl SwapScreen()
  1483. void SwapScreen(void) {
  1484.     PDScreenBufferSwap(0);
  1485. }
  1486.  
  1487. // IDA: void __usercall ShowFlic(int pIndex@<EAX>)
  1488. void ShowFlic(int pIndex) {
  1489.     do {
  1490.         PlayFlic(
  1491.             pIndex,
  1492.             gMain_flic_list[pIndex].the_size,
  1493.             gMain_flic_list[pIndex].data_ptr,
  1494.             gBack_screen,
  1495.             gMain_flic_list[pIndex].x_offset,
  1496.             gMain_flic_list[pIndex].y_offset,
  1497.             SwapScreen,
  1498.             gMain_flic_list[pIndex].interruptable,
  1499.             gMain_flic_list[pIndex].frame_rate);
  1500.     } while (gMain_flic_list[pIndex].repeat && !AnyKeyDown());
  1501.     gLast_flic_name[0] = '\0'; // byte_10344C;
  1502. }
  1503.  
  1504. // IDA: void __cdecl InitFlics()
  1505. void InitFlics(void) {
  1506.     int i;
  1507.     LOG_TRACE("()");
  1508.  
  1509.     for (i = 0; i < COUNT_OF(gMain_flic_list); i++) {
  1510.         gMain_flic_list[i].data_ptr = NULL;
  1511.     }
  1512. }
  1513.  
  1514. // IDA: int __usercall LoadFlic@<EAX>(int pIndex@<EAX>)
  1515. int LoadFlic(int pIndex) {
  1516.     tPath_name the_path;
  1517.     FILE* f;
  1518.     //char* the_buffer; // Pierre-Marie Baty -- unused variable
  1519.     LOG_TRACE("(%d)", pIndex);
  1520.  
  1521.     if (pIndex < 0) {
  1522.         return 0;
  1523.     }
  1524.     if (gMain_flic_list[pIndex].data_ptr != NULL) {
  1525.         MAMSLock((void**)&gMain_flic_list[pIndex].data_ptr);
  1526.         return 1;
  1527.     }
  1528.     if (gPlay_from_disk) {
  1529.         gMain_flic_list[pIndex].data_ptr = NULL;
  1530.         return 1;
  1531.     }
  1532.     PossibleService();
  1533.     PathCat(the_path, gApplication_path, "ANIM");
  1534.     PathCat(the_path, the_path, gMain_flic_list[pIndex].file_name);
  1535.     f = DRfopen(the_path, "rb");
  1536.  
  1537.     if (f == NULL) {
  1538.         FatalError(kFatalError_LoadFlicFile_S, gMain_flic_list[pIndex].file_name);
  1539.     }
  1540.  
  1541.     gMain_flic_list[pIndex].the_size = GetFileLength(f);
  1542.     gMain_flic_list[pIndex].data_ptr = BrMemAllocate(gMain_flic_list[pIndex].the_size, 0x90u);
  1543.  
  1544.     if (gMain_flic_list[pIndex].data_ptr == NULL) {
  1545.         if (AllocationErrorsAreFatal()) {
  1546.             FatalError(kFatalError_AllocateFlicFile_S, gMain_flic_list[pIndex].file_name);
  1547.         }
  1548. #ifdef DETHRACE_FIX_BUGS
  1549.         fclose(f);
  1550. #endif
  1551.         return 0;
  1552.     }
  1553.  
  1554.     fread(gMain_flic_list[pIndex].data_ptr, 1, gMain_flic_list[pIndex].the_size, f);
  1555.     strcpy(gLast_flic_name, gMain_flic_list[pIndex].file_name);
  1556.     fclose(f);
  1557.     return 1;
  1558. }
  1559.  
  1560. // IDA: void __usercall UnlockFlic(int pIndex@<EAX>)
  1561. void UnlockFlic(int pIndex) {
  1562.     if (pIndex >= 0) {
  1563.         if (gMain_flic_list[pIndex].data_ptr != NULL) {
  1564.             MAMSUnlock((void**)&gMain_flic_list[pIndex].data_ptr);
  1565.         }
  1566.     }
  1567. }
  1568.  
  1569. // IDA: int __usercall LoadFlicData@<EAX>(char *pName@<EAX>, tU8 **pData@<EDX>, tU32 *pData_length@<EBX>)
  1570. int LoadFlicData(char* pName, tU8** pData, tU32* pData_length) {
  1571.     FILE* f;
  1572.     tPath_name the_path;
  1573.     LOG_TRACE("(\"%s\", %p, %p)", pName, pData, pData_length);
  1574.  
  1575.     if (*pData != NULL) {
  1576.         MAMSLock((void**)pData);
  1577.         return 1;
  1578.     }
  1579.     if (gPlay_from_disk) {
  1580.         return 1;
  1581.     }
  1582.     PossibleService();
  1583.     PathCat(the_path, gApplication_path, "ANIM");
  1584.     PathCat(the_path, the_path, pName);
  1585.     f = DRfopen(the_path, "rb");
  1586.     if (f == NULL) {
  1587.         return 0;
  1588.     }
  1589.     *pData_length = GetFileLength(f);
  1590.     *pData = BrMemAllocate(*pData_length, kMem_flic_data_2);
  1591.     if (*pData == NULL) {
  1592.         fclose(f);
  1593.         return 0;
  1594.     }
  1595.     fread(*pData, 1, *pData_length, f);
  1596.     fclose(f);
  1597.     return 1;
  1598. }
  1599.  
  1600. // IDA: void __usercall FreeFlic(int pIndex@<EAX>)
  1601. void FreeFlic(int pIndex) {
  1602.     LOG_TRACE("(%d)", pIndex);
  1603.  
  1604.     PossibleService();
  1605.     if (gMain_flic_list[pIndex].data_ptr != NULL) {
  1606.         BrMemFree(gMain_flic_list[pIndex].data_ptr);
  1607.         gMain_flic_list[pIndex].data_ptr = NULL;
  1608.     }
  1609. }
  1610.  
  1611. // IDA: void __usercall ForceRunFlic(int pIndex@<EAX>)
  1612. void ForceRunFlic(int pIndex) {
  1613.     LOG_TRACE("(%d)", pIndex);
  1614.  
  1615.     LoadFlic(pIndex);
  1616.     ShowFlic(pIndex);
  1617.     UnlockFlic(pIndex);
  1618. }
  1619.  
  1620. // IDA: void __usercall RunFlicAt(int pIndex@<EAX>, int pX@<EDX>, int pY@<EBX>)
  1621. void RunFlicAt(int pIndex, int pX, int pY) {
  1622.     LOG_TRACE("(%d, %d, %d)", pIndex, pX, pY);
  1623.  
  1624.     LoadFlic(pIndex);
  1625.     PlayFlic(
  1626.         pIndex,
  1627.         gMain_flic_list[pIndex].the_size,
  1628.         gMain_flic_list[pIndex].data_ptr,
  1629.         gBack_screen,
  1630.         pX,
  1631.         pY,
  1632.         SwapScreen,
  1633.         0,
  1634.         0);
  1635.     UnlockFlic(pIndex);
  1636. }
  1637.  
  1638. // IDA: void __usercall RunFlic(int pIndex@<EAX>)
  1639. void RunFlic(int pIndex) {
  1640.     LOG_TRACE("(%d)", pIndex);
  1641.  
  1642.     if (gPending_flic >= 0) {
  1643.         ForceRunFlic(gPending_flic);
  1644.         gPending_flic = -1;
  1645.     }
  1646.     if (LoadFlic(pIndex)) {
  1647.         if (gMain_flic_list[pIndex].queued) {
  1648.             gPending_flic = pIndex;
  1649.         } else {
  1650.             ShowFlic(pIndex);
  1651.             UnlockFlic(pIndex);
  1652.         }
  1653.     }
  1654. }
  1655.  
  1656. // IDA: void __usercall PreloadBunchOfFlics(int pBunch_index@<EAX>)
  1657. void PreloadBunchOfFlics(int pBunch_index) {
  1658.     int i;
  1659.     LOG_TRACE("(%d)", pBunch_index);
  1660.  
  1661.     for (i = 0; i < gFlic_bunch[pBunch_index].count; i++) {
  1662.         LoadFlic(gFlic_bunch[pBunch_index].indexes[i]);
  1663.     }
  1664. }
  1665.  
  1666. // IDA: void __usercall UnlockBunchOfFlics(int pBunch_index@<EAX>)
  1667. void UnlockBunchOfFlics(int pBunch_index) {
  1668.     int i;
  1669.     LOG_TRACE("(%d)", pBunch_index);
  1670.  
  1671.     for (i = 0; i < gFlic_bunch[pBunch_index].count; i++) {
  1672.         UnlockFlic(gFlic_bunch[pBunch_index].indexes[i]);
  1673.     }
  1674. }
  1675.  
  1676. // IDA: void __usercall FlushAllFlics(int pBunch_index@<EAX>)
  1677. void FlushAllFlics(int pBunch_index) {
  1678.     int i;
  1679.     LOG_TRACE("(%d)", pBunch_index);
  1680.  
  1681.     for (i = 0; i < COUNT_OF(gFlic_bunch); i++) {
  1682.         FreeFlic(i);
  1683.     }
  1684. }
  1685.  
  1686. // IDA: void __cdecl InitFlicQueue()
  1687. void InitFlicQueue(void) {
  1688.     gFirst_flic = NULL;
  1689. }
  1690.  
  1691. // IDA: int __cdecl FlicQueueFinished()
  1692. int FlicQueueFinished(void) {
  1693.     tFlic_descriptor* the_flic;
  1694.     LOG_TRACE("()");
  1695.  
  1696.     the_flic = gFirst_flic;
  1697.     while (the_flic != NULL) {
  1698.         if (the_flic->must_finish) {
  1699.             return 0;
  1700.         }
  1701.         the_flic = the_flic->next;
  1702.     }
  1703.     return 1;
  1704. }
  1705.  
  1706. // IDA: void __usercall ProcessFlicQueue(tU32 pInterval@<EAX>)
  1707. void ProcessFlicQueue(tU32 pInterval) {
  1708.     tFlic_descriptor* the_flic;
  1709.     tFlic_descriptor* last_flic;
  1710.     tFlic_descriptor* doomed_flic;
  1711.     tU32 new_time;
  1712.     int finished_playing;
  1713.     LOG_TRACE8("(%d)", pInterval);
  1714.  
  1715.     DontLetFlicFuckWithPalettes();
  1716.     TurnFlicTransparencyOn();
  1717.     the_flic = gFirst_flic;
  1718.     last_flic = NULL;
  1719.     new_time = PDGetTotalTime();
  1720.     while (the_flic != NULL) {
  1721.         if (new_time - the_flic->last_frame < the_flic->frame_period) {
  1722.             finished_playing = 0;
  1723.         } else {
  1724.             the_flic->last_frame = new_time;
  1725.             finished_playing = PlayNextFlicFrame(the_flic);
  1726.         }
  1727.         if (finished_playing) {
  1728.             EndFlic(the_flic);
  1729.             if (last_flic != NULL) {
  1730.                 last_flic->next = the_flic->next;
  1731.             } else {
  1732.                 gFirst_flic = the_flic->next;
  1733.             }
  1734.             doomed_flic = the_flic;
  1735.             the_flic = the_flic->next;
  1736.             BrMemFree(doomed_flic);
  1737.         } else {
  1738.             last_flic = the_flic;
  1739.             the_flic = the_flic->next;
  1740.         }
  1741.     }
  1742.     TurnFlicTransparencyOff();
  1743.     LetFlicFuckWithPalettes();
  1744. }
  1745.  
  1746. // IDA: void __cdecl FlushFlicQueue()
  1747. void FlushFlicQueue(void) {
  1748.     tFlic_descriptor* the_flic;
  1749.     tFlic_descriptor* old_flic;
  1750.     LOG_TRACE("()");
  1751.  
  1752.     // Jeff: loop through pending flics until we reach the end or we find one that is `must_finish`.
  1753.     // If `must_finish`, we process the queue then check again.
  1754.     // If there are no `must_finish` in the list, immediately end any remaining flics
  1755.  
  1756.     while (!FlicQueueFinished()) {
  1757.         RemoveTransientBitmaps(1);
  1758.         ProcessFlicQueue(gFrame_period);
  1759.         DoMouseCursor();
  1760.         PDScreenBufferSwap(0);
  1761.     }
  1762.     the_flic = gFirst_flic;
  1763.     while (the_flic != NULL) {
  1764.         EndFlic(the_flic);
  1765.         old_flic = the_flic;
  1766.         the_flic = the_flic->next;
  1767.         BrMemFree(old_flic);
  1768.     }
  1769.     gFirst_flic = NULL;
  1770. }
  1771.  
  1772. // IDA: void __usercall AddToFlicQueue(int pIndex@<EAX>, int pX@<EDX>, int pY@<EBX>, int pMust_finish@<ECX>)
  1773. void AddToFlicQueue(int pIndex, int pX, int pY, int pMust_finish) {
  1774.     tFlic_descriptor* the_flic = NULL;
  1775.     tFlic_descriptor* new_flic = NULL;
  1776.     tFlic_descriptor* last_flic = NULL;
  1777.     tFlic_descriptor* doomed_flic = NULL;
  1778.     LOG_TRACE("(%d, %d, %d, %d)", pIndex, pX, pY, pMust_finish);
  1779.  
  1780.     the_flic = gFirst_flic;
  1781.     while (the_flic != NULL) {
  1782.         if (pX == the_flic->x_offset && pY == the_flic->y_offset) {
  1783.             doomed_flic = the_flic;
  1784.             break;
  1785.         }
  1786.         last_flic = the_flic;
  1787.         the_flic = the_flic->next;
  1788.     }
  1789.  
  1790.     if (doomed_flic != NULL) {
  1791.         EndFlic(doomed_flic);
  1792.         if (last_flic != NULL) {
  1793.             last_flic->next = doomed_flic->next;
  1794.         } else {
  1795.             gFirst_flic = doomed_flic->next;
  1796.         }
  1797.         BrMemFree(doomed_flic);
  1798.     }
  1799.  
  1800.     LoadFlic(pIndex);
  1801.     new_flic = BrMemAllocate(sizeof(tFlic_descriptor), kMem_queued_flic);
  1802.     new_flic->next = NULL;
  1803.     the_flic = gFirst_flic;
  1804.     if (gFirst_flic != NULL) {
  1805.         while (the_flic->next != NULL) {
  1806.             the_flic = the_flic->next;
  1807.         }
  1808.         the_flic->next = new_flic;
  1809.     } else {
  1810.         gFirst_flic = new_flic;
  1811.     }
  1812.     new_flic->last_frame = 0;
  1813.     new_flic->data_start = NULL;
  1814.     new_flic->the_index = pIndex;
  1815.     new_flic->must_finish = pMust_finish;
  1816.  
  1817.     StartFlic(
  1818.         gMain_flic_list[pIndex].file_name,
  1819.         pIndex,
  1820.         new_flic,
  1821.         gMain_flic_list[pIndex].the_size,
  1822.         gMain_flic_list[pIndex].data_ptr,
  1823.         gBack_screen,
  1824.         pX >= 0 ? pX : gMain_flic_list[pIndex].x_offset,
  1825.         pY >= 0 ? pY : gMain_flic_list[pIndex].y_offset,
  1826.         20);
  1827. }
  1828.  
  1829. // IDA: void __usercall InitialiseFlicPanel(int pIndex@<EAX>, int pLeft@<EDX>, int pTop@<EBX>, int pWidth@<ECX>, int pHeight)
  1830. void InitialiseFlicPanel(int pIndex, int pLeft, int pTop, int pWidth, int pHeight) {
  1831.     void* the_pixels;
  1832.     LOG_TRACE("(%d, %d, %d, %d, %d)", pIndex, pLeft, pTop, pWidth, pHeight);
  1833.  
  1834.     gPanel_flic[pIndex].data = NULL;
  1835.     gPanel_flic_left[pIndex] = pLeft;
  1836.     gPanel_flic_top[pIndex] = pTop;
  1837.     the_pixels = BrMemAllocate(pHeight * ((pWidth + 3) & ~3), kFlic_panel_pixels);
  1838.     if (gScreen->row_bytes < 0) {
  1839.         BrFatal(
  1840.             "..\\..\\source\\common\\flicplay.c",
  1841.             2116,
  1842.             "Bruce bug at line %d, file ..\\..\\source\\common\\flicplay.c",
  1843.             68);
  1844.     }
  1845.     gPanel_buffer[pIndex] = DRPixelmapAllocate(gScreen->type, pWidth, pHeight, the_pixels, 0);
  1846. }
  1847.  
  1848. // IDA: void __usercall DisposeFlicPanel(int pIndex@<EAX>)
  1849. void DisposeFlicPanel(int pIndex) {
  1850.     LOG_TRACE("(%d)", pIndex);
  1851.  
  1852.     EndFlic(&gPanel_flic[pIndex]);
  1853.     BrMemFree(gPanel_buffer[pIndex]->pixels);
  1854.     BrPixelmapFree(gPanel_buffer[pIndex]);
  1855.     gPanel_buffer[pIndex] = NULL;
  1856. }
  1857.  
  1858. // IDA: void __usercall ServicePanelFlics(int pCopy_to_buffer@<EAX>)
  1859. void ServicePanelFlics(int pCopy_to_buffer) {
  1860.     tU32 time_diff;
  1861.     tU32 the_time;
  1862.     tU32 old_last_time[2];
  1863.     int i;
  1864.     int j;
  1865.     int iteration_count;
  1866.     int finished;
  1867.  
  1868.     if (gPanel_flic_disable) {
  1869.         return;
  1870.     }
  1871.     the_time = PDGetTotalTime();
  1872.     DontLetFlicFuckWithPalettes();
  1873.     TurnFlicTransparencyOn();
  1874.  
  1875.     for (i = 0; i < COUNT_OF(gPanel_flic); i++) {
  1876.         old_last_time[i] = gLast_panel_frame_time[i];
  1877.         if (gPanel_buffer[i] != NULL && gPanel_flic[i].data != NULL) {
  1878.             if (old_last_time[i] != 0) {
  1879.                 time_diff = the_time - old_last_time[i];
  1880.                 iteration_count = time_diff / gPanel_flic[i].frame_period;
  1881.             } else {
  1882.                 iteration_count = 1;
  1883.             }
  1884.             for (j = 0; j < iteration_count; j++) {
  1885.                 finished = PlayNextFlicFrame2(&gPanel_flic[i], 1);
  1886.                 if (finished) {
  1887.                     EndFlic(&gPanel_flic[i]);
  1888.                     StartFlic(
  1889.                         gPanel_flic[i].file_name,
  1890.                         gPanel_flic[i].the_index,
  1891.                         &gPanel_flic[i],
  1892.                         gPanel_flic_data_length[i],
  1893.                         (tS8*)gPanel_flic_data[i],
  1894.                         gPanel_buffer[i],
  1895.                         0,
  1896.                         0,
  1897.                         0);
  1898.                 }
  1899.                 gLast_panel_frame_time[i] = the_time;
  1900.             }
  1901.             if (pCopy_to_buffer) {
  1902.                 BrPixelmapRectangleCopy(
  1903.                     gBack_screen,
  1904.                     gPanel_flic_left[i],
  1905.                     gPanel_flic_top[i],
  1906.                     gPanel_buffer[i],
  1907.                     0,
  1908.                     0,
  1909.                     gPanel_buffer[i]->width,
  1910.                     gPanel_buffer[i]->height);
  1911.             }
  1912.         }
  1913.     }
  1914.     TurnFlicTransparencyOff();
  1915.     LetFlicFuckWithPalettes();
  1916. }
  1917.  
  1918. // IDA: void __usercall ChangePanelFlic(int pIndex@<EAX>, tU8 *pData@<EDX>, tU32 pData_length@<EBX>)
  1919. void ChangePanelFlic(int pIndex, tU8* pData, tU32 pData_length) {
  1920.     LOG_TRACE("(%d, %p, %d)", pIndex, pData, pData_length);
  1921.  
  1922.     EndFlic(&gPanel_flic[pIndex]);
  1923.     gPanel_flic_data[pIndex] = pData;
  1924.     gPanel_flic_data_length[pIndex] = pData_length;
  1925.     BrPixelmapFill(gPanel_buffer[pIndex], 0);
  1926.     StartFlic(
  1927.         gPanel_flic[pIndex].file_name,
  1928.         pIndex,
  1929.         &gPanel_flic[pIndex],
  1930.         gPanel_flic_data_length[pIndex],
  1931.         (tS8*)gPanel_flic_data[pIndex],
  1932.         gPanel_buffer[pIndex],
  1933.         0,
  1934.         0,
  1935.         0);
  1936.     gLast_panel_frame_time[pIndex] = 0;
  1937.     ServicePanelFlics(0);
  1938. }
  1939.  
  1940. // IDA: br_pixelmap* __usercall GetPanelPixelmap@<EAX>(int pIndex@<EAX>)
  1941. br_pixelmap* GetPanelPixelmap(int pIndex) {
  1942.     LOG_TRACE("(%d)", pIndex);
  1943.  
  1944.     return gPanel_buffer[pIndex];
  1945. }
  1946.  
  1947. // IDA: void __cdecl LoadInterfaceStrings()
  1948. void LoadInterfaceStrings(void) {
  1949.     FILE* f; // Added by DethRace
  1950.     char s[256];
  1951.     char s2[256];
  1952.     char* str;
  1953.     char* comment;
  1954.     char ch;
  1955.     tPath_name the_path;
  1956.     int i;
  1957.     int j;
  1958.     int len;
  1959.  
  1960.     gTranslation_count = 0;
  1961.     PathCat(the_path, gApplication_path, "TRNSLATE.TXT");
  1962.     f = fopen(the_path, "rt");
  1963.     if (f == NULL) {
  1964.         return;
  1965.     }
  1966.     while (!feof(f)) {
  1967.         GetALineAndDontArgue(f, s);
  1968.         gTranslation_count++;
  1969.     }
  1970.     rewind(f);
  1971.     gTranslations = BrMemAllocate(gTranslation_count * sizeof(tTranslation_record), kMem_translations);
  1972.     for (i = 0; i < gTranslation_count; i++) {
  1973.         GetALineAndDontArgue(f, s);
  1974.         str = strtok(s, "\t ,/");
  1975.         strcpy(s2, str);
  1976.         strtok(s2, ".");
  1977.         strcat(s2, ".FLI");
  1978.         gTranslations[i].flic_index = -1;
  1979.         for (j = 0; j < COUNT_OF(gMain_flic_list); j++) {
  1980.             if (strcmp(gMain_flic_list[j].file_name, s2) == 0) {
  1981.                 gTranslations[i].flic_index = j;
  1982.                 break;
  1983.             }
  1984.         }
  1985.         if (gTranslations[i].flic_index < 0) {
  1986.             FatalError(kFatalError_FindFlicUsedInTranslationFile_S, s2);
  1987.         }
  1988.         str[strlen(str)] = ',';
  1989.         str = strtok(s, "\t ,/");
  1990.         str = strtok(NULL, "\t ,/");
  1991.         sscanf(str, "%d", &gTranslations[i].x);
  1992.         str = strtok(NULL, "\t ,/");
  1993.         sscanf(str, "%d", &gTranslations[i].y);
  1994.         str = strtok(NULL, "\t ,/");
  1995.         sscanf(str, "%d", &gTranslations[i].font_index);
  1996.         str = strtok(NULL, "\t ,/");
  1997.         sscanf(str, "%c", &ch);
  1998.         switch (ch) {
  1999.         case 'C':
  2000.         case 'c':
  2001.             gTranslations[i].justification = eJust_centre;
  2002.             break;
  2003.         case 'L':
  2004.         case 'l':
  2005.             gTranslations[i].justification = eJust_left;
  2006.             break;
  2007.         case 'R':
  2008.         case 'r':
  2009.             gTranslations[i].justification = eJust_right;
  2010.             break;
  2011.         }
  2012.         str = strtok(NULL, "\t ,/");
  2013.         sscanf(str, "%c", &ch);
  2014.         gTranslations[i].global = ch == 'G' || ch == 'g';
  2015.         gTranslations[i].every_frame = strlen(str) > 1 && (str[1] == 'E' || str[1] == 'e');
  2016.         str += strlen(str) + 1;
  2017.         comment = strstr(str, "//");
  2018.         if (comment != NULL) {
  2019.             *comment = '\0';
  2020.         }
  2021.         len = strlen(str);
  2022.         for (j = len - 1; j >= 0 && (str[j] == ' ' || str[j] == '\t'); j--) {
  2023.         }
  2024.         str[j + 1] = '\0';
  2025.         gTranslations[i].text = BrMemAllocate(strlen(str) + 1, kMem_translations_text);
  2026.         strcpy(gTranslations[i].text, str);
  2027.     }
  2028.     LoadFont(kFont_BLUEHEAD);
  2029.     LoadFont(kFont_ORANGHED);
  2030.     LoadFont(kFont_GREENHED);
  2031.     LoadFont(kFont_LITPLAQ);
  2032.     LoadFont(kFont_BUTTOUT);
  2033.     LoadFont(kFont_DRKPLAQ);
  2034.     LoadFont(kFont_BUTTIN);
  2035.     LoadFont(kFont_GRNLIT);
  2036.     LoadFont(kFont_GRYLIT);
  2037.     LoadFont(kFont_GRNDK);
  2038.     LoadFont(kFont_GRYDK);
  2039.     LoadFont(kFont_LITPLAQ1);
  2040.     LoadFont(kFont_BUTTOUT1);
  2041.     LoadFont(kFont_DRKPLAQ1);
  2042.     LoadFont(kFont_BUTTIN1);
  2043.     gTrans_fonts[0] = &gFonts[kFont_ORANGHED];
  2044.     gTrans_fonts[1] = &gFonts[kFont_LITPLAQ];
  2045.     gTrans_fonts[2] = &gFonts[kFont_BUTTOUT];
  2046.     gTrans_fonts[3] = &gFonts[kFont_DRKPLAQ];
  2047.     gTrans_fonts[4] = &gFonts[kFont_BUTTIN];
  2048.     gTrans_fonts[5] = &gFonts[kFont_GRNLIT];
  2049.     gTrans_fonts[6] = &gFonts[kFont_GRYLIT];
  2050.     gTrans_fonts[7] = &gFonts[kFont_GRNDK];
  2051.     gTrans_fonts[8] = &gFonts[kFont_GRYDK];
  2052.     gTrans_fonts[9] = &gFonts[kFont_LITPLAQ1];
  2053.     gTrans_fonts[10] = &gFonts[kFont_DRKPLAQ1];
  2054.     gTrans_fonts[11] = &gFonts[kFont_BUTTOUT1];
  2055.     gTrans_fonts[12] = &gFonts[kFont_BUTTIN1];
  2056.  
  2057. #ifdef DETHRACE_FIX_BUGS
  2058.     fclose(f);
  2059. #endif
  2060. }
  2061.  
  2062. // IDA: void __cdecl FlushInterfaceFonts()
  2063. void FlushInterfaceFonts(void) {
  2064.     LOG_TRACE("()");
  2065.  
  2066.     DisposeFont(19);
  2067.     DisposeFont(18);
  2068.     DisposeFont(20);
  2069.     DisposeFont(17);
  2070.     DisposeFont(15);
  2071.     DisposeFont(14);
  2072.     DisposeFont(16);
  2073.     DisposeFont(13);
  2074. }
  2075.  
  2076. // IDA: void __cdecl SuspendPendingFlic()
  2077. void SuspendPendingFlic(void) {
  2078.     LOG_TRACE("()");
  2079.  
  2080.     gPending_pending_flic = gPending_flic;
  2081.     gPending_flic = -1;
  2082. }
  2083.  
  2084. // IDA: void __cdecl ResumePendingFlic()
  2085. void ResumePendingFlic(void) {
  2086.     LOG_TRACE("()");
  2087.  
  2088.     gPending_flic = gPending_pending_flic;
  2089. }
  2090.