text.c

Go to the documentation of this file.

#include "color.h"
#include "render.h"
#include "text.h"
#include "genconmac.h"
#include "states.h"
#include <SDL_ttf.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <locale.h>
#include <errno.h>

#if defined(USE_GETTEXT) || defined(DOXYGEN)
#include <wchar.h>
#include <iconv.h>
#if !defined(WIN32) || defined(DOXYGEN)

static iconv_t strconvdescr;
static iconv_t strconvntou;
static iconv_t strconvuton;
#endif
#endif

#ifndef TEXT_MAX_LINES

#define TEXT_MAX_LINES  16
#endif

extern char binPath[128];

// Probably should always compile in the English strings. If fwide() determines
// that stdout is not wide, use English output to stdout, but still use wide
// characters for the user's set language for the GUI.

rtsa_char * strings[STRING_MAX];

RenderItem textItems[TEXTITEM_MAX];

static TTF_Font *fonts[FONT_MAX];

static int spaceWidth[FONT_MAX];

static int fontHeight[FONT_MAX];

Bool TextInit() {
    #ifdef USE_GETTEXT
    int loop;
    char *codeset = NULL, *localeDir = NULL, *localeName = NULL;
    // setup the default locale
    localeName = setlocale(LC_ALL, "");
    #ifndef NDEBUG
    // use a non-defulat directory for the translations
    localeDir = bindtextdomain("rtsa", "./locale");
    #endif
    // set the domain using the program's name
    textdomain("rtsa");
    #ifndef WIN32
    // not MS 
    // use the native wide character type for strings returned by gettext()
    codeset = bind_textdomain_codeset("rtsa", "wchar_t");
    // conversion used on strings prior to being given to SDL_ttf
    strconvdescr = iconv_open("UTF-16", "wchar_t");
    // conversion used on strings before being sent over the network
    strconvntou = iconv_open("UTF-16BE", "wchar_t");
    // conversion used on strings received over the network
    strconvuton = iconv_open("wchar_t", "UTF-16BE");
    #else
    // MS Windows
    // endianness must be specified -- some iconv libraries on win32 will
    // default to big-endian
    codeset = bind_textdomain_codeset("rtsa", "UTF-16LE");
    #endif
    #ifndef NDEBUG
    if (localeName) {
        #ifdef WIN32
        prnout(L"Using locale %S\n", localeName);
        #else
        prnout(L"Using locale %s\n", localeName);
        #endif
    }
    if (localeDir) {
        #ifdef WIN32
        prnout(L"Getting translated stings from path: %S\n", localeDir);
        #else
        prnout(L"Getting translated stings from path: %s\n", localeDir);
        #endif
    }

    if (codeset) {
        #ifdef WIN32
        // A printf call here causes a crash. Don't yet understand why.
        prnout(L"Using %S character encoding\n", codeset);
        #else
        prnout(L"Using %s character encoding\n", codeset);
        #endif
    }
    else {
        // This may cuase a crash on Windows.
        prnout(
        L"No character encoding set. Check your enviornment for problems.\n");
    }
    #endif
    #endif
    
    // The label for the red team.
    // This string is not yet used and is included to support future
    // development. It is safe to leave it with the English default value.
    strings[STRING_REDTEAM]      = _("Red team");
    // The label for the blue team.
    // This string is not yet used and is included to support future
    // development. It is safe to leave it with the English default value.
    strings[STRING_BLUETEAM]     = _("Blue team");
    // The announcement that the red team's flag is currently held by a member
    // of the blue team.
    // This string is not yet used and is included to support future
    // development. It is safe to leave it with the English default value.
    strings[STRING_REDFLAGHELD]  = _("Red flag held by blue team");
    // The announcement that the blue team successfully captured the red team's
    // flag.
    // This string is not yet used and is included to support future
    // development. It is safe to leave it with the English default value.
    strings[STRING_REDFLAGCAP]   = _("Blue team scores!");
    // The announcement that the red team has won the game.
    // This string is not yet used and is included to support future
    // development. It is safe to leave it with the English default value.
    strings[STRING_REDWIN]       = _("Red team wins!");
    // The announcement that the blue team's flag is currently held by a member
    // of the red team. 
    // This string is not yet used and is included to support future
    // development. It is safe to leave it with the English default value.
    strings[STRING_BLUEFLAGHELD] = _("Blue flag held by red team");
    // The announcement that the red team successfully captured the blue team's
    // flag.
    // This string is not yet used and is included to support future
    // development. It is safe to leave it with the English default value.
    strings[STRING_BLUEFLAGCAP]  = _("Red team scores!");
    // The announcement that the blue team has won the game.
    // This string is not yet used and is included to support future
    // development. It is safe to leave it with the English default value.
    strings[STRING_BLUEWIN]      = _("Blue team wins!");
    #ifdef USE_GETTEXT
    // A notice that a player (%1$ls) has shot a teammate (%2%ls).
    strings[STRING_TEAMKILL]      = _("%ls shot teammate %ls");
    // A notice that the local player has shot a teammate (%ls).
    strings[STRING_LOCALTEAMKILLER] = _("You shot %ls, a teammate!");
    // A notice that the local player has been shot by a teammate (%ls).
    strings[STRING_LOCALTEAMKILLED] = _("Your teammate %ls shot you!");
    // A notice that a player (%1$ls) has shot an opponent (%2$ls) and now
    // has a personal score of %3$d.
    strings[STRING_KILL]          = _("%ls shot %ls for a score of %d");
    // A notice that the local player has shot an opponent (%1$ls) and now
    // has a personal score of %2$d.
    strings[STRING_LOCALKILL]     = _("You shot %ls, your score is %d");
    #else
    strings[STRING_TEAMKILL]        = "%s shot teammate %s";
    strings[STRING_LOCALTEAMKILLER] = "You shot %s, a teammate!";
    strings[STRING_LOCALTEAMKILLED] = "Your teammate %s shot you!";
    strings[STRING_KILL]            = "%s shot %s for a score of %d";
    strings[STRING_LOCALKILL]       = "You shot %s, your score is %d";
    #endif  
    // A prompt for the user to press fire to make their tank respawn. This
    // message is displayed in the middle of the screen when the player first
    // joins the game and after their tank has been destroyed.
    strings[STRING_RESPAWN]      = _("Press fire to spawn your tank");
    // The game's title. It appears on the title and menu screens, and if
    // visible, the game window's title bar. On systems with older versions
    // of SDL (before 1.2.10), the title bar will always have the English
    // string, but the title and menu screens will have the translated string.
    // If the platform doesn't support UTF/UCS for the title bar, oh well.
    strings[STRING_TITLE]         = _("Retro Tank Super Attack");
    // The author's name and email address.
    strings[STRING_AUTH]          = _("by Jeff Jackowski (jeffj@ro.com)");
    // A message stating who did the translation displayed on the title
    // screen. This string is not displayed when set to the default
    // "translator", as it is for English.
    strings[STRING_TRANS]         = _("translator");
    #ifdef USE_GETTEXT
    // Copyright notice.
    strings[STRING_COPYRIGHT]     = _("Copyright \xC2\xA9 2007");
    #else
    strings[STRING_COPYRIGHT]     = "Copyright \xA9 2007";
    #endif
    // GPL notice. This will display on the title screen at the bottom.
    // The official GPL is only in English, although a number of unofficial
    // translations exist to help everyone understand its terms.
    // The translations are listed at:
    //   http://www.gnu.org/licenses/translations.html
    strings[STRING_GPL] = _( \
    "Retro Tank Super Attack comes with ABSOLUTELY NO WARRANTY. This is free software, and you are welcome to redistribute it under certain conditions as defined by the GPL. For more details, see the GPL at: http://www.gnu.org/copyleft/gpl.html");
    // A prompt for the user to select a team to join.
    strings[STRING_CHOSETEAM]     = _("Chose your team");
    // A prompt for the user to press the fire button for more network play
    // options. Since there are no options yet, it is ok to make this a space
    // to prevent the prompt from being visible.
    strings[STRING_FIREOPT]       = _("Press fire for options");
    // A prompt for the user to press the fire button to continue on to the
    // next screen.
    strings[STRING_FIRECONT]      = _("Press fire to continue");
    // A message informing the user that the game is looking for a server on
    // the LAN.
    strings[STRING_NETLOOKING]    = _("Looking for server . . .");
    // A status message indicating that the game is attempting to contact a
    // server (hostname is %s) and is waiting for a response.
    strings[STRING_NETCONTACT]    = _("Contacting %s");
    // A message telling the user that the game has contacted a server
    // (hostname is %s) and is waiting on game option/config data before the
    // user can join the game in progress.
    strings[STRING_NETRCVCFG]     = _("Connected to %s, awaiting game options");
    // A message telling the user that the game has contacted a server
    // (hostname is %s) and the user can join the game now.
    strings[STRING_NETCLIENT]     = _("Connected to %s");
    // A message informing the user that the game client is disconnecting from
    // the server.
    strings[STRING_NETCLIDISCONN] = _("Disconnecting from server . . .");
    // A status message indicating that the game is running as a server. The
    // machine's hostname, or IP address if the name lookup fails, is %s.
    strings[STRING_NETSERVER]     = _("Running as server %s");
    // A message informing the user that the server is disconnecting all game
    // clients.
    strings[STRING_NETSRVDISCONN] = _("Disconnecting all clients . . .");
    // A message telling the user that the server (hostname %s) will not allow
    // the game client to connect.
    strings[STRING_NETDENY]       = _("Server %s denied the connection");
    // A status message indicating the game has disconnected from the server
    // or all clients.
    strings[STRING_NETDISCONN]    = _("Disconnected");
    #ifdef USE_GETTEXT
    // An error message informing the user that the process of finding a server
    // on the LAN could not be performed. This does not mean that a server
    // could not be found, but that the finding could not be done. The error
    // string is %ls and its translations are in net.c.
    strings[STRING_NETSEARCHERR]  = _("Error prevented server discovery (%ls)");
    // An error message indicating that the game could not run as a server.
    // The error string is %ls and its translations are in net.c.
    strings[STRING_NETSRVERR]     = _("Error prevented running a server (%ls)");
    // An error message telling the user that the game acting as a client
    // could not connect to a server. The error is %ls.
    strings[STRING_NETCONERR]     = \
    _("Error prevented connecting to the server (%ls)");
    #else
    strings[STRING_NETSEARCHERR]  = "Error prevented server discovery (%s)";
    strings[STRING_NETSRVERR]     = "Error prevented running a server (%s)";
    strings[STRING_NETCONERR]     = 
    "Error prevented connecting to the server (%s)";
    #endif
    // A status message showing this computer's network address (%s, not
    // hostname).
    strings[STRING_NETADDR]       = _("Local address: %s");
    // A message informing the user that time synchronization with the server
    // is in progress.
    strings[STRING_NETSYNC]       = _("Performing time synchronization");
    // A message with the latency result of time synchronization. The latency
    // value is given as a double (I recommed using %0.1lf for one digit after
    // the decimal point). The units are milliseconds.
    strings[STRING_NETLAT]        = _("Latency: %0.1lfms");
    // The player name used when a name cannot be determined from the
    // environment variables. Normally a username can be found in the
    // environment on UNIX-like and Windows systems.
    strings[STRING_DEFAULTNAME]   = _("Anonymous");
    
    // The time format. The first parameter (%02d) is the number of minutes,
    // the second is the number of seconds.
    // This string is not yet used and is included to support future
    // development. It is safe to leave it with the English default value.
    strings[STRING_TIMEFORM]      = _("%02d:%02d");
    // The time that remains for the round of combat.
    // This string is not yet used and is included to support future
    // development. It is safe to leave it with the English default value.
    strings[STRING_TIMELEFT]      = _("Time left:");
    
    // A format for status output showing a summary of information read from
    // the battlefield file(s). This output is only shown on the console
    // (stdout.txt on Windows) to assist people in creating their own battle
    // fields. The string is only shown on the console (stdout.txt or debug
    // console on Windows) and not the GUI.
    //
    // Be sue to add the approprite line breaks ('\n'), including one at the
    // end of the string.
    strings[STRING_BF_STAT] = \
    _("Finished parsing the battlefield configuration file successfully\nStats:\n       Red  Blue\nSpawn  %3d   %3d\nGoal   %3d   %3d\nObstacles    %3d\n");
    // A success/debugging message sent to the console (stdout.txt on Windows)
    // that indicates the battlefield data is ready for network transmission.
    strings[STRING_CMPLOPT] = \
    _("Compiled %i network messages that describe the game options\n");
    #ifdef USE_GETTEXT
    // The sting used to present errors with line numbers encountered while
    // reading the battlefield fil(e) to the user. The first parameter (%1$s)
    // is the name of the file. The second parameter (%2$i) is the line number
    // where the problem can be found. The third (%3$ls) is the error string.
    // OK to use just %s and %i so long as the ordering is maintained.
    strings[STRING_ERR_READ] = \
    _("Error in file %s at line %i: %ls");
    // The sting used to present errors without line numbers encountered while
    // reading the battlefield fil(e) to the user. These errors are not
    // attributed to any particular section of the file(s). The only parameter
    // (%ls) is the error string.
    strings[STRING_ERR_PROC] = \
    _("Error while processing the battlefield: %ls");
    #else
    strings[STRING_ERR_READ] = \
    _("Error in file %s at line %i: %s");
    strings[STRING_ERR_PROC] = \
    _("Error while processing the battlefield: %s");
    #endif
    // Too little memory to handle the battlefield file.
    strings[STRING_ERR_MEM]       = _("Inadequate memory");
    // The battlefield file (%s) could not be opened.
    strings[STRING_ERR_FOPEN]     = _("Could not open file: %s");
    // The battlefield file ends after the start of an include statement before
    // the name of the file to include. So, the word include, followed maybe
    // by whitespace, then the end of the file.
    strings[STRING_ERR_EOFINC]   = _("End of file in include statement");
    // The name of a battlefield file (%s) to include continues to the end of
    // the file. It should be terminated by either a semicolon (;) or the end
    // of a line.
    strings[STRING_ERR_EOFNAME]  = _("End of file in file name: %s");
    // The name of a battlefield file to include is too long. The maximum
    // length is 127 characters. Only the first ten characters of the file name
    // will be used in the output (%s).
    strings[STRING_ERR_NAMELONG] = _("File name too long: %s...");
    // The size of the battlefield is too small. Each dimension should be at
    // least 32. This is just a sanity check to keep the game from being
    // unplayable. %1$d is the specified horizontal size, and %2$d is the
    // vertical size. OK to use %d twice; it will always be horizontal then
    // vertical.
    strings[STRING_ERR_FLDSMALL] = _("Field size, %dx%d, too small");
    // The size of the battlefield is too large. The size is currently limited
    // to 2048 in each dimension. The two parameters are the same as above.
    strings[STRING_ERR_FLDLARGE] = _("Field size, %dx%d, too large");
    // The battlefield's size is not specified. It is specified with the size
    // keyword. It should appear at least once in the battlefield files. Only
    // the first occurrence is used.
    strings[STRING_ERR_NOSIZE]   = _("Battlefield size not specified");
    // An invalid keyword (%s) is in the battlefield file.
    strings[STRING_ERR_INVLDKEY] = _("Invalid keyword: %s");
    // No spawn area was specified for the red (player's) team.
    strings[STRING_ERR_NOREDSPN] = _("Spawn area for red team not specified");
    // No spawn area was specified for the blue team.
    strings[STRING_ERR_NOBLSPN] = _("Spawn area for blue team not specified");
    // No goal area specified for the red team. For capture-the-flag games,
    // a goal area must be given for each team.
    // This string is not yet used and is included to support future
    // development. It is safe to leave it with the English default value.
    strings[STRING_ERR_NOREDGOAL]  = _("Goal area for red team not specified");
    // No goal area specified for the blue team. For capture-the-flag games,
    // a goal area must be given for each team.
    // This string is not yet used and is included to support future
    // development. It is safe to leave it with the English default value.
    strings[STRING_ERR_NOBLGOAL]   = _("Goal area for blue team not specified");
    // Illegal use of a backslash in the path to a battlefield file.
    // Backslashes are not allowed because they are only supported on Windows.
    // Slashes work on almost all modern operating systems, including Windows,
    // so they should be used instead to enhance multi-platform compatibility.
    strings[STRING_ERR_BACKSLASH] \
    = _("Illegal backslashes used in file path: %s");
    // General I/O error while reading from a battlefield file.
    strings[STRING_ERR_IO]       = _("I/O error while reading");
    // Line break before the end of a token.
    strings[STRING_ERR_EOL]      = _("Token has line break");
    // Too few parameters were given to a statement in a battlefield file.
    strings[STRING_ERR_PARAM] \
    = _("Too few parameters for statement");
    // A specified coordinate is out of the allowable range. The current
    // maximum is 2047, and the minimum is 0.
    strings[STRING_ERR_XYRANGE]  = _("X or Y coordinate out of range");
    // A specified height or width is out of the allowable range. The current
    // maximum is 2047, and the minimum is 1.
    strings[STRING_ERR_WHRANGE]  = _("Bad width or height");
    // An invalid team (%s) was specified as the owning team of either a goal
    // or spawn area.
    strings[STRING_ERR_BADOWN]   = _("Bad team owning area: %s");
    // Message for no network error. Specified in case the error string
    // is requested when there was no error.
    strings[STRING_ERR_NONE]     = _("No error");
    // Message indicating that a non-blocking network operation is
    // waiting on data, so there is no data to process now.
    strings[STRING_ERR_WOULDBLOCK] = \
    _("Non-blocking operation waiting on data");
    // An error message indicating that an invalid file descriptor was
    // used for a socket in a network function call.
    strings[STRING_ERR_BADF]     = _("Invalid file descriptor for the socket");
    // An error indicating that a buffer pointer is bad and attempting
    // to access its data will result in a segmentation fault (crash).
    strings[STRING_ERR_FAULT] = \
    _("Fault reading or writing to the given pointer(s)");
    // A message indicating that an operation was interrupted before it
    // could complete.
    strings[STRING_ERR_INTR]     = _("Operation interrupted");
    // A general error message indicating that something is invalid.
    strings[STRING_ERR_INVAL]    = _("Bad invalidness");
    // An error message indicating that a file descriptor used in a
    // network function call is not actually a socket.
    strings[STRING_ERR_NOTSOCK]  = _("Not a socket");
    // An error message indicating that the requested socket address is
    // already being used. This will happen if an attempt is made to
    // run two game serers on the same computer, or if there are two
    // game processes running and looking for a server.
    strings[STRING_ERR_ADDRINUSE] = _("Address & port already in use");
    // An error message indicating that the network is down. Could be
    // caused by having no availble network interfaces.
    strings[STRING_ERR_NETDOWN]  = _("Network is down");
    // An error message indicating an unreachable network. Could be
    // cuased by a bad routing table.
    strings[STRING_ERR_NETUNREACH] = _("Network unreachable");
    // An error indicating that the remote end closed a connection.
    // Since this game uses UDP and not TCP, this shouldn't happen, but
    // is here for completeness anyway.
    strings[STRING_ERR_CONNRESET] = _("Connection closed by remote end");
    // An error indicating that the remote end did not accept incomming
    // data. This could happen if a connection between a client and
    // server is established, and then one of them crashes. The still
    // running process should recieve this error.
    strings[STRING_ERR_CONNREFUSED] = _("Previously sent data was refused");
    // An error indicating that a host was unreachable. Happens when
    // there is no route to the destination host.
    strings[STRING_ERR_HOSTUNREACH] = _("Host unreachable");
    // An error issued to the console (stderr) giving a specific error for a
    // failed hostname lookup. Since this string is not presented on the GUI,
    // consider translating it is a low priority.
    strings[STRING_ERR_HOSTLOOK]  = _("Hostname lookup error: %s\n");
    // An error message displayed on the console (stderr) indicating that
    // SDL could not be initialized. Without SDL, the game cannot provide
    // a GUI or accept input. The error string (%s) is provided by SDL
    // and is likely only in English.
    strings[STRING_ERR_SDL]       = _("Unable to initialize SDL: %s\n");
    // An error message displayed on the console (stderr) indicating that
    // the query for information about the availble video output failed.
    // Without this information, proper video output cannot be established.
    // The error string (%s) is provided by SDL and is likely only in
    // English.
    strings[STRING_ERR_VIDQ]      = _("Video query failed: %s\n");
    // An error message displayed on the console (stderr) indicating that
    // the game was unable to get video output in the requested mode
    // (resolution, color depth, etc..). No video, no game. The error
    // string (%s) is provided by SDL and is likely only in English.
    strings[STRING_ERR_VIDMODE]   = _("Unable to set video mode: %s\n");
    // An error message displayed on the console (stderr) indicating that
    // the SDL_ttf font rendering library failed to initialize. Without
    // this library, the game cannot display text in its graphical output
    // which would make it hard to use, so the game will quit instead.
    // The error string (%s) is provided by SDL_ttf and is likely only in
    // English.
    strings[STRING_ERR_TTFINIT]   = _("Unable to initalize SDL_ttf: %s\n");
    // An error message displayed on the console (stderr) indicating that
    // the game's rendering system failed to initialize properly, preventing
    // graphical output.
    strings[STRING_ERR_RENDER] = \
    _("Unable to initalize the rendering system\n");
    // An error displayed on the console (stderr) indicating that a font file
    // (%s) could not be opened.
    strings[STRING_ERR_FNTOPEN]   = _("Could not open font file: %s\n");
    // An error message displayed on the console (stderr) indicating that
    // the game failed to load and initialize its fonts.
    strings[STRING_ERR_FNTINIT]   = _("Unable to initalize the fonts\n");
    // An error message indicating that the requested audio output is
    // not available. The game will attempt to continue without sound,
    // but the error is still sent to stderr. The error description (%s)
    // comes directly from SDL_mixer and is likely in English.
    strings[STRING_ERR_OPENAUDIO] = _("Failed to open audio output: %s\n");
    // An error message given when one of the game's sound files could
    // not be loaded. The file name is %s.
    strings[STRING_ERR_LOADSND]  = _("Failed to load sound from file %s\n");
    // A message indicating that none of the game's sounds could be loaded.
    // When this occurs, the game will run without sound.
    strings[STRING_ERR_NOSNDS]   = _("No sounds could be loaded\n");    
    // A catch-all message for all other errors.
    strings[STRING_ERR_DEFAULT]   = _("Some unbogus error");
    // A status message output on the console (stdout) telling curious
    // users that the video output is single buffered.
    strings[STRING_STAT_SINGLEBUFF] = _("Video output is single-buffered\n");
    // A status message output on the console (stdout) telling curious
    // users that the video output is double buffered.
    strings[STRING_STAT_DOUBLEBUFF] = _("Video output is double-buffered\n");
    // A status message output on the console (stdout) telling curious
    // users that the video output has no hardware acceleration.
    strings[STRING_STAT_NOHWACCEL] = \
    _("Video output lacks hardware acceleration\n");
    // A status message output on the console (stdout) telling curious
    // users that the video output benifits from hardware acceleration.
    strings[STRING_STAT_HWACCEL]  = _("Video output is hardware accelerated\n");
    // A status message output on the console (stdout) telling curious
    // users that the video output surface (where things are drawn to)
    // resides system memory.
    strings[STRING_STAT_OUTSYSMEM] = \
    _("Video output surface is stored in system memory\n");
    // A status message output on the console (stdout) telling curious
    // users that the video output surface (where things are drawn to)
    // resides in memory belonging to the graphics hardware rather than
    // system/main memory.
    strings[STRING_STAT_OUTGRPMEM] = \
    _("Video output surface is stored in the graphics hardware's memory\n");
    // A status message output on the console (stdout) telling curious
    // users the name of the video driver that the game will use.
    strings[STRING_STAT_VIDDRNAME] = _("Video driver is %s\n");
    // A status message output on the console (stdout) telling curious
    // users that the game has found and will use a joystick or
    // similar controller. The first parameter (%1$s) is the name of
    // the controller. The second (%2$d) is the number of axes found
    // on the controller. The final parameter (%3$d) is the number
    // of buttons on the controller.
    strings[STRING_STAT_JOYSTICK] = \
    _("Using joystick %s:\n\tAxes: %d\n\tButtons: %d\n");
    // A warning indicating that the game could not initalize audio output.
    // When this happens, the game will attempt to continue without audio.
    strings[STRING_STAT_NOAUDIO] = \
    _("Could not initialize audio; continuing without sound\n");
    // An informational message showing that the game has entered its state
    // loop from where everything else runs.
    strings[STRING_STAT_ENTERSTATE] = _("Entering state loop\n");
    // An informational message showing that the game has left its state
    // loop and will begin to shutdown all of its innards.
    strings[STRING_STAT_EXITSTATE] = _("Exited state loop; shutting down\n");
    
    #ifdef USE_GETTEXT
    // see if ASCII stuff is in the strings
    //  This is a part of gettext I find annoying.
    if (strcmp((char*)(strings[STRING_REDTEAM]), "Red team") == 0) {
        char *src;
        wchar_t *dest;
        size_t srcLen, destLen;
        // fix all strings
        #ifndef WIN32
        iconv_t descr = iconv_open("wchar_t", "UTF-8");
        #else
        iconv_t descr = iconv_open("UTF-16LE", "UTF-8");
        #endif
        // error?
        if (descr == (iconv_t)-1) {
            #if defined(WIN32) && !defined(NDEBUG)
            int err = errno; // so we can look before next printf causes crash
            #endif
            // must have wide character strings, so now die
            prnfile(stderr,
            L"Cannot convert internal strings to wide character strings\nError code: %d\n",
            errno);
            exit(1);
        }
        #ifndef NDEBUG
        prnout(
        L"Translated strings were not loaded; using internal English strings instead\n");
        #endif
        // lop through the strings
        for (loop = 0; loop < STRING_MAX; loop++) {
            // grab a source pointer and find the length of the source
            srcLen = (int)strlen(src = (char*)strings[loop]);
            // allocate space for the destination
            strings[loop] = dest = malloc(
            destLen = (srcLen + 1) * sizeof(wchar_t));
            // convert the string
            iconv(descr, &src, &srcLen, (char**)&dest, &destLen);
            *dest = 0;
        }
        iconv_close(descr);
    }
    #ifdef WIN32        
    // for the one system with a broken wprintf . . .
    {
        rtsa_char buff[1024], **src;
        int srcInd, destInd;
        Bool typeStart;
        // loop through the strings
        for (src = strings, loop = 0; loop < STRING_MAX; src++, loop++) {
            typeStart = FALSE;
            // loop through the characters in a string
            for (srcInd = destInd = 0; (*src)[srcInd] != 0;
            srcInd++, destInd++) { 
                // check for a regular (single-byte) character string type
                if (typeStart && ((*src)[srcInd] == 's')) {
                    // use MS's reverse X/Open non-ISO standard
                    buff[destInd] = 'S';
                    typeStart = FALSE;
                    continue;
                }
                // check for a wide character string type
                else if (typeStart && ((*src)[srcInd] == 'l') &&
                ((*src)[srcInd + 1] == 's')) {
                    // use MS's reverse ISO standard
                    buff[destInd] = 's';
                    // advance one more source character
                    srcInd++;
                    typeStart = FALSE;
                    continue;
                }
                // check for the start of a type
                else if ((*src)[srcInd] == '%') {
                    // set the flag
                    typeStart = TRUE;
                }
                // assure that the character is not the field width or the
                // positional paramter for formating
                else if (((*src)[srcInd] != '$') &&
                !iswdigit((*src)[srcInd])) {
                    // not a type start
                    typeStart = FALSE;
                }
                // copy the character
                buff[destInd] = (*src)[srcInd];
            }
            // null terminate destination
            buff[destInd] = 0;
            // allocate memory for the converted string
            (*src) = malloc(sizeof(wchar_t) * (destInd + 1));
            // copy over the string
            memcpy(*src, buff, sizeof(wchar_t) * (destInd + 1));
        }
    }
    // for WIN32
    #endif
    // for Gettext
    #endif
    // success
    return TRUE;
}

