LCOV - code coverage report
Current view: top level - omega-rpg-0.90-pa9 - city.c (source / functions) Hit Total Coverage
Test: lcov.info Lines: 414 467 88.7 %
Date: 2017-08-31 19:31:11 Functions: 7 9 77.8 %
Branches: 122 146 83.6 %

           Branch data     Line data    Source code
       1                 :            : /* omega copyright (C) by Laurence Raphael Brothers, 1987,1988,1989 */
       2                 :            : /* city.c */
       3                 :            : /* some functions to make the city level */
       4                 :            : 
       5                 :            : #include "glob.h"
       6                 :            : 
       7                 :            : 
       8                 :            : void mazesite( char,int,int,int );
       9                 :            : extern int WIDTH, LENGTH;
      10                 :            : void randommazesite( int,int,int );
      11                 :            : 
      12                 :            : /* loads the city level */
      13                 :          9 : void load_city(int populate)
      14                 :            : {
      15                 :            :   int i,j;
      16                 :            :   pml ml;
      17                 :            :   char site;
      18                 :            :   map *city;
      19                 :            :   map *maze;
      20                 :            :   
      21                 :          9 :   initrand(E_CITY, 0);
      22                 :            :   
      23                 :            :   /* Get the hedge maze (which is in the city). */
      24                 :          9 :   maze = map_open(MAP_hedges);
      25                 :            :   /* Choose a random level from it. */
      26                 :          9 :   map_setLevel(maze, random_range(map_getDepth(maze)));
      27                 :            :   
      28                 :            :   /* Get the city. */
      29                 :          9 :   city = map_open(MAP_city);
      30                 :          9 :   map_setLevel(city,0);
      31                 :            :   
      32                 :          9 :   TempLevel = Level;
      33         [ -  + ]:          9 :   if (ok_to_free(TempLevel)) {
      34                 :            : #ifndef SAVE_LEVELS
      35                 :          0 :     free_level(TempLevel);
      36                 :            : #endif
      37                 :          0 :     TempLevel = NULL;
      38                 :            :   }
      39                 :            : #ifndef SAVE_LEVELS
      40                 :          9 :   Level = ((plv) checkmalloc(sizeof(levtype)));
      41                 :            : #else
      42                 :            :   msdos_changelevel(TempLevel,0,-1);
      43                 :            :   Level = &TheLevel;
      44                 :            : #endif
      45                 :          9 :   clear_level(Level);
      46                 :          9 :   Level->depth = 0;
      47                 :          9 :   Level->environment = E_CITY;
      48                 :            :   
      49                 :            :   /* WDT: Rampart, as a special case, has its width stored in a
      50                 :            :    * global variable. */
      51                 :          9 :   WIDTH = Level->level_width = map_getWidth(city);
      52                 :          9 :   LENGTH = Level->level_length = map_getLength(city);
      53                 :            :   
      54         [ +  + ]:        585 :   for(j=0;j<Level->level_length;j++) {
      55         [ +  + ]:      37440 :     for(i=0;i<Level->level_width;i++) {
      56                 :      36864 :       lset(i,j,SEEN);
      57                 :      36864 :       site = map_getSiteChar(city,i,j);
      58   [ +  +  +  +  :      36864 :       switch(site) {
          +  +  +  +  +  
          +  +  +  +  +  
          -  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
                      - ]
      59                 :            :         /*
      60                 :            :       case '@':
      61                 :            :         Player.x = i; Player.y = j;
      62                 :            :         Level->site[i][j].locchar = FLOOR;
      63                 :            :         break;
      64                 :            :         */
      65                 :            :       case 'g':
      66                 :          9 :         Level->site[i][j].locchar = FLOOR;
      67                 :          9 :         Level->site[i][j].p_locf = L_GARDEN;
      68                 :          9 :         break;
      69                 :            :       case 'y':
      70                 :          9 :         Level->site[i][j].locchar = FLOOR;
      71                 :          9 :         Level->site[i][j].p_locf = L_CEMETARY;
      72                 :          9 :         break;
      73                 :            :       case 'p': /* WDT: each of these places needs to be assigned
      74                 :            :                  * a function (or replaced with an 'x' in the map)
      75                 :            :                  */
      76                 :            :       case '!':
      77                 :            :       case 'I':
      78                 :            :       case 'E':
      79                 :            :       case 'e':
      80                 :            :       case 'x':
      81                 :        594 :         assign_city_function(i,j);
      82                 :        594 :         break;
      83                 :            :       case 't':
      84                 :          9 :         Level->site[i][j].locchar = FLOOR;
      85                 :          9 :         Level->site[i][j].p_locf = L_TEMPLE;
      86                 :          9 :         CitySiteList[L_TEMPLE-CITYSITEBASE][0] = TRUE;
      87                 :          9 :         CitySiteList[L_TEMPLE-CITYSITEBASE][1] = i;
      88                 :          9 :         CitySiteList[L_TEMPLE-CITYSITEBASE][2] = j;
      89                 :          9 :         break;
      90                 :            : #if 0 /* WDT: HACK!  The new city doesn't use portcullis traps, but has other
      91                 :            :        * uses for 'T'.  Um...  I'd rather have a use for them (that's what
      92                 :            :        * the jail is supposed to be), so this will stay only for now; with
      93                 :            :        * any luck we'll have things fixed up before the next release. */
      94                 :            :       case 'T':
      95                 :            :         Level->site[i][j].locchar = FLOOR;
      96                 :            :         Level->site[i][j].p_locf = L_PORTCULLIS_TRAP;
      97                 :            :         Level->site[i][j].aux = NOCITYMOVE;
      98                 :            :         break;
      99                 :            : #endif /* end of hack */
     100                 :            :       case 'R':
     101                 :         36 :         Level->site[i][j].locchar = FLOOR;
     102                 :         36 :         Level->site[i][j].p_locf = L_RAISE_PORTCULLIS;
     103                 :         36 :         Level->site[i][j].aux = NOCITYMOVE;
     104                 :         36 :         break;
     105                 :            :       case '7':
     106                 :         36 :         Level->site[i][j].locchar = FLOOR;
     107                 :         36 :         Level->site[i][j].p_locf = L_PORTCULLIS;
     108                 :         36 :         Level->site[i][j].aux = NOCITYMOVE;
     109                 :         36 :         break;
     110                 :            :       case 'C':
     111                 :         18 :         Level->site[i][j].locchar = OPEN_DOOR;
     112                 :         18 :         Level->site[i][j].p_locf = L_COLLEGE;
     113                 :         18 :         CitySiteList[L_COLLEGE-CITYSITEBASE][0] = TRUE;
     114                 :         18 :         CitySiteList[L_COLLEGE-CITYSITEBASE][1] = i;
     115                 :         18 :         CitySiteList[L_COLLEGE-CITYSITEBASE][2] = j;
     116                 :         18 :         break;
     117                 :            :       case 's':
     118                 :          9 :         Level->site[i][j].locchar = OPEN_DOOR;
     119                 :          9 :         Level->site[i][j].p_locf = L_SORCERORS;
     120                 :          9 :         CitySiteList[L_SORCERORS-CITYSITEBASE][0] = TRUE;
     121                 :          9 :         CitySiteList[L_SORCERORS-CITYSITEBASE][1] = i;
     122                 :          9 :         CitySiteList[L_SORCERORS-CITYSITEBASE][2] = j;
     123                 :          9 :         break;
     124                 :            :       case 'M':
     125                 :         18 :         Level->site[i][j].locchar = OPEN_DOOR;
     126                 :         18 :         Level->site[i][j].p_locf = L_MERC_GUILD;
     127                 :         18 :         CitySiteList[L_MERC_GUILD-CITYSITEBASE][0] = TRUE;
     128                 :         18 :         CitySiteList[L_MERC_GUILD-CITYSITEBASE][1] = i;
     129                 :         18 :         CitySiteList[L_MERC_GUILD-CITYSITEBASE][2] = j;
     130                 :         18 :         break;
     131                 :            :       case 'K':
     132                 :            : #ifdef INCLUDE_MONKS
     133                 :          9 :         Level->site[i][j].locchar = OPEN_DOOR;
     134                 :          9 :         Level->site[i][j].p_locf = L_MONASTERY;
     135                 :          9 :         CitySiteList[L_MONASTERY-CITYSITEBASE][0] = TRUE;
     136                 :          9 :         CitySiteList[L_MONASTERY-CITYSITEBASE][1] = i;
     137                 :          9 :         CitySiteList[L_MONASTERY-CITYSITEBASE][2] = j;
     138                 :            : #else
     139                 :            :         assign_city_function(i,j);
     140                 :            : #endif
     141                 :          9 :         break;
     142                 :            :       case 'c':
     143                 :         18 :         Level->site[i][j].locchar = OPEN_DOOR;
     144                 :         18 :         Level->site[i][j].p_locf = L_CASTLE;
     145                 :         18 :         CitySiteList[L_CASTLE-CITYSITEBASE][0] = TRUE;
     146                 :         18 :         CitySiteList[L_CASTLE-CITYSITEBASE][1] = i;
     147                 :         18 :         CitySiteList[L_CASTLE-CITYSITEBASE][2] = j;
     148                 :         18 :         break;
     149                 :            :       case '?':
     150                 :            :         {
     151                 :            :           static int myI = -1, myJ;
     152                 :            :           char site;
     153         [ +  + ]:       2574 :           if ( myI == -1 )
     154                 :            :             {
     155                 :            :               /* If this is the first time we've seen the hedge maze,
     156                 :            :                * set this as its corner. */
     157                 :          9 :               myI = i; myJ = j;
     158                 :            :             }
     159                 :       2574 :           site = map_getSiteChar(maze, i - myI, j - myJ);
     160                 :       2574 :           mazesite(site,i,j,populate);
     161                 :            :         }
     162                 :       2574 :         break;
     163                 :            :       case 'P':
     164                 :          9 :         Level->site[i][j].locchar = OPEN_DOOR;
     165                 :          9 :         Level->site[i][j].p_locf = L_ORDER;
     166                 :          9 :         CitySiteList[L_ORDER-CITYSITEBASE][0] = TRUE;
     167                 :          9 :         CitySiteList[L_ORDER-CITYSITEBASE][1] = i;
     168                 :          9 :         CitySiteList[L_ORDER-CITYSITEBASE][2] = j;
     169                 :          9 :         break;
     170                 :            :       case 'H':
     171                 :          9 :         Level->site[i][j].locchar = OPEN_DOOR;
     172                 :          9 :         Level->site[i][j].p_locf = L_CHARITY;
     173                 :          9 :         CitySiteList[L_CHARITY-CITYSITEBASE][0] = TRUE;
     174                 :          9 :         CitySiteList[L_CHARITY-CITYSITEBASE][1] = i;
     175                 :          9 :         CitySiteList[L_CHARITY-CITYSITEBASE][2] = j;
     176                 :          9 :         break;
     177                 :            :       case 'h':
     178                 :          0 :         Level->site[i][j].locchar = FLOOR;
     179         [ #  # ]:          0 :         if (populate)
     180                 :          0 :           make_horse(i,j); /* from village.c */
     181                 :          0 :         break;
     182                 :            :       case 'j':
     183                 :          9 :         Level->site[i][j].locchar = FLOOR;
     184         [ +  + ]:          9 :         if (populate)
     185                 :          1 :           make_justiciar(i,j);
     186                 :          9 :         break;
     187                 :            :       case 'J':
     188                 :          9 :         Level->site[i][j].locchar = CLOSED_DOOR;
     189                 :          9 :         Level->site[i][j].p_locf = L_JAIL;
     190                 :          9 :         break;
     191                 :            :       case 'A':
     192                 :         18 :         Level->site[i][j].locchar = OPEN_DOOR;
     193                 :         18 :         Level->site[i][j].p_locf = L_ARENA;
     194                 :         18 :         CitySiteList[L_ARENA-CITYSITEBASE][0] = TRUE;
     195                 :         18 :         CitySiteList[L_ARENA-CITYSITEBASE][1] = i;
     196                 :         18 :         CitySiteList[L_ARENA-CITYSITEBASE][2] = j;
     197                 :         18 :         break;
     198                 :            :       case 'B':
     199                 :          9 :         Level->site[i][j].locchar = OPEN_DOOR;
     200                 :          9 :         Level->site[i][j].p_locf = L_BANK;
     201                 :          9 :         CitySiteList[L_BANK-CITYSITEBASE][0] = TRUE;
     202                 :          9 :         CitySiteList[L_BANK-CITYSITEBASE][1] = i;
     203                 :          9 :         CitySiteList[L_BANK-CITYSITEBASE][2] = j;
     204                 :          9 :         lset(i,j,STOPS);
     205                 :          9 :         lset(i,j+1,STOPS);
     206                 :          9 :         lset(i+1,j,STOPS);
     207                 :          9 :         lset(i-1,j,STOPS);
     208                 :          9 :         lset(i,j-1,STOPS);
     209                 :          9 :         break;
     210                 :            :       case 'i':
     211                 :          9 :         Level->site[i][j].locchar = OPEN_DOOR;
     212                 :          9 :         Level->site[i][j].p_locf = L_TOURIST;
     213                 :          9 :         CitySiteList[L_TOURIST-CITYSITEBASE][1] = i;
     214                 :          9 :         CitySiteList[L_TOURIST-CITYSITEBASE][2] = j;
     215                 :          9 :         lset(i,j,STOPS);
     216                 :          9 :         lset(i,j+1,STOPS);
     217                 :          9 :         lset(i+1,j,STOPS);
     218                 :          9 :         lset(i-1,j,STOPS);
     219                 :          9 :         lset(i,j-1,STOPS);
     220                 :          9 :         break;
     221                 :            :       case 'X':
     222                 :         18 :         Level->site[i][j].locchar = FLOOR;
     223                 :         18 :         Level->site[i][j].p_locf = L_COUNTRYSIDE;
     224                 :         18 :         CitySiteList[L_COUNTRYSIDE-CITYSITEBASE][0] = TRUE;
     225                 :         18 :         CitySiteList[L_COUNTRYSIDE-CITYSITEBASE][1] = i;
     226                 :         18 :         CitySiteList[L_COUNTRYSIDE-CITYSITEBASE][2] = j;
     227                 :         18 :         break;
     228                 :            :       case 'v':
     229                 :          9 :         Level->site[i][j].locchar = FLOOR;
     230                 :          9 :         Level->site[i][j].p_locf = L_VAULT;
     231                 :          9 :         Level->site[i][j].aux = NOCITYMOVE;
     232                 :          9 :         lset(i,j,SECRET);
     233                 :          9 :         break;
     234                 :            :       case 'S':
     235                 :         54 :         Level->site[i][j].locchar = FLOOR;
     236                 :         54 :         Level->site[i][j].aux = NOCITYMOVE;
     237                 :         54 :         lset(i,j,SECRET);
     238                 :         54 :         break;
     239                 :            :       case 'G':
     240                 :        108 :         Level->site[i][j].locchar = FLOOR;
     241         [ +  + ]:        108 :         if (populate) {
     242                 :         12 :           make_site_monster(i,j,GUARD);
     243                 :         12 :           Level->site[i][j].creature->aux1 = i;
     244                 :         12 :           Level->site[i][j].creature->aux2 = j;
     245                 :            :         }
     246                 :        108 :         break;
     247                 :            :       case 'u':
     248                 :         36 :         Level->site[i][j].locchar = FLOOR;
     249         [ +  + ]:         36 :         if (populate)
     250                 :          4 :           make_minor_undead(i,j);
     251                 :         36 :         break;
     252                 :            :       case 'U':
     253                 :         36 :         Level->site[i][j].locchar = FLOOR;
     254         [ +  + ]:         36 :         if (populate)
     255                 :          4 :           make_major_undead(i,j);
     256                 :         36 :         break;
     257                 :            :       case 'V':
     258                 :          9 :         Level->site[i][j].showchar = WALL;
     259                 :          9 :         Level->site[i][j].locchar = FLOOR;
     260                 :          9 :         Level->site[i][j].p_locf = L_VAULT;
     261         [ +  + ]:          9 :         if (populate)
     262                 :          1 :           make_site_treasure(i,j,5);
     263                 :          9 :         Level->site[i][j].aux = NOCITYMOVE;
     264                 :          9 :         lset(i,j,SECRET);
     265                 :          9 :         break;
     266                 :            :       case '%':
     267                 :        252 :         Level->site[i][j].showchar = WALL;
     268                 :        252 :         Level->site[i][j].locchar = FLOOR;
     269                 :        252 :         Level->site[i][j].p_locf = L_TRAP_SIREN;
     270         [ +  + ]:        252 :         if (populate)
     271                 :         28 :           make_site_treasure(i,j,5);
     272                 :        252 :         Level->site[i][j].aux = NOCITYMOVE;
     273                 :        252 :         lset(i,j,SECRET);
     274                 :        252 :         break;
     275                 :            :       case '$':
     276                 :         36 :         Level->site[i][j].locchar = FLOOR;
     277         [ +  + ]:         36 :         if (populate)
     278                 :          4 :           make_site_treasure(i,j,5);
     279                 :         36 :         break;
     280                 :            :       case '2':
     281                 :          9 :         Level->site[i][j].locchar = ALTAR;
     282                 :          9 :         Level->site[i][j].p_locf = L_ALTAR;
     283                 :          9 :         Level->site[i][j].aux = ODIN;
     284                 :          9 :         break;
     285                 :            :       case '3':
     286                 :          9 :         Level->site[i][j].locchar = ALTAR;
     287                 :          9 :         Level->site[i][j].p_locf = L_ALTAR;
     288                 :          9 :         Level->site[i][j].aux = SET;
     289                 :          9 :         break;
     290                 :            :       case '4':
     291                 :          9 :         Level->site[i][j].locchar = ALTAR;
     292                 :          9 :         Level->site[i][j].p_locf = L_ALTAR;
     293                 :          9 :         Level->site[i][j].aux = ATHENA;
     294                 :          9 :         break;
     295                 :            :       case '5':
     296                 :          9 :         Level->site[i][j].locchar = ALTAR;
     297                 :          9 :         Level->site[i][j].p_locf = L_ALTAR;
     298                 :          9 :         Level->site[i][j].aux = HECATE;
     299                 :          9 :         break;
     300                 :            :       case '6':
     301                 :          9 :         Level->site[i][j].locchar = ALTAR;
     302                 :          9 :         Level->site[i][j].p_locf = L_ALTAR;
     303                 :          9 :         Level->site[i][j].aux = DESTINY;
     304                 :          9 :         break;
     305                 :            :       case '^':
     306                 :         27 :         Level->site[i][j].showchar = WALL;
     307                 :         27 :         Level->site[i][j].locchar = FLOOR;
     308                 :         27 :         Level->site[i][j].p_locf = TRAP_BASE+random_range(NUMTRAPS);
     309                 :         27 :         lset(i,j,SECRET);
     310                 :         27 :         break;
     311                 :            :       case '"':
     312                 :       2115 :         Level->site[i][j].locchar = HEDGE;
     313                 :       2115 :         break;
     314                 :            :       case '~':
     315                 :        252 :         Level->site[i][j].locchar = WATER;
     316                 :        252 :         Level->site[i][j].p_locf = L_WATER;
     317                 :        252 :         break;
     318                 :            :       case '=':
     319                 :        108 :         Level->site[i][j].locchar = WATER;
     320                 :        108 :         Level->site[i][j].p_locf = L_MAGIC_POOL;
     321                 :        108 :         break;
     322                 :            :       case '*':
     323                 :         54 :         Level->site[i][j].locchar = WALL;
     324                 :         54 :         Level->site[i][j].aux = 10;
     325                 :         54 :         break;
     326                 :            :       case '#':
     327                 :      15345 :         Level->site[i][j].locchar = WALL;
     328                 :      15345 :         Level->site[i][j].aux = 500;
     329                 :      15345 :         break;
     330                 :            :       case 'T':/* currently meaningless in large city map. */
     331                 :            :       case '>':  /* currently meaningless outside of maze.*/
     332                 :            :       case '.':
     333                 :      14778 :         Level->site[i][j].locchar = FLOOR;
     334                 :      14778 :         break;
     335                 :            :       case ',':
     336                 :         27 :         Level->site[i][j].showchar = WALL;
     337                 :         27 :         Level->site[i][j].locchar = FLOOR;
     338                 :         27 :         Level->site[i][j].aux = NOCITYMOVE;
     339                 :         27 :         lset(i,j,SECRET);
     340                 :         27 :         break;
     341                 :            :       case '-':
     342                 :            :       case 'D': /* WDT: should all Ds be changed to -, or should D be given
     343                 :            :                  * special treatment? */
     344                 :         45 :         Level->site[i][j].locchar = CLOSED_DOOR;
     345                 :         45 :         break;
     346                 :            :       case '1':
     347                 :         99 :         Level->site[i][j].locchar = STATUE;
     348                 :         99 :         break;
     349                 :            :       default:
     350                 :          0 :         printf("\nOops... missed a case [%d,%d]: '%c' (%d)\n", i,j,site,site);
     351                 :          0 :         morewait();
     352                 :            :       }
     353                 :            : 
     354         [ +  + ]:      36864 :       if (loc_statusp(i,j,SEEN)) {
     355         [ +  + ]:      34290 :         if (loc_statusp(i,j,SECRET))
     356                 :        378 :           Level->site[i][j].showchar = WALL;
     357                 :      33912 :         else Level->site[i][j].showchar = Level->site[i][j].locchar;
     358                 :            :       }
     359                 :            :     }
     360                 :            :   }
     361                 :          9 :   map_close(maze);
     362                 :          9 :   map_close(city);
     363                 :          9 :   City = Level;
     364                 :            :   
     365                 :            :   /* make all city monsters asleep, and shorten their wakeup range to 2 */
     366                 :            :   /* to prevent players from being molested by vicious monsters on */
     367                 :            :   /* the streets */
     368         [ +  + ]:         31 :   for(ml=Level->mlist;ml!=NULL;ml=ml->next) {
     369                 :         22 :     m_status_reset(ml->m,AWAKE);
     370                 :         22 :     ml->m->wakeup = 2;
     371                 :            :   }
     372                 :          9 :   initrand(E_RESTORE, 0);
     373                 :          9 : }
     374                 :            : 
     375                 :            : 
     376                 :        594 : void assign_city_function(int x, int y)
     377                 :            : {
     378                 :            :   static int setup=0;
     379                 :            :   static int next=0;
     380                 :            :   static int permutation[64]; /* number of x's in city map */
     381                 :            :   int i,j,k,l;
     382                 :            : 
     383                 :        594 :   Level->site[x][y].aux = TRUE;
     384                 :            : 
     385                 :        594 :   lset(x,y+1,STOPS);
     386                 :        594 :   lset(x+1,y,STOPS);
     387                 :        594 :   lset(x-1,y,STOPS);
     388                 :        594 :   lset(x,y-1,STOPS);
     389                 :        594 :   lset(x,y,STOPS); /* FIXED! 12/30/98 */
     390                 :            : 
     391         [ +  + ]:        594 :   if (setup == 0) {
     392                 :          9 :     setup = 1;
     393         [ +  + ]:        585 :     for(i=0;i<64;i++)
     394                 :        576 :       permutation[i] = i;
     395         [ +  + ]:       4509 :     for(i=0;i<500;i++) {
     396                 :       4500 :       j = random_range(64);
     397                 :       4500 :       k = random_range(64);
     398                 :       4500 :       l = permutation[j];
     399                 :       4500 :       permutation[j] = permutation[k];
     400                 :       4500 :       permutation[k] = l;
     401                 :            :     }
     402                 :            :   }
     403         [ +  + ]:        594 :   if (next > 63) { /* in case someone changes the no. of x's */
     404                 :         18 :     Level->site[x][y].locchar = CLOSED_DOOR;
     405                 :         18 :     Level->site[x][y].p_locf = L_HOUSE;
     406         [ +  - ]:         18 :     if(random_range(5)) Level->site[x][y].aux = LOCKED;
     407                 :            :   }
     408   [ +  +  +  +  :        576 :   else switch(permutation[next]) {
          +  +  +  +  +  
          +  +  +  +  +  
                +  +  + ]
     409                 :            :   case 0:
     410                 :          9 :     Level->site[x][y].locchar = OPEN_DOOR;
     411                 :          9 :     Level->site[x][y].p_locf = L_ARMORER;
     412                 :          9 :     CitySiteList[L_ARMORER-CITYSITEBASE][1] = x;
     413                 :          9 :     CitySiteList[L_ARMORER-CITYSITEBASE][2] = y;
     414                 :          9 :     break;
     415                 :            :   case 1:
     416                 :          9 :     Level->site[x][y].locchar = OPEN_DOOR;
     417                 :          9 :     Level->site[x][y].p_locf = L_CLUB;
     418                 :          9 :     CitySiteList[L_CLUB-CITYSITEBASE][1] = x;
     419                 :          9 :     CitySiteList[L_CLUB-CITYSITEBASE][2] = y;
     420                 :          9 :     break;
     421                 :            :   case 2:
     422                 :          9 :     Level->site[x][y].locchar = OPEN_DOOR;
     423                 :          9 :     Level->site[x][y].p_locf = L_GYM;
     424                 :          9 :     CitySiteList[L_GYM-CITYSITEBASE][1] = x;
     425                 :          9 :     CitySiteList[L_GYM-CITYSITEBASE][2] = y;
     426                 :          9 :     break;
     427                 :            :   case 3:
     428                 :          9 :     Level->site[x][y].locchar = CLOSED_DOOR;
     429                 :          9 :     Level->site[x][y].p_locf = L_THIEVES_GUILD;
     430                 :          9 :     CitySiteList[L_THIEVES_GUILD-CITYSITEBASE][1] = x;
     431                 :          9 :     CitySiteList[L_THIEVES_GUILD-CITYSITEBASE][2] = y;
     432                 :          9 :     break;
     433                 :            :   case 4:
     434                 :          9 :     Level->site[x][y].locchar = OPEN_DOOR;
     435                 :          9 :     Level->site[x][y].p_locf = L_HEALER;
     436                 :          9 :     CitySiteList[L_HEALER-CITYSITEBASE][1] = x;
     437                 :          9 :     CitySiteList[L_HEALER-CITYSITEBASE][2] = y;
     438                 :          9 :     break;
     439                 :            :   case 5:
     440                 :          9 :     Level->site[x][y].locchar = OPEN_DOOR;
     441                 :          9 :     Level->site[x][y].p_locf = L_CASINO;
     442                 :          9 :     CitySiteList[L_CASINO-CITYSITEBASE][1] = x;
     443                 :          9 :     CitySiteList[L_CASINO-CITYSITEBASE][2] = y;
     444                 :          9 :     break;
     445                 :            :   case 7: 
     446                 :          9 :     Level->site[x][y].locchar = OPEN_DOOR;
     447                 :          9 :     Level->site[x][y].p_locf = L_DINER;
     448                 :          9 :     CitySiteList[L_DINER-CITYSITEBASE][1] = x;
     449                 :          9 :     CitySiteList[L_DINER-CITYSITEBASE][2] = y;
     450                 :          9 :     break;
     451                 :            :   case 8: 
     452                 :          9 :     Level->site[x][y].locchar = OPEN_DOOR;
     453                 :          9 :     Level->site[x][y].p_locf = L_CRAP;
     454                 :          9 :     CitySiteList[L_CRAP-CITYSITEBASE][1] = x;
     455                 :          9 :     CitySiteList[L_CRAP-CITYSITEBASE][2] = y;
     456                 :          9 :     break;
     457                 :            :   case 6:
     458                 :            :   case 9: 
     459                 :            :   case 20: 
     460                 :         27 :     Level->site[x][y].locchar = OPEN_DOOR;
     461                 :         27 :     Level->site[x][y].p_locf = L_COMMANDANT;
     462                 :         27 :     CitySiteList[L_COMMANDANT-CITYSITEBASE][1] = x;
     463                 :         27 :     CitySiteList[L_COMMANDANT-CITYSITEBASE][2] = y;
     464                 :         27 :     break;
     465                 :            :   case 21:
     466                 :          9 :     Level->site[x][y].locchar = OPEN_DOOR;
     467                 :          9 :     Level->site[x][y].p_locf = L_TAVERN;
     468                 :          9 :     CitySiteList[L_TAVERN-CITYSITEBASE][1] = x;
     469                 :          9 :     CitySiteList[L_TAVERN-CITYSITEBASE][2] = y;
     470                 :          9 :     break;
     471                 :            :   case 10:
     472                 :          9 :     Level->site[x][y].locchar = OPEN_DOOR;
     473                 :          9 :     Level->site[x][y].p_locf = L_ALCHEMIST;
     474                 :          9 :     CitySiteList[L_ALCHEMIST-CITYSITEBASE][1] = x;
     475                 :          9 :     CitySiteList[L_ALCHEMIST-CITYSITEBASE][2] = y;
     476                 :          9 :     break;
     477                 :            :   case 11:
     478                 :          9 :     Level->site[x][y].locchar = OPEN_DOOR;
     479                 :          9 :     Level->site[x][y].p_locf = L_DPW;
     480                 :          9 :     CitySiteList[L_DPW-CITYSITEBASE][1] = x;
     481                 :          9 :     CitySiteList[L_DPW-CITYSITEBASE][2] = y;
     482                 :          9 :     break;
     483                 :            :   case 12:
     484                 :          9 :     Level->site[x][y].locchar = OPEN_DOOR;
     485                 :          9 :     Level->site[x][y].p_locf = L_LIBRARY;
     486                 :          9 :     CitySiteList[L_LIBRARY-CITYSITEBASE][1] = x;
     487                 :          9 :     CitySiteList[L_LIBRARY-CITYSITEBASE][2] = y;
     488                 :          9 :     break;
     489                 :            :   case 13:
     490                 :          9 :     Level->site[x][y].locchar = OPEN_DOOR;
     491                 :          9 :     Level->site[x][y].p_locf = L_PAWN_SHOP;
     492                 :          9 :     CitySiteList[L_PAWN_SHOP-CITYSITEBASE][1] = x;
     493                 :          9 :     CitySiteList[L_PAWN_SHOP-CITYSITEBASE][2] = y;
     494                 :          9 :     break;
     495                 :            :   case 14:
     496                 :          9 :     Level->site[x][y].locchar = OPEN_DOOR;
     497                 :          9 :     Level->site[x][y].p_locf = L_CONDO;
     498                 :          9 :     CitySiteList[L_CONDO-CITYSITEBASE][1] = x;
     499                 :          9 :     CitySiteList[L_CONDO-CITYSITEBASE][2] = y;
     500                 :          9 :     break;
     501                 :            :   case 15:
     502                 :          9 :     Level->site[x][y].locchar = CLOSED_DOOR;
     503                 :          9 :     Level->site[x][y].p_locf = L_BROTHEL;
     504                 :          9 :     CitySiteList[L_BROTHEL-CITYSITEBASE][1] = x;
     505                 :          9 :     CitySiteList[L_BROTHEL-CITYSITEBASE][2] = y;
     506                 :          9 :     break;
     507                 :            :   default:
     508                 :        414 :     Level->site[x][y].locchar = CLOSED_DOOR;
     509   [ +  +  +  - ]:        414 :     switch(random_range(6)) {
     510                 :         78 :     case 0: Level->site[x][y].p_locf = L_HOVEL; break;
     511                 :            :     case 1: case 2: case 3:
     512                 :        272 :     case 4: Level->site[x][y].p_locf = L_HOUSE; break;
     513                 :         64 :     case 5: Level->site[x][y].p_locf = L_MANSION; break;
     514                 :            :     }
     515         [ +  + ]:        414 :     if(random_range(5)) Level->site[x][y].aux = LOCKED;
     516                 :        414 :     break;
     517                 :            :   }
     518                 :        594 :   next++;
     519                 :        594 : }
     520                 :            : 
     521                 :            :   
     522                 :            : 
     523                 :            : 
     524                 :            : /* makes a hiscore npc for mansions */
     525                 :          1 : void make_justiciar(int i, int j)
     526                 :            : {
     527                 :          1 :   pml ml = ((pml) checkmalloc(sizeof(mltype)));
     528                 :          1 :   ml->m = ((pmt) checkmalloc(sizeof(montype)));
     529                 :          1 :   *(ml->m) = Monsters[NPC];
     530                 :          1 :   make_hiscore_npc(ml->m,15);
     531                 :          1 :   ml->m->x = i;
     532                 :          1 :   ml->m->y = j;
     533                 :          1 :   Level->site[i][j].creature = ml->m;
     534                 :          1 :   ml->m->click = (Tick + 1) % 60;
     535                 :          1 :   ml->next = Level->mlist;
     536                 :          1 :   Level->mlist = ml;
     537                 :          1 :   m_status_reset(ml->m,AWAKE);
     538                 :          1 : }
     539                 :            : 
     540                 :            : 
     541                 :            : 
     542                 :            : /* loads the city level */
     543                 :          0 : void resurrect_guards(void)
     544                 :            : {
     545                 :            :   int i,j;
     546                 :            :   map *city;
     547                 :            :   
     548                 :            :   /* Get the original city. */
     549                 :          0 :   city = map_open(MAP_city);
     550                 :          0 :   map_setLevel(city,0);
     551                 :            : 
     552         [ #  # ]:          0 :   for(j=0;j<Level->level_length;j++) {
     553         [ #  # ]:          0 :     for(i=0;i<Level->level_width;i++) {
     554         [ #  # ]:          0 :       if (map_getSiteChar(city,i,j) == 'G') {
     555                 :          0 :         make_site_monster(i,j,GUARD);
     556                 :          0 :         Level->site[i][j].creature->monstring = "undead guardsman";
     557                 :          0 :         Level->site[i][j].creature->meleef = M_MELEE_SPIRIT;
     558                 :          0 :         Level->site[i][j].creature->movef = M_MOVE_SPIRIT;
     559                 :          0 :         Level->site[i][j].creature->strikef = M_STRIKE_MISSILE;
     560                 :          0 :         Level->site[i][j].creature->immunity = EVERYTHING-pow2(NORMAL_DAMAGE);
     561                 :          0 :         Level->site[i][j].creature->hp *= 2;
     562                 :          0 :         Level->site[i][j].creature->hit *= 2;
     563                 :          0 :         Level->site[i][j].creature->dmg *= 2;
     564                 :          0 :         Level->site[i][j].creature->ac *= 2;
     565                 :          0 :         m_status_set(Level->site[i][j].creature,HOSTILE);
     566                 :          0 :         m_status_set(Level->site[i][j].creature,AWAKE);
     567                 :            :       }
     568                 :            :     }
     569                 :            :   }
     570                 :          0 : }
     571                 :            : 
     572                 :            : 
     573                 :       2574 : void mazesite(char site, int i, int j, int populate)
     574                 :            : {
     575   [ +  +  +  +  :       2574 :   switch(site) {
             +  +  +  - ]
     576                 :            :   case '"':
     577                 :       1306 :     Level->site[i][j].locchar = HEDGE;
     578         [ +  + ]:       1306 :     if (random_range(10))
     579                 :       1109 :       Level->site[i][j].p_locf = L_HEDGE;
     580                 :            :     else
     581                 :        197 :       Level->site[i][j].p_locf = L_TRIFID;
     582                 :       1306 :     break;
     583                 :            :   case '-':
     584                 :        103 :     Level->site[i][j].locchar = CLOSED_DOOR;
     585                 :        103 :     break;
     586                 :            :   case '.':
     587                 :       1065 :     Level->site[i][j].locchar = FLOOR;
     588                 :       1065 :     break;
     589                 :            :   case '>':
     590                 :          9 :     Level->site[i][j].locchar = STAIRS_DOWN;
     591                 :          9 :     Level->site[i][j].p_locf = L_SEWER;
     592                 :          9 :     CitySiteList[L_SEWER-CITYSITEBASE][1] = i;
     593                 :          9 :     CitySiteList[L_SEWER-CITYSITEBASE][2] = j;
     594                 :          9 :     break;
     595                 :            :   case 'z':
     596                 :          9 :     Level->site[i][j].locchar = FLOOR;
     597                 :          9 :     Level->site[i][j].p_locf = L_MAZE;
     598                 :          9 :     break;
     599                 :            :   case 'O':
     600                 :          9 :     Level->site[i][j].locchar = OPEN_DOOR;
     601                 :          9 :     Level->site[i][j].p_locf = L_ORACLE;
     602                 :          9 :     CitySiteList[L_ORACLE-CITYSITEBASE][1] = i;
     603                 :          9 :     CitySiteList[L_ORACLE-CITYSITEBASE][2] = j;
     604                 :          9 :     break;
     605                 :            :   case '?':
     606                 :         73 :     randommazesite(i,j,populate);
     607                 :         73 :     break;
     608                 :            :   }
     609                 :       2574 :   lreset(i,j,SEEN);
     610                 :       2574 : }
     611                 :            : 
     612                 :         73 : void randommazesite(int i, int j, int populate)
     613                 :            : {
     614   [ +  +  +  + ]:         73 :   switch(random_range(7)) {
     615                 :            :   case 0: case 1:
     616                 :         29 :     Level->site[i][j].locchar = FLOOR;
     617                 :            :     /*    Level->site[i][j].p_locf = TRAP_BASE+random_range(NUMTRAPS); */
     618                 :         29 :     Level->site[i][j].p_locf = TRAP_BASE+random_range(NUM_SAFE_TRAPS);
     619                 :         29 :     break;
     620                 :            :   case 2: case 3:
     621                 :         25 :     Level->site[i][j].locchar = FLOOR;
     622         [ +  + ]:         25 :     if (populate)
     623                 :          1 :       make_site_monster(i,j,-1);
     624                 :         25 :     break;
     625                 :            :   case 4: case 5:
     626                 :         18 :     Level->site[i][j].locchar = FLOOR;
     627         [ +  + ]:         18 :     if (populate)
     628                 :          2 :       make_site_treasure(i,j,5);
     629                 :         18 :     break;
     630                 :            :   default:
     631                 :          1 :     Level->site[i][j].locchar = FLOOR;    
     632                 :            :   }
     633                 :         73 : }
     634                 :            : 
     635                 :            : 
     636                 :            : /* undead are not hostile unless disturbed.... */
     637                 :          4 : void make_minor_undead(int i, int j)
     638                 :            : {
     639                 :            :   int mid;
     640         [ +  + ]:          4 :   if (random_range(2)) mid = GHOST;
     641                 :          2 :   else mid = HAUNT;
     642                 :          4 :   make_site_monster(i,j,mid);
     643                 :          4 :   m_status_reset(Level->site[i][j].creature,AWAKE);
     644                 :          4 :   m_status_reset(Level->site[i][j].creature,HOSTILE);
     645                 :          4 : }    
     646                 :            : 
     647                 :            : /* undead are not hostile unless disturbed.... */
     648                 :          4 : void make_major_undead(int i, int j)
     649                 :            : {
     650                 :            :   int mid;
     651         [ +  + ]:          4 :   if (random_range(2)) mid = LICHE; /* lich */
     652                 :          1 :   else mid = VAMP_LORD; /*vampire lord*/
     653                 :          4 :   make_site_monster(i,j,mid);
     654                 :          4 :   m_status_reset(Level->site[i][j].creature,AWAKE);
     655                 :          4 :   m_status_reset(Level->site[i][j].creature,HOSTILE);
     656                 :          4 : }    
     657                 :            : 
     658                 :            : 
     659                 :            : static char jail[5][11] = 
     660                 :            : {
     661                 :            :    { '#', '#', '*', '#', '#', '*', '#', '#', '*', '#', '#' },
     662                 :            :    { '#', '#', '*', '#', '#', '*', '#', '*', '#', '#', '#' },
     663                 :            :    { '#', '#', 'T', '#', 'T', '#', 'T', '#', 'T', '#', '#' },
     664                 :            :    { '#', '#', '7', '#', '7', '#', '7', '#', '7', '#', '#' },
     665                 :            :    { '#', '#', 'R', '#', 'R', '#', 'R', '#', 'R', '#', '#' }
     666                 :            : };
     667                 :            : 
     668                 :            : /* fixes up the jail in case it has been munged by player action */
     669                 :          0 : void repair_jail(void)
     670                 :            : {
     671                 :            :   int i,j;
     672         [ #  # ]:          0 :   for(i=0;i<11;i++)
     673         [ #  # ]:          0 :     for(j=0;j<5;j++) {
     674   [ #  #  #  #  :          0 :       switch(jail[j][i]) {
                   #  # ]
     675                 :            :       case '#':
     676                 :          0 :         City->site[i+35][j+52].locchar = WALL;
     677                 :          0 :         City->site[i+35][j+52].p_locf = L_NO_OP;
     678                 :          0 :         City->site[i+35][j+52].aux = NOCITYMOVE;
     679                 :          0 :         break;
     680                 :            :       case '*':
     681                 :          0 :         City->site[i+35][j+52].locchar = WALL;
     682                 :          0 :         City->site[i+35][j+52].p_locf = L_NO_OP;
     683                 :          0 :         City->site[i+35][j+52].aux = 10;
     684                 :          0 :         break;
     685                 :            :       case 'T':
     686                 :          0 :         City->site[i+35][j+52].locchar = FLOOR;
     687                 :          0 :         City->site[i+35][j+52].p_locf = L_PORTCULLIS_TRAP;
     688                 :          0 :         City->site[i+35][j+52].aux = NOCITYMOVE;
     689                 :          0 :         break;
     690                 :            :       case '7':
     691                 :          0 :         City->site[i+35][j+52].locchar = FLOOR;
     692                 :          0 :         City->site[i+35][j+52].p_locf = L_PORTCULLIS;
     693                 :          0 :         City->site[i+35][j+52].aux = NOCITYMOVE;
     694                 :          0 :         break;
     695                 :            :       case 'R':
     696                 :          0 :         City->site[i+35][j+52].locchar = FLOOR;
     697                 :          0 :         City->site[i+35][j+52].p_locf = L_RAISE_PORTCULLIS;
     698                 :          0 :         City->site[i+35][j+52].aux = NOCITYMOVE;
     699                 :          0 :         break;
     700                 :            :       }
     701                 :          0 :       lreset(i+35, j+52, CHANGED);
     702                 :            :     }
     703                 :          0 : }

Generated by: LCOV version 1.11