Look for the following in merc.h: extern sh_int gsn_recall; Then add: extern sh_int gsn_hunt;
[EMAIL PROTECTED] wrote: > This is my hunt.c and for some reason it wont compile right because it > says that gsn_hunt isn't declared. But I do have it declared and > everything... Hrm... Anybody see anything wrong with it. Btw I think it > might be where it says gsn_hunt might be: > ch->pcdata->learned[gsn_hunt] > Instead of (I THINK) something like: > ch, gsn_hunt, FALSE, 2 > or something of the sort. Thats what I seen in the code. What do the TRUE > FALSE and numerical args stand for though? > Here's hunt.c: > > /* > * > * Modified by Baxter for Deadland MUD (Rom2.4b4) (01-Feb-97). > * Hidayet Dogan ([EMAIL PROTECTED]) > * ftp://deadland.ada.com.tr/pub/mud/Rom/code/track.skill (195.142.130.3) > * Deadland MUD - deadland.ada.com.tr 4000 (195.142.130.3) > * > */ > > /* > * SillyMUD Distribution V1.1b (c) 1993 SillyMUD Developement > * See license.doc for distribution terms. SillyMUD is based on DIKUMUD > * > * Modifications by Rip in attempt to port to merc 2.1 > */ > > /* > * Modified by Turtle for Merc22 (07-Nov-94) > * > * I got this one from > ftp.atinc.com:/pub/mud/outgoing/track.merc21.tar.gz. > * It cointained 5 files: README, hash.c, hash.h, skills.c, and skills.h. > * I combined the *.c and *.h files in this hunt.c, which should compile > * without any warnings or errors. > */ > > /* > * Some systems don't have bcopy and bzero functions in their linked > libraries. > * If compilation fails due to missing of either of these functions, > * define NO_BCOPY or NO_BZERO accordingly. -- Turtle > 31-Jan-95 > */ > > #if defined(macintosh) > #include <types.h> > #include <time.h> > #else > #include <sys/types.h> > #include <sys/time.h> > #endif > #include <stdio.h> > #include <stdlib.h> > #include <unistd.h> > #include "merc.h" > #include "interp.h" > #include "recycle.h" > #include "tables.h" > #include "lookup.h" > #include "olc.h" > > DECLARE_DO_FUN(do_say ); > DECLARE_DO_FUN(do_open ); > > void bcopy(register char *s1,register char *s2,int len); > void bzero(register char *sp,int len); > > struct hash_link > { > int key; > struct hash_link *next; > void *data; > }; > > struct hash_header > { > int rec_size; > int table_size; > int *keylist, klistsize, klistlen; /* this is really lame, > AMAZINGLY lame */ > struct hash_link **buckets; > }; > > #define WORLD_SIZE 30000 > #define HASH_KEY(ht,key)((((unsigned int)(key))*17)%(ht)->table_size) > > struct hunting_data > { > char *name; > struct char_data **victim; > }; > > struct room_q > { > int room_nr; > struct room_q *next_q; > }; > > struct nodes > { > int visited; > int ancestor; > }; > > #define IS_DIR (get_room_index(q_head->room_nr)->exit[i]) > #define GO_OK (!IS_SET( IS_DIR->exit_info, EX_CLOSED )) > #define GO_OK_SMARTER 1 > > #if defined( NO_BCOPY ) > void bcopy(register char *s1,register char *s2,int len) > { > while( len-- ) *(s2++) = *(s1++); > } > #endif > > #if defined( NO_BZERO ) > void bzero(register char *sp,int len) > { > while( len-- ) *(sp++) = '\0'; > } > #endif > > void init_hash_table(struct hash_header *ht,int rec_size,int table_size) > { > ht->rec_size = rec_size; > ht->table_size= table_size; > ht->buckets = (void*)calloc(sizeof(struct hash_link**),table_size); > ht->keylist = (void*)malloc(sizeof(ht->keylist)*(ht->klistsize=128)); > ht->klistlen = 0; > } > > void init_world(ROOM_INDEX_DATA *room_db[]) > { > /* zero out the world */ > bzero((char *)room_db,sizeof(ROOM_INDEX_DATA *)*WORLD_SIZE); > } > > void destroy_hash_table(struct hash_header *ht,void (*gman)()) > { > int i; > struct hash_link *scan,*temp; > > for(i=0;i<ht->table_size;i++) > for(scan=ht->buckets[i];scan;) > { > temp = scan->next; > (*gman)(scan->data); > free(scan); > scan = temp; > } > free(ht->buckets); > free(ht->keylist); > } > > void _hash_enter(struct hash_header *ht,int key,void *data) > { > /* precondition: there is no entry for <key> yet */ > struct hash_link *temp; > int i; > > temp = (struct hash_link *)malloc(sizeof(struct hash_link)); > temp->key = key; > temp->next = ht->buckets[HASH_KEY(ht,key)]; > temp->data = data; > ht->buckets[HASH_KEY(ht,key)] = temp; > if(ht->klistlen>=ht->klistsize) > { > ht->keylist = (void*)realloc(ht->keylist,sizeof(*ht->keylist)* > (ht->klistsize*=2)); > } > for(i=ht->klistlen;i>=0;i--) > { > if(ht->keylist[i-1]<key) > { > ht->keylist[i] = key; > break; > } > ht->keylist[i] = ht->keylist[i-1]; > } > ht->klistlen++; > } > > ROOM_INDEX_DATA *room_find(ROOM_INDEX_DATA *room_db[],int key) > { > return((key<WORLD_SIZE&&key>-1)?room_db[key]:0); > } > > void *hash_find(struct hash_header *ht,int key) > { > struct hash_link *scan; > > scan = ht->buckets[HASH_KEY(ht,key)]; > > while(scan && scan->key!=key) > scan = scan->next; > > return scan ? scan->data : NULL; > } > > int room_enter(ROOM_INDEX_DATA *rb[],int key,ROOM_INDEX_DATA *rm) > { > ROOM_INDEX_DATA *temp; > > temp = room_find(rb,key); > if(temp) return(0); > > rb[key] = rm; > return(1); > } > > int hash_enter(struct hash_header *ht,int key,void *data) > { > void *temp; > > temp = hash_find(ht,key); > if(temp) return 0; > > _hash_enter(ht,key,data); > return 1; > } > > ROOM_INDEX_DATA *room_find_or_create(ROOM_INDEX_DATA *rb[],int key) > { > ROOM_INDEX_DATA *rv; > > rv = room_find(rb,key); > if(rv) return rv; > > rv = (ROOM_INDEX_DATA *)malloc(sizeof(ROOM_INDEX_DATA)); > rb[key] = rv; > > return rv; > } > > void *hash_find_or_create(struct hash_header *ht,int key) > { > void *rval; > > rval = hash_find(ht, key); > if(rval) return rval; > > rval = (void*)malloc(ht->rec_size); > _hash_enter(ht,key,rval); > > return rval; > } > > int room_remove(ROOM_INDEX_DATA *rb[],int key) > { > ROOM_INDEX_DATA *tmp; > > tmp = room_find(rb,key); > if(tmp) > { > rb[key] = 0; > free(tmp); > } > return(0); > } > > void *hash_remove(struct hash_header *ht,int key) > { > struct hash_link **scan; > > scan = ht->buckets+HASH_KEY(ht,key); > > while(*scan && (*scan)->key!=key) > scan = &(*scan)->next; > > if(*scan) > { > int i; > struct hash_link *temp, *aux; > > temp = (*scan)->data; > aux = *scan; > *scan = aux->next; > free(aux); > > for(i=0;i<ht->klistlen;i++) > if(ht->keylist[i]==key) > break; > > if(i<ht->klistlen) > { > bcopy((char *)ht->keylist+i+1,(char *)ht->keylist+i,(ht->klistlen-i) > *sizeof(*ht->keylist)); > ht->klistlen--; > } > > return temp; > } > > return NULL; > } > > void room_iterate(ROOM_INDEX_DATA *rb[],void (*func)(),void *cdata) > { > register int i; > > for(i=0;i<WORLD_SIZE;i++) > { > ROOM_INDEX_DATA *temp; > > temp = room_find(rb,i); > if(temp) (*func)(i,temp,cdata); > } > } > > void hash_iterate(struct hash_header *ht,void (*func)(),void *cdata) > { > int i; > > for(i=0;i<ht->klistlen;i++) > { > void *temp; > register int key; > > key = ht->keylist[i]; > temp = hash_find(ht,key); > (*func)(key,temp,cdata); > if(ht->keylist[i]!=key) /* They must have deleted this room */ > i--; /* Hit this slot again. */ > } > } > > int exit_ok( EXIT_DATA *pexit ) > { > ROOM_INDEX_DATA *to_room; > > if ( ( pexit == NULL ) > || ( to_room = pexit->u1.to_room ) == NULL ) > return 0; > > return 1; > } > > void donothing() > { > return; > } > > int find_path( int in_room_vnum, int out_room_vnum, CHAR_DATA *ch, > int depth, int in_zone ) > { > struct room_q *tmp_q, *q_head, *q_tail; > struct hash_header x_room; > int i, tmp_room, count=0, thru_doors; > ROOM_INDEX_DATA *herep; > ROOM_INDEX_DATA *startp; > EXIT_DATA *exitp; > > if ( depth <0 ) > { > thru_doors = TRUE; > depth = -depth; > } > else > { > thru_doors = FALSE; > } > > startp = get_room_index( in_room_vnum ); > > init_hash_table( &x_room, sizeof(int), 2048 ); > hash_enter( &x_room, in_room_vnum, (void *) - 1 ); > > /* initialize queue */ > q_head = (struct room_q *) malloc(sizeof(struct room_q)); > q_tail = q_head; > q_tail->room_nr = in_room_vnum; > q_tail->next_q = 0; > > while(q_head) > { > herep = get_room_index( q_head->room_nr ); > /* for each room test all directions */ > if( herep->area == startp->area || !in_zone ) > { > /* only look in this zone... > saves cpu time and makes world safer for players */ > for( i = 0; i <= 5; i++ ) > { > exitp = herep->exit[i]; > if( exit_ok(exitp) && ( thru_doors ? GO_OK_SMARTER : GO_OK ) ) > { > /* next room */ > tmp_room = herep->exit[i]->u1.to_room->vnum; > if( tmp_room != out_room_vnum ) > { > /* shall we add room to queue ? > count determines total breadth and depth */ > if( !hash_find( &x_room, tmp_room ) > && ( count < depth ) ) > /* && !IS_SET( RM_FLAGS(tmp_room), DEATH ) ) */ > { > count++; > /* mark room as visted and put on queue */ > > tmp_q = (struct room_q *) > malloc(sizeof(struct room_q)); > tmp_q->room_nr = tmp_room; > tmp_q->next_q = 0; > q_tail->next_q = tmp_q; > q_tail = tmp_q; > > /* ancestor for first layer is the direction */ > hash_enter( &x_room, tmp_room, > ((int)hash_find(&x_room,q_head->room_nr) > == -1) ? (void*)(i+1) > : hash_find(&x_room,q_head->room_nr)); > } > } > else > { > /* have reached our goal so free queue */ > tmp_room = q_head->room_nr; > for(;q_head;q_head = tmp_q) > { > tmp_q = q_head->next_q; > free(q_head); > } > /* return direction if first layer */ > if ((int)hash_find(&x_room,tmp_room)==-1) > { > if (x_room.buckets) > { > /* junk left over from a previous track */ > destroy_hash_table(&x_room, donothing); > } > return(i); > } > else > { > /* else return the ancestor */ > int i; > > i = (int)hash_find(&x_room,tmp_room); > if (x_room.buckets) > { > /* junk left over from a previous track */ > destroy_hash_table(&x_room, donothing); > } > return( -1+i); > } > } > } > } > } > > /* free queue head and point to next entry */ > tmp_q = q_head->next_q; > free(q_head); > q_head = tmp_q; > } > > /* couldn't find path */ > if( x_room.buckets ) > { > /* junk left over from a previous track */ > destroy_hash_table( &x_room, donothing ); > } > return -1; > } > > /* void do_track( CHAR_DATA *ch, char *argument ) */ > void do_hunt( CHAR_DATA *ch, char *argument ) > { > char buf[MAX_STRING_LENGTH]; > char arg[MAX_STRING_LENGTH]; > CHAR_DATA *victim; > int direction; > bool fArea; > > one_argument( argument, arg ); > > if (!IS_NPC(ch) > && ch->level < skill_table[gsn_hunt].skill_level[ch->class]) > { > send_to_char("Huh?\n\r",ch); > return; > } > > if( arg[0] == '\0' ) > { > send_to_char( "Whom are you trying to hunt?\n\r", ch ); > return; > } > > /* only imps can hunt to different areas */ > fArea = ( get_trust(ch) < MAX_LEVEL ); > > if (IS_NPC(ch)) > victim = get_char_world( ch, arg ); > else if (fArea) > victim = get_char_area( ch, arg ); > else > victim = get_char_world( ch, arg ); > > if( victim == NULL ) > { > send_to_char("No-one around by that name.\n\r", ch ); > return; > } > > if( ch->in_room == victim->in_room ) > { > act( "$N is here!", ch, NULL, victim, TO_CHAR ); > return; > } > > /* > * Deduct some movement. > */ > if( ch->move > 2 ) > ch->move -= 3; > else > { > send_to_char( "You're too exhausted to hunt anyone!\n\r", ch ); > return; > } > > act( "$n carefully sniffs the air.", ch, NULL, NULL, TO_ROOM ); > WAIT_STATE( ch, skill_table[gsn_hunt].beats ); > direction = find_path( ch->in_room->vnum, victim->in_room->vnum, > ch, -40000, fArea ); > > if( direction == -1 ) > { > act( "You couldn't find a path to $N from here.", > ch, NULL, victim, TO_CHAR ); > return; > } > > if( direction < 0 || direction > 5 ) > { > send_to_char( "Hmm... Something seems to be wrong.\n\r", ch ); > return; > } > > /* > * Give a random direction if the player misses the die roll. > */ > #if 0 > if( ( IS_NPC (ch) && number_percent () > 75) /* NPC @ 25% */ > || (!IS_NPC (ch) && number_percent () > /* PC @ norm */ > ch->pcdata->learned[gsn_hunt] ) ) > #endif > > if (!IS_NPC(ch) && number_percent() > ch->pcdata->learned[gsn_hunt]) > { > do > { > direction = number_door(); > } > while( ( ch->in_room->exit[direction] == NULL ) > || ( ch->in_room->exit[direction]->u1.to_room == NULL) ); > } > > /* > * Display the results of the search. > */ > sprintf( buf, "$N is %s from here.", dir_name[direction] ); > act( buf, ch, NULL, victim, TO_CHAR ); > check_improve(ch,gsn_hunt,TRUE,1); > return; > } > > _______________________________________________ > ROM mailing list > [email protected] > http://www.rom.org/cgi-bin/mailman/listinfo/rom
