home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 030.lha / Ogre / init.c < prev    next >
Encoding:
C/C++ Source or Header  |  1986-11-10  |  7.7 KB  |  415 lines
  1. #include "ext.h"
  2.  
  3. static char a,b;
  4. static int cp_set;
  5. static int infantry_points, armor_points;
  6.  
  7. init_units(mark)
  8. {
  9.    char s[80];
  10.    int i,j;
  11.    int unitcmp();
  12.  
  13.    a = b = 10;
  14.  
  15.    switch (mark)
  16.    {
  17.       case 3:
  18.          armor_points = 16;
  19.          infantry_points = 18;
  20.          break;
  21.  
  22.       case 5:
  23.          armor_points = 22;
  24.          infantry_points = 27;
  25.          break;
  26.    }
  27.  
  28.    n_units = 0;
  29.    cp_set = FALSE;
  30.  
  31.    while (armor_points > 0 || infantry_points > 0 || !cp_set)
  32.    {
  33.       sprintf(s, "left to place: %d armor, %d infantry%s", armor_points,
  34.          infantry_points, (cp_set) ? "." : ", CP");
  35.       movecur(16,0);
  36.       eeol(16);
  37.       Amiga_puts(s);
  38.       getunit();
  39.    }
  40.  
  41.    sort(&unit[0], n_units, sizeof(UNIT), unitcmp);
  42.  
  43. }
  44.  
  45. sort(unit, n, size, comp)
  46. UNIT *unit;
  47. int n, size;
  48. int (*comp)();
  49. {
  50.    int gap, i, j;
  51.    UNIT tmp;
  52.  
  53.    for (gap = n/2; gap > 0; gap /= 2)
  54.       for (i = gap; i < n; ++i)
  55.          for (j = i - gap; j >= 0; j -= gap)
  56.          {
  57.             if ((*comp)(unit[j], unit[j + gap]) <= 0)
  58.                break;
  59.             tmp = unit[j];
  60.             unit[j] = unit[j + gap];
  61.             unit[j + gap] = tmp;
  62.          }
  63. }
  64.  
  65. getunit()
  66. {
  67.    char no_new, bad_char;
  68.    char olda, oldb;
  69.    char dir;
  70.  
  71.    no_new = TRUE;
  72.    bad_char = FALSE;
  73.    movecur_hex(a, b);
  74.  
  75.    while (no_new)
  76.    {
  77.       olda = a;
  78.       oldb = b;
  79.  
  80.       dir = Amiga_getchar();
  81.  
  82.       switch (dir)
  83.       {
  84.          case RIGHT:
  85.             --a;
  86.             --b;
  87.             break;
  88.  
  89.          case UPRIGHT:
  90.             --a;
  91.             break;
  92.  
  93.          case DOWNRIGHT:
  94.             --b;
  95.             break;
  96.  
  97.          case LEFT:
  98.             ++a;
  99.             ++b;
  100.             break;
  101.  
  102.          case UPLEFT:
  103.             ++b;
  104.             break;
  105.  
  106.          case DOWNLEFT:
  107.             ++a;
  108.             break;
  109.  
  110.          case SIT:
  111.             break;
  112.  
  113.          case CP:
  114.             if (cp_set)
  115.                bad_char = TRUE;
  116.             else
  117.             {
  118.                add_unit(a, b, dir);
  119.                no_new = FALSE;
  120.                cp_set = TRUE;
  121.             }
  122.             break;
  123.  
  124.          case HVYTANK:
  125.          case MSLTANK:
  126.          case GEV:
  127.             if (occupied(a,b) || blocked(a,b) || armor_points == 0)
  128.             {
  129.                bad_char = TRUE;
  130.                break;
  131.             }
  132.             add_unit(a,b,dir);
  133.             no_new = FALSE;
  134.             --armor_points;
  135.             break;
  136.  
  137.          case '1':
  138.          case '2':
  139.          case '3':
  140.           if (occupied(a,b) || blocked(a,b) || infantry_points < (dir - '0'))
  141.             {
  142.                bad_char = TRUE;
  143.                break;
  144.             }
  145.             add_unit(a, b, dir);
  146.             no_new = FALSE;
  147.             infantry_points -= (dir - '0');
  148.             break;
  149.  
  150.       case INFANTRY:
  151.             if (occupied(a,b) || blocked(a,b) || infantry_points < 3)
  152.             {
  153.                bad_char = TRUE;
  154.                break;
  155.             }
  156.             add_unit(a, b, '3');
  157.             no_new = FALSE;
  158.             infantry_points -= 3;
  159.             break;
  160.  
  161.       case HOWITZER:
  162.             if (occupied(a,b) || blocked(a,b) || armor_points <= 1)
  163.             {
  164.                bad_char = TRUE;
  165.                break;
  166.             }
  167.             add_unit(a,b,dir);
  168.             no_new = FALSE;
  169.             armor_points -= 2;
  170.             break;
  171.  
  172.       default:
  173.             bad_char = TRUE;
  174.             break;
  175.    }
  176.    if (off_obstructed(a,b) || bad_char)
  177.    {
  178.       a = olda;
  179.       b = oldb;
  180.       bad_char = FALSE;
  181.    }
  182.    else
  183.       movecur_hex(a,b);
  184.    }  /* while */
  185. }
  186.  
  187. add_unit(a, b, c)
  188. char a, b, c;
  189. {
  190.    int i;
  191.  
  192.    i = n_units;
  193.    ++n_units;
  194.  
  195.    switch (c)
  196.    {
  197.       case CP:
  198.          unit[i].type = CP;
  199.          unit[i].attack = 0;
  200.          unit[i].range = 0;
  201.          unit[i].defend = 0;
  202.          unit[i].movement = 0;
  203.          break;
  204.  
  205.       case HVYTANK:
  206.          unit[i].type = HVYTANK;
  207.          unit[i].attack = 4;
  208.          unit[i].range = 2;
  209.          unit[i].defend = 3;
  210.          unit[i].movement = 3;
  211.          break;
  212.  
  213.       case MSLTANK:
  214.          unit[i].type = MSLTANK;
  215.          unit[i].attack = 3;
  216.          unit[i].range = 4;
  217.          unit[i].defend = 2;
  218.          unit[i].movement = 2;
  219.          break;
  220.  
  221.       case GEV:
  222.          unit[i].type = GEV;
  223.          unit[i].attack = 2;
  224.          unit[i].range = 2;
  225.          unit[i].defend = 2;
  226.          unit[i].movement = 4;
  227.          break;
  228.  
  229.       case HOWITZER:
  230.          unit[i].type = HOWITZER;
  231.          unit[i].attack = 6;
  232.          unit[i].range = 8;
  233.          unit[i].defend = 1;
  234.          unit[i].movement = 0;
  235.          break;
  236.  
  237.       case INFANTRY:
  238.       case '3':
  239.          unit[i].type = INFANTRY;
  240.          unit[i].attack = 3;
  241.          unit[i].range = 1;
  242.          unit[i].defend = 1;
  243.          unit[i].movement = 2;
  244.          break;
  245.  
  246.       case '1':
  247.          unit[i].type = INFANTRY;
  248.          unit[i].attack = 1;
  249.          unit[i].range = 1;
  250.          unit[i].defend = 1;
  251.          unit[i].movement = 2;
  252.          break;
  253.  
  254.       case '2':
  255.          unit[i].type = INFANTRY;
  256.          unit[i].attack = 2;
  257.          unit[i].range = 1;
  258.          unit[i].defend = 1;
  259.          unit[i].movement = 2;
  260.          break;
  261.    }
  262.  
  263.    unit[i].range_to_ogre = 0;
  264.    unit[i].fired = 0;
  265.    unit[i].status = OK;
  266.    unit[i].moves_left = 0;
  267.    unit[i].l_hex = a;
  268.    unit[i].r_hex = b;
  269.  
  270.    disp_unit(i);
  271. }
  272.  
  273. occupied(a,b)
  274. char a,b;
  275. {
  276.    int i;
  277.  
  278.    for (i = 0; i < n_units; ++i)
  279.       if (unit[i].status != DESTROYED && unit[i].l_hex == a &&
  280.          unit[i].r_hex == b)  return(TRUE);
  281.    return(FALSE);
  282. }
  283.  
  284. init_ogre(mark)
  285. int mark;
  286. {
  287.    long lrand48();
  288.  
  289.    ogre.l_hex = (char) lrand48() % 7 + 22;
  290.    ogre.r_hex = 50 - ogre.l_hex;
  291.  
  292.    switch (mark)
  293.    {
  294.       case 3:
  295.          ogre.treads = 45;
  296.          ogre.init_treads = 45;
  297.          ogre.movement = 3;
  298.          ogre.missiles = 2;
  299.          ogre.main_bats = 1;
  300.          ogre.sec_bats = 4;
  301.          ogre.ap = 8;
  302.          break;
  303.  
  304.       case 5:
  305.          ogre.treads = 60;
  306.          ogre.init_treads = 60;
  307.          ogre.movement = 3;
  308.          ogre.missiles = 5;
  309.          ogre.main_bats = 2;
  310.          ogre.sec_bats = 6;
  311.          ogre.ap = 10;
  312.          break;
  313.  
  314.    }
  315.    disp_ogre();
  316. }
  317.  
  318. unitcmp(u1, u2)
  319. UNIT *u1, *u2;
  320. {
  321.    int cmp;
  322.  
  323.    switch(u1->type)
  324.    {
  325.       case CP:
  326.          switch (u2->type)
  327.          {
  328.             case CP:
  329.                cmp = 0;
  330.                break;
  331.             default:
  332.                cmp = -1;
  333.                break;
  334.          }
  335.          break;
  336.  
  337.       case HOWITZER:
  338.          switch(u2->type)
  339.          {
  340.             case CP:
  341.                cmp = 1;
  342.                break;
  343.             case HOWITZER:
  344.                cmp = 0;
  345.                break;
  346.             default:
  347.                cmp = -1;
  348.                break;
  349.          }
  350.          break;
  351.  
  352.       case HVYTANK:
  353.          switch (u2->type)
  354.          {
  355.             case CP:
  356.             case HOWITZER:
  357.                cmp = 1;
  358.                break;
  359.             case HVYTANK:
  360.                cmp = 0;
  361.                break;
  362.             default:
  363.                cmp = -1;
  364.                break;
  365.          }
  366.          break;
  367.  
  368.       case MSLTANK:
  369.          switch(u2->type)
  370.          {
  371.             case CP:
  372.             case HOWITZER:
  373.             case HVYTANK:
  374.                cmp = 1;
  375.                break;
  376.             case MSLTANK:
  377.                cmp = 0;
  378.                break;
  379.             default:
  380.                cmp = -1;
  381.                break;
  382.          }
  383.          break;
  384.  
  385.       case GEV:
  386.          switch (u2->type)
  387.          {
  388.             case INFANTRY:
  389.                cmp = -1;
  390.                break;
  391.             case GEV:
  392.                cmp = 0;
  393.                break;
  394.             default:
  395.                cmp = -1;
  396.                break;
  397.          }
  398.          break;
  399.  
  400.       case INFANTRY:
  401.          switch (u2->type)
  402.          {
  403.             case INFANTRY:
  404.                cmp = 0;
  405.                break;
  406.             default:
  407.                cmp = -1;
  408.                break;
  409.          }
  410.          break;
  411.    }
  412.  
  413.    return(cmp);
  414. }
  415.