server/common/image.C

/*
 * CrossFire, A Multiplayer game
 * 
 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
 * Copyright (C) 2002 Mark Wedel & Crossfire Development Team
 * Copyright (C) 1992 Frank Tore Johansen
 * 
 * This program 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 2 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, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * The maintainer of this code can be reached at <crossfire@schmorp.de>
 */


#include <global.h>
#include <stdio.h>

#include "face.h"
#include "crc.h"

faceidx blank_face, empty_face;

facehash_t facehash;
std::vector<faceinfo> faces;
std::vector<facedata> face32, face64;

/**
 * id is the face to smooth, smooth is the 16x2 face used to smooth id.
 */
struct smoothing : zero_initialised
{
  uint16 id;
  uint16 smooth;
};

/**
 * Contains all defined smoothing entries. smooth is an array of nrofsmooth
 * entries. It is sorted by smooth[].id.
 */
static struct smoothing *smooth = NULL;
int nrofsmooth = 0;

/* the only thing this table is used for now is to
 * translate the colorname in the magicmap field of the
 * face into a numeric index that is then sent to the
 * client for magic map commands.  The order of this table
 * must match that of the NDI colors in include/newclient.h.
 */
static const char *const colorname[] = {
  "black",                      /* 0  */
  "white",                      /* 1  */
  "blue",                       /* 2  */
  "red",                        /* 3  */
  "orange",                     /* 4  */
  "light_blue",                 /* 5  */
  "dark_orange",                /* 6  */
  "green",                      /* 7  */
  "light_green",                /* 8  */
  "grey",                       /* 9  */
  "brown",                      /* 10 */
  "yellow",                     /* 11 */
  "khaki"                       /* 12 */
};

static int
compar_smooth (const struct smoothing *a, const struct smoothing *b)
{
  if (a->id < b->id)
    return -1;
  if (b->id < a->id)
    return 1;
  return 0;
}

/*
 * Returns the matching color in the coloralias if found,
 * 0 otherwise.  Note that 0 will actually be black, so there is no
 * way the calling function can tell if an error occurred or not
 */
static uint8
find_color (const char *name)
{
  uint8 i;

  for (i = 0; i < sizeof (colorname) / sizeof (*colorname); i++)
    if (!strcmp (name, colorname[i]))
      return i;

  LOG (llevError, "Unknown color: %s\n", name);
  return 0;
}

int
face_find (const char *name, int defidx)
{
  facehash_t::iterator i = facehash.find (name);

  return i == facehash.end ()
         ? defidx : i->second;
}

facedata *
face_data (int idx, int faceset)
{
  return &(faceset ? face64 : face32)[idx];
}

/* Reads the smooth file to know how to smooth datas.
 * the smooth file if made of 2 elements lines.
 * lines starting with # are comment
 * the first element of line is face to smooth
 * the next element is the 16x2 faces picture
 * used for smoothing
 */
int
ReadSmooth (void)
{
  char buf[MAX_BUF], *p, *q;
  FILE *fp;
  int smoothcount = 0;

  sprintf (buf, "%s/smooth", settings.datadir);
  LOG (llevDebug, "Reading smooth from %s...\n", buf);
  if ((fp = fopen (buf, "r")) == NULL)
    {
      LOG (llevError, "Cannot open smooth file %s: %s\n", strerror (errno));
      exit (-1);
    }

  /* First count how many smooth we have, so we can allocate correctly */
  while (fgets (buf, MAX_BUF, fp) != NULL)
    if (buf[0] != '#' && buf[0] != '\n')
      smoothcount++;
  rewind (fp);

  smooth = new smoothing[smoothcount];

  while (nrofsmooth < smoothcount && fgets (buf, MAX_BUF, fp) != NULL)
    {
      if (*buf == '#')
        continue;
      p = strchr (buf, ' ');
      if (!p)
        continue;
      *p = '\0';
      q = buf;
      smooth[nrofsmooth].id = face_find (q);
      q = p + 1;
      smooth[nrofsmooth].smooth = face_find (q);
      nrofsmooth++;
    }
  fclose (fp);

  LOG (llevDebug, "done (got %d smooth entries)\n", nrofsmooth);
  qsort (smooth, nrofsmooth, sizeof (struct smoothing), (int (*)(const void *, const void *)) compar_smooth);
  return nrofsmooth;
}

