socket/info.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>
#include <stdarg.h>

int color_notation_to_flag(const char *color)
{
    if (!strcmp(color, COLOR_WHITE))
    {
        return 0;
    }
    else if (!strcmp(color, COLOR_ORANGE))
    {
        return 1;
    }
    else if (!strcmp(color, COLOR_NAVY))
    {
        return 2;
    }
    else if (!strcmp(color, COLOR_RED))
    {
        return 3;
    }
    else if (!strcmp(color, COLOR_GREEN))
    {
        return 4;
    }
    else if (!strcmp(color, COLOR_BLUE))
    {
        return 5;
    }
    else if (!strcmp(color, COLOR_GRAY))
    {
        return 6;
    }
    else if (!strcmp(color, COLOR_BROWN))
    {
        return 7;
    }
    else if (!strcmp(color, COLOR_PURPLE))
    {
        return 8;
    }
    else if (!strcmp(color, COLOR_PINK))
    {
        return 9;
    }
    else if (!strcmp(color, COLOR_YELLOW))
    {
        return 10;
    }
    else if (!strcmp(color, COLOR_DK_NAVY))
    {
        return 11;
    }
    else if (!strcmp(color, COLOR_DK_GREEN))
    {
        return 12;
    }
    else if (!strcmp(color, COLOR_DK_ORANGE))
    {
        return 17;
    }
    else if (!strcmp(color, COLOR_BRIGHT_PURPLE))
    {
        return 197;
    }
    else if (!strcmp(color, COLOR_HGOLD))
    {
        return 64;
    }
    else if (!strcmp(color, COLOR_DGOLD))
    {
        return 65;
    }

    return 0;
}

void new_draw_info(int flags, const char *color, object *pl, const char *buf)
{
    unsigned char info_string[HUGE_BUF];
    size_t len;
    SockList sl;

    /* Handle global messages. */
    if (flags & NDI_ALL)
    {
        player *tmppl;

        for (tmppl = first_player; tmppl; tmppl = tmppl->next)
        {
            new_draw_info((flags & ~NDI_ALL), color, tmppl->ob, buf);
        }

        return;
    }

    if (!pl || pl->type != PLAYER)
    {
        return;
    }

    if (CONTR(pl) == NULL)
    {
        LOG(llevBug, "new_draw_info(): Called for player with contr == NULL! %s (%x) msg: %s\n", query_name(pl, NULL), flags, buf);
        return;
    }

    if (CONTR(pl)->state != ST_PLAYING)
    {
        return;
    }

    sl.buf = info_string;
    SOCKET_SET_BINARY_CMD(&sl, BINARY_CMD_DRAWINFO2);
    if (CONTR(pl)->socket.socket_version >= 1055)
    {
    SockList_AddShort(&sl, flags);
    SockList_AddString(&sl, color);
    }
    else
    {
    SockList_AddShort(&sl, flags | color_notation_to_flag(color));
    }
    /* Make sure we don't copy more bytes than available space in the buffer. */
    len = MIN(strlen(buf), sizeof(info_string) - sl.len - 1);
    memcpy((char *) sl.buf + sl.len, buf, len);
    sl.len += len;

    /* Terminate the string. */
    SockList_AddChar(&sl, '\0');
    Send_With_Handling(&CONTR(pl)->socket, &sl);
}

void new_draw_info_format(int flags, const char *color, object *pl, char *format, ...)
{
    char buf[HUGE_BUF];

    va_list ap;
    va_start(ap, format);
    vsnprintf(buf, sizeof(buf), format, ap);
    va_end(ap);

    new_draw_info(flags, color, pl, buf);
}

static void new_info_map_all_except(int flags, const char *color, mapstruct *map, object *op1, object *op, const char *str)
{
    object *tmp;

    if (map->player_first)
    {
        for (tmp = map->player_first; tmp; tmp = CONTR(tmp)->map_above)
        {
            if (tmp != op && tmp != op1)
            {
                new_draw_info(flags, color, tmp, str);
            }
        }
    }
}

