Crossfire Server, Trunk
cfpython.cpp
Go to the documentation of this file.
1 /*****************************************************************************/
2 /* CFPython - A Python module for Crossfire RPG. */
3 /*****************************************************************************/
4 /* This is the third version of the Crossfire Scripting Engine. */
5 /* The first version used Guile. It was directly integrated in the server */
6 /* code, but since Guile wasn't perceived as an easy-to-learn, easy-to-use */
7 /* language by many, it was dropped in favor of Python. */
8 /* The second version, CFPython 1.0, was included as a plugin and provided */
9 /* just about the same level of functionality the current version has. But */
10 /* it used a rather counter-intuitive, procedural way of presenting things. */
11 /* */
12 /* CFPython 2.0 aims at correcting many of the design flaws crippling the */
13 /* older version. It is also the first plugin to be implemented using the */
14 /* new interface, that doesn't need awkward stuff like the horrible CFParm */
15 /* structure. For the Python writer, things should probably be easier and */
16 /* lead to more readable code: instead of writing "CFPython.getObjectXPos(ob)*/
17 /* he/she now can simply write "ob.X". */
18 /* */
19 /*****************************************************************************/
20 /* Please note that it is still very beta - some of the functions may not */
21 /* work as expected and could even cause the server to crash. */
22 /*****************************************************************************/
23 /* Version history: */
24 /* 0.1 "Ophiuchus" - Initial Alpha release */
25 /* 0.5 "Stalingrad" - Message length overflow corrected. */
26 /* 0.6 "Kharkov" - Message and Write correctly redefined. */
27 /* 0.7 "Koursk" - Setting informations implemented. */
28 /* 1.0a "Petersburg" - Last "old-fashioned" version, never submitted to CVS.*/
29 /* 2.0 "Arkangelsk" - First release of the 2.x series. */
30 /*****************************************************************************/
31 /* Version: 2.0beta8 (also known as "Alexander") */
32 /* Contact: yann.chachkoff@myrealbox.com */
33 /*****************************************************************************/
34 /* That code is placed under the GNU General Public Licence (GPL) */
35 /* (C)2001-2005 by Chachkoff Yann (Feel free to deliver your complaints) */
36 /*****************************************************************************/
37 /* CrossFire, A Multiplayer game for X-windows */
38 /* */
39 /* Copyright (C) 2000 Mark Wedel */
40 /* Copyright (C) 1992 Frank Tore Johansen */
41 /* */
42 /* This program is free software; you can redistribute it and/or modify */
43 /* it under the terms of the GNU General Public License as published by */
44 /* the Free Software Foundation; either version 2 of the License, or */
45 /* (at your option) any later version. */
46 /* */
47 /* This program is distributed in the hope that it will be useful, */
48 /* but WITHOUT ANY WARRANTY; without even the implied warranty of */
49 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
50 /* GNU General Public License for more details. */
51 /* */
52 /* You should have received a copy of the GNU General Public License */
53 /* along with this program; if not, write to the Free Software */
54 /* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
55 /* */
56 /*****************************************************************************/
57 
58 /* First let's include the header file needed */
59 
60 #include <cfpython.h>
61 #include <fcntl.h>
62 #include <stdarg.h>
63 // node.h is deprecated in python 3.9, and removed in 3.10 due to a new parser for Python.
64 #ifndef IS_PY3K10
65 #include <node.h>
66 #endif
67 #include <svnversion.h>
68 
70 
71 //#define PYTHON_DEBUG /**< Give us some general infos out. */
72 #define PYTHON_CACHE_SIZE 256
77 struct pycode_cache_entry {
79  PyCodeObject *code;
80  time_t cached_time,
82 };
83 
84 #define MAX_COMMANDS 1024
86 
89 
90 static PyObject *CFPythonError;
91 
93 static void set_exception(const char *fmt, ...) {
94  char buf[1024];
95  va_list arg;
96 
97  va_start(arg, fmt);
98  vsnprintf(buf, sizeof(buf), fmt, arg);
99  va_end(arg);
100 
101  PyErr_SetString(PyExc_ValueError, buf);
102 }
103 
105 
107 
108 static PyObject *shared_data = NULL;
109 
110 static PyObject *private_data = NULL;
111 
112 static CFPContext *popContext(void);
113 static void freeContext(CFPContext *context);
114 static int do_script(CFPContext *context);
115 
116 static PyObject *registerGEvent(PyObject *self, PyObject *args) {
117  int eventcode;
118  (void)self;
119 
120  if (!PyArg_ParseTuple(args, "i", &eventcode))
121  return NULL;
122 
124 
125  Py_INCREF(Py_None);
126  return Py_None;
127 }
128 
129 static PyObject *unregisterGEvent(PyObject *self, PyObject *args) {
130  int eventcode;
131  (void)self;
132 
133  if (!PyArg_ParseTuple(args, "i", &eventcode))
134  return NULL;
135 
137 
138  Py_INCREF(Py_None);
139  return Py_None;
140 }
141 
142 static PyObject *createCFObject(PyObject *self, PyObject *args) {
143  object *op;
144  (void)self;
145  (void)args;
146 
147  op = cf_create_object();
148 
149  return Crossfire_Object_wrap(op);
150 }
151 
152 static PyObject *createCFObjectByName(PyObject *self, PyObject *args) {
153  char *obname;
154  object *op;
155  (void)self;
156 
157  if (!PyArg_ParseTuple(args, "s", &obname))
158  return NULL;
159 
160  op = cf_create_object_by_name(obname);
161 
162  return Crossfire_Object_wrap(op);
163 }
164 
165 static PyObject *getCFPythonVersion(PyObject *self, PyObject *args) {
166  int i = 2044;
167  (void)self;
168  (void)args;
169 
170  return Py_BuildValue("i", i);
171 }
172 
173 static PyObject *getReturnValue(PyObject *self, PyObject *args) {
174  (void)self;
175  (void)args;
176  return Py_BuildValue("i", current_context->returnvalue);
177 }
178 
179 static PyObject *setReturnValue(PyObject *self, PyObject *args) {
180  int i;
181  (void)self;
182 
183  if (!PyArg_ParseTuple(args, "i", &i))
184  return NULL;
186  Py_INCREF(Py_None);
187  return Py_None;
188 }
189 
190 static PyObject *matchString(PyObject *self, PyObject *args) {
191  char *premiere;
192  char *seconde;
193  const char *result;
194  (void)self;
195 
196  if (!PyArg_ParseTuple(args, "ss", &premiere, &seconde))
197  return NULL;
198 
199  result = cf_re_cmp(premiere, seconde);
200  if (result != NULL)
201  return Py_BuildValue("i", 1);
202  else
203  return Py_BuildValue("i", 0);
204 }
205 
206 static PyObject *findPlayer(PyObject *self, PyObject *args) {
207  player *foundpl;
208  char *txt;
209  (void)self;
210 
211  if (!PyArg_ParseTuple(args, "s", &txt))
212  return NULL;
213 
214  foundpl = cf_player_find(txt);
215 
216  if (foundpl != NULL)
217  return Py_BuildValue("O", Crossfire_Object_wrap(foundpl->ob));
218  else {
219  Py_INCREF(Py_None);
220  return Py_None;
221  }
222 }
223 
224 static PyObject *readyMap(PyObject *self, PyObject *args) {
225  char *mapname;
226  mapstruct *map;
227  int flags = 0;
228  (void)self;
229 
230  if (!PyArg_ParseTuple(args, "s|i", &mapname, &flags))
231  return NULL;
232 
234 
235  return Crossfire_Map_wrap(map);
236 }
237 
238 static PyObject *createMap(PyObject *self, PyObject *args) {
239  int sizex, sizey;
240  mapstruct *map;
241  (void)self;
242 
243  if (!PyArg_ParseTuple(args, "ii", &sizex, &sizey))
244  return NULL;
245 
246  map = cf_get_empty_map(sizex, sizey);
247 
248  return Crossfire_Map_wrap(map);
249 }
250 
251 static PyObject *getMapDirectory(PyObject *self, PyObject *args) {
252  (void)self;
253  (void)args;
254  return Py_BuildValue("s", cf_get_directory(0));
255 }
256 
257 static PyObject *getUniqueDirectory(PyObject *self, PyObject *args) {
258  (void)self;
259  (void)args;
260  return Py_BuildValue("s", cf_get_directory(1));
261 }
262 
263 static PyObject *getTempDirectory(PyObject *self, PyObject *args) {
264  (void)self;
265  (void)args;
266  return Py_BuildValue("s", cf_get_directory(2));
267 }
268 
269 static PyObject *getConfigDirectory(PyObject *self, PyObject *args) {
270  (void)self;
271  (void)args;
272  return Py_BuildValue("s", cf_get_directory(3));
273 }
274 
275 static PyObject *getLocalDirectory(PyObject *self, PyObject *args) {
276  (void)self;
277  (void)args;
278  return Py_BuildValue("s", cf_get_directory(4));
279 }
280 
281 static PyObject *getPlayerDirectory(PyObject *self, PyObject *args) {
282  (void)self;
283  (void)args;
284  return Py_BuildValue("s", cf_get_directory(5));
285 }
286 
287 static PyObject *getDataDirectory(PyObject *self, PyObject *args) {
288  (void)self;
289  (void)args;
290  return Py_BuildValue("s", cf_get_directory(6));
291 }
292 
293 static PyObject *getWhoAmI(PyObject *self, PyObject *args) {
294  (void)self;
295  (void)args;
296  if (!current_context->who) {
297  Py_INCREF(Py_None);
298  return Py_None;
299  }
300  Py_INCREF(current_context->who);
301  return current_context->who;
302 }
303 
304 static PyObject *getWhoIsActivator(PyObject *self, PyObject *args) {
305  (void)self;
306  (void)args;
307  if (!current_context->activator) {
308  Py_INCREF(Py_None);
309  return Py_None;
310  }
311  Py_INCREF(current_context->activator);
312  return current_context->activator;
313 }
314 
315 static PyObject *getWhoIsThird(PyObject *self, PyObject *args) {
316  (void)self;
317  (void)args;
318  if (!current_context->third) {
319  Py_INCREF(Py_None);
320  return Py_None;
321  }
322  Py_INCREF(current_context->third);
323  return current_context->third;
324 }
325 
326 static PyObject *getWhatIsMessage(PyObject *self, PyObject *args) {
327  (void)self;
328  (void)args;
329  if (*current_context->message == '\0')
330  return Py_BuildValue("");
331  else
332  return Py_BuildValue("s", current_context->message);
333 }
334 
335 static PyObject *getScriptName(PyObject *self, PyObject *args) {
336  (void)self;
337  (void)args;
338  return Py_BuildValue("s", current_context->script);
339 }
340 
341 static PyObject *getScriptParameters(PyObject *self, PyObject *args) {
342  (void)self;
343  (void)args;
344  if (!*current_context->options) {
345  Py_INCREF(Py_None);
346  return Py_None;
347  }
348  return Py_BuildValue("s", current_context->options);
349 }
350 
351 static PyObject *getEvent(PyObject *self, PyObject *args) {
352  (void)self;
353  (void)args;
354  if (!current_context->event) {
355  Py_INCREF(Py_None);
356  return Py_None;
357  }
358  Py_INCREF(current_context->event);
359  return current_context->event;
360 }
361 
362 static PyObject *getPrivateDictionary(PyObject *self, PyObject *args) {
363  PyObject *data;
364  (void)self;
365  (void)args;
366 
367  data = PyDict_GetItemString(private_data, current_context->script);
368  if (!data) {
369  data = PyDict_New();
370  PyDict_SetItemString(private_data, current_context->script, data);
371  Py_DECREF(data);
372  }
373  Py_INCREF(data);
374  return data;
375 }
376 
377 static PyObject *getSharedDictionary(PyObject *self, PyObject *args) {
378  (void)self;
379  (void)args;
380  Py_INCREF(shared_data);
381  return shared_data;
382 }
383 
384 static PyObject *getArchetypes(PyObject *self, PyObject *args) {
385  PyObject *list;
386  std::vector<archetype *> archs;
387  (void)self;
388  (void)args;
389 
391  list = PyList_New(0);
392  for (auto arch : archs) {
393  PyList_Append(list, Crossfire_Archetype_wrap(arch));
394  }
395  return list;
396 }
397 
398 static PyObject *getPlayers(PyObject *self, PyObject *args) {
399  PyObject *list;
400  std::vector<object *> players;
401  (void)self;
402  (void)args;
403 
405 
406  list = PyList_New(0);
407  for (auto pl : players) {
408  PyList_Append(list, Crossfire_Object_wrap(pl));
409  }
410  return list;
411 }
412 
413 static PyObject *getMaps(PyObject *self, PyObject *args) {
414  PyObject *list;
415  std::vector<mapstruct *> maps;
416  (void)self;
417  (void)args;
418 
420 
421  list = PyList_New(0);
422  for (auto map : maps) {
423  PyList_Append(list, Crossfire_Map_wrap(map));
424  }
425  return list;
426 }
427 
428 static PyObject *getParties(PyObject *self, PyObject *args) {
429  PyObject *list;
430  std::vector<partylist *> parties;
431  (void)self;
432  (void)args;
433 
435  list = PyList_New(0);
436  for (auto party : parties) {
437  PyList_Append(list, Crossfire_Party_wrap(party));
438  }
439  return list;
440 }
441 
442 static PyObject *getRegions(PyObject *self, PyObject *args) {
443  PyObject *list;
444  std::vector<region *> regions;
445  (void)self;
446  (void)args;
447 
449  list = PyList_New(0);
450  for (auto reg : regions) {
451  PyList_Append(list, Crossfire_Region_wrap(reg));
452  }
453  return list;
454 }
455 
456 static PyObject *getFriendlyList(PyObject *self, PyObject *args) {
457  PyObject *list;
458  std::vector<object *> friends;
459  (void)self;
460  (void)args;
461 
463  list = PyList_New(0);
464  for (auto ob : friends) {
465  PyList_Append(list, Crossfire_Object_wrap(ob));
466  }
467  return list;
468 }
469 
470 static void python_command_function(object *op, const char *params, const char *script) {
471  char buf[1024], path[1024];
472  CFPContext *context;
473 
474  snprintf(buf, sizeof(buf), "%s.py", cf_get_maps_directory(script, path, sizeof(path)));
475 
476  context = static_cast<CFPContext *>(malloc(sizeof(CFPContext)));
477  context->message[0] = 0;
478 
479  context->who = Crossfire_Object_wrap(op);
480  context->activator = NULL;
481  context->third = NULL;
482  /* We are not running from an event, so set it to NULL to avoid segfaults. */
483  context->event = NULL;
484  snprintf(context->script, sizeof(context->script), "%s", buf);
485  if (params)
486  snprintf(context->options, sizeof(context->options), "%s", params);
487  else
488  context->options[0] = 0;
489  context->returnvalue = 1; /* Default is "command successful" */
490 
491  if (!do_script(context)) {
492  freeContext(context);
493  return;
494  }
495 
496  context = popContext();
497  freeContext(context);
498 }
499 
500 static PyObject *registerCommand(PyObject *self, PyObject *args) {
501  char *cmdname;
502  char *scriptname;
503  double cmdspeed;
505  (void)self;
506 
507  if (!PyArg_ParseTuple(args, "ssd|i", &cmdname, &scriptname, &cmdspeed, &type))
508  return NULL;
509 
510  if (cmdspeed < 0) {
511  set_exception("speed must not be negative");
512  return NULL;
513  }
514 
515  if (type < 0 || type > COMMAND_TYPE_WIZARD) {
516  set_exception("type must be between 0 and 2");
517  return NULL;
518  }
519 
520  for (index = 0; index < MAX_COMMANDS; index++) {
521  if (registered_commands[index] == 0) {
522  break;
523  }
524  }
525  if (index == MAX_COMMANDS) {
526  set_exception("too many registered commands");
527  return NULL;
528  }
529 
531  if (registered_commands[index] == 0) {
532  set_exception("failed to register command (overriding an existing one with a different type?)");
533  return NULL;
534  }
535 
536  Py_INCREF(Py_None);
537  return Py_None;
538 }
539 
540 static PyObject *getTime(PyObject *self, PyObject *args) {
541  PyObject *list;
542  timeofday_t tod;
543  (void)self;
544  (void)args;
545 
546  cf_get_time(&tod);
547 
548  list = PyList_New(0);
549  PyList_Append(list, Py_BuildValue("i", tod.year));
550  PyList_Append(list, Py_BuildValue("i", tod.month));
551  PyList_Append(list, Py_BuildValue("i", tod.day));
552  PyList_Append(list, Py_BuildValue("i", tod.hour));
553  PyList_Append(list, Py_BuildValue("i", tod.minute));
554  PyList_Append(list, Py_BuildValue("i", tod.dayofweek));
555  PyList_Append(list, Py_BuildValue("i", tod.weekofmonth));
556  PyList_Append(list, Py_BuildValue("i", tod.season));
557  PyList_Append(list, Py_BuildValue("i", tod.periodofday));
558 
559  return list;
560 }
561 
562 static PyObject *destroyTimer(PyObject *self, PyObject *args) {
563  int id;
564  (void)self;
565 
566  if (!PyArg_ParseTuple(args, "i", &id))
567  return NULL;
568  return Py_BuildValue("i", cf_timer_destroy(id));
569 }
570 
571 static PyObject *getMapHasBeenLoaded(PyObject *self, PyObject *args) {
572  char *name;
573  (void)self;
574 
575  if (!PyArg_ParseTuple(args, "s", &name))
576  return NULL;
578 }
579 
580 static PyObject *findFace(PyObject *self, PyObject *args) {
581  char *name;
582  (void)self;
583 
584  if (!PyArg_ParseTuple(args, "s", &name))
585  return NULL;
586  return Py_BuildValue("i", cf_find_face(name, 0));
587 }
588 
589 static PyObject *log_message(PyObject *self, PyObject *args) {
590  LogLevel level;
591  int intLevel;
592  char *message;
593  (void)self;
594 
595  if (!PyArg_ParseTuple(args, "is", &intLevel, &message))
596  return NULL;
597 
598  switch (intLevel) {
599  case llevError:
600  level = llevError;
601  break;
602 
603  case llevInfo:
604  level = llevInfo;
605  break;
606 
607  case llevDebug:
608  level = llevDebug;
609  break;
610 
611  case llevMonster:
612  level = llevMonster;
613  break;
614 
615  default:
616  return NULL;
617  }
618  if ((message != NULL) && (message[strlen(message)] == '\n'))
619  cf_log(level, "CFPython: %s", message);
620  else
621  cf_log(level, "CFPython: %s\n", message);
622  Py_INCREF(Py_None);
623  return Py_None;
624 }
625 
626 static PyObject *findAnimation(PyObject *self, PyObject *args) {
627  char *name;
628  (void)self;
629 
630  if (!PyArg_ParseTuple(args, "s", &name))
631  return NULL;
632  return Py_BuildValue("i", cf_find_animation(name));
633 }
634 
635 static PyObject *getSeasonName(PyObject *self, PyObject *args) {
636  int i;
637  (void)self;
638 
639  if (!PyArg_ParseTuple(args, "i", &i))
640  return NULL;
641  return Py_BuildValue("s", cf_get_season_name(i));
642 }
643 
644 static PyObject *getMonthName(PyObject *self, PyObject *args) {
645  int i;
646  (void)self;
647 
648  if (!PyArg_ParseTuple(args, "i", &i))
649  return NULL;
650  return Py_BuildValue("s", cf_get_month_name(i));
651 }
652 
653 static PyObject *getWeekdayName(PyObject *self, PyObject *args) {
654  int i;
655  (void)self;
656 
657  if (!PyArg_ParseTuple(args, "i", &i))
658  return NULL;
659  return Py_BuildValue("s", cf_get_weekday_name(i));
660 }
661 
662 static PyObject *getPeriodofdayName(PyObject *self, PyObject *args) {
663  int i;
664  (void)self;
665 
666  if (!PyArg_ParseTuple(args, "i", &i))
667  return NULL;
668  return Py_BuildValue("s", cf_get_periodofday_name(i));
669 }
670 
671 static PyObject *addReply(PyObject *self, PyObject *args) {
672  char *word, *reply;
673  talk_info *talk;
674  (void)self;
675 
676  if (current_context->talk == NULL) {
677  set_exception("not in a dialog context");
678  return NULL;
679  }
680  talk = current_context->talk;
681 
682  if (!PyArg_ParseTuple(args, "ss", &word, &reply)) {
683  return NULL;
684  }
685 
686  if (talk->replies_count == MAX_REPLIES) {
687  set_exception("too many replies");
688  return NULL;
689  }
690 
691  talk->replies_words[talk->replies_count] = cf_add_string(word);
692  talk->replies[talk->replies_count] = cf_add_string(reply);
693  talk->replies_count++;
694  Py_INCREF(Py_None);
695  return Py_None;
696 
697 }
698 
699 static PyObject *setPlayerMessage(PyObject *self, PyObject *args) {
700  char *message;
701  int type = rt_reply;
702  (void)self;
703 
704  if (current_context->talk == NULL) {
705  set_exception("not in a dialog context");
706  return NULL;
707  }
708 
709  if (!PyArg_ParseTuple(args, "s|i", &message, &type)) {
710  return NULL;
711  }
712 
713  if (current_context->talk->message != NULL)
716  current_context->talk->message_type = static_cast<reply_type>(type);
717 
718  Py_INCREF(Py_None);
719  return Py_None;
720 }
721 
722 static PyObject *npcSay(PyObject *self, PyObject *args) {
723  Crossfire_Object *npc = NULL;
724  char *message, buf[2048];
725  (void)self;
726 
727  if (!PyArg_ParseTuple(args, "O!s", &Crossfire_ObjectType, &npc, &message))
728  return NULL;
729 
730  if (current_context->talk == NULL) {
731  set_exception("not in a dialog context");
732  return NULL;
733  }
734 
736  set_exception("too many NPCs");
737  return NULL;
738  }
739 
740  if (strlen(message) >= sizeof(buf) - 1)
741  cf_log(llevError, "CFPython: warning, too long message in npcSay, will be truncated");
743  snprintf(buf, sizeof(buf), "%s says: %s", npc->obj->name, message);
744 
747 
748  Py_INCREF(Py_None);
749  return Py_None;
750 }
751 
752 static PyObject *costStringFromValue(PyObject *self, PyObject *args) {
753  uint64_t value;
754  char buf[2048];
755  int largest_coin = 0;
756  (void)self;
757 
758  if (!PyArg_ParseTuple(args, "L|i", &value, &largest_coin))
759  return NULL;
760 
761  cf_cost_string_from_value(value, largest_coin, buf, sizeof(buf));
762  return Py_BuildValue("s", buf);
763 }
764 
765 PyMethodDef CFPythonMethods[] = {
766  { "WhoAmI", getWhoAmI, METH_NOARGS, NULL },
767  { "WhoIsActivator", getWhoIsActivator, METH_NOARGS, NULL },
768  { "WhoIsOther", getWhoIsThird, METH_NOARGS, NULL },
769  { "WhatIsMessage", getWhatIsMessage, METH_NOARGS, NULL },
770  { "ScriptName", getScriptName, METH_NOARGS, NULL },
771  { "ScriptParameters", getScriptParameters, METH_NOARGS, NULL },
772  { "WhatIsEvent", getEvent, METH_NOARGS, NULL },
773  { "MapDirectory", getMapDirectory, METH_NOARGS, NULL },
774  { "UniqueDirectory", getUniqueDirectory, METH_NOARGS, NULL },
775  { "TempDirectory", getTempDirectory, METH_NOARGS, NULL },
776  { "ConfigDirectory", getConfigDirectory, METH_NOARGS, NULL },
777  { "LocalDirectory", getLocalDirectory, METH_NOARGS, NULL },
778  { "PlayerDirectory", getPlayerDirectory, METH_NOARGS, NULL },
779  { "DataDirectory", getDataDirectory, METH_NOARGS, NULL },
780  { "ReadyMap", readyMap, METH_VARARGS, NULL },
781  { "CreateMap", createMap, METH_VARARGS, NULL },
782  { "FindPlayer", findPlayer, METH_VARARGS, NULL },
783  { "MatchString", matchString, METH_VARARGS, NULL },
784  { "GetReturnValue", getReturnValue, METH_NOARGS, NULL },
785  { "SetReturnValue", setReturnValue, METH_VARARGS, NULL },
786  { "PluginVersion", getCFPythonVersion, METH_NOARGS, NULL },
787  { "CreateObject", createCFObject, METH_NOARGS, NULL },
788  { "CreateObjectByName", createCFObjectByName, METH_VARARGS, NULL },
789  { "GetPrivateDictionary", getPrivateDictionary, METH_NOARGS, NULL },
790  { "GetSharedDictionary", getSharedDictionary, METH_NOARGS, NULL },
791  { "GetPlayers", getPlayers, METH_NOARGS, NULL },
792  { "GetArchetypes", getArchetypes, METH_NOARGS, NULL },
793  { "GetMaps", getMaps, METH_NOARGS, NULL },
794  { "GetParties", getParties, METH_NOARGS, NULL },
795  { "GetRegions", getRegions, METH_NOARGS, NULL },
796  { "GetFriendlyList", getFriendlyList, METH_NOARGS, NULL },
797  { "RegisterCommand", registerCommand, METH_VARARGS, NULL },
798  { "RegisterGlobalEvent", registerGEvent, METH_VARARGS, NULL },
799  { "UnregisterGlobalEvent", unregisterGEvent, METH_VARARGS, NULL },
800  { "GetTime", getTime, METH_NOARGS, NULL },
801  { "DestroyTimer", destroyTimer, METH_VARARGS, NULL },
802  { "MapHasBeenLoaded", getMapHasBeenLoaded, METH_VARARGS, NULL },
803  { "Log", log_message, METH_VARARGS, NULL },
804  { "FindFace", findFace, METH_VARARGS, NULL },
805  { "FindAnimation", findAnimation, METH_VARARGS, NULL },
806  { "GetSeasonName", getSeasonName, METH_VARARGS, NULL },
807  { "GetMonthName", getMonthName, METH_VARARGS, NULL },
808  { "GetWeekdayName", getWeekdayName, METH_VARARGS, NULL },
809  { "GetPeriodofdayName", getPeriodofdayName, METH_VARARGS, NULL },
810  { "AddReply", addReply, METH_VARARGS, NULL },
811  { "SetPlayerMessage", setPlayerMessage, METH_VARARGS, NULL },
812  { "NPCSay", npcSay, METH_VARARGS, NULL },
813  { "CostStringFromValue", costStringFromValue, METH_VARARGS, NULL },
814  { NULL, NULL, 0, NULL }
815 };
816 
817 static void initContextStack(void) {
818  current_context = NULL;
819  context_stack = NULL;
820 }
821 
822 static void pushContext(CFPContext *context) {
823  if (current_context == NULL) {
824  context_stack = context;
825  context->down = NULL;
826  } else {
827  context->down = current_context;
828  }
829  current_context = context;
830 }
831 
832 static CFPContext *popContext(void) {
833  CFPContext *oldcontext;
834 
835  if (current_context != NULL) {
836  oldcontext = current_context;
838  return oldcontext;
839  }
840  else
841  return NULL;
842 }
843 
844 static void freeContext(CFPContext *context) {
845  Py_XDECREF(context->event);
846  Py_XDECREF(context->third);
847  Py_XDECREF(context->who);
848  Py_XDECREF(context->activator);
849  free(context);
850 }
851 
855 static PyObject* cfpython_openpyfile(char *filename) {
856  PyObject *scriptfile;
857  int fd;
858  fd = open(filename, O_RDONLY);
859  if (fd == -1)
860  return NULL;
861  scriptfile = PyFile_FromFd(fd, filename, "r", -1, NULL, NULL, NULL, 1);
862  return scriptfile;
863 }
864 
869 static FILE* cfpython_pyfile_asfile(PyObject* obj) {
870  return fdopen(PyObject_AsFileDescriptor(obj), "r");
871 }
872 
877 static PyObject *catcher = NULL;
878 
879 #if defined(IS_PY3K9) || defined(IS_PY3K10)
880 
884 static PyObject *io_module = NULL;
885 #endif
886 
893 static void log_python_error(void) {
894 
895  PyErr_Print();
896 
897  if (catcher != NULL) {
898  PyObject *output = PyObject_GetAttrString(catcher, "value"); //get the stdout and stderr from our catchOutErr object
899  PyObject* empty = PyUnicode_FromString("");
900 
901  cf_log_plain(llevError, PyUnicode_AsUTF8(output));
902  Py_DECREF(output);
903 
904  PyObject_SetAttrString(catcher, "value", empty);
905  Py_DECREF(empty);
906  }
907 
908  return;
909 }
910 
911 
913 static PyCodeObject *compilePython(char *filename) {
914  PyObject *scriptfile = NULL;
915  sstring sh_path;
916  struct stat stat_buf;
917  int i;
918  pycode_cache_entry *replace = NULL, *run = NULL;
919 
920  if (stat(filename, &stat_buf)) {
921  cf_log(llevError, "CFPython: script file %s can't be stat'ed\n", filename);
922  return NULL;
923  }
924 
925  sh_path = cf_add_string(filename);
926 
927  /* Search through cache. Four cases:
928  * 1) script in cache, but older than file -> replace cached
929  * 2) script in cache and up to date -> use cached
930  * 3) script not in cache, cache not full -> add to end of cache
931  * 4) script not in cache, cache full -> replace least recently used
932  */
933  for (i = 0; i < PYTHON_CACHE_SIZE; i++) {
934  if (pycode_cache[i].file == NULL) { /* script not in cache, cache not full */
935  replace = &pycode_cache[i]; /* add to end of cache */
936  break;
937  } else if (pycode_cache[i].file == sh_path) {
938  /* script in cache */
939  if (pycode_cache[i].code == NULL || (pycode_cache[i].cached_time < stat_buf.st_mtime)) {
940  /* cache older than file, replace cached */
941  replace = &pycode_cache[i];
942  } else {
943  /* cache uptodate, use cached*/
944  replace = NULL;
945  run = &pycode_cache[i];
946  }
947  break;
948  } else if (replace == NULL || pycode_cache[i].used_time < replace->used_time)
949  /* if we haven't found it yet, set replace to the oldest cache */
950  replace = &pycode_cache[i];
951  }
952 
953  /* replace a specific cache index with the file */
954  if (replace) {
955  Py_XDECREF(replace->code); /* safe to call on NULL */
956  replace->code = NULL;
957 
958  /* Need to replace path string? */
959  if (replace->file != sh_path) {
960  if (replace->file) {
961  cf_free_string(replace->file);
962  }
963  replace->file = cf_add_string(sh_path);
964  }
965 #if defined (IS_PY3K9) || defined(IS_PY3K10)
966  /* With the new parser in 3.10, we need to read the file contents into a buffer, and then pass that string to compile it.
967  * The new parser removes the PyNode functions as well as PyParser_SimpleParseFile,
968  * so the code needed to be completely rewritten to work.
969  *
970  * Python's solution to these changes is to import the io module and use Python's read method to read in the file,
971  * and then convert the bytes object into a c-string for Py_CompileString
972  *
973  * Though, if it is more performant than the previous code, Py_CompileString is
974  * available for all Python 3, so it is possible to simplify all of them to this if we need to.
975  */
976  if (!io_module)
977  io_module = PyImport_ImportModule("io");
978  scriptfile = PyObject_CallMethod(io_module, "open", "ss", filename, "rb");
979  if (!scriptfile) {
980  cf_log(llevDebug, "CFPython: script file %s can't be opened\n", filename);
981  cf_free_string(sh_path);
982  return NULL;
983  }
984  PyObject *source_bytes = PyObject_CallMethod(scriptfile, "read", "");
985  (void)PyObject_CallMethod(scriptfile, "close", "");
986  PyObject *code = Py_CompileString(PyBytes_AsString(source_bytes), filename, Py_file_input);
987  if (code) {
988  replace->code = (PyCodeObject *)code;
989  }
990  if (PyErr_Occurred())
992  else
993  replace->cached_time = stat_buf.st_mtime;
994  run = replace;
995 #else
996  /* Load, parse and compile. Note: because Pyhon may have been built with a
997  * different library than Crossfire, the FILE* it uses may be incompatible.
998  * Therefore we use PyFile to open the file, then convert to FILE* and get
999  * Python's own structure. Messy, but can't be helped... */
1000  if (!(scriptfile = cfpython_openpyfile(filename))) {
1001  cf_log(llevDebug, "CFPython: script file %s can't be opened\n", filename);
1002  cf_free_string(sh_path);
1003  return NULL;
1004  } else {
1005  /* Note: FILE* being opaque, it works, but the actual structure may be different! */
1006  FILE* pyfile = cfpython_pyfile_asfile(scriptfile);
1007  struct _node *n;
1008  if ((n = PyParser_SimpleParseFile(pyfile, filename, Py_file_input))) {
1009  replace->code = PyNode_Compile(n, filename);
1010  PyNode_Free(n);
1011  }
1012  if (PyErr_Occurred())
1013  log_python_error();
1014  else
1015  replace->cached_time = stat_buf.st_mtime;
1016  run = replace;
1017  }
1018 #endif
1019  }
1020 
1021  cf_free_string(sh_path);
1022 
1023  if (scriptfile) {
1024  Py_DECREF(scriptfile);
1025  }
1026 
1027  assert(run != NULL);
1028  run->used_time = time(NULL);
1029  return run->code;
1030 }
1031 
1032 static int do_script(CFPContext *context) {
1033  PyCodeObject *pycode;
1034  PyObject *dict;
1035  PyObject *ret;
1036 
1037 #ifdef PYTHON_DEBUG
1038  cf_log(llevDebug, "CFPython: running script %s\n", context->script);
1039 #endif
1040 
1041  pycode = compilePython(context->script);
1042  if (pycode) {
1043  pushContext(context);
1044  dict = PyDict_New();
1045  PyDict_SetItemString(dict, "__builtins__", PyEval_GetBuiltins());
1046  ret = PyEval_EvalCode((PyObject *)pycode, dict, NULL);
1047  if (PyErr_Occurred()) {
1048  log_python_error();
1049  }
1050  Py_XDECREF(ret);
1051  Py_DECREF(dict);
1052  return 1;
1053  } else
1054  return 0;
1055 }
1056 
1064 static void addConstants(PyObject *module, const char *name, const CFConstant *constants) {
1065  int i = 0;
1066  char tmp[1024];
1067  PyObject *cst;
1068  PyObject *dict;
1069 
1070  snprintf(tmp, sizeof(tmp), "Crossfire_%s", name);
1071 
1072  cst = PyModule_New(tmp);
1073  dict = PyDict_New();
1074 
1075  while (constants[i].name != NULL) {
1076  PyModule_AddIntConstant(cst, (char *)constants[i].name, constants[i].value);
1077  PyDict_SetItem(dict, PyLong_FromLong(constants[i].value), PyUnicode_FromString(constants[i].name));
1078  i++;
1079  }
1080  PyDict_SetItemString(PyModule_GetDict(module), name, cst);
1081 
1082  snprintf(tmp, sizeof(tmp), "%sName", name);
1083  PyDict_SetItemString(PyModule_GetDict(module), tmp, dict);
1084  Py_DECREF(dict);
1085 }
1086 
1096 static void addSimpleConstants(PyObject *module, const char *name, const CFConstant *constants) {
1097  int i = 0;
1098  char tmp[1024];
1099  PyObject *cst;
1100 
1101  snprintf(tmp, sizeof(tmp), "Crossfire_%s", name);
1102 
1103  cst = PyModule_New(tmp);
1104 
1105  while (constants[i].name != NULL) {
1106  PyModule_AddIntConstant(cst, (char *)constants[i].name, constants[i].value);
1107  i++;
1108  }
1109  PyDict_SetItemString(PyModule_GetDict(module), name, cst);
1110 }
1111 
1113  { "NORTH", 1 },
1114  { "NORTHEAST", 2 },
1115  { "EAST", 3 },
1116  { "SOUTHEAST", 4 },
1117  { "SOUTH", 5 },
1118  { "SOUTHWEST", 6 },
1119  { "WEST", 7 },
1120  { "NORTHWEST", 8 },
1121  { NULL, 0 }
1122 };
1123 
1124 const CFConstant cstType[] = {
1125  { "PLAYER", PLAYER },
1126  { "TRANSPORT", TRANSPORT },
1127  { "ROD", ROD },
1128  { "TREASURE", TREASURE },
1129  { "POTION", POTION },
1130  { "FOOD", FOOD },
1131  { "POISON", POISON },
1132  { "BOOK", BOOK },
1133  { "CLOCK", CLOCK },
1134  { "DRAGON_FOCUS", DRAGON_FOCUS },
1135  { "ARROW", ARROW },
1136  { "BOW", BOW },
1137  { "WEAPON", WEAPON },
1138  { "ARMOUR", ARMOUR },
1139  { "PEDESTAL", PEDESTAL },
1140  { "ALTAR", ALTAR },
1141  { "LOCKED_DOOR", LOCKED_DOOR },
1142  { "SPECIAL_KEY", SPECIAL_KEY },
1143  { "MAP", MAP },
1144  { "DOOR", DOOR },
1145  { "KEY", KEY },
1146  { "TIMED_GATE", TIMED_GATE },
1147  { "TRIGGER", TRIGGER },
1148  { "GRIMREAPER", GRIMREAPER },
1149  { "MAGIC_EAR", MAGIC_EAR },
1150  { "TRIGGER_BUTTON", TRIGGER_BUTTON },
1151  { "TRIGGER_ALTAR", TRIGGER_ALTAR },
1152  { "TRIGGER_PEDESTAL", TRIGGER_PEDESTAL },
1153  { "SHIELD", SHIELD },
1154  { "HELMET", HELMET },
1155  { "MONEY", MONEY },
1156  { "CLASS", CLASS },
1157  { "AMULET", AMULET },
1158  { "PLAYERMOVER", PLAYERMOVER },
1159  { "TELEPORTER", TELEPORTER },
1160  { "CREATOR", CREATOR },
1161  { "SKILL", SKILL },
1162  { "EARTHWALL", EARTHWALL },
1163  { "GOLEM", GOLEM },
1164  { "THROWN_OBJ", THROWN_OBJ },
1165  { "BLINDNESS", BLINDNESS },
1166  { "GOD", GOD },
1167  { "DETECTOR", DETECTOR },
1168  { "TRIGGER_MARKER", TRIGGER_MARKER },
1169  { "DEAD_OBJECT", DEAD_OBJECT },
1170  { "DRINK", DRINK },
1171  { "MARKER", MARKER },
1172  { "HOLY_ALTAR", HOLY_ALTAR },
1173  { "PLAYER_CHANGER", PLAYER_CHANGER },
1174  { "BATTLEGROUND", BATTLEGROUND },
1175  { "PEACEMAKER", PEACEMAKER },
1176  { "GEM", GEM },
1177  { "FIREWALL", FIREWALL },
1178  { "CHECK_INV", CHECK_INV },
1179  { "MOOD_FLOOR", MOOD_FLOOR },
1180  { "EXIT", EXIT },
1181  { "ENCOUNTER", ENCOUNTER },
1182  { "SHOP_FLOOR", SHOP_FLOOR },
1183  { "SHOP_MAT", SHOP_MAT },
1184  { "RING", RING },
1185  { "FLOOR", FLOOR },
1186  { "FLESH", FLESH },
1187  { "INORGANIC", INORGANIC },
1188  { "SKILL_TOOL", SKILL_TOOL },
1189  { "LIGHTER", LIGHTER },
1190  { "WALL", WALL },
1191  { "MISC_OBJECT", MISC_OBJECT },
1192  { "MONSTER", MONSTER },
1193  { "LAMP", LAMP },
1194  { "DUPLICATOR", DUPLICATOR },
1195  { "SPELLBOOK", SPELLBOOK },
1196  { "CLOAK", CLOAK },
1197  { "SPINNER", SPINNER },
1198  { "GATE", GATE },
1199  { "BUTTON", BUTTON },
1200  { "CF_HANDLE", CF_HANDLE },
1201  { "HOLE", HOLE },
1202  { "TRAPDOOR", TRAPDOOR },
1203  { "SIGN", SIGN },
1204  { "BOOTS", BOOTS },
1205  { "GLOVES", GLOVES },
1206  { "SPELL", SPELL },
1207  { "SPELL_EFFECT", SPELL_EFFECT },
1208  { "CONVERTER", CONVERTER },
1209  { "BRACERS", BRACERS },
1210  { "POISONING", POISONING },
1211  { "SAVEBED", SAVEBED },
1212  { "WAND", WAND },
1213  { "SCROLL", SCROLL },
1214  { "DIRECTOR", DIRECTOR },
1215  { "GIRDLE", GIRDLE },
1216  { "FORCE", FORCE },
1217  { "POTION_RESIST_EFFECT", POTION_RESIST_EFFECT },
1218  { "EVENT_CONNECTOR", EVENT_CONNECTOR },
1219  { "CLOSE_CON", CLOSE_CON },
1220  { "CONTAINER", CONTAINER },
1221  { "ARMOUR_IMPROVER", ARMOUR_IMPROVER },
1222  { "WEAPON_IMPROVER", WEAPON_IMPROVER },
1223  { "SKILLSCROLL", SKILLSCROLL },
1224  { "DEEP_SWAMP", DEEP_SWAMP },
1225  { "IDENTIFY_ALTAR", IDENTIFY_ALTAR },
1226  { "SHOP_INVENTORY", SHOP_INVENTORY },
1227  { "RUNE", RUNE },
1228  { "TRAP", TRAP },
1229  { "POWER_CRYSTAL", POWER_CRYSTAL },
1230  { "CORPSE", CORPSE },
1231  { "DISEASE", DISEASE },
1232  { "SYMPTOM", SYMPTOM },
1233  { "BUILDER", BUILDER },
1234  { "MATERIAL", MATERIAL },
1235  { "MIMIC", MIMIC },
1236  { "LIGHTABLE", LIGHTABLE },
1237  { NULL, 0 }
1238 };
1239 
1240 const CFConstant cstMove[] = {
1241  { "WALK", MOVE_WALK },
1242  { "FLY_LOW", MOVE_FLY_LOW },
1243  { "FLY_HIGH", MOVE_FLY_HIGH },
1244  { "FLYING", MOVE_FLYING },
1245  { "SWIM", MOVE_SWIM },
1246  { "BOAT", MOVE_BOAT },
1247  { "ALL", MOVE_ALL },
1248  { NULL, 0 }
1249 };
1250 
1252  { "NDI_BLACK", NDI_BLACK },
1253  { "NDI_WHITE", NDI_WHITE },
1254  { "NDI_NAVY", NDI_NAVY },
1255  { "NDI_RED", NDI_RED },
1256  { "NDI_ORANGE", NDI_ORANGE },
1257  { "NDI_BLUE", NDI_BLUE },
1258  { "NDI_DK_ORANGE", NDI_DK_ORANGE },
1259  { "NDI_GREEN", NDI_GREEN },
1260  { "NDI_LT_GREEN", NDI_LT_GREEN },
1261  { "NDI_GREY", NDI_GREY },
1262  { "NDI_BROWN", NDI_BROWN },
1263  { "NDI_GOLD", NDI_GOLD },
1264  { "NDI_TAN", NDI_TAN },
1265  { "NDI_UNIQUE", NDI_UNIQUE },
1266  { "NDI_ALL", NDI_ALL },
1267  { "NDI_ALL_DMS", NDI_ALL_DMS },
1268  { NULL, 0 }
1269 };
1270 
1272  { "PHYSICAL", AT_PHYSICAL },
1273  { "MAGIC", AT_MAGIC },
1274  { "FIRE", AT_FIRE },
1275  { "ELECTRICITY", AT_ELECTRICITY },
1276  { "COLD", AT_COLD },
1277  { "CONFUSION", AT_CONFUSION },
1278  { "ACID", AT_ACID },
1279  { "DRAIN", AT_DRAIN },
1280  { "WEAPONMAGIC", AT_WEAPONMAGIC },
1281  { "GHOSTHIT", AT_GHOSTHIT },
1282  { "POISON", AT_POISON },
1283  { "SLOW", AT_SLOW },
1284  { "PARALYZE", AT_PARALYZE },
1285  { "TURN_UNDEAD", AT_TURN_UNDEAD },
1286  { "FEAR", AT_FEAR },
1287  { "CANCELLATION", AT_CANCELLATION },
1288  { "DEPLETE", AT_DEPLETE },
1289  { "DEATH", AT_DEATH },
1290  { "CHAOS", AT_CHAOS },
1291  { "COUNTERSPELL", AT_COUNTERSPELL },
1292  { "GODPOWER", AT_GODPOWER },
1293  { "HOLYWORD", AT_HOLYWORD },
1294  { "BLIND", AT_BLIND },
1295  { "INTERNAL", AT_INTERNAL },
1296  { "LIFE_STEALING", AT_LIFE_STEALING },
1297  { "DISEASE", AT_DISEASE },
1298  { NULL, 0 }
1299 };
1300 
1302  { "PHYSICAL", ATNR_PHYSICAL },
1303  { "MAGIC", ATNR_MAGIC },
1304  { "FIRE", ATNR_FIRE },
1305  { "ELECTRICITY", ATNR_ELECTRICITY },
1306  { "COLD", ATNR_COLD },
1307  { "CONFUSION", ATNR_CONFUSION },
1308  { "ACID", ATNR_ACID },
1309  { "DRAIN", ATNR_DRAIN },
1310  { "WEAPONMAGIC", ATNR_WEAPONMAGIC },
1311  { "GHOSTHIT", ATNR_GHOSTHIT },
1312  { "POISON", ATNR_POISON },
1313  { "SLOW", ATNR_SLOW },
1314  { "PARALYZE", ATNR_PARALYZE },
1315  { "TURN_UNDEAD", ATNR_TURN_UNDEAD },
1316  { "FEAR", ATNR_FEAR },
1317  { "CANCELLATION", ATNR_CANCELLATION },
1318  { "DEPLETE", ATNR_DEPLETE },
1319  { "DEATH", ATNR_DEATH },
1320  { "CHAOS", ATNR_CHAOS },
1321  { "COUNTERSPELL", ATNR_COUNTERSPELL },
1322  { "GODPOWER", ATNR_GODPOWER },
1323  { "HOLYWORD", ATNR_HOLYWORD },
1324  { "BLIND", ATNR_BLIND },
1325  { "INTERNAL", ATNR_INTERNAL },
1326  { "LIFE_STEALING", ATNR_LIFE_STEALING },
1327  { "DISEASE", ATNR_DISEASE },
1328  { NULL, 0 }
1329 };
1330 
1333  { "APPLY", EVENT_APPLY },
1334  { "ATTACK", EVENT_ATTACKED },
1335  { "ATTACKS", EVENT_ATTACKS },
1336  { "BOUGHT", EVENT_BOUGHT },
1337  { "CLOSE", EVENT_CLOSE },
1338  { "DEATH", EVENT_DEATH },
1339  { "DESTROY", EVENT_DESTROY },
1340  { "DROP", EVENT_DROP },
1341  { "PICKUP", EVENT_PICKUP },
1342  { "SAY", EVENT_SAY },
1343  { "SELLING", EVENT_SELLING },
1344  { "STOP", EVENT_STOP },
1345  { "TIME", EVENT_TIME },
1346  { "THROW", EVENT_THROW },
1347  { "TRIGGER", EVENT_TRIGGER },
1348  { "TIMER", EVENT_TIMER },
1349  { "USER", EVENT_USER },
1350 
1352  { "BORN", EVENT_BORN },
1353  { "CLOCK", EVENT_CLOCK },
1354  { "CRASH", EVENT_CRASH },
1355  { "GKILL", EVENT_GKILL },
1356  { "KICK", EVENT_KICK },
1357  { "LOGIN", EVENT_LOGIN },
1358  { "LOGOUT", EVENT_LOGOUT },
1359  { "MAPENTER", EVENT_MAPENTER },
1360  { "MAPLEAVE", EVENT_MAPLEAVE },
1361  { "MAPLOAD", EVENT_MAPLOAD },
1362  { "MAPREADY", EVENT_MAPREADY },
1363  { "MAPRESET", EVENT_MAPRESET },
1364  { "MAPUNLOAD", EVENT_MAPUNLOAD },
1365  { "MUZZLE", EVENT_MUZZLE },
1366  { "PLAYER_DEATH", EVENT_PLAYER_DEATH },
1367  { "REMOVE", EVENT_REMOVE },
1368  { "SHOUT", EVENT_SHOUT },
1369  { "TELL", EVENT_TELL },
1370  { NULL, 0 }
1371 };
1372 
1373 const CFConstant cstTime[] = {
1374  { "HOURS_PER_DAY", HOURS_PER_DAY },
1375  { "DAYS_PER_WEEK", DAYS_PER_WEEK },
1376  { "WEEKS_PER_MONTH", WEEKS_PER_MONTH },
1377  { "MONTHS_PER_YEAR", MONTHS_PER_YEAR },
1378  { "SEASONS_PER_YEAR", SEASONS_PER_YEAR },
1379  { "PERIODS_PER_DAY", PERIODS_PER_DAY },
1380  { NULL, 0 }
1381 };
1382 
1384  { "SAY", rt_say },
1385  { "REPLY", rt_reply },
1386  { "QUESTION", rt_question },
1387  { NULL, 0 }
1388 };
1389 
1391  { "DISTATT", DISTATT },
1392  { "RUNATT", RUNATT },
1393  { "HITRUN", HITRUN },
1394  { "WAITATT", WAITATT },
1395  { "RUSH", RUSH },
1396  { "ALLRUN", ALLRUN },
1397  { "DISTHIT", DISTHIT },
1398  { "WAIT2", WAIT2 },
1399  { "PETMOVE", PETMOVE },
1400  { "CIRCLE1", CIRCLE1 },
1401  { "CIRCLE2", CIRCLE2 },
1402  { "PACEH", PACEH },
1403  { "PACEH2", PACEH2 },
1404  { "RANDO", RANDO },
1405  { "RANDO2", RANDO2 },
1406  { "PACEV", PACEV },
1407  { "PACEV2", PACEV2 },
1408  { NULL, 0 }
1409 };
1410 
1411 static void initConstants(PyObject *module) {
1412  addConstants(module, "Direction", cstDirection);
1413  addConstants(module, "Type", cstType);
1414  addConstants(module, "Move", cstMove);
1415  addConstants(module, "MessageFlag", cstMessageFlag);
1416  addConstants(module, "AttackType", cstAttackType);
1417  addConstants(module, "AttackTypeNumber", cstAttackTypeNumber);
1418  addConstants(module, "EventType", cstEventType);
1419  addSimpleConstants(module, "Time", cstTime);
1420  addSimpleConstants(module, "ReplyType", cstReplyTypes);
1421  addSimpleConstants(module, "AttackMovement", cstAttackMovement);
1422 }
1423 
1424 /*
1425  * Set up the main module and handle misc plugin loading stuff and such.
1426  */
1427 
1432 static void cfpython_init_types(PyObject* m) {
1433  PyObject *d = PyModule_GetDict(m);
1434 
1435  Crossfire_ObjectType.tp_new = PyType_GenericNew;
1436  Crossfire_MapType.tp_new = PyType_GenericNew;
1437  Crossfire_PlayerType.tp_new = PyType_GenericNew;
1438  Crossfire_ArchetypeType.tp_new = PyType_GenericNew;
1439  Crossfire_PartyType.tp_new = PyType_GenericNew;
1440  Crossfire_RegionType.tp_new = PyType_GenericNew;
1441  PyType_Ready(&Crossfire_ObjectType);
1442  PyType_Ready(&Crossfire_MapType);
1443  PyType_Ready(&Crossfire_PlayerType);
1444  PyType_Ready(&Crossfire_ArchetypeType);
1445  PyType_Ready(&Crossfire_PartyType);
1446  PyType_Ready(&Crossfire_RegionType);
1447 
1448  Py_INCREF(&Crossfire_ObjectType);
1449  Py_INCREF(&Crossfire_MapType);
1450  Py_INCREF(&Crossfire_PlayerType);
1451  Py_INCREF(&Crossfire_ArchetypeType);
1452  Py_INCREF(&Crossfire_PartyType);
1453  Py_INCREF(&Crossfire_RegionType);
1454 
1455  PyModule_AddObject(m, "Object", (PyObject *)&Crossfire_ObjectType);
1456  PyModule_AddObject(m, "Map", (PyObject *)&Crossfire_MapType);
1457  PyModule_AddObject(m, "Player", (PyObject *)&Crossfire_PlayerType);
1458  PyModule_AddObject(m, "Archetype", (PyObject *)&Crossfire_ArchetypeType);
1459  PyModule_AddObject(m, "Party", (PyObject *)&Crossfire_PartyType);
1460  PyModule_AddObject(m, "Region", (PyObject *)&Crossfire_RegionType);
1461 
1462  PyModule_AddObject(m, "LogError", Py_BuildValue("i", llevError));
1463  PyModule_AddObject(m, "LogInfo", Py_BuildValue("i", llevInfo));
1464  PyModule_AddObject(m, "LogDebug", Py_BuildValue("i", llevDebug));
1465  PyModule_AddObject(m, "LogMonster", Py_BuildValue("i", llevMonster));
1466 
1467  CFPythonError = PyErr_NewException("Crossfire.error", NULL, NULL);
1468  PyDict_SetItemString(d, "error", CFPythonError);
1469 }
1470 
1471 extern PyObject* PyInit_cjson(void);
1472 
1473 static PyModuleDef CrossfireModule = {
1474  PyModuleDef_HEAD_INIT,
1475  "Crossfire", /* m_name */
1476  NULL, /* m_doc */
1477  -1, /* m_size */
1478  CFPythonMethods, /* m_methods */
1479  NULL, /* m_reload */
1480  NULL, /* m_traverse */
1481  NULL, /* m_clear */
1482  NULL /* m_free */
1483 };
1484 
1485 static PyObject* PyInit_Crossfire(void)
1486 {
1487  PyObject *m = PyModule_Create(&CrossfireModule);
1488  Py_INCREF(m);
1489  return m;
1490 }
1491 
1492 extern "C"
1493 int initPlugin(const char *iversion, f_plug_api gethooksptr) {
1494  PyObject *m;
1495  /* Python code to redirect stdouts/stderr. */
1496  const char *stdOutErr =
1497 "import sys\n\
1498 class CatchOutErr:\n\
1499  def __init__(self):\n\
1500  self.value = ''\n\
1501  def write(self, txt):\n\
1502  self.value += txt\n\
1503 catchOutErr = CatchOutErr()\n\
1504 sys.stdout = catchOutErr\n\
1505 sys.stderr = catchOutErr\n\
1506 ";
1507  (void)iversion;
1508 
1509  for (int c = 0; c < MAX_COMMANDS; c++) {
1510  registered_commands[c] = 0;
1511  }
1512 
1513  cf_init_plugin(gethooksptr);
1514  cf_log(llevDebug, "CFPython 2.0a init\n");
1515 
1516  PyImport_AppendInittab("Crossfire", &PyInit_Crossfire);
1517  PyImport_AppendInittab("cjson", &PyInit_cjson);
1518 
1519  Py_Initialize();
1520 
1521  m = PyImport_ImportModule("Crossfire");
1522 
1524 
1525  initConstants(m);
1526  private_data = PyDict_New();
1527  shared_data = PyDict_New();
1528 
1529  /* Redirect Python's stderr to a special object so it can be put to
1530  * the Crossfire log. */
1531  m = PyImport_AddModule("__main__");
1532  PyRun_SimpleString(stdOutErr);
1533  catcher = PyObject_GetAttrString(m, "catchOutErr");
1534  return 0;
1535 }
1536 
1538  va_list args;
1539  const char *propname;
1540  int size;
1541  char *buf;
1542 
1543  va_start(args, type);
1544  propname = va_arg(args, const char *);
1545  if (!strcmp(propname, "Identification")) {
1546  buf = va_arg(args, char *);
1547  size = va_arg(args, int);
1548  va_end(args);
1549  snprintf(buf, size, PLUGIN_NAME);
1550  return NULL;
1551  } else if (!strcmp(propname, "FullName")) {
1552  buf = va_arg(args, char *);
1553  size = va_arg(args, int);
1554  va_end(args);
1555  snprintf(buf, size, PLUGIN_VERSION);
1556  return NULL;
1557  }
1558  va_end(args);
1559  return NULL;
1560 }
1561 
1562 static int GECodes[] = {
1563  EVENT_BORN,
1564  EVENT_CLOCK,
1566  EVENT_GKILL,
1567  EVENT_LOGIN,
1568  EVENT_LOGOUT,
1572  EVENT_REMOVE,
1573  EVENT_SHOUT,
1574  EVENT_TELL,
1575  EVENT_MUZZLE,
1576  EVENT_KICK,
1578  EVENT_MAPLOAD,
1580  0
1581 };
1582 
1583 static const char* GEPaths[] = {
1584  "born",
1585  "clock",
1586  "death",
1587  "gkill",
1588  "login",
1589  "logout",
1590  "mapenter",
1591  "mapleave",
1592  "mapreset",
1593  "remove",
1594  "shout",
1595  "tell",
1596  "muzzle",
1597  "kick",
1598  "mapunload",
1599  "mapload",
1600  "mapready",
1601  NULL
1602 };
1603 
1609 static void freeEventFiles(char **eventFiles) {
1610  assert(eventFiles);
1611  for (int e = 0; eventFiles[e] != NULL; e++) {
1612  free(eventFiles[e]);
1613  }
1614  free(eventFiles);
1615 }
1616 
1622 static char **getEventFiles(CFPContext *context) {
1623  char **eventFiles = NULL;
1624  char name[HUGE_BUF], path[NAME_MAX + 1];
1625 
1626  int allocated = 0, current = 0;
1627  DIR *dp;
1628  struct dirent *d;
1629  struct stat sb;
1630 
1631  snprintf(name, sizeof(name), "python/events/%s/", context->options);
1632  cf_get_maps_directory(name, path, sizeof(path));
1633 
1634  dp = opendir(path);
1635  if (dp == NULL) {
1636  eventFiles = static_cast<char **>(calloc(1, sizeof(eventFiles[0])));
1637  eventFiles[0] = NULL;
1638  return eventFiles;
1639  }
1640 
1641  while ((d = readdir(dp)) != NULL) {
1642  snprintf(name, sizeof(name), "%s%s", path, d->d_name);
1643  stat(name, &sb);
1644  if (S_ISDIR(sb.st_mode)) {
1645  continue;
1646  }
1647  if (strcmp(d->d_name + strlen(d->d_name) - 3, ".py")) {
1648  continue;
1649  }
1650 
1651  if (allocated == current) {
1652  allocated += 10;
1653  eventFiles = static_cast<char **>(realloc(eventFiles, sizeof(char *) * (allocated + 1)));
1654  for (int i = current; i < allocated + 1; i++) {
1655  eventFiles[i] = NULL;
1656  }
1657  }
1658  eventFiles[current] = strdup(name);
1659  current++;
1660  }
1661  (void)closedir(dp);
1662  return eventFiles;
1663 }
1664 
1666  PyObject *scriptfile;
1667  char path[1024];
1668  int i;
1669 
1670  cf_log(llevDebug, "CFPython 2.0a post init\n");
1671  initContextStack();
1672  for (i = 0; GECodes[i] != 0; i++)
1674 
1675  scriptfile = cfpython_openpyfile(cf_get_maps_directory("python/events/python_init.py", path, sizeof(path)));
1676  if (scriptfile != NULL) {
1677  FILE* pyfile = cfpython_pyfile_asfile(scriptfile);
1678  PyRun_SimpleFile(pyfile, cf_get_maps_directory("python/events/python_init.py", path, sizeof(path)));
1679  Py_DECREF(scriptfile);
1680  }
1681 
1682  for (i = 0; i < PYTHON_CACHE_SIZE; i++) {
1683  pycode_cache[i].code = NULL;
1684  pycode_cache[i].file = NULL;
1685  pycode_cache[i].cached_time = 0;
1686  pycode_cache[i].used_time = 0;
1687  }
1688 
1689  return 0;
1690 }
1691 
1692 static const char *getGlobalEventPath(int code) {
1693  for (int i = 0; GECodes[i] != 0; i++) {
1694  if (GECodes[i] == code)
1695  return GEPaths[i];
1696  }
1697  return "";
1698 }
1699 
1701  va_list args;
1702  int rv = 0;
1703  CFPContext *context;
1704  char *buf;
1705  player *pl;
1706  object *op;
1707  context = static_cast<CFPContext *>(calloc(1, sizeof(CFPContext)));
1708  char **files;
1709 
1710  va_start(args, type);
1711  context->event_code = va_arg(args, int);
1712 
1713  context->message[0] = 0;
1714 
1715  rv = context->returnvalue = 0;
1716  switch (context->event_code) {
1717  case EVENT_CRASH:
1718  cf_log(llevDebug, "CFPython: event_crash unimplemented for now\n");
1719  break;
1720 
1721  case EVENT_BORN:
1722  op = va_arg(args, object *);
1723  context->activator = Crossfire_Object_wrap(op);
1724  break;
1725 
1726  case EVENT_PLAYER_DEATH:
1727  op = va_arg(args, object *);
1728  context->who = Crossfire_Object_wrap(op);
1729  op = va_arg(args, object *);
1730  context->activator = Crossfire_Object_wrap(op);
1731  break;
1732 
1733  case EVENT_GKILL:
1734  {
1735  op = va_arg(args, object *);
1736  object* hitter = va_arg(args, object *);
1737  context->who = Crossfire_Object_wrap(op);
1739  break;
1740  }
1741 
1742  case EVENT_LOGIN:
1743  pl = va_arg(args, player *);
1744  context->activator = Crossfire_Object_wrap(pl->ob);
1745  buf = va_arg(args, char *);
1746  if (buf != NULL)
1747  snprintf(context->message, sizeof(context->message), "%s", buf);
1748  break;
1749 
1750  case EVENT_LOGOUT:
1751  pl = va_arg(args, player *);
1752  context->activator = Crossfire_Object_wrap(pl->ob);
1753  buf = va_arg(args, char *);
1754  if (buf != NULL)
1755  snprintf(context->message, sizeof(context->message), "%s", buf);
1756  break;
1757 
1758  case EVENT_REMOVE:
1759  op = va_arg(args, object *);
1760  context->activator = Crossfire_Object_wrap(op);
1761  break;
1762 
1763  case EVENT_SHOUT:
1764  op = va_arg(args, object *);
1765  context->activator = Crossfire_Object_wrap(op);
1766  buf = va_arg(args, char *);
1767  if (buf != NULL)
1768  snprintf(context->message, sizeof(context->message), "%s", buf);
1769  break;
1770 
1771  case EVENT_MUZZLE:
1772  op = va_arg(args, object *);
1773  context->activator = Crossfire_Object_wrap(op);
1774  buf = va_arg(args, char *);
1775  if (buf != NULL)
1776  snprintf(context->message, sizeof(context->message), "%s", buf);
1777  break;
1778 
1779  case EVENT_KICK:
1780  op = va_arg(args, object *);
1781  context->activator = Crossfire_Object_wrap(op);
1782  buf = va_arg(args, char *);
1783  if (buf != NULL)
1784  snprintf(context->message, sizeof(context->message), "%s", buf);
1785  break;
1786 
1787  case EVENT_MAPENTER:
1788  op = va_arg(args, object *);
1789  context->activator = Crossfire_Object_wrap(op);
1790  context->who = Crossfire_Map_wrap(va_arg(args, mapstruct *));
1791  break;
1792 
1793  case EVENT_MAPLEAVE:
1794  op = va_arg(args, object *);
1795  context->activator = Crossfire_Object_wrap(op);
1796  context->who = Crossfire_Map_wrap(va_arg(args, mapstruct *));
1797  break;
1798 
1799  case EVENT_CLOCK:
1800  break;
1801 
1802  case EVENT_MAPRESET:
1803  context->who = Crossfire_Map_wrap(va_arg(args, mapstruct *));
1804  break;
1805 
1806  case EVENT_TELL:
1807  op = va_arg(args, object *);
1808  buf = va_arg(args, char *);
1809  context->activator = Crossfire_Object_wrap(op);
1810  if (buf != NULL)
1811  snprintf(context->message, sizeof(context->message), "%s", buf);
1812  op = va_arg(args, object *);
1813  context->third = Crossfire_Object_wrap(op);
1814  break;
1815 
1816  case EVENT_MAPUNLOAD:
1817  context->who = Crossfire_Map_wrap(va_arg(args, mapstruct *));
1818  break;
1819 
1820  case EVENT_MAPLOAD:
1821  context->who = Crossfire_Map_wrap(va_arg(args, mapstruct *));
1822  break;
1823  }
1824  va_end(args);
1825  context->returnvalue = 0;
1826 
1827  if (context->event_code == EVENT_CLOCK) {
1828  // Ignore EVENT_CLOCK. It is not being used in maps, but nevertheless
1829  // runs python_init.py several times per second even while idling.
1830  freeContext(context);
1831  return rv;
1832  }
1833 
1834  snprintf(context->options, sizeof(context->options), "%s", getGlobalEventPath(context->event_code));
1835  files = getEventFiles(context);
1836  for (int file = 0; files[file] != NULL; file++)
1837  {
1838  CFPContext *copy = static_cast<CFPContext *>(malloc(sizeof(CFPContext)));
1839  (*copy) = (*context);
1840  Py_XINCREF(copy->activator);
1841  Py_XINCREF(copy->event);
1842  Py_XINCREF(copy->third);
1843  Py_XINCREF(copy->who);
1844  strncpy(copy->script, files[file], sizeof(copy->script));
1845 
1846  if (!do_script(copy)) {
1847  freeContext(copy);
1848  freeEventFiles(files);
1849  return rv;
1850  }
1851 
1852  copy = popContext();
1853  rv = copy->returnvalue;
1854 
1855  freeContext(copy);
1856  }
1857  freeEventFiles(files);
1858 
1859  /* Invalidate freed map wrapper. */
1860  if (context->event_code == EVENT_MAPUNLOAD)
1862 
1863  free(context);
1864 
1865  return rv;
1866 }
1867 
1868 CF_PLUGIN int eventListener(int *type, ...) {
1869  int rv = 0;
1870  va_list args;
1871  char *buf;
1872  CFPContext *context;
1873  object *event;
1874 
1875  context = static_cast<CFPContext *>(malloc(sizeof(CFPContext)));
1876 
1877  context->message[0] = 0;
1878 
1879  va_start(args, type);
1880 
1881  context->who = Crossfire_Object_wrap(va_arg(args, object *));
1882  context->activator = Crossfire_Object_wrap(va_arg(args, object *));
1883  context->third = Crossfire_Object_wrap(va_arg(args, object *));
1884  buf = va_arg(args, char *);
1885  if (buf != NULL)
1886  snprintf(context->message, sizeof(context->message), "%s", buf);
1887  /* fix = */va_arg(args, int);
1888  event = va_arg(args, object *);
1889  context->talk = va_arg(args, talk_info *);
1890  context->event_code = event->subtype;
1891  context->event = Crossfire_Object_wrap(event);
1892  cf_get_maps_directory(event->slaying, context->script, sizeof(context->script));
1893  snprintf(context->options, sizeof(context->options), "%s", event->name);
1894  context->returnvalue = 0;
1895 
1896  va_end(args);
1897 
1898  if (!do_script(context)) {
1899  freeContext(context);
1900  return rv;
1901  }
1902 
1903  context = popContext();
1904  rv = context->returnvalue;
1905  freeContext(context);
1906  return rv;
1907 }
1908 
1910  int i;
1911 
1912  cf_log(llevDebug, "CFPython 2.0a closing\n");
1913 
1914  for (int c = 0; c < MAX_COMMANDS; c++) {
1915  if (registered_commands[c]) {
1917  }
1918  }
1919 
1920  for (i = 0; i < PYTHON_CACHE_SIZE; i++) {
1921  Py_XDECREF(pycode_cache[i].code);
1922  if (pycode_cache[i].file != NULL)
1924  }
1925 
1926  Py_Finalize();
1927 
1928  return 0;
1929 }
cf_cost_string_from_value
void cf_cost_string_from_value(uint64_t cost, int largest_coin, char *buffer, int length)
Definition: plugin_common.cpp:994
CLASS
@ CLASS
Definition: object.h:143
findPlayer
static PyObject * findPlayer(PyObject *self, PyObject *args)
Definition: cfpython.cpp:206
getMonthName
static PyObject * getMonthName(PyObject *self, PyObject *args)
Definition: cfpython.cpp:644
CFPContext::event_code
int event_code
Definition: cfpython.h:101
TRIGGER
@ TRIGGER
Definition: object.h:134
MIMIC
@ MIMIC
Definition: object.h:254
PLAYER
@ PLAYER
Definition: object.h:112
cf_log
void cf_log(LogLevel logLevel, const char *format,...)
Definition: plugin_common.cpp:1522
ATNR_PARALYZE
#define ATNR_PARALYZE
Definition: attack.h:61
cstMove
const CFConstant cstMove[]
Definition: cfpython.cpp:1240
pycode_cache_entry::used_time
time_t used_time
Definition: cfpython.cpp:81
DAYS_PER_WEEK
#define DAYS_PER_WEEK
Definition: tod.h:16
ATNR_CANCELLATION
#define ATNR_CANCELLATION
Definition: attack.h:64
getCFPythonVersion
static PyObject * getCFPythonVersion(PyObject *self, PyObject *args)
Definition: cfpython.cpp:165
shared_data
static PyObject * shared_data
Definition: cfpython.cpp:108
CF_HANDLE
@ CF_HANDLE
Definition: object.h:213
cf_get_weekday_name
const char * cf_get_weekday_name(int index)
Definition: plugin_common.cpp:1574
cf_add_string
sstring cf_add_string(const char *str)
Definition: plugin_common.cpp:1167
talk_info::replies
sstring replies[MAX_REPLIES]
Definition: dialog.h:57
MAP
@ MAP
Definition: object.h:130
getSeasonName
static PyObject * getSeasonName(PyObject *self, PyObject *args)
Definition: cfpython.cpp:635
cf_get_directory
const char * cf_get_directory(int id)
Definition: plugin_common.cpp:1130
getLocalDirectory
static PyObject * getLocalDirectory(PyObject *self, PyObject *args)
Definition: cfpython.cpp:275
AT_POISON
#define AT_POISON
Definition: attack.h:86
ATNR_INTERNAL
#define ATNR_INTERNAL
Definition: attack.h:72
AT_MAGIC
#define AT_MAGIC
Definition: attack.h:77
MONSTER
@ MONSTER
Definition: object.h:205
BOW
@ BOW
Definition: object.h:123
BRACERS
@ BRACERS
Definition: object.h:222
CLOSE_CON
@ CLOSE_CON
Definition: object.h:234
WAITATT
#define WAITATT
Definition: define.h:495
llevError
@ llevError
Definition: logger.h:11
ARMOUR_IMPROVER
@ ARMOUR_IMPROVER
Definition: object.h:237
maps
static std::unordered_map< std::string, mapzone * > maps
Definition: citylife.cpp:92
EVENT_CONNECTOR
@ EVENT_CONNECTOR
Definition: object.h:232
MOVE_ALL
#define MOVE_ALL
Definition: define.h:398
SYMPTOM
@ SYMPTOM
Definition: object.h:250
WAND
@ WAND
Definition: object.h:225
cf_get_season_name
const char * cf_get_season_name(int index)
Definition: plugin_common.cpp:1556
ALLRUN
#define ALLRUN
Definition: define.h:497
talk_info::replies_words
sstring replies_words[MAX_REPLIES]
Definition: dialog.h:56
talk_info::npc_msg_count
int npc_msg_count
Definition: dialog.h:58
FLESH
@ FLESH
Definition: object.h:192
ENCOUNTER
@ ENCOUNTER
Definition: object.h:187
player
Definition: player.h:105
GLOVES
@ GLOVES
Definition: object.h:218
altar_valkyrie.obj
obj
Definition: altar_valkyrie.py:33
GIRDLE
@ GIRDLE
Definition: object.h:228
compilePython
static PyCodeObject * compilePython(char *filename)
Definition: cfpython.cpp:913
ATNR_ACID
#define ATNR_ACID
Definition: attack.h:55
BUTTON
@ BUTTON
Definition: object.h:212
timeofday_t::year
int year
Definition: tod.h:39
RUNATT
#define RUNATT
Definition: define.h:493
AT_ELECTRICITY
#define AT_ELECTRICITY
Definition: attack.h:79
archininventory.arch
arch
DIALOGCHECK MINARGS 1 MAXARGS 1
Definition: archininventory.py:16
PACEV2
#define PACEV2
Definition: define.h:526
TRIGGER_PEDESTAL
@ TRIGGER_PEDESTAL
Definition: object.h:139
NDI_GREEN
#define NDI_GREEN
Definition: newclient.h:252
CFBank.open
def open()
Definition: CFBank.py:69
CFPContext::third
PyObject * third
Definition: cfpython.h:98
Crossfire_Object
Definition: cfpython_object.h:32
timeofday_t::weekofmonth
int weekofmonth
Definition: tod.h:45
c
static event_registration c
Definition: citylife.cpp:425
AT_PHYSICAL
#define AT_PHYSICAL
Definition: attack.h:76
postInitPlugin
CF_PLUGIN int postInitPlugin(void)
Definition: cfpython.cpp:1665
eventListener
CF_PLUGIN int eventListener(int *type,...)
Definition: cfpython.cpp:1868
SHOP_FLOOR
@ SHOP_FLOOR
Definition: object.h:188
GEM
@ GEM
Definition: object.h:172
cf_create_object_by_name
object * cf_create_object_by_name(const char *name)
Definition: plugin_common.cpp:1093
HITRUN
#define HITRUN
Definition: define.h:494
HOURS_PER_DAY
#define HOURS_PER_DAY
Definition: tod.h:15
TRAP
@ TRAP
Definition: object.h:246
setPlayerMessage
static PyObject * setPlayerMessage(PyObject *self, PyObject *args)
Definition: cfpython.cpp:699
CFPythonError
static PyObject * CFPythonError
Definition: cfpython.cpp:90
player::ob
object * ob
Definition: player.h:177
ARMOUR
@ ARMOUR
Definition: object.h:125
guildoracle.list
list
Definition: guildoracle.py:87
SVN_REV
#define SVN_REV
Definition: svnversion.h:2
popContext
static CFPContext * popContext(void)
Definition: cfpython.cpp:832
WEAPON
@ WEAPON
Definition: object.h:124
TIMED_GATE
@ TIMED_GATE
Definition: object.h:133
guildjoin.ob
ob
Definition: guildjoin.py:42
timeofday_t
Definition: tod.h:38
EVENT_TIMER
#define EVENT_TIMER
Definition: events.h:35
say.reply
string reply
Definition: say.py:77
getPrivateDictionary
static PyObject * getPrivateDictionary(PyObject *self, PyObject *args)
Definition: cfpython.cpp:362
CFPContext::activator
PyObject * activator
Definition: cfpython.h:97
cf_timer_destroy
int cf_timer_destroy(int id)
Definition: plugin_common.cpp:1620
ATNR_SLOW
#define ATNR_SLOW
Definition: attack.h:60
CFAPI_SYSTEM_ARCHETYPES
#define CFAPI_SYSTEM_ARCHETYPES
Definition: plugin.h:286
AMULET
@ AMULET
Definition: object.h:144
CHECK_INV
@ CHECK_INV
Definition: object.h:174
getConfigDirectory
static PyObject * getConfigDirectory(PyObject *self, PyObject *args)
Definition: cfpython.cpp:269
mad_mage_user.file
file
Definition: mad_mage_user.py:15
initPlugin
int initPlugin(const char *iversion, f_plug_api gethooksptr)
Definition: cfpython.cpp:1493
ATNR_GODPOWER
#define ATNR_GODPOWER
Definition: attack.h:69
TREASURE
@ TREASURE
Definition: object.h:115
EVENT_MAPLOAD
#define EVENT_MAPLOAD
Definition: events.h:48
NDI_ALL_DMS
#define NDI_ALL_DMS
Definition: newclient.h:267
Crossfire_Party_wrap
PyObject * Crossfire_Party_wrap(partylist *what)
Definition: cfpython_party.cpp:61
SKILL
@ SKILL
Definition: object.h:148
flags
static const flag_definition flags[]
Definition: gridarta-types-convert.cpp:101
RUNE
@ RUNE
Definition: object.h:245
createCFObject
static PyObject * createCFObject(PyObject *self, PyObject *args)
Definition: cfpython.cpp:142
ATNR_DISEASE
#define ATNR_DISEASE
Definition: attack.h:74
registerCommand
static PyObject * registerCommand(PyObject *self, PyObject *args)
Definition: cfpython.cpp:500
pycode_cache
static pycode_cache_entry pycode_cache[PYTHON_CACHE_SIZE]
Definition: cfpython.cpp:88
Ice.tmp
int tmp
Definition: Ice.py:207
AT_INTERNAL
#define AT_INTERNAL
Definition: attack.h:99
NDI_RED
#define NDI_RED
Definition: newclient.h:248
CREATOR
@ CREATOR
Definition: object.h:147
EVENT_LOGOUT
#define EVENT_LOGOUT
Definition: events.h:45
NDI_NAVY
#define NDI_NAVY
Definition: newclient.h:247
RANDO
#define RANDO
Definition: define.h:520
pushContext
static void pushContext(CFPContext *context)
Definition: cfpython.cpp:822
COMMAND_TYPE_NORMAL
#define COMMAND_TYPE_NORMAL
Definition: commands.h:35
llevMonster
@ llevMonster
Definition: logger.h:14
EVENT_SAY
#define EVENT_SAY
Definition: events.h:29
TRANSPORT
@ TRANSPORT
Definition: object.h:113
ATNR_PHYSICAL
#define ATNR_PHYSICAL
Definition: attack.h:49
POTION_RESIST_EFFECT
@ POTION_RESIST_EFFECT
Definition: object.h:230
FLOOR
@ FLOOR
Definition: object.h:191
SIGN
@ SIGN
Definition: object.h:216
CFAPI_SYSTEM_PLAYERS
#define CFAPI_SYSTEM_PLAYERS
Definition: plugin.h:285
NAME_MAX
#define NAME_MAX
Definition: define.h:30
ATNR_TURN_UNDEAD
#define ATNR_TURN_UNDEAD
Definition: attack.h:62
TRIGGER_BUTTON
@ TRIGGER_BUTTON
Definition: object.h:137
getEventFiles
static char ** getEventFiles(CFPContext *context)
Definition: cfpython.cpp:1622
npc_dialog.filename
filename
Definition: npc_dialog.py:99
friends
static std::vector< std::pair< object *, tag_t > > friends
Definition: friend.cpp:23
CFPContext::down
CFPContext * down
Definition: cfpython.h:95
Handle_Map_Unload_Hook
void Handle_Map_Unload_Hook(Crossfire_Map *map)
Definition: cfpython_map.cpp:430
NDI_BLUE
#define NDI_BLUE
Definition: newclient.h:250
current_context
CFPContext * current_context
Definition: cfpython.cpp:106
POWER_CRYSTAL
@ POWER_CRYSTAL
Definition: object.h:247
WEEKS_PER_MONTH
#define WEEKS_PER_MONTH
Definition: tod.h:17
AT_LIFE_STEALING
#define AT_LIFE_STEALING
Definition: attack.h:100
buf
StringBuffer * buf
Definition: readable.cpp:1565
HUGE_BUF
#define HUGE_BUF
Definition: define.h:37
PACEH
#define PACEH
Definition: define.h:514
POISONING
@ POISONING
Definition: object.h:223
AT_DEATH
#define AT_DEATH
Definition: attack.h:93
ATNR_CONFUSION
#define ATNR_CONFUSION
Definition: attack.h:54
Crossfire_Object_wrap
PyObject * Crossfire_Object_wrap(object *what)
Definition: cfpython_object.cpp:1606
cstMessageFlag
const CFConstant cstMessageFlag[]
Definition: cfpython.cpp:1251
ATNR_HOLYWORD
#define ATNR_HOLYWORD
Definition: attack.h:70
NDI_ORANGE
#define NDI_ORANGE
Definition: newclient.h:249
talk_info::message
sstring message
Definition: dialog.h:53
talk_info::replies_count
int replies_count
Definition: dialog.h:55
cf_system_get_region_vector
void cf_system_get_region_vector(int property, std::vector< region * > *list)
Definition: plugin_common.cpp:2140
getDataDirectory
static PyObject * getDataDirectory(PyObject *self, PyObject *args)
Definition: cfpython.cpp:287
TRIGGER_MARKER
@ TRIGGER_MARKER
Definition: object.h:158
Crossfire_PlayerType
PyTypeObject Crossfire_PlayerType
ATNR_BLIND
#define ATNR_BLIND
Definition: attack.h:71
CFPContext::who
PyObject * who
Definition: cfpython.h:96
m
static event_registration m
Definition: citylife.cpp:425
getPluginProperty
CF_PLUGIN void * getPluginProperty(int *type,...)
Definition: cfpython.cpp:1537
AT_CHAOS
#define AT_CHAOS
Definition: attack.h:94
CLOAK
@ CLOAK
Definition: object.h:209
timeofday_t::day
int day
Definition: tod.h:41
pycode_cache_entry::cached_time
time_t cached_time
Definition: cfpython.cpp:80
opendir
DIR * opendir(const char *)
EVENT_LOGIN
#define EVENT_LOGIN
Definition: events.h:44
HELMET
@ HELMET
Definition: object.h:141
disinfect.map
map
Definition: disinfect.py:4
POISON
@ POISON
Definition: object.h:118
setReturnValue
static PyObject * setReturnValue(PyObject *self, PyObject *args)
Definition: cfpython.cpp:179
cf_log_plain
void cf_log_plain(LogLevel logLevel, const char *message)
Definition: plugin_common.cpp:1542
EVENT_STOP
#define EVENT_STOP
Definition: events.h:31
EVENT_CLOCK
#define EVENT_CLOCK
Definition: events.h:40
getArchetypes
static PyObject * getArchetypes(PyObject *self, PyObject *args)
Definition: cfpython.cpp:384
DEEP_SWAMP
@ DEEP_SWAMP
Definition: object.h:241
make_face_from_files.args
args
Definition: make_face_from_files.py:37
MARKER
@ MARKER
Definition: object.h:163
rotate-tower.result
bool result
Definition: rotate-tower.py:13
getMapHasBeenLoaded
static PyObject * getMapHasBeenLoaded(PyObject *self, PyObject *args)
Definition: cfpython.cpp:571
GEPaths
static const char * GEPaths[]
Definition: cfpython.cpp:1583
EVENT_PICKUP
#define EVENT_PICKUP
Definition: events.h:28
EVENT_CRASH
#define EVENT_CRASH
Definition: events.h:41
getMapDirectory
static PyObject * getMapDirectory(PyObject *self, PyObject *args)
Definition: cfpython.cpp:251
SAVEBED
@ SAVEBED
Definition: object.h:224
EVENT_SELLING
#define EVENT_SELLING
Definition: events.h:30
AT_COLD
#define AT_COLD
Definition: attack.h:80
CF_PLUGIN
#define CF_PLUGIN
Definition: plugin_common.h:38
SEASONS_PER_YEAR
#define SEASONS_PER_YEAR
Definition: tod.h:19
LIGHTABLE
@ LIGHTABLE
Definition: object.h:255
POTION
@ POTION
Definition: object.h:116
timeofday_t::periodofday
int periodofday
Definition: tod.h:47
MOVE_WALK
#define MOVE_WALK
Definition: define.h:392
cf_find_face
int cf_find_face(const char *name, int error)
Definition: plugin_common.cpp:1510
BUILDER
@ BUILDER
Definition: object.h:251
EVENT_DROP
#define EVENT_DROP
Definition: events.h:27
findFace
static PyObject * findFace(PyObject *self, PyObject *args)
Definition: cfpython.cpp:580
EVENT_TRIGGER
#define EVENT_TRIGGER
Definition: events.h:34
f_plug_api
void(* f_plug_api)(int *type,...)
Definition: plugin.h:79
EVENT_MAPENTER
#define EVENT_MAPENTER
Definition: events.h:46
cstDirection
const CFConstant cstDirection[]
Definition: cfpython.cpp:1112
CFPContext
Definition: cfpython.h:94
npcSay
static PyObject * npcSay(PyObject *self, PyObject *args)
Definition: cfpython.cpp:722
cf_system_unregister_global_event
void cf_system_unregister_global_event(int event, const char *name)
Definition: plugin_common.cpp:1109
cf_get_month_name
const char * cf_get_month_name(int index)
Definition: plugin_common.cpp:1565
cf_init_plugin
int cf_init_plugin(f_plug_api getHooks)
Definition: plugin_common.cpp:146
ROD
@ ROD
Definition: object.h:114
CONTAINER
@ CONTAINER
Definition: object.h:236
INORGANIC
@ INORGANIC
Definition: object.h:193
readdir
struct dirent * readdir(DIR *)
python_init.path
path
Definition: python_init.py:8
cf_get_empty_map
mapstruct * cf_get_empty_map(int sizex, int sizey)
Definition: plugin_common.cpp:948
LOCKED_DOOR
@ LOCKED_DOOR
Definition: object.h:128
PLAYERMOVER
@ PLAYERMOVER
Definition: object.h:145
PLUGIN_NAME
#define PLUGIN_NAME
Definition: cfanim.h:32
unregisterGEvent
static PyObject * unregisterGEvent(PyObject *self, PyObject *args)
Definition: cfpython.cpp:129
EVENT_MAPRESET
#define EVENT_MAPRESET
Definition: events.h:50
cfpython.h
pycode_cache_entry::code
PyCodeObject * code
Definition: cfpython.cpp:79
addSimpleConstants
static void addSimpleConstants(PyObject *module, const char *name, const CFConstant *constants)
Definition: cfpython.cpp:1096
SPECIAL_KEY
@ SPECIAL_KEY
Definition: object.h:129
MOVE_FLYING
#define MOVE_FLYING
Definition: define.h:395
HOLE
@ HOLE
Definition: object.h:214
costStringFromValue
static PyObject * costStringFromValue(PyObject *self, PyObject *args)
Definition: cfpython.cpp:752
PEACEMAKER
@ PEACEMAKER
Definition: object.h:169
MAX_NPC
#define MAX_NPC
Definition: dialog.h:45
CIRCLE2
#define CIRCLE2
Definition: define.h:513
SvnRevPlugin
CF_PLUGIN char SvnRevPlugin[]
Definition: cfpython.cpp:69
do_script
static int do_script(CFPContext *context)
Definition: cfpython.cpp:1032
getSharedDictionary
static PyObject * getSharedDictionary(PyObject *self, PyObject *args)
Definition: cfpython.cpp:377
EVENT_BORN
#define EVENT_BORN
Definition: events.h:39
guild_questpoints_apply.mapname
mapname
Definition: guild_questpoints_apply.py:8
CONVERTER
@ CONVERTER
Definition: object.h:221
GECodes
static int GECodes[]
Definition: cfpython.cpp:1562
EVENT_MAPUNLOAD
#define EVENT_MAPUNLOAD
Definition: events.h:51
SKILLSCROLL
@ SKILLSCROLL
Definition: object.h:239
createMap
static PyObject * createMap(PyObject *self, PyObject *args)
Definition: cfpython.cpp:238
set_exception
static void set_exception(const char *fmt,...)
Definition: cfpython.cpp:93
ATNR_DRAIN
#define ATNR_DRAIN
Definition: attack.h:56
catcher
static PyObject * catcher
Definition: cfpython.cpp:877
navar-midane_time.data
data
Definition: navar-midane_time.py:11
NDI_GOLD
#define NDI_GOLD
Definition: newclient.h:257
Crossfire_Archetype_wrap
PyObject * Crossfire_Archetype_wrap(archetype *what)
Definition: cfpython_archetype.cpp:62
DRAGON_FOCUS
@ DRAGON_FOCUS
Definition: object.h:121
rt_say
@ rt_say
Definition: dialog.h:8
LAMP
@ LAMP
Definition: object.h:206
getFriendlyList
static PyObject * getFriendlyList(PyObject *self, PyObject *args)
Definition: cfpython.cpp:456
timeofday_t::dayofweek
int dayofweek
Definition: tod.h:42
GOLEM
@ GOLEM
Definition: object.h:150
registered_commands
static command_registration registered_commands[MAX_COMMANDS]
Definition: cfpython.cpp:85
ATNR_COUNTERSPELL
#define ATNR_COUNTERSPELL
Definition: attack.h:68
closePlugin
CF_PLUGIN int closePlugin(void)
Definition: cfpython.cpp:1909
getPlayers
static PyObject * getPlayers(PyObject *self, PyObject *args)
Definition: cfpython.cpp:398
EVENT_USER
#define EVENT_USER
Definition: events.h:36
MOOD_FLOOR
@ MOOD_FLOOR
Definition: object.h:175
CFAPI_SYSTEM_MAPS
#define CFAPI_SYSTEM_MAPS
Definition: plugin.h:284
ATNR_POISON
#define ATNR_POISON
Definition: attack.h:59
ARROW
@ ARROW
Definition: object.h:122
EVENT_THROW
#define EVENT_THROW
Definition: events.h:33
ATNR_DEATH
#define ATNR_DEATH
Definition: attack.h:66
rt_reply
@ rt_reply
Definition: dialog.h:9
PACEV
#define PACEV
Definition: define.h:524
BOOK
@ BOOK
Definition: object.h:119
empty
const char * empty[]
Definition: check_treasure.cpp:107
CFPContext::message
char message[1024]
Definition: cfpython.h:100
Crossfire_Region_wrap
PyObject * Crossfire_Region_wrap(region *what)
Definition: cfpython_region.cpp:72
timeofday_t::month
int month
Definition: tod.h:40
RING
@ RING
Definition: object.h:190
CFAPI_SYSTEM_REGIONS
#define CFAPI_SYSTEM_REGIONS
Definition: plugin.h:287
EVENT_SHOUT
#define EVENT_SHOUT
Definition: events.h:55
BLINDNESS
@ BLINDNESS
Definition: object.h:152
replace
Definition: replace.py:1
timeofday_t::season
int season
Definition: tod.h:46
nlohmann::detail::void
j template void())
Definition: json.hpp:4099
NDI_BLACK
#define NDI_BLACK
Definition: newclient.h:245
getUniqueDirectory
static PyObject * getUniqueDirectory(PyObject *self, PyObject *args)
Definition: cfpython.cpp:257
matchString
static PyObject * matchString(PyObject *self, PyObject *args)
Definition: cfpython.cpp:190
CLOCK
@ CLOCK
Definition: object.h:120
cf_free_string
void cf_free_string(sstring str)
Definition: plugin_common.cpp:1182
cstTime
const CFConstant cstTime[]
Definition: cfpython.cpp:1373
SHOP_MAT
@ SHOP_MAT
Definition: object.h:189
EVENT_BOUGHT
#define EVENT_BOUGHT
Definition: events.h:23
COMMAND_TYPE_WIZARD
#define COMMAND_TYPE_WIZARD
Definition: commands.h:39
destroyTimer
static PyObject * destroyTimer(PyObject *self, PyObject *args)
Definition: cfpython.cpp:562
CFPContext::talk
struct talk_info * talk
Definition: cfpython.h:105
MOVE_FLY_LOW
#define MOVE_FLY_LOW
Definition: define.h:393
EVENT_PLAYER_DEATH
#define EVENT_PLAYER_DEATH
Definition: events.h:53
ATNR_FIRE
#define ATNR_FIRE
Definition: attack.h:51
cfpython_pyfile_asfile
static FILE * cfpython_pyfile_asfile(PyObject *obj)
Definition: cfpython.cpp:869
cstType
const CFConstant cstType[]
Definition: cfpython.cpp:1124
cf_system_register_command_extra
command_registration cf_system_register_command_extra(const char *name, const char *extra, command_function_extra func, uint8_t command_type, float time)
Definition: plugin_common.cpp:2103
EXIT
@ EXIT
Definition: object.h:186
getPlayerDirectory
static PyObject * getPlayerDirectory(PyObject *self, PyObject *args)
Definition: cfpython.cpp:281
MAGIC_EAR
@ MAGIC_EAR
Definition: object.h:136
MONTHS_PER_YEAR
#define MONTHS_PER_YEAR
Definition: tod.h:18
getWeekdayName
static PyObject * getWeekdayName(PyObject *self, PyObject *args)
Definition: cfpython.cpp:653
PLUGIN_VERSION
#define PLUGIN_VERSION
Definition: cfanim.h:33
getMaps
static PyObject * getMaps(PyObject *self, PyObject *args)
Definition: cfpython.cpp:413
cstReplyTypes
const CFConstant cstReplyTypes[]
Definition: cfpython.cpp:1383
diamondslots.message
string message
Definition: diamondslots.py:57
cf_system_get_object_vector
void cf_system_get_object_vector(int property, std::vector< object * > *list)
Definition: plugin_common.cpp:2116
replace
void replace(const char *src, const char *key, const char *replacement, char *result, size_t resultsize)
Definition: utils.cpp:327
reply_type
reply_type
Definition: dialog.h:7
cf_system_register_global_event
void cf_system_register_global_event(int event, const char *name, f_plug_event hook)
Definition: plugin_common.cpp:1102
llevInfo
@ llevInfo
Definition: logger.h:12
talk_info::message_type
reply_type message_type
Definition: dialog.h:54
autojail.dict
dict
Definition: autojail.py:7
cfpython_openpyfile
static PyObject * cfpython_openpyfile(char *filename)
Definition: cfpython.cpp:855
getTempDirectory
static PyObject * getTempDirectory(PyObject *self, PyObject *args)
Definition: cfpython.cpp:263
pycode_cache_entry::file
sstring file
Definition: cfpython.cpp:78
NDI_UNIQUE
#define NDI_UNIQUE
Definition: newclient.h:265
EVENT_MUZZLE
#define EVENT_MUZZLE
Definition: events.h:52
cf_find_animation
int cf_find_animation(const char *txt)
Definition: plugin_common.cpp:1498
MAX_COMMANDS
#define MAX_COMMANDS
Definition: cfpython.cpp:84
AT_BLIND
#define AT_BLIND
Definition: attack.h:98
getReturnValue
static PyObject * getReturnValue(PyObject *self, PyObject *args)
Definition: cfpython.cpp:173
CFPythonMethods
PyMethodDef CFPythonMethods[]
Definition: cfpython.cpp:765
EVENT_TELL
#define EVENT_TELL
Definition: events.h:56
ATNR_CHAOS
#define ATNR_CHAOS
Definition: attack.h:67
EVENT_DEATH
#define EVENT_DEATH
Definition: events.h:25
BATTLEGROUND
@ BATTLEGROUND
Definition: object.h:168
Crossfire_PartyType
PyTypeObject Crossfire_PartyType
AT_SLOW
#define AT_SLOW
Definition: attack.h:87
CFAPI_SYSTEM_FRIENDLY_LIST
#define CFAPI_SYSTEM_FRIENDLY_LIST
Definition: plugin.h:289
CFConstant
Definition: cfpython.h:108
MAX_REPLIES
#define MAX_REPLIES
Definition: dialog.h:43
players
std::vector< archetype * > players
Definition: player.cpp:493
AT_TURN_UNDEAD
#define AT_TURN_UNDEAD
Definition: attack.h:89
cf_get_periodofday_name
const char * cf_get_periodofday_name(int index)
Definition: plugin_common.cpp:1583
getWhatIsMessage
static PyObject * getWhatIsMessage(PyObject *self, PyObject *args)
Definition: cfpython.cpp:326
GRIMREAPER
@ GRIMREAPER
Definition: object.h:135
getScriptName
static PyObject * getScriptName(PyObject *self, PyObject *args)
Definition: cfpython.cpp:335
ATNR_DEPLETE
#define ATNR_DEPLETE
Definition: attack.h:65
timeofday_t::minute
int minute
Definition: tod.h:44
KEY
@ KEY
Definition: object.h:132
CrossfireModule
static PyModuleDef CrossfireModule
Definition: cfpython.cpp:1473
EARTHWALL
@ EARTHWALL
Definition: object.h:149
python_command_function
static void python_command_function(object *op, const char *params, const char *script)
Definition: cfpython.cpp:470
DUPLICATOR
@ DUPLICATOR
Definition: object.h:207
DISEASE
@ DISEASE
Definition: object.h:249
FIREWALL
@ FIREWALL
Definition: object.h:173
TRIGGER_ALTAR
@ TRIGGER_ALTAR
Definition: object.h:138
getGlobalEventPath
static const char * getGlobalEventPath(int code)
Definition: cfpython.cpp:1692
PLAYER_CHANGER
@ PLAYER_CHANGER
Definition: object.h:167
mapstruct
Definition: map.h:313
cf_system_get_map_vector
void cf_system_get_map_vector(int property, std::vector< mapstruct * > *list)
Definition: plugin_common.cpp:2122
createCFObjectByName
static PyObject * createCFObjectByName(PyObject *self, PyObject *args)
Definition: cfpython.cpp:152
cstAttackType
const CFConstant cstAttackType[]
Definition: cfpython.cpp:1271
sstring
const typedef char * sstring
Definition: sstring.h:2
LIGHTER
@ LIGHTER
Definition: object.h:195
rt_question
@ rt_question
Definition: dialog.h:10
PERIODS_PER_DAY
#define PERIODS_PER_DAY
Definition: tod.h:20
give.op
op
Definition: give.py:33
NDI_ALL
#define NDI_ALL
Definition: newclient.h:266
cstAttackTypeNumber
const CFConstant cstAttackTypeNumber[]
Definition: cfpython.cpp:1301
autojail.value
value
Definition: autojail.py:6
AT_DEPLETE
#define AT_DEPLETE
Definition: attack.h:92
Crossfire_ArchetypeType
PyTypeObject Crossfire_ArchetypeType
cf_map_has_been_loaded
mapstruct * cf_map_has_been_loaded(const char *name)
Definition: plugin_common.cpp:961
MATERIAL
@ MATERIAL
Definition: object.h:253
EVENT_TIME
#define EVENT_TIME
Definition: events.h:32
cf_re_cmp
const char * cf_re_cmp(const char *str, const char *regexp)
Definition: plugin_common.cpp:1143
EVENT_MAPLEAVE
#define EVENT_MAPLEAVE
Definition: events.h:47
SPINNER
@ SPINNER
Definition: object.h:210
getRegions
static PyObject * getRegions(PyObject *self, PyObject *args)
Definition: cfpython.cpp:442
AT_WEAPONMAGIC
#define AT_WEAPONMAGIC
Definition: attack.h:84
SPELL_EFFECT
@ SPELL_EFFECT
Definition: object.h:220
readyMap
static PyObject * readyMap(PyObject *self, PyObject *args)
Definition: cfpython.cpp:224
SKILL_TOOL
@ SKILL_TOOL
Definition: object.h:194
getParties
static PyObject * getParties(PyObject *self, PyObject *args)
Definition: cfpython.cpp:428
timeofday_t::hour
int hour
Definition: tod.h:43
ATNR_MAGIC
#define ATNR_MAGIC
Definition: attack.h:50
roll-o-matic.params
params
Definition: roll-o-matic.py:193
SHOP_INVENTORY
@ SHOP_INVENTORY
Definition: object.h:243
NDI_WHITE
#define NDI_WHITE
Definition: newclient.h:246
PEDESTAL
@ PEDESTAL
Definition: object.h:126
cf_create_object
object * cf_create_object(void)
Definition: plugin_common.cpp:1081
cf_get_maps_directory
char * cf_get_maps_directory(const char *name, char *buf, int size)
Definition: plugin_common.cpp:1069
npc_dialog.index
int index
Definition: npc_dialog.py:102
NDI_BROWN
#define NDI_BROWN
Definition: newclient.h:256
talk_info
Definition: dialog.h:50
NDI_TAN
#define NDI_TAN
Definition: newclient.h:258
EVENT_REMOVE
#define EVENT_REMOVE
Definition: events.h:54
freeEventFiles
static void freeEventFiles(char **eventFiles)
Definition: cfpython.cpp:1609
cfpython_init_types
static void cfpython_init_types(PyObject *m)
Definition: cfpython.cpp:1432
regions
static std::unordered_map< std::string, Region * > regions
Definition: cfcitybell.cpp:43
CFPContext::event
PyObject * event
Definition: cfpython.h:99
NDI_DK_ORANGE
#define NDI_DK_ORANGE
Definition: newclient.h:251
addReply
static PyObject * addReply(PyObject *self, PyObject *args)
Definition: cfpython.cpp:671
level
int level
Definition: readable.cpp:1563
pycode_cache_entry
Definition: cfpython.cpp:77
initConstants
static void initConstants(PyObject *module)
Definition: cfpython.cpp:1411
DEAD_OBJECT
@ DEAD_OBJECT
Definition: object.h:161
ATNR_WEAPONMAGIC
#define ATNR_WEAPONMAGIC
Definition: attack.h:57
DIRECTOR
@ DIRECTOR
Definition: object.h:227
getWhoIsThird
static PyObject * getWhoIsThird(PyObject *self, PyObject *args)
Definition: cfpython.cpp:315
CORPSE
@ CORPSE
Definition: object.h:248
getScriptParameters
static PyObject * getScriptParameters(PyObject *self, PyObject *args)
Definition: cfpython.cpp:341
talk_info::npc_msgs
sstring npc_msgs[MAX_NPC]
Definition: dialog.h:59
npc_dialog.npc
npc
Definition: npc_dialog.py:95
Crossfire_RegionType
PyTypeObject Crossfire_RegionType
cf_system_get_archetype_vector
void cf_system_get_archetype_vector(int property, std::vector< archetype * > *list)
Definition: plugin_common.cpp:2128
cf_player_find
player * cf_player_find(const char *plname)
Definition: plugin_common.cpp:825
AT_COUNTERSPELL
#define AT_COUNTERSPELL
Definition: attack.h:95
AT_DISEASE
#define AT_DISEASE
Definition: attack.h:102
AT_ACID
#define AT_ACID
Definition: attack.h:82
cf_system_unregister_command
void cf_system_unregister_command(command_registration command)
Definition: plugin_common.cpp:2111
AT_FEAR
#define AT_FEAR
Definition: attack.h:90
FOOD
@ FOOD
Definition: object.h:117
AT_GODPOWER
#define AT_GODPOWER
Definition: attack.h:96
CFPContext::options
char options[1024]
Definition: cfpython.h:103
PYTHON_CACHE_SIZE
#define PYTHON_CACHE_SIZE
Definition: cfpython.cpp:72
CFAPI_SYSTEM_PARTIES
#define CFAPI_SYSTEM_PARTIES
Definition: plugin.h:288
MOVE_BOAT
#define MOVE_BOAT
Definition: define.h:397
MOVE_FLY_HIGH
#define MOVE_FLY_HIGH
Definition: define.h:394
context_stack
CFPContext * context_stack
Definition: cfpython.cpp:104
EVENT_ATTACKED
#define EVENT_ATTACKED
Definition: events.h:21
EVENT_MAPREADY
#define EVENT_MAPREADY
Definition: events.h:49
ALTAR
@ ALTAR
Definition: object.h:127
animate.event
event
DIALOGCHECK MINARGS 1 MAXARGS 2
Definition: animate.py:17
DOOR
@ DOOR
Definition: object.h:131
EVENT_CLOSE
#define EVENT_CLOSE
Definition: events.h:24
command_registration
uint64_t command_registration
Definition: commands.h:32
AT_CONFUSION
#define AT_CONFUSION
Definition: attack.h:81
cf_map_get_map
mapstruct * cf_map_get_map(const char *name, int flags)
Definition: plugin_common.cpp:935
WAIT2
#define WAIT2
Definition: define.h:499
DRINK
@ DRINK
Definition: object.h:162
ATNR_GHOSTHIT
#define ATNR_GHOSTHIT
Definition: attack.h:58
cf_system_get_party_vector
void cf_system_get_party_vector(int property, std::vector< partylist * > *list)
Definition: plugin_common.cpp:2134
WALL
@ WALL
Definition: object.h:196
ATNR_COLD
#define ATNR_COLD
Definition: attack.h:53
WEAPON_IMPROVER
@ WEAPON_IMPROVER
Definition: object.h:238
SCROLL
@ SCROLL
Definition: object.h:226
AT_CANCELLATION
#define AT_CANCELLATION
Definition: attack.h:91
DISTHIT
#define DISTHIT
Definition: define.h:498
RUSH
#define RUSH
Definition: define.h:496
PETMOVE
#define PETMOVE
Definition: define.h:501
registerGEvent
static PyObject * registerGEvent(PyObject *self, PyObject *args)
Definition: cfpython.cpp:116
death_message.hitter
hitter
Definition: death_message.py:33
cstAttackMovement
const CFConstant cstAttackMovement[]
Definition: cfpython.cpp:1390
LogLevel
LogLevel
Definition: logger.h:10
MOVE_SWIM
#define MOVE_SWIM
Definition: define.h:396
DISTATT
#define DISTATT
Definition: define.h:491
log_message
static PyObject * log_message(PyObject *self, PyObject *args)
Definition: cfpython.cpp:589
CFPContext::script
char script[1024]
Definition: cfpython.h:102
EVENT_ATTACKS
#define EVENT_ATTACKS
Definition: events.h:22
svnversion.h
BOOTS
@ BOOTS
Definition: object.h:217
AT_PARALYZE
#define AT_PARALYZE
Definition: attack.h:88
ATNR_ELECTRICITY
#define ATNR_ELECTRICITY
Definition: attack.h:52
AT_HOLYWORD
#define AT_HOLYWORD
Definition: attack.h:97
IDENTIFY_ALTAR
@ IDENTIFY_ALTAR
Definition: object.h:242
SPELL
@ SPELL
Definition: object.h:219
AT_GHOSTHIT
#define AT_GHOSTHIT
Definition: attack.h:85
EVENT_DESTROY
#define EVENT_DESTROY
Definition: events.h:26
replace.current
current
Definition: replace.py:64
getWhoAmI
static PyObject * getWhoAmI(PyObject *self, PyObject *args)
Definition: cfpython.cpp:293
closedir
int closedir(DIR *)
log_python_error
static void log_python_error(void)
Definition: cfpython.cpp:893
getTime
static PyObject * getTime(PyObject *self, PyObject *args)
Definition: cfpython.cpp:540
EVENT_GKILL
#define EVENT_GKILL
Definition: events.h:42
addConstants
static void addConstants(PyObject *module, const char *name, const CFConstant *constants)
Definition: cfpython.cpp:1064
SHIELD
@ SHIELD
Definition: object.h:140
CIRCLE1
#define CIRCLE1
Definition: define.h:509
TELEPORTER
@ TELEPORTER
Definition: object.h:146
Crossfire_Map_wrap
PyObject * Crossfire_Map_wrap(mapstruct *what)
Definition: cfpython_map.cpp:435
private_data
static PyObject * private_data
Definition: cfpython.cpp:110
altar_valkyrie.pl
pl
Definition: altar_valkyrie.py:28
ATNR_LIFE_STEALING
#define ATNR_LIFE_STEALING
Definition: attack.h:73
PACEH2
#define PACEH2
Definition: define.h:516
Crossfire_Map
Definition: cfpython_map.h:32
THROWN_OBJ
@ THROWN_OBJ
Definition: object.h:151
NDI_GREY
#define NDI_GREY
Definition: newclient.h:255
SPELLBOOK
@ SPELLBOOK
Definition: object.h:208
Crossfire_ObjectType
PyTypeObject Crossfire_ObjectType
getPeriodofdayName
static PyObject * getPeriodofdayName(PyObject *self, PyObject *args)
Definition: cfpython.cpp:662
CFPContext::returnvalue
int returnvalue
Definition: cfpython.h:104
EVENT_KICK
#define EVENT_KICK
Definition: events.h:43
cstEventType
const CFConstant cstEventType[]
Definition: cfpython.cpp:1331
PyInit_cjson
PyObject * PyInit_cjson(void)
Definition: cjson.cpp:1165
cfpython_globalEventListener
CF_PLUGIN int cfpython_globalEventListener(int *type,...)
Definition: cfpython.cpp:1700
FORCE
@ FORCE
Definition: object.h:229
HOLY_ALTAR
@ HOLY_ALTAR
Definition: object.h:166
TRAPDOOR
@ TRAPDOOR
Definition: object.h:215
AT_DRAIN
#define AT_DRAIN
Definition: attack.h:83
getWhoIsActivator
static PyObject * getWhoIsActivator(PyObject *self, PyObject *args)
Definition: cfpython.cpp:304
DETECTOR
@ DETECTOR
Definition: object.h:154
NDI_LT_GREEN
#define NDI_LT_GREEN
Definition: newclient.h:253
PyInit_Crossfire
static PyObject * PyInit_Crossfire(void)
Definition: cfpython.cpp:1485
initContextStack
static void initContextStack(void)
Definition: cfpython.cpp:817
cf_get_time
void cf_get_time(timeofday_t *tod)
Definition: plugin_common.cpp:1549
GOD
@ GOD
Definition: object.h:153
llevDebug
@ llevDebug
Definition: logger.h:13
MISC_OBJECT
@ MISC_OBJECT
Definition: object.h:198
MONEY
@ MONEY
Definition: object.h:142
findAnimation
static PyObject * findAnimation(PyObject *self, PyObject *args)
Definition: cfpython.cpp:626
RANDO2
#define RANDO2
Definition: define.h:523
is_valid_types_gen.type
list type
Definition: is_valid_types_gen.py:25
GATE
@ GATE
Definition: object.h:211
give.name
name
Definition: give.py:27
EVENT_APPLY
#define EVENT_APPLY
Definition: events.h:20
getEvent
static PyObject * getEvent(PyObject *self, PyObject *args)
Definition: cfpython.cpp:351
freeContext
static void freeContext(CFPContext *context)
Definition: cfpython.cpp:844
ATNR_FEAR
#define ATNR_FEAR
Definition: attack.h:63
Crossfire_MapType
PyTypeObject Crossfire_MapType
AT_FIRE
#define AT_FIRE
Definition: attack.h:78
level
Definition: level.py:1
diamondslots.id
id
Definition: diamondslots.py:53