home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / games / volume12 / mdg / part03 / players.c < prev   
C/C++ Source or Header  |  1991-03-04  |  8KB  |  382 lines
  1. /*
  2.     MDG Multiuser Dungeon Game -- players.c player code
  3.     
  4.     MDG is Copyright 1990 John C. Gonnerman
  5.     This program is subject to the general MDG 
  6.     copyright statement (see enclosed file, Copyright).
  7. */
  8.  
  9. static char *sccsvers = "@(#) players.c\t(1.5)\tcreated 1/3/91";
  10.  
  11. #include <stdio.h>
  12. #include <ctype.h>
  13. #include <string.h>
  14. #include <sys/types.h>
  15. #include <time.h>
  16. #include "setup.h"
  17. #include "files.h"
  18. #include "struct.h"
  19.  
  20. extern char *progname;
  21.  
  22. extern int errno;
  23. extern char *sys_errlist[];
  24.  
  25. extern struct player_seg *pseg;
  26. extern struct map_seg *mseg;
  27.  
  28. extern int player_size;
  29.  
  30. extern int memory[];
  31.  
  32.  
  33. saveplayer(indx)
  34. int indx;
  35. {
  36.     char fname[128];
  37.     FILE *fp;
  38.     int i;
  39.     time_t time();
  40.  
  41.     if(pseg->p[indx].playernum == -1) /* no such player */
  42.         return;
  43.  
  44.     if(pseg->p[indx].loc.sector == LOC_NONESUCH 
  45.     && pseg->p[indx].lives < 0) {    /* he died */
  46.         pseg->p[indx].playernum = -1;
  47.         pseg->player_sem++;
  48.         return;
  49.     }
  50.  
  51.     sprintf(fname, "%s/pl%05d", PLAYERDIR, pseg->p[indx].playernum);
  52.  
  53.     /* mark player's items as old */
  54.  
  55.     for(i = 0; i < pseg->item_count; i++)
  56.         if(pseg->itm[i].loc.sector == LOC_PLAYER
  57.         && pseg->itm[i].loc.x == pseg->p[indx].playernum)
  58.             pseg->itm[i].loc.y = ITEM_OLD;
  59.  
  60.     /* save player's file */
  61.  
  62.     if((fp = fopen(fname, "w")) == NULL)
  63.         return;
  64.         
  65.     fprintf(fp, "%s\n", pseg->p[indx].name);
  66.     fprintf(fp, "%ld\n", pseg->p[indx].gold);
  67.  
  68.     for(i = 0; i < 26; i++) {
  69.         fprintf(fp, "%hd ", pseg->p[indx].spells[i]);
  70.         if(((i + 1) % 13) == 0)
  71.             putc('\n', fp);
  72.     }
  73.  
  74.     fprintf(fp, "%hd:%hd\n", pseg->p[indx].max_hp, 
  75.         pseg->p[indx].hitpoints);
  76.  
  77.     fprintf(fp, "%hd:%hd\n", pseg->p[indx].max_mp, 
  78.         pseg->p[indx].magicpts);
  79.  
  80.     fprintf(fp, "%hd\n", pseg->p[indx].fighting);
  81.  
  82.     fprintf(fp, "[%d/%d]\n", pseg->p[indx].loc.x, pseg->p[indx].home);
  83.  
  84.     fprintf(fp, "%d\n", pseg->p[indx].lives);
  85.  
  86.     fprintf(fp, "%ld\n", time(NULL) - DATE_OFFSET);
  87.  
  88.     fprintf(fp, "%hd\n", pseg->p[indx].createpts);
  89.  
  90.     fprintf(fp, "al = %hd\n", pseg->p[indx].alignment);
  91.  
  92.     fclose(fp);
  93.  
  94.     pseg->p[indx].playernum = -1;
  95.  
  96.     pseg->player_sem++;
  97. }
  98.  
  99.  
  100. dmsg_all(msg)
  101. char *msg;
  102. {
  103.     int i;
  104.  
  105.     for(i = 0; i < MAX_PLAYERS; i++)
  106.         if(pseg->p[i].playernum >= 0)
  107.             dmsg_add(i, msg);
  108. }
  109.  
  110.  
  111. int loadplayer(indx, playernum)
  112. int indx, playernum;
  113. {
  114.     char fname[128], altfname[128], profname[128], *p;
  115.     char tmpname[PNAMELEN];
  116.     long time_out, time_old, time_diff;
  117.     time_t time();
  118.     FILE *fp;
  119.     int i, startsect;
  120.  
  121.     sprintf(fname, "%s/pl%05d", PLAYERDIR, playernum);
  122.     sprintf(altfname, "%s/default", PLAYERDIR);
  123.     sprintf(profname, "%s/pr%05d", PLAYERDIR, playernum);
  124.  
  125.     pseg->weapon[indx] = -1;
  126.     pseg->armor[indx] = -1;
  127.     pseg->shield[indx] = -1;
  128.     pseg->p[indx].dmsg[0][0] = '\0';
  129.     pseg->p[indx].dmsg[1][0] = '\0';
  130.     pseg->p[indx].dmsg_loc = -1;
  131.     pseg->p[indx].brief = 0;
  132.     pseg->p[indx].clock = 0;
  133.     pseg->p[indx].detect = 0;
  134.     pseg->p[indx].light = 0;
  135.     pseg->p[indx].blocked = 0;
  136.     pseg->p[indx].invis = 0;
  137.     pseg->p[indx].knight = 0;
  138.     pseg->p[indx].user_spell = 0;
  139.     pseg->p[indx].gold_hidden = 0;
  140.     pseg->p[indx].ma_count = 0;
  141.     pseg->p[indx].m_armor = 0;
  142.     pseg->p[indx].createpts = 0;
  143.  
  144.     memory[indx] = LOC_NONESUCH;
  145.  
  146.     if((fp = fopen(profname, "r")) == NULL)
  147.         pseg->p[indx].name[0] = '\0';
  148.     else {
  149.         fgets(pseg->p[indx].name, 20, fp);
  150.         fclose(fp);
  151.     }
  152.  
  153.     if((fp = fopen(fname, "r")) == NULL 
  154.     && (fp = fopen(altfname, "r")) == NULL)
  155.         return;
  156.  
  157.     fgets(tmpname, 20, fp);
  158.  
  159.     if(pseg->p[indx].name[0] == '\0')
  160.         strcpy(pseg->p[indx].name, tmpname);
  161.  
  162.     for(p = pseg->p[indx].name; *p; p++)
  163.         if(*p == '\n')
  164.             *p = '\0';
  165.  
  166.     if(pseg->p[indx].name[0] == '\0')
  167.         get_handle(pseg->p[indx].name, playernum);
  168.  
  169.     fscanf(fp, "%ld\n", &(pseg->p[indx].gold));
  170.  
  171.     for(i = 0; i < 26; i++)
  172.         fscanf(fp, "%hd", &(pseg->p[indx].spells[i]));
  173.  
  174.     fscanf(fp, "%hd:%hd\n", &(pseg->p[indx].max_hp),
  175.         &(pseg->p[indx].hitpoints));
  176.  
  177.     fscanf(fp, "%hd:%hd\n", &(pseg->p[indx].max_mp),
  178.         &(pseg->p[indx].magicpts));
  179.  
  180.     fscanf(fp, "%hd\n", &(pseg->p[indx].fighting));
  181.  
  182.     fscanf(fp, "[%d/%d]\n", &startsect, &(pseg->p[indx].home));
  183.  
  184.     fscanf(fp, "%d\n", &(pseg->p[indx].lives));
  185.  
  186.     fscanf(fp, "%ld\n", &time_old);
  187.  
  188.     fscanf(fp, "%hd\n", &(pseg->p[indx].createpts));
  189.  
  190.     fscanf(fp, "al = %hd\n", &(pseg->p[indx].alignment));
  191.  
  192.     fclose(fp);
  193.  
  194.     for(i = 0; i < MAX_PLAYERS; i++)
  195.         pseg->p[indx].partners[i] = pseg->p[indx].alignment;
  196.  
  197.     time_diff = (time(NULL) - DATE_OFFSET) - time_old;
  198.  
  199.     if(time_diff > 600)
  200.         time_diff = 600;
  201.  
  202.     time_out = time_diff / TIME_TO_HEAL;
  203.  
  204.     while(time_out--)
  205.         heal_a_player(indx);
  206.  
  207.     if(startsect < 0 || startsect >= mseg->max_areas)
  208.         startsect = 0;
  209.  
  210.     if(place(indx, startsect) == -1
  211.     && place(indx, 0) == -1)
  212.         return;
  213.  
  214.     pseg->p[indx].prev_sect = startsect;
  215.  
  216.     pseg->p[indx].playernum = playernum;
  217.  
  218.     for(i = 0; i < PMAX_ITEMS; i++)
  219.         pseg->p[indx].items[i] = -1;
  220.  
  221.     for(i = 0; i < pseg->item_count; i++)
  222.         if(pseg->itm[i].loc.sector == LOC_PLAYER
  223.         && pseg->itm[i].loc.x == pseg->p[indx].playernum) {
  224.             insert_item(indx, i);
  225.             freshen_item(i);
  226.         }
  227.  
  228.     move_sym(&(pseg->p[indx].loc), 1 + indx);
  229.  
  230.     pseg->player_sem++;
  231. }
  232.  
  233.  
  234. place(p_indx, startsect)
  235. int p_indx, startsect;
  236. {
  237.     int rc, x, y;
  238.  
  239.     for(x = MAPCOLS / 3; x < (2 * (MAPCOLS / 3)); x++)
  240.     for(y = MAPROWS / 3; y < 2 * (MAPROWS / 3); y++) {
  241.         if(try_spot(p_indx, startsect, x, y) == 0)
  242.             return 0;
  243.     }
  244.  
  245.     return -1;
  246. }
  247.  
  248.  
  249. int try_spot(p_indx, startsect, x, y)
  250. int p_indx, startsect, x, y;
  251. {
  252.     if(isdigit(mseg->m[startsect].map[y][x]))
  253.         return -1;
  254.  
  255.     if(mseg->m[startsect].map[y][x] == '~'
  256.     || mseg->m[startsect].map[y][x] == '%'
  257.     || mseg->m[startsect].map[y][x] == '^')
  258.         return -1;
  259.  
  260.     if(move_to(&(pseg->p[p_indx].loc), startsect, x, y, p_indx) == 0)
  261.         return 0;
  262.  
  263.     return -1;
  264. }
  265.  
  266.  
  267. abortplayer(indx)
  268. int indx;
  269. {
  270.     int sector, x, y, under;
  271.  
  272.     sector = pseg->p[indx].loc.sector;
  273.     x = pseg->p[indx].loc.x;
  274.     y = pseg->p[indx].loc.y;
  275.     under = pseg->p[indx].loc.under;
  276.  
  277.     if(sector < 0)
  278.         return;
  279.  
  280.     mseg->m[sector].map[y][x] = under;
  281.  
  282.     drop_new(indx, sector, x, y);
  283.  
  284.     pseg->p[indx].playernum = -1;
  285.  
  286.     pseg->player_sem++;
  287.  
  288.     mseg->map_sem++;
  289.  
  290.     notify(sector);
  291. }
  292.  
  293.  
  294. drop_new(p_indx, sector, x, y)
  295. int p_indx, sector, x, y;
  296. {
  297.     int i, playernum;
  298.  
  299.     playernum = pseg->p[p_indx].playernum;
  300.  
  301.     for(i = 0; i < pseg->item_count; i++)
  302.         if(pseg->itm[i].loc.sector == LOC_PLAYER
  303.         && pseg->itm[i].loc.x == playernum
  304.         && pseg->itm[i].loc.y == ITEM_NEW)
  305.             if(put_item(i, sector, x, y) == -1)
  306.                 pseg->itm[i].loc.sector = LOC_NONESUCH;
  307.  
  308.     notify(sector);
  309. }
  310.  
  311.  
  312. del_player(p_indx)
  313. int p_indx;
  314. {
  315.     char fname[128];
  316.     int temp_x;
  317.  
  318.     pseg->p[p_indx].lives--;
  319.  
  320.     if(pseg->p[p_indx].lives >= 0) {
  321.         pseg->p[p_indx].hitpoints = 1;
  322.         temp_x = pseg->p[p_indx].loc.x;
  323.         pseg->p[p_indx].loc.x = 0;
  324.         pseg->p[p_indx].gold = 0;
  325.         pseg->player_sem++;
  326.         saveplayer(p_indx);
  327.         pseg->p[p_indx].loc.x = temp_x;
  328.         pseg->p[p_indx].hitpoints = 0;
  329.         pseg->player_sem++;
  330.         tell_player(p_indx);
  331.     } else {
  332.         sprintf(fname, "%s/pl%05d", PLAYERDIR, 
  333.             pseg->p[p_indx].playernum);
  334.         unlink(fname);
  335.     }
  336. }
  337.  
  338.  
  339. heal_players()
  340. {
  341.     int indx;
  342.  
  343.     for(indx = 0; indx < MAX_PLAYERS; indx++) {
  344.         if(pseg->p[indx].playernum >= 0 
  345.         && pseg->p[indx].loc.sector >= 0
  346.         && ++pseg->p[indx].clock > TIME_TO_HEAL) 
  347.             heal_a_player(indx);
  348.         if(pseg->p[indx].playernum >= 0
  349.         && (pseg->p[indx].loc.sector == LOC_NONESUCH
  350.         || pseg->p[indx].loc.sector == LOC_HOME)) {
  351.             pseg->player_sem++;
  352.             tell_player(indx);
  353.         }
  354.     }
  355. }
  356.  
  357.  
  358. heal_a_player(indx)
  359. int indx;
  360. {
  361.     pseg->p[indx].clock = 0;
  362.  
  363.     if(pseg->p[indx].hitpoints < pseg->p[indx].max_hp) {
  364.         pseg->p[indx].hitpoints += 
  365.             rnd(pseg->p[indx].max_hp / HEAL_DIV);
  366.         if(pseg->p[indx].hitpoints > pseg->p[indx].max_hp)
  367.             pseg->p[indx].hitpoints = pseg->p[indx].max_hp;
  368.         pseg->player_sem++;
  369.     } 
  370.     
  371.     if(pseg->p[indx].hitpoints > MIN_HPS
  372.     && pseg->p[indx].magicpts < pseg->p[indx].max_mp) {
  373.         pseg->p[indx].magicpts += CHARGE_INC;
  374.         pseg->player_sem++;
  375.     }
  376.  
  377.     tell_player(indx);
  378. }
  379.  
  380.  
  381. /* end of file. */
  382.