Bool FontInit() {
    char path[128];
    int len, loop;
    const Uint16 space[] = { ' ', 0 };

    // clear out all the text items
    memset(textItems, 0, sizeof(textItems));
    // build a path to the data file from the current working directory
    strcpy(path, binPath);
    len = (int)strlen(path);
    strcpy(path + len, "font.ttf");
    // prepare the fonts for use
    if ((fonts[FONT_MESSAGE] = TTF_OpenFont(path, 32)) == NULL) {
        goto FontInit_noFont;
    }
    if ((fonts[FONT_SCORE] = TTF_OpenFont(path, 16)) == NULL) {
        goto FontInit_noFont;
    }
    if ((fonts[FONT_PLAYER] = TTF_OpenFont(path, 10)) == NULL) {
        goto FontInit_noFont;
    }
    // find the width of a space for each font
    for (loop = 0; loop < FONT_MAX; loop++) {
        TTF_SizeUNICODE(fonts[loop], space, &spaceWidth[loop], NULL);
        fontHeight[loop] = TTF_FontLineSkip(fonts[loop]);
    }
    return TRUE;
    // Handle not being able to open a font
    FontInit_noFont:
    // tell the user about the failure
    prnfile(stderr, strings[STRING_ERR_FNTOPEN], path);
    return FALSE;
}

