-/* File: util.c */
+/* File: util.c */
/*
* Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke
* are included in all such copies. Other copyrights may also apply.
*/
-/* Purpose: Angband utilities -BEN- */
+ /* Purpose: Angband utilities -BEN- */
#include "angband.h"
+#include "core.h"
+#include "term.h"
+#include "util.h"
+#include "files.h"
+#include "monsterrace-hook.h"
+#include "view-mainwindow.h"
+#include "quest.h"
+#include "floor.h"
+#include "world.h"
+#include "cmd-dump.h"
+#include "japanese.h"
+#include "player-class.h"
+
+/*!
+ * 10進数から16進数への変換テーブル /
+ * Global array for converting numbers to uppercase hecidecimal digit
+ * This array can also be used to convert a number to an octal digit
+ */
+const char hexsym[16] =
+{
+ '0', '1', '2', '3', '4', '5', '6', '7',
+ '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
+};
+
+/*
+ * Keymaps for each "mode" associated with each keypress.
+ */
+concptr keymap_act[KEYMAP_MODES][256];
+
+/*
+ * The next "free" index to use
+ */
+u32b message__next;
+
+/*
+ * The index of the oldest message (none yet)
+ */
+u32b message__last;
+
+/*
+ * The next "free" offset
+ */
+u32b message__head;
+
+/*
+ * The offset to the oldest used char (none yet)
+ */
+u32b message__tail;
+
+/*
+ * The array of offsets, by index [MESSAGE_MAX]
+ */
+u32b *message__ptr;
+
+/*
+ * The array of chars, by offset [MESSAGE_BUF]
+ */
+char *message__buf;
+
+bool msg_flag; /* Used in msg_print() for "buffering" */
+
+/*
+ * Number of active macros.
+ */
+s16b macro__num;
+
+/*
+ * Array of macro patterns [MACRO_MAX]
+ */
+concptr *macro__pat;
+
+/*
+ * Array of macro actions [MACRO_MAX]
+ */
+concptr *macro__act;
+
+/*
+ * Array of macro types [MACRO_MAX]
+ */
+bool *macro__cmd;
+
+/*
+ * Current macro action [1024]
+ */
+char *macro__buf;
+bool get_com_no_macros = FALSE; /* Expand macros in "get_com" or not */
+
+bool inkey_base; /* See the "inkey()" function */
+bool inkey_xtra; /* See the "inkey()" function */
+bool inkey_scan; /* See the "inkey()" function */
+bool inkey_flag; /* See the "inkey()" function */
+
+bool use_menu;
+
+pos_list tmp_pos;
+
+/*
+ * The number of quarks
+ */
+STR_OFFSET quark__num;
+
+/*
+ * The pointers to the quarks [QUARK_MAX]
+ */
+concptr *quark__str;
static int num_more = 0;
/* Save macro trigger string for use in inkey_special() */
static char inkey_macro_trigger_string[1024];
-#if 0
-#ifndef HAS_STRICMP
+int max_macrotrigger = 0; /*!< 現在登録中のマクロ(トリガー)の数 */
+concptr macro_template = NULL; /*!< Angband設定ファイルのT: タグ情報から読み込んだ長いTコードを処理するために利用する文字列ポインタ */
+concptr macro_modifier_chr; /*!< &x# で指定されるマクロトリガーに関する情報を記録する文字列ポインタ */
+concptr macro_modifier_name[MAX_MACRO_MOD]; /*!< マクロ上で取り扱う特殊キーを文字列上で表現するためのフォーマットを記録した文字列ポインタ配列 */
+concptr macro_trigger_name[MAX_MACRO_TRIG]; /*!< マクロのトリガーコード */
+concptr macro_trigger_keycode[2][MAX_MACRO_TRIG]; /*!< マクロの内容 */
-/*
- * For those systems that don't have "stricmp()"
- *
- * Compare the two strings "a" and "b" ala "strcmp()" ignoring case.
- */
-int stricmp(cptr a, cptr b)
-{
- cptr s1, s2;
- char z1, z2;
+s16b command_cmd; /* Current "Angband Command" */
+COMMAND_ARG command_arg; /*!< 各種コマンドの汎用的な引数として扱う / Gives argument of current command */
+COMMAND_NUM command_rep; /*!< 各種コマンドの汎用的なリピート数として扱う / Gives repetition of current command */
+DIRECTION command_dir; /*!< 各種コマンドの汎用的な方向値処理として扱う/ Gives direction of current command */
+s16b command_see; /* See "object1.c" */
+s16b command_wrk; /* See "object1.c" */
+TERM_LEN command_gap = 999; /* See "object1.c" */
+s16b command_new; /* Command chaining from inven/equip view */
- /* Scan the strings */
- for (s1 = a, s2 = b; TRUE; s1++, s2++)
- {
- z1 = FORCEUPPER(*s1);
- z2 = FORCEUPPER(*s2);
- if (z1 < z2) return (-1);
- if (z1 > z2) return (1);
- if (!z1) return (0);
- }
-}
-#endif /* HAS_STRICMP */
-#endif /* 0 */
#ifdef SET_UID
/* Paranoia -- No excessive sleeping */
-#ifdef JP
- if (usecs > 4000000L) core("ÉÔÅö¤Ê usleep() ¸Æ¤Ó½Ð¤·");
-#else
- if (usecs > 4000000L) core("Illegal usleep() call");
-#endif
-
-
+ if (usecs > 4000000L) core(_("不当な usleep() 呼び出し", "Illegal usleep() call"));
/* Wait for it */
Timer.tv_sec = (usecs / 1000000L);
*/
#ifdef SET_UID
extern struct passwd *getpwuid(uid_t uid);
-extern struct passwd *getpwnam(const char *name);
+extern struct passwd *getpwnam(concptr name);
#endif
(void)strcpy(buf, pw->pw_name);
buf[16] = '\0';
-#ifdef CAPITALIZE_USER_NAME
/* Hack -- capitalize the user name */
#ifdef JP
if (!iskanji(buf[0]))
#endif
if (islower(buf[0]))
buf[0] = toupper(buf[0]);
-#endif /* CAPITALIZE_USER_NAME */
return;
}
* path, and a leading "tilde" to indicate a special directory, and default to a
* relative path, but MSDOS uses a leading "drivename plus colon" to indicate the
* use of a "special drive", and then the rest of the path is parsed "normally",
- * and MACINTOSH uses a leading colon to indicate a relative path, and an embedded
- * colon to indicate a "drive plus absolute path", and finally defaults to a file
- * in the current working directory, which may or may not be defined.
+ * and an embedded colon to indicate a "drive plus absolute path", and finally
+ * defaults to a file in the current working directory, which may or may not be defined.
*
* We should probably parse a leading "~~/" as referring to "ANGBAND_DIR". (?)
*/
-#ifdef ACORN
-
-
-/*
- * Most of the "file" routines for "ACORN" should be in "main-acn.c"
- */
-
-
-#else /* ACORN */
-
-
#ifdef SET_UID
-/*
- * Extract a "parsed" path from an initial filename
- * Normally, we simply copy the filename into the buffer
- * But leading tilde symbols must be handled in a special way
- * Replace "~user/" by the home directory of the user named "user"
- * Replace "~/" by the home directory of the current user
- */
-errr path_parse(char *buf, int max, cptr file)
+ /*
+ * Extract a "parsed" path from an initial filename
+ * Normally, we simply copy the filename into the buffer
+ * But leading tilde symbols must be handled in a special way
+ * Replace "~user/" by the home directory of the user named "user"
+ * Replace "~/" by the home directory of the current user
+ */
+errr path_parse(char *buf, int max, concptr file)
{
- cptr u, s;
+ concptr u, s;
struct passwd *pw;
char user[128];
buf[0] = '\0';
/* No file? */
- if (!file) return (-1);
+ if (!file) return -1;
/* File needs no parsing */
if (file[0] != '~')
{
(void)strnfmt(buf, max, "%s", file);
- return (0);
+ return 0;
}
/* Point at the user */
- u = file+1;
+ u = file + 1;
/* Look for non-user portion of the file */
s = my_strstr(u, PATH_SEP);
/* Hack -- no long user names */
- if (s && (s >= u + sizeof(user))) return (1);
+ if (s && (s >= u + sizeof(user))) return 1;
/* Extract a user name */
if (s)
else pw = getpwuid(getuid());
/* Nothing found? */
- if (!pw) return (1);
+ if (!pw) return 1;
/* Make use of the info */
if (s) strnfmt(buf, max, "%s%s", pw->pw_dir, s);
else strnfmt(buf, max, "%s", pw->pw_dir);
/* Success */
- return (0);
+ return 0;
}
#else /* SET_UID */
-/*
- * Extract a "parsed" path from an initial filename
- *
- * This requires no special processing on simple machines,
- * except for verifying the size of the filename.
- */
-errr path_parse(char *buf, int max, cptr file)
+ /*
+ * Extract a "parsed" path from an initial filename
+ *
+ * This requires no special processing on simple machines,
+ * except for verifying the size of the filename.
+ */
+errr path_parse(char *buf, int max, concptr file)
{
/* Accept the filename */
(void)strnfmt(buf, max, "%s", file);
-
-#if defined(MAC_MPW) && defined(CARBON)
- /* Fix it according to the current operating system */
- convert_pathname(buf);
-#endif /* MAC_MPW && CARBON */
-
- /* Success */
- return (0);
+ return 0;
}
*/
static errr path_temp(char *buf, int max)
{
- cptr s;
+ concptr s;
/* Temp file */
s = tmpnam(NULL);
- /* Oops */
- if (!s) return (-1);
+ if (!s) return -1;
/* Format to length */
-#ifndef WIN32
+#if !defined(WIN32) || (defined(_MSC_VER) && (_MSC_VER >= 1900))
(void)strnfmt(buf, max, "%s", s);
#else
(void)strnfmt(buf, max, ".%s", s);
#endif
/* Success */
- return (0);
+ return 0;
}
#endif
-/*
- * Create a new path by appending a file (or directory) to a path.
+/*!
+ * @brief ファイル入出力のためのパス生成する。/ Create a new path by appending a file (or directory) to a path.
+ * @param buf ファイルのフルを返すバッファ
+ * @param max bufのサイズ
+ * @param path ファイルパス
+ * @param file ファイル名
+ * @return エラーコード(ただし常に0を返す)
*
* This requires no special processing on simple machines, except
* for verifying the size of the filename, but note the ability to
* Note that this function yields a path which must be "parsed"
* using the "parse" function above.
*/
-errr path_build(char *buf, int max, cptr path, cptr file)
+errr path_build(char *buf, int max, concptr path, concptr file)
{
/* Special file */
if (file[0] == '~')
}
/* Success */
- return (0);
+ return 0;
}
/*
* Hack -- replacement for "fopen()"
*/
-FILE *my_fopen(cptr file, cptr mode)
+FILE *my_fopen(concptr file, concptr mode)
{
char buf[1024];
-#if defined(MAC_MPW) || defined(MACH_O_CARBON)
+#if defined(MACH_O_CARBON)
FILE *tempfff;
#endif
/* Hack -- Try to parse the path */
if (path_parse(buf, 1024, file)) return (NULL);
-#if defined(MAC_MPW) || defined(MACH_O_CARBON)
+#if defined(MACH_O_CARBON)
if (my_strchr(mode, 'w'))
{
/* setting file type/creator */
errr my_fclose(FILE *fff)
{
/* Require a file */
- if (!fff) return (-1);
+ if (!fff) return -1;
/* Close, check for error */
- if (fclose(fff) == EOF) return (1);
+ if (fclose(fff) == EOF) return 1;
/* Success */
- return (0);
+ return 0;
}
-#endif /* ACORN */
-
-
#ifdef HAVE_MKSTEMP
FILE *my_fopen_temp(char *buf, int max)
{
/* Generate a temporary filename */
if (path_temp(buf, max)) return (NULL);
-
- /* Open the file */
return (my_fopen(buf, "w"));
}
errr my_fgets(FILE *fff, char *buf, huge n)
{
huge i = 0;
-
char *s;
-
char tmp[1024];
/* Read a line */
if (fgets(tmp, 1024, fff))
{
+#ifdef JP
+ guess_convert_to_system_encoding(tmp, sizeof(tmp));
+#endif
+
/* Convert weirdness */
for (s = tmp; *s; s++)
{
-#if defined(MACINTOSH) || defined(MACH_O_CARBON)
+#if defined(MACH_O_CARBON)
/*
* Be nice to the Macintosh, where a file can have Mac or Unix
*/
if (*s == '\r') *s = '\n';
-#endif /* MACINTOSH || MACH_O_CARBON */
+#endif /* MACH_O_CARBON */
/* Handle newline */
if (*s == '\n')
buf[i] = '\0';
/* Success */
- return (0);
+ return 0;
}
/* Handle tabs */
buf[i++] = *s;
}
- /* Ⱦ³Ñ¤«¤Ê¤ËÂбþ */
+ /* 半角かなに対応 */
else if (iskana(*s))
{
buf[i++] = *s;
}
#endif
/* Handle printables */
- else if (isprint(*s))
+ else if (isprint((unsigned char)*s))
{
/* Copy */
buf[i++] = *s;
buf[i] = '\0';
/* Success */
- return (0);
+ return 0;
}
/* Nothing */
buf[0] = '\0';
/* Failure */
- return (1);
+ return 1;
}
/*
* Hack -- replacement for "fputs()"
- *
* Dump a string, plus a newline, to a file
- *
- * XXX XXX XXX Process internal weirdness?
+ * Process internal weirdness?
*/
-errr my_fputs(FILE *fff, cptr buf, huge n)
+errr my_fputs(FILE *fff, concptr buf, huge n)
{
/* XXX XXX */
n = n ? n : 0;
(void)fprintf(fff, "%s\n", buf);
/* Success */
- return (0);
+ return 0;
}
-#ifdef ACORN
-
-
-/*
- * Most of the "file" routines for "ACORN" should be in "main-acn.c"
- *
- * Many of them can be rewritten now that only "fd_open()" and "fd_make()"
- * and "my_fopen()" should ever create files.
- */
-
-
-#else /* ACORN */
-
-
-/*
- * Code Warrior is a little weird about some functions
- */
-#ifdef BEN_HACK
-extern int open(const char *, int, ...);
-extern int close(int);
-extern int read(int, void *, unsigned int);
-extern int write(int, const void *, unsigned int);
-extern long lseek(int, long, int);
-#endif /* BEN_HACK */
-
-
-/*
- * The Macintosh is a little bit brain-dead sometimes
- */
-#ifdef MACINTOSH
-# define open(N,F,M) \
-((M), open((char*)(N),F))
-# define write(F,B,S) \
-write(F,(char*)(B),S)
-#endif /* MACINTOSH */
-
-
-/*
- * Several systems have no "O_BINARY" flag
- */
+ /*
+ * Several systems have no "O_BINARY" flag
+ */
#ifndef O_BINARY
# define O_BINARY 0
#endif /* O_BINARY */
-/*
- * Hack -- attempt to delete a file
- */
-errr fd_kill(cptr file)
+ /*
+ * Hack -- attempt to delete a file
+ */
+errr fd_kill(concptr file)
{
char buf[1024];
/* Hack -- Try to parse the path */
- if (path_parse(buf, 1024, file)) return (-1);
+ if (path_parse(buf, 1024, file)) return -1;
/* Remove */
(void)remove(buf);
- /* XXX XXX XXX */
- return (0);
+ return 0;
}
/*
* Hack -- attempt to move a file
*/
-errr fd_move(cptr file, cptr what)
+errr fd_move(concptr file, concptr what)
{
char buf[1024];
char aux[1024];
/* Hack -- Try to parse the path */
- if (path_parse(buf, 1024, file)) return (-1);
+ if (path_parse(buf, 1024, file)) return -1;
/* Hack -- Try to parse the path */
- if (path_parse(aux, 1024, what)) return (-1);
+ if (path_parse(aux, 1024, what)) return -1;
/* Rename */
(void)rename(buf, aux);
- /* XXX XXX XXX */
- return (0);
+ return 0;
}
/*
* Hack -- attempt to copy a file
*/
-errr fd_copy(cptr file, cptr what)
+errr fd_copy(concptr file, concptr what)
{
char buf[1024];
char aux[1024];
int src_fd, dst_fd;
/* Hack -- Try to parse the path */
- if (path_parse(buf, 1024, file)) return (-1);
+ if (path_parse(buf, 1024, file)) return -1;
/* Hack -- Try to parse the path */
- if (path_parse(aux, 1024, what)) return (-1);
+ if (path_parse(aux, 1024, what)) return -1;
/* Open source file */
src_fd = fd_open(buf, O_RDONLY);
- if (src_fd < 0) return (-1);
+ if (src_fd < 0) return -1;
/* Open destination file */
- dst_fd = fd_open(aux, O_WRONLY|O_TRUNC|O_CREAT);
- if (dst_fd < 0) return (-1);
+ dst_fd = fd_open(aux, O_WRONLY | O_TRUNC | O_CREAT);
+ if (dst_fd < 0) return -1;
/* Copy */
while ((read_num = read(src_fd, buf, 1024)) > 0)
fd_close(src_fd);
fd_close(dst_fd);
- /* XXX XXX XXX */
- return (0);
+ return 0;
}
-
/*
* Hack -- attempt to open a file descriptor (create file)
- *
* This function should fail if the file already exists
- *
* Note that we assume that the file should be "binary"
- *
- * XXX XXX XXX The horrible "BEN_HACK" code is for compiling under
- * the CodeWarrior compiler, in which case, for some reason, none
- * of the "O_*" flags are defined, and we must fake the definition
- * of "O_RDONLY", "O_WRONLY", and "O_RDWR" in "A-win-h", and then
- * we must simulate the effect of the proper "open()" call below.
*/
-int fd_make(cptr file, int mode)
+int fd_make(concptr file, BIT_FLAGS mode)
{
char buf[1024];
/* Hack -- Try to parse the path */
- if (path_parse(buf, 1024, file)) return (-1);
-
-#ifdef BEN_HACK
-
- /* Check for existance */
- /* if (fd_close(fd_open(file, O_RDONLY | O_BINARY))) return (1); */
-
- /* Mega-Hack -- Create the file */
- (void)my_fclose(my_fopen(file, "wb"));
+ if (path_parse(buf, 1024, file)) return -1;
- /* Re-open the file for writing */
- return (open(buf, O_WRONLY | O_BINARY, mode));
-
-#else /* BEN_HACK */
-
-#if defined(MAC_MPW) || defined(MACH_O_CARBON)
+#if defined(MACH_O_CARBON)
{
int fdes;
/* Create the file, fail if exists, write-only, binary */
/* Return the descriptor */
return (fdes);
}
-# else
+#else
/* Create the file, fail if exists, write-only, binary */
return (open(buf, O_CREAT | O_EXCL | O_WRONLY | O_BINARY, mode));
-# endif
-
-#endif /* BEN_HACK */
+#endif
}
*
* Note that we assume that the file should be "binary"
*/
-int fd_open(cptr file, int flags)
+int fd_open(concptr file, int flags)
{
char buf[1024];
/* Hack -- Try to parse the path */
- if (path_parse(buf, 1024, file)) return (-1);
+ if (path_parse(buf, 1024, file)) return -1;
/* Attempt to open the file */
return (open(buf, flags | O_BINARY, 0));
what = what ? what : 0;
/* Verify the fd */
- if (fd < 0) return (-1);
+ if (fd < 0) return -1;
#ifdef SET_UID
else
{
/* Lock the score file */
- if (lockf(fd, F_LOCK, 0) != 0) return (1);
+ if (lockf(fd, F_LOCK, 0) != 0) return 1;
}
# endif
else
{
/* Lock the score file */
- if (flock(fd, LOCK_EX) != 0) return (1);
+ if (flock(fd, LOCK_EX) != 0) return 1;
}
# endif
#endif
/* Success */
- return (0);
+ return 0;
}
huge p;
/* Verify fd */
- if (fd < 0) return (-1);
+ if (fd < 0) return -1;
/* Seek to the given position */
p = lseek(fd, n, SEEK_SET);
/* Failure */
- if (p != n) return (1);
+ if (p != n) return 1;
/* Success */
- return (0);
+ return 0;
}
n = n ? n : 0;
/* Verify the fd */
- if (fd < 0) return (-1);
+ if (fd < 0) return -1;
-#if defined(SUNOS) || defined(ULTRIX) || defined(NeXT)
+#if defined(NeXT)
/* Truncate */
ftruncate(fd, n);
#endif
/* Success */
- return (0);
+ return 0;
}
errr fd_read(int fd, char *buf, huge n)
{
/* Verify the fd */
- if (fd < 0) return (-1);
+ if (fd < 0) return -1;
#ifndef SET_UID
while (n >= 16384)
{
/* Read a piece */
- if (read(fd, buf, 16384) != 16384) return (1);
+ if (read(fd, buf, 16384) != 16384) return 1;
/* Shorten the task */
buf += 16384;
#endif
/* Read the final piece */
- if (read(fd, buf, n) != (int)n) return (1);
+ if (read(fd, buf, n) != (int)n) return 1;
/* Success */
- return (0);
+ return 0;
}
/*
* Hack -- Attempt to write data to a file descriptor
*/
-errr fd_write(int fd, cptr buf, huge n)
+errr fd_write(int fd, concptr buf, huge n)
{
/* Verify the fd */
- if (fd < 0) return (-1);
+ if (fd < 0) return -1;
#ifndef SET_UID
while (n >= 16384)
{
/* Write a piece */
- if (write(fd, buf, 16384) != 16384) return (1);
+ if (write(fd, buf, 16384) != 16384) return 1;
/* Shorten the task */
buf += 16384;
#endif
/* Write the final piece */
- if (write(fd, buf, n) != (int)n) return (1);
+ if (write(fd, buf, n) != (int)n) return 1;
/* Success */
- return (0);
+ return 0;
}
errr fd_close(int fd)
{
/* Verify the fd */
- if (fd < 0) return (-1);
+ if (fd < 0) return -1;
/* Close */
(void)close(fd);
- /* XXX XXX XXX */
- return (0);
+ return 0;
}
-#endif /* ACORN */
-
-
-
-
/*
- * XXX XXX XXX Important note about "colors" XXX XXX XXX
+ * Important note about "colors"
*
* The "TERM_*" color definitions list the "composition" of each
* "Angband color" in terms of "quarters" of each of the three color
*/
-/*
- * Move the cursor
- */
+ /*
+ * Move the cursor
+ */
void move_cursor(int row, int col)
{
Term_gotoxy(col, row);
*/
static char octify(uint i)
{
- return (hexsym[i%8]);
+ return (hexsym[i % 8]);
}
/*
*/
static char hexify(uint i)
{
- return (hexsym[i%16]);
+ return (hexsym[i % 16]);
}
static int deoct(char c)
{
if (isdigit(c)) return (D2I(c));
- return (0);
+ return 0;
}
/*
if (isdigit(c)) return (D2I(c));
if (islower(c)) return (A2I(c) + 10);
if (isupper(c)) return (A2I(tolower(c)) + 10);
- return (0);
+ return 0;
}
-static int my_stricmp(cptr a, cptr b)
+static int my_stricmp(concptr a, concptr b)
{
- cptr s1, s2;
+ concptr s1, s2;
char z1, z2;
/* Scan the strings */
{
z1 = FORCEUPPER(*s1);
z2 = FORCEUPPER(*s2);
- if (z1 < z2) return (-1);
- if (z1 > z2) return (1);
- if (!z1) return (0);
+ if (z1 < z2) return -1;
+ if (z1 > z2) return 1;
+ if (!z1) return 0;
}
}
-static int my_strnicmp(cptr a, cptr b, int n)
+static int my_strnicmp(concptr a, concptr b, int n)
{
- cptr s1, s2;
+ concptr s1, s2;
char z1, z2;
/* Scan the strings */
{
z1 = FORCEUPPER(*s1);
z2 = FORCEUPPER(*s2);
- if (z1 < z2) return (-1);
- if (z1 > z2) return (1);
- if (!z1) return (0);
+ if (z1 < z2) return -1;
+ if (z1 > z2) return 1;
+ if (!z1) return 0;
}
return 0;
}
-static void trigger_text_to_ascii(char **bufptr, cptr *strptr)
+static void trigger_text_to_ascii(char **bufptr, concptr *strptr)
{
char *s = *bufptr;
- cptr str = *strptr;
+ concptr str = *strptr;
bool mod_status[MAX_MACRO_MOD];
int i, len = 0;
int shiftstatus = 0;
- cptr key_code;
+ concptr key_code;
if (macro_template == NULL)
return;
-
+
for (i = 0; macro_modifier_chr[i]; i++)
mod_status[i] = FALSE;
str++;
/* Examine modifier keys */
- while (1)
+ while (TRUE)
{
- for (i=0; macro_modifier_chr[i]; i++)
+ for (i = 0; macro_modifier_chr[i]; i++)
{
len = strlen(macro_modifier_name[i]);
-
- if(!my_strnicmp(str, macro_modifier_name[i], len))
+
+ if (!my_strnicmp(str, macro_modifier_name[i], len))
break;
}
if (!macro_modifier_chr[i]) break;
char ch = macro_template[i];
int j;
- switch(ch)
+ switch (ch)
{
case '&':
for (j = 0; macro_modifier_chr[j]; j++) {
* parsing "\xFF" into a (signed) char. Whoever thought of making
* the "sign" of a "char" undefined is a complete moron. Oh well.
*/
-void text_to_ascii(char *buf, cptr str)
+void text_to_ascii(char *buf, concptr str)
{
char *s = buf;
{
/* Skip the backslash */
str++;
-
- /* Paranoia */
if (!(*str)) break;
/* Macro Trigger */
}
else
- /* Hex-mode XXX */
- if (*str == 'x')
- {
- *s = 16 * dehex(*++str);
- *s++ += dehex(*++str);
- }
+ /* Hex-mode XXX */
+ if (*str == 'x')
+ {
+ *s = 16 * (char)dehex(*++str);
+ *s++ += (char)dehex(*++str);
+ }
/* Hack -- simple way to specify "backslash" */
- else if (*str == '\\')
- {
- *s++ = '\\';
- }
+ else if (*str == '\\')
+ {
+ *s++ = '\\';
+ }
/* Hack -- simple way to specify "caret" */
- else if (*str == '^')
- {
- *s++ = '^';
- }
+ else if (*str == '^')
+ {
+ *s++ = '^';
+ }
/* Hack -- simple way to specify "space" */
- else if (*str == 's')
- {
- *s++ = ' ';
- }
+ else if (*str == 's')
+ {
+ *s++ = ' ';
+ }
/* Hack -- simple way to specify Escape */
- else if (*str == 'e')
- {
- *s++ = ESCAPE;
- }
+ else if (*str == 'e')
+ {
+ *s++ = ESCAPE;
+ }
/* Backspace */
- else if (*str == 'b')
- {
- *s++ = '\b';
- }
+ else if (*str == 'b')
+ {
+ *s++ = '\b';
+ }
/* Newline */
- else if (*str == 'n')
- {
- *s++ = '\n';
- }
+ else if (*str == 'n')
+ {
+ *s++ = '\n';
+ }
/* Return */
- else if (*str == 'r')
- {
- *s++ = '\r';
- }
+ else if (*str == 'r')
+ {
+ *s++ = '\r';
+ }
/* Tab */
- else if (*str == 't')
- {
- *s++ = '\t';
- }
+ else if (*str == 't')
+ {
+ *s++ = '\t';
+ }
/* Octal-mode */
- else if (*str == '0')
- {
- *s = 8 * deoct(*++str);
- *s++ += deoct(*++str);
- }
+ else if (*str == '0')
+ {
+ *s = 8 * (char)deoct(*++str);
+ *s++ += (char)deoct(*++str);
+ }
/* Octal-mode */
- else if (*str == '1')
- {
- *s = 64 + 8 * deoct(*++str);
- *s++ += deoct(*++str);
- }
+ else if (*str == '1')
+ {
+ *s = 64 + 8 * (char)deoct(*++str);
+ *s++ += (char)deoct(*++str);
+ }
/* Octal-mode */
- else if (*str == '2')
- {
- *s = 64 * 2 + 8 * deoct(*++str);
- *s++ += deoct(*++str);
- }
+ else if (*str == '2')
+ {
+ *s = 64 * 2 + 8 * (char)deoct(*++str);
+ *s++ += (char)deoct(*++str);
+ }
/* Octal-mode */
- else if (*str == '3')
- {
- *s = 64 * 3 + 8 * deoct(*++str);
- *s++ += deoct(*++str);
- }
+ else if (*str == '3')
+ {
+ *s = 64 * 3 + 8 * (char)deoct(*++str);
+ *s++ += (char)deoct(*++str);
+ }
/* Skip the final char */
str++;
}
-static bool trigger_ascii_to_text(char **bufptr, cptr *strptr)
+static bool trigger_ascii_to_text(char **bufptr, concptr *strptr)
{
char *s = *bufptr;
- cptr str = *strptr;
+ concptr str = *strptr;
char key_code[100];
int i;
- cptr tmp;
+ concptr tmp;
if (macro_template == NULL)
return FALSE;
int j;
char ch = macro_template[i];
- switch(ch)
+ switch (ch)
{
case '&':
- while ((tmp = my_strchr(macro_modifier_chr, *str)))
+ while ((tmp = my_strchr(macro_modifier_chr, *str)) != 0)
{
j = (int)(tmp - macro_modifier_chr);
tmp = macro_modifier_name[j];
- while(*tmp) *s++ = *tmp++;
+ while (*tmp) *s++ = *tmp++;
str++;
}
break;
for (i = 0; i < max_macrotrigger; i++)
{
if (!my_stricmp(key_code, macro_trigger_keycode[0][i])
- || !my_stricmp(key_code, macro_trigger_keycode[1][i]))
+ || !my_stricmp(key_code, macro_trigger_keycode[1][i]))
break;
}
if (i == max_macrotrigger)
while (*tmp) *s++ = *tmp++;
*s++ = ']';
-
+
*bufptr = s;
*strptr = str;
return TRUE;
/*
* Hack -- convert a string into a printable form
*/
-void ascii_to_text(char *buf, cptr str)
+void ascii_to_text(char *buf, concptr str)
{
char *s = buf;
/* Macro Trigger */
if (i == 31)
{
- if(!trigger_ascii_to_text(&s, &str))
+ if (!trigger_ascii_to_text(&s, &str))
{
*s++ = '^';
*s++ = '_';
}
else
- if (i == ESCAPE)
- {
- *s++ = '\\';
- *s++ = 'e';
- }
- else if (i == ' ')
- {
- *s++ = '\\';
- *s++ = 's';
- }
- else if (i == '\b')
- {
- *s++ = '\\';
- *s++ = 'b';
- }
- else if (i == '\t')
- {
- *s++ = '\\';
- *s++ = 't';
- }
- else if (i == '\n')
- {
- *s++ = '\\';
- *s++ = 'n';
- }
- else if (i == '\r')
- {
- *s++ = '\\';
- *s++ = 'r';
- }
- else if (i == '^')
- {
- *s++ = '\\';
- *s++ = '^';
- }
- else if (i == '\\')
- {
- *s++ = '\\';
- *s++ = '\\';
- }
- else if (i < 32)
- {
- *s++ = '^';
- *s++ = i + 64;
- }
- else if (i < 127)
- {
- *s++ = i;
- }
- else if (i < 64)
- {
- *s++ = '\\';
- *s++ = '0';
- *s++ = octify(i / 8);
- *s++ = octify(i % 8);
- }
- else
- {
- *s++ = '\\';
- *s++ = 'x';
- *s++ = hexify(i / 16);
- *s++ = hexify(i % 16);
- }
+ if (i == ESCAPE)
+ {
+ *s++ = '\\';
+ *s++ = 'e';
+ }
+ else if (i == ' ')
+ {
+ *s++ = '\\';
+ *s++ = 's';
+ }
+ else if (i == '\b')
+ {
+ *s++ = '\\';
+ *s++ = 'b';
+ }
+ else if (i == '\t')
+ {
+ *s++ = '\\';
+ *s++ = 't';
+ }
+ else if (i == '\n')
+ {
+ *s++ = '\\';
+ *s++ = 'n';
+ }
+ else if (i == '\r')
+ {
+ *s++ = '\\';
+ *s++ = 'r';
+ }
+ else if (i == '^')
+ {
+ *s++ = '\\';
+ *s++ = '^';
+ }
+ else if (i == '\\')
+ {
+ *s++ = '\\';
+ *s++ = '\\';
+ }
+ else if (i < 32)
+ {
+ *s++ = '^';
+ *s++ = i + 64;
+ }
+ else if (i < 127)
+ {
+ *s++ = i;
+ }
+ else if (i < 64)
+ {
+ *s++ = '\\';
+ *s++ = '0';
+ *s++ = octify(i / 8);
+ *s++ = octify(i % 8);
+ }
+ else
+ {
+ *s++ = '\\';
+ *s++ = 'x';
+ *s++ = hexify(i / 16);
+ *s++ = hexify(i % 16);
+ }
}
/* Terminate */
-/*
- * Determine if any macros have ever started with a given character.
- */
+ /*
+ * Determine if any macros have ever started with a given character.
+ */
static bool macro__use[256];
/*
* Find the macro (if any) which exactly matches the given pattern
*/
-sint macro_find_exact(cptr pat)
+sint macro_find_exact(concptr pat)
{
int i;
/* Nothing possible */
if (!macro__use[(byte)(pat[0])])
{
- return (-1);
+ return -1;
}
/* Scan the macros */
}
/* No matches */
- return (-1);
+ return -1;
}
/*
* Find the first macro (if any) which contains the given pattern
*/
-static sint macro_find_check(cptr pat)
+static sint macro_find_check(concptr pat)
{
int i;
/* Nothing possible */
if (!macro__use[(byte)(pat[0])])
{
- return (-1);
+ return -1;
}
/* Scan the macros */
}
/* Nothing */
- return (-1);
+ return -1;
}
/*
* Find the first macro (if any) which contains the given pattern and more
*/
-static sint macro_find_maybe(cptr pat)
+static sint macro_find_maybe(concptr pat)
{
int i;
/* Nothing possible */
if (!macro__use[(byte)(pat[0])])
{
- return (-1);
+ return -1;
}
/* Scan the macros */
}
/* Nothing */
- return (-1);
+ return -1;
}
/*
* Find the longest macro (if any) which starts with the given pattern
*/
-static sint macro_find_ready(cptr pat)
+static sint macro_find_ready(concptr pat)
{
int i, t, n = -1, s = -1;
/* Nothing possible */
if (!macro__use[(byte)(pat[0])])
{
- return (-1);
+ return -1;
}
/* Scan the macros */
n = i;
s = t;
}
-
- /* Result */
return (n);
}
* Add a macro definition (or redefinition).
*
* We should use "act == NULL" to "remove" a macro, but this might make it
- * impossible to save the "removal" of a macro definition. XXX XXX XXX
+ * impossible to save the "removal" of a macro definition.
*
* We should consider refusing to allow macros which contain existing macros,
* or which are contained in existing macros, because this would simplify the
- * macro analysis code. XXX XXX XXX
+ * macro analysis code.
*
* We should consider removing the "command macro" crap, and replacing it
* with some kind of "powerful keymap" ability, but this might make it hard
- * to change the "roguelike" option from inside the game. XXX XXX XXX
+ * to change the "roguelike" option from inside the game.
*/
-errr macro_add(cptr pat, cptr act)
+errr macro_add(concptr pat, concptr act)
{
int n;
/* Paranoia -- require data */
- if (!pat || !act) return (-1);
+ if (!pat || !act) return -1;
/* Look for any existing macro */
macro__use[(byte)(pat[0])] = TRUE;
/* Success */
- return (0);
+ return 0;
}
/*
* Hack -- Play a music
*/
-void music(int val)
+errr play_music(int type, int val)
{
/* No sound */
- if (!use_music) return;
+ if (!use_music) return 1;
/* Make a sound (if allowed) */
- Term_xtra(TERM_XTRA_MUSIC, val);
+ return Term_xtra(type, val);
}
-/*
- * Hack -- Select floor music.
- */
-void select_floor_music()
-{
- /* No sound */
- if (!use_music) return;
+/*
+ * Hack -- Select floor music.
+ */
+void select_floor_music(player_type *player_ptr)
+{
+ if (!use_music) return;
+
+ if (player_ptr->ambush_flag)
+ {
+ if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_AMBUSH)) return;
+ }
+
+ if (player_ptr->wild_mode)
+ {
+ if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_WILD)) return;
+ }
+
+ if (player_ptr->current_floor_ptr->inside_arena)
+ {
+ if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_ARENA)) return;
+ }
+
+ if (player_ptr->phase_out)
+ {
+ if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_BATTLE)) return;
+ }
+
+ if (player_ptr->current_floor_ptr->inside_quest)
+ {
+ if (!play_music(TERM_XTRA_MUSIC_QUEST, player_ptr->current_floor_ptr->inside_quest)) return;
+ if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_QUEST)) return;
+ }
+
+ if (player_ptr->dungeon_idx)
+ {
+ if (player_ptr->feeling == 2)
+ {
+ if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_DUN_FEEL2)) return;
+ }
+ else if (player_ptr->feeling >= 3 && player_ptr->feeling <= 5)
+ {
+ if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_DUN_FEEL1)) return;
+ }
+ else
+ {
+ if (!play_music(TERM_XTRA_MUSIC_DUNGEON, player_ptr->dungeon_idx)) return;
+
+ if (player_ptr->current_floor_ptr->dun_level < 40)
+ {
+ if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_DUN_LOW)) return;
+ }
+ else if (player_ptr->current_floor_ptr->dun_level < 80)
+ {
+ if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_DUN_MED)) return;
+ }
+ else
+ {
+ if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_DUN_HIGH)) return;
+ }
+ }
+ }
+
+ if (player_ptr->town_num)
+ {
+ if (!play_music(TERM_XTRA_MUSIC_TOWN, player_ptr->town_num)) return;
+ if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_TOWN)) return;
+ return;
+ }
- /* Make a sound (if allowed) */
- //TODO Term_xtra(TERM_XTRA_MUSIC, val);
+ if (!player_ptr->current_floor_ptr->dun_level)
+ {
+ if (player_ptr->lev >= 45)
+ {
+ if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_FIELD3)) return;
+ }
+ else if (player_ptr->lev >= 25)
+ {
+ if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_FIELD2)) return;
+ }
+ else
+ {
+ if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_FIELD1)) return;
+ }
+ }
+
+ play_music(TERM_XTRA_MUSIC_MUTE, 0);
}
* Only 500 (0+1+2+...+29+30) milliseconds may elapse between each key in
* the macro trigger sequence. If a key sequence forms the "prefix" of a
* macro trigger, 500 milliseconds must pass before the key sequence is
- * known not to be that macro trigger. XXX XXX XXX
+ * known not to be that macro trigger.
*/
static char inkey_aux(void)
{
char ch;
- cptr pat, act;
+ concptr pat, act;
char *buf = inkey_macro_trigger_string;
- /* Hack : ¥¡¼ÆþÎÏÂÔ¤Á¤Ç»ß¤Þ¤Ã¤Æ¤¤¤ë¤Î¤Ç¡¢Î®¤ì¤¿¹Ô¤Îµ²±¤ÏÉÔÍס£ */
+ /* Hack : キー入力待ちで止まっているので、流れた行の記憶は不要。 */
num_more = 0;
if (parse_macro)
else
{
/* Wait for a keypress */
- (void) (Term_inkey(&ch, TRUE, TRUE));
+ (void)(Term_inkey(&ch, TRUE, TRUE));
}
/* Excessive delay */
if (w >= 10) break;
- /* Delay */
Term_xtra(TERM_XTRA_DELAY, w);
}
}
while (p > 0)
{
/* Push the key, notice over-flow */
- if (Term_key_push(buf[--p])) return (0);
+ if (Term_key_push(buf[--p])) return 0;
}
/* Wait for (and remove) a pending key */
while (p > n)
{
/* Push the key, notice over-flow */
- if (Term_key_push(buf[--p])) return (0);
+ if (Term_key_push(buf[--p])) return 0;
}
parse_macro = TRUE;
/* Push the "end of macro action" key */
- if (Term_key_push(30)) return (0);
+ if (Term_key_push(30)) return 0;
/* Access the macro action */
while (n > 0)
{
/* Push the key, notice over-flow */
- if (Term_key_push(act[--n])) return (0);
+ if (Term_key_push(act[--n])) return 0;
}
/* Hack -- Force "inkey()" to call us again */
- return (0);
+ return 0;
}
parse_macro = FALSE;
}
-
/*
- * Mega-Hack -- special "inkey_next" pointer. XXX XXX XXX
+ * Mega-Hack -- special "inkey_next" pointer.
*
* This special pointer allows a sequence of keys to be "inserted" into
* the stream of keys returned by "inkey()". This key sequence will not
* trigger any macros, and cannot be bypassed by the Borg. It is used
* in Angband to handle "keymaps".
*/
-static cptr inkey_next = NULL;
-
-
-#ifdef ALLOW_BORG
-
-/*
- * Mega-Hack -- special "inkey_hack" hook. XXX XXX XXX
- *
- * This special function hook allows the "Borg" (see elsewhere) to take
- * control of the "inkey()" function, and substitute in fake keypresses.
- */
-char (*inkey_hack)(int flush_first) = NULL;
-
-#endif /* ALLOW_BORG */
-
-
+static concptr inkey_next = NULL;
/*
* Get a keypress from the user.
* is only requested (via "Term_inkey()") when "angband_term[0]" is active.
*
* Mega-Hack -- This function is used as the entry point for clearing the
- * "signal_count" variable, and of the "character_saved" variable.
+ * "signal_count" variable, and of the "current_world_ptr->character_saved" variable.
*
* Hack -- Note the use of "inkey_next" to allow "keymaps" to be processed.
*
/* Forget pointer */
inkey_next = NULL;
-
-#ifdef ALLOW_BORG
-
- /* Mega-Hack -- Use the special hook */
- if (inkey_hack && ((ch = (*inkey_hack)(inkey_xtra)) != 0))
- {
- /* Cancel the various "global parameters" */
- inkey_base = inkey_xtra = inkey_flag = inkey_scan = FALSE;
-
- /* Accept result */
- return (ch);
- }
-
-#endif /* ALLOW_BORG */
-
-
/* Hack -- handle delayed "flush()" */
if (inkey_xtra)
{
(void)Term_get_cursor(&v);
/* Show the cursor if waiting, except sometimes in "command" mode */
- if (!inkey_scan && (!inkey_flag || hilite_player || character_icky))
+ if (!inkey_scan && (!inkey_flag || hilite_player || current_world_ptr->character_icky))
{
/* Show the cursor */
(void)Term_set_cursor(1);
Term_activate(angband_term[0]);
/* Mega-Hack -- reset saved flag */
- character_saved = FALSE;
+ current_world_ptr->character_saved = FALSE;
/* Mega-Hack -- reset signal counter */
signal_count = 0;
/* Wait for (and remove) a pending key */
if (0 == Term_inkey(&ch, TRUE, TRUE))
{
- /* Done */
break;
}
- /* Oops */
break;
}
/* Check for (and remove) a pending key */
if (0 == Term_inkey(&ch, FALSE, TRUE))
{
- /* Done */
break;
}
/* Excessive delay */
if (w >= 100) break;
- /* Delay */
Term_xtra(TERM_XTRA_DELAY, w);
}
}
- /* Done */
break;
}
{
/* Strip this key */
ch = 0;
-
- /* Continue */
continue;
}
* Note that "quark zero" is NULL and should not be "dereferenced".
*/
-/*
- * Initialize the quark array
- */
+ /*
+ * Initialize the quark array
+ */
void quark_init(void)
{
/* Quark variables */
- C_MAKE(quark__str, QUARK_MAX, cptr);
+ C_MAKE(quark__str, QUARK_MAX, concptr);
/* Prepare first quark, which is used when quark_add() is failed */
quark__str[1] = string_make("");
/*
* Add a new "quark" to the set of quarks.
*/
-s16b quark_add(cptr str)
+u16b quark_add(concptr str)
{
- int i;
+ u16b i;
/* Look for an existing quark */
for (i = 1; i < quark__num; i++)
/*
* This function looks up a quark
*/
-cptr quark_str(s16b i)
+concptr quark_str(STR_OFFSET i)
{
- cptr q;
+ concptr q;
/* Return NULL for an invalid index */
if ((i < 1) || (i >= quark__num)) return NULL;
-/*
- * How many messages are "available"?
- */
-s16b message_num(void)
+ /*!
+ * @brief 保存中の過去ゲームメッセージの数を返す。 / How many messages are "available"?
+ * @return 残っているメッセージの数
+ */
+s32b message_num(void)
{
int last, next, n;
}
-
-/*
- * Recall the "text" of a saved message
+/*!
+ * @brief 過去のゲームメッセージを返す。 / Recall the "text" of a saved message
+ * @params age メッセージの世代
+ * @return メッセージの文字列ポインタ
*/
-cptr message_str(int age)
+concptr message_str(int age)
{
- s16b x;
- s16b o;
- cptr s;
+ s32b x;
+ s32b o;
+ concptr s;
/* Forgotten messages have no text */
if ((age < 0) || (age >= message_num())) return ("");
}
-
-/*
- * Add a new message, with great efficiency
+/*!
+ * @brief ゲームメッセージをログに追加する。 / Add a new message, with great efficiency
+ * @params str 保存したいメッセージ
+ * @return なし
*/
-void message_add(cptr str)
+void message_add(concptr str)
{
- int i, k, x, m, n;
+ u32b i, n;
+ int k, x, m;
- char u[1024];
+ char u[4096];
char splitted1[81];
- cptr splitted2;
+ concptr splitted2;
/*** Step 1 -- Analyze the message ***/
/* Important Hack -- Ignore "long" messages */
if (n >= MESSAGE_BUF / 4) return;
- /* extra step -- split the message if n>80. (added by Mogami) */
+ /* extra step -- split the message if n>80.(added by Mogami) */
if (n > 80) {
#ifdef JP
- cptr t = str;
-
- for (n = 0; n < 80; n++, t++)
- if(iskanji(*t)) {
- t++;
- n++;
- }
- if (n == 81) n = 79; /* ºÇ¸å¤Îʸ»ú¤¬´Á»úȾʬ */
+ concptr t = str;
+
+ for (n = 0; n < 80; n++, t++)
+ {
+ if (iskanji(*t)) {
+ t++;
+ n++;
+ }
+ }
+ if (n == 81) n = 79; /* 最後の文字が漢字半分 */
#else
- for (n = 80; n > 60; n--)
- if (str[n] == ' ') break;
- if (n == 60)
- n = 80;
+ for (n = 80; n > 60; n--)
+ if (str[n] == ' ') break;
+ if (n == 60) n = 80;
#endif
- splitted2 = str + n;
- strncpy(splitted1, str ,n);
- splitted1[n] = '\0';
- str = splitted1;
- } else {
- splitted2 = NULL;
+ splitted2 = str + n;
+ strncpy(splitted1, str, n);
+ splitted1[n] = '\0';
+ str = splitted1;
+ }
+ else {
+ splitted2 = NULL;
}
- /*** Step 2 -- Attempt to optimize ***/
+ /*** Step 2 -- 最適化の試行 / Attempt to optimize ***/
/* Limit number of messages to check */
m = message_num();
-
k = m / 4;
-
- /* Limit number of messages to check */
if (k > MESSAGE_MAX / 32) k = MESSAGE_MAX / 32;
/* Check previous message */
char buf[1024];
char *t;
- cptr old;
+ concptr old;
/* Back up and wrap if needed */
if (i-- == 0) i = MESSAGE_MAX - 1;
/* Find multiple */
#ifdef JP
- for (t = buf; *t && (*t != '<' || (*(t+1) != 'x' )); t++)
- if( iskanji(*t))t++;
+ for (t = buf; *t && (*t != '<' || (*(t + 1) != 'x')); t++)
+ if (iskanji(*t))t++;
#else
for (t = buf; *t && (*t != '<'); t++);
#endif
if (*t)
{
/* Message is too small */
- if (strlen(buf) < 6) break;
+ if (strlen(buf) < A_MAX) break;
/* Drop the space */
*(t - 1) = '\0';
/* Get multiplier */
- j = atoi(t+2);
+ j = atoi(t + 2);
}
/* Limit the multiplier to 1000 */
}
else
{
- num_more++;/*ή¤ì¤¿¹Ô¤Î¿ô¤ò¿ô¤¨¤Æ¤ª¤¯ */
+ num_more++;/*流れた行の数を数えておく */
now_message++;
}
- /* Done */
break;
}
/* Check the last few messages (if any to count) */
for (i = message__next; k; k--)
{
- u16b q;
-
- cptr old;
+ int q;
+ concptr old;
/* Back up and wrap if needed */
if (i-- == 0) i = MESSAGE_MAX - 1;
message__tail = message__head + n + 1;
/* Advance tail while possible past first "nul" */
- while (message__buf[message__tail-1]) message__tail++;
+ while (message__buf[message__tail - 1]) message__tail++;
/* Kill all "dead" messages */
for (i = message__last; TRUE; i++)
message__head += n + 1;
/* recursively add splitted message (added by Mogami) */
- end_of_message_add:
+end_of_message_add:
if (splitted2 != NULL)
- message_add(splitted2);
+ message_add(splitted2);
}
/*
* Hack -- flush
*/
-static void msg_flush(int x)
+static void msg_flush(player_type *player_ptr, int x)
{
byte a = TERM_L_BLUE;
bool nagasu = FALSE;
- if ((auto_more && !now_damaged) || num_more < 0){
+ if ((auto_more && !player_ptr->now_damaged) || num_more < 0) {
int i;
for (i = 0; i < 8; i++)
{
nagasu = TRUE;
}
}
- now_damaged = FALSE;
- if (!p_ptr->playing || !nagasu)
+ player_ptr->now_damaged = FALSE;
+
+ if (!player_ptr->playing || !nagasu)
{
/* Pause for response */
-#ifdef JP
- Term_putstr(x, 0, -1, a, "-³¤¯-");
-#else
- Term_putstr(x, 0, -1, a, "-more-");
-#endif
-
+ Term_putstr(x, 0, -1, a, _("-続く-", "-more-"));
/* Get an acceptable keypress */
- while (1)
+ while (TRUE)
{
int cmd = inkey();
if (cmd == ESCAPE) {
- num_more = -9999; /*auto_more¤Î¤È¤¡¢Á´¤Æή¤¹¡£ */
- break;
- } else if (cmd == ' ') {
- num_more = 0; /*£±²èÌ̤À¤±Î®¤¹¡£ */
- break;
- } else if ((cmd == '\n') || (cmd == '\r')) {
- num_more--; /*£±¹Ô¤À¤±Î®¤¹¡£ */
- break;
+ num_more = -9999; /*auto_moreのとき、全て流す。 */
+ break;
+ }
+ else if (cmd == ' ') {
+ num_more = 0; /*１画面だけ流す。 */
+ break;
+ }
+ else if ((cmd == '\n') || (cmd == '\r')) {
+ num_more--; /*１行だけ流す。 */
+ break;
}
if (quick_messages) break;
bell();
}
+void msg_erase(void)
+{
+ msg_print(NULL);
+}
+
+
/*
* Output a message to the top line of the screen.
*
* The global "msg_flag" variable can be cleared to tell us to
* "erase" any "pending" messages still on the screen.
*
- * XXX XXX XXX Note that we must be very careful about using the
+ * Note that we must be very careful about using the
* "msg_print()" functions without explicitly calling the special
* "msg_print(NULL)" function, since this may result in the loss
* of information if the screen is cleared, or if anything is
* displayed on the top line.
*
- * XXX XXX XXX Note that "msg_print(NULL)" will clear the top line
+ * Note that "msg_print(NULL)" will clear the top line
* even if no messages are pending. This is probably a hack.
*/
-void msg_print(cptr msg)
+void msg_print(concptr msg)
{
static int p = 0;
-
int n;
-
char *t;
-
char buf[1024];
- if (world_monster) return;
+ if (current_world_ptr->timewalk_m_idx) return;
/* Hack -- Reset */
if (!msg_flag) {
p = 0;
}
- /* Message Length */
+ /* Original Message Length */
n = (msg ? strlen(msg) : 0);
/* Hack -- flush when requested or needed */
if (p && (!msg || ((p + n) > 72)))
{
- /* Flush */
- msg_flush(p);
+ msg_flush(p_ptr, p);
/* Forget it */
msg_flag = FALSE;
p = 0;
}
-
/* No message */
if (!msg) return;
-
- /* Paranoia */
if (n > 1000) return;
+ /* Copy it */
+ if (!cheat_turn)
+ {
+ strcpy(buf, msg);
+ }
+ else
+ {
+ sprintf(buf, ("T:%d - %s"), (int)current_world_ptr->game_turn, msg);
+ }
- /* Memorize the message */
- if (character_generated) message_add(msg);
-
+ /* New Message Length */
+ n = strlen(buf);
- /* Copy it */
- strcpy(buf, msg);
+ /* Memorize the message */
+ if (current_world_ptr->character_generated) message_add(buf);
/* Analyze the buffer */
t = buf;
Term_putstr(0, 0, split, TERM_WHITE, t);
/* Flush it */
- msg_flush(split + 1);
+ msg_flush(p_ptr, split + 1);
/* Memorize the piece */
- /* if (character_generated) message_add(t); */
+ /* if (current_world_ptr->character_generated) message_add(t); */
/* Restore the split character */
t[split] = oops;
t += split; n -= split;
}
-
/* Display the tail of the message */
Term_putstr(p, 0, n, TERM_WHITE, t);
/* Memorize the tail */
- /* if (character_generated) message_add(t); */
+ /* if (current_world_ptr->character_generated) message_add(t); */
- /* Window stuff */
p_ptr->window |= (PW_MESSAGE);
- window_stuff();
+ update_output(p_ptr);
/* Remember the message */
msg_flag = TRUE;
p += n + 1;
#endif
-
/* Optional refresh */
if (fresh_message) Term_fresh();
}
+void msg_print_wizard(int cheat_type, concptr msg)
+{
+ if (!cheat_room && cheat_type == CHEAT_DUNGEON) return;
+ if (!cheat_peek && cheat_type == CHEAT_OBJECT) return;
+ if (!cheat_hear && cheat_type == CHEAT_MONSTER) return;
+ if (!cheat_xtra && cheat_type == CHEAT_MISC) return;
+
+ concptr cheat_mes[] = { "ITEM", "MONS", "DUNG", "MISC" };
+ char buf[1024];
+ sprintf(buf, "WIZ-%s:%s", cheat_mes[cheat_type], msg);
+ msg_print(buf);
+
+ if (cheat_diary_output)
+ {
+ exe_write_diary(p_ptr, DIARY_WIZARD_LOG, 0, buf);
+ }
+
+}
+
+
/*
* Hack -- prevent "accidents" in "screen_save()" or "screen_load()"
*/
*
* This function must match exactly one call to "screen_load()".
*/
-void screen_save(void)
+void screen_save()
{
/* Hack -- Flush messages */
msg_print(NULL);
if (screen_depth++ == 0) Term_save();
/* Increase "icky" depth */
- character_icky++;
+ current_world_ptr->character_icky++;
}
*
* This function must match exactly one call to "screen_save()".
*/
-void screen_load(void)
+void screen_load()
{
/* Hack -- Flush messages */
msg_print(NULL);
if (--screen_depth == 0) Term_load();
/* Decrease "icky" depth */
- character_icky--;
+ current_world_ptr->character_icky--;
}
/*
* Display a formatted message, using "vstrnfmt()" and "msg_print()".
*/
-void msg_format(cptr fmt, ...)
+void msg_format(concptr fmt, ...)
{
va_list vp;
msg_print(buf);
}
+/*
+ * Display a formatted message, using "vstrnfmt()" and "msg_print()".
+ */
+void msg_format_wizard(int cheat_type, concptr fmt, ...)
+{
+ if (!cheat_room && cheat_type == CHEAT_DUNGEON) return;
+ if (!cheat_peek && cheat_type == CHEAT_OBJECT) return;
+ if (!cheat_hear && cheat_type == CHEAT_MONSTER) return;
+ if (!cheat_xtra && cheat_type == CHEAT_MISC) return;
+
+ va_list vp;
+ char buf[1024];
+
+ /* Begin the Varargs Stuff */
+ va_start(vp, fmt);
+
+ /* Format the args, save the length */
+ (void)vstrnfmt(buf, 1024, fmt, vp);
+
+ /* End the Varargs Stuff */
+ va_end(vp);
+
+ /* Display */
+ msg_print_wizard(cheat_type, buf);
+}
/*
* At the given location, using the given attribute, if allowed,
* add the given string. Do not clear the line.
*/
-void c_put_str(byte attr, cptr str, int row, int col)
+void c_put_str(TERM_COLOR attr, concptr str, TERM_LEN row, TERM_LEN col)
{
/* Position cursor, Dump the attr/text */
Term_putstr(col, row, -1, attr, str);
/*
* As above, but in "white"
*/
-void put_str(cptr str, int row, int col)
+void put_str(concptr str, TERM_LEN row, TERM_LEN col)
{
/* Spawn */
Term_putstr(col, row, -1, TERM_WHITE, str);
* Display a string on the screen using an attribute, and clear
* to the end of the line.
*/
-void c_prt(byte attr, cptr str, int row, int col)
+void c_prt(TERM_COLOR attr, concptr str, TERM_LEN row, TERM_LEN col)
{
/* Clear line, position cursor */
Term_erase(col, row, 255);
/*
* As above, but in "white"
*/
-void prt(cptr str, int row, int col)
+void prt(concptr str, TERM_LEN row, TERM_LEN col)
{
/* Spawn */
c_prt(TERM_WHITE, str, row, col);
* This function will correctly handle any width up to the maximum legal
* value of 256, though it works best for a standard 80 character width.
*/
-void c_roff(byte a, cptr str)
+void c_roff(TERM_COLOR a, concptr str)
{
int x, y;
int w, h;
- cptr s;
+ concptr s;
/* Obtain the size */
(void)Term_get_size(&w, &h);
(void)Term_locate(&x, &y);
/* Hack -- No more space */
- if( y == h - 1 && x > w - 3) return;
+ if (y == h - 1 && x > w - 3) return;
/* Process the string */
for (s = str; *s; s++)
y++;
/* No more space */
- if( y == h ) break;
+ if (y == h) break;
/* Clear line, move cursor */
Term_erase(x, y, 255);
/* Clean up the char */
#ifdef JP
- ch = ((isprint(*s) || k_flag) ? *s : ' ');
+ ch = ((k_flag || isprint(*s)) ? *s : ' ');
#else
ch = (isprint(*s) ? *s : ' ');
#endif
/* Wrap words as needed */
#ifdef JP
- if (( x >= ( (k_flag) ? w - 2 : w - 1 ) ) && (ch != ' '))
+ if ((x >= ((k_flag) ? w - 2 : w - 1)) && (ch != ' '))
#else
if ((x >= w - 1) && (ch != ' '))
#endif
{
int i, n = 0;
- byte av[256];
+ TERM_COLOR av[256];
char cv[256];
/* Wrap word */
if (x < w)
#ifdef JP
{
- /* ¸½ºß¤¬È¾³Ñʸ»ú¤Î¾ì¹ç */
- if( !k_flag )
+ /* 現在が半角文字の場合 */
+ if (!k_flag)
#endif
- {
- /* Scan existing text */
- for (i = w - 2; i >= 0; i--)
{
- /* Grab existing attr/char */
- Term_what(i, y, &av[i], &cv[i]);
+ /* Scan existing text */
+ for (i = w - 2; i >= 0; i--)
+ {
+ /* Grab existing attr/char */
+ Term_what(i, y, &av[i], &cv[i]);
- /* Break on space */
- if (cv[i] == ' ') break;
+ /* Break on space */
+ if (cv[i] == ' ') break;
- /* Track current word */
- n = i;
+ /* Track current word */
+ n = i;
#ifdef JP
- if (cv[i] == '(') break;
+ if (cv[i] == '(') break;
#endif
+ }
}
- }
#ifdef JP
- else
- {
- /* ¸½ºß¤¬Á´³Ñʸ»ú¤Î¤È¤ */
- /* ʸƬ¤¬¡Ö¡£¡×¡Ö¡¢¡×Åù¤Ë¤Ê¤ë¤È¤¤Ï¡¢¤½¤Î£±¤ÄÁ°¤Î¸ì¤Ç²þ¹Ô */
- if (strncmp(s, "¡£", 2) == 0 || strncmp(s, "¡¢", 2) == 0
-#if 0 /* °ìÈÌŪ¤Ë¤Ï¡Ö¥£¡×¡Ö¡¼¡×¤Ï¶Ø§¤ÎÂоݳ° */
- || strncmp(s, "¥£", 2) == 0 || strncmp(s, "¡¼", 2) == 0
-#endif
- ){
- Term_what(x , y, &av[x ], &cv[x ]);
- Term_what(x-1, y, &av[x-1], &cv[x-1]);
- Term_what(x-2, y, &av[x-2], &cv[x-2]);
- n = x - 2;
- cv[ x ] = '\0';
+ else
+ {
+ /* 現在が全角文字のとき */
+ /* 文頭が「。」「、」等になるときは、その１つ前の語で改行 */
+ if (strncmp(s, "。", 2) == 0 || strncmp(s, "、", 2) == 0)
+ {
+ Term_what(x, y, &av[x], &cv[x]);
+ Term_what(x - 1, y, &av[x - 1], &cv[x - 1]);
+ Term_what(x - 2, y, &av[x - 2], &cv[x - 2]);
+ n = x - 2;
+ cv[x] = '\0';
+ }
}
}
- }
#endif
/* Special case */
if (n == 0) n = w;
y++;
/* No more space */
- if( y == h ) break;
+ if (y == h) break;
/* Clear line, move cursor */
Term_erase(x, y, 255);
for (i = n; i < w - 1; i++)
{
#ifdef JP
- if( cv[i] == '\0' ) break;
+ if (cv[i] == '\0') break;
#endif
/* Dump */
Term_addch(av[i], cv[i]);
/* Dump */
#ifdef JP
- Term_addch((byte)(a|0x10), ch);
+ Term_addch((byte)(a | 0x10), ch);
#else
Term_addch(a, ch);
#endif
s++;
x++;
ch = *s;
- Term_addch((byte)(a|0x20), ch);
+ Term_addch((byte)(a | 0x20), ch);
}
#endif
/* Advance */
/*
* As above, but in "white"
*/
-void roff(cptr str)
+void roff(concptr str)
{
/* Spawn */
c_roff(TERM_WHITE, str);
if (iskanji(buf[i])) next_pos++;
#endif
- /* Is there the cursor at next position? */
+ /* Is there the cursor at next position? */
if (next_pos >= pos) break;
/* Move to next */
if (iskanji(buf[i])) next_pos++;
#endif
- /* Is there the cursor at next position? */
+ /* Is there the cursor at next position? */
if (next_pos >= pos) break;
/* Move to next */
*
* We clear the input, and return FALSE, on "ESCAPE".
*/
-bool get_string(cptr prompt, char *buf, int len)
+bool get_string(concptr prompt, char *buf, int len)
{
bool res;
-
- /* Paranoia XXX XXX XXX */
msg_print(NULL);
/* Display prompt */
/* Clear prompt */
prt("", 0, 0);
-
- /* Result */
return (res);
}
*
* Note that "[y/n]" is appended to the prompt.
*/
-bool get_check(cptr prompt)
+bool get_check(concptr prompt)
{
return get_check_strict(prompt, 0);
}
* mode & CHECK_NO_HISTORY : no message_add
* mode & CHECK_DEFAULT_Y : accept any key as y, except n and Esc.
*/
-bool get_check_strict(cptr prompt, int mode)
+bool get_check_strict(concptr prompt, BIT_FLAGS mode)
{
int i;
char buf[80];
if (auto_more)
{
p_ptr->window |= PW_MESSAGE;
- window_stuff();
+ handle_stuff(p_ptr);
num_more = 0;
}
- /* Paranoia XXX XXX XXX */
msg_print(NULL);
if (!rogue_like_commands)
mode &= ~CHECK_OKAY_CANCEL;
-
/* Hack -- Build a "useful" prompt */
if (mode & CHECK_OKAY_CANCEL)
{
- my_strcpy(buf, prompt, sizeof(buf)-15);
+ my_strcpy(buf, prompt, sizeof(buf) - 15);
strcat(buf, "[(O)k/(C)ancel]");
}
else if (mode & CHECK_DEFAULT_Y)
{
- my_strcpy(buf, prompt, sizeof(buf)-5);
+ my_strcpy(buf, prompt, sizeof(buf) - 5);
strcat(buf, "[Y/n]");
}
else
{
- my_strcpy(buf, prompt, sizeof(buf)-5);
+ my_strcpy(buf, prompt, sizeof(buf) - 5);
strcat(buf, "[y/n]");
}
/* HACK : Add the line to message buffer */
message_add(buf);
p_ptr->window |= (PW_MESSAGE);
- window_stuff();
+ handle_stuff(p_ptr);
}
/* Get an acceptable answer */
*
* Returns TRUE unless the character is "Escape"
*/
-bool get_com(cptr prompt, char *command, bool z_escape)
+bool get_com(concptr prompt, char *command, bool z_escape)
{
- /* Paranoia XXX XXX XXX */
msg_print(NULL);
/* Display a prompt */
/* Get a key */
if (get_com_no_macros)
- *command = inkey_special(FALSE);
+ *command = (char)inkey_special(FALSE);
else
*command = inkey();
prt("", 0, 0);
/* Handle "cancel" */
- if (*command == ESCAPE) return (FALSE);
- if (z_escape && ((*command == 'z') || (*command == 'Z'))) return (FALSE);
+ if (*command == ESCAPE) return FALSE;
+ if (z_escape && ((*command == 'z') || (*command == 'Z'))) return FALSE;
/* Success */
- return (TRUE);
+ return TRUE;
}
*
* Hack -- allow "command_arg" to specify a quantity
*/
-s16b get_quantity(cptr prompt, int max)
+QUANTITY get_quantity(concptr prompt, QUANTITY max)
{
- bool res;
- int amt;
+ bool res, result;
+ QUANTITY amt;
char tmp[80];
char buf[80];
+ COMMAND_CODE code;
/* Use "command_arg" */
return (amt);
}
-#ifdef ALLOW_REPEAT /* TNB */
-
/* Get the item index */
- if ((max != 1) && repeat_pull(&amt))
+ result = repeat_pull(&code);
+ amt = (QUANTITY)code;
+ if ((max != 1) && result)
{
/* Enforce the maximum */
if (amt > max) amt = max;
return (amt);
}
-#endif /* ALLOW_REPEAT -- TNB */
-
/* Build a prompt if needed */
if (!prompt)
{
- /* Build a prompt */
-#ifdef JP
- sprintf(tmp, "¤¤¤¯¤Ä¤Ç¤¹¤« (1-%d): ", max);
-#else
- sprintf(tmp, "Quantity (1-%d): ", max);
-#endif
-
+ sprintf(tmp, _("いくつですか (1-%d): ", "Quantity (1-%d): "), max);
/* Use that prompt */
prompt = tmp;
}
-
- /* Paranoia XXX XXX XXX */
msg_print(NULL);
/* Display prompt */
if (!res) return 0;
/* Extract a number */
- amt = atoi(buf);
+ amt = (COMMAND_CODE)atoi(buf);
/* A letter means "all" */
if (isalpha(buf[0])) amt = max;
/* Enforce the minimum */
if (amt < 0) amt = 0;
-#ifdef ALLOW_REPEAT /* TNB */
-
- if (amt) repeat_push(amt);
-
-#endif /* ALLOW_REPEAT -- TNB */
+ if (amt) repeat_push((COMMAND_CODE)amt);
/* Return the result */
return (amt);
/*
- * Pause for user response XXX XXX XXX
+ * Pause for user response
*/
void pause_line(int row)
{
prt("", row, 0);
-#ifdef JP
- put_str("[ ²¿¤«¥¡¼¤ò²¡¤·¤Æ²¼¤µ¤¤ ]", row, 26);
-#else
- put_str("[Press any key to continue]", row, 23);
-#endif
+ put_str(_("[ 何かキーを押して下さい ]", "[Press any key to continue]"), row, _(26, 23));
(void)inkey();
prt("", row, 0);
typedef struct
{
- cptr name;
+ concptr name;
byte cmd;
bool fin;
} menu_naiyou;
menu_naiyou menu_info[10][10] =
{
{
- {"ËâË¡/ÆüìǽÎÏ", 1, FALSE},
- {"¹ÔÆ°", 2, FALSE},
- {"Æ»¶ñ(»ÈÍÑ)", 3, FALSE},
- {"Æ»¶ñ(¤½¤Î¾)", 4, FALSE},
- {"ÁõÈ÷", 5, FALSE},
- {"Èâ/È¢", 6, FALSE},
- {"¾ðÊó", 7, FALSE},
- {"ÀßÄê", 8, FALSE},
- {"¤½¤Î¾", 9, FALSE},
+ {"魔法/特殊能力", 1, FALSE},
+ {"行動", 2, FALSE},
+ {"道具(使用)", 3, FALSE},
+ {"道具(その他)", 4, FALSE},
+ {"装備", 5, FALSE},
+ {"扉/箱", 6, FALSE},
+ {"情報", 7, FALSE},
+ {"設定", 8, FALSE},
+ {"その他", 9, FALSE},
{"", 0, FALSE},
},
{
- {"»È¤¦(m)", 'm', TRUE},
- {"Ä´¤Ù¤ë(b/P)", 'b', TRUE},
- {"³Ð¤¨¤ë(G)", 'G', TRUE},
- {"ÆüìǽÎϤò»È¤¦(U/O)", 'U', TRUE},
+ {"使う(m)", 'm', TRUE},
+ {"調べる(b/P)", 'b', TRUE},
+ {"覚える(G)", 'G', TRUE},
+ {"特殊能力を使う(U/O)", 'U', TRUE},
{"", 0, FALSE},
{"", 0, FALSE},
{"", 0, FALSE},
},
{
- {"µÙ©¤¹¤ë(R)", 'R', TRUE},
- {"¥È¥é¥Ã¥×²ò½ü(D)", 'D', TRUE},
- {"õ¤¹(s)", 's', TRUE},
- {"¼þ¤ê¤òÄ´¤Ù¤ë(l/x)", 'l', TRUE},
- {"¥¿¡¼¥²¥Ã¥È»ØÄê(*)", '*', TRUE},
- {"·ê¤ò·¡¤ë(T/^t)", 'T', TRUE},
- {"³¬Ãʤò¾å¤ë(<)", '<', TRUE},
- {"³¬Ãʤò²¼¤ê¤ë(>)", '>', TRUE},
- {"¥Ú¥Ã¥È¤ËÌ¿Î᤹¤ë(p)", 'p', TRUE},
- {"õº÷¥â¡¼¥É¤ÎON/OFF(S/#)", 'S', TRUE}
+ {"休息する(R)", 'R', TRUE},
+ {"トラップ解除(D)", 'D', TRUE},
+ {"探す(s)", 's', TRUE},
+ {"周りを調べる(l/x)", 'l', TRUE},
+ {"ターゲット指定(*)", '*', TRUE},
+ {"穴を掘る(T/^t)", 'T', TRUE},
+ {"階段を上る(<)", '<', TRUE},
+ {"階段を下りる(>)", '>', TRUE},
+ {"ペットに命令する(p)", 'p', TRUE},
+ {"探索モードのON/OFF(S/#)", 'S', TRUE}
},
{
- {"Æɤà(r)", 'r', TRUE},
- {"°û¤à(q)", 'q', TRUE},
- {"¾ó¤ò»È¤¦(u/Z)", 'u', TRUE},
- {"ËâË¡ËÀ¤ÇÁÀ¤¦(a/z)", 'a', TRUE},
- {"¥í¥Ã¥É¤ò¿¶¤ë(z/a)", 'z', TRUE},
- {"»ÏÆ°¤¹¤ë(A)", 'A', TRUE},
- {"¿©¤Ù¤ë(E)", 'E', TRUE},
- {"Èô¤ÓÆ»¶ñ¤Ç·â¤Ä(f/t)", 'f', TRUE},
- {"Åꤲ¤ë(v)", 'v', TRUE},
+ {"読む(r)", 'r', TRUE},
+ {"飲む(q)", 'q', TRUE},
+ {"杖を使う(u/Z)", 'u', TRUE},
+ {"魔法棒で狙う(a/z)", 'a', TRUE},
+ {"ロッドを振る(z/a)", 'z', TRUE},
+ {"始動する(A)", 'A', TRUE},
+ {"食べる(E)", 'E', TRUE},
+ {"飛び道具で撃つ(f/t)", 'f', TRUE},
+ {"投げる(v)", 'v', TRUE},
{"", 0, FALSE}
},
{
- {"½¦¤¦(g)", 'g', TRUE},
- {"Íî¤È¤¹(d)", 'd', TRUE},
- {"²õ¤¹(k/^d)", 'k', TRUE},
- {"Ìäò¹ï¤à({)", '{', TRUE},
- {"Ìäò¾Ã¤¹(})", '}', TRUE},
- {"Ä´ºº(I)", 'I', TRUE},
- {"¥¢¥¤¥Æ¥à°ìÍ÷(i)", 'i', TRUE},
+ {"拾う(g)", 'g', TRUE},
+ {"落とす(d)", 'd', TRUE},
+ {"壊す(k/^d)", 'k', TRUE},
+ {"銘を刻む({)", '{', TRUE},
+ {"銘を消す(})", '}', TRUE},
+ {"調査(I)", 'I', TRUE},
+ {"アイテム一覧(i)", 'i', TRUE},
{"", 0, FALSE},
{"", 0, FALSE},
{"", 0, FALSE}
},
{
- {"ÁõÈ÷¤¹¤ë(w)", 'w', TRUE},
- {"ÁõÈ÷¤ò³°¤¹(t/T)", 't', TRUE},
- {"dzÎÁ¤òÊäµë(F)", 'F', TRUE},
- {"ÁõÈ÷°ìÍ÷(e)", 'e', TRUE},
+ {"装備する(w)", 'w', TRUE},
+ {"装備を外す(t/T)", 't', TRUE},
+ {"燃料を補給(F)", 'F', TRUE},
+ {"装備一覧(e)", 'e', TRUE},
{"", 0, FALSE},
{"", 0, FALSE},
{"", 0, FALSE},
},
{
- {"³«¤±¤ë(o)", 'o', TRUE},
- {"ÊĤ¸¤ë(c)", 'c', TRUE},
- {"ÂÎÅö¤¿¤ê¤¹¤ë(B/f)", 'B', TRUE},
- {"¤¯¤µ¤Ó¤òÂǤÄ(j/S)", 'j', TRUE},
+ {"開ける(o)", 'o', TRUE},
+ {"閉じる(c)", 'c', TRUE},
+ {"体当たりする(B/f)", 'B', TRUE},
+ {"くさびを打つ(j/S)", 'j', TRUE},
{"", 0, FALSE},
{"", 0, FALSE},
{"", 0, FALSE},
},
{
- {"¥À¥ó¥¸¥ç¥ó¤ÎÁ´ÂοÞ(M)", 'M', TRUE},
- {"°ÌÃÖ¤ò³Îǧ(L/W)", 'L', TRUE},
- {"³¬¤ÎÊ·°Ïµ¤(^f)", KTRL('F'), TRUE},
- {"¥¹¥Æ¡¼¥¿¥¹(C)", 'C', TRUE},
- {"ʸ»ú¤ÎÀâÌÀ(/)", '/', TRUE},
- {"¥á¥Ã¥»¡¼¥¸ÍúÎò(^p)", KTRL('P'), TRUE},
- {"¸½ºß¤Î»þ¹ï(^t/')", KTRL('T'), TRUE},
- {"¸½ºß¤ÎÃμ±(~)", '~', TRUE},
- {"¥×¥ì¥¤µÏ¿(|)", '|', TRUE},
+ {"ダンジョンの全体図(M)", 'M', TRUE},
+ {"位置を確認(L/W)", 'L', TRUE},
+ {"階の雰囲気(^f)", KTRL('F'), TRUE},
+ {"ã\82¹ã\83\86ã\83¼ã\82¿ã\82¹(C)", 'C', TRUE},
+ {"文字の説明(/)", '/', TRUE},
+ {"メッセージ履歴(^p)", KTRL('P'), TRUE},
+ {"現在の時刻(^t/')", KTRL('T'), TRUE},
+ {"現在の知識(~)", '~', TRUE},
+ {"プレイ記録(|)", '|', TRUE},
{"", 0, FALSE}
},
{
- {"¥ª¥×¥·¥ç¥ó(=)", '=', TRUE},
- {"¥Þ¥¯¥í(@)", '@', TRUE},
- {"²èÌÌɽ¼¨(%)", '%', TRUE},
- {"¥«¥é¡¼(&)", '&', TRUE},
- {"ÀßÄêÊѹ¹¥³¥Þ¥ó¥É(\")", '\"', TRUE},
- {"¼«Æ°½¦¤¤¤ò¥í¡¼¥É($)", '$', TRUE},
- {"¥·¥¹¥Æ¥à(!)", '!', TRUE},
+ {"オプション(=)", '=', TRUE},
+ {"マクロ(@)", '@', TRUE},
+ {"画面表示(%)", '%', TRUE},
+ {"ã\82«ã\83©ã\83¼(&)", '&', TRUE},
+ {"設定変更コマンド(\")", '\"', TRUE},
+ {"自動拾いをロード($)", '$', TRUE},
+ {"システム(!)", '!', TRUE},
{"", 0, FALSE},
{"", 0, FALSE},
{"", 0, FALSE}
},
{
- {"¥»¡¼¥Ö&ÃæÃÇ(^x)", KTRL('X'), TRUE},
- {"¥»¡¼¥Ö(^s)", KTRL('S'), TRUE},
- {"¥Ø¥ë¥×(?)", '?', TRUE},
- {"ºÆÉÁ²è(^r)", KTRL('R'), TRUE},
- {"¥á¥â(:)", ':', TRUE},
- {"µÇ°»£±Æ())", ')', TRUE},
- {"µÇ°»£±Æ¤Îɽ¼¨(()", '(', TRUE},
- {"¥Ð¡¼¥¸¥ç¥ó¾ðÊó(V)", 'V', TRUE},
- {"°úÂह¤ë(Q)", 'Q', TRUE},
+ {"セーブ&中断(^x)", KTRL('X'), TRUE},
+ {"セーブ(^s)", KTRL('S'), TRUE},
+ {"ヘルプ(?)", '?', TRUE},
+ {"再描画(^r)", KTRL('R'), TRUE},
+ {"メモ(:)", ':', TRUE},
+ {"記念撮影())", ')', TRUE},
+ {"記念撮影の表示(()", '(', TRUE},
+ {"バージョン情報(V)", 'V', TRUE},
+ {"引退する(Q)", 'Q', TRUE},
{"", 0, FALSE}
},
};
{"Identify symbol(/)", '/', TRUE},
{"Show prev messages(^p)", KTRL('P'), TRUE},
{"Current time(^t/')", KTRL('T'), TRUE},
- {"Various informations(~)", '~', TRUE},
+ {"Various information(~)", '~', TRUE},
{"Play record menu(|)", '|', TRUE},
{"", 0, FALSE}
},
typedef struct
{
- cptr name;
+ concptr name;
byte window;
byte number;
byte jouken;
#ifdef JP
special_menu_naiyou special_menu_info[] =
{
- {"ĶǽÎÏ/ÆüìǽÎÏ", 0, 0, MENU_CLASS, CLASS_MINDCRAFTER},
- {"¤â¤Î¤Þ¤Í/ÆüìǽÎÏ", 0, 0, MENU_CLASS, CLASS_IMITATOR},
- {"²Î/ÆüìǽÎÏ", 0, 0, MENU_CLASS, CLASS_BARD},
- {"ɬ»¦µ»/ÆüìǽÎÏ", 0, 0, MENU_CLASS, CLASS_SAMURAI},
- {"Îýµ¤½Ñ/ËâË¡/ÆüìǽÎÏ", 0, 0, MENU_CLASS, CLASS_FORCETRAINER},
- {"µ»/ÆüìǽÎÏ", 0, 0, MENU_CLASS, CLASS_BERSERKER},
- {"µ»½Ñ/ÆüìǽÎÏ", 0, 0, MENU_CLASS, CLASS_SMITH},
- {"¶ÀËâË¡/ÆüìǽÎÏ", 0, 0, MENU_CLASS, CLASS_MIRROR_MASTER},
- {"Ǧ½Ñ/ÆüìǽÎÏ", 0, 0, MENU_CLASS, CLASS_NINJA},
- {"¹°è¥Þ¥Ã¥×(<)", 2, 6, MENU_WILD, FALSE},
- {"Ä̾ï¥Þ¥Ã¥×(>)", 2, 7, MENU_WILD, TRUE},
+ {"超能力/特殊能力", 0, 0, MENU_CLASS, CLASS_MINDCRAFTER},
+ {"ものまね/特殊能力", 0, 0, MENU_CLASS, CLASS_IMITATOR},
+ {"歌/特殊能力", 0, 0, MENU_CLASS, CLASS_BARD},
+ {"必殺技/特殊能力", 0, 0, MENU_CLASS, CLASS_SAMURAI},
+ {"練気術/魔法/特殊能力", 0, 0, MENU_CLASS, CLASS_FORCETRAINER},
+ {"技/特殊能力", 0, 0, MENU_CLASS, CLASS_BERSERKER},
+ {"技術/特殊能力", 0, 0, MENU_CLASS, CLASS_SMITH},
+ {"鏡魔法/特殊能力", 0, 0, MENU_CLASS, CLASS_MIRROR_MASTER},
+ {"忍術/特殊能力", 0, 0, MENU_CLASS, CLASS_NINJA},
+ {"広域マップ(<)", 2, 6, MENU_WILD, FALSE},
+ {"通常マップ(>)", 2, 7, MENU_WILD, TRUE},
{"", 0, 0, 0, 0},
};
#else
};
#endif
-static char inkey_from_menu(void)
+static char inkey_from_menu(player_type *player_ptr)
{
char cmd;
int basey, basex;
int menu = 0;
bool kisuu;
- if (py - panel_row_min > 10) basey = 2;
+ if (player_ptr->y - panel_row_min > 10) basey = 2;
else basey = 13;
basex = 15;
screen_save();
- while(1)
+ floor_type* floor_ptr = player_ptr->current_floor_ptr;
+ while (TRUE)
{
int i;
char sub_cmd;
- cptr menu_name;
+ concptr menu_name;
if (!menu) old_num = num;
put_str("+----------------------------------------------------+", basey, basex);
- put_str("| |", basey+1, basex);
- put_str("| |", basey+2, basex);
- put_str("| |", basey+3, basex);
- put_str("| |", basey+4, basex);
- put_str("| |", basey+5, basex);
- put_str("+----------------------------------------------------+", basey+6, basex);
-
- for(i = 0; i < 10; i++)
+ put_str("| |", basey + 1, basex);
+ put_str("| |", basey + 2, basex);
+ put_str("| |", basey + 3, basex);
+ put_str("| |", basey + 4, basex);
+ put_str("| |", basey + 5, basex);
+ put_str("+----------------------------------------------------+", basey + 6, basex);
+
+ for (i = 0; i < 10; i++)
{
int hoge;
if (!menu_info[menu][i].cmd) break;
menu_name = menu_info[menu][i].name;
- for(hoge = 0; ; hoge++)
+ for (hoge = 0; ; hoge++)
{
if (!special_menu_info[hoge].name[0]) break;
if ((menu != special_menu_info[hoge].window) || (i != special_menu_info[hoge].number)) continue;
- switch(special_menu_info[hoge].jouken)
+ switch (special_menu_info[hoge].jouken)
{
case MENU_CLASS:
- if (p_ptr->pclass == special_menu_info[hoge].jouken_naiyou) menu_name = special_menu_info[hoge].name;
+ if (player_ptr->pclass == special_menu_info[hoge].jouken_naiyou) menu_name = special_menu_info[hoge].name;
break;
case MENU_WILD:
- if (!dun_level && !p_ptr->inside_arena && !p_ptr->inside_quest)
+ if (!floor_ptr->dun_level && !floor_ptr->inside_arena && !floor_ptr->inside_quest)
{
- if ((byte)p_ptr->wild_mode == special_menu_info[hoge].jouken_naiyou) menu_name = special_menu_info[hoge].name;
+ if ((byte)player_ptr->wild_mode == special_menu_info[hoge].jouken_naiyou) menu_name = special_menu_info[hoge].name;
}
break;
default:
}
max_num = i;
kisuu = max_num % 2;
-#ifdef JP
- put_str("¡Õ",basey + 1 + num / 2, basex + 2 + (num % 2) * 24);
-#else
- put_str("> ",basey + 1 + num / 2, basex + 2 + (num % 2) * 24);
-#endif
+ put_str(_("》", "> "), basey + 1 + num / 2, basex + 2 + (num % 2) * 24);
/* Place the cursor on the player */
- move_cursor_relative(py, px);
+ move_cursor_relative(player_ptr->y, player_ptr->x);
- /* Get a command */
sub_cmd = inkey();
if ((sub_cmd == ' ') || (sub_cmd == 'x') || (sub_cmd == 'X') || (sub_cmd == '\r') || (sub_cmd == '\n'))
{
/*
* Request a command from the user.
*
- * Sets p_ptr->command_cmd, p_ptr->command_dir, p_ptr->command_rep,
- * p_ptr->command_arg. May modify p_ptr->command_new.
+ * Sets player_ptr->command_cmd, player_ptr->command_dir, player_ptr->command_rep,
+ * player_ptr->command_arg. May modify player_ptr->command_new.
*
* Note that "caret" ("^") is treated specially, and is used to
* allow manual input of control characters. This can be used
* Note that this command is used both in the dungeon and in
* stores, and must be careful to work in both situations.
*
- * Note that "p_ptr->command_new" may not work any more. XXX XXX XXX
+ * Note that "player_ptr->command_new" may not work any more.
*/
-void request_command(int shopping)
+void request_command(player_type *player_ptr, int shopping)
{
int i;
- char cmd;
+ s16b cmd;
int mode;
- cptr act;
+ concptr act;
#ifdef JP
int caretcmd = 0;
/* Get command */
- while (1)
+ while (TRUE)
{
/* Hack -- auto-commands */
if (command_new)
{
- /* Flush messages */
- msg_print(NULL);
+ msg_erase();
/* Use auto-command */
cmd = command_new;
/* Activate "command mode" */
inkey_flag = TRUE;
- /* Get a command */
cmd = inkey();
if (!shopping && command_menu && ((cmd == '\r') || (cmd == '\n') || (cmd == 'x') || (cmd == 'X'))
- && !keymap_act[mode][(byte)(cmd)])
- cmd = inkey_from_menu();
+ && !keymap_act[mode][(byte)(cmd)])
+ cmd = inkey_from_menu(player_ptr);
}
/* Clear top line */
/* Command Count */
if (cmd == '0')
{
- int old_arg = command_arg;
+ COMMAND_ARG old_arg = command_arg;
/* Reset */
command_arg = 0;
/* Begin the input */
-#ifdef JP
- prt("²ó¿ô: ", 0, 0);
-#else
- prt("Count: ", 0, 0);
-#endif
-
+ prt(_("回数: ", "Count: "), 0, 0);
/* Get a command count */
- while (1)
+ while (TRUE)
{
/* Get a new keypress */
cmd = inkey();
command_arg = command_arg / 10;
/* Show current count */
-#ifdef JP
- prt(format("²ó¿ô: %d", command_arg), 0, 0);
-#else
- prt(format("Count: %d", command_arg), 0, 0);
-#endif
-
+ prt(format(_("回数: %d", "Count: %d"), command_arg), 0, 0);
}
/* Actual numeric data */
}
/* Show current count */
-#ifdef JP
- prt(format("²ó¿ô: %d", command_arg), 0, 0);
-#else
- prt(format("Count: %d", command_arg), 0, 0);
-#endif
-
+ prt(format(_("回数: %d", "Count: %d"), command_arg), 0, 0);
}
/* Exit on "unusable" input */
command_arg = 99;
/* Show current count */
-#ifdef JP
- prt(format("²ó¿ô: %d", command_arg), 0, 0);
-#else
- prt(format("Count: %d", command_arg), 0, 0);
-#endif
-
+ prt(format(_("回数: %d", "Count: %d"), command_arg), 0, 0);
}
/* Hack -- Handle "old_arg" */
command_arg = old_arg;
/* Show current count */
-#ifdef JP
-prt(format("²ó¿ô: %d", command_arg), 0, 0);
-#else
- prt(format("Count: %d", command_arg), 0, 0);
-#endif
-
+ prt(format(_("回数: %d", "Count: %d"), command_arg), 0, 0);
}
/* Hack -- white-space means "enter command now" */
if ((cmd == ' ') || (cmd == '\n') || (cmd == '\r'))
{
/* Get a real command */
-#ifdef JP
- if (!get_com("¥³¥Þ¥ó¥É: ", (char *)&cmd, FALSE))
-#else
- if (!get_com("Command: ", (char *)&cmd, FALSE))
-#endif
-
+ if (!get_com(_("コマンド: ", "Command: "), (char *)&cmd, FALSE))
{
/* Clear count */
command_arg = 0;
-
- /* Continue */
continue;
}
}
if (cmd == '\\')
{
/* Get a real command */
-#ifdef JP
- (void)get_com("¥³¥Þ¥ó¥É: ", (char *)&cmd, FALSE);
-#else
- (void)get_com("Command: ", (char *)&cmd, FALSE);
-#endif
-
+ (void)get_com(_("コマンド: ", "Command: "), (char *)&cmd, FALSE);
/* Hack -- bypass keymaps */
if (!inkey_next) inkey_next = "";
if (cmd == '^')
{
/* Get a new command and controlify it */
-#ifdef JP
- if (get_com("CTRL: ", (char *)&cmd, FALSE)) cmd = KTRL(cmd);
-#else
- if (get_com("Control: ", (char *)&cmd, FALSE)) cmd = KTRL(cmd);
-#endif
-
+ if (get_com(_("CTRL: ", "Control: "), (char *)&cmd, FALSE)) cmd = KTRL(cmd);
}
/* Start using the buffer */
inkey_next = request_command_buffer;
-
- /* Continue */
continue;
}
-
- /* Paranoia */
if (!cmd) continue;
/* Use command */
command_cmd = (byte)cmd;
- /* Done */
break;
}
if (always_repeat && (command_arg <= 0))
{
/* Hack -- auto repeat certain commands */
- if (my_strchr("TBDoc+", command_cmd))
+ if (my_strchr("TBDoc+", (char)command_cmd))
{
/* Repeat 99 times */
command_arg = 99;
#ifdef JP
for (i = 0; i < 256; i++)
{
- cptr s;
+ concptr s;
if ((s = keymap_act[mode][i]) != NULL)
{
- if (*s == command_cmd && *(s+1) == 0)
+ if (*s == command_cmd && *(s + 1) == 0)
{
caretcmd = i;
break;
/* Hack -- Scan equipment */
for (i = INVEN_RARM; i < INVEN_TOTAL; i++)
{
- cptr s;
+ concptr s;
- object_type *o_ptr = &inventory[i];
-
- /* Skip non-objects */
+ object_type *o_ptr = &player_ptr->inventory_list[i];
if (!o_ptr->k_idx) continue;
/* No inscription */
{
/* Hack -- Verify command */
-#ifdef JP
- if (!get_check("ËÜÅö¤Ç¤¹¤«? "))
-#else
- if (!get_check("Are you sure? "))
-#endif
-
+ if (!get_check(_("本当ですか? ", "Are you sure? ")))
{
/* Hack -- Use space */
command_cmd = ' ';
case 'I':
case 'O':
case 'U':
- return (TRUE);
- }
-
- return (FALSE);
-}
-
-
-
-#if 0
-
-/*
- * Replace the first instance of "target" in "buf" with "insert"
- * If "insert" is NULL, just remove the first instance of "target"
- * In either case, return TRUE if "target" is found.
- *
- * XXX Could be made more efficient, especially in the
- * case where "insert" is smaller than "target".
- */
-static bool insert_str(char *buf, cptr target, cptr insert)
-{
- int i, len;
- int b_len, t_len, i_len;
-
- /* Attempt to find the target (modify "buf") */
- buf = my_strstr(buf, target);
-
- /* No target found */
- if (!buf) return (FALSE);
-
- /* Be sure we have an insertion string */
- if (!insert) insert = "";
-
- /* Extract some lengths */
- t_len = strlen(target);
- i_len = strlen(insert);
- b_len = strlen(buf);
-
- /* How much "movement" do we need? */
- len = i_len - t_len;
-
- /* We need less space (for insert) */
- if (len < 0)
- {
- for (i = t_len; i < b_len; ++i) buf[i+len] = buf[i];
- }
-
- /* We need more space (for insert) */
- else if (len > 0)
- {
- for (i = b_len-1; i >= t_len; --i) buf[i+len] = buf[i];
+ return TRUE;
}
- /* If movement occured, we need a new terminator */
- if (len) buf[b_len+len] = '\0';
-
- /* Now copy the insertion string */
- for (i = 0; i < i_len; ++i) buf[i] = insert[i];
-
- /* Successful operation */
- return (TRUE);
+ return FALSE;
}
-#endif
-
-
/*
* GH
* Called from cmd4.c and a few other places. Just extracts
}
else
{
- int mode;
- cptr act, s;
+ BIT_FLAGS mode;
+ concptr act, s;
/* Roguelike */
if (rogue_like_commands)
}
}
}
-
- /* Paranoia */
if (d == 5) d = 0;
/* Return direction */
}
-#ifdef ALLOW_REPEAT /* TNB */
-
#define REPEAT_MAX 20
/* Number of chars saved */
static int repeat__idx = 0;
/* Saved "stuff" */
-static int repeat__key[REPEAT_MAX];
+static COMMAND_CODE repeat__key[REPEAT_MAX];
-void repeat_push(int what)
+void repeat_push(COMMAND_CODE what)
{
/* Too many keys */
if (repeat__cnt == REPEAT_MAX) return;
}
-bool repeat_pull(int *what)
+bool repeat_pull(COMMAND_CODE *what)
{
/* All out of keys */
- if (repeat__idx == repeat__cnt) return (FALSE);
+ if (repeat__idx == repeat__cnt) return FALSE;
/* Grab the next key, advance */
*what = repeat__key[repeat__idx++];
/* Success */
- return (TRUE);
+ return TRUE;
}
void repeat_check(void)
{
- int what;
+ COMMAND_CODE what;
/* Ignore some commands */
if (command_cmd == ESCAPE) return;
}
}
-#endif /* ALLOW_REPEAT -- TNB */
-
-
-#ifdef SORT_R_INFO
/*
* Array size for which InsertionSort
#define CUTOFF 4
-/*
- * Exchange two sort-entries
- * (should probably be coded inline
- * for speed increase)
- */
+ /*
+ * Exchange two sort-entries
+ * (should probably be coded inline
+ * for speed increase)
+ */
static void swap(tag_type *a, tag_type *b)
{
tag_type temp;
{
pivot = median3(elements, left, right);
- i = left; j = right -1;
+ i = left; j = right - 1;
while (TRUE)
{
quicksort(elements, 0, number - 1);
}
-#endif /* SORT_R_INFO */
-
-#ifdef SUPPORT_GAMMA
-
/* Table of gamma values */
byte gamma_table[256];
};
-/*
+/*
* Build the gamma table so that floating point isn't needed.
- *
+ *
* Note gamma goes from 0->256. The old value of 100 is now 128.
*/
void build_gamma_table(int gamma)
{
int i, n;
-
+
/*
* value is the current sum.
* diff is the new term to add to the series.
*/
long value, diff;
-
+
/* Hack - convergence is bad in these cases. */
gamma_table[0] = 0;
gamma_table[255] = 255;
-
+
for (i = 1; i < 255; i++)
{
- /*
+ /*
* Initialise the Taylor series
*
* value and diff have been scaled by 256
*/
-
+
n = 1;
value = 256 * 256;
diff = ((long)gamma_helper[i]) * (gamma - 256);
-
+
while (diff)
{
value += diff;
n++;
-
-
+
+
/*
* Use the following identiy to calculate the gamma table.
* exp(x) = 1 + x + x^2/2 + x^3/(2*3) + x^4/(2*3*4) +...
*
* n is the current term number.
- *
+ *
* The gamma_helper array contains a table of
* ln(x/256) * 256
* This is used because a^b = exp(b*ln(a))
*/
diff = (((diff / 256) * gamma_helper[i]) * (gamma - 256)) / (256 * n);
}
-
- /*
+
+ /*
* Store the value in the table so that the
* floating point pow function isn't needed .
*/
}
}
-#endif /* SUPPORT_GAMMA */
-
/*
* Add a series of keypresses to the "queue".
*
* NB: The keys added here will be interpreted by any macros or keymaps.
*/
-errr type_string(cptr str, uint len)
+errr type_string(concptr str, uint len)
{
errr err = 0;
- cptr s;
+ concptr s;
term *old = Term;
/* Activate the main window, as all pastes go there. */
Term_activate(term_screen);
- for (s = str; s < str+len; s++)
+ for (s = str; s < str + len; s++)
{
/* Catch end of string */
if (*s == '\0') break;
-void roff_to_buf(cptr str, int maxlen, char *tbuf, size_t bufsize)
+void roff_to_buf(concptr str, int maxlen, char *tbuf, size_t bufsize)
{
int read_pt = 0;
int write_pt = 0;
ch[0] = str[read_pt];
ch[1] = '\0';
#ifdef JP
- kanji = iskanji(ch[0]);
+ kanji = iskanji(ch[0]);
if (kanji)
{
- ch[1] = str[read_pt+1];
+ ch[1] = str[read_pt + 1];
ch_len = 2;
- if (strcmp(ch, "¡£") == 0 ||
- strcmp(ch, "¡¢") == 0 ||
- strcmp(ch, "¥£") == 0 ||
- strcmp(ch, "¡¼") == 0)
+ if (strcmp(ch, "。") == 0 ||
+ strcmp(ch, "、") == 0 ||
+ strcmp(ch, "ã\82£") == 0 ||
+ strcmp(ch, "ã\83¼") == 0)
kinsoku = TRUE;
}
else if (!isprint(ch[0]))
word_len = read_pt - word_punct;
#ifdef JP
if (kanji && !kinsoku)
- /* nothing */ ;
+ /* nothing */;
else
#endif
- if (ch[0] == ' ' || word_len >= line_len/2)
- read_pt++;
- else
- {
- read_pt = word_punct;
- if (str[word_punct] == ' ')
+ if (ch[0] == ' ' || word_len >= line_len / 2)
read_pt++;
- write_pt -= word_len;
- }
+ else
+ {
+ read_pt = word_punct;
+ if (str[word_punct] == ' ')
+ read_pt++;
+ write_pt -= word_len;
+ }
tbuf[write_pt++] = '\0';
line_len = 0;
#endif
}
tbuf[write_pt] = '\0';
- tbuf[write_pt+1] = '\0';
+ tbuf[write_pt + 1] = '\0';
return;
}
*
* This function should be equivalent to the strlcpy() function in BSD.
*/
-size_t my_strcpy(char *buf, const char *src, size_t bufsize)
+size_t my_strcpy(char *buf, concptr src, size_t bufsize)
{
#ifdef JP
char *d = buf;
- const char *s = src;
+ concptr s = src;
size_t len = 0;
if (bufsize > 0) {
{
if (iskanji(*s))
{
- if (len + 1 >= bufsize || !*(s+1)) break;
+ if (len + 1 >= bufsize || !*(s + 1)) break;
*d++ = *s++;
*d++ = *s++;
len += 2;
*d = '\0';
}
- while(*s++) len++;
+ while (*s++) len++;
return len;
size_t len = strlen(src);
size_t ret = len;
-
- /* Paranoia */
if (bufsize == 0) return ret;
/* Truncate */
*
* This function should be equivalent to the strlcat() function in BSD.
*/
-size_t my_strcat(char *buf, const char *src, size_t bufsize)
+size_t my_strcat(char *buf, concptr src, size_t bufsize)
{
size_t dlen = strlen(buf);
*
* my_strstr() can handle Kanji strings correctly.
*/
-char *my_strstr(const char *haystack, const char *needle)
+char *my_strstr(concptr haystack, concptr needle)
{
int i;
int l1 = strlen(haystack);
if (l1 >= l2)
{
- for(i = 0; i <= l1 - l2; i++)
+ for (i = 0; i <= l1 - l2; i++)
{
- if(!strncmp(haystack + i, needle, l2))
+ if (!strncmp(haystack + i, needle, l2))
return (char *)haystack + i;
#ifdef JP
*
* my_strchr() can handle Kanji strings correctly.
*/
-char *my_strchr(const char *ptr, char ch)
+char *my_strchr(concptr ptr, char ch)
{
- for ( ; *ptr != '\0'; ptr++)
+ for (; *ptr != '\0'; ptr++)
{
if (*ptr == ch) return (char *)ptr;
continue;
}
#endif
- *str = tolower(*str);
+ *str = (char)tolower(*str);
}
}
int inkey_special(bool numpad_cursor)
{
static const struct {
- cptr keyname;
+ concptr keyname;
int keyflag;
} modifier_key_list[] = {
{"shift-", SKEY_MOD_SHIFT},
static const struct {
bool numpad;
- cptr keyname;
+ concptr keyname;
int keycode;
} special_key_list[] = {
{FALSE, "Down]", SKEY_DOWN},
};
static const struct {
- cptr keyname;
+ concptr keyname;
int keycode;
} gcu_special_key_list[] = {
{"A", SKEY_UP},
};
char buf[1024];
- cptr str = buf;
+ concptr str = buf;
char key;
int skey = 0;
int modifier = 0;
for (i = 0; special_key_list[i].keyname; i++)
{
if ((!special_key_list[i].numpad || numpad_cursor) &&
- streq(str, special_key_list[i].keyname))
+ streq(str, special_key_list[i].keyname))
{
skey = special_key_list[i].keycode;
break;
/* Return normal keycode */
return (int)((unsigned char)key);
}
+
OSDN Git Service