/**
 * Find the smooth face for a given face.
 *
 * @param face the face to find the smoothing face for
 *
 * @param smoothed return value: set to smooth face
 *
 * @return 1=smooth face found, 0=no smooth face found
 */
int
FindSmooth (uint16 face, uint16 * smoothed)
{
  struct smoothing *bp, tmp;

  tmp.id = face;
  bp = (struct smoothing *) bsearch
    (&tmp, smooth, nrofsmooth, sizeof (struct smoothing), (int (*)(const void *, const void *)) compar_smooth);
  (*smoothed) = 0;
  if (bp)
    (*smoothed) = bp->smooth;
  return bp ? 1 : 0;
}

Revision:	1.19
Committed:	Sun Mar 11 02:12:44 2007 UTC (19 years, 7 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.18:	+16 -274 lines
Log Message:	- MAJOR CHANGE - you now need to use cfutil to install arches. - former bigfaces are broken in the server - bigfaces are no longer supported. at all. - use face numbers instead of pointers * saves lotsa space * saves lotsa indirections * saves lots(?) cpu cycles - completely rewrote face handling - faces can now be added at runtime - reload will add new faces - this does not apply to animations - use a hastable instead of binary search (faster) for faces - face caching is broken - facesets are gone - server always reports MAX_FACES to any client who asks
#	User	Rev	Content
1	elmex	1.1	/*
2	root	1.13	* CrossFire, A Multiplayer game
3	pippijn	1.12	*
4			* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
5			* Copyright (C) 2002 Mark Wedel & Crossfire Development Team
6			* Copyright (C) 1992 Frank Tore Johansen
7			*
8			* This program is free software; you can redistribute it and/or modify
9			* it under the terms of the GNU General Public License as published by
10			* the Free Software Foundation; either version 2 of the License, or
11			* (at your option) any later version.
12			*
13			* This program is distributed in the hope that it will be useful,
14			* but WITHOUT ANY WARRANTY; without even the implied warranty of
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16			* GNU General Public License for more details.
17			*
18			* You should have received a copy of the GNU General Public License
19			* along with this program; if not, write to the Free Software
20			* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21			*
22			* The maintainer of this code can be reached at <crossfire@schmorp.de>
23			*/
24	elmex	1.1
25
26			#include <global.h>
27			#include <stdio.h>
28
29	root	1.19	#include "face.h"
30	root	1.17	#include "crc.h"
31
32	root	1.19	faceidx blank_face, empty_face;
33	elmex	1.1
34	root	1.19	facehash_t facehash;
35			std::vector<faceinfo> faces;
36			std::vector<facedata> face32, face64;
37	elmex	1.1
38			/**
39			* id is the face to smooth, smooth is the 16x2 face used to smooth id.
40			*/
41	root	1.14	struct smoothing : zero_initialised
42	root	1.4	{
43	root	1.6	uint16 id;
44			uint16 smooth;
45	elmex	1.1	};
46
47			/**
48			* Contains all defined smoothing entries. smooth is an array of nrofsmooth
49			* entries. It is sorted by smooth[].id.
50			*/
51	root	1.6	static struct smoothing *smooth = NULL;
52			int nrofsmooth = 0;
53	elmex	1.1
54			/* the only thing this table is used for now is to
55			* translate the colorname in the magicmap field of the
56			* face into a numeric index that is then sent to the
57			* client for magic map commands. The order of this table
58			* must match that of the NDI colors in include/newclient.h.
59			*/
60			static const char *const colorname[] = {
61	root	1.6	"black", /* 0 */
62			"white", /* 1 */
63			"blue", /* 2 */
64			"red", /* 3 */
65			"orange", /* 4 */
66			"light_blue", /* 5 */
67			"dark_orange", /* 6 */
68			"green", /* 7 */
69			"light_green", /* 8 */
70			"grey", /* 9 */
71			"brown", /* 10 */
72			"yellow", /* 11 */
73			"khaki" /* 12 */
74	elmex	1.1	};
75
76	root	1.6	static int
77			compar_smooth (const struct smoothing a, const struct smoothing b)
78			{
79			if (a->id < b->id)
80			return -1;
81			if (b->id < a->id)
82			return 1;
83			return 0;
84	elmex	1.1	}
85
86			/*
87			* Returns the matching color in the coloralias if found,
88			* 0 otherwise. Note that 0 will actually be black, so there is no
89			* way the calling function can tell if an error occurred or not
90			*/
91	root	1.6	static uint8
92			find_color (const char *name)
93			{
94	elmex	1.1	uint8 i;
95	root	1.6
96			for (i = 0; i < sizeof (colorname) / sizeof (*colorname); i++)
97			if (!strcmp (name, colorname[i]))
98	elmex	1.1	return i;
99	root	1.19
100	root	1.6	LOG (llevError, "Unknown color: %s\n", name);
101	elmex	1.1	return 0;
102			}
103
104	root	1.19	int
105			face_find (const char *name, int defidx)
106	elmex	1.1	{
107	root	1.19	facehash_t::iterator i = facehash.find (name);
108	root	1.6
109	root	1.19	return i == facehash.end ()
110			? defidx : i->second;
111	elmex	1.1	}
112
113	root	1.19	facedata *
114			face_data (int idx, int faceset)
115	root	1.6	{
116	root	1.19	return &(faceset ? face64 : face32)[idx];
117	elmex	1.1	}
118
119			/* Reads the smooth file to know how to smooth datas.
120			* the smooth file if made of 2 elements lines.
121			* lines starting with # are comment
122			* the first element of line is face to smooth
123			* the next element is the 16x2 faces picture
124			* used for smoothing
125			*/
126	root	1.6	int
127			ReadSmooth (void)
128			{
129			char buf[MAX_BUF], p, q;
130			FILE *fp;
131			int smoothcount = 0;
132
133			sprintf (buf, "%s/smooth", settings.datadir);
134	pippijn	1.9	LOG (llevDebug, "Reading smooth from %s...\n", buf);
135	root	1.6	if ((fp = fopen (buf, "r")) == NULL)
136			{
137			LOG (llevError, "Cannot open smooth file %s: %s\n", strerror (errno));
138			exit (-1);
139	elmex	1.1	}
140
141	root	1.6	/* First count how many smooth we have, so we can allocate correctly */
142			while (fgets (buf, MAX_BUF, fp) != NULL)
143			if (buf[0] != '#' && buf[0] != '\n')
144			smoothcount++;
145			rewind (fp);
146
147			smooth = new smoothing[smoothcount];
148
149			while (nrofsmooth < smoothcount && fgets (buf, MAX_BUF, fp) != NULL)
150			{
151			if (*buf == '#')
152			continue;
153			p = strchr (buf, ' ');
154			if (!p)
155			continue;
156			*p = '\0';
157			q = buf;
158	root	1.19	smooth[nrofsmooth].id = face_find (q);
159	root	1.6	q = p + 1;
160	root	1.19	smooth[nrofsmooth].smooth = face_find (q);
161	root	1.6	nrofsmooth++;
162	elmex	1.1	}
163	root	1.6	fclose (fp);
164	elmex	1.1
165	root	1.6	LOG (llevDebug, "done (got %d smooth entries)\n", nrofsmooth);
166			qsort (smooth, nrofsmooth, sizeof (struct smoothing), (int ()(const void , const void *)) compar_smooth);
167			return nrofsmooth;
168	elmex	1.1	}
169
170			/**
171			* Find the smooth face for a given face.
172			*
173			* @param face the face to find the smoothing face for
174			*
175			* @param smoothed return value: set to smooth face
176			*
177			* @return 1=smooth face found, 0=no smooth face found
178			*/
179	root	1.6	int
180			FindSmooth (uint16 face, uint16 * smoothed)
181			{
182			struct smoothing *bp, tmp;
183	elmex	1.1
184	root	1.6	tmp.id = face;
185			bp = (struct smoothing *) bsearch
186			(&tmp, smooth, nrofsmooth, sizeof (struct smoothing), (int ()(const void , const void *)) compar_smooth);
187			(*smoothed) = 0;
188			if (bp)
189			(*smoothed) = bp->smooth;
190			return bp ? 1 : 0;
191	elmex	1.1	}
192