static Bool TextSetup(int startStr, int startInd, int endInd, int font,
SDL_Color color) {
    int loop, strInd;
    // render common messages for later use
    for (strInd = startStr, loop = startInd; loop < endInd;
    strInd++, loop++) {
        #ifdef USE_GETTEXT
        #ifndef WIN32
        // convert the string
        Uint16 destStr[96];
        char *src = (char*)strings[strInd], *dest = (char*)destStr;
        size_t srcLen = (wcslen((wchar_t*)src) + 1) * sizeof(rtsa_char);
        size_t destLen = sizeof(destStr);
        iconv(strconvdescr, &src, &srcLen, &dest, &destLen);
        *dest = 0;
        // render the message
        if ((textItems[loop].data = TTF_RenderUNICODE_Blended(fonts[font],
        destStr, color)) == NULL)
        #else
        // render the message
        if ((textItems[loop].data = TTF_RenderUNICODE_Blended(fonts[font],
        strings[strInd], color)) == NULL)
        #endif
        #else
        // render the message and check for error
        if ((textItems[loop].data = TTF_RenderText_Blended(fonts[font],
        strings[strInd], color)) == NULL)
        #endif
        {
            // error!
            return FALSE;
        }
        // setup the width and height of the item
        textItems[loop].loc.w = ((SDL_Surface*)textItems[loop].data)->w;
        textItems[loop].loc.h = ((SDL_Surface*)textItems[loop].data)->h;
        // set the render function
        textItems[loop].renderer = GenericSurfaceRenderer;
        // put the text in the text layer
        if (textItems[loop].parent == NULL) {
            AddRenderItem(&(textItems[loop]), LAYER_TEXT);
        }
    }
    return TRUE;
}

