home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / games / volume13 / dominion / part20 / spells.c < prev   
C/C++ Source or Header  |  1992-02-11  |  25KB  |  882 lines
  1.   /* spells.c -- the spells are coded here */
  2.  
  3. /*
  4.  * Copyright (C) 1990 Free Software Foundation, Inc.
  5.  * Written by the dominion project.
  6.  *
  7.  * This file is part of dominion.
  8.  *
  9.  * dominion is free software; you can redistribute it and/or
  10.  * modify it under the terms of the GNU General Public License as published
  11.  * by the Free Software Foundation; either version 1, or (at your option)
  12.  * any later version.
  13.  *
  14.  * This software is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this software; see the file COPYING.  If not, write to
  21.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  22.  */
  23.  
  24. #include "dominion.h"
  25. #include "misc.h"
  26. #include "army.h"
  27.  
  28. #include <stdio.h>
  29.  
  30.   /* how many new move points the haste spall gives you */
  31. #define HASTE_POINTS 8
  32.  
  33. extern Sworld world;
  34. extern Sh_spell *hanging_spells;
  35. extern Suser user;
  36.  
  37.   /* the spell_structures[] array stores the spell names
  38.      together with the function pointers that execute them.
  39.    */
  40. int spell_caltitude(), spell_fertility(), spell_hide_army(),
  41.   spell_fly_army(), spell_vampire_army(), spell_burrow_army(),
  42.   spell_haste_army(), spell_water_walk(),
  43.   spell_mag_bonus(), spell_merge(), spell_cmetal(), spell_cjewels(),
  44.   spell_fireburst(), spell_inferno(), spell_hide_sector(), spell_castle(),
  45.   spell_sacrifice();
  46.  
  47. struct spell_struct {  char name[NAMELEN];  int (*func)(); };
  48.  
  49. static struct spell_struct spell_structures[] = {
  50.   {"caltitude", spell_caltitude}, {"fertility", spell_fertility},
  51.   {"hide_army", spell_hide_army}, {"fly_army", spell_fly_army},
  52.   {"vampire_army", spell_vampire_army}, {"burrow_army", spell_burrow_army},
  53.   {"water_walk", spell_water_walk}, {"haste_army", spell_haste_army},
  54.   {"mag_bonus", spell_mag_bonus}, {"merge", spell_merge},
  55.   {"cmetal", spell_cmetal},
  56.   {"cjewels", spell_cjewels}, {"fireburst", spell_fireburst},
  57.   {"inferno", spell_inferno}, {"hide_sector", spell_hide_sector},
  58.   {"castle", spell_castle,}, {"sacrifice", spell_sacrifice}
  59. };
  60.  
  61.   /* this actually executes a spell */
  62. exec_spell(spellp, w)
  63.      Sspell *spellp;
  64.      WINDOW *w;
  65. {
  66.   int cost = 0, i;
  67.   Sh_spell h_spell;
  68.   struct argument exec_args[N_EXEC_ARGS];
  69.  
  70.   for (i = 0; i < sizeof(spell_structures)/sizeof(struct spell_struct); ++i) {
  71.     if (strcmp(spellp->name, spell_structures[i].name) == 0) {
  72.         /* each spell function returns the cost of casting */
  73.       cost = spell_structures[i].func(&user, w, spellp, &h_spell);
  74.       if (cost > 0) {        /* only if there is a real cost */
  75.     user.np->spell_pts -= cost;
  76.     cspell_pts(user.np, -cost);
  77.       /* add the spell to the list of hanging spells */
  78.     add_h_spell(&user.h_spells, &h_spell);
  79.     add_h_spell(&hanging_spells, &h_spell);
  80.       /* execute the spell */
  81.     for (i = 0; i < h_spell.n_lines; ++i) {
  82.       if (i % 2 == 0) {
  83.         parse_exec_line(h_spell.lines[i], exec_args);
  84.         run_exec_line(user.np, exec_args);
  85.       }
  86.     }
  87.       /* should put this in a more efficient place */
  88.     write_h_spells();
  89.       }
  90.       return cost;        /* we found our spell, now return */
  91.     }
  92.   }
  93.   return cost;
  94. }
  95.  
  96.   /* terraforming spells */
  97. int spell_caltitude(up, w, spellp, h_spellp)
  98.      Suser *up;
  99.      WINDOW *w;
  100.      Sspell *spellp;
  101.      Sh_spell *h_spellp;
  102. {
  103.   Ssector *sp = &world.map[up->cursor.x][up->cursor.y];
  104.   int cost, change = 0;
  105.   char s[EXECLEN];
  106.  
  107.   if (w) {
  108.     mvwprintw(w, 4, 1,
  109.      "Cost %d spell points.  Do you wish to [+]raise or [-]lower sector? ",
  110.      spellp->cost);
  111.     wrefresh(w);
  112.   } else {
  113.     sprintf(s, "Costs %d; [+] or [-]? ", spellp->cost);
  114.     statline(s, "cast_spell");
  115.     move(LINES-1, strlen(s));
  116.   }
  117.   cost =  spellp->cost;
  118.   switch (getch()) {
  119.   case '+':
  120.     change = 1;
  121.     break;
  122.   case '-':
  123.     change = -1;
  124.     break;
  125.   default:
  126.     break;
  127.   }
  128.     /* only apply the spell if the new altitude is good */
  129.   if (sp->altitude+change > MOUNTAIN_PEAK ||  sp->altitude+change < TRENCH) {
  130.     return 0;
  131.   }
  132.     /* prepare the h_spell struct, and then insert the exec lines */
  133.   prepare_h_spell(h_spellp, spellp->name, up->id, spellp->duration, 2);
  134.   sprintf(h_spellp->lines[0], "CALTITUDE_SECTOR:%d:%d:%d\n",
  135.       sp->loc.x, sp->loc.y, change);
  136.   sprintf(h_spellp->lines[1], "CALTITUDE_SECTOR:%d:%d:%d\n",
  137.       sp->loc.x, sp->loc.y, -change);
  138.   return cost;
  139. }
  140.  
  141. int spell_fertility(up, w, spellp, h_spellp)
  142.      Suser *up;
  143.      WINDOW *w;
  144.      Sspell *spellp;
  145.      Sh_spell *h_spellp;
  146. {
  147.   Ssector *sp = &world.map[up->cursor.x][up->cursor.y];
  148.   int cost, change = 0;
  149.   char s[EXECLEN];
  150.  
  151.   if (w) {
  152.     mvwprintw(w, 4, 1,
  153.      "Cost %d spell points.  Do you wish to [+]increase or [-]decrease soil? ",
  154.      spellp->cost);
  155.     wrefresh(w);
  156.   } else {
  157.     sprintf(s, "Costs %d; [+] or [-]? ", spellp->cost);
  158.     statline(s, "cast_spell");
  159.     move(LINES-1, strlen(s));
  160.   }
  161.   cost =  spellp->cost;
  162.   switch (getch()) {
  163.   case '+':
  164.     change = 1;
  165.     break;
  166.   case '-':
  167.     change = -1;
  168.     break;
  169.   default:
  170.     break;
  171.   }
  172.  
  173.     /* prepare the h_spell struct, and then insert the exec lines */
  174.   prepare_h_spell(h_spellp, spellp->name, up->id, spellp->duration, 2);
  175.   sprintf(h_spellp->lines[0], "CSOIL_SECTOR:%d:%d:%d\n",
  176.       sp->loc.x, sp->loc.y, change);
  177.   sprintf(h_spellp->lines[1], "CSOIL_SECTOR:%d:%d:%d\n",
  178.       sp->loc.x, sp->loc.y, -change);
  179.   return cost;
  180. }
  181.  
  182. int spell_cmetal(up, w, spellp, h_spellp)
  183.      Suser *up;
  184.      WINDOW *w;
  185.      Sspell *spellp;
  186.      Sh_spell *h_spellp;
  187. {
  188.   Ssector *sp = &world.map[up->cursor.x][up->cursor.y];
  189.   int cost, change = 0;
  190.   char s[EXECLEN];
  191.  
  192.   if (w) {
  193.     mvwprintw(w, 4, 1,
  194.     "Cost %d spell points.  Do you wish to [+]increase or [-]decrease metal? ",
  195.     spellp->cost);
  196.     wrefresh(w);
  197.   } else {
  198.     sprintf(s, "Costs %d; [+] or [-]? ", spellp->cost);
  199.     statline(s, "cast_spell");
  200.     move(LINES-1, strlen(s));
  201.   }
  202.   cost =  spellp->cost;
  203.   switch (getch()) {
  204.   case '+':
  205.     change = 1;
  206.     break;
  207.   case '-':
  208.     change = -1;
  209.     break;
  210.   default:
  211.     break;
  212.   }
  213.  
  214.     /* prepare the h_spell struct, and then insert the exec lines */
  215.   prepare_h_spell(h_spellp, spellp->name, up->id, spellp->duration, 2);
  216.   sprintf(h_spellp->lines[0], "CMETAL_SECTOR:%d:%d:%d\n",
  217.       sp->loc.x, sp->loc.y, change);
  218.   sprintf(h_spellp->lines[1], "CMETAL_SECTOR:%d:%d:%d\n",
  219.       sp->loc.x, sp->loc.y, -change);
  220.   return cost;
  221. }
  222.  
  223. int spell_cjewels(up, w, spellp, h_spellp)
  224.      Suser *up;
  225.      WINDOW *w;
  226.      Sspell *spellp;
  227.      Sh_spell *h_spellp;
  228. {
  229.   Ssector *sp = &world.map[up->cursor.x][up->cursor.y];
  230.   int cost, change = 0;
  231.   char s[EXECLEN];
  232.  
  233.  
  234.   if (w) {
  235.     mvwprintw(w, 4, 1,
  236.    "Cost %d spell points.  Do you wish to [+]increase or [-]decrease jewels? ",
  237.    spellp->cost);
  238.     wrefresh(w);
  239.   } else {
  240.     sprintf(s, "Costs %d; [+] or [-]? ", spellp->cost);
  241.     statline(s, "cast_spell");
  242.     move(LINES-1, strlen(s));
  243.   }
  244.   cost =  spellp->cost;
  245.   switch (getch()) {
  246.   case '+':
  247.     change = 1;
  248.     break;
  249.   case '-':
  250.     change = -1;
  251.     break;
  252.   default:
  253.     break;
  254.   }
  255.  
  256.     /* prepare the h_spell struct, and then insert the exec lines */
  257.   prepare_h_spell(h_spellp, spellp->name, up->id, spellp->duration, 2);
  258.   sprintf(h_spellp->lines[0], "CJEWELS_SECTOR:%d:%d:%d\n",
  259.       sp->loc.x, sp->loc.y, change);
  260.   sprintf(h_spellp->lines[1], "CJEWELS_SECTOR:%d:%d:%d\n",
  261.       sp->loc.x, sp->loc.y, -change);
  262.   return cost;
  263. }
  264.  
  265.   /* this really messes up a sector */
  266. int spell_fireburst(up, w, spellp, h_spellp)
  267.      Suser *up;
  268.      WINDOW *w;
  269.      Sspell *spellp;
  270.      Sh_spell *h_spellp;
  271. {
  272.   Ssector *sp = &world.map[up->cursor.x][up->cursor.y];
  273.   int cost = 0, change = 0;
  274.   char c;
  275.   char s[EXECLEN];
  276.  
  277.   if (w) {
  278.     mvwprintw(w, 4, 1, "Cost %d spell points.  Go ahead? ", spellp->cost);
  279.     wclrtoeol(w);
  280.     wrefresh(w);
  281.   } else {
  282.     sprintf(s, "Costs %d; go ahead? ", spellp->cost);
  283.     statline_prompt(s, spellp->name);
  284.   }
  285.   if ((c = getch()) == 'y' || c == 'Y') {
  286.       /* prepare the h_spell struct, and then insert the exec lines */
  287.     cost =  spellp->cost;
  288.     prepare_h_spell(h_spellp, spellp->name, up->id, spellp->duration, 6);
  289.     sprintf(h_spellp->lines[0], "CSOIL_SECTOR:%d:%d:%d\n",
  290.         sp->loc.x, sp->loc.y, -sp->soil);
  291.     sprintf(h_spellp->lines[1], "CSOIL_SECTOR:%d:%d:%d\n",
  292.         sp->loc.x, sp->loc.y, sp->soil);
  293.     sprintf(h_spellp->lines[2], "DESIG_SECTOR:%d:%d:%d\n", sp->loc.x,
  294.         sp->loc.y, sp->designation == D_CAPITAL ? D_CAPITAL : D_NODESIG);
  295.     sprintf(h_spellp->lines[3], "DESIG_SECTOR:%d:%d:%d\n",
  296.         sp->loc.x, sp->loc.y, sp->designation);
  297.     sprintf(h_spellp->lines[4], "CPEOPLE_SECTOR:%d:%d:%d\n",
  298.         sp->loc.x, sp->loc.y, -sp->n_people/3);
  299.     sprintf(h_spellp->lines[5], "CPEOPLE_SECTOR:%d:%d:%d\n",
  300.         sp->loc.x, sp->loc.y, sp->n_people/3);
  301.     user.just_moved = 1;
  302.   }
  303.   return cost;
  304. }
  305.   /* makes a sector completely inaccessible */
  306. int spell_inferno(up, w, spellp, h_spellp)
  307.      Suser *up;
  308.      WINDOW *w;
  309.      Sspell *spellp;
  310.      Sh_spell *h_spellp;
  311. {
  312.   Ssector *sp = &world.map[up->cursor.x][up->cursor.y];
  313.   int cost = 0, change = 0;
  314.   char c;
  315.   char s[EXECLEN];
  316.  
  317.     /* you can only cast inferno on your own sectors */
  318.   if (sp->owner != up->id) {
  319.     return -1;
  320.   }
  321.   if (w) {
  322.     mvwprintw(w, 4, 1, "Cost %d spell points.  Go ahead? ", spellp->cost);
  323.     wclrtoeol(w);
  324.     wrefresh(w);
  325.   } else {
  326.     sprintf(s, "Costs %d; go ahead? ", spellp->cost);
  327.     statline_prompt(s, spellp->name);
  328.   }
  329.   if ((c = getch()) == 'y' || c == 'Y') {
  330.       /* prepare the h_spell struct, and then insert the exec lines */
  331.     cost =  spellp->cost;
  332.     prepare_h_spell(h_spellp, spellp->name, up->id, spellp->duration, 4);
  333.     sprintf(h_spellp->lines[2], "DESIG_SECTOR:%d:%d:%d\n", sp->loc.x,
  334.         sp->loc.y, sp->designation == D_CAPITAL ? D_CAPITAL : D_NODESIG);
  335.     sprintf(h_spellp->lines[3], "DESIG_SECTOR:%d:%d:%d\n", sp->loc.x,
  336.         sp->loc.y, sp->designation == D_CAPITAL ? D_CAPITAL : D_NODESIG);
  337.     sprintf(h_spellp->lines[0], "FLAG_SET_SECTOR:%d:%d:%d\n",
  338.         sp->loc.x, sp->loc.y, SF_IMPENETRABLE);
  339.     sprintf(h_spellp->lines[1], "FLAG_CLEAR_SECTOR:%d:%d:%d\n",
  340.       sp->loc.x, sp->loc.y, SF_IMPENETRABLE);
  341.       /* also:  kill all the people, once and permanently */
  342.     cpeople_sector(sp, -sp->n_people);
  343.     sp->n_people = 0;
  344.     user.just_moved = 1;
  345.   }
  346.   return cost;
  347. }
  348.  
  349.   /* these spells set various army flags */
  350. int spell_hide_army(up, w, spellp, h_spellp)
  351.      Suser *up;
  352.      WINDOW *w;
  353.      Sspell *spellp;
  354.      Sh_spell *h_spellp;
  355. {
  356.   int id, cost;            /* army id and cost of casting */
  357.   Sarmy *ap, *get_army();
  358.   char s[EXECLEN];
  359.  
  360.   if (w) {
  361.     mvwprintw(w, 4, 1,
  362.       "Cost: %d spell pts./100 sold.  Which army do you want to hide? ",
  363.       spellp->cost);
  364.     wrefresh(w);
  365.   } else {
  366.     sprintf(s, "Cost %d pts/100 men; which army? ", spellp->cost);
  367.     statline_prompt(s, "fly_army");
  368.   }
  369.   if ( (wget_number(w, &id) <= 0) ||
  370.        ((ap = get_army(up->np, id)) == NULL) ||
  371.        (ap->pos.x != up->cursor.x) || (ap->pos.y != up->cursor.y) ) {
  372.     return -1;
  373.   }
  374.   cost = (spellp->cost * ap->n_soldiers + 99)/100;
  375.   if (cost > up->np->spell_pts) {
  376.     return -1;
  377.   }
  378.   if (w) {
  379.     wmove(w, 4, 1);
  380.     wclrtoeol(w);
  381.   }
  382.     /* prepare the h_spell struct, and then insert the exec lines */
  383.   prepare_h_spell(h_spellp, spellp->name, up->id, spellp->duration, 2);
  384.   sprintf(h_spellp->lines[0], "AFLAG_SET:%d:%d\n",
  385.       ap->id, AF_HIDDEN);
  386.   sprintf(h_spellp->lines[1], "AFLAG_CLEAR:%d:%d\n",
  387.       ap->id, AF_HIDDEN);
  388.   return cost;
  389. }
  390.  
  391. int spell_fly_army(up, w, spellp, h_spellp)
  392.      Suser *up;
  393.      WINDOW *w;
  394.      Sspell *spellp;
  395.      Sh_spell *h_spellp;
  396. {
  397.   int id, cost;            /* army id and cost of casting */
  398.   Sarmy *ap, *get_army();
  399.   char s[EXECLEN];
  400.  
  401.   if (w) {
  402.     mvwprintw(w, 4, 1,
  403.         "Cost: %d spell pts./100 sold.  Which army do you want to fly? ",
  404.         spellp->cost);
  405.     wrefresh(w);
  406.   } else {
  407.     sprintf(s, "Cost %d pts/100 men; which army? ", spellp->cost);
  408.     statline_prompt(s, "hide_army");
  409.   }
  410.   if ( (wget_number(w, &id) <= 0) ||
  411.        ((ap = get_army(up->np, id)) == NULL) ||
  412.        (ap->pos.x != up->cursor.x) || (ap->pos.y != up->cursor.y) ) {
  413.     return -1;
  414.   }
  415.   cost = (spellp->cost * ap->n_soldiers + 99)/100;
  416.   if (cost > up->np->spell_pts) {
  417.     return -1;
  418.   }
  419.   if (w) {
  420.     wmove(w, 4, 1);
  421.     wclrtoeol(w);
  422.   }
  423.     /* prepare the h_spell struct, and then insert the exec lines */
  424.   prepare_h_spell(h_spellp, spellp->name, up->id, spellp->duration, 2);
  425.   sprintf(h_spellp->lines[0], "AFLAG_SET:%d:%d\n",
  426.       ap->id, AF_FLIGHT);
  427.   sprintf(h_spellp->lines[1], "AFLAG_CLEAR:%d:%d\n",
  428.       ap->id, AF_FLIGHT);
  429.   return cost;
  430. }
  431.  
  432. int spell_vampire_army(up, w, spellp, h_spellp)
  433.      Suser *up;
  434.      WINDOW *w;
  435.      Sspell *spellp;
  436.      Sh_spell *h_spellp;
  437. {
  438.   int id, cost;            /* army id and cost of casting */
  439.   Sarmy *ap, *get_army();
  440.   char s[EXECLEN];
  441.  
  442.   if (w) {
  443.     mvwprintw(w, 4, 1,
  444.       "Cost: %d spell pts./100 sold.  Which army do you want to vampirize? ",
  445.        spellp->cost);
  446.     wrefresh(w);
  447.   } else {
  448.     sprintf(s, "Cost %d pts/100 men; which army? ", spellp->cost);
  449.     statline_prompt(s, "vampire_army");
  450.   }
  451.   if ( (wget_number(w, &id) <= 0) ||
  452.        ((ap = get_army(up->np, id)) == NULL) ) {
  453.     return -1;
  454.   }
  455.   cost = (spellp->cost * ap->n_soldiers + 99)/100;
  456.   if (w) {
  457.     wmove(w, 4, 1);
  458.     wclrtoeol(w);
  459.   }
  460.     /* prepare the h_spell struct, and then insert the exec lines */
  461.   prepare_h_spell(h_spellp, spellp->name, up->id, spellp->duration, 2);
  462.   sprintf(h_spellp->lines[0], "AFLAG_SET:%d:%d\n",
  463.       ap->id, AF_VAMPIRE);
  464.   sprintf(h_spellp->lines[1], "AFLAG_CLEAR:%d:%d\n",
  465.       ap->id, AF_VAMPIRE);
  466.   return cost;
  467. }
  468. int spell_burrow_army(up, w, spellp, h_spellp)
  469.      Suser *up;
  470.      WINDOW *w;
  471.      Sspell *spellp;
  472.      Sh_spell *h_spellp;
  473. {
  474.   int id, cost;            /* army id and cost of casting */
  475.   Sarmy *ap, *get_army();
  476.   char s[EXECLEN];
  477.  
  478.   if (w) {
  479.     mvwprintw(w, 4, 1,
  480.       "Cost: %d spell pts./100 sold.  Which army do you want to send underground? ",
  481.        spellp->cost);
  482.     wrefresh(w);
  483.   } else {
  484.     sprintf(s, "Cost %d pts/100 men; which army? ", spellp->cost);
  485.     statline_prompt(s, "burrow_army");
  486.   }
  487.   if ( (wget_number(w, &id) <= 0) ||
  488.        ((ap = get_army(up->np, id)) == NULL) ) {
  489.     return -1;
  490.   }
  491.   cost = (spellp->cost * ap->n_soldiers + 99)/100;
  492.   if (w) {
  493.     wmove(w, 4, 1);
  494.     wclrtoeol(w);
  495.   }
  496.     /* prepare the h_spell struct, and then insert the exec lines */
  497.   prepare_h_spell(h_spellp, spellp->name, up->id, spellp->duration, 2);
  498.   sprintf(h_spellp->lines[0], "AFLAG_SET:%d:%d\n",
  499.       ap->id, AF_UNDERGROUND);
  500.   sprintf(h_spellp->lines[1], "AFLAG_CLEAR:%d:%d\n",
  501.       ap->id, AF_UNDERGROUND);
  502.   return cost;
  503. }
  504.  
  505. int spell_water_walk(up, w, spellp, h_spellp)
  506.      Suser *up;
  507.      WINDOW *w;
  508.      Sspell *spellp;
  509.      Sh_spell *h_spellp;
  510. {
  511.   int id, cost;            /* army id and cost of casting */
  512.   Sarmy *ap, *get_army();
  513.   char s[EXECLEN];
  514.  
  515.   if (w) {
  516.     mvwprintw(w, 4, 1,
  517.     "Cost: %d spell pts./100 sold.  Which army do you want to walk on water? ",
  518.        spellp->cost);
  519.     wrefresh(w);
  520.   } else {
  521.     sprintf(s, "Cost %d pts/100 men; which army? ", spellp->cost);
  522.     statline_prompt(s, "walk_water");
  523.   }
  524.   if ( (wget_number(w, &id) <= 0) ||
  525.        ((ap = get_army(up->np, id)) == NULL) ||
  526.        (ap->pos.x != up->cursor.x) || (ap->pos.y != up->cursor.y) ) {
  527.     return -1;
  528.   }
  529.   cost = (spellp->cost * ap->n_soldiers + 99)/100;
  530.   if (cost > up->np->spell_pts) {
  531.     return -1;
  532.   }
  533.   if (w) {
  534.     wmove(w, 4, 1);
  535.     wclrtoeol(w);
  536.   }
  537.     /* prepare the h_spell struct, and then insert the exec lines */
  538.   prepare_h_spell(h_spellp, spellp->name, up->id, spellp->duration, 2);
  539.   sprintf(h_spellp->lines[0], "AFLAG_SET:%d:%d\n",
  540.       ap->id, AF_WATER);
  541.   sprintf(h_spellp->lines[1], "AFLAG_CLEAR:%d:%d\n",
  542.       ap->id, AF_WATER);
  543.   return cost;
  544. }
  545.  
  546. int spell_haste_army(up, w, spellp, h_spellp)
  547.      Suser *up;
  548.      WINDOW *w;
  549.      Sspell *spellp;
  550.      Sh_spell *h_spellp;
  551. {
  552.   int id, cost;            /* army id and cost of casting */
  553.   Sarmy *ap, *get_army();
  554.   char s[EXECLEN];
  555.  
  556.   if (w) {
  557.     mvwprintw(w, 4, 1,
  558.       "Cost: %d spell pts./100 sold.  Which army do you want to hasten? ",
  559.        spellp->cost);
  560.     wrefresh(w);
  561.   } else {
  562.     sprintf(s, "Cost %d pts/100 men; which army? ", spellp->cost);
  563.     statline_prompt(s, "haste_army");
  564.   }
  565.   if ( (wget_number(w, &id) <= 0) ||
  566.        ((ap = get_army(up->np, id)) == NULL) ) {
  567.     return -1;
  568.   }
  569.   cost = (spellp->cost * ap->n_soldiers + 99)/100;
  570.   if (w) {
  571.     wmove(w, 4, 1);
  572.     wclrtoeol(w);
  573.   }
  574.     /* prepare the h_spell struct, and then insert the exec lines */
  575.   prepare_h_spell(h_spellp, spellp->name, up->id, spellp->duration, 0);
  576. /*  sprintf(h_spellp->lines[0], "AFLAG_SET:%d:%d\n",
  577.       ap->id, AF_VAMPIRE);
  578.   sprintf(h_spellp->lines[1], "AFLAG_CLEAR:%d:%d\n",
  579.       ap->id, AF_VAMPIRE);
  580. */
  581.   ap->mvpts += HASTE_POINTS;    /* increase movement */
  582.     /* make the exec line for this move point change; we
  583.        implement it as a trivial movement with change in move points.
  584.      */
  585.   sprintf(s, "AMOVE:%d:%d:%d:%d\n",
  586.       ap->id, ap->pos.x, ap->pos.y, ap->mvpts);
  587.   gen_exec(s);
  588.   return cost;
  589. }
  590.  
  591. int spell_mag_bonus(up, w, spellp, h_spellp)
  592.      Suser *up;
  593.      WINDOW *w;
  594.      Sspell *spellp;
  595.      Sh_spell *h_spellp;
  596. {
  597.   int id, cost;            /* army id and cost of casting */
  598.   Sarmy *ap, *get_army();
  599.   char s[EXECLEN];
  600.  
  601.   if (w) {
  602.     mvwprintw(w, 4, 1,
  603.        "Cost: %d spell pts./100 sold.  Which army do you want to enhance? ",
  604.        spellp->cost);
  605.     wrefresh(w);
  606.   } else {
  607.     sprintf(s, "Cost %d pts/100 men; which army? ", spellp->cost);
  608.     statline_prompt(s, "mag_bonus");
  609.   }
  610.   if ( (wget_number(w, &id) <= 0) ||
  611.        ((ap = get_army(up->np, id)) == NULL) ||
  612.        (ap->pos.x != up->cursor.x) || (ap->pos.y != up->cursor.y) ) {
  613.     return -1;
  614.   }
  615.   cost = (spellp->cost * ap->n_soldiers + 99)/100;
  616.   if (cost > up->np->spell_pts) {
  617.     return -1;
  618.   }
  619.   if (w) {
  620.     wmove(w, 4, 1);
  621.     wclrtoeol(w);
  622.   }
  623.     /* prepare the h_spell struct, and then insert the exec lines */
  624.   prepare_h_spell(h_spellp, spellp->name, up->id, spellp->duration, 2);
  625.   sprintf(h_spellp->lines[0], "CABONUS:%d:%d\n", ap->id, 30);
  626.   sprintf(h_spellp->lines[1], "CABONUS:%d:%d\n", ap->id, -30);
  627.   return cost;
  628. }
  629.  
  630.   /* this is a Unity spell which merges people into
  631.      an existing spirit.  you can only make the spirit
  632.      as big as twice its basic size.  the people
  633.      are taken from the current sector.  this is permanent,
  634.      it is not a hanging spell.  In fact, it is more of
  635.      an ability than a spell.
  636.    */
  637. int spell_merge(up, w, spellp, h_spellp)
  638.      Suser *up;
  639.      WINDOW *w;
  640.      Sspell *spellp;
  641.      Sh_spell *h_spellp;
  642. {
  643.   int id, cost, ind;        /* army id, cost of casting and spirit index */
  644.   extern struct spirit_type *spirit_types;
  645.   Sarmy *ap, *get_army();
  646.   char s[EXECLEN];
  647.   int n_merged = 0;        /* number of people merged */
  648.   Ssector *sp = &world.map[up->cursor.x][up->cursor.y];
  649.  
  650.   if (w) {
  651.     mvwprintw(w, 4, 1,
  652.        "Cost: %d spell pts./100 sold.  Which spirit do you want to enhance? ",
  653.        spellp->cost);
  654.     wrefresh(w);
  655.   } else {
  656.     sprintf(s, "Cost %d pts/100 men; which spirit? ", spellp->cost);
  657.     statline_prompt(s, "merge");
  658.   }
  659.   if ( (wget_number(w, &id) <= 0)
  660.       || ((ap = get_army(up->np, id)) == NULL)
  661.       || (ap->pos.x != up->cursor.x) || (ap->pos.y != up->cursor.y)
  662.       || !is_spirit(ap) ) {
  663.     return -1;
  664.   }
  665.   if (has_hostile(sp) || sp->owner != user.id) {
  666.     statline2_err ("hit space", "cannot merge on a hostile sector");
  667.     return -1;
  668.   }
  669.   if (is_spelled(ap)) {
  670.     statline2_err ("hit space", "cannot merge on a spelled army");
  671.     return -1;
  672.   }
  673.   ind = spirit_type_index(ap->type);
  674.   if (w) {
  675.     mvwprintw(w, 4, 1,
  676.           "How many men do you want to merge (or subtract) (max %d)? ",
  677.           2*spirit_types[ind].size - ap->n_soldiers);
  678.     wclrtoeol(w);
  679.     wrefresh(w);
  680.   } else {
  681.     sprintf(s, "Merge how many (max %d)? ",
  682.         2*spirit_types[ind].size - ap->n_soldiers);
  683.     statline_prompt(s, "merge");
  684.   }
  685.     /* make sure that the spirit will not become too big or too small */
  686.   if ( (wget_number(w, &n_merged) <= 0)
  687.       || (n_merged > 0 && n_merged > 2*spirit_types[ind].size - ap->n_soldiers)
  688.       || n_merged < -ap->n_soldiers+1 || n_merged > sp->n_people) {
  689.     return -1;
  690.   }
  691.   cost = (spellp->cost * ap->n_soldiers + 99)/100; /* rounding up */
  692.   if (cost > 0 && cost > up->np->spell_pts) {
  693.     return -1;
  694.   }
  695.   if (w) {
  696.     wmove(w, 4, 1);
  697.     wclrtoeol(w);
  698.   }
  699.     /* this is not a hanging spell.  we just do the work once. */
  700.   ap->n_soldiers += n_merged;
  701.   ap->mvpts = 0;
  702.   ap->mvratio = 0;
  703.   sprintf(s, "AINCREASE:%d:%d\n", ap->id, n_merged);
  704.   gen_exec(s);
  705.   sp->n_people -= n_merged;
  706.   cpeople_sector(sp, -n_merged);
  707.   user.just_moved = 1;
  708.   return -1;
  709. }
  710.  
  711.   /* hide a sector from view */
  712. int spell_hide_sector(up, w, spellp, h_spellp)
  713.      Suser *up;
  714.      WINDOW *w;
  715.      Sspell *spellp;
  716.      Sh_spell *h_spellp;
  717. {
  718.   Ssector *sp = &world.map[up->cursor.x][up->cursor.y];
  719.   int cost;
  720.   char s[EXECLEN];
  721.  
  722.   if (w) {
  723.     mvwprintw(w, 4, 1,
  724.     "Cost %d spell points.  Go ahead (y/n)? ",
  725.     spellp->cost);
  726.     wrefresh(w);
  727.   } else {
  728.     sprintf(s, "Costs %d; go ahead (y/n)? ", spellp->cost);
  729.     statline_prompt(s, "hide_sector");
  730.   }
  731.   cost =  spellp->cost;
  732.   switch (getch()) {
  733.   case 'y':
  734.   case 'Y':
  735.     break;
  736.   default:
  737.     return -1;
  738.   }
  739.  
  740.   /* prepare the h_spell struct, and then insert the exec lines */
  741.   prepare_h_spell(h_spellp, spellp->name, up->id, spellp->duration, 2);
  742.   sprintf(h_spellp->lines[0], "FLAG_SET_SECTOR:%d:%d:%d\n",
  743.       sp->loc.x, sp->loc.y, SF_HIDDEN);
  744.   sprintf(h_spellp->lines[1], "FLAG_CLEAR_SECTOR:%d:%d:%d\n",
  745.       sp->loc.x, sp->loc.y, SF_HIDDEN);
  746.   user.just_moved = 1;
  747.   return cost;
  748. }
  749.  
  750.   /* these are used to set and clear army flags (in the exec file) */
  751. aflag_set(ap, flag)
  752.      Sarmy *ap;
  753.      int flag;
  754. {
  755.   char s[EXECLEN];
  756.  
  757.   sprintf(s, "AFLAG_SET:%d:%d\n", ap->id, flag);
  758.   gen_exec(s);
  759. }
  760.  
  761. aflag_clear(ap, flag)
  762.      Sarmy *ap;
  763.      int flag;
  764. {
  765.   char s[EXECLEN];
  766.  
  767.   sprintf(s, "AFLAG_CLEAR:%d:%d\n", ap->id, flag);
  768.   gen_exec(s);
  769. }
  770.  
  771. /* For chess; transfers the spirit to the nations capital  */
  772. spell_castle (up, w, spellp, h_spellp)
  773.      Suser * up;
  774.      WINDOW * w;
  775.      Sspell * spellp;
  776.      Sh_spell * h_spellp;
  777. {
  778.   Ssector * sp; 
  779.   Ssector * capital = &world.map [up->np->capital.x][up->np->capital.y];
  780.   Ssector * cur = &world.map [up->cursor.x][up->cursor.y];
  781.   Sarmy * ap;
  782.   char s [EXECLEN];
  783.   int army_num;
  784.  
  785.   if (w) {
  786.     mvwprintw (w, 4, 1,
  787.            "Costs %d spell points.  Go ahead (y/n)? ", spellp->cost);
  788.     wrefresh (w);
  789.   } else {
  790.     sprintf (s, "Costs %d; go ahead (y/n)? ", spellp->cost);
  791.     statline (s, "castle");
  792.   }
  793.     
  794.   switch (getch ()) {
  795.   case 'y':
  796.   case 'Y':
  797.     break;
  798.   default:
  799.     return -1;
  800.   }
  801.  
  802.   sprintf (s, "Castle army #");
  803.   if (w) {
  804.     wmove (w, 4,1);
  805.     wclrtoeol (w);
  806.     box (w, '|', '-');
  807.     mvwprintw (w, 4, 1, s);
  808.   }
  809.   else {
  810.     statline (s, "castle");
  811.     move (LINES-1, strlen (s));
  812.     refresh ();
  813.   }
  814.   if (wget_number (w, &army_num) <= 0) {
  815.     return -1;
  816.   }
  817.   if ((ap = get_army (up->np, army_num)) == NULL) {
  818.     return -1;
  819.   }
  820.       
  821.   if (ap->pos.x != up->cursor.x || ap->pos.y != up->cursor.y) {
  822.     statline2_err ("Hit space", "Must be on the same sector as army");
  823.     return 0;
  824.   }
  825.  
  826.   sp = &world.map[ap->pos.x][ap->pos.y];
  827.  
  828.   delete_army_sector (sp, ap);
  829.  
  830.   ap->pos.x = capital->loc.x;
  831.   ap->pos.y = capital->loc.y;
  832.   
  833.   insert_army_sector (capital, ap);
  834.  
  835.   sprintf (s, "ACASTLE:%d\n", ap->id);
  836.   gen_exec (s);
  837.  
  838.   cspell_pts (up->np, spellp->cost);
  839.   up->np->spell_pts -= spellp->cost;
  840.   return -1;
  841. }
  842.  
  843. int spell_sacrifice(up, w, spellp, h_spellp)
  844.      Suser * up;
  845.      WINDOW * w;
  846.      Sspell * spellp;
  847.      Sh_spell * h_spellp;
  848. {
  849.   char s [EXECLEN];
  850.   Ssector * sp = &world.map [up->cursor.x][up->cursor.y];
  851.   int num;
  852.  
  853.   sprintf (s, "Sacrifice how many people (%d people per sp. point)? ",
  854.        SACRIFICED_FRACT);
  855.  
  856.   statline_prompt(s, "sacrifice");
  857.   if (wget_number(stdscr, &num) <= 0) {
  858.     return 0;
  859.   }
  860.   if (sp->owner != up->np->id) {
  861.     statline2_err ("hit space", "sorry, must sacrifice your own people");
  862.     return 0;
  863.   } else if (has_hostile (sp)) {
  864.     statline2_err ("hit space", "sorry, must sacrifice friendly people");
  865.     return 0;
  866.   } else if (sp->n_people < num) {
  867.     statline2_err ("hit space", "too many!");
  868.     return 0;
  869.   } else if (num < 0) {
  870.     statline2_err ("hit space", "nice try");
  871.     return 0;
  872.   }
  873.  
  874.   cpeople_sector (sp, -num);
  875.   cspell_pts (up->np, (int)(num / SACRIFICED_FRACT));
  876.   sp->n_people -= num;
  877.   up->np->spell_pts += (int) (num / SACRIFICED_FRACT);
  878.   up->just_moved = 1;
  879.  
  880.   return 0;
  881. }
  882.