Markus Armbruster
90de24d038
We've been using Phil Lapsley's A* library to find land paths since Chainsaw 3. It's reasonably general, and uses relatively complex data structures to conserve memory. Unfortunately, it occasionally leaks a bit of memory (see commit86a187c0), and is unsafe for long paths (see commite30dc417). To speed it up, v4.2.2 added two caches: the neighbor cache and the path cache. The neighbor cache attempts to speed up lookup of adjacent sectors. It allocates 6 pointers per sector for that. In my tests, this is more, sometimes much more memory than the A* library uses. See commit7edcd3eaon branch old-astar for its (modest) performance impact. The path cache attempts to speed up the update's computation of distribution path costs. There, A* runs many times. Each run finds many shortest paths, of which only the one asked for is returned. The path cache saves all of them, so that when one of them is needed later, we can get it from the path cache instead of running A* again. The cache is quite effective, but a bit of a memory hog (see commita02d3e9fon branch old-astar). I'm pretty sure I could speed up the path cache even more by reducing its excessive memory consumption --- why store paths when we're only interested in cost? But that's a bad idea, because the path cache itself is a bad idea. Finding many shortest paths from the same source has a well-known efficient and simple solution: Dijkstra's algorithm[*]. A* is an extension of Dijkstra's algorithm. It computes a *single* path faster than Dijkstra's. But it can't compute *many* shortest paths from the same source as efficiently as Dijkstra's. I could try to modify Phil's code to make it compute many shortest paths from the same source efficiently: turn A* into its special case Dijkstra's algorithm (at least for distribution path assembly), then generalize it to the many paths problem. Of course, I'd also have to track down its memory allocation bugs, and make it safe for long paths. Instead, I'm replacing it. This commit is the first step: a rather unsophisticated implementation of Dijkstra's algorithm specialized to hex maps. It works with simple data structures: an array for the hex map (16 bytes per sector), and a binary heap for the priority queue (16 bytes per sector, most of it never touched). This is more memory than Phil's A* uses, but much less than Phil's A* with v4.2.2's caches. [*] To fully exploit Dijkstra's "many paths" capability, we need to compute distribution paths in distribution center order.
105 lines
3.3 KiB
C
105 lines
3.3 KiB
C
/*
|
|
* Empire - A multi-player, client/server Internet based war game.
|
|
* Copyright (C) 1986-2011, Dave Pare, Jeff Bailey, Thomas Ruschak,
|
|
* Ken Stevens, Steve McClure, Markus Armbruster
|
|
*
|
|
* Empire is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* ---
|
|
*
|
|
* 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.
|
|
*
|
|
* ---
|
|
*
|
|
* path.h: Definitions for directions, paths, etc.
|
|
*
|
|
* Known contributors to this file:
|
|
* Markus Armbruster, 2005-2011
|
|
*/
|
|
|
|
#ifndef PATH_H
|
|
#define PATH_H
|
|
|
|
#include <stddef.h>
|
|
#include "types.h"
|
|
|
|
/* direction indices */
|
|
#define DIR_STOP 0
|
|
#define DIR_UR 1
|
|
#define DIR_R 2
|
|
#define DIR_DR 3
|
|
#define DIR_DL 4
|
|
#define DIR_L 5
|
|
#define DIR_UL 6
|
|
#define DIR_VIEW 7
|
|
#define DIR_MAP 8
|
|
#define DIR_FIRST 1
|
|
#define DIR_LAST 6
|
|
|
|
#define MOB_MOVE 0
|
|
#define MOB_MARCH 1
|
|
#define MOB_RAIL 2
|
|
|
|
enum p_mode { /* How to find path to destination */
|
|
P_NONE, /* don't */
|
|
P_FLYING, /* use BestAirPath() */
|
|
P_SAILING /* use BestShipPath() */
|
|
};
|
|
|
|
/* src/lib/global/dir.c */
|
|
extern signed char dirindex['z'-'a'+1];
|
|
extern int diroff[DIR_MAP+1][2];
|
|
extern char dirch[DIR_MAP+2];
|
|
extern char *routech[DIR_LAST+1];
|
|
|
|
/* src/lib/common/bestpath.c */
|
|
extern char *bestownedpath(char *, char *, int, int, int, int, int);
|
|
|
|
/* src/lib/common/findpath.c */
|
|
extern void path_find_from(coord, coord, natid, int);
|
|
extern double path_find_to(coord, coord);
|
|
extern double path_find(coord, coord, coord, coord, natid, int);
|
|
extern size_t path_find_route(char *, size_t, coord, coord, coord, coord);
|
|
|
|
/* src/lib/common/path.c */
|
|
extern void bp_enable_cachepath(void);
|
|
extern void bp_disable_cachepath(void);
|
|
extern void bp_clear_cachepath(void);
|
|
extern char *BestDistPath(char *, struct sctstr *, struct sctstr *,
|
|
double *);
|
|
extern char *BestLandPath(char *, struct sctstr *, struct sctstr *,
|
|
double *, int);
|
|
extern char *BestShipPath(char *, int, int, int, int, int);
|
|
extern char *BestAirPath(char *, int, int, int, int);
|
|
extern double pathcost(struct sctstr *, char *, int);
|
|
|
|
/* src/lib/subs/paths.c */
|
|
extern char *getpath(char *, char *, coord, coord, int, int, enum p_mode);
|
|
extern double fcost(struct sctstr *, natid);
|
|
extern double ncost(struct sctstr *, natid);
|
|
extern double pathtoxy(char *, coord *, coord *,
|
|
double (*)(struct sctstr *, natid));
|
|
extern int chkdir(char, int, int);
|
|
extern int diridx(char);
|
|
extern void direrr(char *, char *, char *);
|
|
extern void pathrange(coord, coord, char *, int, struct range *);
|
|
|
|
extern double sector_mcost(struct sctstr *, int);
|
|
extern double speed_factor(double, int);
|
|
|
|
#define MAX_PATH_LEN 1024
|
|
|
|
#endif
|