Bool TextSetupStateSplash()  {
    // render common messages for later use
    if (TextSetup(STRING_TITLE, TEXTITEM_TITLE, TEXTITEM_TITLE + 1,
    FONT_MESSAGE, colorFmtInd[COLOR_TEXT]) && TextSetup(STRING_AUTH,
    TEXTITEM_AUTH, TEXTITEM_AUTH + 1, FONT_SCORE,
    colorFmtInd[COLOR_TEXT]) && TextSetup(STRING_COPYRIGHT, TEXTITEM_COPYRIGHT,
    TEXTITEM_COPYRIGHT + 1, FONT_PLAYER, colorFmtInd[COLOR_TEXT]) &&
    TextRenderString(&textItems[TEXTITEM_GPL], FONT_PLAYER, 340,
    colorFmtInd[COLOR_TEXT], strings[STRING_GPL])) {
        // put the GPL in the text layer -- TextRenderString() doesn't do this
        if (textItems[TEXTITEM_GPL].parent == NULL) {
            AddRenderItem(&(textItems[TEXTITEM_GPL]), LAYER_TEXT);
        }
        // check for a translator
        #ifdef USE_GETTEXT
        if (wcscmp(L"translator", strings[STRING_TRANS]) != 0)
        #else
        if (strcmp("translator", strings[STRING_TRANS]) != 0)
        #endif
        {
            // render the translator credit & check for failure
            if (!TextRenderString(&textItems[TEXTITEM_TRANS], FONT_SCORE, 340,
            colorFmtInd[COLOR_TEXT], strings[STRING_TRANS])) {
                // failure
                return FALSE;
            }
            // assure it is in the text layer
            if (textItems[TEXTITEM_TRANS].parent == NULL) {
                AddRenderItem(&(textItems[TEXTITEM_TRANS]), LAYER_TEXT);
            }
        }
        // success!
        return TRUE;
    }
    // failure
    return FALSE;
}

