ascii.c

Go to the documentation of this file.

/*
Copyright (C) 1997-2001 Id Software, Inc.
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
 
#include "client.h"
 
/*
===============================================================================
 
STAT PROGRAMS TO TEXT
 
===============================================================================
*/
 
#define TH_WIDTH    80
#define TH_HEIGHT   40
 
static void TH_DrawString(char *dst, int x, int y, char *src, size_t len)
{
    int c;
 
    if (x + len > TH_WIDTH) {
        len = TH_WIDTH - x;
    }
 
    dst += y * (TH_WIDTH + 1) + x;
    while (len--) {
        c = *src++;
        c &= 127;
        switch (c) {
        case 13: c = '>'; break;
        case 16: c = '['; break;
        case 17: c = ']'; break;
        case 29: c = '<'; break;
        case 30: c = '='; break;
        case 31: c = '>'; break;
        default:
            if (c < 32) {
                c = 32;
            }
            break;
        }
        *dst++ = c;
    }
}
 
static void TH_DrawCenterString(char *dst, int x, int y, char *src, size_t len)
{
    x -= len / 2;
    if (x < 0) {
        src -= x;
        x = 0;
    }
 
    TH_DrawString(dst, x, y, src, len);
}
 
static void TH_DrawNumber(char *dst, int x, int y, int width, int value)
{
    char num[16];
    int l;
 
    if (width < 1)
        return;
 
    // draw number string
    if (width > 5)
        width = 5;
 
    l = Q_scnprintf(num, sizeof(num), "%d", value);
    if (l > width)
        l = width;
    x += width - l;
 
    TH_DrawString(dst, x, y, num, l);
}
 
static void TH_DrawLayoutString(char *dst, const char *s)
{
    char    buffer[MAX_QPATH];
    int     x, y;
    int     value;
    char    *token;
    size_t  len;
    int     width, index;
    clientinfo_t    *ci;
 
    if (!s[0])
        return;
 
    x = 0;
    y = 0;
 
    while (s) {
        token = COM_Parse(&s);
        if (token[2] == 0) {
            if (token[0] == 'x') {
                if (token[1] == 'l') {
                    token = COM_Parse(&s);
                    x = atoi(token) / 8;
                    continue;
                }
 
                if (token[1] == 'r') {
                    token = COM_Parse(&s);
                    x = TH_WIDTH + atoi(token) / 8;
                    continue;
                }
 
                if (token[1] == 'v') {
                    token = COM_Parse(&s);
                    x = TH_WIDTH / 2 - 20 + atoi(token) / 8;
                    continue;
                }
            }
 
            if (token[0] == 'y') {
                if (token[1] == 't') {
                    token = COM_Parse(&s);
                    y = atoi(token) / 8;
                    continue;
                }
 
                if (token[1] == 'b') {
                    token = COM_Parse(&s);
                    y = TH_HEIGHT + atoi(token) / 8;
                    continue;
                }
 
                if (token[1] == 'v') {
                    token = COM_Parse(&s);
                    y = TH_HEIGHT / 2 - 15 + atoi(token) / 8;
                    continue;
                }
            }
        }
 
        if (!strcmp(token, "pic")) {
            // draw a pic from a stat number
            COM_Parse(&s);
            continue;
        }
 
        if (!strcmp(token, "client")) {
            // draw a deathmatch client block
            int     score, ping, time;
 
            token = COM_Parse(&s);
            x = TH_WIDTH / 2 - 20 + atoi(token) / 8;
            token = COM_Parse(&s);
            y = TH_HEIGHT / 2 - 15 + atoi(token) / 8;
 
            token = COM_Parse(&s);
            value = atoi(token);
            if (value < 0 || value >= MAX_CLIENTS) {
                Com_Error(ERR_DROP, "%s: invalid client index", __func__);
            }
            ci = &cl.clientinfo[value];
 
            token = COM_Parse(&s);
            score = atoi(token);
 
            token = COM_Parse(&s);
            ping = atoi(token);
 
            token = COM_Parse(&s);
            time = atoi(token);
 
            len = strlen(ci->name);
            TH_DrawString(dst, x + 4, y, ci->name, len);
            len = Q_scnprintf(buffer, sizeof(buffer), "Score: %i", score);
            TH_DrawString(dst, x + 4, y + 1, buffer, len);
            len = Q_scnprintf(buffer, sizeof(buffer), "Ping:  %i", ping);
            TH_DrawString(dst, x + 4, y + 2, buffer, len);
            len = Q_scnprintf(buffer, sizeof(buffer), "Time:  %i", time);
            TH_DrawString(dst, x + 4, y + 3, buffer, len);
            continue;
        }
 
        if (!strcmp(token, "ctf")) {
            // draw a ctf client block
            int     score, ping;
 
            token = COM_Parse(&s);
            x = TH_WIDTH / 2 - 20 + atoi(token) / 8;
            token = COM_Parse(&s);
            y = TH_HEIGHT / 2 - 15 + atoi(token) / 8;
 
            token = COM_Parse(&s);
            value = atoi(token);
            if (value < 0 || value >= MAX_CLIENTS) {
                Com_Error(ERR_DROP, "%s: invalid client index", __func__);
            }
            ci = &cl.clientinfo[value];
 
            token = COM_Parse(&s);
            score = atoi(token);
 
            token = COM_Parse(&s);
            ping = atoi(token);
            if (ping > 999)
                ping = 999;
 
            len = Q_scnprintf(buffer, sizeof(buffer), "%3d %3d %-12.12s",
                              score, ping, ci->name);
            TH_DrawString(dst, x, y, buffer, len);
            continue;
        }
 
        if (!strcmp(token, "picn")) {
            // draw a pic from a name
            COM_Parse(&s);
            continue;
        }
 
        if (!strcmp(token, "num")) {
            // draw a number
            token = COM_Parse(&s);
            width = atoi(token);
            token = COM_Parse(&s);
            value = atoi(token);
            if (value < 0 || value >= MAX_STATS) {
                Com_Error(ERR_DROP, "%s: invalid stat index", __func__);
            }
            value = cl.frame.ps.stats[value];
            TH_DrawNumber(dst, x, y, width, value);
            continue;
        }
 
        if (!strcmp(token, "stat_string")) {
            token = COM_Parse(&s);
            index = atoi(token);
            if (index < 0 || index >= MAX_STATS) {
                Com_Error(ERR_DROP, "%s: invalid string index", __func__);
            }
            index = cl.frame.ps.stats[index];
            if (index < 0 || index >= MAX_CONFIGSTRINGS) {
                Com_Error(ERR_DROP, "%s: invalid string index", __func__);
            }
            len = strlen(cl.configstrings[index]);
            TH_DrawString(dst, x, y, cl.configstrings[index], len);
            continue;
        }
 
        if (!strncmp(token, "cstring", 7)) {
            token = COM_Parse(&s);
            len = strlen(token);
            TH_DrawCenterString(dst, x + 40 / 2, y, token, len);
            continue;
        }
 
        if (!strncmp(token, "string", 6)) {
            token = COM_Parse(&s);
            len = strlen(token);
            TH_DrawString(dst, x, y, token, len);
            continue;
        }
 
        if (!strcmp(token, "if")) {
            token = COM_Parse(&s);
            value = atoi(token);
            if (value < 0 || value >= MAX_STATS) {
                Com_Error(ERR_DROP, "%s: invalid stat index", __func__);
            }
            value = cl.frame.ps.stats[value];
            if (!value) {   // skip to endif
                while (strcmp(token, "endif")) {
                    token = COM_Parse(&s);
                    if (!s) {
                        break;
                    }
                }
            }
            continue;
        }
    }
}
 
