--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/shipbitmaps.c	Sat Dec 06 05:41:29 1997 +0000
@@ -0,0 +1,863 @@
+/* $Id: shipbitmaps.c,v 1.1.1.1 1997/12/06 05:41:30 darius Exp $ */
+
+/* with this file, now the user can define and develop new ship bitmap
+   sets ('albums') more easily.
+
+     The user need only create a file in the proper directory with the
+proper name with the proper format.  The directory is specified by the
+shipBitmapPath resource in the .xtrekrc.  Its default is
+/usr/games/lib/netrek.  The name of the file is "R%d.C%d" where the
+first integer is the race number and the second is the ship class
+number.
+
+  The format of the file is: 3 4-byte integers in network byte order.
+The first is the number of views in the file (this field is currently
+ignored but should have the value 16).  The second integer is the
+width and the third is the height.  Then follows raw bitmap data.  I
+don't know what the format is, but it's basically a binary version of
+the X bitmap file format.  Translate those hex numbers to raw bytes
+and you have it.  I can tell you that each line is padded to 8 bits.
+
+*/
+
+#include <stdio.h>
+#ifndef AMIGA
+#include <sys/param.h>
+#include <netinet/in.h>
+#endif
+#include <errno.h>
+
+#ifdef m_flags
+ /* appears under HPUX */
+#undef m_flags
+#endif
+
+#include "Wlib.h"
+#include "defs.h"
+#include "struct.h"
+#include "data.h"
+#include "gameconf.h"
+
+#ifdef NOSHIPBITMAPS
+#include "bitmaps_CASB.h"
+#else
+#include "bitmaps_NEW.h"
+#ifdef HOCKEY
+#include "puck.h"
+#endif /*HOCKEY*/
+#endif
+
+static int
+get_ship_width(team, shipn)
+    int     team, shipn;
+{
+#ifndef NOSHIPBITMAPS
+    if (shipn == ATT && paradise)
+	return att_width;
+    switch (team) {
+    case 0:
+	switch (shipn) {
+#ifdef HOCKEY
+	case PUCK:
+            return puck_width;
+#endif /*HOCKEY*/
+	case SCOUT:
+	    return fed_scout_width;
+	case DESTROYER:
+	    return fed_destroyer_width;
+	case CRUISER:
+	    return fed_cruiser_width;
+	case BATTLESHIP:
+	    return fed_battleship_width;
+	case ASSAULT:
+	    return fed_assault_width;
+	case STARBASE:
+	    return fed_starbase_width;
+	case JUMPSHIP:
+	    return fed_jumpship_width;
+	case FLAGSHIP:
+	    return fed_galaxy_width;
+	case GALAXY:
+	    return fed_galaxy_width;
+	case WARBASE:
+	    return fed_warbase_width;
+	case LIGHTCRUISER:
+	    return fed_lightcruiser_width;
+	case CARRIER:
+	    return fed_carrier_height;
+	case UTILITY:
+	    return fed_utility_width;
+	case PATROL:
+	    return fed_patrol_width;
+	}
+    case 1:
+	switch (shipn) {
+#ifdef HOCKEY
+	case PUCK:
+            return puck_width;
+#endif /*HOCKEY*/
+	case SCOUT:
+	    return rom_scout_width;
+	case DESTROYER:
+	    return rom_destroyer_width;
+	case CRUISER:
+	    return rom_cruiser_width;
+	case BATTLESHIP:
+	    return rom_battleship_width;
+	case ASSAULT:
+	    return rom_assault_width;
+	case STARBASE:
+	    return rom_starbase_width;
+	case JUMPSHIP:
+	    return rom_jumpship_width;
+	case FLAGSHIP:
+	    return rom_galaxy_width;
+	case GALAXY:
+	    return rom_galaxy_width;
+	case WARBASE:
+	    return rom_warbase_width;
+	case LIGHTCRUISER:
+	    return rom_lightcruiser_width;
+	case CARRIER:
+	    return rom_carrier_height;
+	case UTILITY:
+	    return rom_utility_width;
+	case PATROL:
+	    return rom_patrol_width;
+	}
+    case 2:
+	switch (shipn) {
+#ifdef HOCKEY
+	case PUCK:
+            return puck_width;
+#endif /*HOCKEY*/
+	case SCOUT:
+	    return kli_scout_width;
+	case DESTROYER:
+	    return kli_destroyer_width;
+	case CRUISER:
+	    return kli_cruiser_width;
+	case BATTLESHIP:
+	    return kli_battleship_width;
+	case ASSAULT:
+	    return kli_assault_width;
+	case STARBASE:
+	    return kli_starbase_width;
+	case JUMPSHIP:
+	    return kli_jumpship_width;
+	case FLAGSHIP:
+	    return kli_galaxy_width;
+	case GALAXY:
+	    return kli_galaxy_width;
+	case WARBASE:
+	    return kli_warbase_width;
+	case LIGHTCRUISER:
+	    return kli_lightcruiser_width;
+	case CARRIER:
+	    return kli_carrier_height;
+	case UTILITY:
+	    return kli_utility_width;
+	case PATROL:
+	    return kli_patrol_width;
+	}
+    case 3:
+	switch (shipn) {
+#ifdef HOCKEY
+	case PUCK:
+            return puck_width;
+#endif /*HOCKEY*/
+	case SCOUT:
+	    return ori_scout_width;
+	case DESTROYER:
+	    return ori_destroyer_width;
+	case CRUISER:
+	    return ori_cruiser_width;
+	case BATTLESHIP:
+	    return ori_battleship_width;
+	case ASSAULT:
+	    return ori_assault_width;
+	case STARBASE:
+	    return ori_starbase_width;
+	case JUMPSHIP:
+	    return ori_jumpship_width;
+	case FLAGSHIP:
+	    return ori_galaxy_width;
+	case GALAXY:
+	    return ori_galaxy_width;
+	case WARBASE:
+	    return ori_warbase_width;
+	case LIGHTCRUISER:
+	    return ori_lightcruiser_width;
+	case CARRIER:
+	    return ori_carrier_height;
+	case UTILITY:
+	    return ori_utility_width;
+	case PATROL:
+	    return ori_patrol_width;
+	}
+    case -1:
+	switch (shipn) {
+#ifdef HOCKEY
+	case PUCK:
+	    return puck_width;
+#endif /*HOCKEY*/
+	case SCOUT:
+	    return ind_scout_width;
+	case DESTROYER:
+	    return ind_destroyer_width;
+	case CRUISER:
+	    return ind_cruiser_width;
+	case BATTLESHIP:
+	    return ind_battleship_width;
+	case ASSAULT:
+	    return ind_assault_width;
+	case STARBASE:
+	    return ind_starbase_width;
+	case JUMPSHIP:
+	    return ind_starbase_width;
+	case FLAGSHIP:
+	    return ind_galaxy_width;
+	case GALAXY:
+	    return ind_galaxy_width;
+	case WARBASE:
+	    return ind_starbase_width;
+	case LIGHTCRUISER:
+	    return ind_lightcruiser_width;
+	case CARRIER:
+	    return ind_carrier_height;
+	case UTILITY:
+	    return ind_utility_width;
+	case PATROL:
+	    return ind_patrol_width;
+	}
+    }
+#endif				/* NOSHIPBITMAPS */
+    return 20;
+}
+
+
+static int
+get_ship_height(team, shipn)
+    int     team, shipn;
+{
+#ifndef NOSHIPBITMAPS
+    if (shipn == ATT && paradise)
+	return att_height;
+    switch (team) {
+    case 0:
+	switch (shipn) {
+#ifdef HOCKEY
+	case PUCK:
+	    return puck_height;
+#endif /*HOCKEY*/
+	case SCOUT:
+	    return fed_scout_height;
+	case DESTROYER:
+	    return fed_destroyer_height;
+	case CRUISER:
+	    return fed_cruiser_height;
+	case BATTLESHIP:
+	    return fed_battleship_height;
+	case ASSAULT:
+	    return fed_assault_height;
+	case STARBASE:
+	    return fed_starbase_height;
+	case JUMPSHIP:
+	    return fed_jumpship_height;
+	case FLAGSHIP:
+	    return fed_galaxy_height;
+	case GALAXY:
+	    return fed_galaxy_height;
+	case WARBASE:
+	    return fed_warbase_height;
+	case LIGHTCRUISER:
+	    return fed_lightcruiser_height;
+	case CARRIER:
+	    return fed_carrier_height;
+	case UTILITY:
+	    return fed_utility_height;
+	case PATROL:
+	    return fed_patrol_height;
+	}
+    case 1:
+	switch (shipn) {
+#ifdef HOCKEY
+	case PUCK:
+	    return puck_height;
+#endif /*HOCKEY*/
+	case SCOUT:
+	    return rom_scout_height;
+	case DESTROYER:
+	    return rom_destroyer_height;
+	case CRUISER:
+	    return rom_cruiser_height;
+	case BATTLESHIP:
+	    return rom_battleship_height;
+	case ASSAULT:
+	    return rom_assault_height;
+	case STARBASE:
+	    return rom_starbase_height;
+	case JUMPSHIP:
+	    return rom_jumpship_height;
+	case FLAGSHIP:
+	    return rom_galaxy_height;
+	case GALAXY:
+	    return rom_galaxy_height;
+	case WARBASE:
+	    return rom_warbase_height;
+	case LIGHTCRUISER:
+	    return rom_lightcruiser_height;
+	case CARRIER:
+	    return rom_carrier_height;
+	case UTILITY:
+	    return rom_utility_height;
+	case PATROL:
+	    return rom_patrol_height;
+	}
+    case 2:
+	switch (shipn) {
+#ifdef HOCKEY
+	case PUCK:
+	    return puck_height;
+#endif /*HOCKEY*/
+	case SCOUT:
+	    return kli_scout_height;
+	case DESTROYER:
+	    return kli_destroyer_height;
+	case CRUISER:
+	    return kli_cruiser_height;
+	case BATTLESHIP:
+	    return kli_battleship_height;
+	case ASSAULT:
+	    return kli_assault_height;
+	case STARBASE:
+	    return kli_starbase_height;
+	case JUMPSHIP:
+	    return kli_jumpship_height;
+	case FLAGSHIP:
+	    return kli_galaxy_height;
+	case GALAXY:
+	    return kli_galaxy_height;
+	case WARBASE:
+	    return kli_warbase_height;
+	case LIGHTCRUISER:
+	    return kli_lightcruiser_height;
+	case CARRIER:
+	    return kli_carrier_height;
+	case UTILITY:
+	    return kli_utility_height;
+	case PATROL:
+	    return kli_patrol_height;
+	}
+    case 3:
+	switch (shipn) {
+#ifdef HOCKEY
+	case PUCK:
+	    return puck_height;
+#endif /*HOCKEY*/
+	case SCOUT:
+	    return ori_scout_height;
+	case DESTROYER:
+	    return ori_destroyer_height;
+	case CRUISER:
+	    return ori_cruiser_height;
+	case BATTLESHIP:
+	    return ori_battleship_height;
+	case ASSAULT:
+	    return ori_assault_height;
+	case STARBASE:
+	    return ori_starbase_height;
+	case JUMPSHIP:
+	    return ori_jumpship_height;
+	case FLAGSHIP:
+	    return ori_galaxy_height;
+	case GALAXY:
+	    return ori_galaxy_height;
+	case WARBASE:
+	    return ori_warbase_height;
+	case LIGHTCRUISER:
+	    return ori_lightcruiser_height;
+	case CARRIER:
+	    return ori_carrier_height;
+	case UTILITY:
+	    return ori_utility_height;
+	case PATROL:
+	    return ori_patrol_height;
+	}
+    case -1:
+	switch (shipn) {
+#ifdef HOCKEY
+	case PUCK:
+	    return puck_height;
+#endif /*HOCKEY*/
+	case SCOUT:
+	    return ind_scout_height;
+	case DESTROYER:
+	    return ind_destroyer_height;
+	case CRUISER:
+	    return ind_cruiser_height;
+	case BATTLESHIP:
+	    return ind_battleship_height;
+	case ASSAULT:
+	    return ind_assault_height;
+	case STARBASE:
+	    return ind_starbase_height;
+	case JUMPSHIP:
+	    return ind_starbase_height;
+	case FLAGSHIP:
+	    return ind_galaxy_height;
+	case GALAXY:
+	    return ind_galaxy_height;
+	case WARBASE:
+	    return ind_starbase_height;
+	case LIGHTCRUISER:
+	    return ind_lightcruiser_height;
+	case CARRIER:
+	    return ind_carrier_height;
+	case UTILITY:
+	    return ind_utility_height;
+	case PATROL:
+	    return ind_patrol_height;
+	}
+    }
+#endif	/* NOSHIPBITMAPS */
+    return 20;
+}
+
+static int
+get_ship_nviews(shipn)
+    int     shipn;
+{
+    if (shipn == STARBASE ||
+	shipn == WARBASE ||
+	shipn == JUMPSHIP 
+#ifdef HOCKEY
+	|| shipn == PUCK
+#endif /*HOCKEY*/
+	)
+	return 1;
+    else
+	return 16;
+}
+
+static unsigned char *
+get_ship_bits(team, shipn, view)
+    int     team, shipn;
+    int     view;
+{
+#ifndef NOSHIPBITMAPS
+    if (shipn == ATT && paradise) {
+	if (view > 0)
+	    view = 0;
+	return att_bits[view];
+    }
+#endif
+    if (view > 16)
+	view = 0;
+    switch (team) {
+    case 0:
+#ifndef NOSHIPBITMAPS
+	switch (shipn) {
+#ifdef HOCKEY
+	case PUCK:
+	    return puck_bits;
+#endif /*HOCKEY*/
+	case SCOUT:
+	    return fed_scout_bits[view];
+	case DESTROYER:
+	    return fed_destroyer_bits[view];
+	case CRUISER:
+	    return fed_cruiser_bits[view];
+	case BATTLESHIP:
+	    return fed_battleship_bits[view];
+	case ASSAULT:
+	    return fed_assault_bits[view];
+	case STARBASE:
+	    return fed_starbase_bits;
+	case JUMPSHIP:
+	    return fed_jumpship_bits;
+	case FLAGSHIP:
+	    return fed_galaxy_bits[view];
+	case GALAXY:
+	    return fed_galaxy_bits[view];
+	case WARBASE:
+	    return fed_warbase_bits;
+	case LIGHTCRUISER:
+	    return fed_lightcruiser_bits[view];
+	case CARRIER:
+	    return fed_carrier_bits[view];
+	case UTILITY:
+	    return fed_utility_bits[view];
+	case PATROL:
+	    return fed_patrol_bits[view];
+	}
+#else
+	if (get_ship_nviews(shipn) == 1)
+	    return fed_starbase_bits;
+	else
+	    return fed_cruiser_bits[view];
+#endif
+    case 1:
+#ifndef NOSHIPBITMAPS
+	switch (shipn) {
+#ifdef HOCKEY
+	case PUCK:
+	    return puck_bits;
+#endif /*HOCKEY*/
+	case SCOUT:
+	    return rom_scout_bits[view];
+	case DESTROYER:
+	    return rom_destroyer_bits[view];
+	case CRUISER:
+	    return rom_cruiser_bits[view];
+	case BATTLESHIP:
+	    return rom_battleship_bits[view];
+	case ASSAULT:
+	    return rom_assault_bits[view];
+	case STARBASE:
+	    return rom_starbase_bits;
+	case JUMPSHIP:
+	    return rom_jumpship_bits;
+	case FLAGSHIP:
+	    return rom_galaxy_bits[view];
+	case GALAXY:
+	    return rom_galaxy_bits[view];
+	case WARBASE:
+	    return rom_warbase_bits;
+	case LIGHTCRUISER:
+	    return rom_lightcruiser_bits[view];
+	case CARRIER:
+	    return rom_carrier_bits[view];
+	case UTILITY:
+	    return rom_utility_bits[view];
+	case PATROL:
+	    return rom_patrol_bits[view];
+	}
+#else
+	if (get_ship_nviews(shipn) == 1)
+	    return rom_starbase_bits;
+	else
+	    return rom_cruiser_bits[view];
+#endif
+    case 2:
+#ifndef NOSHIPBITMAPS
+	switch (shipn) {
+#ifdef HOCKEY
+	case PUCK:
+	    return puck_bits;
+#endif /*HOCKEY*/
+	case SCOUT:
+	    return kli_scout_bits[view];
+	case DESTROYER:
+	    return kli_destroyer_bits[view];
+	case CRUISER:
+	    return kli_cruiser_bits[view];
+	case BATTLESHIP:
+	    return kli_battleship_bits[view];
+	case ASSAULT:
+	    return kli_assault_bits[view];
+	case STARBASE:
+	    return kli_starbase_bits;
+	case JUMPSHIP:
+	    return kli_jumpship_bits;
+	case FLAGSHIP:
+	    return kli_galaxy_bits[view];
+	case GALAXY:
+	    return kli_galaxy_bits[view];
+	case WARBASE:
+	    return kli_warbase_bits;
+	case LIGHTCRUISER:
+	    return kli_lightcruiser_bits[view];
+	case CARRIER:
+	    return kli_carrier_bits[view];
+	case UTILITY:
+	    return kli_utility_bits[view];
+	case PATROL:
+	    return kli_patrol_bits[view];
+	}
+#else
+	if (get_ship_nviews(shipn) == 1)
+	    return kli_starbase_bits;
+	else
+	    return kli_cruiser_bits[view];
+#endif
+    case 3:
+#ifndef NOSHIPBITMAPS
+	switch (shipn) {
+#ifdef HOCKEY
+	case PUCK:
+	    return puck_bits;
+#endif /*HOCKEY*/
+	case SCOUT:
+	    return ori_scout_bits[view];
+	case DESTROYER:
+	    return ori_destroyer_bits[view];
+	case CRUISER:
+	    return ori_cruiser_bits[view];
+	case BATTLESHIP:
+	    return ori_battleship_bits[view];
+	case ASSAULT:
+	    return ori_assault_bits[view];
+	case STARBASE:
+	    return ori_starbase_bits;
+	case JUMPSHIP:
+	    return ori_jumpship_bits;
+	case FLAGSHIP:
+	    return ori_galaxy_bits[view];
+	case GALAXY:
+	    return ori_galaxy_bits[view];
+	case WARBASE:
+	    return ori_warbase_bits;
+	case LIGHTCRUISER:
+	    return ori_lightcruiser_bits[view];
+	case CARRIER:
+	    return ori_carrier_bits[view];
+	case UTILITY:
+	    return ori_utility_bits[view];
+	case PATROL:
+	    return ori_patrol_bits[view];
+	}
+#else
+	if (get_ship_nviews(shipn) == 1)
+	    return ori_starbase_bits;
+	else
+	    return ori_cruiser_bits[view];
+#endif
+    case -1:
+#ifndef NOSHIPBITMAPS
+	switch (shipn) {
+#ifdef HOCKEY
+	case PUCK:
+	    return puck_bits;
+#endif /*HOCKEY*/
+	case SCOUT:
+	    return ind_scout_bits[view];
+	case DESTROYER:
+	    return ind_destroyer_bits[view];
+	case CRUISER:
+	    return ind_cruiser_bits[view];
+	case BATTLESHIP:
+	    return ind_battleship_bits[view];
+	case ASSAULT:
+	    return ind_assault_bits[view];
+	case STARBASE:
+	    return ind_starbase_bits;
+	case JUMPSHIP:
+	    return ind_starbase_bits;
+	case FLAGSHIP:
+	    return ind_galaxy_bits[view];
+	case GALAXY:
+	    return ind_galaxy_bits[view];
+	case WARBASE:
+	    return ind_starbase_bits;
+	case LIGHTCRUISER:
+	    return ind_lightcruiser_bits[view];
+	case CARRIER:
+	    return ind_carrier_bits[view];
+	case UTILITY:
+	    return ind_utility_bits[view];
+	case PATROL:
+	    return ind_patrol_bits[view];
+	}
+#else
+	if (get_ship_nviews(shipn) == 1)
+	    return fed_starbase_bits;
+	else
+	    return fed_cruiser_bits[view];
+#endif
+    }
+    return fed_cruiser_bits[view];
+}
+
+
+/* points at the beginning of the fed ship shapes.  Independent are
+   at negative indices */
+static struct ship_shape *all_ship_shapes = 0;
+
+struct ship_shape *
+shape_of_ship(team, shipclass)
+    int     team, shipclass;
+{
+    if (team < -1 || team >= number_of_teams ||
+	shipclass < 0 || shipclass >= nshiptypes)
+	return &all_ship_shapes[-nshiptypes];
+    return &all_ship_shapes[team * nshiptypes + shipclass];
+}
+
+void
+clear_one_ship_shape(shp)
+    struct ship_shape *shp;
+{
+    int     j;
+    for (j = 0; j < shp->nviews; j++) {
+	W_FreeBitmap(shp->bmap[j]);
+    }
+    shp->nviews = 0;
+    free(shp->bmap);
+    shp->bmap = 0;
+    W_FreeBitmap(shp->shield);
+    shp->shield = 0;
+}
+
+void
+free_shipshapes()
+{
+    /* don't forget that IND offset */
+    int     race, i;
+    if (!all_ship_shapes)	/* if nothing there to begin with */
+	return;
+    for (race = -1; race < number_of_teams; race++) {
+	for (i = 0; i < nshiptypes; i++) {
+	    clear_one_ship_shape(shape_of_ship(race, i));
+	}
+    }
+    free(all_ship_shapes - nshiptypes);
+    all_ship_shapes = 0;
+}
+
+void
+slurp_ship_bitmaps()
+{
+    int     i, race, k;
+    int     width, height, size = 0;
+    int     nviews;		/* NYI */
+    unsigned char *buf = 0, *buf2;
+    char   *freeme;
+    char   *mainbitmapdir, *bitmapdir;
+    static char path[MAXPATHLEN];
+
+    if (all_ship_shapes == 0) {
+	all_ship_shapes = nshiptypes + (struct ship_shape *)
+	    malloc(sizeof(*all_ship_shapes) * (number_of_teams + 1) * nshiptypes);
+    }
+    mainbitmapdir = stringDefault("shipBitmapPath",
+#ifndef AMIGA			/* worked this way, sort of... was annoying. */
+				  "/usr/games/lib/netrek"
+#else
+				  "netrek:graphics"
+#endif				/* AMIGA */
+	);
+    mainbitmapdir = expandFilename(mainbitmapdir);
+
+    for (race = -1 /* IND */ ; race < number_of_teams; race++) {
+	freeme = NULL;
+	/* you can now have a different bitmapDir for each race [BDyess] */
+	sprintf(path, "shipBitmapPath.%d", race);
+	if ((bitmapdir = getdefault(path)) == NULL)
+	    bitmapdir = mainbitmapdir;
+	else
+	    bitmapdir = freeme = expandFilename((char *) strdup(bitmapdir));
+	for (k = 0; k < nshiptypes; k++) {
+	    struct ship_shape *curr_shape = shape_of_ship(race, k);
+	    FILE   *fp;
+	    sprintf(path, "%s/R%d.C%d", bitmapdir, race, k);
+
+	    fp = fopen(path, "r");
+	    if (fp == 0) {
+		if (errno != ENOENT) {
+		    fprintf(stderr, "Error accessing ship bitmap file %s:", path);
+		    perror("");
+		}
+		nviews = get_ship_nviews(k, 0);
+		width = get_ship_width(race, k, 0);
+		height = get_ship_height(race, k, 0);
+	    } else {
+		fread(&nviews, sizeof(nviews), 1, fp);
+		nviews = ntohl(nviews);
+		fread(&width, sizeof(width), 1, fp);
+		width = ntohl(width);
+		fread(&height, sizeof(height), 1, fp);
+		height = ntohl(height);
+		if (nviews > get_ship_nviews(k, 0))
+		    nviews = get_ship_nviews(k, 0);
+		size = (width + 7) / 8 * height;
+		buf = (unsigned char *) malloc(size);
+	    }
+
+	    curr_shape->nviews = nviews /* nviews */ ;
+	    curr_shape->width = width;
+	    curr_shape->height = height;
+	    curr_shape->shield = W_MakeShieldBitmap(width, height, w);
+
+	    curr_shape->bmap = (W_Icon *) malloc(sizeof(*curr_shape->bmap) *
+						 nviews);
+
+	    for (i = 0; i < nviews; i++) {
+		if (fp) {
+		    fread(buf, size, 1, fp);
+		    curr_shape->bmap[i] =
+			W_StoreBitmap(width, height, buf, w);
+		} else {
+		    buf2 = get_ship_bits(race, k, i);
+		    curr_shape->bmap[i] =
+			W_StoreBitmap(width, height, buf2, w);
+		}
+
+#if 0
+		/* these widths and heights are not necessarily correct */
+		if (fp)
+		    buf2 = get_ship_bits(race, k, i, blk_altbits);
+		else
+		    buf2 = get_ship_bits(race, k, i, !blk_altbits);
+
+		curr_shape->bmap[i + (blk_altbits ? 0 : nviews)] =
+		    W_StoreBitmap(width, height, buf2, w);
+#endif
+	    }
+
+	    if (fp) {
+		free(buf);
+		fclose(fp);
+	    }
+	}
+	if (freeme)
+	    free(freeme);
+    }
+}
+
+void
+replace_shipshape(race, shiptype, nviews, width, height)
+    int     race, shiptype, nviews, width, height;
+{
+    struct ship_shape *shp = shape_of_ship(race, shiptype);
+    int     i;
+
+    clear_one_ship_shape(shp);
+
+    shp->nviews = nviews;
+    shp->bmap = (W_Icon *) malloc(sizeof(*shp->bmap) * nviews);
+    shp->width = width;
+    shp->height = height;
+    shp->shield = W_MakeShieldBitmap(width, height, w);
+    for (i = 0; i < nviews; i++) {
+	/* we really should check the files again. */
+	shp->bmap[i] = W_StoreBitmap(get_ship_width(race, shiptype),
+				     get_ship_height(race, shiptype),
+				     get_ship_bits(race, shiptype, i, 0),
+				     w);
+#if 0
+	shp->bmap[i + nviews] = W_StoreBitmap(get_ship_width(race, shiptype),
+					    get_ship_height(race, shiptype),
+					get_ship_bits(race, shiptype, i, 0),
+					      w);
+#endif
+    }
+}
+
+
+void
+replace_ship_bitmap(race, shiptype, view, bits)
+    int     race, shiptype, view;
+    unsigned char *bits;
+{
+    struct ship_shape *shp = shape_of_ship(race, shiptype);
+
+    if (view >= shp->nviews) {
+	fprintf(stderr, "race %d, ship class %d: view %d out of range (0..%d)\n",
+		race, shiptype, view, shp->nviews - 1);
+	return;
+    }
+    W_FreeBitmap(shp->bmap[view]);
+    /* store the bitmaps into the auxiliary view */
+    shp->bmap[view] = W_StoreBitmap(shp->width, shp->height, bits, w);
+}