--- deliantra/server/socket/request.C 2008/05/20 13:25:55 1.131 +++ deliantra/server/socket/request.C 2008/12/28 06:59:27 1.148 @@ -100,25 +100,21 @@ my = ns->mapy; /* the x and y here are coordinates for the new map, i.e. if we moved - * (dx,dy), newmap[x][y] = oldmap[x-dx][y-dy]. For this reason, + * (dx,dy), newmap[x][y] = oldmap[x-dx][y-dy]. For this reason, * if the destination x or y coordinate is outside the viewable * area, we clear the values - otherwise, the old values * are preserved, and the check_head thinks it needs to clear them. */ for (x = 0; x < mx; x++) - { - for (y = 0; y < my; y++) - { - if (x >= ns->mapx || y >= ns->mapy) - /* clear cells outside the viewable area */ - memset (&newmap.cells[x][y], 0, sizeof (struct MapCell)); - else if ((x + dx) < 0 || (x + dx) >= ns->mapx || (y + dy) < 0 || (y + dy) >= ns->mapy) - /* clear newly visible tiles within the viewable area */ - memset (&(newmap.cells[x][y]), 0, sizeof (struct MapCell)); - else - memcpy (&(newmap.cells[x][y]), &(ns->lastmap.cells[x + dx][y + dy]), sizeof (struct MapCell)); - } - } + for (y = 0; y < my; y++) + if (x >= ns->mapx || y >= ns->mapy) + /* clear cells outside the viewable area */ + memset (&newmap.cells[x][y], 0, sizeof (struct MapCell)); + else if ((x + dx) < 0 || (x + dx) >= ns->mapx || (y + dy) < 0 || (y + dy) >= ns->mapy) + /* clear newly visible tiles within the viewable area */ + memset (&(newmap.cells[x][y]), 0, sizeof (struct MapCell)); + else + memcpy (&(newmap.cells[x][y]), &(ns->lastmap.cells[x + dx][y + dy]), sizeof (struct MapCell)); memcpy (&(ns->lastmap), &newmap, sizeof (struct Map)); @@ -214,13 +210,8 @@ int dx = ob->x - socket.current_x; int dy = ob->y - socket.current_y; - if (socket.buggy_mapscroll && (abs (dx) > 8 || abs (dy) > 8)) - clear_map (pl); // current (<= 1.9.1) clients have unchecked buffer overflows - else - { - socket_map_scroll (&socket, ob->x - socket.current_x, ob->y - socket.current_y); - socket.floorbox_reset (); - } + socket_map_scroll (&socket, ob->x - socket.current_x, ob->y - socket.current_y); + socket.floorbox_reset (); } socket.current_x = ob->x; @@ -410,59 +401,6 @@ INVOKE_CLIENT (ADDME, ns, ARG_DATA (buf, len)); } -/** Reply to ExtendedInfos command */ -void -ToggleExtendedInfos (char *buf, int len, client * ns) -{ - char cmdback[MAX_BUF]; - char command[50]; - int info, nextinfo; - - cmdback[0] = '\0'; - nextinfo = 0; - - while (1) - { - /* 1. Extract an info */ - info = nextinfo; - - while ((info < len) && (buf[info] == ' ')) - info++; - - if (info >= len) - break; - - nextinfo = info + 1; - - while ((nextinfo < len) && (buf[nextinfo] != ' ')) - nextinfo++; - - if (nextinfo - info >= 49) /*Erroneous info asked */ - continue; - - strncpy (command, &(buf[info]), nextinfo - info); - - /* 2. Interpret info */ - if (!strcmp ("smooth", command)) - /* Toggle smoothing */ - ns->EMI_smooth = !ns->EMI_smooth; - else - /*bad value */; - - /*3. Next info */ - } - - strcpy (cmdback, "ExtendedInfoSet"); - - if (ns->EMI_smooth) - { - strcat (cmdback, " "); - strcat (cmdback, "smoothing"); - } - - ns->send_packet (cmdback); -} - /* #define MSG_TYPE_BOOK 1 #define MSG_TYPE_CARD 2 @@ -835,7 +773,7 @@ AddIfShort (ns->last_stats.Cha, ob->stats.Cha, CS_STAT_CHA); for (int s = 0; s < NUM_SKILLS; s++) - if (object *skill = opl->last_skill_ob[s]) + if (object *skill = opl->last_skill_ob [s]) if (skill->stats.exp != ns->last_skill_exp [s]) { ns->last_skill_exp [s] = skill->stats.exp; @@ -914,7 +852,6 @@ pl->ns->last_weight = weight; pl->ns->send_packet (sl); - SET_FLAG (pl->ob, FLAG_CLIENT_SENT); } /****************************************************************************** @@ -991,30 +928,11 @@ return 0; } -/** - * Returns the size of a data for a map square as returned by - * mapextended. There are CLIENTMAPX*CLIENTMAPY*LAYERS entries - * available. - */ -int -getExtendedMapInfoSize (client * ns) -{ - int result = 0; - - if (ns->ext_mapinfos) - { - if (ns->EMI_smooth) - result += 1; /*One byte for smoothlevel */ - } - - return result; -} - // prefetch (and touch) all maps within a specific distancd static void prefetch_surrounding_maps (maptile *map, int distance) { - map->last_access = runtime; + map->touch (); if (--distance) for (int dir = 4; --dir; ) @@ -1042,31 +960,24 @@ if (!ob->active) return; - maptile *plmap = ob->map; - /* If player is just joining the game, he isn't here yet, so the map * can get swapped out. If so, don't try to send them a map. All will * be OK once they really log in. */ - if (!plmap || plmap->in_memory != MAP_ACTIVE) + if (!ob->map || ob->map->in_memory != MAP_ACTIVE) return; - int x, y, ax, ay, startlen, max_x, max_y, oldlen; - int estartlen, eoldlen; - uint8 eentrysize; - uint16 ewhatstart, ewhatflag; - uint8 extendedinfos; + int startlen, oldlen; check_map_change (pl); prefetch_surrounding_maps (pl->ob); /* do LOS after calls to update_position */ - if (ob != pl->ob) - clear_los (pl); - else if (pl->do_los) + /* unfortunately, we need to udpate los when observing, currently */ + if (pl->do_los || pl->observe != pl->ob) { - update_los (ob); pl->do_los = 0; + pl->update_los (); } /** @@ -1095,317 +1006,208 @@ client &socket = *pl->ns; packet sl (socket.mapmode == Map1Cmd ? "map1" : "map1a"); - packet esl; startlen = sl.length (); - /*Extendedmapinfo structure initialisation */ - if (socket.ext_mapinfos) - { - extendedinfos = EMI_NOREDRAW; + int hx = socket.mapx / 2; + int hy = socket.mapy / 2; - if (socket.EMI_smooth) - extendedinfos |= EMI_SMOOTH; + ordered_mapwalk_begin (ob, -hx, -hy, hx, hy) + int ax = dx + hx; + int ay = dy + hy; + + int mask = (ax << 10) | (ay << 4); + MapCell &lastcell = socket.lastmap.cells[ax][ay]; + + /* If the coordinates are not valid, or it is too dark to see, + * we tell the client as such + */ + if (!m) + { + /* space is out of map. Update space and clear values + * if this hasn't already been done. If the space is out + * of the map, it shouldn't have a head. + */ + if (lastcell.count != -1) + { + sl << uint16 (mask); + map_clearcell (&lastcell, -1); + } - ewhatstart = esl.length (); - ewhatflag = extendedinfos; /*The EMI_NOREDRAW bit - could need to be taken away */ - eentrysize = getExtendedMapInfoSize (&socket); - esl << "mapextended " - << uint8 (extendedinfos) - << uint8 (eentrysize); + continue; + } + + int d = pl->blocked_los_uc (dx, dy); - estartlen = esl.length (); - } + if (d > 3) + { + /* This block deals with spaces that are not visible for whatever + * reason. Still may need to send the head for this space. + */ + if (lastcell.count != -1 + || lastcell.faces[0] + || lastcell.faces[1] + || lastcell.faces[2] + || lastcell.stat_hp + || lastcell.flags + || lastcell.player) + sl << uint16 (mask); - /* x,y are the real map locations. ax, ay are viewport relative - * locations. - */ - ay = 0; + /* properly clear a previously sent big face */ + map_clearcell (&lastcell, -1); + } + else + { + /* In this block, the space is visible. + */ - /* We could do this logic as conditionals in the if statement, - * but that started to get a bit messy to look at. - */ - max_x = ob->x + (socket.mapx + 1) / 2; - max_y = ob->y + (socket.mapy + 1) / 2; + /* Rather than try to figure out what everything that we might + * need to send is, then form the packet after that, + * we presume that we will in fact form a packet, and update + * the bits by what we do actually send. If we send nothing, + * we just back out sl.length () to the old value, and no harm + * is done. + * I think this is simpler than doing a bunch of checks to see + * what if anything we need to send, setting the bits, then + * doing those checks again to add the real data. + */ + oldlen = sl.length (); - for (y = ob->y - socket.mapy / 2; y < max_y; y++, ay++) - { - sint16 nx, ny; - maptile *m = 0; + sl << uint16 (mask); - ax = 0; - for (x = ob->x - socket.mapx / 2; x < max_x; x++, ax++) - { - // check to see if we can simply go one right quickly - ++nx; - if (m && nx >= m->width) - m = 0; + unsigned char dummy; + unsigned char *last_ext = &dummy; - if (!m) - { - nx = x; ny = y; m = plmap; + /* Darkness changed */ + if (lastcell.count != d) + { + mask |= 0x8; - if (xy_normalise (m, nx, ny)) - m->touch (); - else - m = 0; - } + *last_ext |= 0x80; + last_ext = &sl[sl.length ()]; + sl << uint8 (d); + } - int emask, mask; - emask = mask = (ax & 0x3f) << 10 | (ay & 0x3f) << 4; + lastcell.count = d; - MapCell &lastcell = socket.lastmap.cells[ax][ay]; + mapspace &ms = m->at (nx, ny); + ms.update (); - /* If the coordinates are not valid, or it is too dark to see, - * we tell the client as such - */ - if (!m) + // extmap handling + uint8 stat_hp = 0; + uint8 stat_width = 0; + uint8 flags = 0; + tag_t player = 0; + + // send hp information, if applicable + if (object *op = ms.faces_obj [0]) + if (op->is_head () && !op->invisible) { - /* space is out of map. Update space and clear values - * if this hasn't already been done. If the space is out - * of the map, it shouldn't have a head - */ - if (lastcell.count != -1) + if (op->stats.maxhp > op->stats.hp + && op->stats.maxhp > 0 + && (op->type == PLAYER + || op->type == DOOR // does not work, have maxhp 0 + || QUERY_FLAG (op, FLAG_MONSTER) + || QUERY_FLAG (op, FLAG_ALIVE) + || QUERY_FLAG (op, FLAG_GENERATOR))) { - sl << uint16 (mask); - map_clearcell (&lastcell, -1); + stat_hp = 255 - (op->stats.hp * 255 + 254) / op->stats.maxhp; + stat_width = op->arch->max_x - op->arch->x; //TODO: should be upper-left edge } - continue; - } - - int d = pl->blocked_los[ax][ay]; - - if (d > 3) - { - - int need_send = 0, count; - - /* This block deals with spaces that are not visible for whatever - * reason. Still may need to send the head for this space. - */ - - oldlen = sl.length (); - - sl << uint16 (mask); - - if (lastcell.count != -1) - need_send = 1; - - count = -1; - - /* properly clear a previously sent big face */ - if (lastcell.faces[0] || lastcell.faces[1] || lastcell.faces[2] - || lastcell.stat_hp || lastcell.flags || lastcell.player) - need_send = 1; + if (expect_false (op->has_dialogue ())) + flags |= 1; - map_clearcell (&lastcell, count); - - if ((mask & 0xf) || need_send) - sl[oldlen + 1] = mask & 0xff; - else - sl.reset (oldlen); + if (expect_false (op->type == PLAYER)) + player = op == ob ? pl->ob->count + : op == pl->ob ? ob->count + : op->count; } - else - { - /* In this block, the space is visible. - */ - - /* Rather than try to figure out what everything that we might - * need to send is, then form the packet after that, - * we presume that we will in fact form a packet, and update - * the bits by what we do actually send. If we send nothing, - * we just back out sl.length () to the old value, and no harm - * is done. - * I think this is simpler than doing a bunch of checks to see - * what if anything we need to send, setting the bits, then - * doing those checks again to add the real data. - */ - oldlen = sl.length (); - eoldlen = esl.length (); - - sl << uint16 (mask); - - unsigned char dummy; - unsigned char *last_ext = &dummy; - - /* Darkness changed */ - if (lastcell.count != d && socket.darkness) - { - mask |= 0x8; - if (socket.extmap) - { - *last_ext |= 0x80; - last_ext = &sl[sl.length ()]; - sl << uint8 (d); - } - else - sl << uint8 (255 - 64 * d); - } + if (expect_false (lastcell.stat_hp != stat_hp)) + { + lastcell.stat_hp = stat_hp; - lastcell.count = d; + mask |= 0x8; + *last_ext |= 0x80; + last_ext = &sl[sl.length ()]; - mapspace &ms = m->at (nx, ny); - ms.update (); + sl << uint8 (5) << uint8 (stat_hp); - if (socket.extmap) - { - uint8 stat_hp = 0; - uint8 stat_width = 0; - uint8 flags = 0; - tag_t player = 0; - - // send hp information, if applicable - if (object *op = ms.faces_obj [0]) - if (op->is_head () && !op->invisible) - { - if (op->stats.maxhp > op->stats.hp - && op->stats.maxhp > 0 - && (op->type == PLAYER - || op->type == DOOR // does not work, have maxhp 0 - || QUERY_FLAG (op, FLAG_MONSTER) || QUERY_FLAG (op, FLAG_ALIVE) || QUERY_FLAG (op, FLAG_GENERATOR))) - { - stat_hp = 255 - (op->stats.hp * 255 + 254) / op->stats.maxhp; - stat_width = op->arch->max_x - op->arch->x; //TODO: should be upper-left edge - } - - if (op->msg && op->msg[0] == '@') - flags |= 1; - - if (op->type == PLAYER && op != ob) - player = op->count; - } - - if (lastcell.stat_hp != stat_hp) - { - lastcell.stat_hp = stat_hp; - - mask |= 0x8; - *last_ext |= 0x80; - last_ext = &sl[sl.length ()]; - - sl << uint8 (5) << uint8 (stat_hp); - - if (stat_width > 1) - { - *last_ext |= 0x80; - last_ext = &sl[sl.length ()]; + if (stat_width > 1) + { + *last_ext |= 0x80; + last_ext = &sl[sl.length ()]; - sl << uint8 (6) << uint8 (stat_width); - } - } + sl << uint8 (6) << uint8 (stat_width); + } + } - if (lastcell.player != player) - { - lastcell.player = player; + if (expect_false (lastcell.player != player)) + { + lastcell.player = player; - mask |= 0x8; - *last_ext |= 0x80; - last_ext = &sl[sl.length ()]; + mask |= 0x8; + *last_ext |= 0x80; + last_ext = &sl[sl.length ()]; - sl << uint8 (0x47) << uint8 (4) << (uint32)player; - } + sl << uint8 (0x47) << uint8 (4) << (uint32)player; + } - if (lastcell.flags != flags) - { - lastcell.flags = flags; + if (expect_false (lastcell.flags != flags)) + { + lastcell.flags = flags; - mask |= 0x8; - *last_ext |= 0x80; - last_ext = &sl[sl.length ()]; + mask |= 0x8; + *last_ext |= 0x80; + last_ext = &sl[sl.length ()]; - sl << uint8 (8) << uint8 (flags); - } - } - - /* Floor face */ - if (update_space (sl, socket, ms, lastcell, 2)) - mask |= 0x4; - - /* Middle face */ - if (update_space (sl, socket, ms, lastcell, 1)) - mask |= 0x2; + sl << uint8 (8) << uint8 (flags); + } - if (ms.player () == ob - && (ob->invisible & (ob->invisible < 50 ? 1 : 7))) - { - // force player to be visible to himself if invisible - if (lastcell.faces[0] != ob->face) - { - lastcell.faces[0] = ob->face; + // faces - mask |= 0x1; - sl << uint16 (ob->face); + /* Floor face */ + if (update_space (sl, socket, ms, lastcell, 2)) + mask |= 0x4; + + /* Middle face */ + if (update_space (sl, socket, ms, lastcell, 1)) + mask |= 0x2; + + if (expect_false (ob->invisible) + && ob->invisible & (ob->invisible < 50 ? 1 : 7) + && ms.player () == ob) + { + // force player to be visible to himself if invisible + if (lastcell.faces[0] != ob->face) + { + lastcell.faces[0] = ob->face; - socket.send_faces (ob); - } - } - /* Top face */ - else if (update_space (sl, socket, ms, lastcell, 0)) mask |= 0x1; + sl << uint16 (ob->face); - /* Check to see if we are in fact sending anything for this - * space by checking the mask. If so, update the mask. - * if not, reset the len to that from before adding the mask - * value, so we don't send those bits. - */ - if (mask & 0xf) - sl[oldlen + 1] = mask & 0xff; - else - sl.reset (oldlen); - - if (socket.ext_mapinfos) - esl << uint16 (emask); - - if (socket.EMI_smooth) - { - for (int layer = 2+1; layer--; ) - { - object *ob = ms.faces_obj [layer]; - - // If there is no object for this space, or if the face for the object - // is the blank face, set the smoothlevel to zero. - int smoothlevel = ob && ob->face != blank_face ? ob->smoothlevel : 0; - - // We've gotten what face we want to use for the object. Now see if - // if it has changed since we last sent it to the client. - if (lastcell.smooth[layer] != smoothlevel) - { - lastcell.smooth[layer] = smoothlevel; - esl << uint8 (smoothlevel); - emask |= 1 << layer; - } - } - - if (emask & 0xf) - esl[eoldlen + 1] = emask & 0xff; - else - esl.reset (eoldlen); - } - } /* else this is a viewable space */ - } /* for x loop */ - } /* for y loop */ + socket.send_faces (ob); + } + } + /* Top face */ + else if (update_space (sl, socket, ms, lastcell, 0)) + mask |= 0x1; + + /* Check to see if we are in fact sending anything for this + * space by checking the mask. If so, update the mask. + * if not, reset the len to that from before adding the mask + * value, so we don't send those bits. + */ + if (mask & 0xf) + sl[oldlen + 1] = mask & 0xff; + else + sl.reset (oldlen); + } /* else this is a viewable space */ + ordered_mapwalk_end socket.flush_fx (); - /* Verify that we in fact do need to send this */ - if (socket.ext_mapinfos) - { - if (!(sl.length () > startlen || socket.sent_scroll)) - { - /* No map data will follow, so don't say the client - * it doesn't need draw! - */ - ewhatflag &= ~EMI_NOREDRAW; - esl[ewhatstart + 1] = ewhatflag & 0xff; - } - - if (esl.length () > estartlen) - socket.send_packet (esl); - } - if (sl.length () > startlen || socket.sent_scroll) { socket.send_packet (sl); @@ -1435,7 +1237,7 @@ sl << "replyinfo skill_info\n"; for (int i = 1; i < NUM_SKILLS; i++) - sl.printf ("%d:%s\n", i + CS_STAT_SKILLINFO, &skill_names[i]); + sl.printf ("%d:%s\n", i + CS_STAT_SKILLINFO, &skill_names [i]); if (sl.length () > MAXSOCKBUF) { @@ -1489,21 +1291,21 @@ int flags = 0; /* check if we need to update it */ - if (spell->last_sp != SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA)) + if (spell->cached_sp != SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA)) { - spell->last_sp = SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA); + spell->cached_sp = SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA); flags |= UPD_SP_MANA; } - if (spell->last_grace != SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE)) + if (spell->cached_grace != SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE)) { - spell->last_grace = SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE); + spell->cached_grace = SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE); flags |= UPD_SP_GRACE; } - if (spell->last_eat != spell->stats.dam + SP_level_dam_adjust (pl->ob, spell)) + if (spell->cached_eat != spell->stats.dam + SP_level_dam_adjust (pl->ob, spell)) { - spell->last_eat = spell->stats.dam + SP_level_dam_adjust (pl->ob, spell); + spell->cached_eat = spell->stats.dam + SP_level_dam_adjust (pl->ob, spell); flags |= UPD_SP_DAMAGE; } @@ -1515,9 +1317,9 @@ << uint8 (flags) << uint32 (spell->count); - if (flags & UPD_SP_MANA ) sl << uint16 (spell->last_sp); - if (flags & UPD_SP_GRACE ) sl << uint16 (spell->last_grace); - if (flags & UPD_SP_DAMAGE) sl << uint16 (spell->last_eat); + if (flags & UPD_SP_MANA ) sl << uint16 (spell->cached_sp); + if (flags & UPD_SP_GRACE ) sl << uint16 (spell->cached_grace); + if (flags & UPD_SP_DAMAGE) sl << uint16 (spell->cached_eat); pl->ns->send_packet (sl); } @@ -1557,20 +1359,14 @@ } /* store costs and damage in the object struct, to compare to later */ - spell->last_sp = SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA); - spell->last_grace = SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE); - spell->last_eat = spell->stats.dam + SP_level_dam_adjust (pl->ob, spell); + spell->cached_sp = SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA); + spell->cached_grace = SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE); + spell->cached_eat = spell->stats.dam + SP_level_dam_adjust (pl->ob, spell); /* figure out which skill it uses, if it uses one */ if (spell->skill) - { - for (i = 1; i < NUM_SKILLS; i++) - if (!strcmp (spell->skill, skill_names[i])) - { - skill = i + CS_STAT_SKILLINFO; - break; - } - } + if (object *tmp = pl->find_skill (spell->skill)) + skill = tmp->subtype + CS_STAT_SKILLINFO; // spells better have a face if (!spell->face) @@ -1585,9 +1381,9 @@ sl << uint32 (spell->count) << uint16 (spell->level) << uint16 (spell->casting_time) - << uint16 (spell->last_sp) - << uint16 (spell->last_grace) - << uint16 (spell->last_eat) + << uint16 (spell->cached_sp) + << uint16 (spell->cached_grace) + << uint16 (spell->cached_eat) << uint8 (skill) << uint32 (spell->path_attuned) << uint32 (spell->face)