Bool TextSetupStateMenu()  {
    // render common messages for later use
    if (TextSetup(STRING_TITLE, TEXTITEM_TITLE, TEXTITEM_TITLE + 1,
    FONT_MESSAGE, colorFmtInd[COLOR_TEXT]) && TextSetup(STRING_CHOSETEAM,
    TEXTITEM_CHOSETEAM, TEXTITEM_FIREOPT + 1, FONT_SCORE,
    colorFmtInd[COLOR_TEXT])) {
        // success!
        return TRUE;
    }
    // failure
    return FALSE;
}

Bool TextSetupStatePlay()  {
    // render common messages for later use
    if (TextSetup(STRING_REDTEAM, TEXTITEM_REDTEAM, TEXTITEM_BLUETEAM + 1,
    FONT_SCORE, colorFmtInd[COLOR_TEXT]) && TextSetup(STRING_RESPAWN,
    TEXTITEM_RESPAWN, TEXTITEM_RESPAWN + 1, FONT_MESSAGE,
    colorFmtInd[COLOR_TEXT])) {
        // success!
        return TRUE;
    }
    // failure
    return FALSE;
}

void TextUnsetState()  {
    int loop;
    // loop through all the text items
    for (loop = 0; loop < TEXTITEM_MAX; loop++) {
        // if the item has a surface . . .
        if (textItems[loop].data) {
            // . . . free that surface
            SDL_FreeSurface(textItems[loop].data);
        }
        // if the item is a member of a layer . . .
        if (textItems[loop].parent != NULL) {
            // remove it from the layer
            RemoveRenderItem(&(textItems[loop]));
        }
    }
    // clear all data for extra good certainies today!
    memset(textItems, 0, sizeof(textItems));
}

