]> git.cameronkatri.com Git - bsdgames-darwin.git/blobdiff - battlestar/room.c
- avoid multipling a boolean value, use &&.
[bsdgames-darwin.git] / battlestar / room.c
index 3ff7d5867ac601e9dbdf449de4b268b85674bd37..61defbbbdbf889c3a854f5b75bfd81189fe99a26 100644 (file)
@@ -1,6 +1,8 @@
+/*     $NetBSD: room.c,v 1.13 2011/05/23 22:44:18 joerg Exp $  */
+
 /*
- * Copyright (c) 1983 Regents of the University of California.
- * All rights reserved.
+ * Copyright (c) 1983, 1993
+ *     The Regents of the University of California.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *     This product includes software developed by the University of
- *     California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
+ * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
  *
  * SUCH DAMAGE.
  */
 
+#include <sys/cdefs.h>
 #ifndef lint
-/*static char sccsid[] = "from: @(#)room.c     5.3 (Berkeley) 6/1/90";*/
-static char rcsid[] = "$Id: room.c,v 1.2 1993/08/01 18:55:54 mycroft Exp $";
-#endif /* not lint */
+#if 0
+static char sccsid[] = "@(#)room.c     8.2 (Berkeley) 4/28/95";
+#else
+__RCSID("$NetBSD: room.c,v 1.13 2011/05/23 22:44:18 joerg Exp $");
+#endif
+#endif                         /* not lint */
 
-#include "externs.h"
+#include "extern.h"
 
-writedes()
+void
+writedes(void)
 {
-       int compass;
-       register char *p;
-       register c;
+       int     compass;
+       const char   *p;
+       int     c;
 
        printf("\n\t%s\n", location[position].name);
-       if (beenthere[position] < 3) {
+       if (beenthere[position] < ROOMDESC || verbose) {
                compass = NORTH;
-               for (p = location[position].desc; c = *p++;)
-                       if (c != '-' && c != '*' && c != '+')
-                               putchar(c);
-                       else {
+               for (p = location[position].desc; (c = *p++) != 0;)
+                       if (c != '-' && c != '*' && c != '+') {
+                               if (c == '=')
+                                       putchar('-');
+                               else
+                                       putchar(c);
+                       } else {
                                if (c != '*')
-                                       printf(truedirec(compass, c));
+                                       printf("%s", truedirec(compass, c));
                                compass++;
                        }
        }
 }
 
-printobjs()
+void
+printobjs(void)
 {
-       register unsigned int *p = location[position].objects;
-       register n;
+       unsigned int *p = location[position].objects;
+       int     n;
 
        printf("\n");
        for (n = 0; n < NUMOFOBJECTS; n++)
@@ -69,159 +76,162 @@ printobjs()
                        puts(objdes[n]);
 }
 
-whichway(here)
-struct room here;
+void
+whichway(struct room here)
 {
-       switch(direction) {
-
-               case NORTH:
-                       left = here.west;
-                       right = here.east;
-                       ahead = here.north;
-                       back = here.south;
-                       break;
-               
-               case SOUTH:
-                       left = here.east;
-                       right = here.west;
-                       ahead = here.south;
-                       back = here.north;
-                       break;
-
-               case EAST:
-                       left = here.north;
-                       right = here.south;
-                       ahead = here.east;
-                       back = here.west;
-                       break;
-
-               case WEST:
-                       left = here.south;
-                       right = here.north;
-                       ahead = here.west;
-                       back = here.east;
-                       break;
+       switch (direction) {
+
+       case NORTH:
+               left = here.west;
+               right = here.east;
+               ahead = here.north;
+               back = here.south;
+               break;
+
+       case SOUTH:
+               left = here.east;
+               right = here.west;
+               ahead = here.south;
+               back = here.north;
+               break;
+
+       case EAST:
+               left = here.north;
+               right = here.south;
+               ahead = here.east;
+               back = here.west;
+               break;
+
+       case WEST:
+               left = here.south;
+               right = here.north;
+               ahead = here.west;
+               back = here.east;
+               break;
 
        }
 }
 
-char *
-truedirec(way, option)
-int way;
-char option;
+const char *
+truedirec(int way, int option)
 {
-       switch(way) {
+       switch (way) {
 
+       case NORTH:
+               switch (direction) {
                case NORTH:
-                       switch(direction) {
-                               case NORTH:
-                                       return("ahead");
-                               case SOUTH:
-                                       return(option == '+' ? "behind you" : "back");
-                               case EAST:
-                                       return("left");
-                               case WEST:
-                                       return("right");
-                       }
+                       return ("ahead");
+               case SOUTH:
+                       return (option == '+' ? "behind you" :
+                           "back");
+               case EAST:
+                       return ("left");
+               case WEST:
+                       return ("right");
+               }
 
+       case SOUTH:
+               switch (direction) {
+               case NORTH:
+                       return (option == '+' ? "behind you" :
+                           "back");
                case SOUTH:
-                       switch(direction) {
-                               case NORTH:
-                                       return(option == '+' ? "behind you" : "back");
-                               case SOUTH:
-                                       return("ahead");
-                               case EAST:
-                                       return("right");
-                               case WEST:
-                                       return("left");
-                       }
+                       return ("ahead");
+               case EAST:
+                       return ("right");
+               case WEST:
+                       return ("left");
+               }
 
+       case EAST:
+               switch (direction) {
+               case NORTH:
+                       return ("right");
+               case SOUTH:
+                       return ("left");
                case EAST:
-                       switch(direction) {
-                               case NORTH:
-                                       return("right");
-                               case SOUTH:
-                                       return("left");
-                               case EAST:
-                                       return("ahead");
-                               case WEST:      
-                                       return(option == '+' ? "behind you" : "back");
-                       }
+                       return ("ahead");
+               case WEST:
+                       return (option == '+' ? "behind you" :
+                           "back");
+               }
 
+       case WEST:
+               switch (direction) {
+               case NORTH:
+                       return ("left");
+               case SOUTH:
+                       return ("right");
+               case EAST:
+                       return (option == '+' ? "behind you" :
+                           "back");
                case WEST:
-                       switch(direction) {
-                               case NORTH:
-                                       return("left");
-                               case SOUTH:
-                                       return("right");
-                               case EAST:
-                                       return(option == '+' ? "behind you" : "back");
-                               case WEST:
-                                       return("ahead");
-                       }
+                       return ("ahead");
+               }
 
-               default:
-                       printf("Error: room %d.  More than four directions wanted.", position);
-                       return("!!");
-      }
+       default:
+               printf("Error: room %d.  More than four directions wanted.", 
+                   position);
+               return ("!!");
+       }
 }
 
-newway(thisway)
-int thisway;
+void
+newway(int thisway)
 {
-       switch(direction){
+       switch (direction) {
 
-               case NORTH:
-                       switch(thisway){
-                               case LEFT:
-                                       direction = WEST;
-                                       break;
-                               case RIGHT:
-                                       direction = EAST;
-                                       break;
-                               case BACK:
-                                       direction = SOUTH;
-                                       break;
-                       }
+       case NORTH:
+               switch (thisway) {
+               case LEFT:
+                       direction = WEST;
                        break;
-               case SOUTH:
-                       switch(thisway){
-                               case LEFT:
-                                       direction = EAST;
-                                       break;
-                               case RIGHT:
-                                       direction = WEST;
-                                       break;
-                               case BACK:
-                                       direction = NORTH;
-                                       break;
-                       }
+               case RIGHT:
+                       direction = EAST;
                        break;
-               case EAST:
-                       switch(thisway){
-                               case LEFT:
-                                       direction = NORTH;
-                                       break;
-                               case RIGHT:
-                                       direction = SOUTH;
-                                       break;
-                               case BACK:
-                                       direction = WEST;
-                                       break;
-                       }
+               case BACK:
+                       direction = SOUTH;
                        break;
-               case WEST:
-                       switch(thisway){
-                               case LEFT:
-                                       direction = SOUTH;
-                                       break;
-                               case RIGHT:
-                                       direction = NORTH;
-                                       break;
-                               case BACK:
-                                       direction = EAST;
-                                       break;
-                       }
+               }
+               break;
+       case SOUTH:
+               switch (thisway) {
+               case LEFT:
+                       direction = EAST;
+                       break;
+               case RIGHT:
+                       direction = WEST;
+                       break;
+               case BACK:
+                       direction = NORTH;
+                       break;
+               }
+               break;
+       case EAST:
+               switch (thisway) {
+               case LEFT:
+                       direction = NORTH;
+                       break;
+               case RIGHT:
+                       direction = SOUTH;
                        break;
-      }
+               case BACK:
+                       direction = WEST;
+                       break;
+               }
+               break;
+       case WEST:
+               switch (thisway) {
+               case LEFT:
+                       direction = SOUTH;
+                       break;
+               case RIGHT:
+                       direction = NORTH;
+                       break;
+               case BACK:
+                       direction = EAST;
+                       break;
+               }
+               break;
+       }
 }