Return to ident.c CVS log

Up to [contributed] / early-roguelike / urogue

Annotation of early-roguelike/urogue/ident.c, Revision 1.1.1.1

1.1       rubenllo    1: /*
                      2:     ident.c - routines to associate an identifier with an object
                      3:
                      4:     UltraRogue: The Ultimate Adventure in the Dungeons of Doom
                      5:     Copyright (C) 1986, 1991, 1993, 1995 Herb Chong
                      6:     All rights reserved.
                      7:
                      8:     See the file LICENSE.TXT for full copyright and licensing information.
                      9: */
                     10:
                     11: /*
                     12:  * ident
                     13:  *
                     14:  * This file contains routines to associate an identifier with an object. The
                     15:  * identifiers are organized by type. Once an identifier is attached to an
                     16:  * object, it remains with that object until the object is removed from the
                     17:  * game. The identifiers are small integers, and they are assigned merely by
                     18:  * counting objects of the same type. Allocation picks the next available
                     19:  * integer.
                     20:  *
                     21:  * It is required that the linked list be sorted within types so that gaps can
                     22:  * easily be detected.
                     23:  */
                     24:
                     25: #include "rogue.h"
                     26:
                     27: /*
                     28:  * Index of 0 is invalid (unused state)
                     29:  */
                     30:
                     31: char print_letters[] = " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
                     32: linked_list *ident_list = NULL; /* master list of all items */
                     33:
                     34: /*
                     35:     get_ident()
                     36:
                     37:     Gets the identifier for the given object. If an identifier exists, it is
                     38:     returned. If not, one is allocated and returned to the user. The
                     39:     identifier remains constant as long as the object is in the game.
                     40: */
                     41:
                     42: int
                     43: get_ident(struct object *obj_p)
                     44: {
                     45:     int obj_type = obj_p->o_type;
                     46:     linked_list *list_p;           /* pointer into ident_list */
                     47:     int new_id = 1;                /* in case we have to allocate */
                     48:     struct object *tmp_obj_p;
                     49:     struct linked_list *new_place_p = NULL;
                     50:
                     51:     if (identifier(obj_p) != 0)
                     52:         return (identifier(obj_p));
                     53:
                     54:     /* no identifier - must allocate one */
                     55:
                     56:     for (list_p = ident_list; list_p != NULL; list_p = next(list_p))
                     57:     {
                     58:         tmp_obj_p = OBJPTR(list_p);
                     59:
                     60:         if (tmp_obj_p->o_type == obj_type)
                     61:         {
                     62:             if (identifier(tmp_obj_p) == new_id)
                     63:             {
                     64:                 /* if this id is taken, try next */
                     65:                 new_place_p = list_p;
                     66:                 new_id++;
                     67:             }
                     68:         }
                     69:     }
                     70:
                     71:     /*
                     72:      * If we get here, the object is not in the list, and we need to add
                     73:      * it. The proper id is in new_id, and the place to put it is right
                     74:      * after new_place_p.
                     75:      */
                     76:
                     77:     list_p = new_list();
                     78:     _attach_after(&ident_list, new_place_p, list_p);
                     79:     identifier(obj_p) = new_id;
                     80:     list_p->data.obj = obj_p;
                     81:     return(new_id);
                     82: }
                     83:
                     84: /*
                     85:     free_ident()
                     86:
                     87:     Frees up an identifier by removing the list entry that contains that item.
                     88:     If the item isn't found, nothing is done.
                     89: */
                     90:
                     91: void
                     92: free_ident(struct object *obj_p)
                     93: {
                     94:     linked_list *list_p;
                     95:
                     96:     for (list_p = ident_list; list_p != NULL; list_p = next(list_p))
                     97:     {
                     98:         if (obj_p == OBJPTR(list_p))
                     99:         {
                    100:             _detach(&ident_list, list_p);   /* unlink it from the list */
                    101:             ur_free(list_p);                /* release link structure */
                    102:             break;
                    103:         }
                    104:     }
                    105: }
                    106:
                    107: /*
                    108:     unprint_id()
                    109:
                    110:     Converts a printable id from print_letters to the real thing by getting the
                    111:     index.
                    112: */
                    113:
                    114: int
                    115: unprint_id(char *print_id)
                    116: {
                    117:     char    *id_p;
                    118:
                    119:     for (id_p = print_letters; id_p != NULL; id_p++)
                    120:         if (*id_p == *print_id)
                    121:             break;
                    122:
                    123:     return( (int) (id_p - print_letters) );
                    124: }
                    125:
                    126: /*
                    127:     max_print()
                    128:
                    129:         returns the size of the print list
                    130: */
                    131:
                    132: int
                    133: max_print(void)
                    134: {
                    135:     return(sizeof(print_letters) - 2); /* 1 for blank and 1 for EOS string */
                    136: }