void TextUninit()  {
    int loop;
    #ifdef USE_GETTEXT
    char *test = "Red team";
    #endif
    // assure the rendered text is gone
    TextUnsetState();
    // loop through all fonts
    for (loop = 0; loop < FONT_MAX; loop++) {
        // remove the font
        TTF_CloseFont(fonts[loop]);
    }
    #ifdef USE_GETTEXT
    // see if gettext couldn't load any strings
    test = gettext(test);
    if (strcmp(test, "Red team") == 0) {
        // deallocate all the converted strings
        for (loop = 0; loop < STRING_MAX; loop++) {
            free(strings[loop]);
        }
    }
    #ifndef WIN32
    iconv_close(strconvdescr);
    iconv_close(strconvntou);
    iconv_close(strconvuton);
    #endif
    #endif
}

int TextNativeToUTF16(Uint16 *dest, size_t destlen, rtsa_char *src,
size_t srclen) {
    size_t len;
    // there must be enough room in the output buffer
    assert(destlen > srclen);
    // convert lengths to bytes
    srclen *= sizeof(rtsa_char);
    destlen <<= 1;
    #if defined(USE_GETTEXT) && !defined(WIN32)
    len = destlen;
    // convert!
    if (iconv(strconvntou, (char**)&src, &srclen, (char**)&dest, &len) < 0) {
        // error
        return -1;
    }
    // assure null termination
    *dest = 0;
    // send back the length, in shorts, of the converted string
    return (destlen - len) >> 1;
    #else
    #ifndef USE_GETTEXT
    srclen <<= 1;
    #endif
    // loop through all the characters
    for (len = 0; len < srclen; len += 2, src++) {
        // copy and check for null terminator
        #ifdef USE_GETTEXT
        ((Uint8*)(dest))[len]     = *src >> 8;
        #else
        ((Uint8*)(dest))[len]     = 0;
        #endif
        ((Uint8*)(dest))[len + 1] = *src & 0xFF;
        if (*src == 0) {
            // quit copying
            return (int)len >> 1;
        }
    }
    // assure null termination
    dest[srclen] = 0;
    // send back the length, in shorts, of the converted string
    return (int)len >> 1;
    #endif
}