static void SCR_ScoreShot_f(void)
{
    char buffer[(TH_WIDTH + 1) * TH_HEIGHT];
    char path[MAX_OSPATH];
    qhandle_t f;
    int i;
    qerror_t ret;
 
    if (cls.state != ca_active) {
        Com_Printf("Must be in a level.\n");
        return;
    }
 
    if (Cmd_Argc() > 1) {
        f = FS_EasyOpenFile(path, sizeof(path), FS_MODE_WRITE | FS_FLAG_TEXT,
                            "scoreshots/", Cmd_Argv(1), ".txt");
        if (!f) {
            return;
        }
    } else {
        // find a file name to save it to
        for (i = 0; i < 1000; i++) {
            Q_snprintf(path, sizeof(path), "scoreshots/quake%03d.txt", i);
            ret = FS_FOpenFile(path, &f, FS_MODE_WRITE | FS_FLAG_TEXT | FS_FLAG_EXCL);
            if (f) {
                break;
            }
            if (ret != Q_ERR_EXIST) {
                Com_EPrintf("Couldn't exclusively open %s for writing: %s\n",
                            path, Q_ErrorString(ret));
                return;
            }
        }
 
        if (i == 1000) {
            Com_EPrintf("All scoreshot slots are full.\n");
            return;
        }
    }
 
    memset(buffer, ' ', sizeof(buffer));
    for (i = 0; i < TH_HEIGHT; i++) {
        buffer[i * (TH_WIDTH + 1) + TH_WIDTH] = '\n';
    }
 
    TH_DrawLayoutString(buffer, cl.configstrings[CS_STATUSBAR]);
    TH_DrawLayoutString(buffer, cl.layout);
 
    FS_Write(buffer, sizeof(buffer), f);
 
    FS_FCloseFile(f);
 
    Com_Printf("Wrote %s.\n", path);
}
 
static void SCR_ScoreDump_f(void)
{
    char buffer[(TH_WIDTH + 1) * TH_HEIGHT];
    int i;
 
    if (cls.state != ca_active) {
        Com_Printf("Must be in a level.\n");
        return;
    }
 
    memset(buffer, ' ', sizeof(buffer));
    for (i = 0; i < TH_HEIGHT - 1; i++) {
        buffer[i * (TH_WIDTH + 1) + TH_WIDTH] = '\n';
    }
    buffer[i * (TH_WIDTH + 1) + TH_WIDTH] = 0;
 
    TH_DrawLayoutString(buffer, cl.configstrings[CS_STATUSBAR]);
    TH_DrawLayoutString(buffer, cl.layout);
 
    Com_Printf("%s\n", buffer);
}
 
void CL_InitAscii(void)
{
    Cmd_AddCommand("aashot", SCR_ScoreShot_f);
    Cmd_AddCommand("aadump", SCR_ScoreDump_f);
}