blob: b951daac1fadeaa6c5c95cc7a277a436507e9c6e [file] [log] [blame]
MG Mud User88f12472016-06-24 23:31:02 +02001// MorgenGrauen MUDlib
2//
3// gmcp.c -- Verwaltung von GMCP im Spielerobjekt
4//
5// $Id$
6
7#pragma strong_types,save_types
8#pragma range_check
9#pragma no_clone
10#pragma no_shadow
11#pragma pedantic
12
13#include <regexp.h>
14#include <telnet.h>
15
16#define NEED_PROTOTYPES
17#include <player/base.h>
18#include <thing/properties.h>
19#include <living/attributes.h>
20#include <player/gmcp.h>
21#include <thing/description.h>
22#include <living/description.h>
23#undef NEED_PROTOTYPES
24
25#include <properties.h>
26#include <new_skills.h>
27#include <rooms.h>
28#include <tls.h>
29
30inherit "/secure/telnetneg-structs.c";
31
32struct gmcp_mod_s {
33 string id; // Name des GMCP-Moduls (z.B. "MG.Char")
34 int version; // Version des aktivierten moduls
35 closure sendcl; // Handler zum Senden (lfun-closure)
36 closure recvcl; // Handler zum Empfangen (lfunc-closure)
37 mixed data; // optional data of the module
38};
39
40nosave mapping gmcpdata;
41/* Struktur:
42 Jedes Modul hat einen Schluessel im Toplevel, worunter ggf. seine Daten
43 abgelegt sind. Die Daten sind eine struct gmcp_mod_s. Der Schluessel ist
44 der Modulname OHNE Version.
45 */
46#define NEED_PROTOTYPES
47#include "/secure/telnetneg.h"
48#undef NEED_PROTOTYPES
49
50//#define __GMCP_DEBUG__ 1
51// Low priority debug messages
52#define GMCP_DEBUG(pre,msg,prio) if (interactive(this_object()) \
53 && gmcpdata) \
54 GMCP_debug(pre,msg,prio);
55// higher priority error messages
56#define GMCPERROR(msg) if (interactive(this_object()) \
57 && gmcpdata) \
58 GMCP_debug("ERROR",msg,10);
59
60
61// **************** API nach Aussen folgt ab hier ********************
62
63// Wird vom Spielerobjekt gerufen, wenn sich Daten am Charakter veraendert
64// haben, die gesendet werden sollten.
65// Dies ist eigentlich nur ein Wrapper, der die Daten an den Handler eines
66// Moduls weitergibt, welches vom Client aktiviert wurde. Hierzu kommen zur
67// Zeit 2 in Frage: MG.Char (bevorzugt) und Char (minimaler Support).
68/*protected*/ int GMCP_Char(mapping data) {
69
70 if (!mappingp(gmcpdata)) return 0;
71
72 // Als erstes schauen, ob der Client MG.Char aktiviert hat.
73 struct gmcp_mod_s mod = gmcpdata["MG.char"];
74 if (structp(mod) && closurep(mod->sendcl))
75 {
76 funcall(mod->sendcl, data);
77 return 1;
78 }
79 // Dann noch das Modul char pruefen. Das ist aber ziemlich eingeschraenkt
80 // und es gibt hoffentlich nicht viele Clients, die es benutzen.
81 // (Aardwolf-Modul)
82 mod = gmcpdata["char"];
83 if (structp(mod) && closurep(mod->sendcl))
84 {
85 funcall(mod->sendcl, data);
86 return 1;
87 }
88 // Dann noch das Modul Char pruefen. Das ist aber ziemlich eingeschraenkt
89 // und es gibt hoffentlich nicht viele Clients, die es benutzen.
90 // (IRE-Modul)
91 mod = gmcpdata["Char"];
92 if (structp(mod) && closurep(mod->sendcl))
93 {
94 funcall(mod->sendcl, data);
95 return 1;
96 }
97 return 0;
98}
99
100/*protected*/ int GMCP_Channel(string msg, string channel, string sender) {
101 if (!mappingp(gmcpdata)) return 0;
102 // comm.channel Modul aktiv?
103 struct gmcp_mod_s mod = gmcpdata["comm.channel"];
104 if (structp(mod) && closurep(mod->sendcl))
105 {
106 funcall(mod->sendcl, (["chan":channel, "player": sender,
107 "msg": msg]) );
108 return 1;
109 }
110 return 0;
111}
112
113/*protected*/ int GMCP_Room() {
114 if (!mappingp(gmcpdata)) return 0;
115 // MG.room Modul aktiv?
116 struct gmcp_mod_s mod = gmcpdata["MG.room"];
117 if (structp(mod) && closurep(mod->sendcl))
118 {
119 funcall(mod->sendcl, 0);
120 return 1;
121 }
122 return 0;
123}
124
125// **************** Ab hier folgen eher die Lowlevel-Dinge ***********
126private void GMCP_debug(string pre, string msg, int prio) {
127 struct gmcp_mod_s mod = gmcpdata["Core"];
128 if (mod && (mod->data)["Debug"] >= prio)
129 tell_object(this_object(), sprintf("GMCP %s: %s\n",pre,msg));
130}
131
132private void GMCP_send(string cmd, mixed data)
133{
134 GMCP_DEBUG("GMCP_send",sprintf("%s %O",cmd,data), 30);
135 send_telnet_neg_str(sprintf("%c%c%s %s", SB, TELOPT_GMCP,
136 cmd, json_serialize(data)), 1);
137}
138
139private void GMCP_unregister_module(string mod)
140{
141 int version;
142 // Wenn nicht "mod version" Schema, ignorieren
143 if (sscanf(mod, "%s %d", mod, version) != 2)
144 return;
145
146 if (mod=="Core") // darf nicht abgeschaltet werden.
147 return;
148
149 m_delete(gmcpdata, mod);
150}
151
152private void GMCP_register_module(string modname)
153{
154 int version;
155 GMCP_DEBUG("register_module(): trying ... ",modname, 20);
156 // Wenn nicht "mod version" Schema, ignorieren
157 if (sscanf(modname, "%s %d", modname, version) != 2)
158 return;
159
160// GMCP_DEBUG("register_module()",modname + " v" + version);
161
162 // Modul (ggf. mit anderer Version) bereits aktiv?
163 struct gmcp_mod_s mod = gmcpdata[modname];
164 if (structp(mod)) {
165 // wenn gleicher Name und Version, wird nix gemacht, bei anderer Version
166 // wird ein neuer Handler eingetragen und die Daten geloescht.
167 // Wenn nicht-existierende Modul/Version-Kombi angefordert wird, ist das
168 // Modul hinterher aus.
169 if (mod->id == modname && mod->version == version)
170 return;
171 else
172 m_delete(gmcpdata,modname);
173 }
174
175 // Das GMCP-Modul ist nur verfuegbar, wenn es zu der Kombination aus mod und
176 // version einen Handler zum Senden gibt...
177 // Der Handler ist: GMCP_<mod>_v<version>_send, aber in <mod> werden alle
178 // "." durch "_" ersetzt.
179 string replacedname = regreplace(modname, "\\.", "_", RE_GLOBAL);
180 closure sendcl = symbol_function(sprintf("GMCPmod_%s_v%d_send",
181 replacedname, version),
182 this_object());
183 if (!sendcl)
184 return;
185 // Diese Closure darf 0 sein. Dann findet keine Behandlung von vom Client
186 // gesendeten Kommandos statt. Was fuer die meisten Module auch in Ordnung
187 // ist, da sie dem Client keine Kommandos anbieten.
188 closure recvcl = symbol_function(sprintf("GMCPmod_%s_v%d_recv",
189 replacedname, version),
190 this_object());
191
192 GMCP_DEBUG("register_module()",modname+" erfolgreich registriert.",10);
193
194 mod = (<gmcp_mod_s> id: modname, version : version,
195 sendcl : sendcl, recvcl: recvcl, data: ([]) );
196 gmcpdata[modname] = mod;
197
198 // Zum schluss noch den Senden-handler mal rufen, damit der mal alle
199 // verfuegbaren daten sendet.
200 funcall(mod->sendcl, 0);
201}
202
203// Handler fuer das Core Modul von GMCP
204// Gerufen bei Empfang von Kommandos vom Client.
205protected void GMCPmod_Core_v1_recv(string cmd, mixed args)
206{
207 struct gmcp_mod_s mod = gmcpdata["Core"];
208 mapping data = mod->data;
209
210/* if (!mod)
211 {
212 GMCPERROR("Command %s for disabled module ignored.");
213 return;
214 }
215 */
216 GMCP_DEBUG("GMCPmod_Core_v1: ", cmd, 20);
217
218 switch (cmd)
219 {
220 case "Core.Hello":
221 if (mappingp(args))
222 data["Hello"] = (["client": args["client"],
223 "version": args["version"] ]);
224 break;
225 case "Core.Supports.Set":
226 if (pointerp(args))
227 {
228 // Alte Module abschalten/loeschen
229 foreach(string m : data["Supports"])
230 GMCP_unregister_module(m);
231 data["Supports"] = args;
232 // Versuchen, die neuen Module zu registrieren
233 foreach(string m : args)
234 GMCP_register_module(m);
235 }
236 else
237 GMCP_DEBUG("GMCPmod_Core_v1: ",
238 "Data for Core.Supports.Set is no array", 5);
239 break;
240 case "Core.Supports.Add":
241 if (!pointerp(data["Supports"]))
242 data["Supports"] = ({});
243 if (pointerp(args))
244 {
245 foreach(string m: args)
246 GMCP_register_module(m);
247 data["Supports"] += args;
248 }
249 break;
250 case "Core.Supports.Remove":
251 if (!pointerp(data["Supports"]))
252 break;
253 if (pointerp(args))
254 {
255 foreach(string m: args)
256 GMCP_unregister_module(m);
257 data["Supports"] -= args;
258 }
259 break;
260 case "Core.Supports.KeepAlive":
261 break; // this is ignored by us.
262 case "Core.Ping":
263 if (intp(args))
264 data["Ping"] = args;
265 // send a ping back
266 GMCP_send("Core.Ping",0);
267 break;
268 case "Core.Debug":
269 if (intp(args) && args >= 0)
270 data["Debug"] = args;
271 break;
272 default:
273 GMCPERROR(sprintf("Unknown GMCP Core cmd %s with args %O",
274 cmd, args));
275 break;
276 }
277}
278
279// Handler fuer das Core Modul von GMCP
280// Gerufen, wenn Daten zu senden sind.
281protected void GMCPmod_Core_v1_send(mapping data)
282{
283 // Zur Zeit nix, spaeter mal Core.Goodbye.
284}
285
286
287// Handler fuer das MG.Char Modul
288// Gerufen bei Empfang von Kommandos vom Client.
289protected void GMCPmod_MG_char_v1_send(mapping data)
290{
291 mapping squeue = m_allocate(5,0);
292 struct gmcp_mod_s mod = gmcpdata["MG.char"];
293 // mod->data fungiert hier auch als Cache der Daten. Die muss man naemlich
294 // leider immer alle senden, nicht nur die geaenderten.
295 if (!mappingp(data))
296 {
297 // Alle verfuegbaren Informationen senden...
298 mod->data = m_allocate(6);
299 m_add(mod->data, "MG.char.base",
300 ([P_NAME: Name(WER),
301 P_GUILD: QueryProp(P_GUILD),
302 P_PRESAY: QueryProp(P_PRESAY), // TODO
303 P_TITLE: QueryProp(P_TITLE),
304 "wizlevel": query_wiz_level(this_object()),
305 P_RACE: QueryProp(P_RACE)]) ); // TODO
306 m_add(mod->data,"MG.char.vitals",
307 ([P_HP: QueryProp(P_HP),
308 P_SP: QueryProp(P_SP),
309 P_POISON: QueryProp(P_POISON) ]) );
310 m_add(mod->data,"MG.char.maxvitals",
311 ([P_MAX_HP: QueryProp(P_MAX_HP),
312 P_MAX_SP: QueryProp(P_MAX_SP),
313 P_MAX_POISON: QueryProp(P_MAX_POISON) ]) );
314 m_add(mod->data,"MG.char.attributes",
315 ([ A_STR: QueryAttribute(A_STR),
316 A_INT: QueryAttribute(A_INT),
317 A_DEX: QueryAttribute(A_DEX),
318 A_CON: QueryAttribute(A_CON) ]) );
319 m_add(mod->data,"MG.char.info",
320 ([P_LEVEL: QueryProp(P_LEVEL),
321 P_GUILD_LEVEL: QueryProp(P_GUILD_LEVEL),
322 P_GUILD_TITLE: QueryProp(P_GUILD_TITLE) ]) );
323 m_add(mod->data,"MG.char.wimpy",
324 ([P_WIMPY: QueryProp(P_WIMPY),
325 P_WIMPY_DIRECTION: QueryProp(P_WIMPY_DIRECTION) ]) );
326 m_add(squeue,"MG.char.base");
327 m_add(squeue,"MG.char.vitals");
328 m_add(squeue,"MG.char.maxvitals");
329 m_add(squeue,"MG.char.attributes");
330 m_add(squeue,"MG.char.info");
331 m_add(squeue,"MG.char.wimpy");
332 // dies wird direkt gesendet, weil es nicht gespeichert werden muss. (wird
333 // nur beim Start des Moduls gesendet).
334 GMCP_send("MG.char.infoVars", ([
335 P_LEVEL: "Spielerstufe", P_GUILD_LEVEL: "Gildenstufe",
336 P_GUILD_TITLE: "Gildentitel" ]) );
337 }
338 else
339 {
340 // nur die in data enthaltenen senden.
341 // jetzt erstmal alles aus data so sortieren, wie es gesendet werden
342 // muss... *seufz*
343 foreach(string key, mixed val : data)
344 {
345 switch(key)
346 {
347 case P_HP:
348 case P_SP:
349 case P_POISON:
350 (mod->data)["MG.char.vitals"] += ([key: val]);
351 m_add(squeue,"MG.char.vitals");
352 break;
353 case P_MAX_HP:
354 case P_MAX_SP:
355 case P_MAX_POISON:
356 (mod->data)["MG.char.maxvitals"] += ([key: val]);
357 m_add(squeue,"MG.char.maxvitals");
358 break;
359 case P_NAME:
360 (mod->data)["MG.char.base"] += ([key: Name(WER)]);
361 m_add(squeue,"MG.char.base");
362 break;
363 case P_RACE:
364 case P_PRESAY:
365 case P_TITLE:
366 case P_GUILD:
367 (mod->data)["MG.char.base"] += ([key: val]);
368 m_add(squeue,"MG.char.base");
369 break;
370 case A_DEX:
371 case A_STR:
372 case A_CON:
373 case A_INT:
374 (mod->data)["MG.char.attributes"] += ([key: val]);
375 m_add(squeue,"MG.char.attributes");
376 break;
377 case P_LEVEL:
378 case P_GUILD_LEVEL:
379 case P_GUILD_TITLE:
380 (mod->data)["MG.char.info"] += ([key: val]);
381 m_add(squeue,"MG.char.info");
382 break;
383 case P_WIMPY:
384 case P_WIMPY_DIRECTION:
385 (mod->data)["MG.char.wimpy"] += ([key: val]);
386 m_add(squeue,"MG.char.wimpy");
387 break;
388 }
389 }
390 }
391 GMCP_DEBUG("GMCPmod_MG_char_v1_send()",
392 sprintf("Data ready: %O, Sendqueue: %O",mod->data, squeue),50);
393
394 // Jetzt die squeue senden...
395 foreach(string key : squeue)
396 {
397 GMCP_send(key, (mod->data)[key]);
398 }
399}
400
401// Handler fuer das MG.Char Modul
402// Gerufen bei Empfang von Kommandos vom Client.
403protected void GMCPmod_MG_char_v1_recv(string cmd, mixed args)
404{
405 // dieses Modul bietet dem Client keine Kommandos an, daher ignorieren.
406 GMCP_DEBUG("GMCPmod_MG_Char_v1_recv","Client-Kommando ignoriert: "+cmd,20);
407}
408
409/*
410// Handler fuer das MG.Room Modul von GMCP
411// Gerufen, wenn Daten zu senden sind.
412protected void GMCPmod_MG_Room_v1_send(mapping data)
413{
414}
415
416// Handler fuer das Room Modul von GMCP
417// Gerufen bei Empfang von Kommandos vom Client.
418protected void GMCPmod_MG_Room_v1_recv(string cmd, mixed args)
419{
420 // dieses Modul bietet dem Client keine Kommandos an, daher ignorieren.
421 GMCP_DEBUG("GMCPmod_MG_Room_v1_recv","Client-Kommando ignoriert: "+cmd,20);
422}
423*/
424
425// Recv Handler fuer das comm.channel Modul von GMCP
426// Gerufen bei Empfang von Kommandos vom Client.
427protected void GMCPmod_comm_channel_v1_recv(string cmd, mixed args)
428{
429 GMCP_DEBUG("GMCPmod_comm_channel_v1_recv",
430 "Client-Kommando ignoriert: "+cmd,20);
431}
432
433// Send Handler fuer das comm.channel Modul von GMCP
434protected void GMCPmod_comm_channel_v1_send(mapping data)
435{
436 // Ganz simpel: einfach raussenden...
437 // Core uebergibt beim Einschalten 0 als data. Dieses modul muss aber beim
438 // Eisnchalten nix machen. Also nur ignorieren.
439 if (mappingp(data))
440 GMCP_send("comm.channel", data);
441}
442
443// Recv Handler fuer das MG.room Modul von GMCP
444// Gerufen bei Empfang von Kommandos vom Client.
445protected void GMCPmod_MG_room_v1_recv(string cmd, mixed args)
446{
447 GMCP_DEBUG("GMCPmod_MG_room_v1_recv",
448 "Client-Kommando ignoriert: "+cmd,20);
449}
450
451// Send Handler fuer das comm.channel Modul von GMCP
452protected void GMCPmod_MG_room_v1_send(mapping data)
453{
454 // Bekommt immer 0 als <data> uebergeben und sucht sich die Daten aus dem
455 // Raum zusammen.
456
457 // Baeh. Warum wird das denn ohne Env gerufen. :-(
458 if (!environment())
459 return;
460
461 // Blind gibt es auch per GMCP nix.
462 if (CannotSee(1))
463 return;
464
465 int restr = environment()->QueryProp(P_MAP_RESTRICTIONS);
466
467 if (restr & MR_NOINFO)
468 return; // gar keine info senden.
469
470 // Anmerkung: int_short() waere cool. Dummerweise uebertraegt das auch
471 // sichtbare Ausgange und Objekte. Insofern: geht nicht.
472 data = ([
473 P_SHORT: process_string(environment()->QueryProp(P_INT_SHORT)||"")+".",
474 "domain": environment()->QueryProp(P_DOMAIN) || "unbekannt",
475 ]);
476
477 // sichtbare Ausgaenge ausgeben
478 mixed hide = environment()->QueryProp(P_HIDE_EXITS);
479 if (hide && !pointerp(hide))
480 data["exits"] = ({}); // alle verstecken
481 else
482 {
483 // Query() verwenden, damit sowohl normale als auch Special Exits
484 // kommen... Die Summe von beiden wuerde auch gehen, aber dann hat man
485 // zwei unnoetige Filter in den Querymethoden. Hngl.
486 mapping exits = environment()->Query(P_EXITS, F_VALUE) || ([]);
487 if (pointerp(hide))
488 data["exits"] = m_indices(exits) - hide;
489 else
490 data["exits"] = m_indices(exits);
491 }
492
493 if (restr & MR_NOUID)
494 data["id"] = "";
495 else
496 data["id"] = hash(TLS_HASH_MD5, object_name(environment()));
497
498 GMCP_send("MG.room.info", data);
499}
500
501
502// Handler fuer das "char" Modul von GMCP (Modul von Aardwolf)
503// Gerufen, wenn Daten zu senden sind.
504protected void GMCPmod_char_v1_send(mapping data)
505{
506 mapping squeue = m_allocate(4,0);
507 struct gmcp_mod_s mod = gmcpdata["char"];
508 // mod->data fungiert hier auch als Cache der Daten. Die muss man naemlich
509 // leider immer alle senden, nicht nur die geaenderten.
510 if (!mappingp(data))
511 {
512 // Alle verfuegbaren Informationen senden...
513 mod->data = m_allocate(4);
514 m_add(mod->data, "char.base", (["name": query_real_name(),
515 "race": QueryProp(P_RACE)]) );
516 m_add(mod->data,"char.vitals", (["hp": QueryProp(P_HP),
517 "mana": QueryProp(P_SP)]) );
518 m_add(mod->data,"char.stats", ([ "str": QueryAttribute(A_STR),
519 "int": QueryAttribute(A_INT),
520 "dex": QueryAttribute(A_DEX),
521 "con": QueryAttribute(A_CON) ]) );
522 m_add(mod->data,"char.status", (["level": QueryProp(P_LEVEL) ]) );
523 m_add(squeue,"char.base");
524 m_add(squeue,"char.vitals");
525 m_add(squeue,"char.stats");
526 m_add(squeue,"char.status");
527 }
528 else
529 {
530 // nur die in data enthaltenen senden.
531 // jetzt erstmal alles aus data so sortieren, wie es gesendet werden
532 // muss... *seufz*
533 foreach(string key, mixed val : data)
534 {
535 switch(key)
536 {
537 case P_HP:
538 (mod->data)["char.vitals"] += (["hp": val]);
539 m_add(squeue,"char.vitals");
540 break;
541 case P_SP:
542 (mod->data)["char.vitals"] += (["mana": val]);
543 m_add(squeue,"char.vitals");
544 break;
545 case P_NAME:
546 case P_RACE:
547 (mod->data)["char.base"] += ([key: val]);
548 m_add(squeue,"char.base");
549 break;
550 case A_DEX:
551 case A_STR:
552 case A_CON:
553 case A_INT:
554 (mod->data)["char.stats"] += ([key: val]);
555 m_add(squeue,"char.stats");
556 break;
557 case P_LEVEL:
558 (mod->data)["char.status"] += ([key: val]);
559 m_add(squeue,"char.status");
560 break;
561 }
562 }
563 }
564 GMCP_DEBUG("GMCPmod_char_v1_send()",
565 sprintf("Data ready: %O, Sendqueue: %O",mod->data, squeue),50);
566
567 // Jetzt die squeue senden...
568 foreach(string key : squeue)
569 {
570 GMCP_send(key, (mod->data)[key]);
571 }
572}
573
574// Handler fuer das "char" Modul von GMCP (Modul von Aardwolf)
575// Gerufen bei Empfang von Kommandos vom Client.
576protected void GMCPmod_char_v1_recv(string cmd, mixed data)
577{
578 // dieses Modul bietet dem Client keine Kommandos an, daher ignorieren.
579 GMCP_DEBUG("GMCPmod_char_v1_recv","Client-Kommando ignoriert: "+cmd,20);
580}
581
582
583// Handler fuer das "Char" Modul von GMCP (Modul von IRE)
584// Gerufen, wenn Daten zu senden sind.
585protected void GMCPmod_Char_v1_send(mapping data)
586{
587 mapping squeue = m_allocate(4,0);
588 struct gmcp_mod_s mod = gmcpdata["Char"];
589 // mod->data fungiert hier auch als Cache der Daten. Die muss man naemlich
590 // leider immer alle senden, nicht nur die geaenderten.
591 if (!mappingp(data))
592 {
593 // Alle verfuegbaren Informationen senden...
594 mod->data = m_allocate(4);
595 m_add(mod->data,"Char.Vitals", (["hp": QueryProp(P_HP),
596 "mp": QueryProp(P_SP),
597 "maxhp": QueryProp(P_MAX_HP),
598 "maxmp": QueryProp(P_MAX_SP) ]) );
599 m_add(mod->data,"Char.Status", (["level": QueryProp(P_LEVEL),
600 "guild": QueryProp(P_GUILD) ]) );
601 m_add(squeue,"Char.Vitals");
602 m_add(squeue,"Char.Status");
603 // dies wird direkt gesendet, weil es nicht gespeichert werden muss. (wird
604 // nur beim Start des Moduls gesendet).
605 GMCP_send("Char.StatusVars", ([
606 "level": "Spielerstufe", "guild": "Gilde" ]) );
607 }
608 else
609 {
610 // nur die in data enthaltenen senden.
611 // jetzt erstmal alles aus data so sortieren, wie es gesendet werden
612 // muss... *seufz*
613 foreach(string key, mixed val : data)
614 {
615 switch(key)
616 {
617 case P_HP:
618 (mod->data)["Char.Vitals"] += (["hp": val]);
619 m_add(squeue,"Char.Vitals");
620 break;
621 case P_SP:
622 (mod->data)["Char.Vitals"] += (["mp": val]);
623 m_add(squeue,"Char.Vitals");
624 break;
625 case P_MAX_HP:
626 (mod->data)["Char.Vitals"] += (["maxhp": val]);
627 m_add(squeue,"Char.Vitals");
628 break;
629 case P_MAX_SP:
630 (mod->data)["Char.Vitals"] += (["maxmp": val]);
631 m_add(squeue,"Char.Vitals");
632 break;
633 case P_LEVEL:
634 case P_GUILD:
635 (mod->data)["Char.Status"] += ([key: val]);
636 m_add(squeue,"Char.Status");
637 break;
638 }
639 }
640 }
641 GMCP_DEBUG("GMCPmod_Char_v1_send()",
642 sprintf("Data ready: %O, Sendqueue: %O",mod->data, squeue),50);
643
644 // Jetzt die squeue senden...
645 foreach(string key : squeue)
646 {
647 GMCP_send(key, (mod->data)[key]);
648 }
649}
650
651// Handler fuer das "char" Modul von GMCP (Modul von Aardwolf)
652// Gerufen bei Empfang von Kommandos vom Client.
653protected void GMCPmod_Char_v1_recv(string cmd, mixed args)
654{
655 // dieses Modul bietet dem Client keine Kommandos an, daher ignorieren.
656 GMCP_DEBUG("GMCPmod_Char_v1_recv","Client-Kommando ignoriert: "+cmd,20);
657}
658
659
660// Handler, der von telnetneg.c gerufen wird.
661private void _std_re_handler_gmcp(struct telopt_s opt, int action,
662 int *optargs)
663{
664 switch(action)
665 {
666 case LOCALON:
667 // super!
668 GMCP_DEBUG("recv:", "LOCALON",10);
669 gmcpdata = ([]);
670 opt->data = gmcpdata; // daten auch dort ablegen.
671 // Coremodule in der Version 1 registrieren (es gibt nur eine).
672 GMCP_register_module("Core 1");
673#ifdef __GMCP_DEBUG__
674 GMCPmod_Core_v1_recv("Core.Debug",30);
675#endif
676 break;
677 case LOCALOFF:
678 // alles abschalten und Daten loeschen
679 GMCP_DEBUG("recv:", "LOCALOFF",10);
680 opt->data = 0;
681 gmcpdata = 0;
682 break;
683 case REMOTEON:
684 case REMOTEOFF:
685 // Huch. Auf Clientseite ist GMCP eigentlich nie an. Ignorieren...
686 GMCP_DEBUG("recv:", "Huh? REMOTE state changed?",50);
687 break;
688 case SB:
689 // Der eigentlich interessante Fall... GMCP-Kommandos
690 if (!mappingp(gmcpdata)) return; // GMCP wohl nicht eingeschaltet...
691 string cmd;
692 mixed args;
693 string payload=to_string(optargs);
694 GMCP_DEBUG("recv", payload,10);
695 if (sscanf(payload,"%s %s", cmd, args) != 2) {
696 // ist vermutlich ein Kommando ohne daten (oder Muell)
697 cmd = payload;
698 //args = 0;
699 }
700 else
701 {
702 string err=catch(args = json_parse(args);nolog);
703 if (err)
704 {
705 printf("\nFehler beim Parsen einer GMCP-Nachricht: %s. "
706 "Nachricht war: '%s'\n"
707 "Befehl: '%s', Argument: '%s'\n\n",err,payload,cmd,args||"");
708 return;
709 }
710 }
711 GMCP_DEBUG("recv", sprintf("Command: %s, Data: %O", cmd, args),20);
712
713 string *cmdparts = explode(cmd, ".");
714 struct gmcp_mod_s mod;
715 string modname;
716 // versuch, ein Modul fuer das Kommando zu finden. Anfangen mit der
717 // Annahme, dass bis zum letzten Punkt der Modulname geht und dann
718 // in jedem case einen Punkt kuerzer werdend.
719 switch(sizeof(cmdparts))
720 {
721 case 4:
722 modname = implode(cmdparts[0..2],".");
723 GMCP_DEBUG("trying modname... ", modname, 20 );
724 if (member(gmcpdata, modname)) {
725 mod = gmcpdata[modname];
726 funcall(mod->recvcl, cmd, args);
727 break;
728 }
729 // Fall-through!
730 case 3:
731 modname = implode(cmdparts[0..1],".");
732 GMCP_DEBUG("trying modname... ", modname, 20);
733 if (member(gmcpdata, modname)) {
734 mod = gmcpdata[modname];
735 funcall(mod->recvcl, cmd, args);
736 break;
737 }
738 // Fall-through!
739 case 2:
740 modname = implode(cmdparts[0..0],".");
741 GMCP_DEBUG("trying modname... ", modname, 20);
742 if (member(gmcpdata, modname)) {
743 mod = gmcpdata[modname];
744 funcall(mod->recvcl, cmd, args);
745 break;
746 }
747 // Hier ists jetzt nen Fehler.
748 GMCPERROR(sprintf("Unknown GMCP module for cmd %s",cmd));
749 break;
750 default:
751 // zuviele oder zuwenig . ;-)
752 GMCPERROR(sprintf("Illegal GMCP cmd %s with args %O",
753 cmd, args));
754 break;
755 }
756 // sbdata brauchen wir eigentlich nicht mehr.
757 opt->re_wishes->sbdata = 0;
758 break;
759 } // switch (action)
760}
761
762// wird von base.c nach Konnektierung gerufen.
763// Darf aber erst gerufen werden, wenn das Spielerobjekt fertig initialisiert
764// und eingelesen ist.
765protected void startup_telnet_negs()
766{
767 // evtl. war es ein reconnect, dann steht in gmcp noch alter kram drin. Der
768 // muss weg, koennte ja auch sein, dass der Client (jetzt) kein GMCP
769 // mehr
770 // will.
771 gmcpdata = 0;
772
773 // Hack besonderer Sorte: GMCP soll lokal eingeschaltet sein. Auf
774 // Clientseiten ist es laut Protokoll nicht vorgesehen, daher duerfen
775 // (sollten?) wir kein DO an den Client senden. Wir brauchen aber einen
776 // remote handler, um die Wuensche vom Client zu verarbeiten. Daher erstmal
777 // nur den local handler binden (und gleichzeitig negotiation anstossen) und
778 // dann direkt danach den remote handler auch binden (ohne erneute
779 // negotiation zu starten). Achja und wir nehmen die gleiche Funktion als
780 // Handler fuer remote und lokal.
781 bind_telneg_handler(TELOPT_GMCP, 0, #'_std_re_handler_gmcp, 1);
782 bind_telneg_handler(TELOPT_GMCP, #'_std_re_handler_gmcp,
783 #'_std_re_handler_gmcp, 0);
784}
785