int TextUTF16toNative(rtsa_char *dest, size_t destlen, Uint16 *src,
size_t srclen) {
    size_t len;
    // there must be enough room in the output buffer
    assert(destlen > srclen);
    // convert lengths to bytes
    srclen <<= 1;
    destlen *= sizeof(rtsa_char);
    #if defined(USE_GETTEXT) && !defined(WIN32)
    len = destlen;
    // there must be at least twice as many bytes in the output buffer
    assert(destlen > (srclen << 1));
    if (iconv(strconvuton, (char**)&src, &srclen, (char**)&dest, &len) < 0) {
        // error
        return -1;
    }
    // assure null termination
    *dest = 0;
    // send back the length, in wchar_t's, of the converted string
    return (destlen - len) / sizeof(rtsa_char);
    #else
    //srclen /= sizeof(rtsa_char);
    // loop through all the characters
    for (len = 0; len < srclen; len += 2, dest++) {
        // copy and check for null terminator
        #ifdef USE_GETTEXT
        // copy from big endian source
        *dest = (((Uint8*)(src))[len] << 8) | ((Uint8*)(src))[len + 1];
        #else
        // character larger than a byte?
        if (((Uint8*)(src))[len] > 0) {
            // can't represent it in ASCII, but must maintain a string with the
            // same number of characters
            *dest = '?';
        }
        else {
            // can represent this one in ASCII
            *dest = ((Uint8*)(src))[len + 1];
        }
        #endif
        if (*dest == 0) {
            // quit copying
            return (int)len >> 1;
        }
    }
    // assure null termination
    *dest = 0;
    // send back the length, in shorts, of the converted string
    return (int)len >> 1;
    #endif
}

void TextSetWindowTitle() {
    #ifdef USE_GETTEXT
    // find the version of SDL in use
    const SDL_version * const ver = SDL_Linked_Version();
    // for version 1.2.10 and later, generate a UTF-8 string
    if ((ver->major >= 1) && (ver->minor >= 2) && (ver->patch >= 10)) {
        char buff[128], *buffPtr = buff, *inPtr = (char*)strings[STRING_TITLE];
        size_t res, inlen, outlen = 128;
        // converter from internal wchar_t to UTF-8
        iconv_t titleconv;
        // create the character encoding converter
        #ifdef WIN32
        titleconv = iconv_open("UTF-8", "UTF-16LE");
        #else
        titleconv = iconv_open("UTF-8", "wchar_t");
        #endif
        inlen = (rtsa_strlen(strings[STRING_TITLE]) + 1) * sizeof(rtsa_char);
        // convert the title string
        res = iconv(titleconv, &inPtr, &inlen, &buffPtr, &outlen);
        // no more need for the character encoding converter
        iconv_close(titleconv);
        // check for success
        if ((res >= 0) && (inlen == 0)) {
            // set the title
            SDL_WM_SetCaption(buff, NULL);
            // all done
            return;
        }
    }
    #endif
    // use an English title for English ony builds or if the title string
    // conversion fails
    SDL_WM_SetCaption("Retro Tank Super Attack", NULL);
}

Bool TextRenderString(RenderItem *text, int font, int maxwidth, SDL_Color color,
const rtsa_char *format, ...) {
    va_list args;
    Bool res;
    // get the variable argument list
    va_start(args, format);
    // render
    res = TextRenderStringV(text, font, maxwidth, color, format, args);
    // done with variable args
    va_end(args);
    return res;
}

