Commit: 1 - hunton_server (svn)

密猟オンラインサーバープログラム

Commit MetaInfo

• Revision: 1 (tree)
• Time: 2016-01-16 19:40:14
• Author: manjihq

Log Message

base version

Change Summary

• added: trunk/ctlsock.c
• added: trunk/h-item
• added: trunk/hunt.h
• added: trunk/h-animal
• added: trunk/pktio.c
• added: trunk/ctlsock.h
• added: trunk/h-setup.default
• added: trunk/port.h
• added: trunk/pktio.h
• added: trunk/Makefile
• added: trunk/h-weapon
• added: trunk/huntserv.c
• added: trunk

Incremental Difference

--- trunk/ctlsock.c	(nonexistent)
+++ trunk/ctlsock.c	(revision 1)
@@ -0,0 +1,85 @@
+#include <string.h>
+
+#include "port.h"
+#include "ctlsock.h"
+
+SOCKET
+makesocket (int port, unsigned long addr, int socktype)
+{
+  SOCKET hsock;
+  struct sockaddr_in sockin;
+
+  memset (&sockin, 0, sizeof (sockin));
+  sockin.sin_family = AF_INET;
+  sockin.sin_addr.s_addr = htonl (addr);
+  sockin.sin_port = htons (port);
+  hsock = socket (PF_INET, socktype, DEFAULT_PROTOCOL);
+  if (hsock != INVALID_SOCKET)
+    {
+      int n = 1;
+      setsockopt (hsock, SOL_SOCKET, SO_REUSEADDR, (void *) &n, sizeof (n));
+#ifdef TCP_MAXSEG
+      n = REQ_SEGMENT_SIZE;
+      setsockopt (hsock, SOL_TCP, TCP_MAXSEG, (void *) &n, sizeof (n));
+#endif
+      if (bind (hsock, (struct sockaddr *) &sockin, sizeof (sockin)) != 0)
+	{
+	  closesocket (hsock);
+	  hsock = INVALID_SOCKET;
+	}
+    }
+  return hsock;
+}
+
+
+int
+cutsocket (SOCKET handle)
+{
+  shutdown (handle, 2);
+  return closesocket (handle);
+}
+
+
+int
+waitconnect (SOCKET handle, SESSION * psession)
+{
+  int ret = -1;
+  struct sockaddr_in sockin;
+  socklen_t socklen = sizeof (sockin);
+  SOCKET newhandle = accept (handle, (struct sockaddr *) &sockin,
+			     &socklen);
+  psession->handle = INVALID_SOCKET;
+  if (newhandle != INVALID_SOCKET)
+    {
+      psession->handle = newhandle;
+      psession->addr = sockin.sin_addr.s_addr;
+      psession->port = sockin.sin_port;
+      ret = 0;
+    }
+  return ret;
+}
+
+SOCKET
+connectsocket (int port, unsigned long addr, int socktype)
+{
+  SOCKET hsock;
+  struct sockaddr_in sockin;
+
+  memset (&sockin, 0, sizeof (sockin));
+  sockin.sin_family = AF_INET;
+  sockin.sin_addr.s_addr = htonl (addr);
+  sockin.sin_port = htons (port);
+  hsock = socket (PF_INET, socktype, DEFAULT_PROTOCOL);
+  if (hsock != INVALID_SOCKET)
+    {
+      if (connect (hsock, (struct sockaddr *) &sockin, sizeof (sockin)) != 0)
+	{
+	  closesocket (hsock);
+	  hsock = INVALID_SOCKET;
+	}
+    }
+  return hsock;
+}
+
+
+/* EOF */

--- trunk/hunt.h	(nonexistent)
+++ trunk/hunt.h	(revision 1)
@@ -0,0 +1,128 @@
+/* h-online */
+
+#define PACKET_DATA_MAX		1024
+#define PACKET_HEADER_MAX	2
+#define PACKET_MAX		(PACKET_DATA_MAX+PACKET_HEADER_MAX)
+
+#define SENDMAP_CHUNK		1000
+
+#define DEFAULT_PORT		10001
+
+#define USERNAME_LEN		16
+#define PASSWORD_LEN		16
+#define SCORE_LIMIT		999999999L
+#define ANIMALNAME_LEN		16
+#define WEAPON_MAX		2
+#define WEAPONNAME_LEN		32
+#define ITEM_MAX		4
+#define ITEMNAME_LEN		32
+#define VIEW_LIMIT		5
+#define VIEW_WIDTH		5
+#define HIGEMESG_LEN		255
+#define HIREABLE_NPC_TYPE	3
+#define HPROTOCOL_VERSION	5
+
+/* from Server packet ID */
+#define HSERV_RESULT		0x00
+#define HSERV_STATUS		0x03
+#define HSERV_MAP		0x04
+#define HSERV_MAPANDSTATUS	0x06
+#define HSERV_MESG		0x10
+#define HSERV_SYSMESG		0x11
+#define HSERV_WHO		0x20
+#define HSERV_BBS_HEADER	0x28
+#define HSERV_BBS_BODY		0x29
+#define HSERV_BBS_BODYEND	0x2a
+#define HSERV_EFFECT_DAMAGE	0x30
+#define HSERV_EFFECT_DEATH	0x31
+#define HSERV_EFFECT_DIGGING	0x32
+#define HSERV_EFFECT_FALL	0x33
+#define HSERV_TRANSMAP_START	0x38
+#define HSERV_TRANSMAP_CHUNK	0x39
+#define HSERV_SENDMAIL		0x3a
+#define HSERV_SENDMAILBODY	0x3b
+#define HSERV_SENDEND		0x3c
+
+/* from Client packet ID */
+#define HCLIT_LOGIN		0x00
+#define HCLIT_MOVE		0x01
+#define HCLIT_CHDIR		0x02
+#define HCLIT_FIRE		0x03
+#define HCLIT_ITEM		0x04
+#define HCLIT_PICK		0x05
+#define HCLIT_PAY		0x06
+#define HCLIT_BUY		0x07
+#define HCLIT_MESG		0x10
+#define HCLIT_MESG2U		0x11
+#define HCLIT_MESG2ALL		0x12
+#define HCLIT_WHO		0x20
+#define HCLIT_REQWEAPON		0x21
+#define HCLIT_REQITEM		0x22
+#define HCLIT_WRITEMESG		0x23
+#define HCLIT_DROPOBJ		0x24
+#define HCLIT_CHANGEANIMAL	0x25
+#define HCLIT_STOREANIMAL	0x28
+#define HCLIT_STOREOBJ		0x29
+#define HCLIT_CHANGEMYSHOP	0x2a
+#define HCLIT_DISCARDMYSHOPOBJ	0x2b
+#define HCLIT_DESTROYMYSHOP	0x2c
+#define HCLIT_LISTMYSHOP	0x2d
+#define HCLIT_REQANIMAL		0x2e
+#define HCLIT_LISTLIVEANIMAL	0x2f
+#define HCLIT_TRANSFERSCORE	0x30
+#define HCLIT_BBS_POST		0x31
+#define HCLIT_BBS_LIST		0x32
+#define HCLIT_BBS_READ		0x33
+#define HCLIT_SENDMAIL		0x34
+#define HCLIT_SENDMAILBODY	0x35
+#define HCLIT_SENDEND		0x36
+#define HCLIT_LISTMAIL		0x37
+#define HCLIT_READMAIL		0x38
+#define HCLIT_DELETEMAIL	0x39
+#define HCLIT_LOGOFF		0x3a
+#define HCLIT_NEWUSER		0x3b
+#define HCLIT_DELUSER		0x3c
+
+/* map data */
+#define HCLIT_MAP_INVALID	'?'
+#define HCLIT_MAP_ROAD		' '
+#define HCLIT_MAP_TREE		'!'
+#define HCLIT_MAP_ROCK		'*'
+#define HCLIT_MAP_ITEM		'$'
+#define HCLIT_MAP_SHOP		'@'
+#define HCLIT_MAP_USERSHOP	'+'
+#define HCLIT_MAP_WALL		'#'
+#define HCLIT_MAP_ANIMAL	'a'
+#define HCLIT_MAP_DEADANIMAL    '%'
+
+/* player on map data */
+#define HCLIT_PLAYER_N		'A'
+#define HCLIT_PLAYER_S		'V'
+#define HCLIT_PLAYER_W		'<'
+#define HCLIT_PLAYER_E		'>'
+#define HCLIT_PLAYER_NONE	' '
+
+#define HCLIT_GUARD_N		'^'
+#define HCLIT_GUARD_S		'v'
+#define HCLIT_GUARD_W		'd'
+#define HCLIT_GUARD_E		'b'
+
+#define HCLIT_NPC_N		'N'
+#define HCLIT_NPC_S		'S'
+#define HCLIT_NPC_W		'W'
+#define HCLIT_NPC_E		'E'
+
+/* direction */
+#define DIRECTION_N		0
+#define DIRECTION_W		1
+#define DIRECTION_E		2
+#define DIRECTION_S		3
+
+/* moving */
+#define MOVE_FORWARD		0
+#define MOVE_BACKWARD		1
+#define MOVE_LEFT		2
+#define MOVE_RIGHT		3
+
+
+/* EOF */

--- trunk/pktio.c	(nonexistent)
+++ trunk/pktio.c	(revision 1)
@@ -0,0 +1,265 @@
+#include "port.h"
+#include "ctlsock.h"
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include "hunt.h"
+#include "pktio.h"
+
+
+/* compress data */
+static int
+compress (const unsigned char *pin, unsigned char *pout, int n)
+{
+  int ret = 0;
+  int count = 1;
+  unsigned char c = *pin++;
+  while (--n > 0)
+    {
+      if (*pin == c)
+	{
+	  if (count == 16)
+	    {
+	      *pout++ = 0xff;
+	      *pout++ = c;
+	      ret += 2;
+	      count = 1;
+	    }
+	  else
+	    {
+	      count++;
+	    }
+	}
+      else
+	{
+	  if (count > 2 || (c & 0xf0) == 0xf0)
+	    {
+	      *pout++ = 0xf0 | (count - 1);
+	      *pout++ = c;
+	      ret += 2;
+	    }
+	  else
+	    {
+	      while (count--)
+		{
+		  *pout++ = c;
+		  ret++;
+		}
+	    }
+	  count = 1;
+	  c = *pin;
+	}
+      pin++;
+    }
+  if (count > 2 || (c & 0xf0) == 0xf0)
+    {
+      *pout++ = 0xf0 | (count - 1);
+      *pout++ = c;
+      ret += 2;
+    }
+  else
+    {
+      while (count--)
+	{
+	  *pout++ = c;
+	  ret++;
+	}
+    }
+  return ret;
+}
+
+/* uncompress data */
+static int
+uncompress (const unsigned char *pin, unsigned char *pout, int n)
+{
+  int ret = 0;
+  while (n-- > 0)
+    {
+      unsigned char c = *pin++;
+      if ((c & 0xf0) == 0xf0)
+	{
+	  int count = (int) (c & 0x0f) + 1;
+	  c = *pin++;
+	  if (n-- <= 0)
+	    {
+	      break;
+	    }
+	  while (count-- > 0)
+	    {
+	      *pout++ = c;
+	      ret++;
+	    }
+	}
+      else
+	{
+	  *pout++ = c;
+	  ret++;
+	}
+    }
+  return ret;
+}
+
+/* send compress packet */
+int
+send_packet_c (SOCKET handle, unsigned char *ppacket, int nsize)
+{
+  int ret = -1;
+  unsigned char sendbuffer[PACKET_MAX];
+  int sendsize = 0;
+  if (nsize > 0)
+    {
+      int compress_size;
+      compress_size = compress (ppacket + 2, sendbuffer + 2, nsize);
+      if (compress_size)
+	{
+	  sendsize = 2 + compress_size;
+	  sendbuffer[0] = *ppacket;
+	  *(ppacket + 1) = sendbuffer[1] = compress_size & 0xff;
+	  sendbuffer[0] &= 0x3f;
+	  sendbuffer[0] |= (compress_size & 0x300) >> 2;
+	  *ppacket = sendbuffer[0];
+	  /* for send sendbuffer */
+	  ppacket = sendbuffer;
+	}
+      else
+	{
+	  return -1;
+	}
+    }
+  else
+    {
+      sendsize = 2;
+      *(ppacket + 1) = 0;
+      *ppacket &= 0x3f;
+    }
+  while (sendsize > 0)
+    {
+      int result;
+      fd_set wfds;
+      struct timeval tmout;
+      tmout.tv_sec = 1;
+      tmout.tv_usec = 0;
+      FD_ZERO (&wfds);
+      FD_SET (handle, &wfds);
+      result = select (handle + 1, NULL, &wfds, NULL, &tmout);
+      if (result > 0)
+	{
+	  int n = send (handle, ppacket, sendsize, 0);
+	  if (n == -1)
+	    {
+	      if (errno == EINTR)
+		{
+		  continue;
+		}
+	      break;
+	    }
+	  if (sendsize == n)
+	    {
+	      ret = 0;
+	      break;
+	    }
+	  if (!n)
+	    {
+	      break;
+	    }
+	  sendsize -= n;
+	  ppacket += n;
+	}
+      else
+	{
+	  if (result < 0 && errno == EINTR)
+	    {
+	      continue;
+	    }
+	  break;
+	}
+    }
+  return ret;
+}
+
+/* low level receive */
+static int
+receive_data (SOCKET handle, unsigned char *p, int nsize)
+{
+  while (nsize > 0)
+    {
+      int result;
+      fd_set rfds;
+      struct timeval tmout;
+      tmout.tv_sec = 1;
+      tmout.tv_usec = 0;
+      FD_ZERO (&rfds);
+      FD_SET (handle, &rfds);
+      result = select (handle + 1, &rfds, NULL, NULL, &tmout);
+      if (result > 0)
+	{
+	  int n = recv (handle, p, nsize, 0);
+	  if (n == -1)
+	    {
+	      if (errno == EINTR)
+		{
+		  continue;
+		}
+	      break;
+	    }
+	  if (!n)
+	    {
+	      break;
+	    }
+	  p += n;
+	  nsize -= n;
+	}
+      else
+	{
+	  if (result < 0 && errno == EINTR)
+	    {
+	      continue;
+	    }
+	  break;
+	}
+    }
+  return nsize ? -1 : 0;
+}
+
+/* receive compress packet */
+int
+receive_packet_c (SOCKET handle, unsigned char *ppacket, int nsize)
+{
+  int ret = -1;
+  unsigned char recvbuffer[PACKET_DATA_MAX];
+  unsigned char uncompbuffer[PACKET_DATA_MAX];
+  unsigned char buf[2];
+  if (receive_data (handle, buf, 2) == 0)
+    {
+      int n = buf[1];
+      n += (int) (buf[0] & 0xc0) << 2;
+      if (n)
+	{
+	  if (receive_data (handle, recvbuffer, n) == 0)
+	    {
+	      int nwk;
+	      nwk = uncompress (recvbuffer, uncompbuffer, n);
+	      if (nwk > nsize)
+		{
+		  nwk = nsize;
+		}
+	      memcpy (ppacket + 2, uncompbuffer, nwk);
+	      *(ppacket + 1) = nwk & 0xff;
+	      *ppacket = buf[0] & 0x3f;
+	      *ppacket |= (nwk & 0x300) >> 2;
+	      ret = 0;
+	    }
+	}
+      else
+	{
+	  *ppacket = buf[0];
+	  *(ppacket + 1) = buf[1];
+	  ret = 0;
+	}
+    }
+  return ret;
+}
+
+
+
+/* EOF */

--- trunk/ctlsock.h	(nonexistent)
+++ trunk/ctlsock.h	(revision 1)
@@ -0,0 +1,19 @@
+#ifndef CONTROL_SOCKET_HEADER
+#define CONTROL_SOCKET_HEADER
+
+typedef struct session_data
+  {				/* server session data */
+    SOCKET handle;		/* socket handle */
+    unsigned long addr;		/* client address */
+    unsigned short port;	/* client port */
+  }
+SESSION;
+
+/* prototypes */
+extern SOCKET makesocket (int port, unsigned long addr, int socktype);
+extern int cutsocket (SOCKET handle);
+extern int waitconnect (SOCKET handle, SESSION * psession);
+extern SOCKET connectsocket (int port, unsigned long addr, int socktype);
+
+#endif
+/* EOF */

--- trunk/port.h	(nonexistent)
+++ trunk/port.h	(revision 1)
@@ -0,0 +1,67 @@
+#ifndef PORT_HEADER
+#define PORT_HEADER
+
+#if defined(UNIX)
+#ifdef __linux__
+#define LINUX
+#define HAVE_SIGACTION
+#define HAVE_SIGALRM
+#define USE_FORK
+#endif
+
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+
+#define init_socket_interface()
+#define cleanup_socket_interface()
+
+#define closesocket	close
+typedef int SOCKET;
+#define INVALID_SOCKET	(-1)
+
+#ifdef TCP_MAXSEG
+/* minimum segment size */
+#define REQ_SEGMENT_SIZE	512
+#endif
+
+#elif defined(MAKEWIN32)
+#define STRICT
+#include <windows.h>
+#include <stdio.h>
+#include <mbstring.h>
+#include <process.h>
+
+/* if your compiler hasn't _beginthread,you define MAKETHREAD by your hand */
+/* here ! */
+
+/* default setting */
+#ifndef MAKETHREAD
+#define MAKETHREAD(f,a)	_beginthread ((f),64 * 1024,(a))
+#endif
+#ifndef ENDTHREAD
+#define ENDTHREAD() _endthread ()
+#endif
+
+#define init_socket_interface() {\
+        WSADATA sockdata;\
+	if(WSAStartup(MAKEWORD(1,1),&sockdata)) {\
+	  fputs("EVAC:winsock fail\n",stderr); exit(255); }\
+			       }
+#define cleanup_socket_interface() {\
+	WSACleanup(); }
+#else
+#error NEED enviroment-type!
+#endif
+
+#ifndef DEFAULT_PROTOCOL
+#define DEFAULT_PROTOCOL	0
+#endif
+
+#endif
+/* EOF */

--- trunk/pktio.h	(nonexistent)
+++ trunk/pktio.h	(revision 1)
@@ -0,0 +1,8 @@
+
+
+extern int send_packet_c (SOCKET handle, unsigned char *ppacket, int nsize);
+extern int receive_packet_c (SOCKET handle,
+			     unsigned char *ppacket, int nsize);
+
+
+/* EOF */

--- trunk/Makefile	(nonexistent)
+++ trunk/Makefile	(revision 1)
@@ -0,0 +1,30 @@
+##Makefile for Hunter-online
+CC=gcc
+DEFINES=-DUNIX
+#CFLAGS=-Wall -g $(DEFINES)
+CFLAGS=-Wall -O $(DEFINES)
+
+SRCS=huntserv.c ctlsock.c pktio.c hunt.h pltio.h ctlsock.h port.h
+
+all: huntserv
+
+clean:
+	-rm *~ core *.o
+
+distclean:
+	-rm *~ core *.o
+	-rm h-user h-bbs h-map h-mail.* huntserv
+
+huntserv : huntserv.o ctlsock.o pktio.o
+	$(CC) $(CFLAGS) -o huntserv huntserv.o ctlsock.o pktio.o
+
+
+ctlsock.o : ctlsock.c ctlsock.h port.h
+
+pktio.o : pktio.c hunt.h pktio.h ctlsock.h port.h
+
+huntserv.o : huntserv.c hunt.h pktio.h ctlsock.h port.h
+
+
+
+#EOF

--- trunk/huntserv.c	(nonexistent)
+++ trunk/huntserv.c	(revision 1)
@@ -0,0 +1,11491 @@
+#include "port.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <time.h>
+#include <errno.h>
+#ifdef USE_FORK
+#include <sys/wait.h>
+#endif
+#include "ctlsock.h"
+#include "hunt.h"
+#include "pktio.h"
+
+/* Game feature */
+#define USE_SAVEMAP
+#define USE_AUTOSAVE
+#define USE_MAIL
+#define USE_BBS
+#define USE_STRONGANIMAL
+
+/* defines */
+#define PATCH_LEVEL_STRING	""
+#ifndef SERVERPOLL_MSEC
+#define SERVERPOLL_MSEC		100
+#endif
+#ifndef DATA_DIR
+#define DATA_DIR		"./"
+#endif
+#define USER_DATA_FILE		"h-user"
+#define WEAPON_DATA_FILE	"h-weapon"
+#define ITEM_DATA_FILE		"h-item"
+#define ANIMAL_DATA_FILE	"h-animal"
+#define INIT_DATA_FILE		"h-setup"
+#ifdef USE_SAVEMAP
+#define SYSMAP_DATA_FILE	"h-map"
+#endif
+#ifdef USE_BBS
+#define BBS_DATA_FILE		"h-bbs"
+#endif
+#ifndef HEARNEAR_DISTANCE
+#define HEARNEAR_DISTANCE	10
+#endif
+#ifndef SELLINSHOP_LIMIT
+#define SELLINSHOP_LIMIT	8
+#endif
+#ifndef USERSHOP_LIMIT
+#define USERSHOP_LIMIT		10
+#endif
+#ifndef ANIMAL_SLOT_MAX
+#define ANIMAL_SLOT_MAX		10
+#endif
+#ifndef HUNTER_SPEAK_RATE
+#define HUNTER_SPEAK_RATE	10
+#endif
+#ifndef OBSERVER_SPEAK_RATE
+#define OBSERVER_SPEAK_RATE	10
+#endif
+#ifndef HIRENPC_SPEAK_RATE
+#define HIRENPC_SPEAK_RATE	10
+#endif
+#ifndef ANIMAL_MORAL_PANIC
+#define ANIMAL_MORAL_PANIC	50
+#endif
+#ifndef ANIMAL_MORAL_NORMAL
+#define ANIMAL_MORAL_NORMAL	100
+#endif
+#ifndef ANIMAL_MORAL_LIMIT
+#define ANIMAL_MORAL_LIMIT	200
+#endif
+#ifndef ANIMAL_RATE_ANGRY
+#define ANIMAL_RATE_ANGRY	50
+#endif
+#ifndef ANIMAL_MORAL_WHENKILL
+#define ANIMAL_MORAL_WHENKILL	10
+#endif
+#ifndef ANIMAL_SEARCH_RANGE
+#define ANIMAL_SEARCH_RANGE	10
+#endif
+#ifndef ANIMAL_RECOVER_COUNT
+#define ANIMAL_RECOVER_COUNT	1800
+#endif
+#ifndef NPC_COUNTERATTACK_COUNT
+#define NPC_COUNTERATTACK_COUNT	300
+#endif
+#ifndef ARREST_LIMIT
+#define ARREST_LIMIT		20
+#endif
+#ifdef USE_STRONGANIMAL
+#ifndef ANIMAL_HP_LIMIT
+#define ANIMAL_HP_LIMIT		1000000L
+#endif
+#ifndef ANIMAL_MORAL_LIMIT
+#define ANIMAL_MORAL_LIMIT	10000
+#endif
+#ifndef ANIMAL_FIRE_LIMIT
+#define ANIMAL_FIRE_LIMIT	10000
+#endif
+#endif /* USE_STRONGANIMAL */
+
+#ifdef MAKEWIN32
+/* Win32 enviroment feature */
+#define USE_W32THREAD
+#endif
+
+#ifdef USE_FORK
+#define SENDPACKET(u,p,s) send_pipe ((u),(p),(s))
+#endif
+#ifdef USE_W32THREAD
+#define SENDPACKET(u,p,s) send_thread ((u),(p),(s))
+#endif
+#ifndef SENDPACKET
+#define SENDPACKET(u,p,s) send_packet_c (User[(u)].session.handle,(p),(s))
+#endif
+
+#define CUTTAIL(s)	cut_tail(s,USERNAME_LEN)
+
+#define ALLOCATE_CHUNK		16
+#define BUFFER_SIZE		256
+#define MESG_BUFFER		256
+#ifdef USE_FORK
+#define SENDPIPE_QUEUE_MAX	200
+#endif
+
+/*********************************/
+static const char ServerInfo[] =
+  "[Hunter-online Version 3.00 alpha" PATCH_LEVEL_STRING "]";
+static int NowRunning = 0;
+static SOCKET mainSocket = INVALID_SOCKET;
+static fd_set mainFDS;
+#ifdef MAKEWIN32
+static HANDLE hEnd;
+static HANDLE hThread;
+#endif
+
+struct location
+{
+  int x;
+  int y;
+};
+
+enum target_type
+{
+  TargetUser,
+  TargetNpc,
+  TargetAnimal,
+  TargetNone
+};
+
+typedef struct animal_data
+{
+  int n;
+  char name[ANIMALNAME_LEN];
+  unsigned long hp;
+  unsigned moral;
+  unsigned speed;
+  unsigned value;
+  unsigned rate;
+  unsigned w_power;
+  unsigned w_rate;
+  int forsell_item;
+  int eatmeat;
+  int pattern;
+  int charm_rate;
+}
+ANIMALDATA;
+
+#ifdef USE_MAIL
+#define MAIL_BOX_LIMIT		20
+#define MAIL_LINE_LIMIT		50
+typedef struct mail_data
+{
+  int readflag;
+  int fromuser;
+  int line;
+  time_t timestamp;
+  char subject[PACKET_DATA_MAX];
+  char message[MAIL_LINE_LIMIT][PACKET_DATA_MAX];
+}
+MAILDATA;
+#endif
+
+#ifdef USE_W32THREAD
+#define W32MSG_QUEUE_MAX	200
+typedef struct w32msg_queue
+{
+  int read_pos;
+  int write_pos;
+  int count;
+  HANDLE hend;
+  unsigned char data[W32MSG_QUEUE_MAX][PACKET_DATA_MAX];
+}
+W32MSG_QUEUE;
+#endif
+
+typedef struct user_info
+{
+  char name[USERNAME_LEN];
+  char password[PASSWORD_LEN];
+  enum usertype_t
+  {
+    Hunter,
+    Observer,
+    TypeMax
+  }
+  c_type;
+  SESSION session;
+  unsigned long idletimer;
+  unsigned long score;
+  unsigned long hp;
+  unsigned long hungry;
+  int speed;
+  int speed_count;
+  unsigned char weapon[WEAPON_MAX];
+  unsigned short bullette[WEAPON_MAX];
+  int reload[WEAPON_MAX];
+  unsigned char item[ITEM_MAX];
+  unsigned short itemcount[ITEM_MAX];
+  int lastuser;
+  enum target_type lastuser_type;
+  unsigned char direction;
+  struct location pos;
+  unsigned char wk_direction;
+  struct location wk_pos;
+  unsigned long maybearrest;
+  unsigned crime_level;
+  unsigned arrest_count;
+  enum move_t
+  {
+    NoMove,
+    MoveForward,
+    MoveBackward,
+    MoveLeft,
+    MoveRight,
+    MoveMax
+  }
+  move;
+  enum move_t move_bkup;
+  enum action_t
+  {
+    NoAction,
+    Fire1,
+    Fire2,
+    UseItem1,
+    UseItem2,
+    UseItem3,
+    UseItem4,
+    PickUp,
+    Pay,
+    BuyWeapon,
+    BuyItem,
+    Who,
+    RequestWeapon,
+    RequestItem,
+    StoreAnimal,
+    StoreWeapon,
+    StoreItem,
+    DiscardWeapon,
+    DiscardItem,
+    ListMyShop,
+    DropWeapon,
+    DropItem,
+    ListMyAnimal,
+    DoSay,
+    DoTell,
+    DoBroadcast,
+    DoWriteMesg,
+    DoChangeShopName,
+    DoChangeAnimalName,
+    DoDestroyShop,
+    ListLiveAnimal,
+#ifdef USE_MAIL
+    ListMyMail,
+    ReadMyMail,
+    DeleteMyMail,
+#ifdef USE_BBS
+    ListBBS,
+    ReadBBS,
+#endif
+#endif
+    ActionMax
+  }
+  action;
+  int wk_for_action;
+  unsigned long lwk_for_action;
+  char mesg_for_action[PACKET_DATA_MAX];
+  enum status_t
+  {
+    Healthy,
+    Arrested,
+    Shopping
+  }
+  status;
+  int cloak_count;		/* count of cloaking */
+  int hold_count;		/* count of no moving */
+  struct myshop_t
+  {				/* shop data */
+    int build;
+    char name[USERNAME_LEN];
+    struct location pos;
+    unsigned char list[2][SELLINSHOP_LIMIT];
+    unsigned leftuse[2][SELLINSHOP_LIMIT];
+    unsigned count[2][SELLINSHOP_LIMIT];
+    unsigned long cost[2][SELLINSHOP_LIMIT];
+  }
+  myshop[USERSHOP_LIMIT];
+  int animal_slot;
+  ANIMALDATA *lastPickupAnimal[ANIMAL_SLOT_MAX];
+  int ride_pattern;
+  char higemesg[HIGEMESG_LEN];
+  unsigned char statusinfo[PACKET_MAX];	/* backup for status info */
+  int statusinfosize;
+  unsigned char mapdata[PACKET_MAX];	/* backup for map data */
+  int mapdatasize;
+#ifdef USE_FORK
+  pid_t send_pid;
+  int send_handle;
+#endif
+#ifdef USE_W32THREAD
+  HANDLE w32thread;
+  W32MSG_QUEUE *w32queue;
+#endif
+#ifdef USE_MAIL
+  int t_target;			/* transaction of send */
+  MAILDATA *t_mail;		/* transaction of send */
+  MAILDATA *mail[MAIL_BOX_LIMIT];	/* mailbox */
+#endif
+}
+USERINFO;
+
+typedef struct npc_t
+{				/* NPC */
+  enum npctype_t
+  {
+    NpcHunter,
+    NpcObserver,
+    NpcHige
+  }
+  c_type;
+  char name[USERNAME_LEN];
+  int number;
+  int owner_user;
+  unsigned long hp;
+  int speed;
+  int weapon;
+  unsigned bullette;
+  int reload;
+  int search;
+  int attack;
+  struct location pos;
+  int direction;
+  int ntarget_user;
+  enum target_type t_type;
+  int nochangelock_count;
+  int speed_count;
+  int hold_count;
+  int moral_limit;
+}
+NPCINFO;
+
+typedef struct animal_info
+{
+  ANIMALDATA *pdata;
+  char name[USERNAME_LEN];
+  unsigned long hp;
+  unsigned moral;
+  unsigned w_power;
+  int speed;
+#ifdef USE_STRONGANIMAL
+  unsigned long hp_org;
+  unsigned moral_org;
+  unsigned w_power_org;
+  int speed_org;
+#endif
+  struct location pos;
+  int reload;
+  enum charm_type
+  {
+    CharmPosition,
+    CharmUser,
+    CharmNpc,
+    CharmAnimal
+  }
+  charm;
+  unsigned charmcount;
+  struct location charm_pos;
+  int ntarget;
+  int search;
+  int ntime;
+  int hold_count;
+  int recover_count;
+  int owner_user;
+}
+ANIMALINFO;
+
+enum bullet_type
+{
+  BulletNormal,
+  BulletCharm,
+  BulletAP,
+  BulletTypeMax
+};
+
+typedef struct weapon_info
+{
+  char name[WEAPONNAME_LEN];
+  unsigned firepower;
+  unsigned moral;
+  unsigned range;
+  unsigned rate;
+  unsigned reduce;
+  unsigned speed;
+  unsigned bullette;
+  unsigned long cost;
+  unsigned forhunter;
+  unsigned npc_rate;
+  enum bullet_type b_type;
+}
+WEAPONINFO;
+
+typedef struct item_info
+{
+  char name[ITEMNAME_LEN];
+  enum item_type
+  {
+    Noeffect,
+    Heal,
+    Tree,
+    Charm,
+    Score,
+    Damage,
+    AnimalRadar,
+    HumanRadar,
+    Invisible,
+    BuildShop,
+    DigHole,
+    Vehicle,
+    Food,
+    HireNpc,
+    ItemTypeMax
+  }
+  id;
+  unsigned effect;
+  unsigned count;
+  unsigned long cost;
+  unsigned forhunter;
+  unsigned pattern;
+}
+ITEMINFO;
+
+/* in game data */
+static USERINFO *User;
+static NPCINFO *Npc;
+static ANIMALINFO *Animal;
+static ANIMALDATA *AnimalData = NULL;
+static int AnimalDataLimit = 0;
+static WEAPONINFO *Weapon = NULL;
+static int WeaponLimit = 0;
+static ITEMINFO *Item = NULL;
+static int ItemLimit = 0;
+
+static int *AnimalTypeTable = NULL;
+static int AnimalTypeTotal;
+static int *ForHunterWeapon;
+static int ForHunterWeaponLimit;
+static int *ForObserverWeapon;
+static int ForObserverWeaponLimit;
+static int *ForHunterItem;
+static int ForHunterItemLimit;
+static int *ForObserverItem;
+static int ForObserverItemLimit;
+static int *NpcHunterWeaponTable;
+static int NpcHunterWeaponTotal;
+static int *NpcObserverWeaponTable;
+static int NpcObserverWeaponTotal;
+
+#if defined(USE_MAIL) && defined(USE_BBS)
+#define BBS_BOX_LIMIT		40
+
+static MAILDATA *BBSdata[BBS_BOX_LIMIT];
+#endif
+
+/* system variable */
+static int MapWidth = 50;
+static int MapHeight = 50;
+static int UserSpeed = 7;
+static int MaxTimeoutValue = 18000;
+static int TreeHP = 210;
+static unsigned long HpLimit = 2000L;
+static unsigned long HpBase = 1000L;
+static unsigned long HungryLimit = 1000L;
+static unsigned long HungryBase = 100L;
+static int TurnPerHungry = 100;
+static unsigned DamageWhenHungry = 100;
+static int RateRoad = 70;
+static int RateBoxInItem = 50;
+static int TurnPerSpawnAnimal = 3000;
+static int TurnPerSpawnNpc = 6000;
+static int JailPositionX = 0;
+static int JailPositionY = 0;
+static int ShopLimit = 25;
+static unsigned long TurnPerSpawnTree = 12 * 36000;
+static int TreasureLimit = 10;
+static unsigned CrimeMurder = 3000;
+static unsigned CrimeNpcMurder = 1000;
+static unsigned ArrestPass = 1000;
+static unsigned ArrestAnyone = 10000;
+static int DigCount = 20;
+static int HoldCount = 100;
+static int CharmCount = 300;
+static int AngryCount = 100;
+static int TurnPerSend = 4;
+static int UserLimit = 100;
+static int AnimalLimit = 50;
+static int AnimalInitLimit = 20;
+static int NpcLimit = 50;
+static int NpcLimitForSystem = 10;
+static int NpcInitLimit = 3;
+static int NpcRateHunter = 50;
+static int NpcRateAverageSpeed = 70;
+static int NpcAverageSpeed = 10;
+static int NpcSpeedBase = 6;
+static int NpcSpeedMin = 1;
+static int NpcSpeedMax = 5;
+static int NpcHpMin = 500;
+static int NpcHpMax = 1500;
+static int NpcSearchMin = 6;
+static int NpcSearchMax = 10;
+static int NpcAttackMin = 3;
+static int NpcAttackMax = 6;
+static int TurnPerDecArrest = 50;
+static int DecArrest = 50;
+static unsigned long TurnPerJailCount = 6000;
+#ifdef USE_AUTOSAVE
+static unsigned long TurnPerSave = 24 * 36000;
+#endif
+static int TurnPerAnimalHeal = 300;
+static int HireableNpcType = HIREABLE_NPC_TYPE;
+static char makeUserKey[PASSWORD_LEN] = "HUNTER1234567890";
+static char rootPassword[PASSWORD_LEN] = "HunterMasterCode";
+
+/* map data */
+struct map_block
+{
+  unsigned char id;
+#define MAP_INVALID		0x00
+#define MAP_ROAD		0x01
+#define MAP_ID_FIRST		0x02
+#define MAP_TREE		0x02
+#define MAP_ROCK		0x03
+#define MAP_ID_LAST		0x03
+#define MAP_MASK		0x03
+#define MAP_THERE_ITEM		0x80
+#define MAP_THERE_SHOP		0x40
+#define MAP_THERE_ANIMAL	0x20
+#define MAP_THERE_WALL		0x10
+#define MAP_THERE_HOLE		0x08
+#define MAP_THERE_NPC		0x04
+#define MAP_HIGH_MASK		0xfc
+#define MAP_NOT_MOVE		(MAP_THERE_ANIMAL|MAP_THERE_NPC|MAP_THERE_WALL)
+#define MAP_NOT_SAVE		~(MAP_THERE_ANIMAL|MAP_THERE_NPC)
+  unsigned char player;
+  unsigned char animal;
+  unsigned char owner;
+};
+static struct map_block *Map = NULL;
+
+#define MAP(x,y)		(Map+(x)+(y)*MapWidth)
+#define INVALID_MAP(x,y)	(Map+(x)+(y)*MapWidth)->id &= ~MAP_MASK
+
+/* for bullette movement */
+struct bullet_t
+{
+  struct bullet_t *pnext;
+  struct bullet_t *pprev;
+  WEAPONINFO *pweapon;
+  struct location pos;
+  int direction;
+  int nuser;
+  enum target_type t_type;
+  int ndamage;
+  int ndistance;
+  int ntime;
+  struct location fire_pos;
+};
+static struct bullet_t *pBullet = NULL;
+
+/* for usermade itembox */
+struct itembox_t
+{				/* itembox made by user */
+  struct itembox_t *pprev;
+  struct itembox_t *pnext;
+  struct location pos;
+  int isitem;
+  int n;
+  unsigned left;
+  char message[PACKET_DATA_MAX];
+};
+static struct itembox_t *UserMadeItem = NULL;
+
+/* movement vector */
+static int FWVectorX[] = {
+  0, -1, 1, 0
+};
+
+static int FWVectorY[] = {
+  -1, 0, 0, 1
+};
+
+static int RGVectorX[] = {
+  1, 0, 0, -1
+};
+
+static int RGVectorY[] = {
+  0, -1, 1, 0
+};
+
+/* relatively direction */
+#define REL_DIRECTION_HERE	0
+#define REL_DIRECTION_N		1
+#define REL_DIRECTION_NE	2
+#define REL_DIRECTION_E		3
+#define REL_DIRECTION_SE	4
+#define REL_DIRECTION_S		5
+#define REL_DIRECTION_SW	6
+#define REL_DIRECTION_W		7
+#define REL_DIRECTION_NW	8
+
+static const char *RelDirection[] = {
+  "Here", "North", "NorthEast", "East", "SouthEast", "South",
+  "SouthWest", "West", "NorthWest"
+};
+
+static const int RelDirectionValue[] = {
+  DIRECTION_N,
+  DIRECTION_N,
+  DIRECTION_E,
+  DIRECTION_E,
+  DIRECTION_E,
+  DIRECTION_S,
+  DIRECTION_W,
+  DIRECTION_W,
+  DIRECTION_W,
+};
+
+static const int RelDirectionValue2[] = {
+  DIRECTION_N,
+  DIRECTION_N,
+  DIRECTION_N,
+  DIRECTION_E,
+  DIRECTION_S,
+  DIRECTION_S,
+  DIRECTION_S,
+  DIRECTION_W,
+  DIRECTION_N,
+};
+
+static unsigned char TargetDirection[][4] = {
+  {HCLIT_PLAYER_N, HCLIT_PLAYER_W, HCLIT_PLAYER_E, HCLIT_PLAYER_S},
+  {HCLIT_GUARD_N, HCLIT_GUARD_W, HCLIT_GUARD_E, HCLIT_GUARD_S},
+  {HCLIT_NPC_N, HCLIT_NPC_W, HCLIT_NPC_E, HCLIT_NPC_S}
+};
+
+/* for NPC name */
+static const char NpcHunters[][USERNAME_LEN] = {
+  "Hunter Red      ",
+  "Hunter Blue     ",
+  "Hunter Green    ",
+  "Hunter Yellow   ",
+  "Hunter Pink     ",
+  "Hunter Black    ",
+  "Hunter Richard  ",
+  "Hunter Jones    ",
+  "Hunter Okita    ",
+  "Hunter Big bear "
+};
+
+static int NpcHuntersN = sizeof (NpcHunters) / USERNAME_LEN;
+
+static const char NpcGuards[][USERNAME_LEN] = {
+  "Guard Red       ",
+  "Guard Blue      ",
+  "Guard Green     ",
+  "Guard Yellow    ",
+  "Guard Pink      ",
+  "Guard Black     ",
+  "Guard Gates     ",
+  "Guard Deathler  ",
+  "Guard Kodai     ",
+  "Guard Shark     "
+};
+
+static int NpcGuardsN = sizeof (NpcGuards) / USERNAME_LEN;
+
+static const char NpcHiges[][USERNAME_LEN] = {
+  "Private Saito   ",
+  "NAV Sima        ",
+  "Pilot Katou     ",
+  "Pilot Yamamoto  ",
+  "COM Aihara      ",
+  "Medic Sado      ",
+  "Commander Domel ",
+  "Commander Okita ",
+  "Warrior Zero    ",
+  "Captain Harlock "
+};
+
+static int NpcHigesN = sizeof (NpcHiges) / USERNAME_LEN;
+
+
+/************************************************/
+#ifdef MAKEWIN32
+/* convert Shift-jis to EUC-JP */
+static const char *
+convertC2H (char *p, int nlen)
+{
+  int i;
+  const char *pret = p;
+  for (i = 0; i < nlen && *p != '\0'; i++)
+    {
+      unsigned char c = *p++;
+      if (_ismbblead (c))
+	{
+	  /* first byte of KANJI */
+	  unsigned char c2 = *p++;
+	  unsigned int njis = _mbcjmstojis (((unsigned int) c << 8) | c2);
+	  njis |= 0x8080;	/* MBS up */
+	  *(p - 2) = (unsigned char) (njis >> 8);
+	  *(p - 1) = (unsigned char) njis;
+	  i++;
+	}
+    }
+  return pret;
+}
+
+/* convert EUC-JP to Shift-jis */
+static const char *
+convertH2C (char *p, int nlen)
+{
+  int i;
+  const char *pret = p;
+  for (i = 0; i < nlen && *p != '\0'; i++)
+    {
+      unsigned char c = *p++;
+      if (c & 0x80)
+	{
+	  /* first byte of KANJI */
+	  unsigned char c2 = *p++;
+	  unsigned int neuc = ((unsigned int) c << 8) | c2;
+	  unsigned int nsjis = _mbcjistojms (neuc & 0x7f7f);
+	  *(p - 2) = (unsigned char) (nsjis >> 8);
+	  *(p - 1) = (unsigned char) nsjis;
+	  i++;
+	}
+    }
+  return pret;
+}
+
+#endif /* MAKEWIN32 */
+
+/* search item for name */
+static int
+SearchItemForName (const char *p)
+{
+  int i;
+  for (i = 0; i < ItemLimit; i++)
+    {
+      if (!strncmp (Item[i].name, p, ITEMNAME_LEN))
+	{
+	  return i;
+	}
+    }
+  return 0;
+}
+
+/* cut tail space (this use fixed single buffer!) */
+static const char *
+cut_tail (const char *p, int n)
+{
+  static char work[MESG_BUFFER];
+  int i;
+  for (i = 0; i < n && *p != '\0'; i++)
+    {
+      work[i] = *p++;
+    }
+  for (i--; i >= 0; i--)
+    {
+      if (work[i] != ' ')
+	{
+	  break;
+	}
+    }
+  work[i + 1] = '\0';
+  return work;
+}
+
+#ifdef USE_MAIL
+/* make new mail */
+static MAILDATA *
+NewMail (void)
+{
+  MAILDATA *ret = malloc (sizeof (MAILDATA));
+  if (ret == NULL)
+    {
+      perror ("malloc");
+      fputs ("EVAC:not enoght to mail memory!", stderr);
+      exit (2);
+    }
+  memset (ret, 0, sizeof (MAILDATA));
+  ret->timestamp = time (NULL);
+  return ret;
+}
+
+/* free mail */
+static void
+FreeMail (MAILDATA * p)
+{
+  free (p);
+  return;
+}
+
+/* add message to mail */
+static int
+AddMessageMail (MAILDATA * p, char *packet)
+{
+  int ret = -1;
+  if (p->line < MAIL_LINE_LIMIT)
+    {
+      int n = *packet;
+      memcpy (p->message[p->line++], packet, n + 1);
+      ret = 0;
+    }
+  return ret;
+}
+
+/* reorder user mail box */
+static void
+ReorderMailbox (int nuser)
+{
+  int i;
+  for (i = 0; i < MAIL_BOX_LIMIT - 1; i++)
+    {
+      if (User[nuser].mail[i] == NULL)
+	{
+	  int j;
+	  for (j = i + 1; j < MAIL_BOX_LIMIT; j++)
+	    {
+	      if (User[nuser].mail[j] != NULL)
+		{
+		  break;
+		}
+	    }
+	  if (j == MAIL_BOX_LIMIT)
+	    {
+	      /* no more mail */
+	      break;
+	    }
+	  User[nuser].mail[i] = User[nuser].mail[j];
+	  User[nuser].mail[j] = NULL;
+	}
+      else if (User[User[nuser].mail[i]->fromuser].name[0] == '\0')
+	{
+	  /* this user is vanished */
+	  int j;
+	  FreeMail (User[nuser].mail[i]);
+	  for (j = i + 1; j < MAIL_BOX_LIMIT; j++)
+	    {
+	      if (User[nuser].mail[j] != NULL)
+		{
+		  break;
+		}
+	    }
+	  if (j == MAIL_BOX_LIMIT)
+	    {
+	      /* no more mail */
+	      break;
+	    }
+	  User[nuser].mail[i] = User[nuser].mail[j];
+	  User[nuser].mail[j] = NULL;
+	}
+    }
+  return;
+}
+
+/* add mail to user */
+static int
+AddMailUser (int nuser, MAILDATA * p)
+{
+  int ret = -1;
+  int i;
+  for (i = 0; i < MAIL_BOX_LIMIT; i++)
+    {
+      if (User[nuser].mail[i] == NULL)
+	{
+	  break;
+	}
+    }
+  if (i < MAIL_BOX_LIMIT)
+    {
+      User[nuser].mail[i] = p;
+      ret = 0;
+    }
+  return ret;
+}
+
+/* check new mail */
+static int
+CheckNewMail (int nuser)
+{
+  int i;
+  for (i = 0; i < MAIL_BOX_LIMIT; i++)
+    {
+      if (User[nuser].mail[i] != NULL && User[nuser].mail[i]->readflag == 0)
+	{
+	  return 1;
+	}
+    }
+  return 0;
+}
+
+#ifdef USE_BBS
+/* reorder bbs box */
+static void
+ReorderBBSbox (void)
+{
+  int i;
+  for (i = 0; i < BBS_BOX_LIMIT - 1; i++)
+    {
+      if (BBSdata[i] == NULL)
+	{
+	  int j;
+	  for (j = i + 1; j < BBS_BOX_LIMIT; j++)
+	    {
+	      if (BBSdata[j] != NULL)
+		{
+		  break;
+		}
+	    }
+	  if (j == BBS_BOX_LIMIT)
+	    {
+	      /* no more mail */
+	      break;
+	    }
+	  BBSdata[i] = BBSdata[j];
+	  BBSdata[j] = NULL;
+	}
+      else if (User[BBSdata[i]->fromuser].name[0] == '\0')
+	{
+	  /* this user is vanished */
+	  int j;
+	  FreeMail (BBSdata[i]);
+	  for (j = i + 1; j < BBS_BOX_LIMIT; j++)
+	    {
+	      if (BBSdata[j] != NULL)
+		{
+		  break;
+		}
+	    }
+	  if (j == BBS_BOX_LIMIT)
+	    {
+	      /* no more mail */
+	      break;
+	    }
+	  BBSdata[i] = BBSdata[j];
+	  BBSdata[j] = NULL;
+	}
+    }
+  return;
+}
+#endif /* USE_BBS */
+#endif /* USE_MAIL */
+
+#ifdef USE_SAVEMAP
+/* search weapon for name */
+static int
+SearchWeaponForName (const char *p)
+{
+  int i;
+  for (i = 0; i < WeaponLimit; i++)
+    {
+      if (!strncmp (Weapon[i].name, p, WEAPONNAME_LEN))
+	{
+	  return i;
+	}
+    }
+  return 0;
+}
+#endif /* USE_SAVEMAP */
+
+/* search weapon for name and user_type */
+static int
+SearchWeaponForNameType (const char *p, enum usertype_t c_type)
+{
+  int i;
+  for (i = 0; i < WeaponLimit; i++)
+    {
+      if (c_type == Hunter && Weapon[i].forhunter == 0)
+	{
+	  continue;
+	}
+      else if (c_type == Observer && Weapon[i].forhunter == 1)
+	{
+	  continue;
+	}
+      if (!strncmp (Weapon[i].name, p, WEAPONNAME_LEN))
+	{
+	  return i;
+	}
+    }
+  return 0;
+}
+
+/* tiny random generator */
+static int
+getrand (int nmin, int nmax)
+{
+  int n = nmax - nmin + 1;
+  /* too simple random value. it need more better code.;) */
+  int nbase = RAND_MAX / n;
+  int nceil = nbase * n;
+  int r;
+  do
+    {
+      r = rand ();
+    }
+  while (r >= nceil);
+  return r / nbase + nmin;
+}
+
+/* get relative direction */
+static int
+rel_dir (int n)
+{
+  return (getrand (1, 10) & 1) ? RelDirectionValue[n] : RelDirectionValue2[n];
+}
+
+#ifdef USE_FORK
+/* signal handler for send process */
+static void
+sighandler_send (int nsig)
+{
+  switch (nsig)
+    {
+    case SIGINT:
+#ifdef SIGHUP
+    case SIGHUP:
+#endif
+    case SIGTERM:
+    case SIGUSR1:
+      _exit (1);
+#ifdef SIGPIPE
+    case SIGPIPE:
+      break;
+#endif
+    }
+  return;
+}
+
+/* send process main */
+static void
+send_process (int handle, SOCKET hsock)
+{
+  unsigned char *packet_queue;
+  int queue_max = SENDPIPE_QUEUE_MAX;
+  int count = 0;
+  int wp = 0;
+  int rp = 0;
+  packet_queue = malloc (queue_max * PACKET_MAX);
+  if (packet_queue == NULL)
+    {
+      fputs ("EVAC CHILD:not enough to queue memory\n", stderr);
+      return;
+    }
+  /* receive from pipe,send to socket handle */
+  for (;;)
+    {
+      int result;
+      fd_set fds;
+      struct timeval tmout;
+      if (count == queue_max)
+	{
+	  /* full queue */
+	  fputs ("EVAC CHILD:full queue\n", stderr);
+	  return;
+	}
+      if (count)
+	{
+	  tmout.tv_sec = 0;
+	  tmout.tv_usec = 100000;
+	}
+      else
+	{
+	  tmout.tv_sec = 0;
+	  tmout.tv_usec = 0;
+	}
+      FD_ZERO (&fds);
+      FD_SET (handle, &fds);
+      result = select (handle + 1, &fds, NULL, NULL, &tmout);
+      if (result > 0 || count == 0)
+	{
+	  int n = 0;
+	  unsigned char *packet = packet_queue + wp * PACKET_MAX;
+	  while (n < PACKET_MAX)
+	    {
+	      int nread = read (handle, packet + n, PACKET_MAX - n);
+	      if (nread == -1)
+		{
+		  if (errno == EINTR)
+		    {
+		      continue;
+		    }
+		  /* error ! */
+		  perror ("read");
+		  fputs ("EVAC CHILD:occur error while reading pipe\n",
+			 stderr);
+		  return;
+		}
+	      if (!nread)
+		{
+		  /* uhmm. what's happen? */
+		  fputs ("EVAC CHILD:can't read pipe\n", stderr);
+		  return;
+		}
+	      n += nread;
+	    }
+	  wp = (wp + 1) % queue_max;
+	  count++;
+	}
+      else
+	{
+	  if (result < 0)
+	    {
+	      if (errno == EINTR)
+		{
+		  continue;
+		}
+	      fputs ("EVAC CHILD:occur error while wait for pipe\n", stderr);
+	      return;
+	    }
+	}
+      while (count)
+	{
+	  tmout.tv_sec = 0;
+	  tmout.tv_usec = 100000;
+	  FD_ZERO (&fds);
+	  FD_SET (hsock, &fds);
+	  result = select (hsock + 1, NULL, &fds, NULL, &tmout);
+	  if (result > 0)
+	    {
+	      unsigned char *packet = packet_queue + rp * PACKET_MAX;
+	      int n = packet[1];
+	      n += (int) (packet[0] & 0xc0) << 2;
+	      if (send_packet_c (hsock, packet, n))
+		{
+		  /* occur error! */
+		  fputs ("EVAC CHILD:occur error while sending data\n",
+			 stderr);
+		  return;
+		}
+	      rp = (rp + 1) % queue_max;
+	      count--;
+	    }
+	  else
+	    {
+	      if (result < 0)
+		{
+		  if (errno == EINTR)
+		    {
+		      continue;
+		    }
+		  fputs ("EVAC CHILD:occur error while wait for send\n",
+			 stderr);
+		  return;
+		}
+	      /* timeout. queue packet */
+	      break;
+	    }
+	}
+    }
+  return;
+}
+
+/* create send process */
+static void
+create_send_process (int nuser, SOCKET hsock)
+{
+  pid_t child;
+  int handle[2];
+  if (pipe (handle))
+    {
+      perror ("pipe");
+      fputs ("EVAC:create send pipe fail!\n", stderr);
+      exit (1);
+    }
+  if ((child = fork ()) == 0)
+    {
+      /* this is child process */
+#ifdef HAVE_SIGACTION
+      struct sigaction sa;
+      sa.sa_handler = sighandler_send;
+      sa.sa_flags = 0;
+      sigemptyset (&sa.sa_mask);
+      sigaction (SIGINT, &sa, NULL);
+#ifdef SIGHUP
+      sigaction (SIGHUP, &sa, NULL);
+#endif
+      sigaction (SIGTERM, &sa, NULL);
+#ifdef SIGPIPE
+      sigaction (SIGPIPE, &sa, NULL);
+#endif
+      sigaction (SIGUSR1, &sa, NULL);
+#else /* HAVE_SIGACTION */
+      signal (SIGINT, sighandler_send);
+#ifdef SIGHUP
+      signal (SIGHUP, sighandler_send);
+#endif
+      signal (SIGTERM, sighandler_send);
+#ifdef SIGPIPE
+      signal (SIGPIPE, sighandler_send);
+#endif
+      signal (SIGUSR1, sighandler_send);
+#endif /* HAVE_SIGACTION */
+      send_process (handle[0], hsock);
+      _exit (0);
+    }
+  else
+    {
+      close (handle[0]);
+      User[nuser].send_pid = child;
+      User[nuser].send_handle = handle[1];
+    }
+  return;
+}
+
+/* delete send_process  */
+static void
+delete_send_process (int nuser)
+{
+  if (User[nuser].send_handle != -1)
+    {
+      close (User[nuser].send_handle);
+      kill (User[nuser].send_pid, SIGUSR1);
+      waitpid (User[nuser].send_pid, NULL, 0);
+      User[nuser].send_pid = 0;
+      User[nuser].send_handle = -1;
+    }
+  return;
+}
+
+/* send via fork_process */
+static int
+send_pipe (int nuser, unsigned char *packet, int n)
+{
+  int death_counter = 10;	/* counter for death */
+  for (;;)
+    {
+      int result;
+      fd_set wfds;
+      struct timeval tmout;
+      tmout.tv_sec = 0;
+      tmout.tv_usec = 50000;
+      FD_ZERO (&wfds);
+      FD_SET (User[nuser].send_handle, &wfds);
+      result =
+	select (User[nuser].send_handle + 1, NULL, &wfds, NULL, &tmout);
+      if (result > 0)
+	{
+	  unsigned char buffer[PACKET_MAX];
+	  int i;
+	  memcpy (buffer, packet, n + 2);
+	  buffer[1] = n % 256;
+	  buffer[0] &= 0x3f;
+	  buffer[0] |= (n & 0x300) >> 2;
+	  i = 0;
+	  while (i < PACKET_MAX)
+	    {
+	      int nwrite =
+		write (User[nuser].send_handle, buffer + i, PACKET_MAX - i);
+	      if (nwrite == -1)
+		{
+		  if (errno == EINTR)
+		    {
+		      if (--death_counter == 0)
+			{
+			  /* death time ! */
+			  return -1;
+			}
+		      continue;
+		    }
+		  /* uhmm. perhaps network error */
+		  return -1;
+		}
+	      if (!nwrite)
+		{
+		  /* uhmm. perhaps child process died */
+		  return -1;
+		}
+	      i += nwrite;
+	    }
+	  return 0;
+	}
+      else
+	{
+	  /* uhmm. perhaps network error */
+	  if (result < 0 && errno == EINTR)
+	    {
+	      if (--death_counter == 0)
+		{
+		  /* death time ! */
+		  return -1;
+		}
+	      continue;
+	    }
+	}
+      return -1;
+    }
+}
+
+#endif /* USE_FORK */
+
+#ifdef USE_W32THREAD
+/* send message thread */
+static void
+send_message_queue_thread (void *arg)
+{
+  USERINFO *user = (USERINFO *) arg;
+  W32MSG_QUEUE *queue = user->w32queue;
+  SOCKET hsock = user->session.handle;
+  while (WaitForSingleObject (queue->hend, 0) == WAIT_TIMEOUT)
+    {
+      if (queue->count)
+	{
+	  int result;
+	  fd_set fds;
+	  struct timeval tmout;
+	  while (queue->count)
+	    {
+	      tmout.tv_sec = 0;
+	      tmout.tv_usec = 100000;
+	      FD_ZERO (&fds);
+	      FD_SET (hsock, &fds);
+	      result = select (hsock + 1, NULL, &fds, NULL, &tmout);
+	      if (result > 0)
+		{
+		  unsigned char *packet = queue->data[queue->read_pos];
+		  int n = packet[1];
+		  n += (int) (packet[0] & 0xc0) << 2;
+		  if (send_packet_c (hsock, packet, n))
+		    {
+		      /* occur error! */
+		      fputs ("EVAC CHILD:occur error while sending data\n",
+			     stderr);
+		      ENDTHREAD ();
+		    }
+		  queue->read_pos = (queue->read_pos + 1) % W32MSG_QUEUE_MAX;
+		  queue->count--;
+		}
+	      else
+		{
+		  if (result < 0)
+		    {
+		      if (errno == EINTR)
+			{
+			  continue;
+			}
+		      fputs ("EVAC THREAD:occur error while wait for send\n",
+			     stderr);
+		      ENDTHREAD ();
+		    }
+		  /* timeout. queue packet */
+		  break;
+		}
+	    }
+	}
+      else
+	{
+	  Sleep (1);
+	}
+    }
+  ENDTHREAD ();
+}
+
+/* create send thread */
+static void
+create_send_message_queue_thread (int nuser)
+{
+  User[nuser].w32queue = malloc (sizeof (W32MSG_QUEUE));
+  if (User[nuser].w32queue == NULL)
+    {
+      perror ("malloc");
+      fputs ("EVAC:not enough to queue thread memory\n", stderr);
+      exit (1);
+    }
+  User[nuser].w32queue->count = 0;
+  User[nuser].w32queue->read_pos = 0;
+  User[nuser].w32queue->write_pos = 0;
+  User[nuser].w32queue->hend = CreateEvent (NULL, TRUE, FALSE, NULL);
+  if (User[nuser].w32queue->hend == NULL)
+    {
+      fputs ("EVAC:can't create event handle for queue thread\n", stderr);
+      exit (1);
+    }
+  User[nuser].w32thread =
+    (HANDLE) MAKETHREAD (send_message_queue_thread, &User[nuser]);
+  return;
+}
+
+/* delete send thread */
+static void
+delete_send_message_queue_thread (int nuser)
+{
+  SetEvent (User[nuser].w32queue->hend);
+  WaitForSingleObject (User[nuser].w32thread, INFINITE);
+  CloseHandle (User[nuser].w32thread);
+  User[nuser].w32thread = NULL;
+  CloseHandle (User[nuser].w32queue->hend);
+  free (User[nuser].w32queue);
+  User[nuser].w32queue = NULL;
+  return;
+}
+
+/* send via message queue thread */
+static int
+send_thread (int nuser, unsigned char *packet, int n)
+{
+  int death_counter = 10;	/* counter for death */
+  W32MSG_QUEUE *queue = User[nuser].w32queue;
+  while (WaitForSingleObject (User[nuser].w32thread, 0))
+    {
+      if (queue->count < W32MSG_QUEUE_MAX)
+	{
+	  unsigned char *buffer = queue->data[queue->write_pos];
+	  int i;
+	  for (i = 0; i < n + 2; i++)
+	    {
+	      buffer[i] = packet[i];
+	    }
+	  buffer[1] = n % 256;
+	  buffer[0] &= 0x3f;
+	  buffer[0] |= (n & 0x300) >> 2;
+	  queue->write_pos = (queue->write_pos + 1) % W32MSG_QUEUE_MAX;
+	  queue->count++;
+	  return 0;
+	}
+      else
+	{
+	  /* uhmm. full queue */
+	  if (--death_counter == 0)
+	    {
+	      /* death! */
+	      break;
+	    }
+	}
+    }
+  return -1;
+}
+
+/* kill all thread */
+static void
+kill_all_send_message_queue_thread (void)
+{
+  int i;
+  for (i = 0; i < UserLimit; i++)
+    {
+      if (User[i].name[0] != '\0')
+	{
+	  if (User[i].w32thread != NULL)
+	    {
+	      SetEvent (User[i].w32queue->hend);
+	    }
+	}
+    }
+  return;
+}
+
+#endif /* USE_W32THREAD */
+
+#ifdef USE_SAVEMAP
+
+/* save map data and shop data */
+static int
+SaveMapData (const char *p)
+{
+  int ret = -1;
+  FILE *optr = fopen (p, "w");
+  if (optr != NULL)
+    {
+      int i;
+      fputs ("#SNAP0000--This is Hunter-online data file. DO NOT MODIFY!\n",
+	     optr);
+      fprintf (optr, "%d,%d,%d,%d,%d,%d,%d\n",
+	       MapWidth, MapHeight, UserLimit,
+	       USERSHOP_LIMIT, SELLINSHOP_LIMIT, JailPositionX,
+	       JailPositionY);
+      for (i = 0; i < MapWidth * MapHeight; i++)
+	{
+	  fprintf (optr, "%02X %02X %02X\n",
+		   Map[i].id & MAP_NOT_SAVE, Map[i].player, Map[i].owner);
+	}
+      for (i = 1; i < UserLimit; i++)
+	{
+	  int j;
+	  if (User[i].name[0] == '\0')
+	    {
+	      fputs ("0\n", optr);
+	      for (j = 0; j < USERSHOP_LIMIT; j++)
+		{
+		  fputs ("0,0,0, \n", optr);
+		}
+	    }
+	  else
+	    {
+	      fprintf (optr, "%d\n", User[i].crime_level);
+	      for (j = 0; j < USERSHOP_LIMIT; j++)
+		{
+		  char namebuf[BUFFER_SIZE];
+		  memcpy (namebuf, User[i].myshop[j].name, USERNAME_LEN);
+#ifdef MAKEWIN32
+		  convertH2C (namebuf, USERNAME_LEN);
+#endif
+		  fprintf (optr, "%d,%d,%d,%-.16s\n",
+			   User[i].myshop[j].build,
+			   User[i].myshop[j].pos.x, User[i].myshop[j].pos.y,
+			   namebuf);
+		  if (User[i].myshop[j].build)
+		    {
+		      int k;
+		      for (k = 0; k < SELLINSHOP_LIMIT; k++)
+			{
+			  memcpy (namebuf,
+				  Weapon[User[i].myshop[j].list[0][k]].name,
+				  WEAPONNAME_LEN);
+#ifdef MAKEWIN32
+			  convertH2C (namebuf, WEAPONNAME_LEN);
+#endif
+			  fprintf (optr, "%-.32s,%u,%u,%lu\n",
+				   namebuf,
+				   User[i].myshop[j].leftuse[0][k],
+				   User[i].myshop[j].count[0][k],
+				   User[i].myshop[j].cost[0][k]);
+			}
+		      for (k = 0; k < SELLINSHOP_LIMIT; k++)
+			{
+			  memcpy (namebuf,
+				  Item[User[i].myshop[j].list[1][k]].name,
+				  ITEMNAME_LEN);
+#ifdef MAKEWIN32
+			  convertH2C (namebuf, ITEMNAME_LEN);
+#endif
+			  fprintf (optr, "%-.32s,%u,%u,%lu\n",
+				   namebuf,
+				   User[i].myshop[j].leftuse[1][k],
+				   User[i].myshop[j].count[1][k],
+				   User[i].myshop[j].cost[1][k]);
+			}
+		    }
+		}
+	    }
+	}
+      ret = 0;
+      fclose (optr);
+    }
+  return ret;
+}
+
+/* load map data */
+static int
+load_sys_map (FILE * iptr)
+{
+  char work[BUFFER_SIZE];
+  int i;
+  puts ("load map data...");
+  for (i = 0; i < MapWidth * MapHeight; i++)
+    {
+      unsigned c[3];
+      if (fgets (work, sizeof (work), iptr) == NULL ||
+	  sscanf (work, "%02X %02X %02X", &c[0], &c[1], &c[2]) != 3)
+	{
+	  /* error */
+	  return -1;
+	}
+      Map[i].id = c[0];
+      Map[i].player = 0;
+      Map[i].animal = 0;
+      Map[i].owner = c[2];
+    }
+  return 0;
+}
+
+/* load one user-shop-data */
+static int
+load_sys_user_one (FILE * iptr, int nuser)
+{
+  int i;
+  char work[BUFFER_SIZE];
+  if (fgets (work, sizeof (work), iptr) == NULL ||
+      sscanf (work, "%d", &User[nuser].crime_level) != 1)
+    {
+      return -1;
+    }
+  for (i = 0; i < USERSHOP_LIMIT; i++)
+    {
+      int j;
+      char namebuf[BUFFER_SIZE];
+      if (fgets (work, sizeof (work), iptr) == NULL ||
+	  sscanf (work, "%d,%d,%d,%[^\n\r]",
+		  &User[nuser].myshop[i].build,
+		  &User[nuser].myshop[i].pos.x, &User[nuser].myshop[i].pos.y,
+		  namebuf) != 4)
+	{
+	  return -1;
+	}
+#ifdef MAKEWIN32
+      convertC2H (namebuf, USERNAME_LEN);
+#endif
+      for (j = 0; j < USERNAME_LEN && namebuf[0] != '\0'; j++)
+	{
+	  User[nuser].myshop[i].name[j] = namebuf[j];
+	}
+      for (; j < USERNAME_LEN; j++)
+	{
+	  User[nuser].myshop[i].name[j] = ' ';
+	}
+      if (User[nuser].myshop[i].build)
+	{
+	  for (j = 0; j < SELLINSHOP_LIMIT; j++)
+	    {
+	      if (fgets (work, sizeof (work), iptr) == NULL ||
+		  sscanf (work, "%[^,],%u,%u,%lu",
+			  namebuf,
+			  &User[nuser].myshop[i].leftuse[0][j],
+			  &User[nuser].myshop[i].count[0][j],
+			  &User[nuser].myshop[i].cost[0][j]) != 4)
+		{
+		  return -1;
+		}
+#ifdef MAKEWIN32
+	      convertC2H (namebuf, WEAPONNAME_LEN);
+#endif
+	      User[nuser].myshop[i].list[0][j] =
+		SearchWeaponForName (namebuf);
+	      if (User[nuser].myshop[i].list[0][j] == 0)
+		{
+		  User[nuser].myshop[i].count[0][j] = 0;
+		}
+	    }
+	  for (j = 0; j < SELLINSHOP_LIMIT; j++)
+	    {
+	      if (fgets (work, sizeof (work), iptr) == NULL ||
+		  sscanf (work, "%[^,],%u,%u,%lu",
+			  namebuf,
+			  &User[nuser].myshop[i].leftuse[1][j],
+			  &User[nuser].myshop[i].count[1][j],
+			  &User[nuser].myshop[i].cost[1][j]) != 4)
+		{
+		  return -1;
+		}
+#ifdef MAKEWIN32
+	      convertC2H (namebuf, ITEMNAME_LEN);
+#endif
+	      User[nuser].myshop[i].list[1][j] = SearchItemForName (namebuf);
+	      if (User[nuser].myshop[i].list[1][j] == 0)
+		{
+		  User[nuser].myshop[i].count[1][j] = 0;
+		}
+	    }
+	}
+    }
+  return 0;
+}
+
+/* load user-shop data */
+static int
+load_sys_user (FILE * iptr)
+{
+  int i;
+  puts ("load user-shop data...");
+  for (i = 1; i < UserLimit; i++)
+    {
+      if (User[i].name[0] != '\0')
+	{
+	  if (load_sys_user_one (iptr, i))
+	    {
+	      /* can't read user info */
+	      memset (User[i].myshop, 0, sizeof (User[i].myshop));
+	      User[i].crime_level = 0;
+	      return -1;
+	    }
+	}
+    }
+  return 0;
+}
+
+/* load map data and shop data */
+static int
+LoadMapData (const char *p)
+{
+  int ret = -1;
+  FILE *iptr = fopen (p, "r");
+  if (iptr != NULL)
+    {
+      char work[BUFFER_SIZE];
+      if (fgets (work, sizeof (work), iptr) == NULL ||
+	  memcmp (work, "#SNAP0000", 9))
+	{
+	  /* mismatch version */
+	  fputs ("Warning:system data file version mismatch\n", stderr);
+	}
+      else
+	{
+	  int width;
+	  int height;
+	  int usermax;
+	  int usershop_max;
+	  int sell_max;
+	  int jailx;
+	  int jaily;
+	  if (fgets (work, sizeof (work), iptr) != NULL &&
+	      sscanf (work, "%d,%d,%d,%d,%d,%d,%d",
+		      &width, &height, &usermax,
+		      &usershop_max, &sell_max, &jailx, &jaily) == 7)
+	    {
+	      if (width != MapWidth || height != MapHeight ||
+		  usermax != UserLimit || usershop_max != USERSHOP_LIMIT ||
+		  sell_max != SELLINSHOP_LIMIT ||
+		  jailx != JailPositionX || jaily != JailPositionY)
+		{
+		  /* uhmm. mismatch paramater */
+		  fputs ("Warnning: this system data can't load!\n", stderr);
+		}
+	      else
+		{
+		  if (load_sys_map (iptr) || load_sys_user (iptr))
+		    {
+		      /* cannot load data */
+		      fputs ("Warnning: this system data is broken!\n",
+			     stderr);
+		    }
+		  else
+		    {
+		      ret = 0;
+		    }
+		}
+	    }
+	}
+      fclose (iptr);
+    }
+  return ret;
+}
+
+#endif /* USE_SAVEMAP */
+
+/* adjust position */
+static void
+adjust_pos (int *px, int *py)
+{
+  int x = *px;
+  int y = *py;
+  if (x < 0)
+    {
+      x = MapWidth + x;
+    }
+  else if (x >= MapWidth)
+    {
+      x -= MapWidth;
+    }
+  if (y < 0)
+    {
+      y = MapHeight + y;
+    }
+  else if (y >= MapHeight)
+    {
+      y -= MapHeight;
+    }
+  *px = x;
+  *py = y;
+  return;
+}
+
+/* calculate delta x */
+static void
+calculate_delta_x (int x, int gx, int *dx1, int *dx2)
+{
+  if (gx > x)
+    {
+      *dx1 = gx - x;
+      *dx2 = x + MapWidth - gx;
+    }
+  else if (gx < x)
+    {
+      *dx1 = gx + MapWidth - x;
+      *dx2 = x - gx;
+    }
+  else
+    {
+      *dx1 = *dx2 = 0;
+    }
+  return;
+}
+
+/* calculate delta y */
+static void
+calculate_delta_y (int y, int gy, int *dy1, int *dy2)
+{
+  if (gy > y)
+    {
+      *dy1 = gy - y;
+      *dy2 = y + MapHeight - gy;
+    }
+  else if (gy < y)
+    {
+      *dy1 = gy + MapHeight - y;
+      *dy2 = y - gy;
+    }
+  else
+    {
+      *dy1 = *dy2 = 0;
+    }
+  return;
+}
+
+/* get relative position */
+static int
+get_rel_position_in (int dx1, int dx2, int dy1, int dy2)
+{
+  if (dx1 < dx2)
+    {
+      /* is east ... */
+      if (dy1 < dy2)
+	{
+	  /* is south */
+	  return REL_DIRECTION_SE;
+	}
+      else if (dy1 > dy2)
+	{
+	  /* is north */
+	  return REL_DIRECTION_NE;
+	}
+      else
+	{
+	  return REL_DIRECTION_E;
+	}
+    }
+  else if (dx1 > dx2)
+    {
+      /* is west ... */
+      if (dy1 < dy2)
+	{
+	  /* is south */
+	  return REL_DIRECTION_SW;
+	}
+      else if (dy1 > dy2)
+	{
+	  /* is north */
+	  return REL_DIRECTION_NW;
+	}
+      else
+	{
+	  return REL_DIRECTION_W;
+	}
+    }
+  else
+    {
+      if (dy1 < dy2)
+	{
+	  /* is south */
+	  return REL_DIRECTION_S;
+	}
+      else if (dy1 > dy2)
+	{
+	  /* is north */
+	  return REL_DIRECTION_N;
+	}
+      else
+	{
+	  return REL_DIRECTION_HERE;
+	}
+    }
+}
+
+/* calculate target distance(not precise) */
+static int
+get_rel_distance_in (int dx1, int dx2, int dy1, int dy2)
+{
+  if (dx1 > dx2)
+    {
+      dx1 = dx2;
+    }
+  if (dy1 > dy2)
+    {
+      dy1 = dy2;
+    }
+  return dx1 + dy1;
+}
+
+static int
+get_rel_distance (int x, int y, int gx, int gy)
+{
+  int dx1;
+  int dx2;
+  int dy1;
+  int dy2;
+  calculate_delta_x (x, gx, &dx1, &dx2);
+  calculate_delta_y (y, gy, &dy1, &dy2);
+  return get_rel_distance_in (dx1, dx2, dy1, dy2);
+}
+
+/* get animal-slot */
+static ANIMALDATA *
+get_animal_slot (int nuser)
+{
+  ANIMALDATA *ret = User[nuser].lastPickupAnimal[0];
+  int i;
+  if (User[nuser].animal_slot > 1)
+    {
+      for (i = 1; i < User[nuser].animal_slot; i++)
+	{
+	  User[nuser].lastPickupAnimal[i - 1] =
+	    User[nuser].lastPickupAnimal[i];
+	}
+    }
+  User[nuser].lastPickupAnimal[User[nuser].animal_slot - 1] = NULL;
+  return ret;
+}
+
+/* put animal_slot */
+static void
+put_animal_slot (int nuser, ANIMALDATA * p)
+{
+  int i;
+  for (i = User[nuser].animal_slot - 1; i > 0; i--)
+    {
+      User[nuser].lastPickupAnimal[i] = User[nuser].lastPickupAnimal[i - 1];
+    }
+  User[nuser].lastPickupAnimal[0] = p;
+  return;
+}
+
+/* clear animal slot */
+static void
+clear_animal_slot (int nuser)
+{
+  int i;
+  for (i = 0; i < User[nuser].animal_slot; i++)
+    {
+      User[nuser].lastPickupAnimal[i] = NULL;
+    }
+  return;
+}
+
+/* get npc weapon */
+static int
+get_npc_weapon (enum npctype_t c_type)
+{
+  int *table;
+  int *list;
+  int nlimit;
+  int total;
+  int n;
+  int i;
+  switch (c_type)
+    {
+    case NpcHunter:
+      table = NpcHunterWeaponTable;
+      total = NpcHunterWeaponTotal;
+      list = ForHunterWeapon;
+      nlimit = ForHunterWeaponLimit;
+      break;
+    case NpcObserver:
+      table = NpcObserverWeaponTable;
+      total = NpcObserverWeaponTotal;
+      list = ForObserverWeapon;
+      nlimit = ForObserverWeaponLimit;
+      break;
+    default:
+      return 0;
+    }
+  n = getrand (1, total);
+  for (i = 0; i < nlimit; i++)
+    {
+      if (table[i] >= n)
+	{
+	  return list[i];
+	}
+    }
+  return 0;
+}
+
+/* make new map data */
+static unsigned char
+make_newmapdata (void)
+{
+  if (getrand (1, 100) <= RateRoad)
+    {
+      return MAP_ROAD;
+    }
+  else
+    {
+      return getrand (MAP_ID_FIRST, MAP_ID_LAST);
+    }
+}
+
+/* new itembox */
+static void
+addUserItemBox (int x, int y, int isitem, int n, unsigned left,
+		const char *pstr)
+{
+  struct itembox_t *p = malloc (sizeof (struct itembox_t));
+  if (p == NULL)
+    {
+      /* oh,no. */
+      perror ("malloc");
+      fputs ("EVAC:not enough to itembox memory", stderr);
+      exit (1);
+    }
+  p->pprev = UserMadeItem;
+  p->pnext = NULL;
+  p->pos.x = x;
+  p->pos.y = y;
+  p->isitem = isitem;
+  p->n = n;
+  p->left = left;
+  if (pstr != NULL)
+    {
+      strncpy (p->message, pstr, sizeof (p->message));
+    }
+  else
+    {
+      memset (p->message, 0, sizeof (p->message));
+    }
+  if (UserMadeItem != NULL)
+    {
+      UserMadeItem->pnext = p;
+    }
+  UserMadeItem = p;
+  return;
+}
+
+/* get itembox */
+struct itembox_t *
+getUserItemBox (int x, int y)
+{
+  struct itembox_t *p = UserMadeItem;
+  while (p != NULL)
+    {
+      if (p->pos.x == x && p->pos.y == y)
+	{
+	  /* found */
+	  if (p == UserMadeItem)
+	    {
+	      UserMadeItem = p->pprev;
+	    }
+	  else
+	    {
+	      if (p->pprev != NULL)
+		{
+		  p->pprev->pnext = p->pnext;
+		}
+	      if (p->pnext != NULL)
+		{
+		  p->pnext->pprev = p->pprev;
+		}
+	    }
+	  return p;
+	}
+      p = p->pprev;
+    }
+  return NULL;
+}
+
+/* Make new map */
+static void
+MakeNewMap (void)
+{
+  int i;
+  for (i = 0; i < MapWidth * MapHeight; i++)
+    {
+      if (Map[i].id & MAP_HIGH_MASK)
+	{
+	  Map[i].id |= MAP_ROAD;
+	}
+      else
+	{
+	  Map[i].id |= make_newmapdata ();
+	}
+    }
+  return;
+}
+
+/* create root user */
+static void
+makeRootUser (void)
+{
+  int i;
+  i = 0;
+  User[0].name[i++] = 'r';
+  User[0].name[i++] = 'o';
+  User[0].name[i++] = 'o';
+  User[0].name[i++] = 't';
+  for (; i < USERNAME_LEN; i++)
+    {
+      User[0].name[i] = ' ';
+    }
+  memcpy (User[0].password, rootPassword, PASSWORD_LEN);
+  User[0].c_type = Observer;
+  return;
+}
+
+/* initialize user information */
+static void
+InitializeUser (void)
+{
+  int i;
+  for (i = 0; i < UserLimit; i++)
+    {
+      int j;
+      User[i].session.handle = INVALID_SOCKET;
+      User[i].session.addr = 0;
+      User[i].session.port = 0;
+      User[i].idletimer = 0;
+      memset (User[i].name, 0, sizeof (User[i].name));
+      memset (User[i].password, 0, sizeof (User[i].password));
+      for (j = 0; j < USERSHOP_LIMIT; j++)
+	{
+	  User[i].myshop[j].build = 0;
+	}
+#ifdef USE_MAIL
+      User[i].t_mail = NULL;
+      for (j = 0; j < MAIL_BOX_LIMIT; j++)
+	{
+	  User[i].mail[j] = NULL;
+	}
+#endif
+    }
+  makeRootUser ();
+  return;
+}
+
+/* clear user */
+static void
+ClearUser (int userno)
+{
+  int x;
+  int y;
+
+  x = User[userno].pos.x;
+  y = User[userno].pos.y;
+  if (MAP (x, y)->player == userno + 1)
+    {
+      MAP (x, y)->player = 0;
+    }
+  return;
+}
+
+/* disconnect */
+static int
+DisconnectUser (int userno)
+{
+#if DEBUG
+  if (!(userno > 0 && userno < UserLimit))
+    {
+      return -1;
+    }
+#endif
+  if (User[userno].session.handle != INVALID_SOCKET)
+    {
+      char work[USERNAME_LEN];
+#ifdef USE_FORK
+      delete_send_process (userno);
+#endif
+#ifdef USE_W32THREAD
+      delete_send_message_queue_thread (userno);
+#endif
+      cutsocket (User[userno].session.handle);
+      FD_CLR (User[userno].session.handle, &mainFDS);
+      User[userno].session.handle = INVALID_SOCKET;
+      User[userno].session.addr = 0;
+      User[userno].session.port = 0;
+      memset (User[userno].statusinfo, 0, PACKET_MAX);
+      memset (User[userno].mapdata, 0, PACKET_MAX);
+      memcpy (work, User[userno].name, USERNAME_LEN);
+#ifdef MAKEWIN32
+      convertH2C (work, USERNAME_LEN);
+#endif
+      printf ("user(%d)[%-16.16s] logoff.\n", userno, work);
+      User[userno].idletimer = 0;
+    }
+  ClearUser (userno);
+  return 0;
+}
+
+/* search user */
+static int
+SearchUser (const char *pname)
+{
+  int i;
+  char work[USERNAME_LEN];
+  for (i = 0; i < USERNAME_LEN; i++)
+    {
+      if (*(pname + i) == '\0')
+	{
+	  break;
+	}
+      work[i] = *(pname + i);
+    }
+  for (; i < USERNAME_LEN; i++)
+    {
+      work[i] = ' ';
+    }
+  for (i = 0; i < UserLimit; i++)
+    {
+      if (!memcmp (User[i].name, work, USERNAME_LEN))
+	{
+	  return i;
+	}
+    }
+  return -1;
+}
+
+/* new user */
+static int
+NewUser (const char *pname)
+{
+  int i;
+  char work[USERNAME_LEN];
+  for (i = 0; i < USERNAME_LEN; i++)
+    {
+      if (*(pname + i) == '\0')
+	{
+	  break;
+	}
+      work[i] = *(pname + i);
+    }
+  for (; i < USERNAME_LEN; i++)
+    {
+      work[i] = ' ';
+    }
+  for (i = 0; i < UserLimit; i++)
+    {
+      if (!memcmp (User[i].name, work, USERNAME_LEN))
+	{
+	  /* double user */
+	  return -2;
+	}
+      if (User[i].name[0] == '\0')
+	{
+	  /* new user */
+	  int j;
+	  memcpy (User[i].name, work, USERNAME_LEN);
+	  for (j = 0; j < USERSHOP_LIMIT; j++)
+	    {
+	      memcpy (User[i].myshop[j].name, User[i].name, USERNAME_LEN);
+	      User[i].myshop[j].build = 0;
+	    }
+	  memset (User[i].password, 0, PASSWORD_LEN);
+	  User[i].session.handle = INVALID_SOCKET;
+	  User[i].idletimer = 0;
+	  User[i].hp = 0;
+	  User[i].score = 100;
+	  User[i].speed = UserSpeed;
+	  User[i].speed_count = 0;
+	  memset (User[i].weapon, 0, sizeof (User[i].weapon));
+	  memset (User[i].bullette, 0, sizeof (User[i].bullette));
+	  memset (User[i].reload, 0, sizeof (User[i].reload));
+	  memset (User[i].item, 0, sizeof (User[i].item));
+	  memset (User[i].itemcount, 0, sizeof (User[i].itemcount));
+	  User[i].direction = 0;
+	  User[i].pos.x = 0;
+	  User[i].pos.y = 0;
+	  User[i].move = NoMove;
+	  User[i].action = NoAction;
+	  User[i].status = Healthy;
+	  User[i].maybearrest = 0;
+	  User[i].crime_level = 0;
+	  User[i].arrest_count = 0;
+	  User[i].cloak_count = 0;
+	  User[i].animal_slot = 1;
+	  for (j = 0; j < ANIMAL_SLOT_MAX; j++)
+	    {
+	      User[i].lastPickupAnimal[j] = NULL;
+	    }
+	  User[i].ride_pattern = 0;
+	  memset (User[i].higemesg, 0, sizeof (User[i].higemesg));
+	  memset (User[i].statusinfo, 0, PACKET_MAX);
+	  memset (User[i].mapdata, 0, PACKET_MAX);
+#ifdef USE_MAIL
+	  User[i].t_mail = NULL;
+	  for (j = 0; j < MAIL_BOX_LIMIT; j++)
+	    {
+	      User[i].mail[j] = NULL;
+	    }
+#endif
+#ifdef USE_FORK
+	  User[i].send_pid = 0;
+	  User[i].send_handle = -1;
+#endif
+#ifdef USE_W32THREAD
+	  User[i].w32thread = NULL;
+	  User[i].w32queue = NULL;
+#endif
+	  return i;
+	}
+    }
+  /* no user */
+  return -1;
+}
+
+/* delete user */
+static int
+DeleteUser (int userno)
+{
+#if DEBUG
+  if (!(userno > 0 && userno < UserLimit))
+    {
+      return -1;
+    }
+#endif
+  if (userno == 0)
+    {
+      /* can't delete root user */
+      return -1;
+    }
+  if (User[userno].session.handle != INVALID_SOCKET)
+    {
+      DisconnectUser (userno);
+    }
+  memset (User[userno].name, 0, sizeof (User[userno].name));
+  memset (User[userno].password, 0, sizeof (User[userno].password));
+  return 0;
+}
+
+/* set activate information */
+static int
+ActivateUser (int userno)
+{
+  int x;
+  int y;
+  int need_repos = 0;
+#if DEBUG
+  if (!(userno > 0 && userno < UserLimit) || User[userno].name[0] == '\0')
+    {
+      return -1;
+    }
+#endif
+  if (User[userno].hp == 0)
+    {
+      /* reborn */
+      int j;
+      User[userno].hp = (userno == 0) ? HpLimit : HpBase;
+      User[userno].hungry = (userno == 0) ? HungryLimit : HungryBase;
+      memset (User[userno].weapon, 0, sizeof (User[userno].weapon));
+      memset (User[userno].bullette, 0, sizeof (User[userno].bullette));
+      memset (User[userno].item, 0, sizeof (User[userno].item));
+      memset (User[userno].itemcount, 0, sizeof (User[userno].itemcount));
+      User[userno].maybearrest = 0;
+      User[userno].crime_level = 0;
+      User[userno].arrest_count = 0;
+      User[userno].cloak_count = 0;
+      User[userno].hold_count = 0;
+      User[userno].speed = (userno == 0) ? 1 : UserSpeed;
+      User[userno].status = Healthy;
+      User[userno].animal_slot = (userno == 0) ? ANIMAL_SLOT_MAX : 1;
+      for (j = 0; j < ANIMAL_SLOT_MAX; j++)
+	{
+	  User[userno].lastPickupAnimal[j] = NULL;
+	}
+      User[userno].ride_pattern = 0;
+      need_repos = 1;
+    }
+  x = User[userno].pos.x;
+  y = User[userno].pos.y;
+  if (User[userno].status != Arrested)
+    {
+      if (!need_repos &&
+	  ((MAP (x, y)->id & MAP_NOT_MOVE) || MAP (x, y)->player))
+	{
+	  need_repos = 1;
+	}
+    }
+  if (need_repos)
+    {
+      int i;
+      int posmax = 0;
+      int posx[USERSHOP_LIMIT];
+      int posy[USERSHOP_LIMIT];
+      for (i = 0; i < USERSHOP_LIMIT; i++)
+	{
+	  if (User[userno].myshop[i].build)
+	    {
+	      x = User[userno].myshop[i].pos.x;
+	      y = User[userno].myshop[i].pos.y;
+	      if (MAP (x, y)->player == 0 && !(MAP (x, y)->id & MAP_NOT_MOVE))
+		{
+		  /* ok */
+		  posx[posmax] = x;
+		  posy[posmax] = y;
+		  posmax++;
+		}
+	    }
+	}
+      if (posmax)
+	{
+	  int n = 0;
+	  if (posmax > 1)
+	    {
+	      n = getrand (0, posmax - 1);
+	    }
+	  x = posx[n];
+	  y = posy[n];
+	  need_repos = 0;
+	}
+      if (need_repos)
+	{
+	  do
+	    {
+	      x = getrand (0, MapWidth - 1);
+	      y = getrand (0, MapHeight - 1);
+	    }
+	  while (MAP (x, y)->player ||
+		 (MAP (x, y)->id & (MAP_NOT_MOVE | MAP_THERE_SHOP)) ||
+		 ((MAP (x, y)->id & MAP_MASK) == MAP_ROCK));
+	}
+      User[userno].pos.x = x;
+      User[userno].pos.y = y;
+      User[userno].direction = DIRECTION_N;
+    }
+  if (User[userno].status != Arrested)
+    {
+      MAP (x, y)->player = userno + 1;
+    }
+  if (MAP (x, y)->id & MAP_THERE_SHOP)
+    {
+      User[userno].status = Shopping;
+    }
+  User[userno].wk_direction = User[userno].direction;
+  memset (User[userno].reload, 0, sizeof (User[userno].reload));
+  User[userno].move = NoMove;
+  User[userno].action = NoAction;
+  User[userno].idletimer = 0;
+  User[userno].speed_count = 0;
+  User[userno].lastuser = -1;
+  User[userno].lastuser_type = TargetNone;
+  memset (User[userno].statusinfo, 0, PACKET_MAX);
+  memset (User[userno].mapdata, 0, PACKET_MAX);
+  return 0;
+}
+
+#ifdef USE_MAIL
+/* make mail prefix */
+static void
+make_mail_prefix (const char *puser, char *outbuffer)
+{
+  int i;
+  strncpy (outbuffer, puser, USERNAME_LEN);
+#ifdef MAKEWIN32
+  convertH2C (outbuffer, USERNAME_LEN);
+#endif
+  for (i = USERNAME_LEN - 1; i >= 0; i--)
+    {
+      if (outbuffer[i] != ' ')
+	{
+	  break;
+	}
+    }
+  outbuffer[i + 1] = '\0';
+  return;
+}
+
+/* load mail data */
+static int
+LoadMail (int nuser, const char *prefix)
+{
+  FILE *iptr;
+  char fname[BUFFER_SIZE];
+  sprintf (fname, "%s/h-mail.%s", DATA_DIR, prefix);
+  iptr = fopen (fname, "r");
+  if (iptr != NULL)
+    {
+      unsigned nmax;
+      char work[BUFFER_SIZE];
+      if (fgets (work, sizeof (work), iptr) == NULL)
+	{
+	  /* error */
+	  fputs ("Warnning: can't read mail data!\n", stderr);
+	}
+      else if (!memcmp (work, "#M0100", 6))
+	{
+	  if (fgets (work, sizeof (work), iptr) == NULL ||
+	      sscanf (work, "%u", &nmax) != 1 || nmax > MAIL_BOX_LIMIT)
+	    {
+	      /* this file is broken */
+	      fputs ("mail data file is broken.\n", stderr);
+	      fclose (iptr);
+	      return -1;
+	    }
+	  else
+	    {
+	      int i;
+	      char namebuf[BUFFER_SIZE];
+	      for (i = 0; i < nmax; i++)
+		{
+		  MAILDATA *pmail = NewMail ();
+		  unsigned long tstamp;
+		  unsigned n;
+		  int j;
+		  if (fgets (work, sizeof (work), iptr) == NULL ||
+		      sscanf (work, "%d,%d,%lu",
+			      &pmail->readflag, &pmail->line, &tstamp) != 3)
+		    {
+		      FreeMail (pmail);
+		      break;
+		    }
+		  pmail->timestamp = tstamp;
+		  if (fgets (work, sizeof (work), iptr) == NULL ||
+		      sscanf (work, "%[^\n\r]", namebuf) != 1)
+		    {
+		      FreeMail (pmail);
+		      break;
+		    }
+#ifdef MAKEWIN32
+		  convertC2H (namebuf, USERNAME_LEN);
+#endif
+		  pmail->fromuser = SearchUser (namebuf);
+		  if (pmail->fromuser == -1)
+		    {
+		      FreeMail (pmail);
+		      break;
+		    }
+		  if (fgets (work, sizeof (work), iptr) == NULL)
+		    {
+		      FreeMail (pmail);
+		      break;
+		    }
+		  namebuf[0] = '\0';
+		  sscanf (work, "%[^\n\r]", namebuf);
+		  n = strlen (namebuf);
+		  if (n > PACKET_DATA_MAX - 1)
+		    {
+		      n = PACKET_DATA_MAX - 1;
+		    }
+#ifdef MAKEWIN32
+		  convertC2H (namebuf, n);
+#endif
+		  pmail->subject[0] = n;
+		  if (n)
+		    {
+		      strncpy (&pmail->subject[1], namebuf, n);
+		    }
+		  for (j = 0; j < pmail->line; j++)
+		    {
+		      if (fgets (work, sizeof (work), iptr) == NULL)
+			{
+			  FreeMail (pmail);
+			  break;
+			}
+		      namebuf[0] = '\0';
+		      sscanf (work, "%[^\n\r]", namebuf);
+		      n = strlen (namebuf);
+		      if (n > PACKET_DATA_MAX - 1)
+			{
+			  n = PACKET_DATA_MAX - 1;
+			}
+#ifdef MAKEWIN32
+		      convertC2H (namebuf, n);
+#endif
+		      pmail->message[j][0] = n;
+		      if (n)
+			{
+			  strncpy (&pmail->message[j][1], namebuf, n);
+			}
+		    }
+		  if (j < pmail->line)
+		    {
+		      /* occur error */
+		      break;
+		    }
+		  User[nuser].mail[i] = pmail;
+		}
+	    }
+	}
+      else
+	{
+	  fputs ("Warnning: mismatch mail data version\n", stderr);
+	}
+      fclose (iptr);
+    }
+  return (iptr != NULL) ? 0 : -1;
+}
+
+/* save mail data */
+static int
+SaveMail (int nuser, const char *prefix)
+{
+  FILE *optr;
+  char fname[BUFFER_SIZE];
+  sprintf (fname, "%s/h-mail.%s", DATA_DIR, prefix);
+  optr = fopen (fname, "w");
+  if (optr != NULL)
+    {
+      int i;
+      fprintf (optr, "#M0100 Hunter-online mail file -DO NOT MODIFY!-\n%u\n",
+	       MAIL_BOX_LIMIT);
+      ReorderMailbox (nuser);
+      for (i = 0; i < MAIL_BOX_LIMIT; i++)
+	{
+	  int j;
+	  unsigned n;
+	  char work[BUFFER_SIZE];
+	  char namebuf[BUFFER_SIZE];
+	  MAILDATA *pmail = User[nuser].mail[i];
+	  if (pmail == NULL)
+	    {
+	      break;
+	    }
+	  strncpy (namebuf, User[pmail->fromuser].name, USERNAME_LEN);
+	  namebuf[USERNAME_LEN] = '\0';
+#ifdef MAKEWIN32
+	  convertH2C (namebuf, USERNAME_LEN);
+#endif
+	  fprintf (optr, "%d,%d,%lu\n%-.16s\n",
+		   pmail->readflag, pmail->line, pmail->timestamp, namebuf);
+	  n = (unsigned char) (pmail->subject[0]);
+	  if (n)
+	    {
+	      memcpy (work, &pmail->subject[1], n);
+	    }
+	  work[n] = '\0';
+#ifdef MAKEWIN32
+	  convertH2C (work, n);
+#endif
+	  fprintf (optr, "%s\n", work);
+	  for (j = 0; j < pmail->line; j++)
+	    {
+	      n = (unsigned char) (pmail->message[j][0]);
+	      if (n)
+		{
+		  memcpy (work, &pmail->message[j][1], n);
+		}
+	      work[n] = '\0';
+#ifdef MAKEWIN32
+	      convertH2C (work, n);
+#endif
+	      fprintf (optr, "%s\n", work);
+	    }
+	}
+      fclose (optr);
+    }
+  return (optr != NULL) ? 0 : -1;
+}
+
+/* load mail for all user */
+static int
+LoadAllMail (void)
+{
+  int ret = 0;
+  int i;
+  for (i = 0; i < UserLimit; i++)
+    {
+      if (User[i].name[0] != '\0')
+	{
+	  char namebuf[USERNAME_LEN + 1];
+	  make_mail_prefix (User[i].name, namebuf);
+	  if (LoadMail (i, namebuf))
+	    {
+	      ret = -1;
+	      break;
+	    }
+	}
+    }
+  return ret;
+}
+
+/* save mail for all user */
+static int
+SaveAllMail (void)
+{
+  int ret = 0;
+  int i;
+  for (i = 0; i < UserLimit; i++)
+    {
+      if (User[i].name[0] != '\0')
+	{
+	  char namebuf[USERNAME_LEN + 1];
+	  make_mail_prefix (User[i].name, namebuf);
+	  if (SaveMail (i, namebuf))
+	    {
+	      ret = -1;
+	      break;
+	    }
+	}
+    }
+  return ret;
+}
+
+#ifdef USE_BBS
+/* load BBS data */
+static int
+LoadBBS (void)
+{
+  FILE *iptr;
+  char fname[BUFFER_SIZE];
+  sprintf (fname, "%s/%s", DATA_DIR, BBS_DATA_FILE);
+  iptr = fopen (fname, "r");
+  if (iptr != NULL)
+    {
+      unsigned nmax;
+      char work[BUFFER_SIZE];
+      if (fgets (work, sizeof (work), iptr) == NULL)
+	{
+	  /* error */
+	  fputs ("Warnning: can't read bbs data!\n", stderr);
+	}
+      else if (!memcmp (work, "#B0100", 6))
+	{
+	  if (fgets (work, sizeof (work), iptr) == NULL ||
+	      sscanf (work, "%u", &nmax) != 1 || nmax > BBS_BOX_LIMIT)
+	    {
+	      /* this file is broken */
+	      fputs ("bbs data file is broken.\n", stderr);
+	      fclose (iptr);
+	      return -1;
+	    }
+	  else
+	    {
+	      int i;
+	      char namebuf[BUFFER_SIZE];
+	      for (i = 0; i < nmax; i++)
+		{
+		  MAILDATA *pmail = NewMail ();
+		  unsigned long tstamp;
+		  unsigned n;
+		  int j;
+		  if (fgets (work, sizeof (work), iptr) == NULL ||
+		      sscanf (work, "%d,%d,%lu",
+			      &pmail->readflag, &pmail->line, &tstamp) != 3)
+		    {
+		      FreeMail (pmail);
+		      break;
+		    }
+		  pmail->timestamp = tstamp;
+		  if (fgets (work, sizeof (work), iptr) == NULL ||
+		      sscanf (work, "%[^\n\r]", namebuf) != 1)
+		    {
+		      FreeMail (pmail);
+		      break;
+		    }
+#ifdef MAKEWIN32
+		  convertC2H (namebuf, USERNAME_LEN);
+#endif
+		  pmail->fromuser = SearchUser (namebuf);
+		  if (pmail->fromuser == -1)
+		    {
+		      FreeMail (pmail);
+		      break;
+		    }
+		  if (fgets (work, sizeof (work), iptr) == NULL)
+		    {
+		      FreeMail (pmail);
+		      break;
+		    }
+		  namebuf[0] = '\0';
+		  sscanf (work, "%[^\n\r]", namebuf);
+		  n = strlen (namebuf);
+		  if (n > PACKET_DATA_MAX - 1)
+		    {
+		      n = PACKET_DATA_MAX - 1;
+		    }
+#ifdef MAKEWIN32
+		  convertC2H (namebuf, n);
+#endif
+		  pmail->subject[0] = n;
+		  if (n)
+		    {
+		      strncpy (&pmail->subject[1], namebuf, n);
+		    }
+		  for (j = 0; j < pmail->line; j++)
+		    {
+		      if (fgets (work, sizeof (work), iptr) == NULL)
+			{
+			  FreeMail (pmail);
+			  break;
+			}
+		      namebuf[0] = '\0';
+		      sscanf (work, "%[^\n\r]", namebuf);
+		      n = strlen (namebuf);
+		      if (n > PACKET_DATA_MAX - 1)
+			{
+			  n = PACKET_DATA_MAX - 1;
+			}
+#ifdef MAKEWIN32
+		      convertC2H (namebuf, n);
+#endif
+		      pmail->message[j][0] = n;
+		      if (n)
+			{
+			  strncpy (&pmail->message[j][1], namebuf, n);
+			}
+		    }
+		  if (j < pmail->line)
+		    {
+		      /* occur error */
+		      break;
+		    }
+		  BBSdata[i] = pmail;
+		}
+	    }
+	}
+      else
+	{
+	  fputs ("Warnning: mismatch bbs data version\n", stderr);
+	}
+      fclose (iptr);
+    }
+  return (iptr != NULL) ? 0 : -1;
+}
+
+/* save bbs data */
+static int
+SaveBBS (void)
+{
+  FILE *optr;
+  char fname[BUFFER_SIZE];
+  sprintf (fname, "%s/%s", DATA_DIR, BBS_DATA_FILE);
+  optr = fopen (fname, "w");
+  if (optr != NULL)
+    {
+      int i;
+      fprintf (optr, "#B0100 Hunter-online bbs file -DO NOT MODIFY!-\n%u\n",
+	       BBS_BOX_LIMIT);
+      ReorderBBSbox ();
+      for (i = 0; i < BBS_BOX_LIMIT; i++)
+	{
+	  int j;
+	  unsigned n;
+	  char work[BUFFER_SIZE];
+	  char namebuf[BUFFER_SIZE];
+	  MAILDATA *pmail = BBSdata[i];
+	  if (pmail == NULL)
+	    {
+	      break;
+	    }
+	  strncpy (namebuf, User[pmail->fromuser].name, USERNAME_LEN);
+	  namebuf[USERNAME_LEN] = '\0';
+#ifdef MAKEWIN32
+	  convertH2C (namebuf, USERNAME_LEN);
+#endif
+	  fprintf (optr, "%d,%d,%lu\n%-.16s\n",
+		   pmail->readflag, pmail->line, pmail->timestamp, namebuf);
+	  n = (unsigned char) (pmail->subject[0]);
+	  if (n)
+	    {
+	      memcpy (work, &pmail->subject[1], n);
+	    }
+	  work[n] = '\0';
+#ifdef MAKEWIN32
+	  convertH2C (work, n);
+#endif
+	  fprintf (optr, "%s\n", work);
+	  for (j = 0; j < pmail->line; j++)
+	    {
+	      n = (unsigned char) (pmail->message[j][0]);
+	      if (n)
+		{
+		  memcpy (work, &pmail->message[j][1], n);
+		}
+	      work[n] = '\0';
+#ifdef MAKEWIN32
+	      convertH2C (work, n);
+#endif
+	      fprintf (optr, "%s\n", work);
+	    }
+	}
+      fclose (optr);
+    }
+  return (optr != NULL) ? 0 : -1;
+}
+#endif /* USE_BBS */
+#endif /* USE_MAIL */
+
+/* load user information */
+static int
+LoadUser (const char *pfilename)
+{
+  int ret = -1;
+  FILE *iptr = fopen (pfilename, "r");
+  if (iptr != NULL)
+    {
+      char work[BUFFER_SIZE];
+      if (fgets (work, sizeof (work), iptr) != NULL)
+	{
+	  int ver = 0;
+	  if (!memcmp (work, "#H0105", 6))
+	    {
+	      ver = 5;
+	    }
+	  else if (!memcmp (work, "#H0106", 6))
+	    {
+	      ver = 6;
+	    }
+	  if (ver == 0)
+	    {
+	      /* mismatch version */
+	      fputs ("Warning:User data file version mismatch\n", stderr);
+	    }
+	  else
+	    {
+	      int nusermax;
+	      if (fgets (work, sizeof (work), iptr) == NULL ||
+		  sscanf (work, "%d", &nusermax) != 1 ||
+		  nusermax > UserLimit - 1)
+		{
+		  /* modify? */
+		  fputs ("Warnning:User data file is broken\n", stderr);
+		}
+	      else
+		{
+		  int i;
+		  printf ("%d users in data-file\n", nusermax);
+		  nusermax++;
+		  for (i = 1; i < nusermax; i++)
+		    {
+		      int j;
+		      unsigned long nwk;
+		      memset (User[i].myshop, 0, sizeof (User[i].myshop));
+		      memset (User[i].higemesg, 0, sizeof (User[i].higemesg));
+		      if (fgets (work, sizeof (work), iptr) == NULL)
+			{
+			  break;
+			}
+#ifdef MAKEWIN32
+		      convertC2H (work, strlen (work));
+#endif
+		      for (j = 0; work[j] != '\0' && j < USERNAME_LEN; j++)
+			{
+			  User[i].name[j] = work[j];
+			}
+		      for (; j < USERNAME_LEN; j++)
+			{
+			  User[i].name[j] = ' ';
+			}
+		      for (j = 0; j < USERSHOP_LIMIT; j++)
+			{
+			  memcpy (User[i].myshop[j].name,
+				  User[i].name, USERNAME_LEN);
+			  User[i].myshop[j].build = 0;
+			}
+		      if (fgets (work, sizeof (work), iptr) == NULL)
+			{
+			  break;
+			}
+#ifdef MAKEWIN32
+		      convertC2H (work, strlen (work));
+#endif
+		      for (j = 0; work[j] != '\0' && j < PASSWORD_LEN; j++)
+			{
+			  User[i].password[j] = work[j];
+			}
+		      for (; j < USERNAME_LEN; j++)
+			{
+			  User[i].password[j] = ' ';
+			}
+		      if (fgets (work, sizeof (work), iptr) == NULL)
+			{
+			  break;
+			}
+		      if (sscanf (work, "%lu", &User[i].score) != 1)
+			{
+			  break;
+			}
+		      if (fgets (work, sizeof (work), iptr) == NULL)
+			{
+			  break;
+			}
+		      if (ver == 5)
+			{
+			  if (sscanf (work, "%lu,%d,%d,%d,%d,%d", &nwk,
+				      &j, &User[i].pos.x, &User[i].pos.y,
+				      &User[i].speed,
+				      &User[i].animal_slot) != 6)
+			    {
+			      break;
+			    }
+			  User[i].ride_pattern = 0;
+			}
+		      else
+			{
+			  if (sscanf (work, "%lu,%d,%d,%d,%d,%d,%d", &nwk,
+				      &j, &User[i].pos.x, &User[i].pos.y,
+				      &User[i].speed,
+				      &User[i].animal_slot,
+				      &User[i].ride_pattern) != 7)
+			    {
+			      break;
+			    }
+			}
+		      User[i].c_type = nwk ? Observer : Hunter;
+		      User[i].direction = j;
+		      for (j = 0; j < WEAPON_MAX; j++)
+			{
+			  char namebuf[BUFFER_SIZE];
+			  if (fgets (work, sizeof (work), iptr) == NULL)
+			    {
+			      break;
+			    }
+			  if (sscanf (work, "%[^,],%lu", namebuf, &nwk) != 2)
+			    {
+			      break;
+			    }
+#ifdef MAKEWIN32
+			  convertC2H (namebuf, strlen (namebuf));
+#endif
+			  User[i].weapon[j] =
+			    SearchWeaponForNameType (namebuf, User[i].c_type);
+			  if (User[i].weapon[j])
+			    {
+			      User[i].bullette[j] = nwk;
+			    }
+			  else
+			    {
+			      User[i].bullette[j] = 0;
+			    }
+			}
+		      if (j < WEAPON_MAX)
+			{
+			  break;
+			}
+		      for (j = 0; j < ITEM_MAX; j++)
+			{
+			  char namebuf[BUFFER_SIZE];
+			  if (fgets (work, sizeof (work), iptr) == NULL)
+			    {
+			      break;
+			    }
+			  if (sscanf (work, "%[^,],%lu", namebuf, &nwk) != 2)
+			    {
+			      break;
+			    }
+#ifdef MAKEWIN32
+			  convertC2H (namebuf, strlen (namebuf));
+#endif
+			  User[i].item[j] = SearchItemForName (namebuf);
+			  if (User[i].item[j])
+			    {
+			      User[i].itemcount[j] = nwk;
+			    }
+			  else
+			    {
+			      User[i].itemcount[j] = 0;
+			    }
+			}
+		      if (j < ITEM_MAX)
+			{
+			  break;
+			}
+		      User[i].hp = HpBase;
+		      User[i].hungry = HungryBase;
+		      User[i].maybearrest = 0;
+		      User[i].crime_level = 0;
+		      User[i].arrest_count = 0;
+		      for (j = 0; j < ANIMAL_SLOT_MAX; j++)
+			{
+			  User[i].lastPickupAnimal[j] = NULL;
+			}
+#ifdef USE_FORK
+		      User[i].send_pid = 0;
+		      User[i].send_handle = -1;
+#endif
+#ifdef USE_W32THREAD
+		      User[i].w32thread = NULL;
+		      User[i].w32queue = NULL;
+#endif
+		    }
+		  printf ("%d users loaded\n", i);
+		  if (i < nusermax)
+		    {
+		      /* perhaps error. clear last user data */
+		      memset (User[i].name, 0, USERNAME_LEN);
+		      memset (User[i].password, 0, PASSWORD_LEN);
+		      User[i].score = 0;
+		      fputs ("Warnning: possible to error loading userdata\n",
+			     stderr);
+		    }
+		}
+	    }
+	}
+      fclose (iptr);
+      ret = 0;
+    }
+  return ret;
+}
+
+/* save user information */
+static int
+SaveUser (const char *pfilename)
+{
+  int ret = -1;
+  FILE *optr = fopen (pfilename, "w");
+  if (optr != NULL)
+    {
+      int i;
+      int nusermax = 0;
+      fputs ("#H0106 Hunter-Online USER DATA FILE - Do not modify!\n", optr);
+      for (i = 1; i < UserLimit; i++)
+	{
+	  if (User[i].name[0] != '\0')
+	    {
+	      nusermax++;
+	    }
+	}
+      fprintf (optr, "%d\n", nusermax);
+      for (i = 1; i < UserLimit; i++)
+	{
+	  if (User[i].name[0] != '\0')
+	    {
+	      int j;
+	      char work[BUFFER_SIZE];
+	      memcpy (work, User[i].name, USERNAME_LEN);
+	      work[USERNAME_LEN] = '\0';
+#ifdef MAKEWIN32
+	      convertH2C (work, USERNAME_LEN);
+#endif
+	      fprintf (optr, "%-*s\n", USERNAME_LEN, work);
+	      memcpy (work, User[i].password, PASSWORD_LEN);
+	      work[PASSWORD_LEN] = '\0';
+#ifdef MAKEWIN32
+	      convertH2C (work, PASSWORD_LEN);
+#endif
+	      fprintf (optr, "%-*s\n", PASSWORD_LEN, work);
+	      fprintf (optr, "%lu\n", User[i].score);
+	      fprintf (optr, "%d,%d,%d,%d,%d,%d,%d\n", User[i].c_type,
+		       User[i].direction, User[i].pos.x, User[i].pos.y,
+		       User[i].speed, User[i].animal_slot,
+		       User[i].ride_pattern);
+	      for (j = 0; j < WEAPON_MAX; j++)
+		{
+		  memcpy (work, Weapon[User[i].weapon[j]].name,
+			  WEAPONNAME_LEN);
+		  work[WEAPONNAME_LEN] = '\0';
+#ifdef MAKEWIN32
+		  convertH2C (work, WEAPONNAME_LEN);
+#endif
+		  fprintf (optr, "%s,%u\n", work, User[i].bullette[j]);
+		}
+	      for (j = 0; j < ITEM_MAX; j++)
+		{
+		  memcpy (work, Item[User[i].item[j]].name, ITEMNAME_LEN);
+		  work[ITEMNAME_LEN] = '\0';
+#ifdef MAKEWIN32
+		  convertH2C (work, ITEMNAME_LEN);
+#endif
+		  fprintf (optr, "%s,%u\n", work, User[i].itemcount[j]);
+		}
+	    }
+	}
+      fclose (optr);
+      ret = 0;
+    }
+  return ret;
+}
+
+/* load animal information */
+static int
+LoadAnimal (const char *pfilename)
+{
+  int ret = -1;
+  FILE *iptr;
+  iptr = fopen (pfilename, "r");
+  if (iptr != NULL)
+    {
+      int n = 0;
+      char lbuf[BUFFER_SIZE];
+      char namebuf[BUFFER_SIZE];
+      char inamebuf[BUFFER_SIZE];
+      ret = 0;
+      while (fgets (lbuf, sizeof (lbuf), iptr) != NULL)
+	{
+	  int i;
+	  ANIMALDATA *p;
+	  if (lbuf[0] == '#')
+	    {
+	      /* this line is comment */
+	      continue;
+	    }
+	  if (n >= AnimalDataLimit)
+	    {
+	      /* need expand */
+	      p = realloc (AnimalData, sizeof (ANIMALDATA) *
+			   (AnimalDataLimit + ALLOCATE_CHUNK));
+	      if (p == NULL)
+		{
+		  /* ??can't allocate memory */
+		  free (AnimalData);
+		  AnimalData = NULL;
+		  n = 0;
+		  ret = 1;
+		  break;
+		}
+	      AnimalData = p;
+	      AnimalDataLimit += ALLOCATE_CHUNK;
+	    }
+	  p = AnimalData + n;
+	  p->n = n;
+	  if (sscanf (lbuf, "%[^,],%lu,%u,%u,%u,%u,%u,%u,%d,%d,%d,%[^\n\r]",
+		      namebuf,
+		      &p->hp, &p->moral, &p->speed,
+		      &p->value, &p->rate, &p->w_power, &p->w_rate,
+		      &p->eatmeat, &p->pattern, &p->charm_rate,
+		      inamebuf) != 12)
+	    {
+	      /* can't read data */
+	      break;
+	    }
+#ifdef MAKEWIN32
+	  convertC2H (namebuf, strlen (namebuf));
+#endif
+	  for (i = 0; namebuf[i] != '\0' && i < ANIMALNAME_LEN; i++)
+	    {
+	      p->name[i] = namebuf[i];
+	    }
+	  for (; i < ANIMALNAME_LEN; i++)
+	    {
+	      p->name[i] = ' ';
+	    }
+#ifdef MAKEWIN32
+	  convertC2H (inamebuf, strlen (inamebuf));
+#endif
+	  p->forsell_item = SearchItemForName (inamebuf);
+	  n++;
+	}
+      AnimalDataLimit = n;
+      fclose (iptr);
+    }
+  return ret;
+}
+
+/* create new Animal */
+static int
+NewAnimal (ANIMALDATA * pdata)
+{
+  int i;
+  for (i = 0; i < AnimalLimit; i++)
+    {
+      if (Animal[i].pdata == NULL)
+	{
+	  int x;
+	  int y;
+	  Animal[i].pdata = pdata;
+	  memcpy (Animal[i].name, pdata->name, USERNAME_LEN);
+	  Animal[i].hp = pdata->hp;
+	  Animal[i].moral = pdata->moral;
+	  Animal[i].speed = pdata->speed;
+	  Animal[i].w_power = pdata->w_power;
+#ifdef USE_STRONGANIMAL
+	  Animal[i].hp_org = Animal[i].hp;
+	  Animal[i].moral_org = Animal[i].moral;
+	  Animal[i].speed_org = Animal[i].speed;
+	  Animal[i].w_power_org = Animal[i].w_power;
+#endif
+	  do
+	    {
+	      x = getrand (0, MapWidth - 1);
+	      y = getrand (0, MapHeight - 1);
+	    }
+	  while (MAP (x, y)->player || (MAP (x, y)->id & MAP_HIGH_MASK));
+	  Animal[i].pos.x = x;
+	  Animal[i].pos.y = y;
+	  Animal[i].reload = 0;
+	  Animal[i].charmcount = 0;
+	  Animal[i].ntarget = -1;
+	  Animal[i].search = ANIMAL_SEARCH_RANGE;
+	  Animal[i].ntime = 0;
+	  Animal[i].hold_count = 0;
+	  Animal[i].recover_count = ANIMAL_RECOVER_COUNT;
+	  Animal[i].owner_user = -1;
+	  return i;
+	}
+    }
+  return -1;
+}
+
+/* delete animal */
+static void
+DeleteAnimal (int nanimal)
+{
+  Animal[nanimal].pdata = NULL;
+  Animal[nanimal].hp = 0;
+  Animal[nanimal].moral = 0;
+  return;
+}
+
+/* Initialize animal type table */
+static void
+InitializeAnimalType (void)
+{
+  int i;
+  int total = 0;
+  AnimalTypeTable = malloc (sizeof (int) * AnimalDataLimit);
+  if (AnimalTypeTable == NULL)
+    {
+      perror ("malloc");
+      fputs ("EVAC:not enought to animal-type memory\n", stderr);
+      exit (1);
+    }
+  for (i = 0; i < AnimalDataLimit; i++)
+    {
+      total += AnimalData[i].rate;
+      AnimalTypeTable[i] = total;
+    }
+  AnimalTypeTotal = total;
+  return;
+}
+
+/* select animal type */
+static ANIMALDATA *
+GetAnimalType (void)
+{
+  int n = getrand (1, AnimalTypeTotal);
+  int i;
+  for (i = 0; i < AnimalDataLimit; i++)
+    {
+      if (AnimalTypeTable[i] >= n)
+	{
+	  return AnimalData + i;
+	}
+    }
+  return NULL;
+}
+
+
+/* load weapon information */
+static int
+LoadWeapon (const char *pfilename)
+{
+  int ret = -1;
+  FILE *iptr;
+  iptr = fopen (pfilename, "r");
+  if (iptr != NULL)
+    {
+      int n = 0;
+      char lbuf[BUFFER_SIZE];
+      char namebuf[BUFFER_SIZE];
+      ret = 0;
+      while (fgets (lbuf, sizeof (lbuf), iptr) != NULL)
+	{
+	  WEAPONINFO *p;
+	  int b_type;
+	  if (lbuf[0] == '#')
+	    {
+	      /* this line is comment */
+	      continue;
+	    }
+	  if (n >= WeaponLimit)
+	    {
+	      /* need expand */
+	      p = realloc (Weapon, sizeof (WEAPONINFO) *
+			   (WeaponLimit + ALLOCATE_CHUNK));
+	      if (p == NULL)
+		{
+		  /* ??can't allocate memory */
+		  free (Weapon);
+		  Weapon = NULL;
+		  n = 0;
+		  ret = 1;
+		  break;
+		}
+	      Weapon = p;
+	      WeaponLimit += ALLOCATE_CHUNK;
+	    }
+	  p = Weapon + n;
+	  if (sscanf (lbuf, "%[^,],%u,%u,%u,%u,%u,%u,%u,%lu,%u,%u,%d",
+		      namebuf,
+		      &p->firepower, &p->moral, &p->range,
+		      &p->rate, &p->reduce, &p->speed, &p->bullette,
+		      &p->cost, &p->forhunter, &p->npc_rate, &b_type) != 12)
+	    {
+	      /* can't read data */
+	      break;
+	    }
+#ifdef MAKEWIN32
+	  convertC2H (namebuf, strlen (namebuf));
+#endif
+	  strncpy (p->name, namebuf, WEAPONNAME_LEN);
+	  p->b_type = (enum bullet_type) b_type;
+	  n++;
+	}
+      WeaponLimit = n;
+      fclose (iptr);
+    }
+  return ret;
+}
+
+/* load item information */
+static int
+LoadItem (const char *pfilename)
+{
+  int ret = -1;
+  FILE *iptr;
+  iptr = fopen (pfilename, "r");
+  if (iptr != NULL)
+    {
+      int n = 0;
+      char lbuf[BUFFER_SIZE];
+      char namebuf[BUFFER_SIZE];
+      ret = 0;
+      while (fgets (lbuf, sizeof (lbuf), iptr) != NULL)
+	{
+	  ITEMINFO *p;
+	  int ntype;
+	  int neffect;
+	  int ncount;
+	  int ncost;
+	  int nforhunter;
+	  int npattern;
+	  if (lbuf[0] == '#')
+	    {
+	      /* this line is comment */
+	      continue;
+	    }
+	  if (n >= ItemLimit)
+	    {
+	      /* need expand */
+	      p = realloc (Item, sizeof (ITEMINFO) *
+			   (ItemLimit + ALLOCATE_CHUNK));
+	      if (p == NULL)
+		{
+		  /* ??can't allocate memory */
+		  free (Item);
+		  Item = NULL;
+		  n = 0;
+		  ret = 1;
+		  break;
+		}
+	      Item = p;
+	      ItemLimit += ALLOCATE_CHUNK;
+	    }
+	  p = Item + n;
+	  if (sscanf (lbuf, "%[^,],%d,%d,%d,%d,%d,%d",
+		      namebuf, &ntype, &neffect, &ncount,
+		      &ncost, &nforhunter, &npattern) != 7)
+	    {
+	      /* can't read data */
+	      break;
+	    }
+#ifdef MAKEWIN32
+	  convertC2H (namebuf, strlen (namebuf));
+#endif
+	  strncpy (p->name, namebuf, ITEMNAME_LEN);
+	  p->id = ntype;
+	  p->effect = neffect;
+	  p->count = ncount;
+	  p->cost = ncost;
+	  p->forhunter = nforhunter;
+	  p->pattern = npattern;
+	  n++;
+	}
+      ItemLimit = n;
+      fclose (iptr);
+    }
+  return ret;
+}
+
+/* initialize map data */
+static void
+InitializeMap (void)
+{
+#ifdef USE_SAVEMAP
+  char work[BUFFER_SIZE];
+#endif
+  int i;
+  Map = malloc (sizeof (struct map_block) * MapWidth * MapHeight);
+  if (Map == NULL)
+    {
+      perror ("malloc");
+      fputs ("EVAC:not enought to map memory\n", stderr);
+      exit (1);
+    }
+#ifdef USE_SAVEMAP
+  sprintf (work, "%s/%s", DATA_DIR, SYSMAP_DATA_FILE);
+  puts ("Loading saved map data...");
+  if (!LoadMapData (work))
+    {
+      puts ("done.");
+      return;
+    }
+  else
+    {
+      puts ("no saved map data");
+    }
+#endif
+  for (i = 0; i < MapWidth * MapHeight; i++)
+    {
+      Map[i].id = MAP_INVALID;
+      Map[i].player = 0;
+      Map[i].animal = 0;
+      Map[i].owner = 0;
+    }
+  MAP (JailPositionX, JailPositionY)->id = MAP_THERE_WALL;
+  for (i = 0; i < ShopLimit; i++)
+    {
+      int x;
+      int y;
+      do
+	{
+	  x = getrand (0, MapWidth - 1);
+	  y = getrand (0, MapHeight - 1);
+	}
+      while ((MAP (x, y)->id & MAP_HIGH_MASK));
+      MAP (x, y)->id |= MAP_THERE_SHOP;
+    }
+  MakeNewMap ();
+  for (i = 0; i < TreasureLimit; i++)
+    {
+      int x;
+      int y;
+      do
+	{
+	  x = getrand (0, MapWidth - 1);
+	  y = getrand (0, MapHeight - 1);
+	}
+      while ((MAP (x, y)->id & MAP_HIGH_MASK));
+      MAP (x, y)->id |= MAP_THERE_ITEM;
+    }
+  return;
+}
+
+/* allocate bullet */
+static struct bullet_t *
+NewBullet (int nweapon, struct location pos, int direction)
+{
+  struct bullet_t *p = malloc (sizeof (struct bullet_t));
+  if (p == NULL)
+    {
+      /* uhm. cannot make bullet. Emergency Evacution.:) */
+      perror ("malloc");
+      fputs ("EVAC:fail NewBullet\n", stderr);
+      NowRunning = 0;
+      exit (255);
+    }
+  p->pprev = pBullet;
+  if (pBullet != NULL)
+    {
+      pBullet->pnext = p;
+    }
+  p->pnext = NULL;
+  p->pweapon = Weapon + nweapon;
+  p->fire_pos = p->pos = pos;
+  p->direction = direction;
+  p->nuser = -1;
+  p->ndamage = p->pweapon->firepower;
+  p->ndistance = p->pweapon->range;
+  p->ntime = 0;
+  pBullet = p;
+  return p;
+}
+
+/* freeup bullet */
+static void
+FreeBullet (struct bullet_t *p)
+{
+  if (p == pBullet)
+    {
+      pBullet = p->pprev;
+    }
+  if (p->pprev != NULL)
+    {
+      p->pprev->pnext = p->pnext;
+    }
+  if (p->pnext != NULL)
+    {
+      p->pnext->pprev = p->pprev;
+    }
+  free (p);
+  return;
+}
+
+/* search user shop from position */
+static int
+searchUserShopFromPos (int nuser, int x, int y)
+{
+  int i;
+  for (i = 0; i < USERSHOP_LIMIT; i++)
+    {
+      if (User[nuser].myshop[i].build)
+	{
+	  if (User[nuser].myshop[i].pos.x == x &&
+	      User[nuser].myshop[i].pos.y == y)
+	    {
+	      /* found */
+	      return i;
+	    }
+	}
+    }
+  return -1;			/* ?? no find */
+}
+
+/* send result code :result=0..ok result!=0..ng */
+static int
+SendResultPacket (SOCKET handle, int result)
+{
+  int ret = -1;
+  if (handle != INVALID_SOCKET)
+    {
+      unsigned char packet[PACKET_MAX];
+      packet[0] = HSERV_RESULT;
+      packet[2] = result ? 0x01 : 0x00;
+      ret = send_packet_c (handle, packet, 1);
+    }
+  return ret;
+}
+
+/* map id to map data */
+static unsigned char
+mapid2mapdata (unsigned char c, int nowner)
+{
+  if (c & MAP_THERE_ITEM)
+    {
+      return HCLIT_MAP_ITEM;
+    }
+  else if (c & MAP_THERE_SHOP)
+    {
+      return nowner ? HCLIT_MAP_ROAD : HCLIT_MAP_SHOP;
+    }
+  else if (c & MAP_THERE_WALL)
+    {
+      return HCLIT_MAP_WALL;
+    }
+  else
+    {
+      c &= MAP_MASK;
+      switch (c)
+	{
+	case MAP_ROAD:
+	  return HCLIT_MAP_ROAD;
+	case MAP_TREE:
+	  return HCLIT_MAP_TREE;
+	case MAP_ROCK:
+	  return HCLIT_MAP_ROCK;
+	default:
+	  return HCLIT_MAP_INVALID;
+	}
+    }
+}
+
+/* map point to map data */
+static unsigned char
+mapid2mapdata2 (int x, int y)
+{
+  return mapid2mapdata (MAP (x, y)->id, MAP (x, y)->owner);
+}
+
+/* make map data for send */
+static void
+make_send_mapdata (int userno, unsigned char d[VIEW_LIMIT * VIEW_WIDTH])
+{
+  int x;
+  int y;
+  int i;
+  int n;
+  int direction = User[userno].direction;
+  x = User[userno].pos.x;
+  y = User[userno].pos.y;
+  n = 0;
+  for (i = 0; i < VIEW_LIMIT; i++)
+    {
+      int ny;
+      int nx;
+      nx = x - RGVectorX[direction] * 2;
+      ny = y - RGVectorY[direction] * 2;
+      adjust_pos (&nx, &ny);
+      d[n++] = mapid2mapdata2 (nx, ny);
+      nx += RGVectorX[direction];
+      ny += RGVectorY[direction];
+      adjust_pos (&nx, &ny);
+      d[n++] = mapid2mapdata2 (nx, ny);
+      d[n++] = mapid2mapdata2 (x, y);
+      nx = x + RGVectorX[direction];
+      ny = y + RGVectorY[direction];
+      adjust_pos (&nx, &ny);
+      d[n++] = mapid2mapdata2 (nx, ny);
+      nx += RGVectorX[direction];
+      ny += RGVectorY[direction];
+      adjust_pos (&nx, &ny);
+      d[n++] = mapid2mapdata2 (nx, ny);
+      x += FWVectorX[direction];
+      y += FWVectorY[direction];
+      adjust_pos (&x, &y);
+    }
+  return;
+}
+
+/* convert player data */
+static unsigned char
+player2mapdata (int x, int y)
+{
+  unsigned char id = MAP (x, y)->id;
+  int n = MAP (x, y)->player;
+  if (n)
+    {
+      if (User[n - 1].cloak_count == 0)
+	{
+	  return TargetDirection[User[n - 1].c_type][User[n - 1].direction];
+	}
+      else
+	{
+	  return HCLIT_PLAYER_NONE;
+	}
+    }
+  else
+    {
+      if (id & MAP_THERE_ANIMAL)
+	{
+	  if (Animal[MAP (x, y)->animal].hp)
+	    {
+	      return HCLIT_MAP_ANIMAL;
+	    }
+	  else
+	    {
+	      return HCLIT_MAP_DEADANIMAL;
+	    }
+	}
+      else if (id & MAP_THERE_NPC)
+	{
+	  int npc = MAP (x, y)->animal;
+	  return TargetDirection[Npc[npc].c_type][Npc[npc].direction];
+	}
+      else if ((id & MAP_THERE_SHOP) && MAP (x, y)->owner)
+	{
+	  return HCLIT_MAP_USERSHOP;
+	}
+      else
+	{
+	  return HCLIT_PLAYER_NONE;
+	}
+    }
+}
+
+/* make player on map data for send */
+static void
+make_send_playeronmapdata (int userno,
+			   unsigned char d[VIEW_LIMIT * VIEW_WIDTH])
+{
+  int x;
+  int y;
+  int i;
+  int n;
+  int direction = User[userno].direction;
+  x = User[userno].pos.x;
+  y = User[userno].pos.y;
+  n = 0;
+  for (i = 0; i < VIEW_LIMIT; i++)
+    {
+      int ny;
+      int nx;
+      nx = x - RGVectorX[direction] * 2;
+      ny = y - RGVectorY[direction] * 2;
+      adjust_pos (&nx, &ny);
+      d[n++] = player2mapdata (nx, ny);
+      nx += RGVectorX[direction];
+      ny += RGVectorY[direction];
+      adjust_pos (&nx, &ny);
+      d[n++] = player2mapdata (nx, ny);
+      d[n++] = player2mapdata (x, y);
+      nx = x + RGVectorX[direction];
+      ny = y + RGVectorY[direction];
+      adjust_pos (&nx, &ny);
+      d[n++] = player2mapdata (nx, ny);
+      nx += RGVectorX[direction];
+      ny += RGVectorY[direction];
+      adjust_pos (&nx, &ny);
+      d[n++] = player2mapdata (nx, ny);
+      x += FWVectorX[direction];
+      y += FWVectorY[direction];
+      adjust_pos (&x, &y);
+    }
+  return;
+}
+
+/* copy player or animal or shop name */
+static unsigned char
+copy_mapdetaildata (int userno, unsigned char *p, int x, int y)
+{
+  unsigned char ret = 0;
+  unsigned char id = MAP (x, y)->id;
+  int nplayer = MAP (x, y)->player;
+  int nowner = MAP (x, y)->owner;
+  int nanimal = MAP (x, y)->animal;
+  if (nplayer && User[nplayer - 1].cloak_count == 0)
+    {
+      memcpy (p, User[nplayer - 1].name, 16);
+      if (User[nplayer - 1].maybearrest > 0)
+	{
+	  if (User[nplayer - 1].maybearrest <= ArrestPass)
+	    {
+	      ret = 1;
+	    }
+	  else if (User[nplayer - 1].maybearrest <= ArrestAnyone)
+	    {
+	      ret = 2;
+	    }
+	  else
+	    {
+	      ret = 3;
+	    }
+	}
+      else
+	{
+	  switch (User[nplayer - 1].crime_level)
+	    {
+	    case 1:
+	      ret = 2;
+	      break;
+	    case 2:
+	      ret = 3;
+	      break;
+	    }
+	}
+      ret |= (User[nplayer - 1].ride_pattern << 4);
+    }
+  else
+    {
+      if (id & MAP_THERE_ANIMAL)
+	{
+	  memcpy (p, Animal[nanimal].name, 16);
+	  if (Animal[nanimal].owner_user == userno)
+	    {
+	      /* your animal */
+	      ret = 5;
+	    }
+	  else if (Animal[nanimal].moral == 0)
+	    {
+	      ret = 1;
+	    }
+	  else if (Animal[nanimal].charmcount)
+	    {
+	      ret = 3;
+	    }
+	  else if (Animal[nanimal].moral < ANIMAL_MORAL_PANIC)
+	    {
+	      ret = 2;
+	    }
+	  else if (Animal[nanimal].moral > ANIMAL_MORAL_NORMAL)
+	    {
+	      ret = 4;
+	    }
+	  ret |= (Animal[nanimal].pdata->pattern << 4);
+	}
+      else if (id & MAP_THERE_NPC)
+	{
+	  memcpy (p, Npc[nanimal].name, 16);
+	  if (Npc[nanimal].c_type == NpcHunter)
+	    {
+	      ret = 3;
+	    }
+	  else if (Npc[nanimal].c_type == NpcHige)
+	    {
+	      ret = Npc[nanimal].number << 4;
+	      if (Npc[nanimal].owner_user == userno)
+		{
+		  ret |= 4;
+		}
+	    }
+	}
+      else if ((id & MAP_THERE_SHOP) && nowner)
+	{
+	  int nshop = searchUserShopFromPos (nowner - 1, x, y);
+	  if (nshop != -1)
+	    {
+	      memcpy (p, User[nowner - 1].myshop[nshop].name, 16);
+	    }
+	  else
+	    {
+	      /* error??? */
+	      memset (p, ' ', 16);
+	    }
+	}
+      else
+	{
+	  memset (p, ' ', 16);
+	}
+    }
+  return ret;
+}
+
+/* make map detail data for send */
+static void
+make_send_mapdetaildata (int userno,
+			 unsigned char d[VIEW_LIMIT * VIEW_WIDTH * 16],
+			 unsigned char crime[VIEW_LIMIT * VIEW_WIDTH])
+{
+  int x;
+  int y;
+  int i;
+  int direction = User[userno].direction;
+  unsigned char *p = d;
+  unsigned char *pcrime = crime;
+  x = User[userno].pos.x;
+  y = User[userno].pos.y;
+  for (i = 0; i < VIEW_LIMIT; i++)
+    {
+      int ny;
+      int nx;
+      nx = x - RGVectorX[direction] * 2;
+      ny = y - RGVectorY[direction] * 2;
+      adjust_pos (&nx, &ny);
+      *pcrime++ = copy_mapdetaildata (userno, p, nx, ny);
+      p += 16;
+      nx += RGVectorX[direction];
+      ny += RGVectorY[direction];
+      adjust_pos (&nx, &ny);
+      *pcrime++ = copy_mapdetaildata (userno, p, nx, ny);
+      p += 16;
+      *pcrime++ = copy_mapdetaildata (userno, p, x, y);
+      p += 16;
+      nx = x + RGVectorX[direction];
+      ny = y + RGVectorY[direction];
+      adjust_pos (&nx, &ny);
+      *pcrime++ = copy_mapdetaildata (userno, p, nx, ny);
+      p += 16;
+      nx += RGVectorX[direction];
+      ny += RGVectorY[direction];
+      adjust_pos (&nx, &ny);
+      *pcrime++ = copy_mapdetaildata (userno, p, nx, ny);
+      p += 16;
+      x += FWVectorX[direction];
+      y += FWVectorY[direction];
+      adjust_pos (&x, &y);
+    }
+  return;
+}
+
+/* make status information */
+static int
+MakeStatusData (int userno)
+{
+  int ret = 1;
+  int i;
+  unsigned char packet[PACKET_MAX];
+  unsigned char cwk;
+  int n = 2;
+  packet[0] = HSERV_STATUS;
+  cwk = User[userno].c_type & 0x0f;
+  if (User[userno].hungry > HungryBase)
+    {
+      cwk |= 0x40;		/* full */
+    }
+  else if (User[userno].hungry > 50)
+    {
+      cwk |= 0x30;		/* normal */
+    }
+  else if (User[userno].hungry > 10)
+    {
+      cwk |= 0x20;		/* hungry */
+    }
+  else if (User[userno].hungry > 0)
+    {
+      cwk |= 0x10;		/* weak */
+    }
+  packet[n++] = cwk;
+  *(unsigned short *) (packet + n) = htons (User[userno].pos.x);
+  n += 2;
+  *(unsigned short *) (packet + n) = htons (User[userno].pos.y);
+  n += 2;
+  *(unsigned long *) (packet + n) = htonl (User[userno].hp);
+  n += 4;
+  *(unsigned long *) (packet + n) = htonl (User[userno].score);
+  n += 4;
+  *(unsigned long *) (packet + n) = htonl (User[userno].maybearrest);
+  n += 4;
+  packet[n++] = User[userno].direction;
+  for (i = 0; i < WEAPON_MAX; i++)
+    {
+      memcpy (packet + n, Weapon[User[userno].weapon[i]].name,
+	      WEAPONNAME_LEN);
+      n += WEAPONNAME_LEN;
+    }
+  for (i = 0; i < WEAPON_MAX; i++)
+    {
+      *(unsigned short *) (packet + n) = htons (User[userno].bullette[i]);
+      n += 2;
+    }
+  for (i = 0; i < ITEM_MAX; i++)
+    {
+      memcpy (packet + n, Item[User[userno].item[i]].name, ITEMNAME_LEN);
+      n += ITEMNAME_LEN;
+    }
+  for (i = 0; i < ITEM_MAX; i++)
+    {
+      *(unsigned short *) (packet + n) = htons (User[userno].itemcount[i]);
+      n += 2;
+    }
+  if (!memcmp (User[userno].statusinfo + 2, packet + 2, n - 2))
+    {
+      /* no need send */
+      ret = 0;
+    }
+  else
+    {
+      memcpy (User[userno].statusinfo, packet, n);
+      User[userno].statusinfosize = n;
+    }
+  return ret;
+}
+
+/* Make map data */
+static int
+MakeMapData (int userno)
+{
+  int ret = 1;
+  unsigned char packet[PACKET_MAX];
+  int n = 2;
+  packet[0] = HSERV_MAP;
+  make_send_mapdata (userno, packet + n);
+  if (User[userno].status == Arrested)
+    {
+      memset (packet + n, HCLIT_MAP_WALL, VIEW_WIDTH * 2);
+    }
+  else if (User[userno].status == Shopping)
+    {
+      memset (packet + n, HCLIT_MAP_SHOP, VIEW_WIDTH * 2);
+    }
+  n += VIEW_LIMIT * VIEW_WIDTH;
+  make_send_playeronmapdata (userno, packet + n);
+  n += VIEW_LIMIT * VIEW_WIDTH;
+  make_send_mapdetaildata (userno, packet + n,
+			   packet + n + VIEW_LIMIT * VIEW_WIDTH * 16);
+  n += VIEW_LIMIT * VIEW_WIDTH * 16;
+  n += VIEW_LIMIT * VIEW_WIDTH;
+  if (!memcmp (User[userno].mapdata + 2, packet + 2, n - 2))
+    {
+      /* no need send */
+      ret = 0;
+    }
+  else
+    {
+      memcpy (User[userno].mapdata, packet, n);
+      User[userno].mapdatasize = n;
+    }
+  return ret;
+}
+
+/* check and send update information */
+static int
+SendUpdateInformation (int userno)
+{
+  int ret = -1;
+  if (User[userno].session.handle != INVALID_SOCKET)
+    {
+      int ntype = 0;
+      ret = 0;
+      if (MakeStatusData (userno))
+	{
+	  ntype |= 1;
+	}
+      if (MakeMapData (userno))
+	{
+	  ntype |= 2;
+	}
+      switch (ntype)
+	{
+	case 3:
+	  {
+	    int n;
+	    char wkpacket[PACKET_MAX];
+	    wkpacket[0] = HSERV_MAPANDSTATUS;
+	    n = 2;
+	    memcpy (wkpacket + n, User[userno].statusinfo + 2,
+		    User[userno].statusinfosize - 2);
+	    n += User[userno].statusinfosize - 2;
+	    memcpy (wkpacket + n, User[userno].mapdata + 2,
+		    User[userno].mapdatasize - 2);
+	    n += User[userno].mapdatasize - 2;
+	    ret = SENDPACKET (userno, (unsigned char *) wkpacket, n - 2);
+	  }
+	  break;
+	case 2:
+	  ret = SENDPACKET (userno, User[userno].mapdata,
+			    User[userno].mapdatasize - 2);
+	  break;
+	case 1:
+	  ret = SENDPACKET (userno, User[userno].statusinfo,
+			    User[userno].statusinfosize - 2);
+	  break;
+	default:
+	  break;
+	}
+    }
+  return ret;
+}
+
+/* send message */
+static int
+SendMessagePacket (int userno, int srcuser, const char *p)
+{
+  int ret = -1;
+  if (User[userno].session.handle != INVALID_SOCKET)
+    {
+      unsigned char packet[PACKET_MAX];
+      int nlen = strlen (p);
+      packet[0] = HSERV_MESG;
+      memcpy (packet + 2, User[srcuser].name, 16);
+      if (nlen > PACKET_DATA_MAX - 17)
+	{
+	  nlen = PACKET_DATA_MAX - 17;
+	}
+      packet[18] = nlen;
+      memcpy (packet + 19, p, nlen);
+      ret = SENDPACKET (userno, packet, nlen + 17);
+    }
+  return ret;
+}
+
+/* send system message */
+static int
+SendSystemMessagePacket (int userno, const char *p)
+{
+  int ret = -1;
+  if (User[userno].session.handle != INVALID_SOCKET)
+    {
+      unsigned char packet[PACKET_MAX];
+      int nlen = strlen (p);
+      packet[0] = HSERV_SYSMESG;
+      if (nlen > PACKET_DATA_MAX - 1)
+	{
+	  nlen = PACKET_DATA_MAX - 1;
+	}
+      packet[2] = nlen;
+      memcpy (packet + 3, p, nlen);
+      ret = SENDPACKET (userno, packet, nlen + 1);
+    }
+  return ret;
+}
+
+/* send message to all user */
+static void
+SendMessageAllUser (const char *p)
+{
+  int i;
+  for (i = 0; i < UserLimit; i++)
+    {
+      if (User[i].session.handle != INVALID_SOCKET)
+	{
+	  if (SendSystemMessagePacket (i, p))
+	    {
+	      DisconnectUser (i);
+	    }
+	}
+    }
+  return;
+}
+
+/* send message to near user */
+static void
+SendMessageNearUser (int userno, const char *p)
+{
+  int i;
+  for (i = 0; i < UserLimit; i++)
+    {
+      if (i != userno)
+	{
+	  if (User[i].session.handle != INVALID_SOCKET)
+	    {
+	      int n =
+		get_rel_distance (User[userno].pos.x, User[userno].pos.y,
+				  User[i].pos.x, User[i].pos.y);
+	      if (n <= HEARNEAR_DISTANCE)
+		{
+		  if (SendSystemMessagePacket (i, p))
+		    {
+		      DisconnectUser (i);
+		    }
+		}
+	    }
+	}
+    }
+  return;
+}
+
+/* send message to near user and sender */
+static void
+SendMessageNearUserSender (int userno, const char *p)
+{
+  int i;
+  for (i = 0; i < UserLimit; i++)
+    {
+      if (User[i].session.handle != INVALID_SOCKET)
+	{
+	  int n = get_rel_distance (User[userno].pos.x, User[userno].pos.y,
+				    User[i].pos.x, User[i].pos.y);
+	  if (n <= HEARNEAR_DISTANCE)
+	    {
+	      if (SendSystemMessagePacket (i, p))
+		{
+		  DisconnectUser (i);
+		}
+	    }
+	}
+    }
+  return;
+}
+
+/* send message to near user (origin animal)*/
+static void
+SendMessageNearUserAnimal (int animalno, const char *p)
+{
+  int i;
+  for (i = 0; i < UserLimit; i++)
+    {
+      if (User[i].session.handle != INVALID_SOCKET)
+	{
+	  int n =
+	    get_rel_distance (Animal[animalno].pos.x, Animal[animalno].pos.y,
+			      User[i].pos.x, User[i].pos.y);
+	  if (n <= HEARNEAR_DISTANCE)
+	    {
+	      if (SendSystemMessagePacket (i, p))
+		{
+		  DisconnectUser (i);
+		}
+	    }
+	}
+    }
+  return;
+}
+
+/* send message to near user (origin position)*/
+static void
+SendMessageNearUserPosition (struct location pos, const char *p)
+{
+  int i;
+  for (i = 0; i < UserLimit; i++)
+    {
+      if (User[i].session.handle != INVALID_SOCKET)
+	{
+	  int n = get_rel_distance (pos.x, pos.y,
+				    User[i].pos.x, User[i].pos.y);
+	  if (n <= HEARNEAR_DISTANCE)
+	    {
+	      if (SendSystemMessagePacket (i, p))
+		{
+		  DisconnectUser (i);
+		}
+	    }
+	}
+    }
+  return;
+}
+
+/* send message to near user (origin position, exclude nuser)*/
+static void
+SendMessageNearUserPosition2 (struct location pos, const char *p, int nuser)
+{
+  int i;
+  for (i = 0; i < UserLimit; i++)
+    {
+      if (i != nuser && User[i].session.handle != INVALID_SOCKET)
+	{
+	  int n = get_rel_distance (pos.x, pos.y,
+				    User[i].pos.x, User[i].pos.y);
+	  if (n <= HEARNEAR_DISTANCE)
+	    {
+	      if (SendSystemMessagePacket (i, p))
+		{
+		  DisconnectUser (i);
+		}
+	    }
+	}
+    }
+  return;
+}
+
+/* send user list */
+static int
+SendUserListPacket (int userno)
+{
+  int ret = -1;
+  if (User[userno].session.handle != INVALID_SOCKET)
+    {
+      int i;
+      unsigned char packet[PACKET_MAX];
+      ret = 0;
+      SendSystemMessagePacket (userno, "==== registered people ====");
+      for (i = 0; i < UserLimit && !ret; i++)
+	{
+	  if (User[i].name[0] != '\0')
+	    {
+	      int n = 2;
+	      packet[0] = HSERV_WHO;
+	      memcpy (packet + n, User[i].name, 16);
+	      n += 16;
+	      *(unsigned long *) (packet + n) = htonl (User[i].score);
+	      n += 4;
+	      packet[n++] =
+		(User[i].session.handle != INVALID_SOCKET) ? 1 : 0;
+	      packet[n++] = User[i].c_type;
+	      ret = SENDPACKET (userno, packet, n - 2);
+	    }
+	}
+      SendSystemMessagePacket (userno, "==== end of list ====");
+    }
+  return ret;
+}
+
+/* Send Effect 'damage' packet */
+static int
+SendEffectDamagePacket (int userno)
+{
+  int ret = -1;
+  if (User[userno].session.handle != INVALID_SOCKET)
+    {
+      unsigned char packet[PACKET_MAX];
+      packet[0] = HSERV_EFFECT_DAMAGE;
+      ret = SENDPACKET (userno, packet, 0);
+    }
+  return ret;
+}
+
+/* Send Effect 'death' packet */
+static int
+SendEffectDeathPacket (int userno)
+{
+  int ret = -1;
+  if (User[userno].session.handle != INVALID_SOCKET)
+    {
+      unsigned char packet[PACKET_MAX];
+      packet[0] = HSERV_EFFECT_DEATH;
+      ret = SENDPACKET (userno, packet, 0);
+    }
+  return ret;
+}
+
+/* Send Effect 'diggin' packet */
+static int
+SendEffectDiggingPacket (int userno)
+{
+  int ret = -1;
+  if (User[userno].session.handle != INVALID_SOCKET)
+    {
+      unsigned char packet[PACKET_MAX];
+      packet[0] = HSERV_EFFECT_DIGGING;
+      ret = SENDPACKET (userno, packet, 0);
+    }
+  return ret;
+}
+
+/* Send Effect 'fall in hole' packet */
+static int
+SendEffectFallInHolePacket (int userno)
+{
+  int ret = -1;
+  if (User[userno].session.handle != INVALID_SOCKET)
+    {
+      unsigned char packet[PACKET_MAX];
+      packet[0] = HSERV_EFFECT_FALL;
+      ret = SENDPACKET (userno, packet, 0);
+    }
+  return ret;
+}
+
+#ifdef USE_MAIL
+/* send mail header */
+static int
+SendMailHeader (int userno, MAILDATA * p)
+{
+  int ret = -1;
+  if (User[userno].session.handle != INVALID_SOCKET)
+    {
+      unsigned char packet[PACKET_MAX];
+      int n = 2;
+      packet[0] = HSERV_SENDMAIL;
+      memcpy (packet + n, User[p->fromuser].name, 16);
+      n += 16;
+      *(unsigned long *) (packet + n) = htonl (p->timestamp);
+      n += 4;
+      packet[n++] = p->subject[0];
+      if (p->subject[0])
+	{
+	  memcpy (packet + n, p->subject + 1, p->subject[0]);
+	  n += p->subject[0];
+	}
+      ret = SENDPACKET (userno, packet, n - 2);
+    }
+  return ret;
+}
+
+/* send mail body */
+static int
+SendMailBody (int userno, MAILDATA * p)
+{
+  int ret = -1;
+  if (User[userno].session.handle != INVALID_SOCKET)
+    {
+      unsigned char packet[PACKET_MAX];
+      int i;
+      for (i = 0; i < p->line; i++)
+	{
+	  int n = 2;
+	  packet[0] = HSERV_SENDMAILBODY;
+	  packet[n++] = p->message[i][0];
+	  if (p->message[i][0])
+	    {
+	      memcpy (packet + n, &p->message[i][1], p->message[i][0]);
+	      n += p->message[i][0];
+	    }
+	  ret = SENDPACKET (userno, packet, n - 2);
+	  if (ret)
+	    {
+	      return ret;
+	    }
+	}
+      packet[0] = HSERV_SENDEND;
+      ret = SENDPACKET (userno, packet, 0);
+    }
+  return ret;
+}
+
+#ifdef USE_BBS
+/* send BBS header */
+static int
+SendBBSHeader (int userno, MAILDATA * p)
+{
+  int ret = -1;
+  if (User[userno].session.handle != INVALID_SOCKET)
+    {
+      unsigned char packet[PACKET_MAX];
+      int n = 2;
+      packet[0] = HSERV_BBS_HEADER;
+      memcpy (packet + n, User[p->fromuser].name, 16);
+      n += 16;
+      *(unsigned long *) (packet + n) = htonl (p->timestamp);
+      n += 4;
+      packet[n++] = p->subject[0];
+      if (p->subject[0])
+	{
+	  memcpy (packet + n, p->subject + 1, p->subject[0]);
+	  n += p->subject[0];
+	}
+      ret = SENDPACKET (userno, packet, n - 2);
+    }
+  return ret;
+}
+
+/* send bbs body */
+static int
+SendBBSBody (int userno, MAILDATA * p)
+{
+  int ret = -1;
+  if (User[userno].session.handle != INVALID_SOCKET)
+    {
+      unsigned char packet[PACKET_MAX];
+      int i;
+      for (i = 0; i < p->line; i++)
+	{
+	  int n = 2;
+	  packet[0] = HSERV_BBS_BODY;
+	  packet[n++] = p->message[i][0];
+	  if (p->message[i][0])
+	    {
+	      memcpy (packet + n, &p->message[i][1], p->message[i][0]);
+	      n += p->message[i][0];
+	    }
+	  ret = SENDPACKET (userno, packet, n - 2);
+	  if (ret)
+	    {
+	      return ret;
+	    }
+	}
+      packet[0] = HSERV_BBS_BODYEND;
+      ret = SENDPACKET (userno, packet, 0);
+    }
+  return ret;
+}
+
+#endif /* USE_BBS */
+#endif /* USE_MAIL */
+
+/* send user shop list */
+static void
+SendUserShopList (int nowner, int nuser, int n)
+{
+  int i;
+  char work[MESG_BUFFER];
+  int nshop =
+    searchUserShopFromPos (nowner, User[nuser].pos.x, User[nuser].pos.y);
+  if (nshop == -1 || User[nowner].myshop[nshop].build == 0)
+    {
+      /* error ?? */
+      SendSystemMessagePacket (nuser, "(FATAL:user shop linkage is broken)");
+      return;
+    }
+  for (i = 0; i < SELLINSHOP_LIMIT; i++)
+    {
+      if (User[nowner].myshop[nshop].count[n][i])
+	{
+	  sprintf (work,
+		   n ? "<%2d:%-32.32s:%10luP %4ucount (stock:%4u)>" :
+		   "<%2d:%-32.32s:%10luP %4uround (stock:%4u)>",
+		   i,
+		   (n ? Item[User[nowner].myshop[nshop].list[n][i]].name :
+		    Weapon[User[nowner].myshop[nshop].list[n][i]].name),
+		   User[nowner].myshop[nshop].cost[n][i],
+		   User[nowner].myshop[nshop].leftuse[n][i],
+		   User[nowner].myshop[nshop].count[n][i]);
+	  SendSystemMessagePacket (nuser, work);
+	}
+    }
+  return;
+}
+
+/* send weapon list */
+static void
+SendWeaponList (int nuser)
+{
+  int nowner = MAP (User[nuser].pos.x, User[nuser].pos.y)->owner;
+  SendSystemMessagePacket (nuser, "<WEAPON LIST>");
+  if (nowner)
+    {
+      SendUserShopList (nowner - 1, nuser, 0);
+    }
+  else
+    {
+      int i;
+      char work[PACKET_DATA_MAX + 1];
+      int *plist;
+      int nmax;
+      if (User[nuser].c_type == Hunter)
+	{
+	  plist = ForHunterWeapon;
+	  nmax = ForHunterWeaponLimit;
+	}
+      else
+	{
+	  plist = ForObserverWeapon;
+	  nmax = ForObserverWeaponLimit;
+	}
+      for (i = 0; i < nmax; i++)
+	{
+	  WEAPONINFO *pw = Weapon + plist[i];
+	  sprintf (work, "<%3d:%-32.32s:%10luP %4uround %4u/%4u %4ublock>",
+		   i, pw->name, pw->cost, pw->bullette,
+		   pw->firepower, pw->moral, pw->range);
+	  SendSystemMessagePacket (nuser, work);
+	}
+    }
+  SendSystemMessagePacket (nuser, "<end of list>");
+  return;
+}
+
+/* send item list */
+static void
+SendItemList (int nuser)
+{
+  int nowner = MAP (User[nuser].pos.x, User[nuser].pos.y)->owner;
+  SendSystemMessagePacket (nuser, "<ITEM LIST>");
+  if (nowner)
+    {
+      SendUserShopList (nowner - 1, nuser, 1);
+    }
+  else
+    {
+      int i;
+      char work[PACKET_DATA_MAX + 1];
+      int *plist;
+      int nmax;
+      if (User[nuser].c_type == Hunter)
+	{
+	  plist = ForHunterItem;
+	  nmax = ForHunterItemLimit;
+	}
+      else
+	{
+	  plist = ForObserverItem;
+	  nmax = ForObserverItemLimit;
+	}
+      for (i = 0; i < nmax; i++)
+	{
+	  ITEMINFO *pi = Item + plist[i];
+	  sprintf (work, "<%3d:%-32.32s:%10luP %4ucount>",
+		   i, pi->name, pi->cost, pi->count);
+	  SendSystemMessagePacket (nuser, work);
+	}
+    }
+  SendSystemMessagePacket (nuser, "<end of list>");
+  return;
+}
+
+/* send who list */
+static void
+SendWhoList (int nuser)
+{
+  if (SendUserListPacket (nuser))
+    {
+      DisconnectUser (nuser);
+    }
+  return;
+}
+
+/* send startup map data */
+static int
+SendStartupMapData (int nuser)
+{
+  int ret = -1;
+  if (User[nuser].session.handle != INVALID_SOCKET)
+    {
+      unsigned char packet[PACKET_MAX];
+      int n;
+      packet[0] = HSERV_TRANSMAP_START;
+      n = 2;
+      *(unsigned short *) (packet + n) = htons (MapWidth);
+      n += 2;
+      *(unsigned short *) (packet + n) = htons (MapHeight);
+      n += 2;
+      ret = SENDPACKET (nuser, packet, n - 2);
+      if (ret == 0)
+	{
+	  /* map data transfer */
+	  int i;
+	  n = 2;
+	  packet[0] = HSERV_TRANSMAP_CHUNK;
+	  for (i = 0; i < MapWidth * MapHeight; i++)
+	    {
+	      if (Map[i].id & MAP_THERE_SHOP)
+		{
+		  if (Map[i].owner)
+		    {
+		      /* perhaps,it is user shop. */
+		      packet[n++] = HCLIT_MAP_USERSHOP;
+		    }
+		  else
+		    {
+		      packet[n++] = HCLIT_MAP_SHOP;
+		    }
+		}
+	      else if (Map[i].id & MAP_THERE_WALL)
+		{
+		  packet[n++] = HCLIT_MAP_WALL;
+		}
+	      else
+		{
+		  if ((Map[i].id & MAP_MASK) == MAP_ROCK)
+		    {
+		      packet[n++] = HCLIT_MAP_ROCK;
+		    }
+		  else
+		    {
+		      packet[n++] = HCLIT_MAP_ROAD;
+		    }
+		}
+	      if (n == 2 + SENDMAP_CHUNK)
+		{
+		  /* ok. send packet. */
+		  ret = SENDPACKET (nuser, packet, n - 2);
+		  n = 2;
+		  if (ret)
+		    {
+		      break;
+		    }
+		}
+	    }
+	  if (n != 2)
+	    {
+	      for (; n < 2 + SENDMAP_CHUNK; n++)
+		{
+		  packet[n] = HCLIT_MAP_ROAD;
+		}
+	      ret = SENDPACKET (nuser, packet, n - 2);
+	    }
+	}
+    }
+  return ret;
+}
+
+/********************************************************/
+/* npc say */
+static void
+NPCsay (int npc, const char *mesg[], int nmax)
+{
+  char work[MESG_BUFFER];
+  sprintf (work, mesg[getrand (0, nmax - 1)], CUTTAIL (Npc[npc].name));
+  SendMessageNearUserPosition (Npc[npc].pos, work);
+  return;
+}
+
+/* cause damage */
+static void
+cause_damage (int nuser, unsigned ndamage, int fromuser, enum target_type t)
+{
+  if (ndamage && User[nuser].hp)
+    {
+      SendEffectDamagePacket (nuser);
+      if (t == TargetNpc && Npc[fromuser].name[0] == '\0')
+	{
+	  fromuser = -1;
+	}
+      if (fromuser >= 0)
+	{
+	  char work[PACKET_DATA_MAX - 1];
+	  switch (t)
+	    {
+	    case TargetUser:
+	      sprintf (work, "%-.16s damages you. lost %uHP.",
+		       CUTTAIL (User[fromuser].name), ndamage);
+	      break;
+	    case TargetNpc:
+	      sprintf (work, "%-.16s damages you. lost %uHP.",
+		       CUTTAIL (Npc[fromuser].name), ndamage);
+	      break;
+	    case TargetAnimal:
+	      sprintf (work, "Animal '%-.16s' damages you. lost %uHP",
+		       CUTTAIL (Animal[fromuser].name), ndamage);
+	      break;
+	    default:
+	      work[0] = '\0';
+	      break;
+	    }
+	  if (work[0])
+	    {
+	      SendSystemMessagePacket (nuser, work);
+	    }
+	  if (t == TargetUser)
+	    {
+	      sprintf (work, "You attack %-.16s", CUTTAIL (User[nuser].name));
+	      SendSystemMessagePacket (fromuser, work);
+	    }
+	}
+      if (User[nuser].hp)
+	{
+	  User[nuser].lastuser = fromuser;
+	  User[nuser].lastuser_type = t;
+	}
+      if (User[nuser].hp > ndamage)
+	{
+	  User[nuser].hp -= ndamage;
+	}
+      else
+	{
+	  User[nuser].hp = 0;
+	}
+    }
+  return;
+}
+
+/* cause damage to animal */
+static void
+cause_damage_animal (int nanimal, unsigned ndamage, unsigned nmoral)
+{
+  if (Animal[nanimal].hp)
+    {
+      if (Animal[nanimal].moral > nmoral)
+	{
+	  Animal[nanimal].moral -= nmoral;
+	}
+      else
+	{
+	  Animal[nanimal].moral = 0;
+	}
+      if (Animal[nanimal].hp > ndamage)
+	{
+	  Animal[nanimal].hp -= ndamage;
+	}
+      else
+	{
+	  Animal[nanimal].hp = 0;
+	}
+    }
+  return;
+}
+
+/* cause damage to npc */
+static void
+cause_damage_npc (int npc, unsigned ndamage)
+{
+  if (Npc[npc].hp)
+    {
+      if (Npc[npc].hp > ndamage)
+	{
+	  Npc[npc].hp -= ndamage;
+	}
+      else
+	{
+	  Npc[npc].hp = 0;
+	}
+    }
+  return;
+}
+
+/* heal */
+static void
+cause_heal (int nuser, unsigned nheal)
+{
+  if (User[nuser].hp + nheal <= HpLimit)
+    {
+      User[nuser].hp += nheal;
+    }
+  else
+    {
+      User[nuser].hp = HpLimit;
+    }
+  return;
+}
+
+/* eat */
+static void
+cause_eat (int nuser, unsigned neat)
+{
+  if (User[nuser].hungry + neat <= HungryLimit)
+    {
+      User[nuser].hungry += neat;
+    }
+  else
+    {
+      User[nuser].hungry = HungryLimit;
+    }
+  return;
+}
+
+/* add score */
+static void
+add_score (int nuser, unsigned nscore)
+{
+  if (nscore)
+    {
+      User[nuser].score += nscore;
+      if (User[nuser].score > SCORE_LIMIT)
+	{
+	  User[nuser].score = SCORE_LIMIT;
+	}
+    }
+  return;
+}
+
+/* decrement score */
+static void
+dec_score (int nuser, unsigned nscore)
+{
+  if (nscore)
+    {
+      if (User[nuser].score > nscore)
+	{
+	  User[nuser].score -= nscore;
+	}
+      else
+	{
+	  User[nuser].score = 0;
+	}
+    }
+  return;
+}
+
+/* add crime point */
+static void
+add_crime (int nuser, unsigned ncrime)
+{
+  if (ncrime)
+    {
+      User[nuser].maybearrest += ncrime;
+      if (User[nuser].maybearrest > SCORE_LIMIT)
+	{
+	  User[nuser].maybearrest = SCORE_LIMIT;
+	}
+      switch (User[nuser].crime_level)
+	{
+	case 0:
+	  if (User[nuser].maybearrest > ArrestPass)
+	    {
+	      User[nuser].crime_level = 1;
+	    }
+	case 1:
+	  if (User[nuser].maybearrest > ArrestAnyone)
+	    {
+	      User[nuser].crime_level = 2;
+	    }
+	}
+    }
+  return;
+}
+
+/* add arrest */
+static void
+add_arrest (int nuser)
+{
+  if (User[nuser].arrest_count + 1 < ARREST_LIMIT)
+    {
+      User[nuser].arrest_count++;
+    }
+  else
+    {
+      SendSystemMessagePacket (nuser, "[You were arrested too many times!]");
+      SendSystemMessagePacket (nuser, "[You were executed!]");
+      User[nuser].hp = 0;
+      User[nuser].lastuser = -1;
+    }
+  return;
+}
+
+/********************************************************/
+/* make new connection */
+static int
+NewConnection (SESSION * psession)
+{
+  int ret = -1;
+  unsigned char packet[PACKET_MAX];
+  union ipaddr_u
+  {
+    unsigned long addr_l;
+    unsigned char addr[4];
+  }
+  wkadr;
+
+  wkadr.addr_l = psession->addr;
+  printf ("try new connection...from %u.%u.%u.%u:%u\n",
+	  wkadr.addr[0], wkadr.addr[1], wkadr.addr[2], wkadr.addr[3],
+	  ntohs (psession->port));
+  if (receive_packet_c (psession->handle, packet, PACKET_DATA_MAX) == 0)
+    {
+      printf ("packet ID:%02x length:%d\n", packet[0] & 0x3f,
+	      packet[1] + ((int) (packet[0] & 0xc0) << 2));
+      packet[0] &= 0x3f;
+      if (packet[0] == HCLIT_LOGIN)
+	{
+	  /* login */
+	  int nuser = SearchUser ((char *) (packet + 2));
+	  puts ("attempt to login.");
+	  if (packet[1] != 16 + 16 + 2 ||
+	      packet[2 + 16 + 16 + 1] != HPROTOCOL_VERSION)
+	    {
+	      /* illegal protocol */
+	      puts ("protocol mismatch.");
+	      SendResultPacket (psession->handle, -1);
+	    }
+	  else if (nuser != -1)
+	    {
+	      int i;
+	      const unsigned char *p = packet + 2 + 16;
+	      char uname[USERNAME_LEN];
+	      char work[PASSWORD_LEN];
+	      memcpy (uname, User[nuser].name, USERNAME_LEN);
+#ifdef MAKEWIN32
+	      convertH2C (uname, USERNAME_LEN);
+#endif
+	      printf ("User name:%-16.16s\n", uname);
+	      for (i = 0; i < PASSWORD_LEN; i++)
+		{
+		  if (*(p + i) == '\0')
+		    {
+		      break;
+		    }
+		  work[i] = *(p + i);
+		}
+	      for (; i < PASSWORD_LEN; i++)
+		{
+		  work[i] = ' ';
+		}
+	      if (memcmp (User[nuser].password, work, PASSWORD_LEN) == 0)
+		{
+		  /* password check is ok */
+		  if (User[nuser].session.handle != INVALID_SOCKET)
+		    {
+		      /* already login */
+		      /* cut connection */
+		      puts ("cut old connection.");
+		      cutsocket (User[nuser].session.handle);
+		      User[nuser].session.handle = INVALID_SOCKET;
+		    }
+		  if (SendResultPacket (psession->handle, 0) == -1)
+		    {
+		      /* ?? error */
+		      puts ("can't send result. fail to login.");
+		      DisconnectUser (nuser);
+		    }
+		  else
+		    {
+		      User[nuser].session = *psession;
+#ifdef USE_FORK
+		      create_send_process (nuser, psession->handle);
+#endif
+#ifdef USE_W32THREAD
+		      create_send_message_queue_thread (nuser);
+#endif
+		      ActivateUser (nuser);
+		      puts ("send startup map data...");
+		      if (SendStartupMapData (nuser) == -1)
+			{
+			  /* ?? error */
+			  puts ("can't send startup map data. fail to login");
+			  DisconnectUser (nuser);
+			}
+		      else
+			{
+			  puts ("Ok");
+			  SendSystemMessagePacket (nuser, ServerInfo);
+			  if (User[nuser].status == Arrested)
+			    {
+			      SendSystemMessagePacket (nuser,
+						       "[Welcome to Jail!]");
+			    }
+#ifdef USE_MAIL
+			  if (CheckNewMail (nuser))
+			    {
+			      /* new mail! */
+			      SendSystemMessagePacket (nuser,
+						       "[You have new mail]");
+			    }
+#endif
+			  ret = 0;
+			}
+		    }
+		}
+	      else
+		{
+		  puts ("mismatch password.");
+		  SendResultPacket (psession->handle, -1);
+		}
+	    }
+	  else
+	    {
+	      puts ("no user.");
+	      SendResultPacket (psession->handle, -1);
+	    }
+	}
+      else if (packet[0] == HCLIT_NEWUSER)
+	{
+	  /* new user */
+	  puts ("attempt to create new user");
+	  if (packet[1] == USERNAME_LEN + PASSWORD_LEN + 16 + PASSWORD_LEN)
+	    {
+	      /* ok */
+	      if (packet[2 + 16 + 16 + 1] != HPROTOCOL_VERSION)
+		{
+		  /* illegal protocol */
+		  puts ("protocol mismatch");
+		  SendResultPacket (psession->handle, -1);
+		}
+	      else if (memcmp (packet + 2 + 16 + 16 + 16, makeUserKey,
+			       PASSWORD_LEN))
+		{
+		  /* illegal system password */
+		  puts ("system password mismatch");
+		  printf ("Client key[%-16.16s]\n",
+			  packet + 2 + 16 + 16 + 16);
+		  SendResultPacket (psession->handle, -1);
+		}
+	      else
+		{
+		  int nuser = NewUser ((char *) (packet + 2));
+		  printf ("NewUser check:%d\n", nuser);
+		  if (nuser == -2)
+		    {
+		      /* double user */
+		      puts ("double user");
+		      SendResultPacket (psession->handle, -1);
+		    }
+		  else if (nuser == -1)
+		    {
+		      /* error */
+		      puts ("error?");
+		      SendResultPacket (psession->handle, -1);
+		    }
+		  else
+		    {
+		      int i;
+		      char *ps;
+		      char *pd;
+		      puts ("ok. new user!");
+		      ps = (char *) (packet + 2 + 16);
+		      pd = User[nuser].password;
+		      for (i = 0; i < PASSWORD_LEN; i++)
+			{
+			  if (*(ps + i) == '\0')
+			    {
+			      break;
+			    }
+			  *pd++ = *(ps + i);
+			}
+		      for (; i < PASSWORD_LEN; i++)
+			{
+			  *pd++ = ' ';
+			}
+		      User[nuser].c_type =
+			packet[2 + 16 + 16] ? Observer : Hunter;
+		      if (SendResultPacket (psession->handle, 0) == -1)
+			{
+			  /* ?? error */
+			  puts ("occur error in make new user");
+			  DisconnectUser (nuser);
+			}
+		      else
+			{
+			  User[nuser].session = *psession;
+#ifdef USE_FORK
+			  create_send_process (nuser, psession->handle);
+#endif
+#ifdef USE_W32THREAD
+			  create_send_message_queue_thread (nuser);
+#endif
+			  ActivateUser (nuser);
+			  puts ("send startup map data...");
+			  if (SendStartupMapData (nuser) == -1)
+			    {
+			      /* ?? error */
+			      puts
+				("can't send startup map data. fail to login");
+			      DisconnectUser (nuser);
+			    }
+			  else
+			    {
+			      SendSystemMessagePacket (nuser, ServerInfo);
+			      puts ("success.");
+			      ret = 0;
+			    }
+			}
+		    }
+		}
+	    }
+	}
+      else if (packet[0] == HCLIT_DELUSER)
+	{
+	  int nuser = SearchUser ((char *) (packet + 2));
+	  puts ("attempt to delete.");
+	  if (nuser != -1)
+	    {
+	      int i;
+	      const unsigned char *p = packet + 2 + 16;
+	      char uname[USERNAME_LEN];
+	      char work[PASSWORD_LEN];
+	      memcpy (uname, User[nuser].name, USERNAME_LEN);
+#ifdef MAKEWIN32
+	      convertH2C (uname, USERNAME_LEN);
+#endif
+	      printf ("User name:%-16.16s\n", uname);
+	      for (i = 0; i < PASSWORD_LEN; i++)
+		{
+		  if (*(p + i) == '\0')
+		    {
+		      break;
+		    }
+		  work[i] = *(p + i);
+		}
+	      for (; i < PASSWORD_LEN; i++)
+		{
+		  work[i] = ' ';
+		}
+	      if (memcmp (User[nuser].password, work, PASSWORD_LEN) == 0)
+		{
+		  /* ok. delete this user. */
+		  puts ("OK. delete this user.");
+		  DeleteUser (nuser);
+		  SendResultPacket (psession->handle, 0);
+		}
+	      else
+		{
+		  puts ("password mismatch.");
+		  SendResultPacket (psession->handle, -1);
+		}
+	    }
+	  else
+	    {
+	      puts ("no user.");
+	      SendResultPacket (psession->handle, -1);
+	    }
+	}
+    }
+  return ret;
+}
+
+/* check new connection */
+static void
+CheckNewConnection (void)
+{
+  SESSION session;
+  if (waitconnect (mainSocket, &session) == 0)
+    {
+      /* success connect */
+      puts ("connected.");
+      if (NewConnection (&session) == -1)
+	{
+	  /* occur error */
+	  puts ("occur error");
+	  if (session.handle != INVALID_SOCKET)
+	    {
+	      cutsocket (session.handle);
+	    }
+	}
+      else
+	{
+	  puts ("ok. comming new user.");
+	  FD_SET (session.handle, &mainFDS);
+	}
+    }
+  return;
+}
+
+/********************************************************/
+/* move command */
+static void
+doMove (int nuser, int n)
+{
+  if (n >= 0 && n <= 3)
+    {
+      User[nuser].move = n + 1;
+    }
+  return;
+}
+
+/* change direction command */
+static void
+doChangeDirection (int nuser, int n)
+{
+  if (n >= 0 && n <= 3)
+    {
+      User[nuser].wk_direction = n;
+    }
+  return;
+}
+
+/* fire weaon command */
+static void
+doFire (int nuser, int n)
+{
+  if (n == 1)
+    {
+      User[nuser].action = Fire1;
+    }
+  else if (n == 2)
+    {
+      User[nuser].action = Fire2;
+    }
+  return;
+}
+
+/* use item command */
+static void
+doUseItem (int nuser, int n)
+{
+  switch (n)
+    {
+    case 1:
+      User[nuser].action = UseItem1;
+      break;
+    case 2:
+      User[nuser].action = UseItem2;
+      break;
+    case 3:
+      User[nuser].action = UseItem3;
+      break;
+    case 4:
+      User[nuser].action = UseItem4;
+      break;
+    }
+  return;
+}
+
+/* pickup command */
+static void
+doPickUp (int nuser)
+{
+  User[nuser].action = PickUp;
+  return;
+}
+
+/* pay command */
+static void
+doPay (int nuser)
+{
+  User[nuser].action = Pay;
+  return;
+}
+
+/* buy command */
+static void
+doBuy (int nuser, int n, int m)
+{
+  User[nuser].action = n ? BuyItem : BuyWeapon;
+  User[nuser].wk_for_action = m;
+  return;
+}
+
+/* who command */
+static void
+doWho (int nuser)
+{
+  User[nuser].action = Who;
+  return;
+}
+
+/* request weapon list command */
+static void
+doListWeapon (int nuser)
+{
+  User[nuser].action = RequestWeapon;
+  return;
+}
+
+/* request item list command */
+static void
+doListItem (int nuser)
+{
+  User[nuser].action = RequestItem;
+  return;
+}
+
+/* store lastpickup-animal */
+static void
+doStoreAnimal (int nuser, unsigned long lwk)
+{
+  User[nuser].action = StoreAnimal;
+  User[nuser].lwk_for_action = lwk;
+  return;
+}
+
+/* store item or weapn */
+static void
+doStoreObj (int nuser, int n, int m, unsigned long lwk)
+{
+  User[nuser].action = n ? StoreItem : StoreWeapon;
+  User[nuser].wk_for_action = m - 1;
+  User[nuser].lwk_for_action = lwk;
+  return;
+}
+
+/* discard item or weapon in shop */
+static void
+doDiscardMyshopObj (int nuser, int n, int m)
+{
+  User[nuser].action = n ? DiscardItem : DiscardWeapon;
+  User[nuser].wk_for_action = m;
+  return;
+}
+
+/* list up my shop */
+static void
+doListMyshop (int nuser)
+{
+  User[nuser].action = ListMyShop;
+  return;
+}
+
+/* list up my animal */
+static void
+doListMyAnimal (int nuser)
+{
+  User[nuser].action = ListMyAnimal;
+  return;
+}
+
+/* list up live animal */
+static void
+doListLiveAnimal (int nuser)
+{
+  User[nuser].action = ListLiveAnimal;
+  return;
+}
+
+/* drop weapon or item */
+static void
+doDropObj (int nuser, int n, int m, const unsigned char *p)
+{
+  int nlen = *p;
+  User[nuser].action = n ? DropItem : DropWeapon;
+  User[nuser].wk_for_action = m - 1;
+  if (nlen > sizeof (User[nuser].mesg_for_action) - 1)
+    {
+      nlen = sizeof (User[nuser].mesg_for_action) - 1;
+    }
+  if (nlen)
+    {
+      strncpy (User[nuser].mesg_for_action, (char *) (p + 1), nlen);
+    }
+  User[nuser].mesg_for_action[nlen] = '\0';
+  return;
+}
+
+/* do say command */
+static void
+doSay (int nuser, unsigned char *p)
+{
+  User[nuser].action = DoSay;
+  memcpy (User[nuser].mesg_for_action, p,
+	  sizeof (User[nuser].mesg_for_action));
+  return;
+}
+
+/* do tell command */
+static void
+doTell (int nuser, unsigned char *p)
+{
+  User[nuser].action = DoTell;
+  memcpy (User[nuser].mesg_for_action, p,
+	  sizeof (User[nuser].mesg_for_action));
+  return;
+}
+
+/* do broadcast command */
+static void
+doBroadcast (int nuser, unsigned char *p)
+{
+  User[nuser].action = DoBroadcast;
+  memcpy (User[nuser].mesg_for_action, p,
+	  sizeof (User[nuser].mesg_for_action));
+  return;
+}
+
+/* do write npc shop command */
+static void
+doWriteNpcShop (int nuser, int nlen, const char *p)
+{
+  User[nuser].action = DoWriteMesg;
+  User[nuser].wk_for_action = nlen;
+  memcpy (User[nuser].mesg_for_action, p, nlen);
+  return;
+}
+
+/* do change user shop name */
+static void
+doChangeShopName (int nuser, const char *p)
+{
+  User[nuser].action = DoChangeShopName;
+  strncpy (User[nuser].mesg_for_action, p, 16);
+  User[nuser].mesg_for_action[16] = '\0';
+  return;
+}
+
+/* do destroy user shop */
+static void
+doDestroyShop (int nuser)
+{
+  User[nuser].action = DoDestroyShop;
+  return;
+}
+
+#ifdef USE_MAIL
+/* send mail header */
+static void
+doSendMyMail (int nuser, unsigned char *p)
+{
+  int ntarget = SearchUser ((char *) p);
+  if (User[nuser].t_mail != NULL)
+    {
+      /* ?? need to discard old transaction */
+      FreeMail (User[nuser].t_mail);
+      User[nuser].t_mail = NULL;
+    }
+  if (ntarget != -1)
+    {
+      printf ("user:%d try to send mail to user:%d...\n", nuser, ntarget);
+      User[nuser].t_mail = NewMail ();
+      User[nuser].t_target = ntarget;
+      if (User[nuser].t_mail != NULL)
+	{
+	  int n = *(p + 16);
+	  User[nuser].t_mail->fromuser = nuser;
+	  memcpy (User[nuser].t_mail->subject, p + 16, n + 1);
+	}
+    }
+  else
+    {
+      SendSystemMessagePacket (nuser, "(Mail error:no such user!)");
+    }
+  return;
+}
+
+/* send mail body */
+static void
+doSendMyMailBody (int nuser, unsigned char *p)
+{
+  if (User[nuser].t_mail != NULL)
+    {
+      AddMessageMail (User[nuser].t_mail, (char *) p);
+    }
+  return;
+}
+
+/* end of send mail */
+static void
+doSendMyMailEnd (int nuser)
+{
+  if (User[nuser].t_mail != NULL)
+    {
+      if (User[nuser].t_target != -1)
+	{
+	  /* try to send */
+	  if (AddMailUser (User[nuser].t_target, User[nuser].t_mail))
+	    {
+	      /* ?? occur error. perhaps mailbox is full.  */
+	      puts ("Mail delivery fail");
+	      SendSystemMessagePacket (nuser,
+				       "(Mail error:target user's mailbox is"
+				       " full)");
+	    }
+	  else
+	    {
+	      puts ("Mail delivery success.");
+	      SendSystemMessagePacket (nuser, "[Ok. deliver mail.]");
+	      SendSystemMessagePacket (User[nuser].t_target,
+				       "[You have new mail!]");
+	      User[nuser].t_mail = NULL;
+	      User[nuser].t_target = -1;
+	    }
+	}
+#ifdef USE_BBS
+      else
+	{
+	  /* for BBS */
+	  int n;
+	  for (n = 0; n < BBS_BOX_LIMIT; n++)
+	    {
+	      if (BBSdata[n] == NULL)
+		{
+		  break;
+		}
+	    }
+	  if (n == BBS_BOX_LIMIT)
+	    {
+	      /* BBS box is full. delete old article. */
+	      puts ("BBS article box is full. delete old article.");
+	      FreeMail (BBSdata[0]);
+	      BBSdata[0] = NULL;
+	      ReorderBBSbox ();
+	      n = BBS_BOX_LIMIT - 1;
+	    }
+	  puts ("post article success.");
+	  SendSystemMessagePacket (nuser, "[Ok. post article.]");
+	  BBSdata[n] = User[nuser].t_mail;
+	  User[nuser].t_mail = NULL;
+	}
+#endif /* USE_BBS */
+    }
+  else
+    {
+      SendSystemMessagePacket (nuser, "(Mail error:can't send)");
+    }
+  return;
+}
+
+/* list my mail box command */
+static void
+doListMyMail (int nuser)
+{
+  User[nuser].action = ListMyMail;
+  return;
+}
+
+/* read my mail command */
+static void
+doReadMyMail (int nuser, int n)
+{
+  if (n > 0 && n <= MAIL_BOX_LIMIT)
+    {
+      User[nuser].action = ReadMyMail;
+      User[nuser].wk_for_action = n - 1;
+    }
+  return;
+}
+
+/* delete my mail command */
+static void
+doDeleteMyMail (int nuser, int n)
+{
+  if (n > 0 && n <= MAIL_BOX_LIMIT)
+    {
+      User[nuser].action = DeleteMyMail;
+      User[nuser].wk_for_action = n - 1;
+    }
+  return;
+}
+
+#ifdef USE_BBS
+/* post BBS article header */
+static void
+doPostBBS (int nuser, unsigned char *p)
+{
+  if (User[nuser].t_mail != NULL)
+    {
+      /* ?? need to discard old transaction */
+      FreeMail (User[nuser].t_mail);
+      User[nuser].t_mail = NULL;
+    }
+  printf ("user:%d try to post BBS...\n", nuser);
+  User[nuser].t_mail = NewMail ();
+  User[nuser].t_target = -1;
+  if (User[nuser].t_mail != NULL)
+    {
+      int n = *p;
+      User[nuser].t_mail->fromuser = nuser;
+      memcpy (User[nuser].t_mail->subject, p, n + 1);
+    }
+  return;
+}
+
+/* list bbs command */
+static void
+doListBBS (int nuser)
+{
+  User[nuser].action = ListBBS;
+  return;
+}
+
+/* read bbs command */
+static void
+doReadBBS (int nuser, int n)
+{
+  if (n > 0 && n <= BBS_BOX_LIMIT)
+    {
+      User[nuser].action = ReadBBS;
+      User[nuser].wk_for_action = n - 1;
+    }
+  return;
+}
+
+#endif /* USE_BBS */
+#endif /* USE_MAIL */
+
+/* trasnfer score to other user */
+static void
+doTransferScore (int nuser, unsigned char *p)
+{
+  int ndist = SearchUser ((char *) p);
+  if (ndist != -1)
+    {
+      char work[MESG_BUFFER];
+      unsigned n = ntohl (*(unsigned long *) (p + 16));
+      unsigned ntax = n / 100;
+      if (User[nuser].score < n + ntax)
+	{
+	  /* no score */
+	  SendSystemMessagePacket (nuser, "[no have enough score]");
+	  return;
+	}
+      dec_score (nuser, n + ntax);
+      add_score (ndist, n);
+      sprintf (work, "[You transfer %uscore to %-.16s. Tax:%upoint]",
+	       n, CUTTAIL (User[ndist].name), ntax);
+      SendSystemMessagePacket (nuser, work);
+      sprintf (work, "[You receive %uscore from %-.16s]",
+	       n, CUTTAIL (User[nuser].name));
+      SendSystemMessagePacket (ndist, work);
+    }
+  else
+    {
+      SendSystemMessagePacket (nuser, "[no such user]");
+    }
+  return;
+}
+
+/* do change animal name */
+static void
+doChangeUserAnimalName (int nuser, unsigned char *p)
+{
+  User[nuser].action = DoChangeAnimalName;
+  strncpy (User[nuser].mesg_for_action, (char *) p, 16);
+  User[nuser].mesg_for_action[16] = '\0';
+  return;
+}
+
+/* logoff command */
+static void
+doLogoff (int nuser)
+{
+  DisconnectUser (nuser);
+  return;
+}
+
+/* parse user command */
+static void
+parseCommand (int nuser, unsigned char *packet)
+{
+  switch (packet[0] & 0x3f)
+    {
+    case HCLIT_MOVE:
+      if (User[nuser].status != Arrested)
+	{
+	  doMove (nuser, packet[2]);
+	}
+      break;
+    case HCLIT_CHDIR:
+      doChangeDirection (nuser, packet[2]);
+      break;
+    case HCLIT_FIRE:
+      if (User[nuser].status == Healthy)
+	{
+	  doFire (nuser, packet[2]);
+	}
+      break;
+    case HCLIT_ITEM:
+      if (User[nuser].status == Healthy)
+	{
+	  doUseItem (nuser, packet[2]);
+	}
+      break;
+    case HCLIT_PICK:
+      if (User[nuser].status == Healthy)
+	{
+	  doPickUp (nuser);
+	}
+      break;
+    case HCLIT_PAY:
+      if (User[nuser].c_type == Hunter && User[nuser].status == Arrested)
+	{
+	  doPay (nuser);
+	}
+      break;
+    case HCLIT_BUY:
+      if (User[nuser].status != Arrested)
+	{
+	  doBuy (nuser, packet[2], packet[3]);
+	}
+      break;
+    case HCLIT_MESG:
+      doSay (nuser, packet + 2);
+      break;
+    case HCLIT_MESG2U:
+      doTell (nuser, packet + 2);
+      break;
+    case HCLIT_MESG2ALL:
+      doBroadcast (nuser, packet + 2);
+      break;
+    case HCLIT_WHO:
+      doWho (nuser);
+      break;
+    case HCLIT_REQWEAPON:
+      doListWeapon (nuser);
+      break;
+    case HCLIT_REQITEM:
+      doListItem (nuser);
+      break;
+    case HCLIT_WRITEMESG:
+      if (User[nuser].status != Arrested)
+	{
+	  doWriteNpcShop (nuser, packet[2], (char *) (packet + 3));
+	}
+      break;
+    case HCLIT_DROPOBJ:
+      if (User[nuser].status == Healthy)
+	{
+	  doDropObj (nuser, packet[2], packet[3], packet + 4);
+	}
+      break;
+    case HCLIT_CHANGEANIMAL:
+      doChangeUserAnimalName (nuser, packet + 2);
+      break;
+    case HCLIT_STOREANIMAL:
+      if (User[nuser].status != Arrested)
+	{
+	  doStoreAnimal (nuser, ntohl (*(unsigned long *) (packet + 2)));
+	}
+      break;
+    case HCLIT_STOREOBJ:
+      if (User[nuser].status != Arrested)
+	{
+	  doStoreObj (nuser, packet[2], packet[3],
+		      ntohl (*(unsigned long *) (packet + 4)));
+	}
+      break;
+    case HCLIT_CHANGEMYSHOP:
+      if (User[nuser].status != Arrested)
+	{
+	  doChangeShopName (nuser, (char *) (packet + 2));
+	}
+      break;
+    case HCLIT_DISCARDMYSHOPOBJ:
+      if (User[nuser].status != Arrested)
+	{
+	  doDiscardMyshopObj (nuser, packet[2], packet[3]);
+	}
+      break;
+    case HCLIT_DESTROYMYSHOP:
+      if (User[nuser].status != Arrested)
+	{
+	  doDestroyShop (nuser);
+	}
+      break;
+    case HCLIT_LISTMYSHOP:
+      if (User[nuser].status != Arrested)
+	{
+	  doListMyshop (nuser);
+	}
+      break;
+    case HCLIT_REQANIMAL:
+      if (User[nuser].status != Arrested && User[nuser].c_type == Hunter)
+	{
+	  doListMyAnimal (nuser);
+	}
+      break;
+    case HCLIT_LISTLIVEANIMAL:
+      if (User[nuser].status != Arrested)
+	{
+	  doListLiveAnimal (nuser);
+	}
+      break;
+#ifdef USE_MAIL
+    case HCLIT_SENDMAIL:
+      doSendMyMail (nuser, packet + 2);
+      break;
+    case HCLIT_SENDMAILBODY:
+      doSendMyMailBody (nuser, packet + 2);
+      break;
+    case HCLIT_SENDEND:
+      doSendMyMailEnd (nuser);
+      break;
+    case HCLIT_LISTMAIL:
+      doListMyMail (nuser);
+      break;
+    case HCLIT_READMAIL:
+      doReadMyMail (nuser, packet[2]);
+      break;
+    case HCLIT_DELETEMAIL:
+      doDeleteMyMail (nuser, packet[2]);
+      break;
+#ifdef USE_BBS
+    case HCLIT_BBS_POST:
+      doPostBBS (nuser, packet + 2);
+      break;
+    case HCLIT_BBS_LIST:
+      doListBBS (nuser);
+      break;
+    case HCLIT_BBS_READ:
+      doReadBBS (nuser, packet[2]);
+      break;
+#endif /* USE_BBS */
+#endif /* USE_MAIL */
+    case HCLIT_TRANSFERSCORE:
+      doTransferScore (nuser, packet + 2);
+      break;
+    case HCLIT_LOGOFF:
+      doLogoff (nuser);
+      break;
+    }
+  return;
+}
+
+/* receive user command */
+static int
+receiveUserCommand (int nuser)
+{
+  unsigned char packet[PACKET_MAX];
+  int ret = -1;
+  SOCKET handle = User[nuser].session.handle;
+  if (receive_packet_c (handle, packet, PACKET_DATA_MAX) == 0)
+    {
+      parseCommand (nuser, packet);
+      ret = 0;
+    }
+  User[nuser].idletimer = 0;
+  return ret;
+}
+
+/* handling user packet */
+static void
+HandleUser (fd_set * rfds)
+{
+  int nuser;
+  for (nuser = 0; nuser < UserLimit; nuser++)
+    {
+      if (User[nuser].session.handle != INVALID_SOCKET)
+	{
+	  SOCKET handle = User[nuser].session.handle;
+	  if (FD_ISSET (handle, rfds) && receiveUserCommand (nuser) != 0)
+	    {
+	      DisconnectUser (nuser);
+	    }
+	}
+    }
+  return;
+}
+
+/********************************************************/
+/* check and send hige-shop message */
+static void
+checkHigeMessage (int nuser)
+{
+  int f = 0;
+  int i;
+  for (i = 0; i < UserLimit; i++)
+    {
+      if (i == nuser)
+	{
+	  continue;
+	}
+      if (User[i].name[0] != '\0' && User[i].higemesg[0] != '\0')
+	{
+	  /* find message */
+	  char work[PACKET_DATA_MAX];
+	  int n = 0;
+	  memcpy (work, User[i].name, USERNAME_LEN);
+	  n += USERNAME_LEN;
+	  work[n++] = ':';
+	  strncpy (work + n, User[i].higemesg, PACKET_DATA_MAX - n);
+	  SendSystemMessagePacket (nuser, work);
+	  f = 1;
+	}
+      if (User[i].c_type == Hunter)
+	{
+	  char work[PACKET_DATA_MAX];
+	  switch (User[i].crime_level)
+	    {
+	    case 1:
+	      sprintf (work, "<WANTED '%-.16s'>", CUTTAIL (User[i].name));
+	      SendSystemMessagePacket (nuser, work);
+	      break;
+	    case 2:
+	      sprintf (work, "<Dead or Alive '%-.16s'",
+		       CUTTAIL (User[i].name));
+	      SendSystemMessagePacket (nuser, work);
+	      break;
+	    }
+	}
+    }
+  if (!f)
+    {
+      /* no message */
+      SendSystemMessagePacket (nuser,
+			       "Shop HIGE:Do you wanna use my design?");
+    }
+  return;
+}
+
+
+/*  movement users */
+static void
+MovementUserPhase (void)
+{
+  int i;
+  for (i = 0; i < UserLimit; i++)
+    {
+      if (User[i].session.handle != INVALID_SOCKET)
+	{
+	  if (User[i].speed_count == 0)
+	    {
+	      if (User[i].hold_count && User[i].move != NoMove)
+		{
+		  SendSystemMessagePacket (i, "[You can't move now!]");
+		  User[i].move = NoMove;
+		}
+	      User[i].move_bkup = User[i].move;
+	      if (User[i].move_bkup != NoMove)
+		{
+		  unsigned char c;
+		  int x = User[i].pos.x;
+		  int y = User[i].pos.y;
+		  switch (User[i].move_bkup)
+		    {
+		    case MoveForward:
+		      x += FWVectorX[User[i].wk_direction];
+		      y += FWVectorY[User[i].wk_direction];
+		      break;
+		    case MoveBackward:
+		      x -= FWVectorX[User[i].wk_direction];
+		      y -= FWVectorY[User[i].wk_direction];
+		      break;
+		    case MoveLeft:
+		      x -= RGVectorX[User[i].wk_direction];
+		      y -= RGVectorY[User[i].wk_direction];
+		      break;
+		    case MoveRight:
+		      x += RGVectorX[User[i].wk_direction];
+		      y += RGVectorY[User[i].wk_direction];
+		      break;
+		    default:
+		      break;
+		    }
+		  adjust_pos (&x, &y);
+		  c = MAP (x, y)->id & MAP_MASK;
+		  if (MAP (x, y)->player || (MAP (x, y)->id & MAP_NOT_MOVE) ||
+		      c == MAP_ROCK || c == MAP_INVALID)
+		    {
+		      /* impossible to move */
+		      User[i].move_bkup = NoMove;
+		      User[i].move = NoMove;
+		      SendSystemMessagePacket (i,
+					       "[Can't move its direction!]");
+		    }
+		  else
+		    {
+		      User[i].wk_pos.x = x;
+		      User[i].wk_pos.y = y;
+		      MAP (x, y)->player = i + 1;
+		      User[i].status = Healthy;
+		    }
+		}
+	    }
+	}
+    }
+  for (i = 0; i < UserLimit; i++)
+    {
+      if (User[i].session.handle != INVALID_SOCKET)
+	{
+	  if (User[i].speed_count == 0)
+	    {
+	      if (User[i].move_bkup != NoMove)
+		{
+		  int x;
+		  int y;
+		  x = User[i].pos.x;
+		  y = User[i].pos.y;
+		  MAP (x, y)->player = 0;
+		  User[i].pos = User[i].wk_pos;
+		  User[i].direction = User[i].wk_direction;
+		  User[i].move = NoMove;
+		  x = User[i].pos.x;
+		  y = User[i].pos.y;
+		  if (MAP (x, y)->id & MAP_THERE_SHOP)
+		    {
+		      User[i].status = Shopping;
+		      if (MAP (x, y)->owner == 0)
+			{
+			  /* in hige shop. check message. */
+			  checkHigeMessage (i);
+			}
+		    }
+		}
+	      else if (User[i].direction != User[i].wk_direction)
+		{
+		  User[i].direction = User[i].wk_direction;
+		}
+	      User[i].speed_count = User[i].speed;
+	    }
+	  else
+	    {
+	      User[i].speed_count--;
+	    }
+	}
+    }
+  return;
+}
+
+/********************************************************/
+/* build up user shop */
+static int
+buildupMyShop (int nuser)
+{
+  int nshop;
+  for (nshop = 0; nshop < USERSHOP_LIMIT; nshop++)
+    {
+      if (User[nuser].myshop[nshop].build == 0)
+	{
+	  /* ok. find free slot */
+	  break;
+	}
+    }
+  if (nshop == USERSHOP_LIMIT)
+    {
+      SendSystemMessagePacket (nuser, "[You can't build anymore]");
+      return -1;
+    }
+  else
+    {
+      int x = User[nuser].pos.x;
+      int y = User[nuser].pos.y;
+      if (!(MAP (x, y)->id & MAP_HIGH_MASK) &&
+	  (MAP (x, y)->id & MAP_MASK) == MAP_ROAD)
+	{
+	  /* ok. */
+	  int i;
+	  User[nuser].myshop[nshop].build = 1;
+	  User[nuser].myshop[nshop].pos = User[nuser].pos;
+	  MAP (x, y)->owner = nuser + 1;
+	  MAP (x, y)->id |= MAP_THERE_SHOP;
+	  for (i = 0; i < SELLINSHOP_LIMIT; i++)
+	    {
+	      User[nuser].myshop[nshop].list[0][i] = 0;
+	      User[nuser].myshop[nshop].list[1][i] = 0;
+	      User[nuser].myshop[nshop].leftuse[0][i] = 0;
+	      User[nuser].myshop[nshop].leftuse[1][i] = 0;
+	      User[nuser].myshop[nshop].count[0][i] = 0;
+	      User[nuser].myshop[nshop].count[1][i] = 0;
+	      User[nuser].myshop[nshop].cost[0][i] = 0;
+	      User[nuser].myshop[nshop].cost[1][i] = 0;
+	    }
+	  return 0;
+	}
+      else
+	{
+	  return -1;
+	}
+    }
+}
+
+/* store last pickup-animal */
+static void
+storeLastPickup (int nuser, unsigned long ncost)
+{
+  int x = User[nuser].pos.x;
+  int y = User[nuser].pos.y;
+  if (MAP (x, y)->owner == nuser + 1)
+    {
+      int nshop = searchUserShopFromPos (nuser, x, y);
+      ANIMALDATA *p = get_animal_slot (nuser);
+      if (nshop == -1 || User[nuser].myshop[nshop].build == 0)
+	{
+	  SendSystemMessagePacket (nuser,
+				   "(FATAL:user shop linkage is broken)");
+	  return;
+	}
+      if (p != NULL)
+	{
+	  int nitem = p->forsell_item;
+	  int i;
+	  /* store to shop */
+	  for (i = 0; i < SELLINSHOP_LIMIT; i++)
+	    {
+	      if (User[nuser].myshop[nshop].list[1][i] == nitem &&
+		  User[nuser].myshop[nshop].cost[1][i] == ncost)
+		{
+		  break;
+		}
+	    }
+	  if (i == SELLINSHOP_LIMIT)
+	    {
+	      for (i = 0; i < SELLINSHOP_LIMIT; i++)
+		{
+		  if (User[nuser].myshop[nshop].list[1][i] == 0 ||
+		      User[nuser].myshop[nshop].count[1][i] == 0)
+		    {
+		      User[nuser].myshop[nshop].list[1][i] = nitem;
+		      User[nuser].myshop[nshop].count[1][i] = 0;
+		      User[nuser].myshop[nshop].cost[1][i] = ncost;
+		      User[nuser].myshop[nshop].leftuse[1][i] =
+			Item[nitem].count;
+		      break;
+		    }
+		}
+	    }
+	  if (i < SELLINSHOP_LIMIT)
+	    {
+	      User[nuser].myshop[nshop].count[1][i]++;
+	      SendSystemMessagePacket (nuser, "[1 animal stocked]");
+	    }
+	  else
+	    {
+	      SendSystemMessagePacket (nuser, "[NO STOCK SPACE]");
+	      put_animal_slot (nuser, p);
+	    }
+	}
+      else
+	{
+	  SendSystemMessagePacket (nuser, "[You have no animal]");
+	}
+    }
+  else
+    {
+      SendSystemMessagePacket (nuser, "[You must go to your shop]");
+    }
+  return;
+}
+
+/* store item or weapon */
+static void
+storeItemOrWeapon (int nuser, int isitem, int nslot, unsigned long cost)
+{
+  int x = User[nuser].pos.x;
+  int y = User[nuser].pos.y;
+  if (MAP (x, y)->owner == nuser + 1)
+    {
+      int nshop = searchUserShopFromPos (nuser, x, y);
+      char work[MESG_BUFFER];
+      int i;
+      int n;
+      unsigned short nleft;
+      if (nshop == -1 || User[nuser].myshop[nshop].build == 0)
+	{
+	  SendSystemMessagePacket (nuser,
+				   "(FATAL:user shop linkage is broken)");
+	  return;
+	}
+      if (isitem)
+	{
+	  if (nslot < 0 || nslot > ITEM_MAX)
+	    {
+	      /* illegal slot */
+	      SendSystemMessagePacket (nuser, "[Illegal slot number]");
+	      return;
+	    }
+	  n = User[nuser].item[nslot];
+	  nleft = User[nuser].itemcount[nslot];
+	}
+      else
+	{
+	  if (nslot < 0 || nslot > WEAPON_MAX)
+	    {
+	      /* illegal slot */
+	      SendSystemMessagePacket (nuser, "[Illegal slot number]");
+	      return;
+	    }
+	  n = User[nuser].weapon[nslot];
+	  nleft = User[nuser].bullette[nslot];
+	}
+      if (n == 0 || nleft == 0)
+	{
+	  /* NG */
+	  sprintf (work, "[%s slot%d is empty]",
+		   isitem ? "Item" : "Weapon", nslot + 1);
+	  SendSystemMessagePacket (nuser, work);
+	  return;
+	}
+      for (i = 0; i < SELLINSHOP_LIMIT; i++)
+	{
+	  if (User[nuser].myshop[nshop].list[isitem][i] == n &&
+	      User[nuser].myshop[nshop].leftuse[isitem][i] == nleft &&
+	      User[nuser].myshop[nshop].cost[isitem][i] == cost)
+	    {
+	      break;
+	    }
+	}
+      if (i == SELLINSHOP_LIMIT)
+	{
+	  for (i = 0; i < SELLINSHOP_LIMIT; i++)
+	    {
+	      if (User[nuser].myshop[nshop].list[isitem][i] == 0 ||
+		  User[nuser].myshop[nshop].count[isitem][i] == 0)
+		{
+		  User[nuser].myshop[nshop].list[isitem][i] = n;
+		  User[nuser].myshop[nshop].count[isitem][i] = 0;
+		  User[nuser].myshop[nshop].leftuse[isitem][i] = nleft;
+		  User[nuser].myshop[nshop].cost[isitem][i] = cost;
+		  break;
+		}
+	    }
+	}
+      if (i < SELLINSHOP_LIMIT)
+	{
+	  if (isitem)
+	    {
+	      User[nuser].item[nslot] = 0;
+	      User[nuser].itemcount[nslot] = 0;
+	    }
+	  else
+	    {
+	      User[nuser].weapon[nslot] = 0;
+	      User[nuser].bullette[nslot] = 0;
+	    }
+	  User[nuser].myshop[nshop].count[isitem][i]++;
+	  sprintf (work, "[%-.32s stocked]",
+		   isitem ? Item[n].name : Weapon[n].name);
+	  SendSystemMessagePacket (nuser, work);
+	}
+      else
+	{
+	  SendSystemMessagePacket (nuser, "[NO STOCK SPACE]");
+	}
+    }
+  else
+    {
+      SendSystemMessagePacket (nuser, "[You must go to your shop]");
+    }
+  return;
+}
+
+/* discard item or weapon in my shop */
+static void
+discardItemOrWeapon (int nuser, int isitem, int n)
+{
+  int x = User[nuser].pos.x;
+  int y = User[nuser].pos.y;
+  if (MAP (x, y)->owner == nuser + 1)
+    {
+      int nshop = searchUserShopFromPos (nuser, x, y);
+      if (nshop == -1 || User[nuser].myshop[nshop].build == 0)
+	{
+	  SendSystemMessagePacket (nuser,
+				   "(FATAL:user shop linkage is broken)");
+	  return;
+	}
+      if (n >= 0 && n < SELLINSHOP_LIMIT)
+	{
+	  if (User[nuser].myshop[nshop].list[isitem][n] != 0)
+	    {
+	      /* ok */
+	      User[nuser].myshop[nshop].list[isitem][n] = 0;
+	      User[nuser].myshop[nshop].count[isitem][n] = 0;
+	      SendSystemMessagePacket (nuser, isitem ?
+				       "[Discard Item]" : "[Discard Weapon]");
+	    }
+	  else
+	    {
+	      SendSystemMessagePacket (nuser, "[It is EMPTY]");
+	    }
+	}
+    }
+  else
+    {
+      SendSystemMessagePacket (nuser, "[You must go to your shop]");
+    }
+  return;
+}
+
+/* destroy my shop */
+static void
+processDestroyMyshop (int nuser)
+{
+  int x = User[nuser].pos.x;
+  int y = User[nuser].pos.y;
+  int nshop = searchUserShopFromPos (nuser, x, y);
+  if (nshop != -1 && User[nuser].myshop[nshop].build)
+    {
+      int i;
+      MAP (x, y)->id &= ~MAP_THERE_SHOP;
+      MAP (x, y)->owner = 0;
+      User[nuser].myshop[nshop].build = 0;
+      for (i = 0; i < SELLINSHOP_LIMIT; i++)
+	{
+	  if (User[nuser].myshop[nshop].list[0][i] &&
+	      User[nuser].myshop[nshop].count[0][i])
+	    {
+	      int j;
+	      unsigned long ncost =
+		Weapon[User[nuser].myshop[nshop].list[0][i]].cost / 2;
+	      for (j = 0; j < User[nuser].myshop[nshop].count[0][i]; j++)
+		{
+		  add_score (nuser, ncost);
+		}
+	    }
+	  if (User[nuser].myshop[nshop].list[0][i] &&
+	      User[nuser].myshop[nshop].count[0][i])
+	    {
+	      int j;
+	      unsigned long ncost =
+		Item[User[nuser].myshop[nshop].list[0][i]].cost / 2;
+	      for (j = 0; j < User[nuser].myshop[nshop].count[0][i]; j++)
+		{
+		  add_score (nuser, ncost);
+		}
+	    }
+	}
+      SendSystemMessagePacket (nuser, "[You destroy your shop]");
+    }
+  else
+    {
+      SendSystemMessagePacket (nuser, "[You must go to your shop]");
+    }
+  return;
+}
+
+/* change myshop name */
+static void
+processChangeMyshop (int nuser, const char *p)
+{
+  int x = User[nuser].pos.x;
+  int y = User[nuser].pos.y;
+  int nshop = searchUserShopFromPos (nuser, x, y);
+  if (nshop != -1 && User[nuser].myshop[nshop].build)
+    {
+      int i;
+      for (i = 0; p[i] != '\0' && i < USERNAME_LEN; i++)
+	{
+	  User[nuser].myshop[nshop].name[i] = p[i];
+	}
+      for (; i < USERNAME_LEN; i++)
+	{
+	  User[nuser].myshop[nshop].name[i] = ' ';
+	}
+      SendSystemMessagePacket (nuser, "[Your shop name is changed]");
+    }
+  else
+    {
+      SendSystemMessagePacket (nuser, "[You must go to your shop]");
+    }
+  return;
+}
+
+/* write message on hige shop */
+static void
+processWriteMesg (int nuser, int nlen, const char *p)
+{
+  int x = User[nuser].pos.x;
+  int y = User[nuser].pos.y;
+  if ((MAP (x, y)->id & MAP_THERE_SHOP) && MAP (x, y)->owner == 0)
+    {
+      if (nlen > sizeof (User[nuser].higemesg) - 1)
+	{
+	  nlen = sizeof (User[nuser].higemesg) - 1;
+	}
+      if (nlen)
+	{
+	  strncpy (User[nuser].higemesg, p, nlen);
+	}
+      User[nuser].higemesg[nlen] = '\0';
+      if (nlen == 0)
+	{
+	  SendSystemMessagePacket (nuser, "[Your message is cleard]");
+	}
+      else
+	{
+	  SendSystemMessagePacket (nuser,
+				   "[Your write message on Shop HIGE]");
+	}
+    }
+  else
+    {
+      SendSystemMessagePacket (nuser, "[You must go to Shop HIGE!]");
+    }
+  return;
+}
+
+/* process change user animal name */
+static void
+processChangeUserAnimalName (int nuser, const char *p)
+{
+  int x = User[nuser].pos.x;
+  int y = User[nuser].pos.y;
+  x += FWVectorX[User[nuser].direction];
+  y += FWVectorY[User[nuser].direction];
+  adjust_pos (&x, &y);
+  if (MAP (x, y)->id & MAP_THERE_ANIMAL)
+    {
+      int nanimal = MAP (x, y)->animal;
+      if (Animal[nanimal].owner_user == nuser)
+	{
+	  /* your animal */
+	  int i;
+	  for (i = 0; i < USERNAME_LEN && *p != '\0'; i++, p++)
+	    {
+	      Animal[nanimal].name[i] = *p;
+	    }
+	  for (; i < USERNAME_LEN; i++)
+	    {
+	      Animal[nanimal].name[i] = ' ';
+	    }
+	  SendSystemMessagePacket (nuser, "[animal name is changed]");
+	}
+      else
+	{
+	  SendSystemMessagePacket (nuser, "[This animal is not yours!]");
+	}
+    }
+  else
+    {
+      SendSystemMessagePacket (nuser, "[no animal on front!]");
+    }
+  return;
+}
+
+/* send message */
+static void
+processSendMessage (int nuser, unsigned char *p)
+{
+  char work[PACKET_DATA_MAX + 1];
+  int nlen = *p;
+  if (nlen > PACKET_DATA_MAX - USERNAME_LEN - 5)
+    {
+      nlen = PACKET_DATA_MAX - USERNAME_LEN - 5;
+    }
+  memcpy (work, User[nuser].name, USERNAME_LEN);
+  memcpy (work + USERNAME_LEN, " say,", 5);
+  if (nlen)
+    {
+      memcpy (work + USERNAME_LEN + 5, p + 1, nlen);
+    }
+  work[USERNAME_LEN + 5 + nlen] = '\0';
+  SendMessageNearUserSender (nuser, work);
+  return;
+}
+
+/* broadcast message */
+static void
+processBroadcastMessage (int nuser, unsigned char *p)
+{
+  char work[PACKET_DATA_MAX + 1];
+  int nlen = *p;
+  if (nlen > PACKET_DATA_MAX - USERNAME_LEN - 11)
+    {
+      nlen = PACKET_DATA_MAX - USERNAME_LEN - 11;
+    }
+  memcpy (work, User[nuser].name, USERNAME_LEN);
+  memcpy (work + USERNAME_LEN, " broadcast,", 11);
+  if (nlen)
+    {
+      memcpy (work + USERNAME_LEN + 11, p + 1, nlen);
+    }
+  work[USERNAME_LEN + 11 + nlen] = '\0';
+  SendMessageAllUser (work);
+  return;
+}
+
+/* send message to specific user */
+static void
+processSendMessage2User (int nuser, unsigned char *p)
+{
+  int destuser = SearchUser ((char *) p);
+  if (destuser != -1)
+    {
+      char work[PACKET_DATA_MAX];
+      int nlen = *(p + 16);
+      memcpy (work, p + 17, nlen);
+      work[nlen] = '\0';
+      SendMessagePacket (destuser, nuser, work);
+      if (nlen > PACKET_DATA_MAX - USERNAME_LEN - 10)
+	{
+	  nlen = PACKET_DATA_MAX - USERNAME_LEN - 10;
+	}
+      sprintf (work, "You tell %-.16s,", CUTTAIL (User[destuser].name));
+      if (nlen)
+	{
+	  memcpy (work + USERNAME_LEN + 10, p + 17, nlen);
+	}
+      work[USERNAME_LEN + 10 + nlen] = '\0';
+      SendSystemMessagePacket (nuser, work);
+    }
+  return;
+}
+
+/* process fire weapon */
+static void
+processFireWeapon (int nuser, int nweapon)
+{
+  if (User[nuser].reload[nweapon] == 0)
+    {
+      struct bullet_t *pbullet;
+      if (User[nuser].bullette[nweapon])
+	{
+	  User[nuser].bullette[nweapon]--;
+	}
+      else
+	{
+	  User[nuser].weapon[nweapon] = 0;	/* bear hand */
+	}
+      pbullet = NewBullet (User[nuser].weapon[nweapon],
+			   User[nuser].pos, User[nuser].direction);
+      pbullet->nuser = nuser;	/* owner */
+      pbullet->t_type = TargetUser;
+      User[nuser].reload[nweapon] = Weapon[User[nuser].weapon[nweapon]].rate;
+      User[nuser].cloak_count = 0;
+    }
+  else
+    {
+      char work[PACKET_DATA_MAX];
+      sprintf (work, "[Weapon:%-32.32s NOT READY]",
+	       Weapon[User[nuser].weapon[nweapon]].name);
+      SendSystemMessagePacket (nuser, work);
+    }
+  return;
+}
+
+/* char near animal */
+static void
+processCharmAnimal (int nuser, int neffect)
+{
+  int i;
+  for (i = 0; i < AnimalLimit; i++)
+    {
+      if (Animal[i].pdata != NULL && Animal[i].hp)
+	{
+	  int n = get_rel_distance (User[nuser].pos.x, User[nuser].pos.y,
+				    Animal[i].pos.x, Animal[i].pos.y);
+	  if (n < neffect)
+	    {
+	      /* charm this */
+	      Animal[i].charm = CharmPosition;
+	      Animal[i].charmcount = CharmCount;
+	      Animal[i].charm_pos = User[nuser].pos;
+	    }
+	}
+    }
+  return;
+}
+
+/* list up near Animal */
+static void
+ListUpNearAnimal (int nuser, int neffect)
+{
+  int i;
+  char work[MESG_BUFFER];
+  for (i = 0; i < AnimalLimit; i++)
+    {
+      if (Animal[i].pdata != NULL && Animal[i].hp)
+	{
+	  int dx1;
+	  int dx2;
+	  int dy1;
+	  int dy2;
+	  int n;
+	  calculate_delta_x (User[nuser].pos.x, Animal[i].pos.x, &dx1, &dx2);
+	  calculate_delta_y (User[nuser].pos.y, Animal[i].pos.y, &dy1, &dy2);
+	  n = get_rel_distance_in (dx1, dx2, dy1, dy2);
+	  if (n < neffect)
+	    {
+	      /* list up this */
+	      int relpos = get_rel_position_in (dx1, dx2, dy1, dy2);
+	      sprintf (work, "<%-16.16s %10s %5dBlock>",
+		       Animal[i].name, RelDirection[relpos], n);
+	      SendSystemMessagePacket (nuser, work);
+	    }
+	}
+    }
+  return;
+}
+
+/* list up near human */
+static void
+ListUpNearHuman (int nuser, int neffect)
+{
+  int i;
+  enum npctype_t npct;
+  char work[MESG_BUFFER];
+  for (i = 0; i < UserLimit; i++)
+    {
+      if (nuser == i)
+	{
+	  continue;
+	}
+      if (User[i].session.handle != INVALID_SOCKET && User[i].hp &&
+	  User[i].cloak_count == 0 && User[i].c_type != User[nuser].c_type)
+	{
+	  int dx1;
+	  int dx2;
+	  int dy1;
+	  int dy2;
+	  int n;
+	  calculate_delta_x (User[nuser].pos.x, User[i].pos.x, &dx1, &dx2);
+	  calculate_delta_y (User[nuser].pos.y, User[i].pos.y, &dy1, &dy2);
+	  n = get_rel_distance_in (dx1, dx2, dy1, dy2);
+	  if (n < neffect)
+	    {
+	      /* list up this */
+	      int relpos = get_rel_position_in (dx1, dx2, dy1, dy2);
+	      if (User[i].c_type == Hunter)
+		{
+		  sprintf (work, "<Hunter:%-16.16s %10s %5dBlock crime:%lu>",
+			   User[i].name, RelDirection[relpos], n,
+			   User[i].maybearrest);
+		}
+	      else
+		{
+		  sprintf (work, "<Guard :%-16.16s %10s %5dBlock>",
+			   User[i].name, RelDirection[relpos], n);
+		}
+	      SendSystemMessagePacket (nuser, work);
+	    }
+	}
+    }
+  if (User[nuser].c_type == Hunter)
+    {
+      npct = NpcObserver;
+    }
+  else
+    {
+      npct = NpcHunter;
+    }
+  for (i = 0; i < NpcLimit; i++)
+    {
+      if (Npc[i].name[0] != '\0' && Npc[i].hp && Npc[i].c_type == npct)
+	{
+	  int dx1;
+	  int dx2;
+	  int dy1;
+	  int dy2;
+	  int n;
+	  calculate_delta_x (User[nuser].pos.x, Npc[i].pos.x, &dx1, &dx2);
+	  calculate_delta_y (User[nuser].pos.y, Npc[i].pos.y, &dy1, &dy2);
+	  n = get_rel_distance_in (dx1, dx2, dy1, dy2);
+	  if (n < neffect)
+	    {
+	      /* list up this */
+	      int relpos = get_rel_position_in (dx1, dx2, dy1, dy2);
+	      if (Npc[i].c_type == NpcHunter)
+		{
+		  sprintf (work, "<Hunter:%-16.16s %10s %5dBlock crime:NA>",
+			   Npc[i].name, RelDirection[relpos], n);
+		}
+	      else
+		{
+		  sprintf (work, "<Guard :%-16.16s %10s %5dBlock>",
+			   Npc[i].name, RelDirection[relpos], n);
+		}
+	      SendSystemMessagePacket (nuser, work);
+	    }
+	}
+    }
+  return;
+}
+
+/* glow tree */
+static void
+glowTree (int nuser)
+{
+  int x = User[nuser].pos.x;
+  int y = User[nuser].pos.y;
+  INVALID_MAP (x, y);
+  MAP (x, y)->id |= MAP_TREE;
+  return;
+}
+
+/* dig hole */
+static int
+digHoleHere (int nuser)
+{
+  int x = User[nuser].pos.x;
+  int y = User[nuser].pos.y;
+  x += FWVectorX[User[nuser].direction];
+  y += FWVectorY[User[nuser].direction];
+  adjust_pos (&x, &y);
+  if ((MAP (x, y)->id & MAP_HIGH_MASK) ||
+      (MAP (x, y)->id & MAP_MASK) != MAP_ROAD)
+    {
+      return -1;
+    }
+  else
+    {
+      MAP (x, y)->id |= MAP_THERE_HOLE;
+      User[nuser].hold_count = DigCount;	/* need time for digging */
+      SendEffectDiggingPacket (nuser);
+      return 0;
+    }
+}
+
+/* ride */
+static void
+rideVehicle (int nuser, int nslot, int nspeed, int npattern)
+{
+  if (User[nuser].c_type == Hunter)
+    {
+      if (User[nuser].animal_slot > nslot)
+	{
+	  /* need shrink slot */
+	  int i;
+	  for (i = nslot; i < User[nuser].animal_slot; i++)
+	    {
+	      User[nuser].lastPickupAnimal[i] = NULL;
+	    }
+	}
+      User[nuser].animal_slot = nslot;
+    }
+  User[nuser].speed = nspeed;
+  User[nuser].speed_count = 0;
+  User[nuser].ride_pattern = npattern;
+  return;
+}
+
+/* hire npc for user */
+static int
+HireNpcForUser (int nuser, int neffect)
+{
+  int i;
+  for (i = NpcLimitForSystem; i < NpcLimit; i++)
+    {
+      if (Npc[i].name[0] == '\0')
+	{
+	  static const char *mesg[4] = {
+	    "%-.16s say,OK Boss. I will guard you.",
+	    "%-.16s say,Ready for deployment",
+	    "%-.16s say,It's show time!",
+	    "%-.16s say,Do you wanna use my design?"
+	  };
+	  static const int ck_x[8] = { 0, 1, 1, 1, 0, -1, -1, -1 };
+	  static const int ck_y[8] = { -1, -1, 0, 1, 1, 1, 0, -1 };
+	  int x;
+	  int y;
+	  int j;
+	  x = User[nuser].pos.x;
+	  y = User[nuser].pos.y;
+	  for (j = 0; j < 8; j++)
+	    {
+	      int wkx = x + ck_x[j];
+	      int wky = y + ck_y[j];
+	      adjust_pos (&wkx, &wky);
+	      if ((MAP (wkx, wky)->id & MAP_MASK) == MAP_ROCK ||
+		  (MAP (wkx, wky)->id & MAP_NOT_MOVE) ||
+		  MAP (wkx, wky)->player)
+		{
+		  continue;
+		}
+	      break;
+	    }
+	  if (j == 8)
+	    {
+	      return -1;
+	    }
+	  x += ck_x[j];
+	  y += ck_y[j];
+	  adjust_pos (&x, &y);
+	  Npc[i].c_type = NpcHige;
+	  Npc[i].number = getrand (1, HireableNpcType);
+	  memcpy (Npc[i].name,
+		  NpcHiges[getrand (0, NpcHigesN - 1)], USERNAME_LEN);
+	  MAP (x, y)->id |= MAP_THERE_NPC;
+	  MAP (x, y)->animal = i;
+	  Npc[i].pos.x = x;
+	  Npc[i].pos.y = y;
+	  Npc[i].direction = getrand (0, 3);
+	  Npc[i].speed = getrand (NpcSpeedMin, NpcSpeedMax) * NpcSpeedBase;
+	  Npc[i].speed_count = 0;
+	  Npc[i].search = getrand (NpcSearchMin, NpcSearchMax);
+	  Npc[i].attack = getrand (NpcAttackMin, NpcAttackMax);
+	  Npc[i].owner_user = nuser;
+	  Npc[i].ntarget_user = -1;
+	  Npc[i].hp = neffect;
+	  if (User[nuser].c_type == Hunter)
+	    {
+	      Npc[i].weapon = get_npc_weapon (NpcHunter);
+	      Npc[i].moral_limit = ANIMAL_MORAL_PANIC;
+	    }
+	  else
+	    {
+	      Npc[i].weapon = get_npc_weapon (NpcObserver);
+	      Npc[i].moral_limit = ANIMAL_MORAL_NORMAL + 1;
+	    }
+	  Npc[i].bullette = Weapon[Npc[i].weapon].bullette;
+	  Npc[i].nochangelock_count = 0;
+	  Npc[i].hold_count = 0;
+	  Npc[i].reload = 0;
+	  NPCsay (i, mesg, 4);
+	  return 0;
+	}
+    }
+  return -1;
+}
+
+/* process use item */
+static void
+processUseItem (int nuser, int nitem)
+{
+  if (User[nuser].itemcount[nitem])
+    {
+      char work[MESG_BUFFER];
+      ITEMINFO *pitem = Item + User[nuser].item[nitem];
+      User[nuser].itemcount[nitem]--;
+      switch (pitem->id)
+	{
+	case Noeffect:
+	  /* no effect */
+	  strcpy (work, "No effect");
+	  break;
+	case Heal:
+	  /* heal */
+	  cause_heal (nuser, pitem->effect);
+	  sprintf (work, "You get %uHP", pitem->effect);
+	  break;
+	case Tree:
+	  /* glow Tree */
+	  glowTree (nuser);
+	  strcpy (work, "[Tree is important resource.]");
+	  break;
+	case Charm:
+	  /* charm near animal */
+	  strcpy (work, "You attempt to charm animal...");
+	  processCharmAnimal (nuser, pitem->effect);
+	  break;
+	case Score:
+	  /* get score */
+	  add_score (nuser, pitem->effect);
+	  sprintf (work, "You get %uscore", pitem->effect);
+	  break;
+	case Damage:
+	  /* bad ... */
+	  cause_damage (nuser, pitem->effect, -1, TargetNone);
+	  sprintf (work, "You lost %uHP", pitem->effect);
+	  break;
+	case AnimalRadar:
+	  /* animal radar */
+	  SendSystemMessagePacket (nuser, "<scan animal...>");
+	  ListUpNearAnimal (nuser, pitem->effect);
+	  strcpy (work, "<end of scan>");
+	  break;
+	case HumanRadar:
+	  /* human radar */
+	  SendSystemMessagePacket (nuser, "<scan...>");
+	  ListUpNearHuman (nuser, pitem->effect);
+	  strcpy (work, "<end of scan>");
+	  break;
+	case Invisible:
+	  if (User[nuser].cloak_count)
+	    {
+	      User[nuser].itemcount[nitem]++;
+	      strcpy (work, "[You are already invisible!]");
+	    }
+	  else
+	    {
+	      User[nuser].cloak_count = pitem->effect;
+	      strcpy (work, "[You are now invisible]");
+	    }
+	  break;
+	case BuildShop:
+	  if (buildupMyShop (nuser))
+	    {
+	      /* occur error */
+	      User[nuser].itemcount[nitem]++;
+	      strcpy (work, "[You can't build shop here!]");
+	    }
+	  else
+	    {
+	      strcpy (work, "[Build your shop!]");
+	    }
+	  break;
+	case DigHole:
+	  if (digHoleHere (nuser))
+	    {
+	      strcpy (work, "[You try to dig...but you can't dig hole]");
+	    }
+	  else
+	    {
+	      strcpy (work, "[You dig hole... hehehe]");
+	    }
+	  break;
+	case Vehicle:
+	  sprintf (work, "You ride on %-.32s", pitem->name);
+	  rideVehicle (nuser, pitem->effect % 100, pitem->effect / 100,
+		       pitem->pattern);
+	  break;
+	case Food:
+	  cause_eat (nuser, pitem->effect);
+	  sprintf (work, "You eat %-.32s. ", pitem->name);
+	  if (pitem->effect > 100)
+	    {
+	      strcat (work, "Delicious!");
+	    }
+	  else if (pitem->effect >= 50)
+	    {
+	      strcat (work, "uhmm. no feel so bad.");
+	    }
+	  else if (pitem->effect >= 10)
+	    {
+	      strcat (work, "better than nothing.");
+	    }
+	  else
+	    {
+	      strcat (work, "I think this is dogfood.");
+	    }
+	  break;
+	case HireNpc:
+	  if (HireNpcForUser (nuser, pitem->effect))
+	    {
+	      User[nuser].itemcount[nitem]++;
+	      strcpy (work, "[Can't hire NPC now]");
+	    }
+	  else
+	    {
+	      strcpy (work, "[You hire NPC]");
+	    }
+	  break;
+	default:
+	  strcpy (work, "?? error item");
+	  break;
+	}
+      SendSystemMessagePacket (nuser, work);
+    }
+  if (User[nuser].itemcount[nitem] == 0)
+    {
+      User[nuser].item[nitem] = 0;
+    }
+  return;
+}
+
+/* add item to slot */
+static int
+addItemSlot (int nuser, int nitem)
+{
+  int i;
+  char work[MESG_BUFFER];
+  for (i = 0; i < ITEM_MAX; i++)
+    {
+      if (User[nuser].item[i] == 0 || User[nuser].itemcount[i] == 0)
+	{
+	  break;
+	}
+    }
+  if (i == ITEM_MAX)
+    {
+      /* full hand */
+      /* no space */
+      return -1;
+    }
+  User[nuser].item[i] = nitem;
+  User[nuser].itemcount[i] = Item[User[nuser].item[i]].count;
+  sprintf (work, "[Get item%1d:%-.32s]",
+	   i + 1, Item[User[nuser].item[i]].name);
+  SendSystemMessagePacket (nuser, work);
+  return i;
+}
+
+/* add weapon to slot */
+static int
+addWeaponSlot (int nuser, int nweapon)
+{
+  int i;
+  char work[MESG_BUFFER];
+  for (i = 0; i < WEAPON_MAX; i++)
+    {
+      if (User[nuser].weapon[i] == 0 || User[nuser].bullette[i] == 0)
+	{
+	  break;
+	}
+    }
+  if (i == WEAPON_MAX)
+    {
+      /* full hand */
+      /* no space */
+      return -1;
+    }
+  User[nuser].weapon[i] = nweapon;
+  User[nuser].bullette[i] = Weapon[User[nuser].weapon[i]].bullette;
+  User[nuser].reload[i] = 0;
+  sprintf (work, "[Get weapon%1d:%-.32s]",
+	   i + 1, Weapon[User[nuser].weapon[i]].name);
+  SendSystemMessagePacket (nuser, work);
+  return i;
+}
+
+/* process pickup */
+static void
+processPickUp (int nuser)
+{
+  int x = User[nuser].pos.x;
+  int y = User[nuser].pos.y;
+  x += FWVectorX[User[nuser].direction];
+  y += FWVectorY[User[nuser].direction];
+  adjust_pos (&x, &y);
+  if (MAP (x, y)->id & MAP_THERE_ITEM)
+    {
+      /* pickup */
+      struct itembox_t *pitembox;
+      int nitem;
+      int isitem;
+      unsigned nleft;
+      int okpickup = 0;
+      SendSystemMessagePacket (nuser, "[You open treasure box...]");
+      pitembox = getUserItemBox (x, y);
+      if (pitembox == NULL)
+	{
+	  /* it is made by system */
+	  if (getrand (1, 100) == 1)
+	    {
+	      /* trap */
+	      unsigned ndamage = getrand (100, 500);
+	      SendSystemMessagePacket (nuser, "[Explode! You are damaged!]");
+	      cause_damage (nuser, ndamage, -1, TargetNone);
+	      okpickup = 1;
+	    }
+	  else if (getrand (1, 100) <= RateBoxInItem)
+	    {
+	      /* it's item */
+	      isitem = 1;
+	      nitem = getrand (1, ItemLimit - 1);
+	      nleft = Item[nitem].count;
+	      if (addItemSlot (nuser, nitem) != -1)
+		{
+		  okpickup = 1;
+		}
+	    }
+	  else
+	    {
+	      /* it's weapon */
+	      isitem = 0;
+	      nitem = getrand (1, WeaponLimit - 1);
+	      nleft = Weapon[nitem].bullette;
+	      if (addWeaponSlot (nuser, nitem) != -1)
+		{
+		  okpickup = 1;
+		}
+	    }
+	}
+      else
+	{
+	  /* user made */
+	  isitem = pitembox->isitem;
+	  nitem = pitembox->n;
+	  nleft = pitembox->left;
+	  if (pitembox->isitem)
+	    {
+	      /* it's item */
+	      int nslot = addItemSlot (nuser, pitembox->n);
+	      if (nslot != -1)
+		{
+		  User[nuser].itemcount[nslot] = pitembox->left;
+		  okpickup = 1;
+		}
+	    }
+	  else
+	    {
+	      /* its's weapon */
+	      int nslot = addWeaponSlot (nuser, pitembox->n);
+	      if (nslot != -1)
+		{
+		  User[nuser].bullette[nslot] = pitembox->left;
+		  okpickup = 1;
+		}
+	    }
+	  if (pitembox->message[0] != '\0')
+	    {
+	      SendSystemMessagePacket (nuser, pitembox->message);
+	    }
+	  free (pitembox);
+	}
+      if (!okpickup)
+	{
+	  /* can't get this. drop original position */
+	  char work[MESG_BUFFER];
+	  sprintf (work, "[You have no space to get %-.32s!]",
+		   isitem ? Item[nitem].name : Weapon[nitem].name);
+	  SendSystemMessagePacket (nuser, work);
+	  addUserItemBox (x, y, isitem, nitem, nleft, NULL);
+	}
+      else
+	{
+	  MAP (x, y)->id &= ~MAP_THERE_ITEM;
+	}
+    }
+  else if (MAP (x, y)->id & MAP_THERE_ANIMAL)
+    {
+      int nanimal = MAP (x, y)->animal;
+      if (User[nuser].c_type == Hunter)
+	{
+	  /* animal */
+	  if (Animal[nanimal].moral < ANIMAL_MORAL_PANIC)
+	    {
+	      /* ok. you can catch */
+	      char work[MESG_BUFFER];
+	      unsigned n;
+	      MAP (x, y)->id &= ~MAP_THERE_ANIMAL;
+	      n = Animal[nanimal].pdata->value;
+	      if (Animal[nanimal].hp == 0)
+		{
+		  n /= 100;
+		}
+	      else
+		{
+		  put_animal_slot (nuser, Animal[nanimal].pdata);
+		}
+	      add_score (nuser, n);
+	      add_crime (nuser, n);
+	      sprintf (work, "[You catch %-.16s:%upoint]",
+		       CUTTAIL (Animal[nanimal].name), n);
+	      SendSystemMessagePacket (nuser, work);
+	      DeleteAnimal (nanimal);
+	    }
+	  else
+	    {
+	      /* aggressive animal */
+	      SendSystemMessagePacket (nuser,
+				       "[You can't catch aggressive animal!]");
+	    }
+	}
+      else
+	{
+	  /* observer */
+	  if (Animal[nanimal].hp == 0)
+	    {
+	      /* it is animal corpse */
+	      char work[MESG_BUFFER];
+	      sprintf (work, "[You collect %-.16s's corpse:10point]",
+		       CUTTAIL (Animal[nanimal].name));
+	      SendSystemMessagePacket (nuser, work);
+	      MAP (x, y)->id &= ~MAP_THERE_ANIMAL;
+	      add_score (nuser, 10);
+	      DeleteAnimal (nanimal);
+	    }
+	  else
+	    {
+	      SendSystemMessagePacket (nuser,
+				       "[You do not allow to catch animal!]");
+	    }
+	}
+    }
+  else if (MAP (x, y)->id & MAP_THERE_NPC)
+    {
+      int npc = MAP (x, y)->animal;
+      if (User[nuser].c_type == Observer && Npc[npc].c_type == NpcHunter)
+	{
+	  /* arrest! */
+	  char work[MESG_BUFFER];
+	  sprintf (work, "[You arrest %-.16s. Get 500point.]",
+		   CUTTAIL (Npc[npc].name));
+	  SendSystemMessagePacket (nuser, work);
+	  add_score (nuser, 500);
+	  MAP (x, y)->id &= ~MAP_THERE_NPC;
+	  Npc[npc].name[0] = '\0';
+	}
+    }
+  else if (MAP (x, y)->player)
+    {
+      int ntarget = MAP (x, y)->player - 1;
+      if (User[nuser].c_type == Observer && User[ntarget].c_type == Hunter)
+	{
+	  char work[MESG_BUFFER];
+	  if (User[ntarget].maybearrest || User[ntarget].crime_level > 1)
+	    {
+	      unsigned long npts = User[ntarget].maybearrest + 100;
+	      switch (User[ntarget].crime_level)
+		{
+		case 1:
+		  npts += ArrestPass / 2;
+		  add_crime (ntarget, ArrestPass);
+		  break;
+		case 2:
+		  npts += ArrestAnyone / 2;
+		  add_crime (ntarget, ArrestAnyone);
+		  break;
+		}
+	      User[ntarget].crime_level = 0;
+	      sprintf (work, "[You arrest %-.16s. Get %lupoint.]",
+		       CUTTAIL (User[ntarget].name), npts);
+	      SendSystemMessagePacket (nuser, work);
+	      sprintf (work, "[You were arrested by %-.16s]",
+		       CUTTAIL (User[nuser].name));
+	      SendSystemMessagePacket (ntarget, work);
+	      SendSystemMessagePacket (ntarget, "[Go to Jail!]");
+	      ClearUser (ntarget);
+	      User[ntarget].status = Arrested;
+	      add_arrest (ntarget);
+	      User[ntarget].action = NoAction;
+	      User[ntarget].move = NoMove;
+	      User[ntarget].pos.x = JailPositionX;
+	      User[ntarget].pos.y = JailPositionY;
+	      clear_animal_slot (ntarget);
+	      add_score (nuser, npts);
+	    }
+	  else
+	    {
+	      sprintf (work, "[You attempt to arrest %-.16s]",
+		       CUTTAIL (User[ntarget].name));
+	      SendSystemMessagePacket (nuser, work);
+	      SendSystemMessagePacket (nuser, "[But he do not crime]");
+	      sprintf (work, "[%-.16s attempt to arrest you]",
+		       CUTTAIL (User[nuser].name));
+	      SendSystemMessagePacket (ntarget, work);
+	      SendSystemMessagePacket (ntarget, "[But you are innocence]");
+	    }
+	}
+      else
+	{
+	  SendSystemMessagePacket (nuser, "[What do you want?]");
+	}
+    }
+  else
+    {
+      SendSystemMessagePacket (nuser, "[You catch the air]");
+    }
+  return;
+}
+
+/* process pay*/
+static void
+processPay (int nuser)
+{
+  if (User[nuser].status == Arrested)
+    {
+      unsigned ncost = User[nuser].maybearrest;
+      char work[MESG_BUFFER];
+      if (ncost)
+	{
+	  if (User[nuser].score >= ncost)
+	    {
+	      dec_score (nuser, ncost);
+	      sprintf (work, "[You paid %upoint for free]", ncost);
+	      User[nuser].status = Healthy;
+	      User[nuser].maybearrest = 0;
+	      ActivateUser (nuser);
+	    }
+	  else
+	    {
+	      strcpy (work, "[You have not enought point for free]");
+	    }
+	}
+      else
+	{
+	  /* ok. you are free now. */
+	  strcpy (work, "[You are free now]");
+	  User[nuser].status = Healthy;
+	  User[nuser].maybearrest = 0;
+	  ActivateUser (nuser);
+	}
+      SendSystemMessagePacket (nuser, work);
+    }
+  else
+    {
+      SendSystemMessagePacket (nuser, "[No need pay. You are free.]");
+    }
+  return;
+}
+
+/* buy in HIGE Shop */
+static void
+buyInHigeShop (int nuser, int buyitem)
+{
+  char work[MESG_BUFFER];
+  int buy = 0;
+  int nospace = 0;
+  unsigned ncost = 0;
+  int n = User[nuser].wk_for_action;
+  if (User[nuser].c_type == Hunter)
+    {
+      if (buyitem)
+	{
+	  if (n >= 0 && n < ForHunterItemLimit)
+	    {
+	      ncost = Item[ForHunterItem[n]].cost;
+	      if (User[nuser].score >= ncost)
+		{
+		  if (addItemSlot (nuser, ForHunterItem[n]) != -1)
+		    {
+		      dec_score (nuser, ncost);
+		      buy = 1;
+		    }
+		  else
+		    {
+		      nospace = 1;
+		    }
+		}
+	    }
+	}
+      else
+	{
+	  if (n >= 0 && n < ForHunterWeaponLimit)
+	    {
+	      ncost = Weapon[ForHunterWeapon[n]].cost;
+	      if (User[nuser].score >= ncost)
+		{
+		  if (addWeaponSlot (nuser, ForHunterWeapon[n]) != -1)
+		    {
+		      dec_score (nuser, ncost);
+		      buy = 1;
+		    }
+		  else
+		    {
+		      nospace = 1;
+		    }
+		}
+	    }
+	}
+    }
+  else
+    {
+      if (buyitem)
+	{
+	  if (n >= 0 && n < ForObserverItemLimit)
+	    {
+	      ncost = Item[ForObserverItem[n]].cost;
+	      if (User[nuser].score >= ncost)
+		{
+		  if (addItemSlot (nuser, ForObserverItem[n]) != -1)
+		    {
+		      dec_score (nuser, ncost);
+		      buy = 1;
+		    }
+		  else
+		    {
+		      nospace = 1;
+		    }
+		}
+	    }
+	}
+      else
+	{
+	  if (n >= 0 && n < ForObserverWeaponLimit)
+	    {
+	      ncost = Weapon[ForObserverWeapon[n]].cost;
+	      if (User[nuser].score >= ncost)
+		{
+		  if (addWeaponSlot (nuser, ForObserverWeapon[n]) != -1)
+		    {
+		      dec_score (nuser, ncost);
+		      buy = 1;
+		    }
+		  else
+		    {
+		      nospace = 1;
+		    }
+		}
+	    }
+	}
+    }
+  if (buy)
+    {
+      if (ncost)
+	{
+	  sprintf (work, "[You paid %upoint]", ncost);
+	}
+      else
+	{
+	  strcpy (work, "[You no need pay for this!]");
+	}
+    }
+  else
+    {
+      if (nospace)
+	{
+	  strcpy (work,
+		  buyitem ? "[no free Item slot]" : "[no free Weapon slot]");
+	}
+      else if (ncost)
+	{
+	  sprintf (work, "[Need %upoint for buy!]", ncost);
+	}
+      else
+	{
+	  strcpy (work, "[out of item number range]");
+	}
+    }
+  SendSystemMessagePacket (nuser, work);
+  return;
+}
+
+/* buy in User Shop */
+static void
+buyInUserShop (int nowner, int nuser, int buyitem)
+{
+  int x = User[nuser].pos.x;
+  int y = User[nuser].pos.y;
+  int nshop = searchUserShopFromPos (nowner, x, y);
+  if (nshop == -1 || User[nowner].myshop[nshop].build == 0)
+    {
+      SendSystemMessagePacket (nuser, "(FATAL:user shop linkage is broken)");
+    }
+  else
+    {
+      char work[MESG_BUFFER];
+      unsigned short ncost = 0;
+      int n = User[nuser].wk_for_action;
+      if (n >= 0 && n < SELLINSHOP_LIMIT)
+	{
+	  if (User[nowner].myshop[nshop].count[buyitem][n])
+	    {
+	      int buy = 0;
+	      int nospace = 0;
+	      ncost = User[nowner].myshop[nshop].cost[buyitem][n];
+	      if (User[nuser].score >= ncost)
+		{
+		  int nbuy = User[nowner].myshop[nshop].list[buyitem][n];
+		  if (buyitem)
+		    {
+		      int nitem;
+		      nitem = addItemSlot (nuser, nbuy);
+		      if (nitem != -1)
+			{
+			  User[nuser].itemcount[nitem] =
+			    User[nowner].myshop[nshop].leftuse[buyitem][n];
+			  buy = 1;
+			}
+		      else
+			{
+			  nospace = 1;
+			}
+		    }
+		  else
+		    {
+		      int nweapon;
+		      nweapon = addWeaponSlot (nuser, nbuy);
+		      if (nweapon != -1)
+			{
+			  User[nuser].bullette[nweapon] =
+			    User[nowner].myshop[nshop].leftuse[buyitem][n];
+			  buy = 1;
+			}
+		      else
+			{
+			  nospace = 1;
+			}
+		    }
+		  if (buy)
+		    {
+		      dec_score (nuser, ncost);
+		      add_score (nowner, ncost);
+		    }
+		}
+	      if (buy)
+		{
+		  User[nowner].myshop[nshop].count[buyitem][n]--;
+		  if (ncost)
+		    {
+		      sprintf (work, "[You paid %upoint]", ncost);
+		    }
+		  else
+		    {
+		      strcpy (work, "[You no need pay for this!]");
+		    }
+		}
+	      else
+		{
+		  if (nospace)
+		    {
+		      strcpy (work, buyitem ?
+			      "[no free Item slot]" :
+			      "[no free Weapon slot]");
+		    }
+		  else
+		    {
+		      sprintf (work, "[Need %upoint for buy!]", ncost);
+		    }
+		}
+	    }
+	  else
+	    {
+	      strcpy (work, "[no stock]");
+	    }
+	  SendSystemMessagePacket (nuser, work);
+	}
+      else
+	{
+	  SendSystemMessagePacket (nuser, "[out of item number range]");
+	}
+    }
+  return;
+}
+
+/* process buy */
+static void
+processBuy (int nuser, int buyitem)
+{
+  if (MAP (User[nuser].pos.x, User[nuser].pos.y)->id & MAP_THERE_SHOP)
+    {
+      /* ok. in shop. */
+      int nowner = MAP (User[nuser].pos.x, User[nuser].pos.y)->owner;
+      if (!nowner)
+	{
+	  buyInHigeShop (nuser, buyitem);
+	}
+      else
+	{
+	  buyInUserShop (nowner - 1, nuser, buyitem);
+	}
+    }
+  else
+    {
+      SendSystemMessagePacket (nuser, "[No shop here!]");
+    }
+  return;
+}
+
+/* process list myshop */
+static void
+processListMyShop (int nuser)
+{
+  int i;
+  SendSystemMessagePacket (nuser, "<Your shop list>");
+  for (i = 0; i < USERSHOP_LIMIT; i++)
+    {
+      if (User[nuser].myshop[i].build)
+	{
+	  char work[MESG_BUFFER];
+	  sprintf (work,
+		   "<%d:%-16.16s (%3d,%3d)>", i + 1,
+		   User[nuser].myshop[i].name,
+		   User[nuser].myshop[i].pos.x, User[nuser].myshop[i].pos.y);
+	  SendSystemMessagePacket (nuser, work);
+	}
+    }
+  SendSystemMessagePacket (nuser, "<end of list>");
+  return;
+}
+
+/* process list my animal */
+static void
+processListMyAnimal (int nuser)
+{
+  int i;
+  char work[MESG_BUFFER];
+  SendSystemMessagePacket (nuser, "<CAPTURED ANIMAL>");
+  for (i = 0; i < User[nuser].animal_slot; i++)
+    {
+      ANIMALDATA *p = User[nuser].lastPickupAnimal[i];
+      if (p != NULL)
+	{
+	  sprintf (work, "<%d:%-16.16s(%-.32s)>", i + 1, p->name,
+		   Item[p->forsell_item].name);
+	  SendSystemMessagePacket (nuser, work);
+	}
+      else
+	{
+	  sprintf (work, "<%d:EMPTY>", i + 1);
+	  SendSystemMessagePacket (nuser, work);
+	}
+    }
+  SendSystemMessagePacket (nuser, "<end of list>");
+  return;
+}
+
+/* drop item or weapon */
+static void
+dropItemOrWeapon (int nuser, int isitem, int nslot, const char *pmesg)
+{
+  int x = User[nuser].pos.x;
+  int y = User[nuser].pos.y;
+  if (!(MAP (x, y)->id & MAP_HIGH_MASK))
+    {
+      int n;
+      unsigned ncount;
+      if (isitem)
+	{
+	  if (nslot < 0 || nslot > ITEM_MAX)
+	    {
+	      /* illegal slot */
+	      SendSystemMessagePacket (nuser, "[Illegal slot number]");
+	      return;
+	    }
+	  n = User[nuser].item[nslot];
+	  ncount = User[nuser].itemcount[nslot];
+	}
+      else
+	{
+	  if (nslot < 0 || nslot > WEAPON_MAX)
+	    {
+	      /* illegal slot */
+	      SendSystemMessagePacket (nuser, "[Illegal slot number]");
+	      return;
+	    }
+	  n = User[nuser].weapon[nslot];
+	  ncount = User[nuser].bullette[nslot];
+	}
+      if (n && ncount)
+	{
+	  MAP (x, y)->id |= MAP_THERE_ITEM;
+	  addUserItemBox (x, y, isitem, n, ncount, pmesg);
+	  if (isitem)
+	    {
+	      User[nuser].item[nslot] = 0;
+	      User[nuser].itemcount[nslot] = 0;
+	    }
+	  else
+	    {
+	      User[nuser].weapon[nslot] = 0;
+	      User[nuser].bullette[nslot] = 0;
+	    }
+	  SendSystemMessagePacket (nuser, isitem ?
+				   "[Drop item]" : "[Drop Weapon]");
+	}
+      else
+	{
+	  SendSystemMessagePacket (nuser, isitem ?
+				   "[Item is empty]" : "[Weapon is empty]");
+	}
+    }
+  else
+    {
+      SendSystemMessagePacket (nuser, "[You can't drop here!]");
+    }
+  return;
+}
+
+/* process list live animal */
+static void
+processListLiveAnimal (int nuser)
+{
+  int i;
+  int *animal = malloc (AnimalDataLimit * sizeof (int));
+  char work[MESG_BUFFER];
+  if (animal == NULL)
+    {
+      SendSystemMessagePacket (nuser,
+			       "<FATAL:can't allocate animal list memory!>");
+      return;
+    }
+  memset (animal, 0, AnimalDataLimit * sizeof (int));
+  SendSystemMessagePacket (nuser, "<ANIMAL LIST>");
+  for (i = 0; i < AnimalLimit; i++)
+    {
+      if (Animal[i].pdata != NULL && Animal[i].hp)
+	{
+	  animal[Animal[i].pdata->n]++;
+	}
+    }
+  for (i = 0; i < AnimalDataLimit; i++)
+    {
+      if (animal[i])
+	{
+	  sprintf (work, "<'%-16.16s' lives:%3d rate:%3u value:%5u>",
+		   AnimalData[i].name, animal[i],
+		   AnimalData[i].rate, AnimalData[i].value);
+	  SendSystemMessagePacket (nuser, work);
+	}
+    }
+  SendSystemMessagePacket (nuser, "<end of list>");
+  free (animal);
+  return;
+}
+
+#ifdef USE_MAIL
+/* list my mailbox */
+static void
+processListMyMail (int nuser)
+{
+  int i;
+  int f = 0;
+  SendSystemMessagePacket (nuser, "<MAILBOX>");
+  ReorderMailbox (nuser);
+  for (i = 0; i < MAIL_BOX_LIMIT; i++)
+    {
+      if (User[nuser].mail[i] != NULL)
+	{
+	  MAILDATA *pmail = User[nuser].mail[i];
+	  char subjectbuffer[32];
+	  char work[MESG_BUFFER];
+	  if (pmail->subject[0])
+	    {
+	      int n = pmail->subject[0];
+	      if (n > 32)
+		{
+		  n = 32;
+		}
+	      strncpy (subjectbuffer, pmail->subject + 1, n);
+	      for (; n < 32; n++)
+		{
+		  subjectbuffer[n] = '\0';
+		}
+	    }
+	  else
+	    {
+	      strcpy (subjectbuffer, "NO SUBJECT");
+	    }
+	  sprintf (work, "<%c%2d:%-16.16s %-.32s>",
+		   pmail->readflag ? ' ' : '*', i + 1,
+		   User[pmail->fromuser].name, subjectbuffer);
+	  SendSystemMessagePacket (nuser, work);
+	  f = 1;
+	}
+    }
+  SendSystemMessagePacket (nuser, (!f) ? "<no mail!>" : "<end of list>");
+  return;
+}
+
+/* read my mail */
+static void
+processReadMyMail (int nuser)
+{
+  int n = User[nuser].wk_for_action;
+  if (n >= 0 && n < MAIL_BOX_LIMIT && User[nuser].mail[n] != NULL)
+    {
+      /* ok. read this mail. */
+      printf ("user:%d read mail...\n", nuser);
+      if (SendMailHeader (nuser, User[nuser].mail[n]) ||
+	  SendMailBody (nuser, User[nuser].mail[n]))
+	{
+	  /* error */
+	  DisconnectUser (nuser);
+	}
+      else
+	{
+	  User[nuser].mail[n]->readflag = 1;
+	  SendSystemMessagePacket (nuser, "[end of mail-data transfer]");
+	  puts ("done");
+	}
+    }
+  else
+    {
+      SendSystemMessagePacket (nuser, "[no such mail!]");
+    }
+  return;
+}
+
+/* delete my mail */
+static void
+processDeleteMyMail (int nuser)
+{
+  int n = User[nuser].wk_for_action;
+  if (n >= 0 && n < MAIL_BOX_LIMIT && User[nuser].mail[n] != NULL)
+    {
+      /* ok. delete this mail. */
+      FreeMail (User[nuser].mail[n]);
+      User[nuser].mail[n] = NULL;
+      ReorderMailbox (nuser);
+      SendSystemMessagePacket (nuser, "[deleted 1 message]");
+    }
+  else
+    {
+      SendSystemMessagePacket (nuser, "[no such mail!]");
+    }
+  return;
+}
+
+#ifdef USE_BBS
+/* list bbs */
+static void
+processListBBS (int nuser)
+{
+  int i;
+  int f = 0;
+  SendSystemMessagePacket (nuser, "<BBS article(s)>");
+  for (i = 0; i < BBS_BOX_LIMIT; i++)
+    {
+      if (BBSdata[i] != NULL)
+	{
+	  MAILDATA *pmail = BBSdata[i];
+	  char subjectbuffer[32];
+	  char work[MESG_BUFFER];
+	  if (pmail->subject[0])
+	    {
+	      int n = pmail->subject[0];
+	      if (n > 32)
+		{
+		  n = 32;
+		}
+	      strncpy (subjectbuffer, pmail->subject + 1, n);
+	      for (; n < 32; n++)
+		{
+		  subjectbuffer[n] = '\0';
+		}
+	    }
+	  else
+	    {
+	      strcpy (subjectbuffer, "NO SUBJECT");
+	    }
+	  sprintf (work, "<%2d:%-16.16s %-.32s>",
+		   i + 1, User[pmail->fromuser].name, subjectbuffer);
+	  SendSystemMessagePacket (nuser, work);
+	  f = 1;
+	}
+    }
+  SendSystemMessagePacket (nuser, (!f) ? "<no article!>" : "<end of list>");
+  return;
+}
+
+/* read bbs article */
+static void
+processReadBBS (int nuser)
+{
+  int n = User[nuser].wk_for_action;
+  if (n >= 0 && n < BBS_BOX_LIMIT && BBSdata[n] != NULL)
+    {
+      /* ok. read this article. */
+      printf ("user:%d read article %d...\n", nuser, n + 1);
+      if (SendBBSHeader (nuser, BBSdata[n]) ||
+	  SendBBSBody (nuser, BBSdata[n]))
+	{
+	  /* error */
+	  DisconnectUser (nuser);
+	}
+      else
+	{
+	  SendSystemMessagePacket (nuser, "[end of article-data transfer]");
+	  puts ("done");
+	}
+    }
+  else
+    {
+      SendSystemMessagePacket (nuser, "[no such article!]");
+    }
+  return;
+}
+
+#endif /* USE_BBS */
+#endif /* USE_MAIL */
+
+/* resolve Users */
+static void
+ResolveUserPhase (void)
+{
+  int i;
+  for (i = 0; i < UserLimit; i++)
+    {
+      if (User[i].session.handle != INVALID_SOCKET)
+	{
+	  switch (User[i].action)
+	    {
+	    case NoAction:
+	      break;
+	    case Fire1:
+	      processFireWeapon (i, 0);
+	      break;
+	    case Fire2:
+	      processFireWeapon (i, 1);
+	      break;
+	    case UseItem1:
+	      processUseItem (i, 0);
+	      break;
+	    case UseItem2:
+	      processUseItem (i, 1);
+	      break;
+	    case UseItem3:
+	      processUseItem (i, 2);
+	      break;
+	    case UseItem4:
+	      processUseItem (i, 3);
+	      break;
+	    case PickUp:
+	      processPickUp (i);
+	      break;
+	    case Pay:
+	      processPay (i);
+	      break;
+	    case BuyWeapon:
+	      processBuy (i, 0);
+	      break;
+	    case BuyItem:
+	      processBuy (i, 1);
+	      break;
+	    case Who:
+	      SendWhoList (i);
+	      break;
+	    case RequestWeapon:
+	      SendWeaponList (i);
+	      break;
+	    case RequestItem:
+	      SendItemList (i);
+	      break;
+	    case StoreAnimal:
+	      storeLastPickup (i, User[i].lwk_for_action);
+	      break;
+	    case StoreWeapon:
+	      storeItemOrWeapon (i, 0,
+				 User[i].wk_for_action,
+				 User[i].lwk_for_action);
+	      break;
+	    case StoreItem:
+	      storeItemOrWeapon (i, 1,
+				 User[i].wk_for_action,
+				 User[i].lwk_for_action);
+	      break;
+	    case DiscardWeapon:
+	      discardItemOrWeapon (i, 0, User[i].wk_for_action);
+	      break;
+	    case DiscardItem:
+	      discardItemOrWeapon (i, 1, User[i].wk_for_action);
+	      break;
+	    case ListMyShop:
+	      processListMyShop (i);
+	      break;
+	    case DropWeapon:
+	      dropItemOrWeapon (i, 0, User[i].wk_for_action,
+				User[i].mesg_for_action);
+	      break;
+	    case DropItem:
+	      dropItemOrWeapon (i, 1, User[i].wk_for_action,
+				User[i].mesg_for_action);
+	      break;
+	    case ListMyAnimal:
+	      processListMyAnimal (i);
+	      break;
+	    case DoSay:
+	      processSendMessage (i, (unsigned char *)
+				  User[i].mesg_for_action);
+	      break;
+	    case DoTell:
+	      processSendMessage2User (i, (unsigned char *)
+				       User[i].mesg_for_action);
+	      break;
+	    case DoBroadcast:
+	      processBroadcastMessage (i, (unsigned char *)
+				       User[i].mesg_for_action);
+	      break;
+	    case DoWriteMesg:
+	      processWriteMesg (i, User[i].wk_for_action,
+				User[i].mesg_for_action);
+	      break;
+	    case DoChangeShopName:
+	      processChangeMyshop (i, User[i].mesg_for_action);
+	      break;
+	    case DoDestroyShop:
+	      processDestroyMyshop (i);
+	      break;
+	    case ListLiveAnimal:
+	      processListLiveAnimal (i);
+	      break;
+	    case DoChangeAnimalName:
+	      processChangeUserAnimalName (i, User[i].mesg_for_action);
+	      break;
+#ifdef USE_MAIL
+	    case ListMyMail:
+	      processListMyMail (i);
+	      break;
+	    case ReadMyMail:
+	      processReadMyMail (i);
+	      break;
+	    case DeleteMyMail:
+	      processDeleteMyMail (i);
+	      break;
+#ifdef USE_BBS
+	    case ListBBS:
+	      processListBBS (i);
+	      break;
+	    case ReadBBS:
+	      processReadBBS (i);
+	      break;
+#endif /* USE_BBS */
+#endif /* USE_MAIL */
+	    default:
+	      break;
+	    }
+	  User[i].action = NoAction;
+	}
+    }
+  return;
+}
+
+/* movement bullets */
+static void
+MovementBulletPhase (void)
+{
+  struct bullet_t *pb = pBullet;
+  while (pb != NULL)
+    {
+      if (pb->ndistance > 0)
+	{
+	  if (pb->ntime == 0)
+	    {
+	      /* move */
+	      pb->pos.x += FWVectorX[pb->direction];
+	      pb->pos.y += FWVectorY[pb->direction];
+	      adjust_pos (&pb->pos.x, &pb->pos.y);
+	      pb->ntime = pb->pweapon->speed;
+	      pb->ndistance--;
+	      if (pb->ndamage > pb->pweapon->reduce)
+		{
+		  pb->ndamage -= pb->pweapon->reduce;
+		}
+	      else
+		{
+		  pb->ndamage = 0;
+		}
+	    }
+	  else
+	    {
+	      pb->ntime--;
+	    }
+	}
+      pb = pb->pprev;
+    }
+  return;
+}
+
+/* check animal count */
+static int
+CountLiveAnimal (ANIMALDATA * p)
+{
+  int ret = 0;
+  int i;
+  for (i = 0; i < AnimalLimit; i++)
+    {
+      if (Animal[i].pdata == p && Animal[i].hp)
+	{
+	  ret++;
+	}
+    }
+  return ret;
+}
+
+/* resolve */
+static void
+ResolveBulletPhase (void)
+{
+  struct bullet_t *pb = pBullet;
+  while (pb != NULL)
+    {
+      struct bullet_t *pwork = pb->pprev;
+      if (pb->ndamage > 0)
+	{
+	  int x = pb->pos.x;
+	  int y = pb->pos.y;
+	  unsigned char c = MAP (x, y)->id & MAP_MASK;
+	  if (MAP (x, y)->player)
+	    {
+	      /* hit to player */
+	      int nuser = MAP (x, y)->player - 1;
+	      if (User[nuser].status == Healthy || User[nuser].maybearrest)
+		{
+		  int ndamage = getrand (pb->ndamage >> 1, pb->ndamage);
+		  cause_damage (nuser, ndamage, pb->nuser, pb->t_type);
+		  if (pb->pweapon->b_type != BulletAP)
+		    {
+		      /* bullet vanish */
+		      FreeBullet (pb);
+		      pb = NULL;
+		    }
+		}
+	    }
+	  else if (MAP (x, y)->id & MAP_THERE_ANIMAL)
+	    {
+	      /* hit to animal */
+	      int nanimal = MAP (x, y)->animal;
+	      if (Animal[nanimal].hp)
+		{
+		  int aggressive =
+		    (Animal[nanimal].moral > ANIMAL_MORAL_NORMAL) ? 1 : 0;
+		  int ndamage = getrand (pb->ndamage >> 1, pb->ndamage);
+		  int nmoral =
+		    getrand (pb->pweapon->moral >> 1, pb->pweapon->moral);
+		  char work[MESG_BUFFER];
+		  if (pb->nuser != -1)
+		    {
+		      if (pb->t_type == TargetUser)
+			{
+			  sprintf (work, "You attack animal '%-.16s'",
+				   CUTTAIL (Animal[nanimal].name));
+			  SendSystemMessagePacket (pb->nuser, work);
+			}
+		      sprintf (work, "[%-.16s shoot animal!]",
+			       CUTTAIL ((pb->t_type == TargetUser) ?
+					User[pb->nuser].name :
+					Npc[pb->nuser].name));
+		      if (pb->t_type == TargetUser)
+			{
+			  SendMessageNearUserPosition2 (pb->pos, work,
+							pb->nuser);
+			}
+		      else
+			{
+			  SendMessageNearUserPosition (pb->pos, work);
+			}
+		    }
+		  cause_damage_animal (nanimal, ndamage, nmoral);
+		  if (Animal[nanimal].hp == 0)
+		    {
+		      if (pb->nuser != -1 && pb->t_type == TargetUser)
+			{
+			  sprintf (work, "animal '%-.16s' died.",
+				   CUTTAIL (Animal[nanimal].name));
+			  SendSystemMessagePacket (pb->nuser, work);
+			  if (CountLiveAnimal (Animal[nanimal].pdata) == 0)
+			    {
+			      /* this is last animal! */
+			      sprintf (work,
+				       "[animal '%-.16s' is extermination!]",
+				       CUTTAIL (Animal[nanimal].name));
+			      SendSystemMessagePacket (pb->nuser, work);
+			      if (User[pb->nuser].c_type == Observer)
+				{
+				  unsigned pts = Animal[nanimal].pdata->value;
+				  dec_score (pb->nuser, pts);
+				  sprintf (work, "[You lost %upoint!]", pts);
+				  SendSystemMessagePacket (pb->nuser, work);
+				}
+			    }
+			  else
+			    {
+			      if (User[pb->nuser].c_type == Observer &&
+				  aggressive)
+				{
+				  unsigned pts = Animal[nanimal].pdata->moral;
+				  if (pts)
+				    {
+				      add_score (pb->nuser, pts);
+				      sprintf (work,
+					       "[You kill dangerous animal."
+					       " get %upoint]", pts);
+				      SendSystemMessagePacket (pb->nuser,
+							       work);
+				    }
+				}
+			    }
+			}
+		      Animal[nanimal].moral = 0;
+		    }
+		  else if (Animal[nanimal].moral == 0)
+		    {
+		      if (pb->nuser != -1 && pb->t_type == TargetUser)
+			{
+			  sprintf (work, "animal '%-.16s' stun.",
+				   CUTTAIL (Animal[nanimal].name));
+			  SendSystemMessagePacket (pb->nuser, work);
+			}
+		    }
+		  if (Animal[nanimal].hp)
+		    {
+		      if (pb->pweapon->b_type == BulletCharm)
+			{
+			  /* charm animal! */
+			  if (getrand (1, 100) <=
+			      Animal[nanimal].pdata->charm_rate)
+			    {
+			      /* success! */
+			      if (Animal[nanimal].owner_user == -1)
+				{
+				  sprintf (work, "You charm animal '%-.16s'!",
+					   CUTTAIL (Animal[nanimal].name));
+				  SendSystemMessagePacket (pb->nuser, work);
+				  Animal[nanimal].owner_user = pb->nuser;
+				}
+			      else
+				{
+				  sprintf (work,
+					   "Animal '%-.16s' is free now!",
+					   CUTTAIL (Animal[nanimal].name));
+				  SendMessageNearUserPosition (pb->pos, work);
+				  Animal[nanimal].owner_user = -1;
+				}
+			    }
+			  else
+			    {
+			      /* fail */
+			      sprintf (work,
+				       "You fail to charm animal '%-.16s'.",
+				       CUTTAIL (Animal[nanimal].name));
+			      SendSystemMessagePacket (pb->nuser, work);
+			    }
+			}
+		      else
+			{
+			  if (Animal[nanimal].moral >= ANIMAL_MORAL_PANIC &&
+			      getrand (1, 100) <= ANIMAL_RATE_ANGRY)
+			    {
+			      /* angry! */
+			      Animal[nanimal].charmcount = AngryCount;
+			      if (pb->nuser == -1)
+				{
+				  Animal[nanimal].charm_pos = pb->fire_pos;
+				  Animal[nanimal].charm = CharmPosition;
+				}
+			      else
+				{
+				  Animal[nanimal].ntarget = pb->nuser;
+				  Animal[nanimal].charm =
+				    (pb->t_type == TargetUser) ?
+				    CharmUser : CharmNpc;
+				}
+			    }
+			  else if (Animal[nanimal].moral < ANIMAL_MORAL_PANIC)
+			    {
+			      /* run away */
+			      Animal[nanimal].charmcount = 0;
+			    }
+			}
+		    }
+		  if (pb->pweapon->b_type != BulletAP)
+		    {
+		      /* bullet vanish */
+		      FreeBullet (pb);
+		      pb = NULL;
+		    }
+		}
+	    }
+	  else if (MAP (x, y)->id & MAP_THERE_NPC)
+	    {
+	      /* hit to NPC */
+	      int npc = MAP (x, y)->animal;
+	      if (Npc[npc].hp)
+		{
+		  int ndamage = getrand (pb->ndamage >> 1, pb->ndamage);
+		  char work[MESG_BUFFER];
+		  if (pb->nuser != -1 && pb->t_type == TargetUser)
+		    {
+		      sprintf (work, "You attack '%-.16s'",
+			       CUTTAIL (Npc[npc].name));
+		      SendSystemMessagePacket (pb->nuser, work);
+		    }
+		  cause_damage_npc (npc, ndamage);
+		  if (Npc[npc].hp == 0)
+		    {
+		      if (pb->nuser != -1 && pb->t_type == TargetUser)
+			{
+			  sprintf (work, "'%-.16s' died.",
+				   CUTTAIL (Npc[npc].name));
+			  SendSystemMessagePacket (pb->nuser, work);
+			  if (User[pb->nuser].c_type == Hunter &&
+			      Npc[npc].c_type == NpcObserver)
+			    {
+			      /* it is crime! */
+			      add_crime (pb->nuser, CrimeNpcMurder);
+			      SendSystemMessagePacket (pb->nuser,
+						       "[You are murder!]");
+			    }
+			}
+		      else
+			{
+			  if (pb->nuser != -1 && pb->t_type == TargetNpc)
+			    {
+			      sprintf (work, "'%-.16s' killed by ",
+				       CUTTAIL (Npc[npc].name));
+			      strcat (work, CUTTAIL (Npc[pb->nuser].name));
+			    }
+			  else
+			    {
+			      sprintf (work, "'%-.16s' killed by any!",
+				       CUTTAIL (Npc[npc].name));
+			    }
+			  SendMessageNearUserPosition (Npc[npc].pos, work);
+			}
+		      Npc[npc].name[0] = '\0';
+		      MAP (Npc[npc].pos.x, Npc[npc].pos.y)->id &=
+			~MAP_THERE_NPC;
+		    }
+		  else
+		    {
+		      /* still alive */
+		      if (Npc[npc].c_type == NpcObserver)
+			{
+			  /* maybe counter-attack */
+			  if (!(pb->t_type == TargetNpc && pb->nuser == npc))
+			    {
+			      static const char *mesg[5] = {
+				"%-.16s say,Hey! Why do you attack me?",
+				"%-.16s say,No! Don't shoot me!",
+				"%-.16s say,What's think?!",
+				"%-.16s say,Ohch! We are under fire!",
+				"%-.16s say,Ok. I will kill you."
+			      };
+			      NPCsay (npc, mesg, 5);
+			      Npc[npc].ntarget_user = pb->nuser;
+			      Npc[npc].t_type = pb->t_type;
+			      Npc[npc].nochangelock_count =
+				NPC_COUNTERATTACK_COUNT;
+			    }
+			}
+		      else if (Npc[npc].c_type == NpcHige)
+			{
+			  int willcounter = 0;
+			  if (pb->t_type == TargetUser &&
+			      Npc[npc].owner_user != pb->nuser)
+			    {
+			      willcounter = 1;
+			    }
+			  else if (pb->t_type == TargetNpc &&
+				   Npc[npc].owner_user != -1 &&
+				   Npc[npc].owner_user !=
+				   Npc[pb->nuser].owner_user)
+			    {
+			      willcounter = 1;
+			    }
+			  if (willcounter)
+			    {
+			      static const char *mesg[5] = {
+				"%-.16s say,Detect one boggy!",
+				"%-.16s say,We are under attack!",
+				"%-.16s say,Engage!",
+				"%-.16s say,Caution! Enemy fire!",
+				"%-.16s say,Emergency! Enemy attack us!"
+			      };
+			      NPCsay (npc, mesg, 5);
+			      Npc[npc].ntarget_user = pb->nuser;
+			      Npc[npc].t_type = pb->t_type;
+			    }
+			  else
+			    {
+			      static const char *mesg[5] = {
+				"%-.16s say,Hey! No shoot me!",
+				"%-.16s say,I'm friendly!",
+				"%-.16s say,This is friendly! Don't shoot!",
+				"%-.16s say,Don't shoot! Are you enemy's spy?",
+				"%-.16s say,Take more care!"
+			      };
+			      NPCsay (npc, mesg, 5);
+			    }
+			}
+		    }
+		  if (pb->pweapon->b_type != BulletAP)
+		    {
+		      /* bullet vanish */
+		      FreeBullet (pb);
+		      pb = NULL;
+		    }
+		}
+	    }
+	  else if (c == MAP_ROCK)
+	    {
+	      /* collision rock */
+	      if (pb->pweapon->b_type != BulletAP)
+		{
+		  /* bullet vanish */
+		  FreeBullet (pb);
+		  pb = NULL;
+		}
+	    }
+	  else if (c == MAP_TREE)
+	    {
+	      /* collision tree */
+	      if (pb->pweapon->b_type != BulletAP)
+		{
+		  if (pb->ndamage >= TreeHP)
+		    {
+		      /* can break tree */
+		      pb->ndamage -= TreeHP;
+		      INVALID_MAP (x, y);
+		      MAP (x, y)->id |= MAP_ROAD;
+		    }
+		  else
+		    {
+		      /* bullet vanish */
+		      FreeBullet (pb);
+		      pb = NULL;
+		    }
+		}
+	      else
+		{
+		  /* break tree! */
+		  INVALID_MAP (x, y);
+		  MAP (x, y)->id |= MAP_ROAD;
+		}
+	    }
+	}
+      if (pb != NULL && pb->ndistance == 0)
+	{
+	  /* no more left effective range... */
+	  /* bullet vanish */
+	  FreeBullet (pb);
+	}
+      pb = pwork;
+    }
+  return;
+}
+
+/* check attacker */
+static void
+check_live_attacker (int nuser)
+{
+  if (User[nuser].lastuser != -1)
+    {
+      switch (User[nuser].lastuser_type)
+	{
+	case TargetUser:
+	  if (User[User[nuser].lastuser].session.handle != INVALID_SOCKET &&
+	      User[User[nuser].lastuser].hp == 0)
+	    {
+	      User[nuser].lastuser = -1;
+	      User[nuser].lastuser_type = TargetNone;
+	    }
+	  break;
+	case TargetNpc:
+	  if (Npc[User[nuser].lastuser].name[0] == '\0')
+	    {
+	      User[nuser].lastuser = -1;
+	      User[nuser].lastuser_type = TargetNone;
+	    }
+	  break;
+	case TargetAnimal:
+	  if (Animal[User[nuser].lastuser].pdata == NULL ||
+	      Animal[User[nuser].lastuser].hp == 0 ||
+	      Animal[User[nuser].lastuser].moral == 0)
+	    {
+	      User[nuser].lastuser = -1;
+	      User[nuser].lastuser_type = TargetNone;
+	    }
+	  break;
+	default:
+	  break;
+	}
+    }
+  return;
+}
+
+/* prep for next turn */
+static void
+TurnEndPhase (int tickcount)
+{
+  static int dec_arrest_count = 0;
+  static int hungry_count = 0;
+  static unsigned long dec_jail_count = 0;
+  int i;
+  for (i = 0; i < UserLimit; i++)
+    {
+      if (User[i].session.handle != INVALID_SOCKET)
+	{
+	  /* check attacker */
+	  check_live_attacker (i);
+	  /* check alive */
+	  if (User[i].hp == 0)
+	    {
+	      /* die */
+	      SendEffectDeathPacket (i);
+	      dec_score (i, 100);
+	      if (User[i].c_type == Hunter)
+		{
+		  dec_score (i, User[i].maybearrest);
+		  switch (User[i].crime_level)
+		    {
+		    case 1:
+		      dec_score (i, ArrestPass / 2);
+		      break;
+		    case 2:
+		      dec_score (i, ArrestAnyone / 2);
+		      break;
+		    }
+		}
+	      if (User[i].lastuser != -1)
+		{
+		  /* anyone kill you */
+		  char work[MESG_BUFFER];
+		  const char *pname;
+		  int nuser = User[i].lastuser;
+		  if (User[i].lastuser_type == TargetUser)
+		    {
+		      sprintf (work, "[You kill %-.16s]",
+			       CUTTAIL (User[i].name));
+		      SendSystemMessagePacket (nuser, work);
+		    }
+		  switch (User[i].lastuser_type)
+		    {
+		    case TargetUser:
+		      pname = User[nuser].name;
+		      break;
+		    case TargetNpc:
+		      pname = Npc[nuser].name;
+		      break;
+		    case TargetAnimal:
+		      pname = Animal[nuser].name;
+		      break;
+		    default:
+		      pname = NULL;
+		      break;
+		    }
+		  if (pname != NULL)
+		    {
+		      sprintf (work,
+			       "[You were killed by %-.16s]",
+			       CUTTAIL (pname));
+		      SendSystemMessagePacket (i, work);
+		    }
+		  if (User[i].lastuser_type == TargetUser)
+		    {
+		      if (User[nuser].c_type == Observer &&
+			  User[i].c_type == Hunter)
+			{
+			  unsigned npoint = 0;
+			  npoint += User[i].score / 100;
+			  if (npoint)
+			    {
+			      add_score (nuser, npoint);
+			      sprintf (work, "[You get %upoint]", npoint);
+			      SendSystemMessagePacket (nuser, work);
+			    }
+			}
+		      else if (User[nuser].c_type == Hunter &&
+			       User[i].c_type == Observer)
+			{
+			  add_crime (nuser, CrimeMurder);
+			  SendSystemMessagePacket (nuser,
+						   "[You are murder!]");
+			}
+		      else if (User[i].crime_level == 2)
+			{
+			  /* it is murder */
+			  unsigned npoint = User[i].score / 100;
+			  if (npoint)
+			    {
+			      add_score (nuser, npoint);
+			      sprintf (work, "[You get bonus %upoint]",
+				       npoint);
+			      SendSystemMessagePacket (nuser, work);
+			    }
+			}
+		    }
+		}
+	      else
+		{
+		  /* you die by your own */
+		  SendSystemMessagePacket (i, "[You died]");
+		}
+	      if (!(MAP (User[i].pos.x, User[i].pos.y)->id &
+		    (MAP_THERE_WALL | MAP_THERE_ITEM)))
+		{
+		  MAP (User[i].pos.x, User[i].pos.y)->id |= MAP_THERE_ITEM;
+		}
+	      ClearUser (i);	/* clear from map */
+	      ActivateUser (i);	/* reborn */
+	    }
+	  if (dec_arrest_count == 0 &&
+	      User[i].c_type == Hunter && User[i].maybearrest)
+	    {
+	      if (User[i].maybearrest > DecArrest)
+		{
+		  User[i].maybearrest -= DecArrest;
+		}
+	      else
+		{
+		  User[i].maybearrest = 0;
+		}
+	      if (User[i].status == Arrested && User[i].arrest_count > 1)
+		{
+		  unsigned long crime_floor = User[i].arrest_count * 100;
+		  if (User[i].maybearrest < crime_floor)
+		    {
+		      User[i].maybearrest = crime_floor;
+		    }
+		}
+	    }
+	  if (dec_jail_count == 0 && User[i].arrest_count)
+	    {
+	      User[i].arrest_count--;
+	    }
+	  if (tickcount == 0)
+	    {
+	      /* send information data to User */
+	      if (SendUpdateInformation (i) != 0)
+		{
+		  DisconnectUser (i);
+		}
+	    }
+	  if (User[i].cloak_count)
+	    {
+	      User[i].cloak_count--;
+	    }
+	  if (User[i].hold_count)
+	    {
+	      User[i].hold_count--;
+	    }
+	  if (User[i].reload[0])
+	    {
+	      User[i].reload[0]--;
+	    }
+	  if (User[i].reload[1])
+	    {
+	      User[i].reload[1]--;
+	    }
+	  if (hungry_count == 0 && User[i].status == Healthy)
+	    {
+	      /* hungry? */
+	      switch (User[i].hungry)
+		{
+		case 50:
+		  SendSystemMessagePacket (i, "[You feel hungry]");
+		  break;
+		case 10:
+		  SendSystemMessagePacket (i, "[You feel weak by hungry]");
+		  break;
+		case 4:
+		case 3:
+		case 2:
+		case 1:
+		case 0:
+		  SendSystemMessagePacket (i, "[You can't move by hungry!]");
+		  User[i].hold_count += 10 * (5 - User[i].hungry);
+		  break;
+		default:
+		  break;
+		}
+	      if (User[i].hungry > 0)
+		{
+		  User[i].hungry--;
+		}
+	      else
+		{
+		  char work[MESG_BUFFER];
+		  cause_damage (i, DamageWhenHungry, -1, TargetNone);
+		  sprintf (work, "[You lost %uHP by hugry]",
+			   DamageWhenHungry);
+		  SendSystemMessagePacket (i, work);
+		}
+	    }
+	  if (MAP (User[i].pos.x, User[i].pos.y)->id & MAP_THERE_HOLE)
+	    {
+	      /* it's hole! */
+	      char work[MESG_BUFFER];
+	      MAP (User[i].pos.x, User[i].pos.y)->id &= ~MAP_THERE_HOLE;
+	      User[i].hold_count = HoldCount;
+	      SendSystemMessagePacket (i, "[You fall in hole!]");
+	      SendEffectFallInHolePacket (i);
+	      sprintf (work, "[You hear sound %-.16s fall in hole]",
+		       CUTTAIL (User[i].name));
+	      SendMessageNearUser (i, work);
+	    }
+	  User[i].idletimer++;
+	  if (User[i].idletimer == MaxTimeoutValue)
+	    {
+	      /* perhaps,disconnect session. */
+	      char work[USERNAME_LEN];
+	      memcpy (work, User[i].name, USERNAME_LEN);
+#ifdef MAKEWIN32
+	      convertH2C (work, USERNAME_LEN);
+#endif
+	      printf ("user(%d)[%-16.16s] no response\n", i, work);
+	      DisconnectUser (i);
+	    }
+	}
+    }
+  if (dec_arrest_count == 0)
+    {
+      dec_arrest_count = TurnPerDecArrest;
+    }
+  else
+    {
+      dec_arrest_count--;
+    }
+  if (dec_jail_count == 0)
+    {
+      dec_jail_count = TurnPerJailCount;
+    }
+  else
+    {
+      dec_jail_count--;
+    }
+  if (hungry_count == 0)
+    {
+      hungry_count = TurnPerHungry;
+    }
+  else
+    {
+      hungry_count--;
+    }
+  return;
+}
+
+/* count players in area */
+static int
+count_player_in (int x, int y)
+{
+  int ret = 0;
+  int by = y - 1;
+  int i;
+  x--;
+  for (i = 0; i < 3; i++)
+    {
+      int bx = x;
+      int j;
+      for (j = 0; j < 3; j++)
+	{
+	  int n;
+	  adjust_pos (&bx, &by);
+	  n = MAP (bx, by)->player;
+	  if (n && User[n - 1].cloak_count == 0)
+	    {
+	      ret++;
+	    }
+	  else if (MAP (bx, by)->id & MAP_THERE_NPC)
+	    {
+	      ret++;
+	    }
+	  bx++;
+	}
+      by++;
+    }
+  return ret;
+}
+
+/* count specific players in area */
+static int
+count_specific_player_in (int x, int y, enum usertype_t c_type)
+{
+  int ret = 0;
+  int by = y - 1;
+  int i;
+  x--;
+
+  for (i = 0; i < 3; i++)
+    {
+      int bx = x;
+      int j;
+      for (j = 0; j < 3; j++)
+	{
+	  int n;
+	  adjust_pos (&bx, &by);
+	  n = MAP (bx, by)->player;
+	  if (n && User[n - 1].cloak_count == 0 &&
+	      User[n - 1].c_type == c_type)
+	    {
+	      ret++;
+	    }
+	  else if (MAP (bx, by)->id & MAP_THERE_NPC)
+	    {
+	      int npc = MAP (bx, by)->animal;
+	      if (c_type == Hunter && Npc[npc].c_type == NpcHunter)
+		{
+		  ret++;
+		}
+	      else if (c_type == Observer && Npc[npc].c_type == NpcObserver)
+		{
+		  ret++;
+		}
+	      else if (Npc[npc].c_type == NpcHige &&
+		       User[Npc[npc].owner_user].c_type == c_type)
+		{
+		  ret++;
+		}
+	    }
+
+	  bx++;
+	}
+      by++;
+    }
+  return ret;
+}
+
+/* random move */
+static void
+random_move (int *px, int *py)
+{
+  static const int ck_x[4] = { 0, 1, 0, -1 };
+  static const int ck_y[4] = { -1, 0, 1, 0 };
+  int i;
+  int dx[4];
+  int dy[4];
+  int n = 0;
+  for (i = 0; i < 4; i++)
+    {
+      int wkx = *px + ck_x[i];
+      int wky = *py + ck_y[i];
+      adjust_pos (&wkx, &wky);
+      if (MAP (wkx, wky)->player)
+	{
+	  /* uhmm. player in destnation point. */
+	  continue;
+	}
+      if (MAP (wkx, wky)->id & MAP_NOT_MOVE)
+	{
+	  /* uhmm. other animal. */
+	  continue;
+	}
+      dx[n] = ck_x[i];
+      dy[n] = ck_y[i];
+      n++;
+    }
+  if (n)
+    {
+      int m = 0;
+      if (n > 1)
+	{
+	  m = getrand (0, n - 1);
+	}
+      *px += dx[m];
+      *py += dy[m];
+    }
+  return;
+}
+
+/* check attack type */
+static int
+check_attacker (int nowner, int ntarget, enum target_type t_type)
+{
+  switch (t_type)
+    {
+    case TargetUser:
+      if (User[ntarget].session.handle != INVALID_SOCKET &&
+	  User[ntarget].status != Arrested && nowner != ntarget)
+	{
+	  return 1;
+	}
+      break;
+    case TargetNpc:
+      if (Npc[ntarget].name[0] != '\0' && Npc[ntarget].owner_user != nowner)
+	{
+	  return 1;
+	}
+      break;
+    case TargetAnimal:
+      if (Animal[ntarget].pdata != NULL &&
+	  Animal[ntarget].hp && Animal[ntarget].owner_user != nowner &&
+	  (Animal[ntarget].moral >= ANIMAL_MORAL_PANIC ||
+	   Animal[ntarget].charmcount))
+	{
+	  return 1;
+	}
+      break;
+    default:
+      return 1;
+    }
+  return 0;
+}
+
+/* attack other animal */
+static void
+AttackOtherAnimal (int nanimal, int targetanimal)
+{
+  if (Animal[nanimal].pdata->eatmeat &&
+      (Animal[targetanimal].hp == 0 || Animal[targetanimal].moral == 0))
+    {
+      /* eat meat */
+      char work[MESG_BUFFER];
+      sprintf (work, "animal '%-.16s' eat ", CUTTAIL (Animal[nanimal].name));
+      strcat (work, CUTTAIL (Animal[targetanimal].name));
+      SendMessageNearUserPosition (Animal[nanimal].pos, work);
+      MAP (Animal[targetanimal].pos.x, Animal[targetanimal].pos.y)->id &=
+	~MAP_THERE_ANIMAL;
+      if (Animal[nanimal].hp + Animal[targetanimal].pdata->hp <
+	  Animal[nanimal].hp_org)
+	{
+	  Animal[nanimal].hp += Animal[targetanimal].pdata->hp;
+	}
+      else
+	{
+	  Animal[nanimal].hp = Animal[nanimal].hp_org;
+	}
+      DeleteAnimal (targetanimal);
+      return;
+    }
+  if (Animal[nanimal].reload == 0)
+    {
+      /* ok. ready to attack. */
+      unsigned nfirepower = Animal[nanimal].w_power;
+      unsigned ndamage = getrand (nfirepower >> 1, nfirepower);
+      cause_damage_animal (targetanimal, ndamage, 0);
+      if (Animal[targetanimal].hp == 0)
+	{
+	  Animal[targetanimal].moral = 0;
+	}
+      if (Animal[targetanimal].moral >= ANIMAL_MORAL_PANIC &&
+	  getrand (1, 100) <= ANIMAL_RATE_ANGRY)
+	{
+	  /* angry! */
+	  Animal[targetanimal].charmcount = AngryCount;
+	  Animal[targetanimal].ntarget = nanimal;
+	  Animal[targetanimal].charm = CharmAnimal;
+	}
+      else if (Animal[targetanimal].moral < ANIMAL_MORAL_PANIC)
+	{
+	  /* run away */
+	  Animal[targetanimal].charmcount = 0;
+	}
+
+      if (Animal[nanimal].moral < ANIMAL_MORAL_LIMIT)
+	{
+	  if (Animal[targetanimal].hp == 0)
+	    {
+	      Animal[nanimal].moral += ANIMAL_MORAL_WHENKILL;
+	    }
+	  else
+	    {
+	      Animal[nanimal].moral++;
+	    }
+	}
+      Animal[nanimal].reload = Animal[nanimal].pdata->w_rate;
+    }
+  return;
+}
+
+/* attack NPC hunter */
+static void
+AttackNpcHunter (int nanimal, int npc)
+{
+  if (Animal[nanimal].reload == 0)
+    {
+      /* ok. ready to attack. */
+      unsigned nfirepower = Animal[nanimal].w_power;
+      unsigned ndamage = getrand (nfirepower >> 1, nfirepower);
+      cause_damage_npc (npc, ndamage);
+      if (Npc[npc].hp)
+	{
+	  static const char *mesg[5] = {
+	    "%-.16s say,Nooo!",
+	    "%-.16s say,Animal bite me!",
+	    "%-.16s say,Danger! This animal is ferocity!",
+	    "%-.16s say,Help! Animal bite ...Arrrrgh!",
+	    "%-.16s say,Why is this animal angry?"
+	  };
+	  NPCsay (npc, mesg, 5);
+	}
+      if (Npc[npc].hp == 0)
+	{
+	  char work[MESG_BUFFER];
+	  sprintf (work, "'%-.16s' died.", CUTTAIL (Npc[npc].name));
+	  SendMessageNearUserPosition (Npc[npc].pos, work);
+	  Npc[npc].name[0] = '\0';
+	  MAP (Npc[npc].pos.x, Npc[npc].pos.y)->id &= ~MAP_THERE_NPC;
+	}
+      else
+	{
+	  if (Npc[npc].c_type == NpcHige || Npc[npc].c_type == NpcObserver)
+	    {
+	      Npc[npc].ntarget_user = nanimal;
+	      Npc[npc].t_type = TargetAnimal;
+	    }
+	}
+      if (Animal[nanimal].moral < ANIMAL_MORAL_LIMIT)
+	{
+	  if (Npc[npc].hp == 0)
+	    {
+	      Animal[nanimal].moral += ANIMAL_MORAL_WHENKILL;
+	    }
+	  else
+	    {
+	      Animal[nanimal].moral++;
+	    }
+	}
+      if (Animal[nanimal].moral > ANIMAL_MORAL_NORMAL && Npc[npc].hp)
+	{
+	  /* angry! */
+	  Animal[nanimal].charmcount = AngryCount;
+	  Animal[nanimal].charm = CharmNpc;
+	  Animal[nanimal].ntarget = npc;
+	}
+      Animal[nanimal].reload = Animal[nanimal].pdata->w_rate;
+    }
+  return;
+}
+
+/* attack hunter */
+static void
+AttackHunter (int nanimal, int nuser)
+{
+  if (Animal[nanimal].reload == 0)
+    {
+      /* ok. ready to attack. */
+      unsigned nfirepower = Animal[nanimal].w_power;
+      unsigned ndamage = getrand (nfirepower >> 1, nfirepower);
+      cause_damage (nuser, ndamage, nanimal, TargetAnimal);
+      if (Animal[nanimal].moral < ANIMAL_MORAL_LIMIT)
+	{
+	  if (User[nuser].hp == 0)
+	    {
+	      Animal[nanimal].moral += ANIMAL_MORAL_WHENKILL;
+	    }
+	  else
+	    {
+	      Animal[nanimal].moral++;
+	    }
+	}
+      if (Animal[nanimal].moral > ANIMAL_MORAL_NORMAL && User[nuser].hp)
+	{
+	  /* angry! */
+	  Animal[nanimal].charmcount = AngryCount;
+	  Animal[nanimal].charm = CharmUser;
+	  Animal[nanimal].ntarget = nuser;
+	}
+      Animal[nanimal].reload = Animal[nanimal].pdata->w_rate;
+    }
+  return;
+}
+
+/* animal escape */
+static void
+AnimalEscapeFromHunter (int nplayer, int *px, int *py)
+{
+  static const int ck_x[4] = { 0, 1, 0, -1 };
+  static const int ck_y[4] = { -1, 0, 1, 0 };
+  int i;
+  int n = 0;
+  int dx[4];
+  int dy[4];
+  for (i = 0; i < 4; i++)
+    {
+      int d = count_player_in (*px + ck_x[i], *py + ck_y[i]);
+      if (nplayer >= d)
+	{
+	  int wkx = *px + ck_x[i];
+	  int wky = *py + ck_y[i];
+	  adjust_pos (&wkx, &wky);
+	  if (MAP (wkx, wky)->player)
+	    {
+	      /* uhmm. player in destnation point. */
+	      continue;
+	    }
+	  if (MAP (wkx, wky)->id & MAP_NOT_MOVE)
+	    {
+	      /* uhmm. do not move */
+	      continue;
+	    }
+	  if (nplayer > d)
+	    {
+	      n = 0;
+	    }
+	  nplayer = d;
+	  dx[n] = ck_x[i];
+	  dy[n] = ck_y[i];
+	  n++;
+	}
+    }
+  if (n)
+    {
+      int m = 0;
+      if (n > 1)
+	{
+	  m = getrand (0, n - 1);
+	}
+      *px += dx[m];
+      *py += dy[m];
+    }
+  else
+    {
+      /* cannot escape. move random. */
+      random_move (px, py);
+    }
+  return;
+}
+
+/* Aggressive animal */
+static int
+AnimalAttackToAny (int nanimal, int x, int y)
+{
+  /* yeah. aggressive. */
+  int n = 0;
+  int n1 = 0;
+  int n2 = 0;
+  int ret = 0;
+  int i;
+  int target[4];
+  int npctarget[4];
+  int animaltarget[4];
+  int angry_animal = (Animal[nanimal].moral > ANIMAL_MORAL_NORMAL) ? 1 : 0;
+  static const int ck_x[4] = { 0, 1, 0, -1 };
+  static const int ck_y[4] = { -1, 0, 1, 0 };
+  for (i = 0; i < 4; i++)
+    {
+      int wkx = x + ck_x[i];
+      int wky = y + ck_y[i];
+      adjust_pos (&wkx, &wky);
+      if (MAP (wkx, wky)->player)
+	{
+	  int nuserno = MAP (wkx, wky)->player - 1;
+	  if (nuserno == Animal[nanimal].owner_user)
+	    {
+	      /* it is owner. do not attack. */
+	      continue;
+	    }
+	  else
+	    {
+	      if ((angry_animal || User[nuserno].c_type == Hunter) &&
+		  User[nuserno].cloak_count == 0 &&
+		  ((User[nuserno].maybearrest &&
+		    User[nuserno].status == Shopping) ||
+		   User[nuserno].status == Healthy))
+		{
+		  target[n++] = nuserno;
+		}
+	    }
+	}
+      if (MAP (wkx, wky)->id & MAP_THERE_NPC)
+	{
+	  int npc = MAP (wkx, wky)->animal;
+	  if (Npc[npc].owner_user != -1 &&
+	      Animal[nanimal].owner_user == Npc[npc].owner_user)
+	    {
+	      continue;
+	    }
+	  if (angry_animal || Npc[npc].c_type == NpcHunter)
+	    {
+	      npctarget[n1++] = npc;
+	    }
+	}
+      if (MAP (wkx, wky)->id & MAP_THERE_ANIMAL)
+	{
+	  int na = MAP (wkx, wky)->animal;
+	  if (Animal[nanimal].owner_user != Animal[na].owner_user)
+	    {
+	      if (Animal[nanimal].pdata->eatmeat == 0 &&
+		  (Animal[na].hp == 0 || Animal[na].moral == 0))
+		{
+		  /* not eat other animal */
+		  continue;
+		}
+	      animaltarget[n2++] = na;
+	    }
+	}
+    }
+  if (n)
+    {
+      /* attack hunter! */
+      int m = 0;
+      if (n > 1)
+	{
+	  m = getrand (0, n - 1);
+	}
+      AttackHunter (nanimal, target[m]);
+      ret = 1;
+    }
+  else if (n1)
+    {
+      /* attempt to attack NPC Hunter */
+      int m = 0;
+      if (n1 > 1)
+	{
+	  m = getrand (0, n1 - 1);
+	}
+      AttackNpcHunter (nanimal, npctarget[m]);
+      ret = 1;
+    }
+  else if (n2)
+    {
+      /* attempt to attack other animal */
+      int m = 0;
+      if (n2 > 1)
+	{
+	  m = getrand (0, n2 - 1);
+	}
+      AttackOtherAnimal (nanimal, animaltarget[m]);
+      ret = 1;
+    }
+  return ret;
+}
+
+/* Animal are charmed */
+static void
+AnimalCharmed (int nanimal, int *px, int *py)
+{
+  int relpos;
+  int ndir;
+  struct location pos;
+  int dx1;
+  int dx2;
+  int dy1;
+  int dy2;
+  int x;
+  int y;
+  int valid = 1;
+  switch (Animal[nanimal].charm)
+    {
+    case CharmPosition:
+      pos = Animal[nanimal].charm_pos;
+      break;
+    case CharmUser:
+      pos = User[Animal[nanimal].ntarget].pos;
+      if (User[Animal[nanimal].ntarget].session.handle == INVALID_SOCKET ||
+	  User[Animal[nanimal].ntarget].cloak_count ||
+	  User[Animal[nanimal].ntarget].status == Arrested)
+	{
+	  valid = 0;
+	}
+      break;
+    case CharmNpc:
+      pos = Npc[Animal[nanimal].ntarget].pos;
+      if (Npc[Animal[nanimal].ntarget].name[0] == '\0')
+	{
+	  valid = 0;
+	}
+      break;
+    case CharmAnimal:
+      pos = Animal[Animal[nanimal].ntarget].pos;
+      if (Animal[Animal[nanimal].ntarget].pdata == NULL ||
+	  Animal[Animal[nanimal].ntarget].hp == 0 ||
+	  Animal[Animal[nanimal].ntarget].moral == 0)
+	{
+	  valid = 0;
+	}
+      break;
+    default:
+      return;
+    }
+  calculate_delta_x (*px, pos.x, &dx1, &dx2);
+  calculate_delta_y (*py, pos.y, &dy1, &dy2);
+  if (Animal[nanimal].charm == CharmUser || Animal[nanimal].charm == CharmNpc)
+    {
+      if (!valid ||
+	  get_rel_distance_in (dx1, dx2, dy1, dy2) > Animal[nanimal].search)
+	{
+	  /* lost */
+	  Animal[nanimal].charm = CharmPosition;
+	  pos = Animal[nanimal].charm_pos;
+	  calculate_delta_x (*px, pos.x, &dx1, &dx2);
+	  calculate_delta_y (*py, pos.y, &dy1, &dy2);
+	}
+      Animal[nanimal].charm_pos = pos;
+    }
+  relpos = get_rel_position_in (dx1, dx2, dy1, dy2);
+  ndir = rel_dir (relpos);
+  if (relpos == 0)
+    {
+      /* eating now... */
+      AnimalAttackToAny (nanimal, *px, *py);
+    }
+  else
+    {
+      x = *px + FWVectorX[ndir];
+      y = *py + FWVectorY[ndir];
+      adjust_pos (&x, &y);
+      if (MAP (x, y)->player)
+	{
+	  if (User[MAP (x, y)->player - 1].status == Healthy &&
+	      MAP (x, y)->player - 1 != Animal[nanimal].owner_user)
+	    {
+	      AttackHunter (nanimal, MAP (x, y)->player - 1);
+	    }
+	}
+      else if (MAP (x, y)->id & MAP_THERE_NPC)
+	{
+	  int npc = MAP (x, y)->animal;
+	  if (Npc[npc].owner_user == -1 ||
+	      Animal[nanimal].owner_user != Npc[npc].owner_user)
+	    {
+	      AttackNpcHunter (nanimal, npc);
+	    }
+	}
+      else if (MAP (x, y)->id & MAP_THERE_ANIMAL)
+	{
+	  int na = MAP (x, y)->animal;
+	  if (Animal[nanimal].owner_user != Animal[na].owner_user)
+	    {
+	      AttackOtherAnimal (nanimal, na);
+	    }
+	}
+      else
+	{
+	  if (!(MAP (x, y)->id & MAP_NOT_MOVE))
+	    {
+	      *px = x;
+	      *py = y;
+	    }
+	}
+    }
+  return;
+}
+
+/* animal chase user */
+static void
+AnimalChaseUser (int nanimal, int nuser, int *px, int *py)
+{
+  struct location target_pos = User[nuser].pos;
+  int dx1;
+  int dx2;
+  int dy1;
+  int dy2;
+  int ndistance;
+  int ndir;
+  int cdir;
+  int x = Animal[nanimal].pos.x;
+  int y = Animal[nanimal].pos.y;
+  int fwd = 1;
+  target_pos.x -= FWVectorX[User[nuser].direction];
+  target_pos.y -= FWVectorY[User[nuser].direction];
+  adjust_pos (&target_pos.x, &target_pos.y);
+  calculate_delta_x (x, target_pos.x, &dx1, &dx2);
+  calculate_delta_y (y, target_pos.y, &dy1, &dy2);
+  ndistance = get_rel_distance_in (dx1, dx2, dy1, dy2);
+  ndir = get_rel_position_in (dx1, dx2, dy1, dy2);
+  cdir = rel_dir (ndir);
+  if (ndistance == 1)
+    {
+      x -= FWVectorX[cdir];
+      y -= FWVectorY[cdir];
+      fwd = 0;
+    }
+  else if (ndistance > 2)
+    {
+      x += FWVectorX[cdir];
+      y += FWVectorY[cdir];
+    }
+  adjust_pos (&x, &y);
+  if (MAP (x, y)->player || (MAP (x, y)->id & MAP_NOT_MOVE))
+    {
+      /* can't move! */
+      int dx[3];
+      int dy[3];
+      int dflag[3];
+      int i;
+      int dmax = 3;
+      dx[0] = RGVectorX[cdir];
+      dy[0] = RGVectorY[cdir];
+      dx[1] = -RGVectorX[cdir];
+      dy[1] = -RGVectorY[cdir];
+      if (fwd)
+	{
+	  dx[2] = -FWVectorX[cdir];
+	  dy[2] = -FWVectorY[cdir];
+	}
+      else
+	{
+	  dx[2] = FWVectorX[cdir];
+	  dy[2] = FWVectorY[cdir];
+	}
+      dflag[0] = dflag[1] = dflag[2] = 1;
+      for (i = getrand (0, dmax - 1); dflag[i] != 0; i = (i + 1) % dmax)
+	{
+	  x = Animal[nanimal].pos.x + dx[i];
+	  y = Animal[nanimal].pos.y + dy[i];
+	  adjust_pos (&x, &y);
+	  if (MAP (x, y)->player == 0 &&
+	      (MAP (x, y)->id & MAP_MASK) != MAP_ROCK &&
+	      !(MAP (x, y)->id & MAP_NOT_MOVE))
+	    {
+	      break;
+	    }
+	  dflag[i] = 0;
+	}
+    }
+  *px = x;
+  *py = y;
+  return;
+}
+
+/* move Animal phase */
+static void
+MovementAnimalPhase (void)
+{
+  static int animal_heal_count = 0;
+  int i;
+  for (i = 0; i < AnimalLimit; i++)
+    {
+      if (Animal[i].pdata != NULL && Animal[i].hp && Animal[i].moral)
+	{
+	  if (Animal[i].ntime == 0)
+	    {
+	      /* action & move */
+	      int x = Animal[i].pos.x;
+	      int y = Animal[i].pos.y;
+	      Animal[i].ntime = Animal[i].speed;
+	      if (Animal[i].charmcount)
+		{
+		  /* charm... */
+		  AnimalCharmed (i, &x, &y);
+		}
+	      else if (Animal[i].owner_user != -1 &&
+		       User[Animal[i].owner_user].session.handle !=
+		       INVALID_SOCKET)
+		{
+		  if (Animal[i].moral < ANIMAL_MORAL_PANIC ||
+		      !AnimalAttackToAny (i, x, y))
+		    {
+		      /* check attacker for owner */
+		      int nowner = Animal[i].owner_user;
+		      if (User[nowner].lastuser != -1 &&
+			  check_attacker (nowner,
+					  User[nowner].lastuser,
+					  User[nowner].lastuser_type))
+			{
+			  /* owner is under attack! */
+			  Animal[i].charmcount = 300;
+			  switch (User[nowner].lastuser_type)
+			    {
+			    case TargetUser:
+			      Animal[i].charm = CharmUser;
+			      break;
+			    case TargetNpc:
+			      Animal[i].charm = CharmNpc;
+			      break;
+			    case TargetAnimal:
+			      Animal[i].charm = CharmAnimal;
+			      break;
+			    default:
+			      /* ?? */
+			      fprintf (stderr,
+				       "Illegal target-type in User:%d.\n",
+				       nowner);
+			      break;
+			    }
+			  Animal[i].ntarget = User[nowner].lastuser;
+			}
+		      else
+			{
+			  /* chase owner */
+			  AnimalChaseUser (i, Animal[i].owner_user, &x, &y);
+			}
+		    }
+		}
+	      else
+		{
+		  if (Animal[i].moral < ANIMAL_MORAL_PANIC)
+		    {
+		      int nplayer;
+		      nplayer = count_player_in (x, y);
+		      if (nplayer)
+			{
+			  /* find player.  */
+			  AnimalEscapeFromHunter (nplayer, &x, &y);
+			}
+		      else
+			{
+			  random_move (&x, &y);
+			}
+		    }
+		  else
+		    {
+		      if (!AnimalAttackToAny (i, x, y))
+			{
+			  /* no target. move random */
+			  random_move (&x, &y);
+			}
+		    }
+		}
+	      if (Animal[i].hold_count == 0)
+		{
+		  /* Animal move */
+		  adjust_pos (&x, &y);
+		  MAP (Animal[i].pos.x, Animal[i].pos.y)->id &=
+		    ~MAP_THERE_ANIMAL;
+		  MAP (Animal[i].pos.x, Animal[i].pos.y)->animal = -1;
+		  MAP (x, y)->id |= MAP_THERE_ANIMAL;
+		  MAP (x, y)->animal = i;
+		  Animal[i].pos.x = x;
+		  Animal[i].pos.y = y;
+		  if (MAP (x, y)->id & MAP_THERE_HOLE)
+		    {
+		      /* animal fall into hole */
+		      char work[MESG_BUFFER];
+		      MAP (x, y)->id &= ~MAP_THERE_HOLE;
+		      Animal[i].hold_count = HoldCount;
+		      sprintf (work,
+			       "[You hear sound '%-.16s' fall in hole]",
+			       CUTTAIL (Animal[i].name));
+		      SendMessageNearUserAnimal (i, work);
+		    }
+		}
+	    }
+	  else
+	    {
+	      Animal[i].ntime--;
+	    }
+	  if (Animal[i].reload > 0)
+	    {
+	      Animal[i].reload--;
+	    }
+	  if (Animal[i].charmcount)
+	    {
+	      Animal[i].charmcount--;
+	    }
+	  if (Animal[i].hold_count)
+	    {
+	      Animal[i].hold_count--;
+	    }
+	  if (animal_heal_count == 0)
+	    {
+#ifdef USE_STRONGANIMAL
+	      if (Animal[i].hp < Animal[i].hp_org)
+		{
+		  Animal[i].hp += 2;
+		}
+	      else
+		{
+		  Animal[i].hp = Animal[i].hp_org;
+		}
+#else /* USE_STRONGANIMAL */
+	      if (Animal[i].hp < Animal[i].pdata->hp)
+		{
+		  Animal[i].hp += 2;
+		}
+	      else
+		{
+		  Animal[i].hp = Animal[i].pdata->hp;
+		}
+#endif /* USE_STRONGANIMAL */
+	    }
+	}
+      else if (Animal[i].pdata != NULL)
+	{
+	  /* die or stun */
+	  if (Animal[i].recover_count)
+	    {
+	      Animal[i].recover_count--;
+	    }
+	  else
+	    {
+	      /* recover ! and power-up! */
+#ifdef USE_STRONGANIMAL
+	      if (Animal[i].hp_org + Animal[i].pdata->hp < ANIMAL_HP_LIMIT)
+		{
+		  Animal[i].hp_org += Animal[i].pdata->hp;
+		}
+	      else
+		{
+		  Animal[i].hp_org = ANIMAL_HP_LIMIT;
+		}
+	      if (Animal[i].moral_org + Animal[i].pdata->moral <
+		  ANIMAL_MORAL_LIMIT)
+		{
+		  Animal[i].moral_org += Animal[i].pdata->moral;
+		}
+	      else
+		{
+		  Animal[i].moral_org = ANIMAL_MORAL_LIMIT;
+		}
+	      if (Animal[i].w_power_org + Animal[i].pdata->w_power <
+		  ANIMAL_FIRE_LIMIT)
+		{
+		  Animal[i].w_power_org += Animal[i].pdata->w_power;
+		}
+	      else
+		{
+		  Animal[i].w_power_org = ANIMAL_FIRE_LIMIT;
+		}
+	      Animal[i].hp = Animal[i].hp_org;
+	      Animal[i].moral = Animal[i].moral_org;
+	      Animal[i].w_power = Animal[i].w_power_org;
+#else /* USE_STRONGANIMAL */
+	      Animal[i].hp = Animal[i].pdata->hp * 2;
+	      Animal[i].moral = Animal[i].pdata->moral * 2;
+	      Animal[i].w_power = Animal[i].pdata->w_power * 2;
+#endif /* USE_STRONGANIMAL */
+	      Animal[i].speed = Animal[i].pdata->speed / 2;
+	      Animal[i].reload = 0;
+	      Animal[i].charmcount = 0;
+	      Animal[i].ntime = 0;
+	      Animal[i].hold_count = 0;
+	      Animal[i].recover_count = ANIMAL_RECOVER_COUNT;
+	      Animal[i].owner_user = -1;
+	      memcpy (Animal[i].name, Animal[i].pdata->name, USERNAME_LEN);
+	    }
+	}
+    }
+  if (animal_heal_count == 0)
+    {
+      animal_heal_count = TurnPerAnimalHeal;
+    }
+  else
+    {
+      animal_heal_count--;
+    }
+  return;
+}
+
+/* spawn animal */
+static void
+SpawnNewAnimal (void)
+{
+  int i;
+  int totalanimal = 0;
+  for (i = 0; i < AnimalLimit; i++)
+    {
+      if (Animal[i].pdata != NULL)
+	{
+	  totalanimal++;
+	}
+    }
+  if (totalanimal < AnimalInitLimit)
+    {
+      for (i = totalanimal; i < AnimalInitLimit; i++)
+	{
+	  ANIMALDATA *pdata = GetAnimalType ();
+	  if (pdata != NULL)
+	    {
+	      NewAnimal (pdata);
+	    }
+	}
+    }
+  else
+    {
+      ANIMALDATA *pdata = GetAnimalType ();
+      if (pdata != NULL)
+	{
+	  NewAnimal (pdata);
+	}
+    }
+  return;
+}
+
+/* spawn new tree */
+static void
+SpawnNewTree (void)
+{
+  int x;
+  int y;
+  do
+    {
+      x = getrand (0, MapWidth - 1);
+      y = getrand (0, MapHeight - 1);
+    }
+  while ((MAP (x, y)->id & MAP_MASK) == MAP_ROCK ||
+	 (MAP (x, y)->id & MAP_THERE_WALL) ||
+	 (MAP (x, y)->id & MAP_THERE_SHOP));
+  INVALID_MAP (x, y);
+  MAP (x, y)->id |= MAP_TREE;
+  return;
+}
+
+/* make new npc */
+static void
+NewNPC (void)
+{
+  int i;
+  for (i = 0; i < NpcLimitForSystem; i++)
+    {
+      if (Npc[i].name[0] == '\0')
+	{
+	  int x;
+	  int y;
+	  if (getrand (1, 100) <= NpcRateHunter)
+	    {
+	      /* spawn hunter */
+	      Npc[i].c_type = NpcHunter;
+	      memcpy (Npc[i].name,
+		      NpcHunters[getrand (0, NpcHuntersN - 1)], USERNAME_LEN);
+	    }
+	  else
+	    {
+	      /* spawn observer */
+	      Npc[i].c_type = NpcObserver;
+	      memcpy (Npc[i].name,
+		      NpcGuards[getrand (0, NpcGuardsN - 1)], USERNAME_LEN);
+	    }
+	  do
+	    {
+	      x = getrand (0, MapWidth - 1);
+	      y = getrand (0, MapHeight - 1);
+	    }
+	  while ((MAP (x, y)->id & MAP_MASK) == MAP_ROCK ||
+		 (MAP (x, y)->id & MAP_NOT_MOVE) || MAP (x, y)->player);
+	  MAP (x, y)->id |= MAP_THERE_NPC;
+	  MAP (x, y)->animal = i;
+	  Npc[i].pos.x = x;
+	  Npc[i].pos.y = y;
+	  Npc[i].direction = getrand (0, 3);
+	  if (getrand (1, 100) < NpcRateAverageSpeed)
+	    {
+	      Npc[i].speed = NpcAverageSpeed;
+	    }
+	  else
+	    {
+	      Npc[i].speed =
+		getrand (NpcSpeedMin, NpcSpeedMax) * NpcSpeedBase;
+	    }
+	  Npc[i].search = getrand (NpcSearchMin, NpcSearchMax);
+	  Npc[i].attack = getrand (NpcAttackMin, NpcAttackMax);
+	  Npc[i].speed_count = 0;
+	  Npc[i].ntarget_user = -1;
+	  Npc[i].hp = getrand (NpcHpMin, NpcHpMax);
+	  Npc[i].weapon = get_npc_weapon (Npc[i].c_type);
+	  Npc[i].bullette = Weapon[Npc[i].weapon].bullette;
+	  Npc[i].nochangelock_count = 0;
+	  Npc[i].hold_count = 0;
+	  Npc[i].reload = 0;
+	  Npc[i].number = 0;
+	  Npc[i].owner_user = -1;
+	  Npc[i].moral_limit = 0;
+	  break;
+	}
+    }
+  return;
+}
+
+/* spawn new npc */
+static void
+SpawnNewNPC (void)
+{
+  int i;
+  int totalnpc = 0;
+  for (i = 0; i < NpcLimitForSystem; i++)
+    {
+      if (Npc[i].name[0] == '\0')
+	{
+	  totalnpc++;
+	}
+    }
+  if (totalnpc < NpcInitLimit)
+    {
+      for (i = totalnpc; i < NpcInitLimit; i++)
+	{
+	  NewNPC ();
+	}
+    }
+  else
+    {
+      NewNPC ();
+    }
+  return;
+}
+
+/* nearest animal */
+static int
+NPCsearchNearAnimal (int npc, int ndistance)
+{
+  int i;
+  int nmin = ndistance;
+  int nanimal = -1;
+  for (i = 0; i < AnimalLimit; i++)
+    {
+      if (Animal[i].pdata != NULL)
+	{
+	  if (Animal[i].owner_user != -1 &&
+	      Animal[i].owner_user == Npc[npc].owner_user)
+	    {
+	      continue;
+	    }
+	  else
+	    {
+	      int n = get_rel_distance (Npc[npc].pos.x, Npc[npc].pos.y,
+					Animal[i].pos.x, Animal[i].pos.y);
+	      if (n <= nmin)
+		{
+		  nmin = n;
+		  nanimal = i;
+		}
+	    }
+	}
+    }
+  return nanimal;
+}
+
+/* nearest pc or npc */
+static void
+NPCsearchNearCharacter (int npc, enum usertype_t c_type, int ndistance,
+			int *nplayer, enum target_type *t_type)
+{
+  int i;
+  int nmin = ndistance;
+  enum npctype_t npct;
+  switch (c_type)
+    {
+    case Hunter:
+      npct = NpcHunter;
+      break;
+    case Observer:
+      npct = NpcObserver;
+      break;
+    default:			/* huh? */
+      npct = NpcHige;
+      break;
+    }
+  *nplayer = -1;
+  for (i = 0; i < UserLimit; i++)
+    {
+      if (User[i].session.handle != INVALID_SOCKET && User[i].hp &&
+	  User[i].cloak_count == 0 && User[i].c_type == c_type &&
+	  User[i].status != Arrested)
+	{
+	  int n = get_rel_distance (Npc[npc].pos.x, Npc[npc].pos.y,
+				    User[i].pos.x, User[i].pos.y);
+	  if (n <= nmin)
+	    {
+	      nmin = n;
+	      *nplayer = i;
+	      *t_type = TargetUser;
+	    }
+	}
+
+    }
+  for (i = 0; i < NpcLimit; i++)
+    {
+      if (Npc[i].name[0] != '\0' && Npc[i].hp && Npc[i].c_type == npct)
+	{
+	  int n = get_rel_distance (Npc[npc].pos.x, Npc[npc].pos.y,
+				    Npc[i].pos.x, Npc[i].pos.y);
+	  if (n <= nmin)
+	    {
+	      nmin = n;
+	      *nplayer = i;
+	      *t_type = TargetNpc;
+	    }
+	}
+    }
+  return;
+}
+
+/* fire at current direction */
+static int
+NPCfire (int npc, int ndir)
+{
+  int ret = -1;
+  if (ndir == REL_DIRECTION_N || ndir == REL_DIRECTION_E ||
+      ndir == REL_DIRECTION_W || ndir == REL_DIRECTION_S)
+    {
+      /* ok. line of sight */
+      if (Npc[npc].reload == 0)
+	{
+	  /* fire ! */
+	  struct bullet_t *pbullet;
+	  ret = 0;
+	  pbullet =
+	    NewBullet (Npc[npc].weapon, Npc[npc].pos, Npc[npc].direction);
+	  pbullet->nuser = npc;
+	  pbullet->t_type = TargetNpc;
+	  Npc[npc].reload = Weapon[Npc[npc].weapon].rate;
+	  if (Npc[npc].weapon)
+	    {
+	      Npc[npc].bullette--;
+	      if (Npc[npc].bullette == 0)
+		{
+		  Npc[npc].weapon = 0;
+		  Npc[npc].bullette = 0;
+		}
+	    }
+	}
+    }
+  return ret;
+}
+
+/* Guard fire at will */
+static int
+NPCfireatwill (int npc, int ntarget_user, int ndir, int ndistance)
+{
+  int ret = -1;
+  if (User[ntarget_user].maybearrest >= CrimeMurder ||
+      (User[ntarget_user].score > 10000 && User[ntarget_user].maybearrest) ||
+      (Npc[npc].nochangelock_count && User[ntarget_user].status == Healthy))
+    {
+      /* fire at will */
+      if (ndistance <= Weapon[Npc[npc].weapon].range)
+	{
+	  ret = NPCfire (npc, ndir);
+	  if (ret == 0)
+	    {
+	      static const char *mesg[5] = {
+		"%-.16s say,FREEZE!",
+		"%-.16s say,FIRE!",
+		"%-.16s say,Hey! I know your position!",
+		"%-.16s say,You can't escape from me!",
+		"%-.16s say,Contact!"
+	      };
+	      NPCsay (npc, mesg, 5);
+	    }
+	}
+    }
+  else
+    {
+      if (ndistance < VIEW_LIMIT)
+	{
+	  if (User[ntarget_user].maybearrest)
+	    {
+	      static const char *mesg[5] = {
+		"%-.16s say,Do not move!",
+		"%-.16s say,You are criminal!",
+		"%-.16s say,Hold up!",
+		"%-.16s say,Do not escape! If you do so,I will shoot you!",
+		"%-.16s say,You should surrender!"
+	      };
+	      NPCsay (npc, mesg, 5);
+	    }
+	  else if (User[ntarget_user].status == Shopping &&
+		   User[ntarget_user].crime_level)
+	    {
+	      static const char *mesg2[5] = {
+		"%-.16s say,Go out!",
+		"%-.16s say,You can't escape!",
+		"%-.16s say,You no have choise!",
+		"%-.16s say,Do anyone call SWAT? We need!",
+		"%-.16s say,We have surrounded you!"
+	      };
+	      NPCsay (npc, mesg2, 5);
+	    }
+	}
+    }
+  return ret;
+}
+
+/* NPC move */
+static void
+NPCmove (int n, int x, int y, int fwd)
+{
+  adjust_pos (&x, &y);
+  if (MAP (x, y)->player || (MAP (x, y)->id & MAP_MASK) == MAP_ROCK ||
+      (MAP (x, y)->id & MAP_NOT_MOVE))
+    {
+      /* can't move! */
+      int dx[3];
+      int dy[3];
+      int dflag[3];
+      int i;
+      int dmax = 3;
+      dx[0] = RGVectorX[Npc[n].direction];
+      dy[0] = RGVectorY[Npc[n].direction];
+      dx[1] = -RGVectorX[Npc[n].direction];
+      dy[1] = -RGVectorY[Npc[n].direction];
+      if (fwd)
+	{
+	  dx[2] = -FWVectorX[Npc[n].direction];
+	  dy[2] = -FWVectorY[Npc[n].direction];
+	}
+      else
+	{
+	  dx[2] = FWVectorX[Npc[n].direction];
+	  dy[2] = FWVectorY[Npc[n].direction];
+	}
+      dflag[0] = dflag[1] = dflag[2] = 1;
+      for (i = getrand (0, dmax - 1); dflag[i] != 0; i = (i + 1) % dmax)
+	{
+	  x = Npc[n].pos.x + dx[i];
+	  y = Npc[n].pos.y + dy[i];
+	  adjust_pos (&x, &y);
+	  if (MAP (x, y)->player == 0 &&
+	      (MAP (x, y)->id & MAP_MASK) != MAP_ROCK &&
+	      !(MAP (x, y)->id & MAP_NOT_MOVE))
+	    {
+	      break;
+	    }
+	  dflag[i] = 0;
+	}
+    }
+  if (MAP (x, y)->player == 0 && (MAP (x, y)->id & MAP_MASK) != MAP_ROCK &&
+      !(MAP (x, y)->id & MAP_NOT_MOVE))
+    {
+      MAP (Npc[n].pos.x, Npc[n].pos.y)->id &= ~MAP_THERE_NPC;
+      MAP (Npc[n].pos.x, Npc[n].pos.y)->animal = -1;
+      MAP (x, y)->id |= MAP_THERE_NPC;
+      MAP (x, y)->animal = n;
+      Npc[n].pos.x = x;
+      Npc[n].pos.y = y;
+      if (MAP (x, y)->id & MAP_THERE_HOLE)
+	{
+	  /* pit hole! */
+	  char work[MESG_BUFFER];
+	  MAP (x, y)->id &= ~MAP_THERE_HOLE;
+	  Npc[n].hold_count = HoldCount;
+	  sprintf (work, "[You hear sound %-.16s fall in hole!]",
+		   Npc[n].name);
+	  SendMessageNearUserPosition (Npc[n].pos, work);
+	}
+    }
+  return;
+}
+
+/* think hunter */
+static void
+ThinkNpcHunter (int n)
+{
+  int x = Npc[n].pos.x;
+  int y = Npc[n].pos.y;
+  int nplayer;
+  x = Npc[n].pos.x;
+  y = Npc[n].pos.y;
+  nplayer = count_specific_player_in (x, y, Observer);
+  if (Npc[n].weapon == 0 && nplayer)
+    {
+      if (getrand (1, 100) < HUNTER_SPEAK_RATE)
+	{
+	  static const char *mesg[3] = {
+	    "%-.16s say,Oh! I am innoucence!",
+	    "%-.16s say,Leave alone!",
+	    "%-.16s say,HELP ME! HELP! HELP!"
+	  };
+	  NPCsay (n, mesg, 3);
+	}
+      AnimalEscapeFromHunter (nplayer, &x, &y);
+      Npc[n].direction = getrand (0, 3);
+      Npc[n].ntarget_user = -1;
+    }
+  else
+    {
+      struct location target_pos;
+      int valid = 0;
+      int ntarget = Npc[n].ntarget_user;
+      enum target_type t_type = Npc[n].t_type;
+      if (ntarget == -1)
+	{
+	  ntarget = NPCsearchNearAnimal (n, Npc[n].search);
+	  t_type = TargetAnimal;
+	}
+      if (ntarget != -1)
+	{
+	  if (t_type == TargetUser)
+	    {
+	      target_pos = User[ntarget].pos;
+	      if (User[ntarget].session.handle != INVALID_SOCKET &&
+		  User[ntarget].status != Arrested &&
+		  User[ntarget].cloak_count == 0)
+		{
+		  valid = 1;
+		}
+	    }
+	  else if (t_type == TargetNpc)
+	    {
+	      target_pos = Npc[ntarget].pos;
+	      if (Npc[ntarget].name[0] != '\0')
+		{
+		  valid = 1;
+		}
+	    }
+	  else
+	    {
+	      target_pos = Animal[ntarget].pos;
+	      if (Animal[ntarget].pdata != NULL)
+		{
+		  valid = 1;
+		}
+	    }
+	}
+      if (!valid)
+	{
+	  if (getrand (1, 100) < HUNTER_SPEAK_RATE)
+	    {
+	      static const char *mesg[5] = {
+		"%-.16s say,Anyone see animal?",
+		"%-.16s say,Oh sorry.",
+		"%-.16s say,Nice meet you!",
+		"%-.16s say,Hello. Is there anyone?",
+		"%-.16s say,I want any food. Anyone have?"
+	      };
+	      NPCsay (n, mesg, 5);
+	    }
+	  random_move (&x, &y);
+	  Npc[n].direction = getrand (0, 3);
+	  Npc[n].ntarget_user = -1;
+	}
+      else
+	{
+	  int dx1;
+	  int dx2;
+	  int dy1;
+	  int dy2;
+	  int ndistance;
+	  int ndir;
+	  Npc[n].ntarget_user = ntarget;
+	  Npc[n].t_type = t_type;
+	  calculate_delta_x (Npc[n].pos.x, target_pos.x, &dx1, &dx2);
+	  calculate_delta_y (Npc[n].pos.y, target_pos.y, &dy1, &dy2);
+	  ndistance = get_rel_distance_in (dx1, dx2, dy1, dy2);
+	  ndir = get_rel_position_in (dx1, dx2, dy1, dy2);
+	  Npc[n].direction = rel_dir (ndir);
+	  if (ndistance == 1)
+	    {
+	      if (t_type == TargetAnimal &&
+		  Animal[ntarget].moral < ANIMAL_MORAL_PANIC)
+		{
+		  /* get */
+		  char work[MESG_BUFFER];
+		  sprintf (work, "%-.16s say,Get!", CUTTAIL (Npc[n].name));
+		  SendMessageNearUserPosition (Npc[n].pos, work);
+		  MAP (Animal[ntarget].pos.x, Animal[ntarget].pos.y)->id &=
+		    ~MAP_THERE_ANIMAL;
+		  DeleteAnimal (ntarget);
+		  Npc[n].ntarget_user = -1;
+		  return;
+		}
+	      else
+		{
+		  if (NPCfire (n, ndir) == 0)
+		    {
+		      if (getrand (1, 100) < HUNTER_SPEAK_RATE)
+			{
+			  static const char *mesg_a[3] = {
+			    "%-.16s say,Fire! Fire!",
+			    "%-.16s say,Oh! This animal is strong!",
+			    "%-.16s say,Hey! Cover me!"
+			  };
+			  static const char *mesg_n[3] = {
+			    "%-.16s say,Fire! Fire! Fire!",
+			    "%-.16s say,We are under attack!",
+			    "%-.16s say,Anyone! Help me!"
+			  };
+			  NPCsay (n,
+				  (t_type == TargetAnimal) ? mesg_a : mesg_n,
+				  3);
+			}
+		    }
+		}
+	    }
+	  else if (ndistance <= Npc[n].attack &&
+		   ((t_type == TargetAnimal &&
+		     Animal[ntarget].moral >= ANIMAL_MORAL_PANIC) ||
+		    t_type != TargetAnimal))
+	    {
+	      if (NPCfire (n, ndir) == 0)
+		{
+		  return;
+		}
+	    }
+	  else if (ndistance > Npc[n].search)
+	    {
+	      /* out of range */
+	      static const char *mesg_a[3] = {
+		"%-.16s say,OH NO! I miss animal!",
+		"%-.16s say,Hey! Don't you get my animal?",
+		"%-.16s say,I think animal enter hyper-space."
+	      };
+	      static const char *mesg_n[3] = {
+		"%-.16s say,hehe! bye bye!",
+		"%-.16s say,Enemy escape from me.",
+		"%-.16s say,Where?"
+	      };
+	      NPCsay (n, (t_type == TargetAnimal) ? mesg_a : mesg_n, 3);
+	      Npc[n].ntarget_user = -1;
+	      return;
+	    }
+	  if (t_type != TargetAnimal && ndistance == 1 && Npc[n].weapon)
+	    {
+	      switch (getrand (0, 2))
+		{
+		case 0:
+		  /* sway back */
+		  x -= FWVectorX[Npc[n].direction];
+		  y -= FWVectorY[Npc[n].direction];
+		  break;
+		case 1:
+		  /* left */
+		  x -= RGVectorX[Npc[n].direction];
+		  y -= RGVectorY[Npc[n].direction];
+		  break;
+		case 2:
+		  /* right */
+		  x += RGVectorX[Npc[n].direction];
+		  y += RGVectorY[Npc[n].direction];
+		  break;
+		}
+	    }
+	  else
+	    {
+	      x += FWVectorX[Npc[n].direction];
+	      y += FWVectorY[Npc[n].direction];
+	    }
+	}
+    }
+  NPCmove (n, x, y, 1);
+  return;
+}
+
+/* think observer */
+static void
+ThinkNpcObserver (int n)
+{
+  int x = Npc[n].pos.x;
+  int y = Npc[n].pos.y;
+  int fwd = 1;
+  int ntarget;
+  enum target_type t_type;
+  if (Npc[n].ntarget_user == -1)
+    {
+      Npc[n].nochangelock_count = 0;
+    }
+  if (Npc[n].nochangelock_count)
+    {
+      ntarget = -1;
+    }
+  else
+    {
+      NPCsearchNearCharacter (n, Hunter, Npc[n].search, &ntarget, &t_type);
+    }
+  if (ntarget == -1)
+    {
+      ntarget = Npc[n].ntarget_user;
+      t_type = Npc[n].t_type;
+    }
+  if (ntarget == -1)
+    {
+      /* no target */
+      if (getrand (1, 100) < OBSERVER_SPEAK_RATE)
+	{
+	  static const char *mesg[5] = {
+	    "%-.16s say,*anyone see bad hunter?*",
+	    "%-.16s say,*uhmm. where is he?*",
+	    "%-.16s say,*are you bad hunter?*",
+	    "%-.16s say,*I want to rest here...*",
+	    "%-.16s say,*Zzzzz*"
+	  };
+	  NPCsay (n, mesg, 5);
+	}
+      random_move (&x, &y);
+      Npc[n].direction = getrand (0, 3);
+    }
+  else
+    {
+      /* target lock */
+      struct location target_pos;
+      int valid = 0;
+      int escape = 0;
+      Npc[n].ntarget_user = ntarget;
+      Npc[n].t_type = t_type;
+      if (t_type == TargetUser)
+	{
+	  target_pos = User[ntarget].pos;
+	  if (User[ntarget].session.handle != INVALID_SOCKET &&
+	      User[ntarget].status != Arrested &&
+	      User[ntarget].cloak_count == 0)
+	    {
+	      valid = 1;
+	    }
+	}
+      else if (t_type == TargetNpc)
+	{
+	  target_pos = Npc[ntarget].pos;
+	  if (Npc[ntarget].name[0] != '\0')
+	    {
+	      valid = 1;
+	    }
+	}
+      else
+	{
+	  target_pos = Animal[ntarget].pos;
+	  if (Animal[ntarget].pdata != NULL &&
+	      Animal[ntarget].hp && Animal[ntarget].moral)
+	    {
+	      valid = 1;
+	      if (Animal[ntarget].moral < ANIMAL_MORAL_PANIC)
+		{
+		  escape = 1;
+		}
+	    }
+	}
+      if (valid)
+	{
+	  int dx1;
+	  int dx2;
+	  int dy1;
+	  int dy2;
+	  int ndistance;
+	  int ndir;
+	  calculate_delta_x (Npc[n].pos.x, target_pos.x, &dx1, &dx2);
+	  calculate_delta_y (Npc[n].pos.y, target_pos.y, &dy1, &dy2);
+	  ndistance = get_rel_distance_in (dx1, dx2, dy1, dy2);
+	  ndir = get_rel_position_in (dx1, dx2, dy1, dy2);
+	  Npc[n].direction = rel_dir (ndir);
+	  if (ndistance == 1)
+	    {
+	      static const char *g_mesg[3] = {
+		"%-.16s say,Hey! You do crime!",
+		"%-.16s say,Arrest you!",
+		"%-.16s say,Hold up!"
+	      };
+	      if (t_type == TargetUser)
+		{
+		  if (User[ntarget].maybearrest ||
+		      User[ntarget].crime_level > 1)
+		    {
+		      /* arrest */
+		      char work[MESG_BUFFER];
+		      NPCsay (n, g_mesg, 3);
+		      sprintf (work, "[You were arrested by %-.16s!]",
+			       CUTTAIL (Npc[n].name));
+		      SendSystemMessagePacket (ntarget, work);
+		      ClearUser (ntarget);
+		      switch (User[ntarget].crime_level)
+			{
+			case 1:
+			  add_crime (ntarget, ArrestPass);
+			  break;
+			case 2:
+			  add_crime (ntarget, ArrestAnyone);
+			  break;
+			}
+		      User[ntarget].crime_level = 0;
+		      User[ntarget].status = Arrested;
+		      add_arrest (ntarget);
+		      User[ntarget].action = NoAction;
+		      User[ntarget].move = NoMove;
+		      User[ntarget].pos.x = JailPositionX;
+		      User[ntarget].pos.y = JailPositionY;
+		      clear_animal_slot (ntarget);
+		      Npc[n].ntarget_user = -1;
+		      return;
+		    }
+		  else
+		    {
+		      if (NPCfireatwill (n, ntarget, ndir, ndistance) == 0)
+			{
+			  return;
+			}
+		    }
+		}
+	      else if (t_type == TargetNpc &&
+		       Npc[ntarget].c_type == NpcHunter)
+		{
+		  /* arrest NPC */
+		  static const char *h_mesg[3] = {
+		    "%-.16s say,Oh NO! PLEASE HELP ME!",
+		    "%-.16s say,ARGGGH!",
+		    "%-.16s say,Yeah I understand your claim. But..."
+		  };
+		  NPCsay (n, g_mesg, 3);
+		  NPCsay (ntarget, h_mesg, 3);
+		  Npc[ntarget].name[0] = '\0';
+		  MAP (target_pos.x, target_pos.y)->id &= ~MAP_THERE_NPC;
+		  Npc[n].ntarget_user = -1;
+		  return;
+		}
+	      /* can't arrest this */
+	    }
+	  else if (!escape && ndistance <= Npc[n].attack && Npc[n].weapon)
+	    {
+	      if (t_type == TargetUser)
+		{
+		  /* fire at User */
+		  if (NPCfireatwill (n, ntarget, ndir, ndistance) == 0)
+		    {
+		      return;
+		    }
+		}
+	      else
+		{
+		  /* fire at NPC */
+		  if (ndistance <= Weapon[Npc[n].weapon].range &&
+		      NPCfire (n, ndir) == 0)
+		    {
+		      static const char *mesg[3] = {
+			"%-.16s say,Hey! Stop!",
+			"%-.16s say,You are BAD HUNTER!",
+			"%-.16s say,Shoot!"
+		      };
+		      NPCsay (n, mesg, 3);
+		      return;
+		    }
+		}
+	    }
+	  else if (ndistance > Npc[n].search)
+	    {
+	      /* out of range */
+	      static const char *mesg[3] = {
+		"%-.16s say,Shit!",
+		"%-.16s say,I miss bad hunter.",
+		"%-.16s say,Oh no! My radar device is malfunction!"
+	      };
+	      NPCsay (n, mesg, 3);
+	      Npc[n].ntarget_user = -1;
+	      return;
+	    }
+	  if (t_type == TargetNpc || User[ntarget].maybearrest ||
+	      User[ntarget].crime_level || Npc[n].nochangelock_count)
+	    {
+	      if (!escape && ndistance > 1)
+		{
+		  x += FWVectorX[Npc[n].direction];
+		  y += FWVectorY[Npc[n].direction];
+		}
+	      else if (escape || (t_type == TargetUser &&
+				  User[ntarget].status != Healthy))
+		{
+		  x -= FWVectorX[Npc[n].direction];
+		  y -= FWVectorY[Npc[n].direction];
+		  fwd = 0;
+		}
+	    }
+	  else
+	    {
+	      if (!escape && ndistance > 2)
+		{
+		  x += FWVectorX[Npc[n].direction];
+		  y += FWVectorY[Npc[n].direction];
+		}
+	      else
+		{
+		  x -= FWVectorX[Npc[n].direction];
+		  y -= FWVectorY[Npc[n].direction];
+		  fwd = 0;
+		}
+	    }
+	}
+      else
+	{
+	  /* lost target lock */
+	  Npc[n].ntarget_user = -1;
+	  return;
+	}
+    }
+  NPCmove (n, x, y, fwd);
+  return;
+}
+
+/* think hireable npc */
+static void
+ThinkNpcHige (int n)
+{
+  int x = Npc[n].pos.x;
+  int y = Npc[n].pos.y;
+  int fwd = 1;
+  int ntarget;
+  enum target_type t_type;
+  ntarget = Npc[n].ntarget_user;
+  t_type = Npc[n].t_type;
+  if (ntarget == -1)
+    {
+      /* no target */
+      int nuser = Npc[n].owner_user;
+      if (User[nuser].session.handle != INVALID_SOCKET)
+	{
+	  struct location target_pos = User[nuser].pos;
+	  int dx1;
+	  int dx2;
+	  int dy1;
+	  int dy2;
+	  int ndistance;
+	  int ndir;
+	  target_pos.x -= FWVectorX[User[nuser].direction];
+	  target_pos.y -= FWVectorY[User[nuser].direction];
+	  adjust_pos (&target_pos.x, &target_pos.y);
+	  calculate_delta_x (Npc[n].pos.x, target_pos.x, &dx1, &dx2);
+	  calculate_delta_y (Npc[n].pos.y, target_pos.y, &dy1, &dy2);
+	  ndistance = get_rel_distance_in (dx1, dx2, dy1, dy2);
+	  ndir = get_rel_position_in (dx1, dx2, dy1, dy2);
+	  Npc[n].direction = rel_dir (ndir);
+	  if (ndistance == 1)
+	    {
+	      if (getrand (1, 100) < HIRENPC_SPEAK_RATE)
+		{
+		  static const char *mesg[5] = {
+		    "%-.16s say,sorry.",
+		    "%-.16s say,I cover your back.",
+		    "%-.16s say,Anyone see enemy?",
+		    "%-.16s say,no boggy.",
+		    "%-.16s say,I no see enemy."
+		  };
+		  NPCsay (n, mesg, 5);
+		}
+	      x -= FWVectorX[Npc[n].direction];
+	      y -= FWVectorY[Npc[n].direction];
+	      fwd = 0;
+	    }
+	  else if (ndistance > 2)
+	    {
+	      if (getrand (1, 100) < HIRENPC_SPEAK_RATE)
+		{
+		  static const char *mesg[5] = {
+		    "%-.16s say,on the way.",
+		    "%-.16s say,search trap now...",
+		    "%-.16s say,Don't go away from me!",
+		    "%-.16s say,no enemy in sight.",
+		    "%-.16s say,I no see any on my radar."
+		  };
+		  NPCsay (n, mesg, 5);
+		}
+	      x += FWVectorX[Npc[n].direction];
+	      y += FWVectorY[Npc[n].direction];
+	    }
+	  /* attempt to search */
+	  ntarget = NPCsearchNearAnimal (n, 2);
+	  if (ntarget == -1 || Animal[ntarget].moral < Npc[n].moral_limit)
+	    {
+	      enum usertype_t c_type;
+	      if (User[Npc[n].owner_user].c_type == Hunter)
+		{
+		  c_type = Observer;
+		}
+	      else
+		{
+		  c_type = Hunter;
+		}
+	      NPCsearchNearCharacter (n, c_type, 2, &ntarget, &t_type);
+	      if (ntarget != -1)
+		{
+		  /* boggy! */
+		  static const char *mesg[3] = {
+		    "%-.16s say,Engage enemy!",
+		    "%-.16s say,Hey! Do not enter!",
+		    "%-.16s say,Formation alpha! move to attack position!"
+		  };
+		  NPCsay (n, mesg, 3);
+		  Npc[n].ntarget_user = ntarget;
+		  Npc[n].t_type = t_type;
+		}
+	      else
+		{
+		  if (User[nuser].lastuser != -1 &&
+		      check_attacker (nuser, User[nuser].lastuser,
+				      User[nuser].lastuser_type))
+		    {
+		      /* owner is under attack! */
+		      static const char *mesg[3] = {
+			"%-.16s say,Alert! HQ is under attack!",
+			"%-.16s say,Condition RED! All guard HQ!",
+			"%-.16s say,Formation sigma! move to support position!"
+		      };
+		      NPCsay (n, mesg, 3);
+		      Npc[n].ntarget_user = User[nuser].lastuser;
+		      Npc[n].t_type = User[nuser].lastuser_type;
+		    }
+		}
+	    }
+	  else
+	    {
+	      /* animal aproach */
+	      static const char *mesg[3] = {
+		"%-.16s say,I find dangerous animal!",
+		"%-.16s say,Animal aproach!",
+		"%-.16s say,Formation delta! move to attack position!"
+	      };
+	      NPCsay (n, mesg, 3);
+	      Npc[n].ntarget_user = ntarget;
+	      Npc[n].t_type = TargetAnimal;
+	    }
+	}
+      else
+	{
+	  return;
+	}
+    }
+  else
+    {
+      /* target lock */
+      struct location target_pos;
+      int valid = 0;
+      if (t_type == TargetUser)
+	{
+	  target_pos = User[ntarget].pos;
+	  if (User[ntarget].session.handle != INVALID_SOCKET &&
+	      User[ntarget].status != Arrested &&
+	      User[ntarget].cloak_count == 0)
+	    {
+	      valid = 1;
+	    }
+	}
+      else if (t_type == TargetNpc)
+	{
+	  target_pos = Npc[ntarget].pos;
+	  if (Npc[ntarget].name[0] != '\0')
+	    {
+	      valid = 1;
+	    }
+	}
+      else
+	{
+	  target_pos = Animal[ntarget].pos;
+	  if (Animal[ntarget].pdata != NULL && Animal[ntarget].hp &&
+	      (Animal[ntarget].moral >= Npc[n].moral_limit ||
+	       Animal[ntarget].charmcount))
+	    {
+	      valid = 1;
+	    }
+	}
+      if (valid)
+	{
+	  int dx1;
+	  int dx2;
+	  int dy1;
+	  int dy2;
+	  int ndistance;
+	  int ndir;
+	  calculate_delta_x (Npc[n].pos.x, target_pos.x, &dx1, &dx2);
+	  calculate_delta_y (Npc[n].pos.y, target_pos.y, &dy1, &dy2);
+	  ndistance = get_rel_distance_in (dx1, dx2, dy1, dy2);
+	  ndir = get_rel_position_in (dx1, dx2, dy1, dy2);
+	  Npc[n].direction = rel_dir (ndir);
+	  if (ndistance == 1 && Npc[n].weapon)
+	    {
+	      static const char *mesg[3] = {
+		"%-.16s say,I wanna need your support!",
+		"%-.16s say,Shit! This enemy is too near!",
+		"%-.16s say,HAHAHA!"
+	      };
+	      NPCsay (n, mesg, 3);
+	    }
+	  else if (ndistance <= Npc[n].attack && Npc[n].weapon)
+	    {
+	      if (ndistance < VIEW_LIMIT && Npc[n].reload == 0)
+		{
+		  static const char *mesg[3] = {
+		    "%-.16s say,I attack this enemy.",
+		    "%-.16s say,We are under fire!",
+		    "%-.16s say,Cover me!"
+		  };
+		  NPCsay (n, mesg, 3);
+		}
+	    }
+	  else if (ndistance > Npc[n].search)
+	    {
+	      /* out of range */
+	      static const char *mesg[3] = {
+		"%-.16s say,I lost target-lock.",
+		"%-.16s say,no see anyone.",
+		"%-.16s say,ok. clear."
+	      };
+	      NPCsay (n, mesg, 3);
+	      Npc[n].ntarget_user = -1;
+	      return;
+	    }
+	  if (ndistance > 2 || Weapon[Npc[n].weapon].range < 2)
+	    {
+	      x += FWVectorX[Npc[n].direction];
+	      y += FWVectorY[Npc[n].direction];
+	    }
+	  else if (ndistance == 2 &&
+		   ndir != REL_DIRECTION_N && ndir != REL_DIRECTION_E &&
+		   ndir != REL_DIRECTION_W && ndir != REL_DIRECTION_S)
+	    {
+	      /* uhmm. no line of sight */
+	      x += FWVectorX[Npc[n].direction];
+	      y += FWVectorY[Npc[n].direction];
+	    }
+	  else
+	    {
+	      x -= FWVectorX[Npc[n].direction];
+	      y -= FWVectorY[Npc[n].direction];
+	      fwd = 0;
+	    }
+	  if (ndistance <= Weapon[Npc[n].weapon].range)
+	    {
+	      if (NPCfire (n, ndir) == 0)
+		{
+		  return;
+		}
+	    }
+	}
+      else
+	{
+	  /* lost target lock */
+	  Npc[n].ntarget_user = -1;
+	  return;
+	}
+    }
+  NPCmove (n, x, y, fwd);
+  return;
+}
+
+/* npc turn */
+static void
+MovementNpcPhase (void)
+{
+  int i;
+  for (i = 0; i < NpcLimit; i++)
+    {
+      if (Npc[i].name[0] != '\0')
+	{
+	  if (Npc[i].speed_count == 0)
+	    {
+	      Npc[i].speed_count = Npc[i].speed;
+	      if (Npc[i].hold_count == 0)
+		{
+		  switch (Npc[i].c_type)
+		    {
+		    case NpcHunter:
+		      ThinkNpcHunter (i);
+		      break;
+		    case NpcObserver:
+		      ThinkNpcObserver (i);
+		      break;
+		    case NpcHige:
+		      ThinkNpcHige (i);
+		      break;
+		    default:
+		      break;
+		    }
+		}
+	    }
+	  else
+	    {
+	      Npc[i].speed_count--;
+	    }
+	  if (Npc[i].nochangelock_count > 0)
+	    {
+	      Npc[i].nochangelock_count--;
+	    }
+	  if (Npc[i].hold_count > 0)
+	    {
+	      Npc[i].hold_count--;
+	    }
+	  if (Npc[i].reload > 0)
+	    {
+	      Npc[i].reload--;
+	    }
+	}
+    }
+  return;
+}
+
+/* save user data */
+static void
+task_save_userdata (void)
+{
+  /* save user data */
+  char work[BUFFER_SIZE];
+  sprintf (work, "%s/%s", DATA_DIR, USER_DATA_FILE);
+  puts ("save user data...");
+  if (SaveUser (work))
+    {
+      fputs ("Warnning:can't save user data\n", stderr);
+    }
+#ifdef USE_MAIL
+  else
+    {
+      if (SaveAllMail ())
+	{
+	  fputs ("Warnning:can't save mail data\n", stderr);
+	}
+#ifdef USE_BBS
+      else
+	{
+	  if (SaveBBS ())
+	    {
+	      fputs ("Warnning:can't save bbs data\n", stderr);
+	    }
+	}
+#endif /* USE_BBS */
+    }
+#endif /* USE_MAIL */
+#ifdef USE_SAVEMAP
+  sprintf (work, "%s/%s", DATA_DIR, SYSMAP_DATA_FILE);
+  puts ("save map data...");
+  if (SaveMapData (work))
+    {
+      fputs ("Warnning:can't save map and shop data\n", stderr);
+    }
+#endif /* USE_SAVEMAP */
+  puts ("done.");
+  return;
+}
+
+/* main task */
+static void
+Task (void)
+{
+#ifdef USE_AUTOSAVE
+  static unsigned long savecount = 0;
+#endif
+  static int tickcount = 0;
+  static int spawn_timer = 0;
+  static unsigned long tree_timer = 0;
+  static int npc_timer = 0;
+  MovementUserPhase ();
+  MovementAnimalPhase ();
+  MovementNpcPhase ();
+  ResolveUserPhase ();
+  MovementBulletPhase ();
+  ResolveBulletPhase ();
+  if (spawn_timer == 0)
+    {
+      spawn_timer = TurnPerSpawnAnimal;
+      SpawnNewAnimal ();
+    }
+  else
+    {
+      spawn_timer--;
+    }
+  if (tree_timer == 0)
+    {
+      tree_timer = TurnPerSpawnTree;
+      SpawnNewTree ();
+    }
+  else
+    {
+      tree_timer--;
+    }
+  if (npc_timer == 0)
+    {
+      npc_timer = TurnPerSpawnNpc;
+      SpawnNewNPC ();
+    }
+  else
+    {
+      npc_timer--;
+    }
+  TurnEndPhase (tickcount);
+  if (tickcount == 0)
+    {
+      tickcount = TurnPerSend;
+    }
+  else
+    {
+      tickcount--;
+    }
+#ifdef USE_AUTOSAVE
+  if (savecount == TurnPerSave)
+    {
+      savecount = 0;
+      task_save_userdata ();
+    }
+  else
+    {
+      savecount++;
+    }
+#endif /* USE_AUTOSAVE */
+  return;
+}
+
+/* copy string (terminator = LF)*/
+static void
+copy_string_nolf (char *pout, const char *pin, int buffer_size)
+{
+  int i;
+  for (i = 0; i < buffer_size; i++)
+    {
+      char c = *pin++;
+      if (c == '\n' || c == '\r' || c == '\0')
+	{
+	  break;
+	}
+      *pout++ = c;
+    }
+  for (; i < buffer_size; i++)
+    {
+      *pout++ = ' ';
+    }
+  return;
+}
+
+/* load setup data */
+static int
+LoadSetup (const char *pfilename, int reload)
+{
+  int ret = -1;
+  FILE *iptr = fopen (pfilename, "r");
+  if (iptr != NULL)
+    {
+      char lbuf[BUFFER_SIZE];
+      char namebuf[BUFFER_SIZE];
+      unsigned long nbuf;
+      while (fgets (lbuf, sizeof (lbuf), iptr) != NULL)
+	{
+	  if (lbuf[0] == '#')
+	    {
+	      continue;
+	    }
+	  if (lbuf[0] == '!')
+	    {
+	      /* define password for create user */
+	      /* !PASSWORD */
+	      copy_string_nolf (makeUserKey, lbuf + 1, PASSWORD_LEN);
+	      continue;
+	    }
+	  if (lbuf[0] == '*')
+	    {
+	      /* define password for administrator */
+	      /* *PASSWORD */
+	      copy_string_nolf (rootPassword, lbuf + 1, PASSWORD_LEN);
+	      continue;
+	    }
+	  if (sscanf (lbuf, "%[^,],%lu", namebuf, &nbuf) != 2)
+	    {
+	      continue;
+	    }
+	  if (!reload)
+	    {
+	      if (!strcmp (namebuf, "MAP_WIDTH"))
+		{
+		  if (nbuf >= 10 && nbuf <= 1000)
+		    {
+		      MapWidth = nbuf;
+		    }
+		}
+	      else if (!strcmp (namebuf, "MAP_HEIGHT"))
+		{
+		  if (nbuf >= 10 && nbuf <= 1000)
+		    {
+		      MapHeight = nbuf;
+		    }
+		}
+	      else if (!strcmp (namebuf, "JAIL_X"))
+		{
+		  JailPositionX = nbuf;
+		}
+	      else if (!strcmp (namebuf, "JAIL_Y"))
+		{
+		  JailPositionY = nbuf;
+		}
+	      else if (!strcmp (namebuf, "TREASURE_LIMIT"))
+		{
+		  TreasureLimit = nbuf;
+		}
+	      else if (!strcmp (namebuf, "SHOP_LIMIT"))
+		{
+		  ShopLimit = nbuf;
+		}
+	      else if (!strcmp (namebuf, "USER_LIMIT"))
+		{
+		  UserLimit = nbuf;
+		}
+	      else if (!strcmp (namebuf, "ANIMAL_LIMIT"))
+		{
+		  AnimalLimit = nbuf;
+		}
+	      else if (!strcmp (namebuf, "NPC_LIMIT"))
+		{
+		  NpcLimit = nbuf;
+		}
+	      else if (!strcmp (namebuf, "NPC_LIMIT_FORSYSTEM"))
+		{
+		  NpcLimitForSystem = nbuf;
+		}
+#ifdef USE_AUTOSAVE
+	      else if (!strcmp (namebuf, "AUTOSAVE_COUNT"))
+		{
+		  TurnPerSave = nbuf;
+		}
+#endif /* USE_AUTOSAVE */
+	    }
+	  if (!strcmp (namebuf, "USER_SPEED"))
+	    {
+	      UserSpeed = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "MAX_TIMEOUT"))
+	    {
+	      if (nbuf > 0)
+		{
+		  MaxTimeoutValue = nbuf;
+		}
+	    }
+	  else if (!strcmp (namebuf, "TREE_HP"))
+	    {
+	      if (nbuf > 0)
+		{
+		  TreeHP = nbuf;
+		}
+	    }
+	  else if (!strcmp (namebuf, "RATE_ROAD"))
+	    {
+	      if (nbuf > 0 && nbuf <= 100)
+		{
+		  RateRoad = nbuf;
+		}
+	    }
+	  else if (!strcmp (namebuf, "RATE_BOX_IN_ITEM"))
+	    {
+	      if (nbuf > 0 && nbuf <= 100)
+		{
+		  RateBoxInItem = nbuf;
+		}
+	    }
+	  else if (!strcmp (namebuf, "HP_LIMIT"))
+	    {
+	      HpLimit = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "HP_BASE"))
+	    {
+	      HpBase = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "HUNGRY_LIMIT"))
+	    {
+	      HungryLimit = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "HUNGRY_BASE"))
+	    {
+	      HungryBase = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "HUNGRY_COUNT"))
+	    {
+	      TurnPerHungry = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "HUNGRY_DAMAGE"))
+	    {
+	      DamageWhenHungry = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "SPAWN_ANIMAL"))
+	    {
+	      TurnPerSpawnAnimal = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "SPAWN_TREE"))
+	    {
+	      TurnPerSpawnTree = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "MURDER_POINT"))
+	    {
+	      CrimeMurder = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "NPCMURDER_POINT"))
+	    {
+	      CrimeNpcMurder = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "ARRESTPASS_POINT"))
+	    {
+	      ArrestPass = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "ARRESTANYONE_POINT"))
+	    {
+	      ArrestAnyone = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "SPAWN_NPC"))
+	    {
+	      TurnPerSpawnNpc = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "DIG_COUNT"))
+	    {
+	      DigCount = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "HOLD_COUNT"))
+	    {
+	      HoldCount = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "CHARM_COUNT"))
+	    {
+	      CharmCount = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "ANGRY_COUNT"))
+	    {
+	      AngryCount = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "SEND_COUNT"))
+	    {
+	      TurnPerSend = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "ANIMAL_INIT_LIMIT"))
+	    {
+	      AnimalInitLimit = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "NPC_INIT_LIMIT"))
+	    {
+	      NpcInitLimit = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "NPC_RATE_HUNTER"))
+	    {
+	      NpcRateHunter = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "NPC_RATE_AVERAGESPEED"))
+	    {
+	      NpcRateAverageSpeed = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "NPC_AVERAGESPEED"))
+	    {
+	      NpcAverageSpeed = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "NPC_SPEEDBASE"))
+	    {
+	      NpcSpeedBase = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "NPC_SPEEDMIN"))
+	    {
+	      NpcSpeedMin = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "NPC_SPEEDMAX"))
+	    {
+	      NpcSpeedMax = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "NPC_HPMIN"))
+	    {
+	      NpcHpMin = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "NPC_HPMAX"))
+	    {
+	      NpcHpMax = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "NPC_SEARCHMIN"))
+	    {
+	      NpcSearchMin = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "NPC_SEARCHMAX"))
+	    {
+	      NpcSearchMax = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "NPC_ATTACKMIN"))
+	    {
+	      NpcAttackMin = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "NPC_ATTACKMAX"))
+	    {
+	      NpcAttackMax = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "DEC_ARREST_COUNT"))
+	    {
+	      TurnPerDecArrest = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "DEC_ARREST"))
+	    {
+	      DecArrest = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "DEC_JAIL_COUNT"))
+	    {
+	      TurnPerJailCount = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "ANIMAL_HEAL_COUNT"))
+	    {
+	      TurnPerAnimalHeal = nbuf;
+	    }
+	  else if (!strcmp (namebuf, "HIREABLE_NPC_TYPE"))
+	    {
+	      HireableNpcType = nbuf;
+	    }
+	}
+      fclose (iptr);
+    }
+  return ret;
+}
+
+/* make weapon & item list */
+static void
+MakeDataList (void)
+{
+  int i;
+
+  ForHunterWeapon = malloc (sizeof (int) * WeaponLimit);
+  ForObserverWeapon = malloc (sizeof (int) * WeaponLimit);
+  ForHunterItem = malloc (sizeof (int) * ItemLimit);
+  ForObserverItem = malloc (sizeof (int) * ItemLimit);
+  if (ForHunterWeapon == NULL || ForObserverWeapon == NULL ||
+      ForHunterItem == NULL || ForObserverItem == NULL)
+    {
+      perror ("malloc");
+      fputs ("EVAC:not enought to data-list memory\n", stderr);
+      exit (1);
+    }
+  ForHunterWeaponLimit = 0;
+  ForObserverWeaponLimit = 0;
+  for (i = 1; i < WeaponLimit; i++)
+    {
+      if (Weapon[i].forhunter == 1)
+	{
+	  ForHunterWeapon[ForHunterWeaponLimit++] = i;
+	}
+      else if (Weapon[i].forhunter == 0)
+	{
+	  ForObserverWeapon[ForObserverWeaponLimit++] = i;
+	}
+    }
+  NpcHunterWeaponTable = malloc (sizeof (int) * ForHunterWeaponLimit);
+  NpcObserverWeaponTable = malloc (sizeof (int) * ForObserverWeaponLimit);
+  if (NpcHunterWeaponTable == NULL || NpcObserverWeaponTable == NULL)
+    {
+      perror ("malloc");
+      fputs ("EVAC:not enought to npc-weapon memory\n", stderr);
+      exit (1);
+    }
+  else
+    {
+      int total;
+      for (total = i = 0; i < ForHunterWeaponLimit; i++)
+	{
+	  total += Weapon[ForHunterWeapon[i]].npc_rate;
+	  NpcHunterWeaponTable[i] = total;
+	}
+      NpcHunterWeaponTotal = total;
+      for (total = i = 0; i < ForObserverWeaponLimit; i++)
+	{
+	  total += Weapon[ForObserverWeapon[i]].npc_rate;
+	  NpcObserverWeaponTable[i] = total;
+	}
+      NpcObserverWeaponTotal = total;
+    }
+  ForHunterItemLimit = 0;
+  ForObserverItemLimit = 0;
+  for (i = 1; i < ItemLimit; i++)
+    {
+      if (Item[i].forhunter == 1)
+	{
+	  ForHunterItem[ForHunterItemLimit++] = i;
+	}
+      else if (Item[i].forhunter == 0)
+	{
+	  ForObserverItem[ForObserverItemLimit++] = i;
+	}
+    }
+  return;
+}
+
+#ifdef HAVE_SIGALRM
+/* setup interval timer */
+static void
+SetupTimer (void)
+{
+  struct itimerval itime;
+  struct itimerval otime;
+
+  itime.it_interval.tv_sec = 0;
+  itime.it_interval.tv_usec = SERVERPOLL_MSEC * 1000L;
+  itime.it_value.tv_sec = 1;
+  itime.it_value.tv_usec = 0;
+  if (setitimer (ITIMER_REAL, &itime, &otime))
+    {
+      perror ("setitimer");
+      fputs ("EVAC:setitimer fail\n", stderr);
+    }
+  return;
+}
+#endif /* HAVE_SIGALRM */
+
+/* shutdown server */
+static void
+shutdown_server (void)
+{
+  puts ("System shutdown...");
+  task_save_userdata ();
+#ifdef MAKEWIN32
+  if (hThread != NULL)
+    {
+      if (hEnd != NULL)
+	{
+	  SetEvent (hEnd);
+	}
+      WaitForSingleObject (hThread, 10000);
+    }
+#ifdef USE_W32THREAD
+  kill_all_send_message_queue_thread ();
+#endif
+#endif /* MAKEWIN32 */
+  puts ("complete.");
+  return;
+}
+
+#ifdef MAKEWIN32
+/* thread for process data */
+static void
+timer_thread (void *pparam)
+{
+  DWORD nwait = SERVERPOLL_MSEC;
+  while (WaitForSingleObject (hEnd, nwait) == WAIT_TIMEOUT)
+    {
+      DWORD nstart = GetTickCount ();
+      DWORD nend;
+      DWORD nspan;
+      Task ();
+      nend = GetTickCount ();
+      if (nstart > nend)
+	{
+	  nspan = 0xffffffffL - nstart;
+	  nspan += nend;
+	}
+      else
+	{
+	  nspan = nend - nstart;
+	}
+      if (nspan > SERVERPOLL_MSEC)
+	{
+	  /* time over. need no wait. */
+	  nwait = 0;
+	}
+      else
+	{
+	  nwait = SERVERPOLL_MSEC - nspan;
+	}
+    }
+  ENDTHREAD ();
+}
+
+/* console event handler */
+static BOOL WINAPI
+Win32ConsoleCtrlHandler (DWORD dwCtrlType)
+{
+  switch (dwCtrlType)
+    {
+    case CTRL_C_EVENT:
+    case CTRL_BREAK_EVENT:
+    case CTRL_CLOSE_EVENT:
+    case CTRL_SHUTDOWN_EVENT:
+      shutdown_server ();
+      cleanup_socket_interface ();
+      exit (1);
+    case CTRL_LOGOFF_EVENT:
+      return TRUE;
+    }
+  return FALSE;
+}
+
+/* make thread for process data */
+static void
+SetupWin32 (void)
+{
+  SetConsoleCtrlHandler (Win32ConsoleCtrlHandler, TRUE);
+  hEnd = CreateEvent (NULL, FALSE, FALSE, NULL);
+  if (hEnd == NULL)
+    {
+      fputs ("EVAC:can't make event!\n", stderr);
+      exit (255);
+    }
+  hThread = (HANDLE) MAKETHREAD (timer_thread, NULL);
+  if (hThread == NULL)
+    {
+      fputs ("EVAC:can't make thread!\n", stderr);
+      exit (255);
+    }
+  return;
+}
+#endif /* MAKEWIN32 */
+
+/* receive loop */
+static void
+receive_loop (void)
+{
+  while (NowRunning)
+    {
+      fd_set rfds;
+      struct timeval tmout;
+      tmout.tv_sec = 1;
+      tmout.tv_usec = 0;
+      rfds = mainFDS;
+      if (select (FD_SETSIZE, &rfds, NULL, NULL, &tmout) >= 1)
+	{
+	  if (FD_ISSET (mainSocket, &rfds))
+	    {
+	      CheckNewConnection ();
+	      continue;
+	    }
+	  HandleUser (&rfds);
+	}
+#ifdef USE_FORK
+      waitpid (0, NULL, WNOHANG);	/* for sweep zombie */
+#endif
+    }
+  puts ("end.");
+
+  cutsocket (mainSocket);
+  return;
+}
+
+
+#ifndef MAKEWIN32
+/* signal handler */
+static void
+sighandler (int nsig)
+{
+  static int shut = 0;
+#ifdef SIGHUP
+  char work[BUFFER_SIZE];
+#endif
+  switch (nsig)
+    {
+#ifdef SIGHUP
+    case SIGHUP:
+      sprintf (work, "%s/%s", DATA_DIR, INIT_DATA_FILE);
+      puts ("Reload configuration file...");
+      LoadSetup (work, 1);
+      break;
+#endif
+    case SIGINT:
+    case SIGTERM:
+      if (!shut)
+	{
+	  shut = 1;
+	  shutdown_server ();
+#ifdef USE_FORK
+	  kill (-getpid (), nsig);
+#endif
+	  cleanup_socket_interface ();
+	}
+      exit (1);
+#ifdef SIGPIPE
+    case SIGPIPE:
+      fputs ("catch SIGPIPE\n", stderr);
+      break;
+#endif
+#ifdef SIGCHLD
+    case SIGCHLD:
+#ifdef DEBUG
+      fputs ("catch SIGCHLD\n", stderr);
+#endif
+      break;
+#endif
+#ifdef HAVE_SIGALRM
+    case SIGALRM:
+      Task ();
+      break;
+#endif
+    default:
+      fprintf (stderr, "catch %d\n", nsig);
+      break;
+    }
+  return;
+}
+#endif /* MAKEWIN32 */
+
+
+/* initialize data */
+static void
+init (void)
+{
+  char work[BUFFER_SIZE];
+
+  srand ((unsigned) time (NULL));
+  puts ("Loading datas...");
+  sprintf (work, "%s/%s", DATA_DIR, INIT_DATA_FILE);
+  LoadSetup (work, 0);
+  User = calloc (sizeof (USERINFO), UserLimit);
+  Animal = calloc (sizeof (ANIMALINFO), AnimalLimit);
+  Npc = calloc (sizeof (NPCINFO), NpcLimit);
+  if (User == NULL || Animal == NULL || Npc == NULL)
+    {
+      perror ("malloc");
+      fputs ("EVAC:not enought to system-data memory\n", stderr);
+      exit (1);
+    }
+  InitializeUser ();
+  sprintf (work, "%s/%s", DATA_DIR, WEAPON_DATA_FILE);
+  LoadWeapon (work);
+  sprintf (work, "%s/%s", DATA_DIR, ITEM_DATA_FILE);
+  LoadItem (work);
+  sprintf (work, "%s/%s", DATA_DIR, ANIMAL_DATA_FILE);
+  LoadAnimal (work);
+  sprintf (work, "%s/%s", DATA_DIR, USER_DATA_FILE);
+  LoadUser (work);
+#ifdef USE_MAIL
+  puts ("Loading mail data...");
+  LoadAllMail ();
+#ifdef USE_BBS
+  puts ("Loading bbs data...");
+  LoadBBS ();
+#endif /* USE_BBS */
+#endif /* USE_MAIL */
+  puts ("Initialize world data...");
+  InitializeMap ();
+  InitializeAnimalType ();
+  MakeDataList ();
+  SpawnNewAnimal ();
+  SpawnNewNPC ();
+  return;
+}
+
+/********/
+/* main */
+
+int
+main (int argc, char *argv[])
+{
+#ifndef MAKEWIN32
+#ifdef HAVE_SIGACTION
+  struct sigaction sa;
+#endif
+#endif
+  int nport = DEFAULT_PORT;
+  if (argc > 1)
+    {
+      if (strcmp (argv[1], "-"))
+	{
+	  nport = atoi (argv[1]);
+	}
+    }
+  setbuf (stdout, NULL);
+  setbuf (stdin, NULL);
+  puts ("Hunter-Online server\n" "Copyright by T.Fukui 2001-2016 (C)");
+  printf ("port:%d\n", nport);
+  puts (ServerInfo);
+  init_socket_interface ();
+#ifndef MAKEWIN32
+#ifdef HAVE_SIGACTION
+  sa.sa_handler = sighandler;
+  sa.sa_flags = 0;
+  sigemptyset (&sa.sa_mask);
+  sigaction (SIGINT, &sa, NULL);
+#ifdef SIGHUP
+  sigaction (SIGHUP, &sa, NULL);
+#endif
+  sigaction (SIGTERM, &sa, NULL);
+#ifdef SIGPIPE
+  sigaction (SIGPIPE, &sa, NULL);
+#endif
+#ifdef SIGCHLD
+  sigaction (SIGCHLD, &sa, NULL);
+#endif
+#ifdef HAVE_SIGALRM
+  sigaction (SIGALRM, &sa, NULL);
+#endif
+  sigaction (SIGUSR1, &sa, NULL);
+#else /* HAVE_SIGACTION */
+  signal (SIGINT, sighandler);
+#ifdef SIGHUP
+  signal (SIGHUP, sighandler);
+#endif
+  signal (SIGTERM, sighandler);
+#ifdef SIGPIPE
+  signal (SIGPIPE, sighandler);
+#endif
+#ifdef SIGCHLD
+  signal (SIGCHLD, sighandler);
+#endif
+#ifdef HAVE_SIGALRM
+  signal (SIGALRM, sighandler);
+#endif
+  signal (SIGUSR1, sighandler);
+#endif /* HAVE_SIGACTION */
+#endif /* MAKEWIN32 */
+
+  init ();			/* initialize and load data */
+  mainSocket = makesocket (nport, INADDR_ANY, SOCK_STREAM);
+  if (mainSocket != INVALID_SOCKET)
+    {
+      NowRunning = 1;
+      if (!listen (mainSocket, 5))
+	{
+	  FD_ZERO (&mainFDS);
+	  FD_SET (mainSocket, &mainFDS);
+	  puts ("start task..");
+#ifdef HAVE_SIGALRM
+	  SetupTimer ();
+#endif
+#ifdef MAKEWIN32
+	  SetupWin32 ();
+#endif
+	  receive_loop ();
+	}
+      else
+	{
+	  perror ("listen");
+	}
+    }
+  task_save_userdata ();
+#ifdef USE_W32THREAD
+  kill_all_send_message_queue_thread ();
+#endif
+#ifdef USE_FORK
+  kill (-getpid (), SIGUSR1);
+#endif
+  cleanup_socket_interface ();
+  return (mainSocket == INVALID_SOCKET) ? -1 : 0;
+}
+
+/* EOF */