void new_info_map(int flags, const char *color, mapstruct *map, int x, int y, int dist, const char *str)
{
    int xt, yt, d;
    object *tmp;

    if (!map || map->in_memory != MAP_IN_MEMORY)
    {
        return;
    }

    if (dist != MAP_INFO_ALL)
    {
        d = POW2(dist);
    }
    else
    {
        /* We want all on this map */
        new_info_map_all_except(flags, color, map, NULL, NULL, str);
        return;
    }

    /* Any players on this map? */
    if (map->player_first)
    {
        for (tmp = map->player_first; tmp; tmp = CONTR(tmp)->map_above)
        {
            if ((POW2(tmp->x - x) + POW2(tmp->y - y)) <= d)
            {
                new_draw_info(flags, color, tmp, str);
            }
        }
    }

    if (map->tile_map[0] && map->tile_map[0]->in_memory == MAP_IN_MEMORY && map->tile_map[0]->player_first)
    {
        yt = y + MAP_HEIGHT(map->tile_map[0]);

        for (tmp = map->tile_map[0]->player_first; tmp; tmp = CONTR(tmp)->map_above)
        {
            if ((POW2(tmp->x - x) + POW2(tmp->y - yt)) <= d)
            {
                new_draw_info(flags, color, tmp, str);
            }
        }
    }

    if (map->tile_map[1] && map->tile_map[1]->in_memory == MAP_IN_MEMORY && map->tile_map[1]->player_first)
    {
        xt = x - MAP_WIDTH(map);

        for (tmp = map->tile_map[1]->player_first; tmp; tmp = CONTR(tmp)->map_above)
        {
            if ((POW2(tmp->x - xt) + POW2(tmp->y - y)) <= d)
            {
                new_draw_info(flags, color, tmp, str);
            }
        }
    }

    if (map->tile_map[2] && map->tile_map[2]->in_memory == MAP_IN_MEMORY && map->tile_map[2]->player_first)
    {
        yt = y - MAP_HEIGHT(map);

        for (tmp = map->tile_map[2]->player_first; tmp; tmp = CONTR(tmp)->map_above)
        {
            if ((POW2(tmp->x - x) + POW2(tmp->y - yt)) <= d)
            {
                new_draw_info(flags, color, tmp, str);
            }
        }
    }

    if (map->tile_map[3] && map->tile_map[3]->in_memory == MAP_IN_MEMORY && map->tile_map[3]->player_first)
    {
        xt = x + MAP_WIDTH(map->tile_map[3]);

        for (tmp = map->tile_map[3]->player_first; tmp; tmp = CONTR(tmp)->map_above)
        {
            if ((POW2(tmp->x - xt) + POW2(tmp->y - y)) <= d)
            {
                new_draw_info(flags, color, tmp, str);
            }
        }
    }

    if (map->tile_map[4] && map->tile_map[4]->in_memory == MAP_IN_MEMORY && map->tile_map[4]->player_first)
    {
        yt = y + MAP_HEIGHT(map->tile_map[4]);
        xt = x - MAP_WIDTH(map);

        for (tmp = map->tile_map[4]->player_first; tmp; tmp = CONTR(tmp)->map_above)
        {
            if ((POW2(tmp->x - xt) + POW2(tmp->y - yt)) <= d)
            {
                new_draw_info(flags, color, tmp, str);
            }
        }
    }

    if (map->tile_map[5] && map->tile_map[5]->in_memory == MAP_IN_MEMORY && map->tile_map[5]->player_first)
    {
        xt = x - MAP_WIDTH(map);
        yt = y - MAP_HEIGHT(map);

        for (tmp = map->tile_map[5]->player_first; tmp; tmp = CONTR(tmp)->map_above)
        {
            if ((POW2(tmp->x - xt) + POW2(tmp->y - yt)) <= d)
            {
                new_draw_info(flags, color, tmp, str);
            }
        }
    }

    if (map->tile_map[6] && map->tile_map[6]->in_memory == MAP_IN_MEMORY && map->tile_map[6]->player_first)
    {
        xt = x + MAP_WIDTH(map->tile_map[6]);
        yt = y - MAP_HEIGHT(map);

        for (tmp = map->tile_map[6]->player_first; tmp; tmp = CONTR(tmp)->map_above)
        {
            if ((POW2(tmp->x - xt) + POW2(tmp->y - yt)) <= d)
            {
                new_draw_info(flags, color, tmp, str);
            }
        }
    }

    if (map->tile_map[7] && map->tile_map[7]->in_memory == MAP_IN_MEMORY && map->tile_map[7]->player_first)
    {
        xt = x + MAP_WIDTH(map->tile_map[7]);
        yt = y + MAP_HEIGHT(map->tile_map[7]);

        for (tmp = map->tile_map[7]->player_first; tmp; tmp = CONTR(tmp)->map_above)
        {
            if ((POW2(tmp->x - xt) + POW2(tmp->y - yt)) <= d)
            {
                new_draw_info(flags, color, tmp, str);
            }
        }
    }
}

void new_info_map_except(int flags, const char *color, mapstruct *map, int x, int y, int dist, object *op1, object *op, const char *str)
{
    int xt, yt, d;
    object *tmp;

    if (!map || map->in_memory != MAP_IN_MEMORY)
    {
        return;
    }

    if (dist != MAP_INFO_ALL)
    {
        d = POW2(dist);
    }
    else
    {
        /* We want all on this map */
        new_info_map_all_except(flags, color, map, op1, op, str);
        return;
    }

    /* Any players on this map? */
    if (map->player_first)
    {
        for (tmp = map->player_first; tmp; tmp = CONTR(tmp)->map_above)
        {
            if (tmp != op && tmp != op1 && (POW2(tmp->x - x) + POW2(tmp->y - y)) <= d)
            {
                new_draw_info(flags, color, tmp, str);
            }
        }
    }

    if (map->tile_map[0] && map->tile_map[0]->in_memory == MAP_IN_MEMORY && map->tile_map[0]->player_first)
    {
        yt = y + MAP_HEIGHT(map->tile_map[0]);

        for (tmp = map->tile_map[0]->player_first; tmp; tmp = CONTR(tmp)->map_above)
        {
            if (tmp != op && tmp != op1 && (POW2(tmp->x - x) + POW2(tmp->y - yt)) <= d)
            {
                new_draw_info(flags, color, tmp, str);
            }
        }
    }

    if (map->tile_map[1] && map->tile_map[1]->in_memory == MAP_IN_MEMORY && map->tile_map[1]->player_first)
    {
        xt = x - MAP_WIDTH(map);

        for (tmp = map->tile_map[1]->player_first; tmp; tmp = CONTR(tmp)->map_above)
        {
            if (tmp != op && tmp != op1 && (POW2(tmp->x - xt) + POW2(tmp->y - y)) <= d)
            {
                new_draw_info(flags, color, tmp, str);
            }
        }
    }

    if (map->tile_map[2] && map->tile_map[2]->in_memory == MAP_IN_MEMORY && map->tile_map[2]->player_first)
    {
        yt = y - MAP_HEIGHT(map);

        for (tmp = map->tile_map[2]->player_first; tmp; tmp = CONTR(tmp)->map_above)
        {
            if (tmp != op && tmp != op1 && (POW2(tmp->x - x) + POW2(tmp->y - yt)) <= d)
            {
                new_draw_info(flags, color, tmp, str);
            }
        }
    }

    if (map->tile_map[3] && map->tile_map[3]->in_memory == MAP_IN_MEMORY && map->tile_map[3]->player_first)
    {
        xt = x + MAP_WIDTH(map->tile_map[3]);

        for (tmp = map->tile_map[3]->player_first; tmp; tmp = CONTR(tmp)->map_above)
        {
            if (tmp != op && tmp != op1 && (POW2(tmp->x - xt) + POW2(tmp->y - y)) <= d)
            {
                new_draw_info(flags, color, tmp, str);
            }
        }
    }

    if (map->tile_map[4] && map->tile_map[4]->in_memory == MAP_IN_MEMORY && map->tile_map[4]->player_first)
    {
        yt = y + MAP_HEIGHT(map->tile_map[4]);
        xt = x - MAP_WIDTH(map);

        for (tmp = map->tile_map[4]->player_first; tmp; tmp = CONTR(tmp)->map_above)
        {
            if (tmp != op && tmp != op1 && (POW2(tmp->x - xt) + POW2(tmp->y - yt)) <= d)
            {
                new_draw_info(flags, color, tmp, str);
            }
        }
    }

    if (map->tile_map[5] && map->tile_map[5]->in_memory == MAP_IN_MEMORY && map->tile_map[5]->player_first)
    {
        xt = x - MAP_WIDTH(map);
        yt = y - MAP_HEIGHT(map);

        for (tmp = map->tile_map[5]->player_first; tmp; tmp = CONTR(tmp)->map_above)
        {
            if (tmp != op && tmp != op1 && (POW2(tmp->x - xt) + POW2(tmp->y - yt)) <= d)
            {
                new_draw_info(flags, color, tmp, str);
            }
        }
    }

    if (map->tile_map[6] && map->tile_map[6]->in_memory == MAP_IN_MEMORY && map->tile_map[6]->player_first)
    {
        xt = x + MAP_WIDTH(map->tile_map[6]);
        yt = y - MAP_HEIGHT(map);

        for (tmp = map->tile_map[6]->player_first; tmp; tmp = CONTR(tmp)->map_above)
        {
            if (tmp != op && tmp != op1 && (POW2(tmp->x - xt) + POW2(tmp->y - yt)) <= d)
            {
                new_draw_info(flags, color, tmp, str);
            }
        }
    }

    if (map->tile_map[7] && map->tile_map[7]->in_memory == MAP_IN_MEMORY && map->tile_map[7]->player_first)
    {
        xt = x + MAP_WIDTH(map->tile_map[7]);
        yt = y + MAP_HEIGHT(map->tile_map[7]);

        for (tmp = map->tile_map[7]->player_first; tmp; tmp = CONTR(tmp)->map_above)
        {
            if (tmp != op && tmp != op1 && (POW2(tmp->x - xt) + POW2(tmp->y - yt)) <= d)
            {
                new_draw_info(flags, color, tmp, str);
            }
        }
    }
}

void send_socket_message(const char *color, socket_struct *ns, const char *buf)
{
    if (ns->socket_version >= 1055)
    {
    SockList sl;
    unsigned char sockbuf[HUGE_BUF];
    size_t len;

    sl.buf = sockbuf;
    SOCKET_SET_BINARY_CMD(&sl, BINARY_CMD_DRAWINFO);

    SockList_AddString(&sl, color);

    /* Make sure we don't copy more bytes than available space in the buffer. */
    len = MIN(strlen(buf), sizeof(sockbuf) - sl.len - 1);
    memcpy(sl.buf + sl.len, buf, len);
    sl.len += len;

    /* Terminate the string. */
    SockList_AddChar(&sl, '\0');
    Send_With_Handling(ns, &sl);
    }
    else
    {
    char tmp[HUGE_BUF];
    snprintf(tmp, sizeof(tmp), "X%d %s", color_notation_to_flag(color), buf);
    Write_String_To_Socket(ns, BINARY_CMD_DRAWINFO, tmp, strlen(tmp));
    }
}