Bool TextRenderStringV(RenderItem *text, int font, int maxwidth,
SDL_Color color, const rtsa_char *format, va_list args) {
    #if !defined(WIN32) && defined(USE_GETTEXT)
    rtsa_char wstring[512];
    #endif
    rtsa_outchar string[512];
    int len;
    assert(font < FONT_MAX);
    assert(text != NULL);
    text->renderer = NULL;
    // create the string
    #ifdef USE_GETTEXT
        #if defined(_MSC_VER)
            #if (_MSC_VER <= 1310)
                // MS Visual Studio 2003
                if ((len = _vsnwprintf(string, 511, format, args)) <= 0) {
                    return FALSE;
                }
                string[511] = 0;
            #else
                // MS Visual Studio 2005
                if ((len = _vswprintf_p(string, 512, format, args)) <= 0) {
                    return FALSE;
                }
            #endif
        #else
            // ISO C with extension
            if ((len = vswprintf(wstring, 512, format, args)) > 0) {
                size_t outsize = sizeof(string);
                size_t inbytes = len * sizeof(rtsa_char);
                rtsa_char *inbuff = wstring;
                Uint16 *outbuff = string;
                // convert from wide chars to double byte chars
                if (iconv(strconvdescr, (char**)&inbuff, &inbytes,
                (char**)&outbuff, &outsize) < 0) {
                    return FALSE;
                }
                *outbuff = 0;
            }
            else {
                return FALSE;
            }
        #endif
    #else
        // ISO C for byte sized characters
        if ((len = vsprintf(string, format, args)) <= 0) {
            return FALSE;
        }
    #endif
    
    // the variable arguments are no longer needed
    va_end(args);

    // check for an already existing surface
    if (text->data != NULL) {
        // deallocate that surface
        SDL_FreeSurface(text->data);
    }

    // limited width for rendered string?
    if (maxwidth > 0) {
        SDL_Surface *lineSurf[TEXT_MAX_LINES], **surface;
        SDL_Rect dest;
        int start = 0, end = 0, pos = 0, greatestWidth = 0, lines = 0, width,
        newWidth, destind;
        // loop through the string
        while ((pos < len) && (lines < TEXT_MAX_LINES)) {
            // loop through a line
            width = 0;
            do {
                // find the next space
                for (pos = end + 1; (pos < len) && (string[pos] != ' '); pos++);
                // found a space?
                if (string[pos] == ' ') {
                    // yes, temporarily remove it
                    string[pos] = 0;
                }
                // compute the new width
                if (SizeTTF(fonts[font], &string[start], &newWidth, NULL) < 0) {
                    // failure!
                    goto TRS_LinesFail;
                }
                // restore space
                if (pos < len) {
                    string[pos] = ' ';
                }
                // does it fit, or is the only word?
                if ((newWidth <= maxwidth) || (start == end)) {
                    // take it!
                    end = pos;
                    width = newWidth;
                }
                // render the next line
                else {
                    break;
                }
            } while ((pos < len) && (width < maxwidth));
            // terminate the line
            string[end] = 0;
            // render the line
            if ((lineSurf[lines++] =
            RenderTTF(fonts[font], &string[start], color)) == NULL) {
                // failed to render the line
                goto TRS_LinesFail;
            }
            // update the greatest width of any line
            if (lineSurf[lines-1]->w > greatestWidth) {
                greatestWidth = lineSurf[lines-1]->w;
            }
            // prepare for the next line
            if (end < len) {
                end++;
            }
            start = pos = end;  // = end + 1;
        }
        // no lines? nothing rendered?
        if (lines == 0) {
            return FALSE;
        }
        // quick special case -- one line only
        if (lines == 1) {
            // use the one surface
            text->data = lineSurf[0];
            goto TRS_End;
        }
        // create a new surface to contain all the text
        if ((text->data = SDL_CreateRGBSurface(SDL_SWSURFACE,
        text->loc.w = greatestWidth, text->loc.h = lines * fontHeight[font], 32,
        // 0xFF0000, 0xFF00, 0xFF000000, 0xFF
        lineSurf[0]->format->Rmask, lineSurf[0]->format->Gmask,
        lineSurf[0]->format->Bmask, lineSurf[0]->format->Amask
        )) == NULL) {
            // failed to create the final surface
            goto TRS_LinesFail;
        }
        // combine all the lines into a single surface
        dest.y = 0;
        destind = 0;
        for (surface = &lineSurf[0]; lines > 0; lines--, surface++) {
            int linecpy, srcind = 0;
            // center the text
            dest.x = (greatestWidth >> 1) - ((*surface)->w >> 1);
            // alter surface format so that the alpha channel will copy over
            // by making it look like blue  --  doesn't work
            /*
            (*surface)->format->Amask = 0xFF;
            (*surface)->format->Bmask = 0xFF000000;
            (*surface)->format->Ashift = 0;
            (*surface)->format->Bshift = 24;
            */
            // put it on the final surface  -- text includes alpha, if black it
            // is only alpha, and SDL's blit won't copy alpha, so doesn't work
            /*
            if (SDL_BlitSurface(*surface, NULL, text->data, &dest) < 0)
                return FALSE;
            */
            // Try doing a simple blit that'll copy alpha and color. If I had
            // known it would come to this, I would have modified SDL_ttf.
            for (linecpy = fontHeight[font]; linecpy > 0; linecpy--, dest.y++) {
                // copy one line of pixel data
                memcpy(
                ((int*)(((SDL_Surface*)(text->data))->pixels)) + dest.x + destind,
                ((int*)((*surface)->pixels)) + srcind, (*surface)->w << 2);
                // advance to the next line
                srcind  += (*surface)->w;
                destind += ((SDL_Surface*)(text->data))->w;
            }
            // deallocate the temp surface
            SDL_FreeSurface(*surface);
        }
        // swap the alpha and blue channels  --  doesn't work
        /*
        ((SDL_Surface*)(text->data))->format->Bmask = 0xFF;
        ((SDL_Surface*)(text->data))->format->Amask = 0xFF000000;
        ((SDL_Surface*)(text->data))->format->Bshift = 0;
        ((SDL_Surface*)(text->data))->format->Ashift = 24;
        */
        // set the rendering function
        text->renderer = GenericSurfaceRenderer;
        // all done!
        return TRUE;
        
        TRS_LinesFail:
        // eliminate any surfaces already rendered
        for (surface = &lineSurf[0]; lines > 0; lines--, surface++) {
            SDL_FreeSurface(*surface);
        }
        // send back the error code
        return FALSE;
    }
    
    // attempt to render the string
    if ((text->data = RenderTTF(fonts[font], string, color)) == NULL) {
        // error!
        return FALSE;
    }
    TRS_End:
    // setup the width and height of the item
    text->loc.w = ((SDL_Surface*)text->data)->w;
    text->loc.h = ((SDL_Surface*)text->data)->h;
    // set the render function
    text->renderer = GenericSurfaceRenderer;
    // worked
    return TRUE;
}

---