ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/socket/request.C
(Generate patch)

Comparing deliantra/server/socket/request.C (file contents):
Revision 1.84 by root, Tue Apr 3 00:21:38 2007 UTC vs.
Revision 1.111 by root, Sun Jul 1 04:08:14 2007 UTC

1/* 1/*
2 * CrossFire, A Multiplayer game for X-windows 2 * This file is part of Crossfire TRT, the Multiplayer Online Role Playing Game.
3 * 3 *
4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team 4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5 * Copyright (C) 2001 Mark Wedel 5 * Copyright (©) 2001,2007 Mark Wedel
6 * Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 * 7 *
8 * This program is free software; you can redistribute it and/or modify 8 * Crossfire TRT is free software; you can redistribute it and/or modify it
9 * it under the terms of the GNU General Public License as published by 9 * under the terms of the GNU General Public License as published by the Free
10 * the Free Software Foundation; either version 2 of the License, or 10 * Software Foundation; either version 2 of the License, or (at your option)
11 * (at your option) any later version. 11 * any later version.
12 * 12 *
13 * This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful, but
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 * GNU General Public License for more details. 16 * for more details.
17 * 17 *
18 * You should have received a copy of the GNU General Public License 18 * You should have received a copy of the GNU General Public License along
19 * along with this program; if not, write to the Free Software 19 * with Crossfire TRT; if not, write to the Free Software Foundation, Inc. 51
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 * 21 *
22 * The author can be reached via e-mail to <crossfire@schmorp.de> 22 * The authors can be reached via e-mail to <crossfire@schmorp.de>
23 */ 23 */
24 24
25/** 25/**
26 * \file 26 * \file
27 * Client handling. 27 * Client handling.
145/** check for map/region change and send new map data */ 145/** check for map/region change and send new map data */
146static void 146static void
147check_map_change (player *pl) 147check_map_change (player *pl)
148{ 148{
149 client &socket = *pl->ns; 149 client &socket = *pl->ns;
150 object *ob = pl->ob; 150 object *ob = pl->observe;
151 char buf[MAX_BUF]; /* eauugggh */
152 151
153 if (socket.force_newmap) 152 if (socket.current_map != ob->map || socket.force_newmap)
154 {
155 // force newmap is used for clients that do not redraw their map
156 // after image uploads.
157 socket.current_map = ob->map;
158 clear_map (pl);
159 }
160 else if (socket.current_map != ob->map)
161 { 153 {
162 clear_map (pl); 154 clear_map (pl);
163 socket.current_map = ob->map; 155 socket.current_map = ob->map;
164 156
165 if (socket.mapinfocmd) 157 if (socket.mapinfocmd)
166 { 158 {
167 if (ob->map && ob->map->path[0]) 159 if (ob->map && ob->map->path[0])
168 { 160 {
169 int flags = 0; 161 int flags = 0;
170 162
171 if (ob->map->tile_path[0]) 163 if (ob->map->tile_path[0]) flags |= 1;
172 flags |= 1;
173 if (ob->map->tile_path[1]) 164 if (ob->map->tile_path[1]) flags |= 2;
174 flags |= 2;
175 if (ob->map->tile_path[2]) 165 if (ob->map->tile_path[2]) flags |= 4;
176 flags |= 4;
177 if (ob->map->tile_path[3]) 166 if (ob->map->tile_path[3]) flags |= 8;
178 flags |= 8;
179 167
180 snprintf (buf, MAX_BUF, "mapinfo - spatial %d %d %d %d %d %s", 168 socket.send_packet_printf ("mapinfo - spatial %d %d %d %d %d %s",
181 flags, socket.mapx / 2 - ob->x, socket.mapy / 2 - ob->y, ob->map->width, ob->map->height, &ob->map->path); 169 flags, socket.mapx / 2 - ob->x, socket.mapy / 2 - ob->y,
170 ob->map->width, ob->map->height, &ob->map->path);
182 } 171 }
183 else 172 else
184 snprintf (buf, MAX_BUF, "mapinfo current");
185
186 socket.send_packet (buf); 173 socket.send_packet ("mapinfo current");
187 } 174 }
188 } 175 }
189 else if (socket.current_x != ob->x || socket.current_y != ob->y) 176 else if (socket.current_x != ob->x || socket.current_y != ob->y)
190 { 177 {
191 int dx = ob->x - socket.current_x; 178 int dx = ob->x - socket.current_x;
332 snprintf (bigbuf, MAX_BUF, "mapinfo %s error", token); 319 snprintf (bigbuf, MAX_BUF, "mapinfo %s error", token);
333 else if (map && map->path[0]) 320 else if (map && map->path[0])
334 { 321 {
335 int flags = 0; 322 int flags = 0;
336 323
337 if (map->tile_path[0]) 324 if (map->tile_path[0]) flags |= 1;
338 flags |= 1;
339 if (map->tile_path[1]) 325 if (map->tile_path[1]) flags |= 2;
340 flags |= 2;
341 if (map->tile_path[2]) 326 if (map->tile_path[2]) flags |= 4;
342 flags |= 4;
343 if (map->tile_path[3]) 327 if (map->tile_path[3]) flags |= 8;
344 flags |= 8;
345 328
346 snprintf (bigbuf, MAX_BUF, "mapinfo %s spatial %d %d %d %d %d %s", token, flags, mapx, mapy, map->width, map->height, &map->path); 329 snprintf (bigbuf, MAX_BUF, "mapinfo %s spatial %d %d %d %d %d %s", token, flags, mapx, mapy, map->width, map->height, &map->path);
347 } 330 }
348 else 331 else
349 snprintf (bigbuf, MAX_BUF, "mapinfo %s nomap", token); 332 snprintf (bigbuf, MAX_BUF, "mapinfo %s nomap", token);
488 471
489 ns->send_packet (cmdback); 472 ns->send_packet (cmdback);
490} 473}
491 474
492/** 475/**
493 * client requested an image. send it rate-limited
494 * before flushing.
495 */
496void
497AskFaceCmd (char *buf, int len, client *ns)
498{
499 ns->askface.push_back (atoi (buf));
500}
501
502/**
503 * Tells client the picture it has to use
504 * to smooth a picture number given as argument.
505 */
506void
507AskSmooth (char *buf, int len, client *ns)
508{
509 ns->send_face (atoi (buf));
510 ns->flush_fx ();
511}
512
513/**
514 * This handles the general commands from the client (ie, north, fire, cast, 476 * This handles the general commands from the client (ie, north, fire, cast,
515 * etc.) 477 * etc.)
516 */ 478 */
517void 479void
518PlayerCmd (char *buf, int len, player *pl) 480PlayerCmd (char *buf, int len, player *pl)
538 * for the command that issued the count should be done before any other 500 * for the command that issued the count should be done before any other
539 * commands. 501 * commands.
540 */ 502 */
541 pl->count = 0; 503 pl->count = 0;
542} 504}
543
544 505
545/** 506/**
546 * This handles the general commands from the client (ie, north, fire, cast, 507 * This handles the general commands from the client (ie, north, fire, cast,
547 * etc.). It is a lot like PlayerCmd above, but is called with the 508 * etc.). It is a lot like PlayerCmd above, but is called with the
548 * 'ncom' method which gives more information back to the client so it 509 * 'ncom' method which gives more information back to the client so it
618 { 579 {
619 case ST_PLAYING: 580 case ST_PLAYING:
620 LOG (llevError, "Got reply message with ST_PLAYING input state\n"); 581 LOG (llevError, "Got reply message with ST_PLAYING input state\n");
621 break; 582 break;
622 583
623 case ST_CHANGE_CLASS:
624 key_change_class (pl->ob, buf[0]);
625 break;
626
627 case ST_GET_PARTY_PASSWORD: /* Get password for party */ 584 case ST_GET_PARTY_PASSWORD: /* Get password for party */
628 receive_party_password (pl->ob, 13); 585 receive_party_password (pl->ob, 13);
629 break; 586 break;
630 587
631 default: 588 default:
670 627
671 cp = strchr (cp + 1, ' '); 628 cp = strchr (cp + 1, ' ');
672 629
673 if (cp) 630 if (cp)
674 { 631 {
675 assign (ns->version, cp + 1); 632 ns->version = cp + 1;
676 633
677 if (ns->sc_version < 1026) 634 if (ns->sc_version < 1026)
678 ns->send_packet_printf ("drawinfo %d %s", NDI_RED, 635 ns->send_packet_printf ("drawinfo %d %s", NDI_RED,
679 "**** VERSION WARNING ****\n**** CLIENT IS TOO OLD!! UPDATE THE CLIENT!! ****"); 636 "**** VERSION WARNING ****\n**** CLIENT IS TOO OLD!! UPDATE THE CLIENT!! ****");
680 } 637 }
745send_query (client *ns, uint8 flags, const char *text) 702send_query (client *ns, uint8 flags, const char *text)
746{ 703{
747 ns->send_packet_printf ("query %d %s", flags, text ? text : ""); 704 ns->send_packet_printf ("query %d %s", flags, text ? text : "");
748} 705}
749 706
707/**
708 * Get player's current range attack in obuf.
709 */
710static void
711rangetostring (player *pl, char *obuf)
712{
713 dynbuf_text buf;
714
715 if (pl->ranged_ob)
716 buf << " Range" << (pl->ob->current_weapon == pl->ranged_ob ? "*" : "") << ": " << pl->ranged_ob->name;
717
718 if (pl->combat_ob)
719 buf << " Combat" << (pl->ob->current_weapon == pl->combat_ob ? "*" : "") << ": " << pl->combat_ob->name;
720
721#if 0
722 //TODO: remove this when slot system is working, this is only for debugging
723 if (pl->ob->chosen_skill)
724 buf << " Skill*: " << pl->ob->chosen_skill->name;
725#endif
726
727 //TODO: maybe golem should become the current_weapon, quite simply?
728 if (pl->golem)
729 buf << " Golem*: " << pl->golem->name;
730
731 buf << '\0';
732 buf.linearise (obuf);
733}
734
750#define AddIfInt64(Old,New,Type) if (Old != New) {\ 735#define AddIfInt64(Old,New,Type) if (Old != New) {\
751 Old = New; \ 736 Old = New; \
752 sl << uint8 (Type) << uint64 (New); \ 737 sl << uint8 (Type) << uint64 (New); \
753 } 738 }
754 739
760#define AddIfShort(Old,New,Type) if (Old != New) {\ 745#define AddIfShort(Old,New,Type) if (Old != New) {\
761 Old = New; \ 746 Old = New; \
762 sl << uint8 (Type) << uint16 (New); \ 747 sl << uint8 (Type) << uint16 (New); \
763 } 748 }
764 749
765#define AddIfFloat(Old,New,Type) if (Old != New) {\ 750#define AddIfFloat(Old,New,Type,mult) if (Old != New) {\
766 Old = New; \ 751 Old = New; \
767 sl << uint8 (Type) << uint32 (New*FLOAT_MULTI); \ 752 sl << uint8 (Type) << uint32 (New*FLOAT_MULTI*mult); \
768 } 753 }
769 754
770#define AddIfString(Old,New,Type) if (Old == NULL || strcmp(Old,New)) {\ 755#define AddIfString(Old,New,Type) if (Old == NULL || strcmp(Old,New)) {\
771 free(Old); Old = strdup (New);\ 756 free(Old); Old = strdup (New);\
772 sl << uint8 (Type) << data8 (New); \ 757 sl << uint8 (Type) << data8 (New); \
786 771
787 client *ns = pl->ns; 772 client *ns = pl->ns;
788 if (!ns) 773 if (!ns)
789 return; 774 return;
790 775
791 object *ob = pl->ob; 776 object *ob = pl->observe;
792 if (!ob) 777 if (!ob)
793 return; 778 return;
779
780 player *opl = ob->contr ? static_cast<player *>(ob->contr) : pl;
794 781
795 packet sl ("stats"); 782 packet sl ("stats");
796 783
797 AddIfShort (ns->last_stats.hp, ob->stats.hp, CS_STAT_HP); 784 AddIfShort (ns->last_stats.hp, ob->stats.hp, CS_STAT_HP);
798 AddIfShort (ns->last_stats.maxhp, ob->stats.maxhp, CS_STAT_MAXHP); 785 AddIfShort (ns->last_stats.maxhp, ob->stats.maxhp, CS_STAT_MAXHP);
807 AddIfShort (ns->last_stats.Wis, ob->stats.Wis, CS_STAT_WIS); 794 AddIfShort (ns->last_stats.Wis, ob->stats.Wis, CS_STAT_WIS);
808 AddIfShort (ns->last_stats.Pow, ob->stats.Pow, CS_STAT_POW); 795 AddIfShort (ns->last_stats.Pow, ob->stats.Pow, CS_STAT_POW);
809 AddIfShort (ns->last_stats.Cha, ob->stats.Cha, CS_STAT_CHA); 796 AddIfShort (ns->last_stats.Cha, ob->stats.Cha, CS_STAT_CHA);
810 797
811 for (int s = 0; s < NUM_SKILLS; s++) 798 for (int s = 0; s < NUM_SKILLS; s++)
812 if (object *skill = pl->last_skill_ob[s]) 799 if (object *skill = opl->last_skill_ob[s])
813 if (skill->stats.exp != ns->last_skill_exp [s]) 800 if (skill->stats.exp != ns->last_skill_exp [s])
814 { 801 {
815 ns->last_skill_exp [s] = skill->stats.exp; 802 ns->last_skill_exp [s] = skill->stats.exp;
816 803
817 /* Always send along the level if exp changes. This is only 804 /* Always send along the level if exp changes. This is only
825 AddIfInt64 (ns->last_stats.exp, ob->stats.exp, CS_STAT_EXP64); 812 AddIfInt64 (ns->last_stats.exp, ob->stats.exp, CS_STAT_EXP64);
826 AddIfShort (ns->last_level, ob->level, CS_STAT_LEVEL); 813 AddIfShort (ns->last_level, ob->level, CS_STAT_LEVEL);
827 AddIfShort (ns->last_stats.wc, ob->stats.wc, CS_STAT_WC); 814 AddIfShort (ns->last_stats.wc, ob->stats.wc, CS_STAT_WC);
828 AddIfShort (ns->last_stats.ac, ob->stats.ac, CS_STAT_AC); 815 AddIfShort (ns->last_stats.ac, ob->stats.ac, CS_STAT_AC);
829 AddIfShort (ns->last_stats.dam, ob->stats.dam, CS_STAT_DAM); 816 AddIfShort (ns->last_stats.dam, ob->stats.dam, CS_STAT_DAM);
830 AddIfFloat (ns->last_speed, ob->speed, CS_STAT_SPEED); 817 AddIfFloat (ns->last_speed, ob->speed, CS_STAT_SPEED, 1.f/TICK);
831 AddIfShort (ns->last_stats.food, ob->stats.food, CS_STAT_FOOD); 818 AddIfShort (ns->last_stats.food, ob->stats.food, CS_STAT_FOOD);
832 AddIfFloat (ns->last_weapon_sp, pl->weapon_sp, CS_STAT_WEAP_SP); 819 AddIfFloat (ns->last_weapon_sp, pl->weapon_sp, CS_STAT_WEAP_SP, 1.f/TICK);
833 AddIfInt (ns->last_weight_limit, weight_limit[ob->stats.Str], CS_STAT_WEIGHT_LIM); 820 AddIfInt (ns->last_weight_limit, weight_limit[ob->stats.Str], CS_STAT_WEIGHT_LIM);
834 821
835 flags = 0; 822 flags = 0;
836 823
837 if (pl->fire_on) 824 if (opl->fire_on)
838 flags |= SF_FIREON; 825 flags |= SF_FIREON;
839 826
840 if (pl->run_on) 827 if (opl->run_on)
841 flags |= SF_RUNON; 828 flags |= SF_RUNON;
842 829
843 AddIfShort (ns->last_flags, flags, CS_STAT_FLAGS); 830 AddIfShort (ns->last_flags, flags, CS_STAT_FLAGS);
844 831
845 if (ns->sc_version < 1025) 832 if (ns->sc_version < 1025)
859 AddIfInt (ns->last_path_attuned, ob->path_attuned, CS_STAT_SPELL_ATTUNE); 846 AddIfInt (ns->last_path_attuned, ob->path_attuned, CS_STAT_SPELL_ATTUNE);
860 AddIfInt (ns->last_path_repelled, ob->path_repelled, CS_STAT_SPELL_REPEL); 847 AddIfInt (ns->last_path_repelled, ob->path_repelled, CS_STAT_SPELL_REPEL);
861 AddIfInt (ns->last_path_denied, ob->path_denied, CS_STAT_SPELL_DENY); 848 AddIfInt (ns->last_path_denied, ob->path_denied, CS_STAT_SPELL_DENY);
862 } 849 }
863 850
864 rangetostring (ob, buf); /* we want use the new fire & run system in new client */ 851 rangetostring (opl, buf); /* we want use the new fire & run system in new client */
865 AddIfString (ns->stats.range, buf, CS_STAT_RANGE); 852 AddIfString (ns->stats.range, buf, CS_STAT_RANGE);
866 set_title (ob, buf); 853 set_title (ob, buf);
867 AddIfString (ns->stats.title, buf, CS_STAT_TITLE); 854 AddIfString (ns->stats.title, buf, CS_STAT_TITLE);
868 855
869 /* Only send it away if we have some actual data */ 856 /* Only send it away if we have some actual data */
1003{ 990{
1004 prefetch_surrounding_maps (op->map, 3); 991 prefetch_surrounding_maps (op->map, 3);
1005} 992}
1006 993
1007/** 994/**
1008 * This function uses the new map1 protocol command to send the map 995 * Draws client map.
1009 * to the client. It is necessary because the old map command supports
1010 * a maximum map size of 15x15.
1011 * This function is much simpler than the old one. This is because
1012 * the old function optimized to send as few face identifiers as possible,
1013 * at the expense of sending more coordinate location (coordinates were
1014 * only 1 byte, faces 2 bytes, so this was a worthwhile savings). Since
1015 * we need 2 bytes for coordinates and 2 bytes for faces, such a trade off
1016 * maps no sense. Instead, we actually really only use 12 bits for coordinates,
1017 * and use the other 4 bits for other informatiion. For full documentation
1018 * of what we send, see the doc/Protocol file.
1019 * I will describe internally what we do:
1020 * the ns->lastmap shows how the map last looked when sent to the client.
1021 * in the lastmap structure, there is a cells array, which is set to the
1022 * maximum viewable size (As set in config.h).
1023 * in the cells, there are faces and a count value.
1024 * we use the count value to hold the darkness value. If -1, then this space
1025 * is not viewable.
1026 * we use faces[0] faces[1] faces[2] to hold what the three layers
1027 * look like.
1028 */ 996 */
1029void 997void
1030draw_client_map1 (object *pl) 998draw_client_map (player *pl)
1031{ 999{
1000 object *ob = pl->observe;
1001 if (!ob->active)
1002 return;
1003
1004 maptile *plmap = ob->map;
1005
1006 /* If player is just joining the game, he isn't here yet, so the map
1007 * can get swapped out. If so, don't try to send them a map. All will
1008 * be OK once they really log in.
1009 */
1010 if (!plmap || plmap->in_memory != MAP_IN_MEMORY)
1011 return;
1012
1032 int x, y, ax, ay, startlen, max_x, max_y, oldlen; 1013 int x, y, ax, ay, startlen, max_x, max_y, oldlen;
1033 sint16 nx, ny;
1034 int estartlen, eoldlen; 1014 int estartlen, eoldlen;
1035 uint8 eentrysize; 1015 uint8 eentrysize;
1036 uint16 ewhatstart, ewhatflag; 1016 uint16 ewhatstart, ewhatflag;
1037 uint8 extendedinfos; 1017 uint8 extendedinfos;
1038 maptile *m;
1039 1018
1040 client &socket = *pl->contr->ns;
1041
1042 if (!pl->active)
1043 return;
1044
1045 check_map_change (pl->contr); 1019 check_map_change (pl);
1046 prefetch_surrounding_maps (pl); 1020 prefetch_surrounding_maps (pl->ob);
1021
1022 /* do LOS after calls to update_position */
1023 if (ob != pl->ob)
1024 clear_los (pl);
1025 else if (pl->do_los)
1026 {
1027 update_los (ob);
1028 pl->do_los = 0;
1029 }
1030
1031 /**
1032 * This function uses the new map1 protocol command to send the map
1033 * to the client. It is necessary because the old map command supports
1034 * a maximum map size of 15x15.
1035 * This function is much simpler than the old one. This is because
1036 * the old function optimized to send as few face identifiers as possible,
1037 * at the expense of sending more coordinate location (coordinates were
1038 * only 1 byte, faces 2 bytes, so this was a worthwhile savings). Since
1039 * we need 2 bytes for coordinates and 2 bytes for faces, such a trade off
1040 * maps no sense. Instead, we actually really only use 12 bits for coordinates,
1041 * and use the other 4 bits for other informatiion. For full documentation
1042 * of what we send, see the doc/Protocol file.
1043 * I will describe internally what we do:
1044 * the ns->lastmap shows how the map last looked when sent to the client.
1045 * in the lastmap structure, there is a cells array, which is set to the
1046 * maximum viewable size (As set in config.h).
1047 * in the cells, there are faces and a count value.
1048 * we use the count value to hold the darkness value. If -1, then this space
1049 * is not viewable.
1050 * we use faces[0] faces[1] faces[2] to hold what the three layers
1051 * look like.
1052 */
1053
1054 client &socket = *pl->ns;
1047 1055
1048 packet sl (socket.mapmode == Map1Cmd ? "map1" : "map1a"); 1056 packet sl (socket.mapmode == Map1Cmd ? "map1" : "map1a");
1049 packet esl; 1057 packet esl;
1050 1058
1051 startlen = sl.length (); 1059 startlen = sl.length ();
1075 ay = 0; 1083 ay = 0;
1076 1084
1077 /* We could do this logic as conditionals in the if statement, 1085 /* We could do this logic as conditionals in the if statement,
1078 * but that started to get a bit messy to look at. 1086 * but that started to get a bit messy to look at.
1079 */ 1087 */
1080 max_x = pl->x + (socket.mapx + 1) / 2; 1088 max_x = ob->x + (socket.mapx + 1) / 2;
1081 max_y = pl->y + (socket.mapy + 1) / 2; 1089 max_y = ob->y + (socket.mapy + 1) / 2;
1082 1090
1083 maptile *plmap = pl->map;
1084
1085 for (y = pl->y - socket.mapy / 2; y < max_y; y++, ay++) 1091 for (y = ob->y - socket.mapy / 2; y < max_y; y++, ay++)
1086 { 1092 {
1093 sint16 nx, ny;
1094 maptile *m = 0;
1095
1087 ax = 0; 1096 ax = 0;
1088 for (x = pl->x - socket.mapx / 2; x < max_x; x++, ax++) 1097 for (x = ob->x - socket.mapx / 2; x < max_x; x++, ax++)
1089 { 1098 {
1099 // check to see if we can simply go one right quickly
1100 ++nx;
1101 if (m && nx >= m->width)
1102 m = 0;
1103
1104 if (!m)
1105 {
1106 nx = x; ny = y; m = plmap;
1107
1108 if (!xy_normalise (m, nx, ny))
1109 m = 0;
1110 }
1111
1090 int emask, mask; 1112 int emask, mask;
1091 emask = mask = (ax & 0x3f) << 10 | (ay & 0x3f) << 4; 1113 emask = mask = (ax & 0x3f) << 10 | (ay & 0x3f) << 4;
1092 1114
1093 MapCell &lastcell = socket.lastmap.cells[ax][ay]; 1115 MapCell &lastcell = socket.lastmap.cells[ax][ay];
1094 1116
1095 /* If the coordinates are not valid, or it is too dark to see, 1117 /* If the coordinates are not valid, or it is too dark to see,
1096 * we tell the client as such 1118 * we tell the client as such
1097 */ 1119 */
1098 nx = x;
1099 ny = y;
1100 m = get_map_from_coord (plmap, &nx, &ny);
1101
1102 if (!m) 1120 if (!m)
1103 { 1121 {
1104 /* space is out of map. Update space and clear values 1122 /* space is out of map. Update space and clear values
1105 * if this hasn't already been done. If the space is out 1123 * if this hasn't already been done. If the space is out
1106 * of the map, it shouldn't have a head 1124 * of the map, it shouldn't have a head
1114 continue; 1132 continue;
1115 } 1133 }
1116 1134
1117 m->touch (); 1135 m->touch ();
1118 1136
1119 int d = pl->contr->blocked_los[ax][ay]; 1137 int d = pl->blocked_los[ax][ay];
1120 1138
1121 if (d > 3) 1139 if (d > 3)
1122 { 1140 {
1123 1141
1124 int need_send = 0, count; 1142 int need_send = 0, count;
1187 } 1205 }
1188 1206
1189 lastcell.count = d; 1207 lastcell.count = d;
1190 1208
1191 mapspace &ms = m->at (nx, ny); 1209 mapspace &ms = m->at (nx, ny);
1210 ms.update ();
1192 1211
1193 if (socket.extmap) 1212 if (socket.extmap)
1194 { 1213 {
1195 uint8 stat_hp = 0; 1214 uint8 stat_hp = 0;
1196 uint8 stat_width = 0; 1215 uint8 stat_width = 0;
1197 uint8 flags = 0; 1216 uint8 flags = 0;
1198 UUID player = 0; 1217 tag_t player = 0;
1199 1218
1200 // send hp information, if applicable 1219 // send hp information, if applicable
1201 if (object *op = ms.faces_obj [0]) 1220 if (object *op = ms.faces_obj [0])
1202 { 1221 {
1203 if (op->head || op->invisible) 1222 if (op->head || op->invisible)
1206 || QUERY_FLAG (op, FLAG_MONSTER) || QUERY_FLAG (op, FLAG_ALIVE) || QUERY_FLAG (op, FLAG_GENERATOR)) 1225 || QUERY_FLAG (op, FLAG_MONSTER) || QUERY_FLAG (op, FLAG_ALIVE) || QUERY_FLAG (op, FLAG_GENERATOR))
1207 { 1226 {
1208 if (op->stats.maxhp > 0 && (unsigned) op->stats.maxhp > (unsigned) op->stats.hp) 1227 if (op->stats.maxhp > 0 && (unsigned) op->stats.maxhp > (unsigned) op->stats.hp)
1209 { 1228 {
1210 stat_hp = 255 - (op->stats.hp * 255 + 254) / op->stats.maxhp; 1229 stat_hp = 255 - (op->stats.hp * 255 + 254) / op->stats.maxhp;
1211 stat_width = op->arch->tail_x; 1230 stat_width = op->arch->max_x - op->arch->x; //TODO: should be upper-left edge
1212 } 1231 }
1213 } 1232 }
1214 1233
1215 if (op->msg && op->msg[0] == '@') 1234 if (op->msg && op->msg[0] == '@')
1216 flags |= 1; 1235 flags |= 1;
1217 1236
1218 if (op->type == PLAYER && op != pl) 1237 if (op->type == PLAYER && op != ob)
1219 player = op->count; 1238 player = op->count;
1220 } 1239 }
1221 1240
1222 if (lastcell.stat_hp != stat_hp) 1241 if (lastcell.stat_hp != stat_hp)
1223 { 1242 {
1244 1263
1245 mask |= 0x8; 1264 mask |= 0x8;
1246 *last_ext |= 0x80; 1265 *last_ext |= 0x80;
1247 last_ext = &sl[sl.length ()]; 1266 last_ext = &sl[sl.length ()];
1248 1267
1249 sl << uint8 (0x47) << uint8 (8) << (uint64)player; 1268 sl << uint8 (0x47) << uint8 (4) << (uint32)player;
1250 } 1269 }
1251 1270
1252 if (lastcell.flags != flags) 1271 if (lastcell.flags != flags)
1253 { 1272 {
1254 lastcell.flags = flags; 1273 lastcell.flags = flags;
1267 1286
1268 /* Middle face */ 1287 /* Middle face */
1269 if (update_space (sl, socket, ms, lastcell, 1)) 1288 if (update_space (sl, socket, ms, lastcell, 1))
1270 mask |= 0x2; 1289 mask |= 0x2;
1271 1290
1272 if (ms.player () == pl 1291 if (ms.player () == ob
1273 && (pl->invisible & (pl->invisible < 50 ? 1 : 7))) 1292 && (ob->invisible & (ob->invisible < 50 ? 1 : 7)))
1274 { 1293 {
1275 // force player to be visible to himself if invisible 1294 // force player to be visible to himself if invisible
1276 if (lastcell.faces[0] != pl->face) 1295 if (lastcell.faces[0] != ob->face)
1277 { 1296 {
1278 lastcell.faces[0] = pl->face; 1297 lastcell.faces[0] = ob->face;
1279 1298
1280 mask |= 0x1; 1299 mask |= 0x1;
1281 sl << uint16 (pl->face); 1300 sl << uint16 (ob->face);
1282 1301
1283 socket.send_faces (pl); 1302 socket.send_faces (ob);
1284 } 1303 }
1285 } 1304 }
1286 /* Top face */ 1305 /* Top face */
1287 else if (update_space (sl, socket, ms, lastcell, 0)) 1306 else if (update_space (sl, socket, ms, lastcell, 0))
1288 mask |= 0x1; 1307 mask |= 0x1;
1289
1290 1308
1291 /* Check to see if we are in fact sending anything for this 1309 /* Check to see if we are in fact sending anything for this
1292 * space by checking the mask. If so, update the mask. 1310 * space by checking the mask. If so, update the mask.
1293 * if not, reset the len to that from before adding the mask 1311 * if not, reset the len to that from before adding the mask
1294 * value, so we don't send those bits. 1312 * value, so we don't send those bits.
1353 socket.send_packet (sl); 1371 socket.send_packet (sl);
1354 socket.sent_scroll = 0; 1372 socket.sent_scroll = 0;
1355 } 1373 }
1356} 1374}
1357 1375
1358/**
1359 * Draws client map.
1360 */
1361void
1362draw_client_map (object *pl)
1363{
1364 int i, j;
1365 sint16 ax, ay; /* ax and ay goes from 0 to max-size of arrays */
1366 int mflags;
1367 struct Map newmap;
1368 maptile *m, *pm;
1369
1370 if (pl->type != PLAYER)
1371 {
1372 LOG (llevError, "draw_client_map called with non player/non eric-server\n");
1373 return;
1374 }
1375
1376 pm = pl->map;
1377
1378 /* If player is just joining the game, he isn't here yet, so the map
1379 * can get swapped out. If so, don't try to send them a map. All will
1380 * be OK once they really log in.
1381 */
1382 if (pm == NULL || pm->in_memory != MAP_IN_MEMORY)
1383 return;
1384
1385 memset (&newmap, 0, sizeof (struct Map));
1386
1387 for (j = (pl->y - pl->contr->ns->mapy / 2); j < (pl->y + (pl->contr->ns->mapy + 1) / 2); j++)
1388 for (i = (pl->x - pl->contr->ns->mapx / 2); i < (pl->x + (pl->contr->ns->mapx + 1) / 2); i++)
1389 {
1390 ax = i;
1391 ay = j;
1392 m = pm;
1393 mflags = get_map_flags (m, &m, ax, ay, &ax, &ay);
1394
1395 if (mflags & P_OUT_OF_MAP)
1396 continue;
1397
1398 /* If a map is visible to the player, we don't want to swap it out
1399 * just to reload it. This should really call something like
1400 * swap_map, but this is much more efficient and 'good enough'
1401 */
1402 if (mflags & P_NEW_MAP)
1403 m->timeout = 50;
1404 }
1405
1406 /* do LOS after calls to update_position */
1407 if (pl->contr->do_los)
1408 {
1409 update_los (pl);
1410 pl->contr->do_los = 0;
1411 }
1412
1413 /* Big maps need a different drawing mechanism to work */
1414 draw_client_map1 (pl);
1415}
1416
1417
1418/*****************************************************************************/ 1376/*****************************************************************************/
1419
1420/* GROS: The following one is used to allow a plugin to send a generic cmd to*/ 1377/* GROS: The following one is used to allow a plugin to send a generic cmd to*/
1421
1422/* a player. Of course, the client need to know the command to be able to */ 1378/* a player. Of course, the client need to know the command to be able to */
1423
1424/* manage it ! */ 1379/* manage it ! */
1425
1426/*****************************************************************************/ 1380/*****************************************************************************/
1427void 1381void
1428send_plugin_custom_message (object *pl, char *buf) 1382send_plugin_custom_message (object *pl, char *buf)
1429{ 1383{
1430 pl->contr->ns->send_packet (buf); 1384 pl->contr->ns->send_packet (buf);

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines