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 (17 years, 3 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
#	Content
1	/*
2	* CrossFire, A Multiplayer game
3	*
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
25
26	#include <global.h>
27	#include <stdio.h>
28
29	#include "face.h"
30	#include "crc.h"
31
32	faceidx blank_face, empty_face;
33
34	facehash_t facehash;
35	std::vector<faceinfo> faces;
36	std::vector<facedata> face32, face64;
37
38	/**
39	* id is the face to smooth, smooth is the 16x2 face used to smooth id.
40	*/
41	struct smoothing : zero_initialised
42	{
43	uint16 id;
44	uint16 smooth;
45	};
46
47	/**
48	* Contains all defined smoothing entries. smooth is an array of nrofsmooth
49	* entries. It is sorted by smooth[].id.
50	*/
51	static struct smoothing *smooth = NULL;
52	int nrofsmooth = 0;
53
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	"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	};
75
76	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	}
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	static uint8
92	find_color (const char *name)
93	{
94	uint8 i;
95
96	for (i = 0; i < sizeof (colorname) / sizeof (*colorname); i++)
97	if (!strcmp (name, colorname[i]))
98	return i;
99
100	LOG (llevError, "Unknown color: %s\n", name);
101	return 0;
102	}
103
104	int
105	face_find (const char *name, int defidx)
106	{
107	facehash_t::iterator i = facehash.find (name);
108
109	return i == facehash.end ()
110	? defidx : i->second;
111	}
112
113	facedata *
114	face_data (int idx, int faceset)
115	{
116	return &(faceset ? face64 : face32)[idx];
117	}
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	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	LOG (llevDebug, "Reading smooth from %s...\n", buf);
135	if ((fp = fopen (buf, "r")) == NULL)
136	{
137	LOG (llevError, "Cannot open smooth file %s: %s\n", strerror (errno));
138	exit (-1);
139	}
140
141	/* 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	smooth[nrofsmooth].id = face_find (q);
159	q = p + 1;
160	smooth[nrofsmooth].smooth = face_find (q);
161	nrofsmooth++;
162	}
163	fclose (fp);
164
165	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	}
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	int
180	FindSmooth (uint16 face, uint16 * smoothed)
181	{
182	struct smoothing *bp, tmp;
183
184	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	}
192