server/utils.c

Go to the documentation of this file.

/************************************************************************
*            Atrinik, a Multiplayer Online Role Playing Game            *
*                                                                       *
*    Copyright (C) 2009-2011 Alex Tokar and Atrinik Development Team    *
*                                                                       *
* Fork from Daimonin (Massive Multiplayer Online Role Playing Game)     *
* and Crossfire (Multiplayer game for X-windows).                       *
*                                                                       *
* This program is free software; you can redistribute it and/or modify  *
* it under the terms of the GNU General Public License as published by  *
* the Free Software Foundation; either version 2 of the License, or     *
* (at your option) any later version.                                   *
*                                                                       *
* This program is distributed in the hope that it will be useful,       *
* but WITHOUT ANY WARRANTY; without even the implied warranty of        *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
* GNU General Public License for more details.                          *
*                                                                       *
* You should have received a copy of the GNU General Public License     *
* along with this program; if not, write to the Free Software           *
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.             *
*                                                                       *
* The author can be reached at admin@atrinik.org                        *
************************************************************************/

#include <global.h>

int rndm(int min, int max)
{
    if (max < 1 || max - min + 1 < 1)
    {
        LOG(llevBug, "Calling rndm() with min=%d max=%d\n", min, max);
        return min;
    }

    return min + RANDOM() / (RAND_MAX / (max - min + 1) + 1);
}

int rndm_chance(uint32 n)
{
    if (!n)
    {
        LOG(llevBug, "Calling rndm_chance() with n=0.\n");
        return 0;
    }

    return (uint32) RANDOM() < (RAND_MAX + 1U) / n;
}

int look_up_spell_name(const char *spname)
{
    int i;

    for (i = 0; i < NROFREALSPELLS; i++)
    {
        if (strcmp(spname, spells[i].name) == 0)
        {
            return i;
        }
    }

    return -1;
}

void replace(const char *src, const char *key, const char *replacement, char *result, size_t resultsize)
{
    size_t resultlen, keylen;

    /* special case to prevent infinite loop if key == replacement == "" */
    if (strcmp(key, replacement) == 0)
    {
        snprintf(result, resultsize, "%s", src);
        return;
    }

    keylen = strlen(key);
    resultlen = 0;

    while (*src != '\0' && resultlen + 1 < resultsize)
    {
        if (strncmp(src, key, keylen) == 0)
        {
            snprintf(result + resultlen, resultsize - resultlen, "%s", replacement);
            resultlen += strlen(result + resultlen);
            src += keylen;
        }
        else
        {
            result[resultlen++] = *src++;
        }
    }

    result[resultlen] = '\0';
}

char *cleanup_string(char *ustring)
{
    /* Trim all left whitespace */
    while (*ustring != '\0' && (isspace(*ustring) || !isprint(*ustring)))
    {
        ustring++;
    }

    /* This happens when whitespace only string was submitted. */
    if (!ustring || *ustring == '\0')
    {
        return NULL;
    }

    return ustring;
}

const char *get_word_from_string(const char *str, int *pos)
{
    /* this is used for controlled input which never should bigger than this */
    static char buf[HUGE_BUF];
    int i = 0;

    buf[0] = '\0';

    while (*(str + (*pos)) != '\0' && (!isalnum(*(str + (*pos))) && !isalpha(*(str + (*pos)))))
    {
        (*pos)++;
    }

    /* Nothing left. */
    if (*(str + (*pos)) == '\0')
    {
        return NULL;
    }

    /* Copy until end of string or whitespace */
    while (*(str + (*pos)) != '\0' && (isalnum(*(str + (*pos))) || isalpha(*(str + (*pos)))))
    {
        buf[i++] = *(str + (*pos)++);
    }

    buf[i] = '\0';
    return buf;
}

void adjust_player_name(char *name)
{
    char *tmp = name;

    if (!tmp || *tmp == '\0')
    {
        return;
    }

    *tmp = toupper(*tmp);

    while (*(++tmp) != '\0')
    {
        *tmp = tolower(*tmp);
    }

    /* Trim the right whitespace */
    while (tmp >= name && *(tmp - 1) == ' ')
    {
        *(--tmp) = '\0';
    }
}

void replace_unprintable_chars(char *buf)
{
    char *p;

    for (p = buf; *p != '\0'; p++)
    {
        if (*p < ' ' || *p > '~')
        {
            *p = ' ';
        }
    }
}

size_t split_string(char *str, char *array[], size_t array_size, char sep)
{
    char *p;
    size_t pos;

    if (array_size <= 0)
    {
        return 0;
    }

    if (*str == '\0')
    {
        array[0] = str;
        return 1;
    }

    pos = 0;
    p = str;

    while (pos < array_size)
    {
        array[pos++] = p;

        while (*p != '\0' && *p != sep)
        {
            p++;
        }

        if (pos >= array_size)
        {
            break;
        }

        if (*p != sep)
        {
            break;
        }

        *p++ = '\0';
    }

    return pos;
}

int get_random_dir()
{
    return rndm(1, 8);
}

int get_randomized_dir(int dir)
{
    return absdir(dir + RANDOM() % 3 + RANDOM() % 3 - 2);
}

int buf_overflow(const char *buf1, const char *buf2, size_t bufsize)
{
    size_t len1 = 0, len2 = 0;

    if (buf1)
    {
        len1 = strlen(buf1);
    }

    if (buf2)
    {
        len2 = strlen(buf2);
    }

    if ((len1 + len2) >= bufsize)
    {
        return 1;
    }

    return 0;
}

char *cleanup_chat_string(char *ustring)
{
    int i;

    if (!ustring)
    {
        return NULL;
    }

    /* This happens when whitespace only string was submitted. */
    if (!ustring || *ustring == '\0')
    {
        return NULL;
    }

    /* Now clear all special characters. */
    for (i = 0; *(ustring + i) != '\0'; i++)
    {
        if (*(ustring + i) < ' ' || *(ustring + i) > '~')
        {
            *(ustring + i) = ' ';
        }
    }

    /* Kill all whitespace. */
    while (*ustring != '\0' && isspace(*ustring))
    {
        ustring++;
    }

    return ustring;
}

char *format_number_comma(uint64 num)
{
    static char retbuf[4 * (sizeof(uint64) * CHAR_BIT + 2) / 3 / 3 + 1];
    char *buf;
    int i = 0;

    buf = &retbuf[sizeof(retbuf) - 1];
    *buf = '\0';

    do
    {
        if (i % 3 == 0 && i != 0)
        {
            *--buf = ',';
        }

        *--buf = '0' + num % 10;
        num /= 10;
        i++;
    }
    while (num != 0);

    return buf;
}

void copy_file(const char *filename, FILE *fpout)
{
    FILE *fp;
    char buf[HUGE_BUF];

    fp = fopen(filename, "r");

    if (!fp)
    {
        LOG(llevBug, "copy_file(): Failed to open '%s'.\n", filename);
        return;
    }

    while (fgets(buf, sizeof(buf), fp))
    {
        fputs(buf, fpout);
    }

    fclose(fp);
}

void convert_newline(char *str)
{
    char *next, buf[MAX_BUF];

    while ((next = strstr(str, "\\n")))
    {
        *next = '\n';
        *(next + 1) = '\0';
        snprintf(buf, sizeof(buf), "%s%s", str, next + 2);
        strcpy(str, buf);
    }
}

void string_remove_markup(char *str)
{
    char *cp;

    for (cp = str; *cp != '\0'; cp++)
    {
        if (*cp == '<')
        {
            *cp = ' ';
        }
    }
}