[ViewVC] Diff of: cvs/cf.schmorp.de/server/common/arch.C

Comparing cf.schmorp.de/server/common/arch.C (file contents):
Revision 1.14 by root, Fri Sep 8 17:14:07 2006 UTC vs.
Revision 1.16 by root, Sun Sep 10 16:00:23 2006 UTC

 /*
  * static char *rcsid_arch_c =
- *   "$Id: arch.C,v 1.14 2006/09/08 17:14:07 root Exp $";
+ *   "$Id: arch.C,v 1.16 2006/09/10 16:00:23 root Exp $";
  */
 /*
     CrossFire, A Multiplayer game for X-windows
 #include <loader.h>
 /* IF set, does a little timing on the archetype load. */
 #define TIME_ARCH_LOAD 0
-static void add_arch (archetype * at);
+static void add_arch (archetype *at);
 static archetype *arch_table[ARCHTABLE];
 int arch_cmp = 0;               /* How many strcmp's */
 int arch_search = 0;            /* How many searches */
 int arch_init;                  /* True if doing arch initialization */
  * MSW 2003-04-29
  */
 #if USE_UNORDERED_MAP
 // the hashtable
-typedef std::tr1::unordered_map<size_t, archetype *> HT;
+typedef
+  std::tr1::unordered_map <
+size_t, archetype *>
+  HT;
-static HT ht;
+static
+  HT
+  ht;
 #endif
 /**
  * GROS -  This function retrieves an archetype given the name that appears
  * during the game (for example, "writing pen" instead of "stylus").
  * - the archetype found or null if nothing was found.
  */
 archetype *
 find_archetype_by_object_name (const char *name)
 {
-  archetype *at;
+  archetype *
+    at;
   if (name == NULL)
     return (archetype *) NULL;
   for (at = first_archetype; at != NULL; at = at->next)
  * except that it considers only items of the given type.
  */
 archetype *
 find_archetype_by_object_type_name (int type, const char *name)
 {
-  archetype *at;
+  archetype *
+    at;
   if (name == NULL)
     return NULL;
   for (at = first_archetype; at != NULL; at = at->next)
   * If count is 1, make a quick check on the name.
   * IF count is >1, we need to make plural name.  Return if match.
   * Last, make a check on the full name.
   */
 int
-item_matched_string (object * pl, object * op, const char *name)
+item_matched_string (object *pl, object *op, const char *name)
 {
   char *
     cp,
     local_name[MAX_BUF];
   int
     count,
     retval = 0;
   strcpy (local_name, name);    /* strtok is destructive to name */
   for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))
     {
       while (cp[0] == ' ')
     return;
   arch_init = 1;
   load_archetypes ();
   arch_init = 0;
   empty_archetype = find_archetype ("empty_archetype");
 /*  init_blocksview();*/
 }
 /*
  * Stores debug-information about how efficient the hashtable
  * used for archetypes has been in the static errmsg array.
  */
 void
-arch_info (object * op)
+arch_info (object *op)
 {
   sprintf (errmsg, "%d searches and %d strcmp()'s", arch_search, arch_cmp);
   new_draw_info (NDI_BLACK, 0, op, errmsg);
 }
  */
 void
 init_archetable (void)
 {
-  archetype *at;
+  archetype *
+    at;
   LOG (llevDebug, " Setting up archetable...\n");
   for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
     add_arch (at);
 /*
  * Dumps an archetype to debug-level output.
  */
 void
-dump_arch (archetype * at)
+dump_arch (archetype *at)
 {
   dump_object (&at->clone);
 }
 /*
 void
 dump_all_archetypes (void)
 {
   archetype *
     at;
   for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
     {
       dump_arch (at);
       fprintf (logfile, "%s\n", errmsg);
     }
       else
         next = at->next;
       delete
         at;
       i++;
     }
   LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
 }
 archetype::archetype ()
 {
-  clear_object (&clone);  /* to initial state other also */
+  clear_object (&clone);        /* to initial state other also */
-  CLEAR_FLAG (&clone, FLAG_FREED);        /* This shouldn't matter, since copy_object() */
+  CLEAR_FLAG (&clone, FLAG_FREED);      /* This shouldn't matter, since copy_object() */
-  SET_FLAG (&clone, FLAG_REMOVED);        /* doesn't copy these flags... */
+  SET_FLAG (&clone, FLAG_REMOVED);      /* doesn't copy these flags... */
 }
 archetype::~archetype ()
 {
 }
  * of archetype-structures.
  */
 void
 first_arch_pass (object_thawer & fp)
 {
+  archetype *
+  at, *
-  archetype *at, *head = NULL, *last_more = NULL;
+    head = NULL, *last_more = NULL;
   at->clone.arch = first_archetype = at = new archetype;
   while (int i = load_object (fp, &at->clone, 0))
     {
        */
       memcpy (&at->clone.body_used, &at->clone.body_info, sizeof (at->clone.body_info));
       switch (i)
         {
-        case LL_NORMAL: /* A new archetype, just link it with the previous */
+            case LL_NORMAL:    /* A new archetype, just link it with the previous */
-          if (last_more != NULL)
+              if (last_more != NULL)
-            last_more->next = at;
+                last_more->next = at;
-          if (head != NULL)
+              if (head != NULL)
-            head->next = at;
+                head->next = at;
-          head = last_more = at;
+              head = last_more = at;
 #if 0
-          if (!op->type)
+              if (!op->type)
-            LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name);
+                LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name);
 #endif
-          at->tail_x = 0;
+              at->tail_x = 0;
-          at->tail_y = 0;
+              at->tail_y = 0;
-          break;
+              break;
-        case LL_MORE:           /* Another part of the previous archetype, link it correctly */
+            case LL_MORE:      /* Another part of the previous archetype, link it correctly */
-          at->head = head;
+              at->head = head;
-          at->clone.head = &head->clone;
+              at->clone.head = &head->clone;
-          if (last_more != NULL)
+              if (last_more != NULL)
-            {
+                {
-              last_more->more = at;
+                  last_more->more = at;
-              last_more->clone.more = &at->clone;
+                  last_more->clone.more = &at->clone;
-            }
+                }
-          last_more = at;
+              last_more = at;
-          /* If this multipart image is still composed of individual small
+              /* If this multipart image is still composed of individual small
-           * images, don't set the tail_.. values.  We can't use them anyways,
+               * images, don't set the tail_.. values.  We can't use them anyways,
-           * and setting these to zero makes the map sending to the client much
+               * and setting these to zero makes the map sending to the client much
-           * easier as just looking at the head, we know what to do.
+               * easier as just looking at the head, we know what to do.
-           */
+               */
-          if (at->clone.face != head->clone.face)
+              if (at->clone.face != head->clone.face)
-            {
+                {
-              head->tail_x = 0;
+                  head->tail_x = 0;
-              head->tail_y = 0;
+                  head->tail_y = 0;
-            }
+                }
-          else
+              else
-            {
+                {
-              if (at->clone.x > head->tail_x)
+                  if (at->clone.x > head->tail_x)
-                head->tail_x = at->clone.x;
+                    head->tail_x = at->clone.x;
-              if (at->clone.y > head->tail_y)
+                  if (at->clone.y > head->tail_y)
-                head->tail_y = at->clone.y;
+                    head->tail_y = at->clone.y;
-            }
+                }
-          break;
+              break;
         }
       at = new archetype;
       at->clone.arch = at;
     }
   delete at;
 }
  */
 void
 second_arch_pass (object_thawer & thawer)
 {
+  char
+  buf[MAX_BUF], *
-  char buf[MAX_BUF], *variable = buf, *argument, *cp;
+    variable = buf, *argument, *cp;
+  archetype *
-  archetype *at = NULL, *other;
+    at = NULL, *other;
   while (fgets (buf, MAX_BUF, thawer) != NULL)
     {
       if (*buf == '#')
         continue;
         {
           if (at != NULL)
             {
               treasurelist *
                 tl = find_treasurelist (argument);
               if (tl == NULL)
                 LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);
               else
                 at->clone.randomitems = tl;
             }
 void
 check_generators (void)
 {
   archetype *
     at;
   for (at = first_archetype; at != NULL; at = at->next)
     if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)
       LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);
 }
 #endif
 void
 load_archetypes (void)
 {
   char
     filename[MAX_BUF];
 #if TIME_ARCH_LOAD
   struct timeval
     tv1,
     tv2;
 #endif
  * Creates and returns a new object which is a copy of the given archetype.
  * This function returns NULL on failure.
  */
 object *
-arch_to_object (archetype * at)
+arch_to_object (archetype *at)
 {
   object *
     op;
   if (at == NULL)
     {
       if (warn_archetypes)
         LOG (llevError, "Couldn't find archetype.\n");
       return NULL;
     }
   op = get_object ();
   copy_object (&at->clone, op);
+  op->arch = at;
   op->instantiate ();
-  op->arch = at;
   return op;
 }
 /*
  * Creates an object.  This function is called by get_archetype()
  */
 object *
 create_singularity (const char *name)
 {
-  object *op;
+  object *
+    op;
+  char
-  char buf[MAX_BUF];
+    buf[MAX_BUF];
   sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
   op = get_object ();
   op->name = op->name_pl = buf;
   SET_FLAG (op, FLAG_NO_PICK);
   return op;
  */
 object *
 get_archetype (const char *name)
 {
-  archetype *at;
+  archetype *
+    at;
   at = find_archetype (name);
   if (at == NULL)
     return create_singularity (name);
   return arch_to_object (at);
 }
 /*
  * Hash-function used by the arch-hashtable.
  */
 unsigned long
 hasharch (const char *str, int tablesize)
 {
-  unsigned long hash = 0;
+  unsigned long
+    hash = 0;
-  unsigned int i = 0;
+  unsigned int
+    i = 0;
-  const char *p;
+  const char *
+    p;
   /* use the one-at-a-time hash function, which supposedly is
    * better than the djb2-like one used by perl5.005, but
    * certainly is better then the bug used here before.
    * see http://burtleburtle.net/bob/hash/doobs.html
   name = shstr::find (name);
   if (!name)
     return 0;
-  HT::const_iterator i = ht.find ((size_t)name);
+  HT::const_iterator i = ht.find ((size_t) name);
   if (i == ht.end ())
     return 0;
   else
     return i->second;
 #endif
-  archetype *at;
+  archetype *
+    at;
-  unsigned long index;
+  unsigned long
+    index;
   if (name == NULL)
     return (archetype *) NULL;
   index = hasharch (name, ARCHTABLE);
 static void
 add_arch (archetype *at)
 {
 #if USE_UNORDERED_MAP
-  ht.insert (std::make_pair ((size_t)(const char *)at->name, at));
+  ht.insert (std::make_pair ((size_t) (const char *) at->name, at));
 #endif
+  int
-  int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index;
+    index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index;
   for (;;)
     {
       if (arch_table[index] == NULL)
         {
 /*
  * member: make instance from class
  */
 object *
-object_create_arch (archetype * at)
+object_create_arch (archetype *at)
 {
   object *
   op, *
     prev = NULL, *head = NULL;

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing cf.schmorp.de/server/common/arch.C (file contents): Revision 1.14 by root, Fri Sep 8 17:14:07 2006 UTC vs. Revision 1.16 by root, Sun Sep 10 16:00:23 2006 UTC

Diff Legend

Comparing cf.schmorp.de/server/common/arch.C (file contents):
Revision 1.14 by root, Fri Sep 8 17:14:07 2006 UTC vs.
Revision 1.16 by root, Sun Sep 10 16:00:23 2006 UTC