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.45 by root, Tue Dec 19 04:58:05 2006 UTC vs.
Revision 1.49 by root, Thu Dec 21 06:12:37 2006 UTC

… …
138} 138}
139 139
140static void 140static void
141clear_map (player *pl) 141clear_map (player *pl)
142{ 142{
143 client &socket = *pl->socket;
144
145 memset (&socket.lastmap, 0, sizeof (socket.lastmap)); 143 memset (&pl->socket->lastmap, 0, sizeof (pl->socket->lastmap));
146 144
147 if (socket.newmapcmd == 1) 145 if (pl->socket->newmapcmd == 1)
148 socket.send_packet ("newmap"); 146 pl->socket->send_packet ("newmap");
149 147
150 socket.update_look = 1; 148 pl->socket->floorbox_reset ();
151 socket.look_position = 0;
152} 149}
153 150
154/** check for map change and send new map data */ 151/** check for map change and send new map data */
155static void 152static void
156check_map_change (player *pl) 153check_map_change (player *pl)
… …
197 if (socket.buggy_mapscroll && (abs (dx) > 8 || abs (dy) > 8)) 194 if (socket.buggy_mapscroll && (abs (dx) > 8 || abs (dy) > 8))
198 clear_map (pl); // current (<= 1.9.1) clients have unchecked buffer overflows 195 clear_map (pl); // current (<= 1.9.1) clients have unchecked buffer overflows
199 else 196 else
200 { 197 {
201 socket_map_scroll (&socket, ob->x - socket.current_x, ob->y - socket.current_y); 198 socket_map_scroll (&socket, ob->x - socket.current_x, ob->y - socket.current_y);
202 socket.update_look = 1; 199 socket.floorbox_reset ();
203 socket.look_position = 0;
204 } 200 }
205 } 201 }
206 202
207 socket.current_x = ob->x; 203 socket.current_x = ob->x;
208 socket.current_y = ob->y; 204 socket.current_y = ob->y;
… …
573 * it either has to be here or init_sockets needs to be exported. 569 * it either has to be here or init_sockets needs to be exported.
574 */ 570 */
575void 571void
576AddMeCmd (char *buf, int len, client * ns) 572AddMeCmd (char *buf, int len, client * ns)
577{ 573{
574 if (INVOKE_CLIENT (ADDME, ns))
575 return;
576
578 if (ns->status != Ns_Add || add_player (ns)) 577 if (ns->pl || add_player (ns))
579 ns->send_packet ("addme_failed"); 578 ns->send_packet ("addme_failed");
580 else 579 else
581 ns->send_packet ("addme_success"); 580 ns->send_packet ("addme_success");
582} 581}
583 582
… …
723 if (!(ns->faces_sent[smoothface] & NS_FACESENT_FACE)) 722 if (!(ns->faces_sent[smoothface] & NS_FACESENT_FACE))
724 esrv_send_face (ns, smoothface, 0); 723 esrv_send_face (ns, smoothface, 0);
725 724
726 ns->faces_sent[face] |= NS_FACESENT_SMOOTH; 725 ns->faces_sent[face] |= NS_FACESENT_SMOOTH;
727 726
728 packet sl; 727 packet sl ("smooth");
729 728
730 sl << "smooth "
731 << uint16 (face) 729 sl << uint16 (face)
732 << uint16 (smoothface); 730 << uint16 (smoothface);
733 731
734 ns->send_packet (sl); 732 ns->send_packet (sl);
735} 733}
736 734
… …
813 int time = FABS (pl->ob->speed) < 0.001 811 int time = FABS (pl->ob->speed) < 0.001
814 ? time = MAX_TIME * 100 812 ? time = MAX_TIME * 100
815 : time = (int) (MAX_TIME / FABS (pl->ob->speed)); 813 : time = (int) (MAX_TIME / FABS (pl->ob->speed));
816 814
817 /* Send confirmation of command execution now */ 815 /* Send confirmation of command execution now */
818 packet sl; 816 packet sl ("comc");
819 sl << "comc " << uint16 (cmdid) << uint32 (time); 817 sl << uint16 (cmdid) << uint32 (time);
820 pl->socket->send_packet (sl); 818 pl->socket->send_packet (sl);
821} 819}
822 820
823
824/** This is a reply to a previous query. */ 821/** This is a reply to a previous query. */
825void 822void
826ReplyCmd (char *buf, int len, player *pl) 823ReplyCmd (char *buf, int len, client *ns)
827{ 824{
825 if (!ns->pl)
826 return; //TODO: depends on the exact reply we are after
827 //TODO: but right now, we always have a ns->pl
828
829 player *pl = ns->pl;
830
828 /* This is to synthesize how the data would be stored if it 831 /* This is to synthesize how the data would be stored if it
829 * was normally entered. A bit of a hack, and should be cleaned up 832 * was normally entered. A bit of a hack, and should be cleaned up
830 * once all the X11 code is removed from the server. 833 * once all the X11 code is removed from the server.
831 * 834 *
832 * We pass 13 to many of the functions because this way they 835 * We pass 13 to many of the functions because this way they
… …
853 case ST_ROLL_STAT: 856 case ST_ROLL_STAT:
854 key_roll_stat (pl->ob, buf[0]); 857 key_roll_stat (pl->ob, buf[0]);
855 break; 858 break;
856 859
857 case ST_CHANGE_CLASS: 860 case ST_CHANGE_CLASS:
858
859 key_change_class (pl->ob, buf[0]); 861 key_change_class (pl->ob, buf[0]);
860 break; 862 break;
861 863
862 case ST_CONFIRM_QUIT: 864 case ST_CONFIRM_QUIT:
863 key_confirm_quit (pl->ob, buf[0]); 865 key_confirm_quit (pl->ob, buf[0]);
… …
1037esrv_update_stats (player *pl) 1039esrv_update_stats (player *pl)
1038{ 1040{
1039 char buf[MAX_BUF]; 1041 char buf[MAX_BUF];
1040 uint16 flags; 1042 uint16 flags;
1041 1043
1042 packet sl; 1044 packet sl ("stats");
1043 sl << "stats ";
1044 1045
1045 if (pl->ob) 1046 if (pl->ob)
1046 { 1047 {
1047 AddIfShort (pl->last_stats.hp, pl->ob->stats.hp, CS_STAT_HP); 1048 AddIfShort (pl->last_stats.hp, pl->ob->stats.hp, CS_STAT_HP);
1048 AddIfShort (pl->last_stats.maxhp, pl->ob->stats.maxhp, CS_STAT_MAXHP); 1049 AddIfShort (pl->last_stats.maxhp, pl->ob->stats.maxhp, CS_STAT_MAXHP);
… …
1131void 1132void
1132esrv_new_player (player *pl, uint32 weight) 1133esrv_new_player (player *pl, uint32 weight)
1133{ 1134{
1134 pl->last_weight = weight; 1135 pl->last_weight = weight;
1135 1136
1136 packet sl; 1137 packet sl ("player");
1137 sl << "player ";
1138 1138
1139 sl << uint32 (pl->ob->count) 1139 sl << uint32 (pl->ob->count)
1140 << uint32 (weight) 1140 << uint32 (weight)
1141 << uint32 (pl->ob->face->number) 1141 << uint32 (pl->ob->face->number)
1142 << data8 (pl->ob->name); 1142 << data8 (pl->ob->name);
… …
1163 { 1163 {
1164 LOG (llevError, "esrv_send_anim (%d) out of bounds??\n", anim_num); 1164 LOG (llevError, "esrv_send_anim (%d) out of bounds??\n", anim_num);
1165 return; 1165 return;
1166 } 1166 }
1167 1167
1168 packet sl; 1168 packet sl ("anim");
1169 1169
1170 sl << "anim "
1171 << uint16 (anim_num) 1170 sl << uint16 (anim_num)
1172 << uint16 (0); /* flags - not used right now */ 1171 << uint16 (0); /* flags - not used right now */
1173 1172
1174 /* Build up the list of faces. Also, send any information (ie, the 1173 /* Build up the list of faces. Also, send any information (ie, the
1175 * the face itself) down to the client. 1174 * the face itself) down to the client.
1176 */ 1175 */
… …
1622 1621
1623 client &socket = *pl->contr->socket; 1622 client &socket = *pl->contr->socket;
1624 1623
1625 check_map_change (pl->contr); 1624 check_map_change (pl->contr);
1626 1625
1627 packet sl; 1626 packet sl (socket.mapmode == Map1Cmd ? "map1" : "map1a");
1628 packet esl; 1627 packet esl;
1629 1628
1630 sl << (socket.mapmode == Map1Cmd ? "map1 " : "map1a ");
1631 startlen = sl.length (); 1629 startlen = sl.length ();
1632 1630
1633 /*Extendedmapinfo structure initialisation */ 1631 /*Extendedmapinfo structure initialisation */
1634 if (socket.ext_mapinfos) 1632 if (socket.ext_mapinfos)
1635 { 1633 {
… …
1679 for (y = pl->y - socket.mapy / 2; y < max_y; y++, ay++) 1677 for (y = pl->y - socket.mapy / 2; y < max_y; y++, ay++)
1680 { 1678 {
1681 ax = 0; 1679 ax = 0;
1682 for (x = pl->x - socket.mapx / 2; x < max_x; x++, ax++) 1680 for (x = pl->x - socket.mapx / 2; x < max_x; x++, ax++)
1683 { 1681 {
1684
1685 emask = mask = (ax & 0x3f) << 10 | (ay & 0x3f) << 4; 1682 emask = mask = (ax & 0x3f) << 10 | (ay & 0x3f) << 4;
1686 1683
1687 /* If this space is out of the normal viewable area, we only check 1684 /* If this space is out of the normal viewable area, we only check
1688 * the heads value ax or ay will only be greater than what 1685 * the heads value ax or ay will only be greater than what
1689 * the client wants if using the map1a command - this is because 1686 * the client wants if using the map1a command - this is because
… …
2020 return; 2017 return;
2021 2018
2022 memset (&newmap, 0, sizeof (struct Map)); 2019 memset (&newmap, 0, sizeof (struct Map));
2023 2020
2024 for (j = (pl->y - pl->contr->socket->mapy / 2); j < (pl->y + (pl->contr->socket->mapy + 1) / 2); j++) 2021 for (j = (pl->y - pl->contr->socket->mapy / 2); j < (pl->y + (pl->contr->socket->mapy + 1) / 2); j++)
2025 {
2026 for (i = (pl->x - pl->contr->socket->mapx / 2); i < (pl->x + (pl->contr->socket->mapx + 1) / 2); i++) 2022 for (i = (pl->x - pl->contr->socket->mapx / 2); i < (pl->x + (pl->contr->socket->mapx + 1) / 2); i++)
2027 { 2023 {
2028 ax = i; 2024 ax = i;
2029 ay = j; 2025 ay = j;
2030 m = pm; 2026 m = pm;
2031 mflags = get_map_flags (m, &m, ax, ay, &ax, &ay); 2027 mflags = get_map_flags (m, &m, ax, ay, &ax, &ay);
2032 2028
2033 if (mflags & P_OUT_OF_MAP) 2029 if (mflags & P_OUT_OF_MAP)
2034 continue; 2030 continue;
2035 2031
2036 if (mflags & P_NEED_UPDATE)
2037 update_position (m, ax, ay);
2038
2039 /* If a map is visible to the player, we don't want to swap it out 2032 /* If a map is visible to the player, we don't want to swap it out
2040 * just to reload it. This should really call something like 2033 * just to reload it. This should really call something like
2041 * swap_map, but this is much more efficient and 'good enough' 2034 * swap_map, but this is much more efficient and 'good enough'
2042 */ 2035 */
2043 if (mflags & P_NEW_MAP) 2036 if (mflags & P_NEW_MAP)
2044 m->timeout = 50; 2037 m->timeout = 50;
2045 } 2038 }
2046 } 2039
2047 /* do LOS after calls to update_position */ 2040 /* do LOS after calls to update_position */
2048 if (pl->contr->do_los) 2041 if (pl->contr->do_los)
2049 { 2042 {
2050 update_los (pl); 2043 update_los (pl);
2051 pl->contr->do_los = 0; 2044 pl->contr->do_los = 0;
… …
2179 { 2172 {
2180 LOG (llevError, "Invalid call to esrv_remove_spell"); 2173 LOG (llevError, "Invalid call to esrv_remove_spell");
2181 return; 2174 return;
2182 } 2175 }
2183 2176
2184 packet sl; 2177 packet sl ("delspell");
2185 2178
2186 sl << "delspell "
2187 << uint32 (spell->count); 2179 sl << uint32 (spell->count);
2188 2180
2189 pl->socket->send_packet (sl); 2181 pl->socket->send_packet (sl);
2190} 2182}
2191 2183
2192/* appends the spell *spell to the Socklist we will send the data to. */ 2184/* appends the spell *spell to the Socklist we will send the data to. */
… …
2245 } 2237 }
2246 2238
2247 if (!pl->socket->monitor_spells) 2239 if (!pl->socket->monitor_spells)
2248 return; 2240 return;
2249 2241
2250 packet sl; 2242 packet sl ("addspell");
2251 sl << "addspell ";
2252 2243
2253 if (!spell) 2244 if (!spell)
2254 { 2245 {
2255 for (spell = pl->ob->inv; spell != NULL; spell = spell->below) 2246 for (spell = pl->ob->inv; spell != NULL; spell = spell->below)
2256 { 2247 {

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines