/*
* Empire - A multi-player, client/server Internet based war game.
- * Copyright (C) 1986-2000, Dave Pare, Jeff Bailey, Thomas Ruschak,
+ * Copyright (C) 1986-2008, Dave Pare, Jeff Bailey, Thomas Ruschak,
* Ken Stevens, Steve McClure
*
* This program is free software; you can redistribute it and/or modify
*
* ---
*
- * See the "LEGAL", "LICENSE", "CREDITS" and "README" files for all the
- * related information and legal notices. It is expected that any future
- * projects/authors will amend these files as needed.
+ * See files README, COPYING and CREDITS in the root of the source
+ * tree for related information and legal notices. It is expected
+ * that future projects/authors will amend these files as needed.
*
* ---
*
* Steve McClure, 1998
*/
+#include <config.h>
+
+#include <stdlib.h>
+#include <string.h>
#include "as.h"
#include "optlist.h"
static int as_cachepath_on = 0; /* Default to off */
void
-as_enable_cachepath()
+as_enable_cachepath(void)
{
as_cachepath_on = 1;
}
void
-as_disable_cachepath()
+as_disable_cachepath(void)
{
as_cachepath_on = 0;
}
/* Note we will only allocate this once. Afterwards, we just keep
* zeroing it since it's rather small and we don't need to re-allocate
* each time. */
- if (fromhead == (struct as_frompath **)0) {
+ if (fromhead == NULL) {
fromhead = calloc(1, sizeof(struct as_frompath *) * WORLD_Y);
- if (fromhead == (struct as_frompath **)0)
+ if (fromhead == NULL)
return;
}
}
} else {
/* We must make a new one of these */
- from = (struct as_frompath *)malloc(sizeof(struct as_frompath));
+ from = malloc(sizeof(struct as_frompath));
if (from == NULL)
return;
/* And set some stuff */
from->x = adp->from.x;
/* Here we malloc a whole bunch of tolist pointers. */
- from->tolist = (struct as_topath **)calloc(1,
- sizeof(struct as_topath
- *) * WORLD_Y);
+ from->tolist = calloc(1, sizeof(struct as_topath *) * WORLD_Y);
/* Now, add from to the global list */
from->next = fromhead[adp->from.y];
fromhead[adp->from.y] = from;
}
if (!to) {
/* We must make a new one */
- to = (struct as_topath *)malloc(sizeof(struct as_topath));
+ to = malloc(sizeof(struct as_topath));
/* We can't, sorry */
if (to == NULL)
return;
}
void
-as_clear_cachepath()
+as_clear_cachepath(void)
{
struct as_frompath *from, *from2;
struct as_topath *to, *to2;
int i, j;
/* Cache not used yet :) */
- if (fromhead == (struct as_frompath **)0)
+ if (fromhead == NULL)
return;
for (j = 0; j < WORLD_Y; j++) {
/* Free this path */
as_free_path(to->path);
/* Free this node */
- free((s_char *)to);
+ free(to);
}
}
/* Now, free the list of lists */
- free((s_char *)from->tolist);
+ free(from->tolist);
/* Save the next pointer */
from2 = from->next;
/* now, free this from node */
- free((s_char *)from);
+ free(from);
}
}
/* Note we don't free the fromhead here, we just zero it. That way,
we can use it next time without mallocing int */
- bzero((s_char *)fromhead, (sizeof(struct as_frompath *) * WORLD_Y));
+ memset(fromhead, 0, (sizeof(struct as_frompath *) * WORLD_Y));
}
struct as_path *
/* Is the cache on? if not, return NULL */
if (as_cachepath_on == 0)
- return (NULL);
+ return NULL;
/* Do we have any cached? */
- if (fromhead == (struct as_frompath **)0)
- return (NULL);
+ if (fromhead == NULL)
+ return NULL;
/* Yes! */
for (from = fromhead[fy]; from; from = from->next) {
if (from->x == fx) {
for (to = from->tolist[ty]; to; to = to->next) {
if (to->x == tx)
- return (to->path);
+ return to->path;
}
}
}
- return (NULL);
+ return NULL;
}