1 | |
|
|
2 | /* |
|
|
3 | * static char *rcsid_plugins_c = |
|
|
4 | * "$Id: plugins.C,v 1.14 2006/09/14 21:16:12 root Exp $"; |
|
|
5 | */ |
|
|
6 | |
|
|
7 | /*****************************************************************************/ |
1 | /*****************************************************************************/ |
8 | |
|
|
9 | /* CrossFire, A Multiplayer game for X-windows */ |
2 | /* CrossFire, A Multiplayer game for X-windows */ |
10 | |
|
|
11 | /* */ |
3 | /* */ |
12 | |
|
|
13 | /* Copyright (C) 2000 Mark Wedel */ |
4 | /* Copyright (C) 2000 Mark Wedel */ |
14 | |
|
|
15 | /* Copyright (C) 1992 Frank Tore Johansen */ |
5 | /* Copyright (C) 1992 Frank Tore Johansen */ |
16 | |
|
|
17 | /* */ |
6 | /* */ |
18 | |
|
|
19 | /* This program is free software; you can redistribute it and/or modify */ |
7 | /* This program is free software; you can redistribute it and/or modify */ |
20 | |
|
|
21 | /* it under the terms of the GNU General Public License as published by */ |
8 | /* it under the terms of the GNU General Public License as published by */ |
22 | |
|
|
23 | /* the Free Software Foundation; either version 2 of the License, or */ |
9 | /* the Free Software Foundation; either version 2 of the License, or */ |
24 | |
|
|
25 | /* (at your option) any later version. */ |
10 | /* (at your option) any later version. */ |
26 | |
|
|
27 | /* */ |
11 | /* */ |
28 | |
|
|
29 | /* This program is distributed in the hope that it will be useful, */ |
12 | /* This program is distributed in the hope that it will be useful, */ |
30 | |
|
|
31 | /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ |
13 | /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ |
32 | |
|
|
33 | /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ |
14 | /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ |
34 | |
|
|
35 | /* GNU General Public License for more details. */ |
15 | /* GNU General Public License for more details. */ |
36 | |
|
|
37 | /* */ |
16 | /* */ |
38 | |
|
|
39 | /* You should have received a copy of the GNU General Public License */ |
17 | /* You should have received a copy of the GNU General Public License */ |
40 | |
|
|
41 | /* along with this program; if not, write to the Free Software */ |
18 | /* along with this program; if not, write to the Free Software */ |
42 | |
|
|
43 | /* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ |
19 | /* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ |
44 | |
|
|
45 | /* */ |
20 | /* */ |
46 | |
|
|
47 | /*****************************************************************************/ |
21 | /*****************************************************************************/ |
48 | |
|
|
49 | /* This is the server-side plugin management part. */ |
22 | /* This is the server-side plugin management part. */ |
50 | |
|
|
51 | /*****************************************************************************/ |
23 | /*****************************************************************************/ |
52 | |
|
|
53 | /* Original code by Yann Chachkoff (yann.chachkoff@mailandnews.com). */ |
24 | /* Original code by Yann Chachkoff (yann.chachkoff@mailandnews.com). */ |
54 | |
|
|
55 | /* Special thanks to: */ |
25 | /* Special thanks to: */ |
56 | |
|
|
57 | /* David Delbecq (david.delbecq@mailandnews.com); */ |
26 | /* David Delbecq (david.delbecq@mailandnews.com); */ |
58 | |
|
|
59 | /* Joris Bontje (jbontje@suespammers.org); */ |
27 | /* Joris Bontje (jbontje@suespammers.org); */ |
60 | |
|
|
61 | /* Philip Currlin (?); */ |
28 | /* Philip Currlin (?); */ |
62 | |
|
|
63 | /*****************************************************************************/ |
29 | /*****************************************************************************/ |
64 | |
|
|
65 | /*****************************************************************************/ |
30 | /*****************************************************************************/ |
66 | |
|
|
67 | /* First, the headers. We only include plugin.h, because all other includes */ |
31 | /* First, the headers. We only include plugin.h, because all other includes */ |
68 | |
|
|
69 | /* are done into it, and plugproto.h (which is used only by this file). */ |
32 | /* are done into it, and plugproto.h (which is used only by this file). */ |
70 | |
|
|
71 | /*****************************************************************************/ |
33 | /*****************************************************************************/ |
|
|
34 | |
72 | #include <plugin.h> |
35 | #include <plugin.h> |
73 | |
36 | |
74 | #ifndef __CEXTRACT__ |
37 | #ifndef __CEXTRACT__ |
75 | # include <sproto.h> |
38 | # include <sproto.h> |
76 | #endif |
39 | #endif |
… | |
… | |
79 | |
42 | |
80 | static const hook_entry plug_hooks[NR_OF_HOOKS] = { |
43 | static const hook_entry plug_hooks[NR_OF_HOOKS] = { |
81 | {cfapi_system_register_global_event, 1, "cfapi_system_register_global_event"}, |
44 | {cfapi_system_register_global_event, 1, "cfapi_system_register_global_event"}, |
82 | {cfapi_system_unregister_global_event, 3, "cfapi_system_unregister_global_event"}, |
45 | {cfapi_system_unregister_global_event, 3, "cfapi_system_unregister_global_event"}, |
83 | {cfapi_system_check_path, 4, "cfapi_system_check_path"}, |
46 | {cfapi_system_check_path, 4, "cfapi_system_check_path"}, |
84 | {cfapi_system_re_cmp, 5, "cfapi_system_re_cmp"}, |
47 | {NULL, 5, "cfapi_system_re_cmp"}, |
85 | {cfapi_system_strdup_local, 6, "cfapi_system_strdup_local"}, |
48 | {cfapi_system_strdup, 6, "cfapi_system_strdup"}, |
86 | {cfapi_system_directory, 7, "cfapi_system_directory"}, |
49 | {cfapi_system_directory, 7, "cfapi_system_directory"}, |
87 | {cfapi_system_find_animation, 8, "cfapi_system_find_animation"}, |
50 | {cfapi_system_find_animation, 8, "cfapi_system_find_animation"}, |
88 | {cfapi_object_clean_object, 9, "cfapi_object_clean_object"}, |
51 | {cfapi_object_clean_object, 9, "cfapi_object_clean_object"}, |
89 | {cfapi_object_on_same_map, 10, "cfapi_object_on_same_map"}, |
52 | {cfapi_object_on_same_map, 10, "cfapi_object_on_same_map"}, |
90 | {cfapi_object_get_key, 11, "cfapi_object_get_key"}, |
53 | {cfapi_object_get_key, 11, "cfapi_object_get_key"}, |
… | |
… | |
158 | |
121 | |
159 | /* NEW PLUGIN STUFF STARTS HERE */ |
122 | /* NEW PLUGIN STUFF STARTS HERE */ |
160 | |
123 | |
161 | /*****************************************************************************/ |
124 | /*****************************************************************************/ |
162 | |
125 | |
163 | #ifdef WIN32 |
|
|
164 | static const char * |
|
|
165 | plugins_dlerror (void) |
|
|
166 | { |
|
|
167 | static char buf[256]; |
|
|
168 | DWORD err; |
|
|
169 | char *p; |
|
|
170 | |
|
|
171 | err = GetLastError (); |
|
|
172 | if (FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL, err, 0, buf, sizeof (buf), NULL) == 0) |
|
|
173 | snprintf (buf, sizeof (buf), "error %lu", err); |
|
|
174 | p = strchr (buf, '\0'); |
|
|
175 | while (p > buf && (p[-1] == '\r' || p[-1] == '\n')) |
|
|
176 | p--; |
|
|
177 | *p = '\0'; |
|
|
178 | return buf; |
|
|
179 | } |
|
|
180 | #endif /* WIN32 */ |
|
|
181 | |
|
|
182 | /** |
126 | /** |
183 | * Notify clients about a changed object. |
127 | * Notify clients about a changed object. |
184 | * |
128 | * |
185 | * @param op the object that has changed |
129 | * @param op the object that has changed |
186 | */ |
130 | */ |
187 | static void |
131 | static void |
188 | send_changed_object (object *op) |
132 | send_changed_object (object *op) |
189 | { |
133 | { |
190 | object *tmp; |
134 | object *tmp; |
191 | player *pl; |
|
|
192 | |
135 | |
193 | if (op->env != NULL) |
136 | if (op->env) |
194 | { |
137 | { |
195 | tmp = is_player_inv (op->env); |
138 | tmp = op->in_player (); |
|
|
139 | |
196 | if (!tmp) |
140 | if (!tmp) |
197 | { |
141 | { |
198 | for (pl = first_player; pl; pl = pl->next) |
142 | for_all_players (pl) |
199 | if (pl->ob->container == op->env) |
143 | if (pl->ob->container == op->env) |
|
|
144 | { |
|
|
145 | tmp = pl->ob; |
200 | break; |
146 | break; |
201 | if (pl) |
147 | } |
202 | tmp = pl->ob; |
|
|
203 | else |
|
|
204 | tmp = NULL; |
|
|
205 | } |
148 | } |
|
|
149 | |
206 | if (tmp) |
150 | if (tmp) |
207 | esrv_send_item (tmp, op); |
151 | esrv_send_item (tmp, op); |
208 | } |
152 | } |
209 | else |
153 | else |
210 | { |
154 | { |
… | |
… | |
222 | */ |
166 | */ |
223 | static void |
167 | static void |
224 | send_removed_object (object *op) |
168 | send_removed_object (object *op) |
225 | { |
169 | { |
226 | object *tmp; |
170 | object *tmp; |
227 | player *pl; |
|
|
228 | |
171 | |
229 | if (op->env == NULL) |
172 | if (op->env == NULL) |
230 | { |
173 | { |
231 | /* no action necessary: remove_ob() notifies the client */ |
174 | /* no action necessary: remove_ob() notifies the client */ |
232 | return; |
175 | return; |
233 | } |
176 | } |
234 | |
177 | |
235 | tmp = is_player_inv (op->env); |
178 | tmp = op->in_player (); |
236 | if (!tmp) |
179 | if (!tmp) |
237 | { |
180 | { |
238 | for (pl = first_player; pl; pl = pl->next) |
181 | for_all_players (pl) |
239 | if (pl->ob->container == op->env) |
182 | if (pl->ob->container == op->env) |
|
|
183 | { |
|
|
184 | tmp = pl->ob; |
240 | break; |
185 | break; |
241 | if (pl) |
186 | } |
242 | tmp = pl->ob; |
|
|
243 | else |
|
|
244 | tmp = NULL; |
|
|
245 | } |
187 | } |
|
|
188 | |
246 | if (tmp) |
189 | if (tmp) |
247 | esrv_del_item (tmp->contr, op->count); |
190 | esrv_del_item (tmp->contr, op->count); |
248 | } |
191 | } |
249 | |
192 | |
250 | extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr); |
193 | extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr); |
… | |
… | |
538 | *type = CFAPI_INT; |
481 | *type = CFAPI_INT; |
539 | return &rv; |
482 | return &rv; |
540 | } |
483 | } |
541 | |
484 | |
542 | void * |
485 | void * |
543 | cfapi_system_strdup_local (int *type, ...) |
486 | cfapi_system_strdup (int *type, ...) |
544 | { |
487 | { |
545 | va_list args; |
488 | va_list args; |
546 | char *txt; |
489 | char *txt; |
547 | |
490 | |
548 | va_start (args, type); |
491 | va_start (args, type); |
549 | txt = va_arg (args, char *); |
492 | txt = va_arg (args, char *); |
550 | |
493 | |
551 | va_end (args); |
494 | va_end (args); |
552 | *type = CFAPI_STRING; |
495 | *type = CFAPI_STRING; |
553 | return strdup_local (txt); |
496 | return strdup (txt); |
554 | } |
497 | } |
555 | |
498 | |
556 | void * |
499 | void * |
557 | cfapi_system_register_global_event (int *type, ...) |
500 | cfapi_system_register_global_event (int *type, ...) |
558 | { |
501 | { |
… | |
… | |
612 | *type = CFAPI_INT; |
555 | *type = CFAPI_INT; |
613 | return &rv; |
556 | return &rv; |
614 | } |
557 | } |
615 | |
558 | |
616 | void * |
559 | void * |
617 | cfapi_system_re_cmp (int *type, ...) |
|
|
618 | { |
|
|
619 | va_list args; |
|
|
620 | char *rv; |
|
|
621 | const char *str; |
|
|
622 | const char *regexp; |
|
|
623 | |
|
|
624 | va_start (args, type); |
|
|
625 | |
|
|
626 | str = va_arg (args, char *); |
|
|
627 | regexp = va_arg (args, char *); |
|
|
628 | |
|
|
629 | rv = (char *) re_cmp (str, regexp); |
|
|
630 | |
|
|
631 | va_end (args); |
|
|
632 | *type = CFAPI_STRING; |
|
|
633 | return rv; |
|
|
634 | } |
|
|
635 | |
|
|
636 | void * |
|
|
637 | cfapi_system_directory (int *type, ...) |
560 | cfapi_system_directory (int *type, ...) |
638 | { |
561 | { |
639 | va_list args; |
562 | va_list args; |
640 | int dirtype; |
563 | int dirtype; |
641 | |
564 | |
… | |
… | |
686 | /* MAP RELATED HOOKS */ |
609 | /* MAP RELATED HOOKS */ |
687 | |
610 | |
688 | void * |
611 | void * |
689 | cfapi_map_get_map (int *type, ...) |
612 | cfapi_map_get_map (int *type, ...) |
690 | { |
613 | { |
|
|
614 | abort (); |
|
|
615 | } |
|
|
616 | |
|
|
617 | void * |
|
|
618 | cfapi_map_has_been_loaded (int *type, ...) |
|
|
619 | { |
|
|
620 | abort (); |
|
|
621 | } |
|
|
622 | |
|
|
623 | void * |
|
|
624 | cfapi_map_create_path (int *type, ...) |
|
|
625 | { |
|
|
626 | abort (); |
|
|
627 | } |
|
|
628 | |
|
|
629 | void * |
|
|
630 | cfapi_map_get_map_property (int *type, ...) |
|
|
631 | { |
|
|
632 | abort (); |
|
|
633 | } |
|
|
634 | |
|
|
635 | void * |
|
|
636 | cfapi_map_set_map_property (int *type, ...) |
|
|
637 | { |
|
|
638 | abort (); |
|
|
639 | } |
|
|
640 | |
|
|
641 | void * |
|
|
642 | cfapi_map_out_of_map (int *type, ...) |
|
|
643 | { |
|
|
644 | abort (); |
|
|
645 | } |
|
|
646 | |
|
|
647 | void * |
|
|
648 | cfapi_map_update_position (int *type, ...) |
|
|
649 | { |
691 | va_list args; |
650 | va_list args; |
692 | mapstruct *rv; |
651 | maptile *map; |
693 | int ctype; |
|
|
694 | int x, y; |
652 | int x, y; |
695 | sint16 nx, ny; |
|
|
696 | char *name; |
|
|
697 | mapstruct *m; |
|
|
698 | |
653 | |
699 | va_start (args, type); |
654 | va_start (args, type); |
700 | |
655 | |
701 | ctype = va_arg (args, int); |
|
|
702 | |
|
|
703 | switch (ctype) |
|
|
704 | { |
|
|
705 | case 0: |
|
|
706 | x = va_arg (args, int); |
|
|
707 | y = va_arg (args, int); |
|
|
708 | |
|
|
709 | rv = get_empty_map (x, y); |
|
|
710 | break; |
|
|
711 | |
|
|
712 | case 1: |
|
|
713 | name = va_arg (args, char *); |
|
|
714 | x = va_arg (args, int); |
|
|
715 | |
|
|
716 | rv = ready_map_name (name, x); |
|
|
717 | break; |
|
|
718 | |
|
|
719 | case 2: |
|
|
720 | m = va_arg (args, mapstruct *); |
|
|
721 | nx = va_arg (args, int); |
|
|
722 | ny = va_arg (args, int); |
|
|
723 | |
|
|
724 | rv = get_map_from_coord (m, &nx, &ny); |
|
|
725 | break; |
|
|
726 | |
|
|
727 | case 3: |
|
|
728 | rv = first_map; |
|
|
729 | break; |
|
|
730 | |
|
|
731 | default: |
|
|
732 | *type = CFAPI_NONE; |
|
|
733 | va_end (args); |
|
|
734 | return NULL; |
|
|
735 | break; |
|
|
736 | } |
|
|
737 | va_end (args); |
|
|
738 | *type = CFAPI_PMAP; |
|
|
739 | return rv; |
|
|
740 | } |
|
|
741 | |
|
|
742 | void * |
|
|
743 | cfapi_map_has_been_loaded (int *type, ...) |
|
|
744 | { |
|
|
745 | va_list args; |
|
|
746 | mapstruct *map; |
|
|
747 | char *string; |
|
|
748 | |
|
|
749 | va_start (args, type); |
|
|
750 | string = va_arg (args, char *); |
|
|
751 | |
|
|
752 | map = has_been_loaded (string); |
|
|
753 | va_end (args); |
|
|
754 | *type = CFAPI_PMAP; |
|
|
755 | return map; |
|
|
756 | } |
|
|
757 | |
|
|
758 | void * |
|
|
759 | cfapi_map_create_path (int *type, ...) |
|
|
760 | { |
|
|
761 | va_list args; |
|
|
762 | int ctype; |
|
|
763 | const char *str; |
|
|
764 | char *rv; |
|
|
765 | |
|
|
766 | va_start (args, type); |
|
|
767 | |
|
|
768 | ctype = va_arg (args, int); |
|
|
769 | str = va_arg (args, char *); |
|
|
770 | |
|
|
771 | *type = CFAPI_STRING; |
|
|
772 | |
|
|
773 | switch (ctype) |
|
|
774 | { |
|
|
775 | case 0: |
|
|
776 | rv = (char *) create_pathname (str); |
|
|
777 | break; |
|
|
778 | |
|
|
779 | case 1: |
|
|
780 | rv = (char *) create_overlay_pathname (str); |
|
|
781 | break; |
|
|
782 | |
|
|
783 | /*case 2: |
|
|
784 | rv = create_items_path(str); |
|
|
785 | break; */ |
|
|
786 | |
|
|
787 | default: |
|
|
788 | rv = NULL; |
|
|
789 | *type = CFAPI_NONE; |
|
|
790 | break; |
|
|
791 | } |
|
|
792 | va_end (args); |
|
|
793 | return rv; |
|
|
794 | } |
|
|
795 | |
|
|
796 | void * |
|
|
797 | cfapi_map_get_map_property (int *type, ...) |
|
|
798 | { |
|
|
799 | va_list args; |
|
|
800 | int x, y; |
|
|
801 | sint16 nx, ny; |
|
|
802 | mapstruct *map; |
|
|
803 | mapstruct *newmap; |
|
|
804 | static int rv; |
|
|
805 | int property; |
|
|
806 | char *buf; |
|
|
807 | |
|
|
808 | va_start (args, type); |
|
|
809 | |
|
|
810 | property = va_arg (args, int); |
|
|
811 | |
|
|
812 | switch (property) |
|
|
813 | { |
|
|
814 | case CFAPI_MAP_PROP_FLAGS: |
|
|
815 | map = va_arg (args, mapstruct *); |
|
|
816 | newmap = va_arg (args, mapstruct *); |
|
|
817 | x = va_arg (args, int); |
|
|
818 | y = va_arg (args, int); |
|
|
819 | nx = va_arg (args, int); |
|
|
820 | ny = va_arg (args, int); |
|
|
821 | |
|
|
822 | rv = get_map_flags (map, &newmap, x, y, &nx, &ny); |
|
|
823 | va_end (args); |
|
|
824 | *type = CFAPI_INT; |
|
|
825 | return &rv; |
|
|
826 | break; |
|
|
827 | |
|
|
828 | case CFAPI_MAP_PROP_DIFFICULTY: |
|
|
829 | map = va_arg (args, mapstruct *); |
|
|
830 | |
|
|
831 | rv = calculate_difficulty (map); |
|
|
832 | va_end (args); |
|
|
833 | *type = CFAPI_INT; |
|
|
834 | return &rv; |
|
|
835 | break; |
|
|
836 | |
|
|
837 | case CFAPI_MAP_PROP_PATH: |
|
|
838 | map = va_arg (args, mapstruct *); |
|
|
839 | |
|
|
840 | buf = map->path; |
|
|
841 | *type = CFAPI_STRING; |
|
|
842 | va_end (args); |
|
|
843 | return buf; |
|
|
844 | break; |
|
|
845 | |
|
|
846 | case CFAPI_MAP_PROP_TMPNAME: |
|
|
847 | map = va_arg (args, mapstruct *); |
|
|
848 | |
|
|
849 | buf = map->tmpname; |
|
|
850 | *type = CFAPI_STRING; |
|
|
851 | va_end (args); |
|
|
852 | return buf; |
|
|
853 | break; |
|
|
854 | |
|
|
855 | case CFAPI_MAP_PROP_NAME: |
|
|
856 | map = va_arg (args, mapstruct *); |
|
|
857 | |
|
|
858 | buf = map->name; |
|
|
859 | *type = CFAPI_STRING; |
|
|
860 | va_end (args); |
|
|
861 | return buf; |
|
|
862 | break; |
|
|
863 | |
|
|
864 | case CFAPI_MAP_PROP_RESET_TIME: |
|
|
865 | map = va_arg (args, mapstruct *); |
|
|
866 | |
|
|
867 | rv = map->reset_time; |
|
|
868 | *type = CFAPI_INT; |
|
|
869 | va_end (args); |
|
|
870 | return &rv; |
|
|
871 | break; |
|
|
872 | |
|
|
873 | case CFAPI_MAP_PROP_RESET_TIMEOUT: |
|
|
874 | map = va_arg (args, mapstruct *); |
|
|
875 | |
|
|
876 | rv = map->reset_timeout; |
|
|
877 | *type = CFAPI_INT; |
|
|
878 | va_end (args); |
|
|
879 | return &rv; |
|
|
880 | break; |
|
|
881 | |
|
|
882 | case CFAPI_MAP_PROP_PLAYERS: |
|
|
883 | map = va_arg (args, mapstruct *); |
|
|
884 | |
|
|
885 | rv = map->players; |
|
|
886 | *type = CFAPI_INT; |
|
|
887 | va_end (args); |
|
|
888 | return &rv; |
|
|
889 | break; |
|
|
890 | |
|
|
891 | case CFAPI_MAP_PROP_DARKNESS: |
|
|
892 | map = va_arg (args, mapstruct *); |
|
|
893 | |
|
|
894 | rv = map->darkness; |
|
|
895 | *type = CFAPI_INT; |
|
|
896 | va_end (args); |
|
|
897 | return &rv; |
|
|
898 | break; |
|
|
899 | |
|
|
900 | case CFAPI_MAP_PROP_WIDTH: |
|
|
901 | map = va_arg (args, mapstruct *); |
|
|
902 | |
|
|
903 | rv = map->width; |
|
|
904 | *type = CFAPI_INT; |
|
|
905 | va_end (args); |
|
|
906 | return &rv; |
|
|
907 | break; |
|
|
908 | |
|
|
909 | case CFAPI_MAP_PROP_HEIGHT: |
|
|
910 | map = va_arg (args, mapstruct *); |
|
|
911 | |
|
|
912 | rv = map->height; |
|
|
913 | *type = CFAPI_INT; |
|
|
914 | va_end (args); |
|
|
915 | return &rv; |
|
|
916 | break; |
|
|
917 | |
|
|
918 | case CFAPI_MAP_PROP_ENTER_X: |
|
|
919 | map = va_arg (args, mapstruct *); |
|
|
920 | |
|
|
921 | rv = map->enter_x; |
|
|
922 | *type = CFAPI_INT; |
|
|
923 | va_end (args); |
|
|
924 | return &rv; |
|
|
925 | break; |
|
|
926 | |
|
|
927 | case CFAPI_MAP_PROP_ENTER_Y: |
|
|
928 | map = va_arg (args, mapstruct *); |
|
|
929 | |
|
|
930 | rv = map->enter_y; |
|
|
931 | *type = CFAPI_INT; |
|
|
932 | va_end (args); |
|
|
933 | return &rv; |
|
|
934 | break; |
|
|
935 | |
|
|
936 | case CFAPI_MAP_PROP_TEMPERATURE: |
|
|
937 | map = va_arg (args, mapstruct *); |
|
|
938 | |
|
|
939 | rv = map->temp; |
|
|
940 | *type = CFAPI_INT; |
|
|
941 | va_end (args); |
|
|
942 | return &rv; |
|
|
943 | break; |
|
|
944 | |
|
|
945 | case CFAPI_MAP_PROP_PRESSURE: |
|
|
946 | map = va_arg (args, mapstruct *); |
|
|
947 | |
|
|
948 | rv = map->pressure; |
|
|
949 | *type = CFAPI_INT; |
|
|
950 | va_end (args); |
|
|
951 | return &rv; |
|
|
952 | break; |
|
|
953 | |
|
|
954 | case CFAPI_MAP_PROP_HUMIDITY: |
|
|
955 | map = va_arg (args, mapstruct *); |
|
|
956 | |
|
|
957 | rv = map->humid; |
|
|
958 | *type = CFAPI_INT; |
|
|
959 | va_end (args); |
|
|
960 | return &rv; |
|
|
961 | break; |
|
|
962 | |
|
|
963 | case CFAPI_MAP_PROP_WINDSPEED: |
|
|
964 | map = va_arg (args, mapstruct *); |
|
|
965 | |
|
|
966 | rv = map->windspeed; |
|
|
967 | *type = CFAPI_INT; |
|
|
968 | va_end (args); |
|
|
969 | return &rv; |
|
|
970 | break; |
|
|
971 | |
|
|
972 | case CFAPI_MAP_PROP_WINDDIR: |
|
|
973 | map = va_arg (args, mapstruct *); |
|
|
974 | |
|
|
975 | rv = map->winddir; |
|
|
976 | *type = CFAPI_INT; |
|
|
977 | va_end (args); |
|
|
978 | return &rv; |
|
|
979 | break; |
|
|
980 | |
|
|
981 | case CFAPI_MAP_PROP_SKY: |
|
|
982 | map = va_arg (args, mapstruct *); |
|
|
983 | |
|
|
984 | rv = map->sky; |
|
|
985 | *type = CFAPI_INT; |
|
|
986 | va_end (args); |
|
|
987 | return &rv; |
|
|
988 | break; |
|
|
989 | |
|
|
990 | case CFAPI_MAP_PROP_WPARTX: |
|
|
991 | map = va_arg (args, mapstruct *); |
|
|
992 | |
|
|
993 | rv = map->wpartx; |
|
|
994 | *type = CFAPI_INT; |
|
|
995 | va_end (args); |
|
|
996 | return &rv; |
|
|
997 | break; |
|
|
998 | |
|
|
999 | case CFAPI_MAP_PROP_WPARTY: |
|
|
1000 | map = va_arg (args, mapstruct *); |
|
|
1001 | |
|
|
1002 | rv = map->wparty; |
|
|
1003 | *type = CFAPI_INT; |
|
|
1004 | va_end (args); |
|
|
1005 | return &rv; |
|
|
1006 | break; |
|
|
1007 | |
|
|
1008 | case CFAPI_MAP_PROP_MESSAGE: |
|
|
1009 | map = va_arg (args, mapstruct *); |
|
|
1010 | |
|
|
1011 | buf = map->msg; |
|
|
1012 | *type = CFAPI_STRING; |
|
|
1013 | va_end (args); |
|
|
1014 | return buf; |
|
|
1015 | break; |
|
|
1016 | |
|
|
1017 | case CFAPI_MAP_PROP_NEXT: |
|
|
1018 | map = va_arg (args, mapstruct *); |
|
|
1019 | |
|
|
1020 | *type = CFAPI_PMAP; |
|
|
1021 | va_end (args); |
|
|
1022 | return map->next; |
|
|
1023 | break; |
|
|
1024 | |
|
|
1025 | case CFAPI_MAP_PROP_REGION: |
|
|
1026 | map = va_arg (args, mapstruct *); |
|
|
1027 | |
|
|
1028 | *type = CFAPI_PREGION; |
|
|
1029 | va_end (args); |
|
|
1030 | return get_region_by_map (map); |
|
|
1031 | break; |
|
|
1032 | |
|
|
1033 | default: |
|
|
1034 | *type = CFAPI_NONE; |
|
|
1035 | va_end (args); |
|
|
1036 | return NULL; |
|
|
1037 | break; |
|
|
1038 | } |
|
|
1039 | } |
|
|
1040 | |
|
|
1041 | void * |
|
|
1042 | cfapi_map_set_map_property (int *type, ...) |
|
|
1043 | { |
|
|
1044 | va_list args; |
|
|
1045 | static int rv; |
|
|
1046 | mapstruct *map; |
|
|
1047 | int val; |
|
|
1048 | int property; |
|
|
1049 | |
|
|
1050 | va_start (args, type); |
|
|
1051 | |
|
|
1052 | property = va_arg (args, int); |
|
|
1053 | |
|
|
1054 | switch (property) |
|
|
1055 | { |
|
|
1056 | case CFAPI_MAP_PROP_LIGHT: |
|
|
1057 | map = va_arg (args, mapstruct *); |
|
|
1058 | val = va_arg (args, int); |
|
|
1059 | |
|
|
1060 | rv = change_map_light (map, val); |
|
|
1061 | *type = CFAPI_INT; |
|
|
1062 | va_end (args); |
|
|
1063 | return &rv; |
|
|
1064 | break; |
|
|
1065 | |
|
|
1066 | case CFAPI_MAP_PROP_RESET_TIME: |
|
|
1067 | map = va_arg (args, mapstruct *); |
|
|
1068 | |
|
|
1069 | *type = CFAPI_NONE; |
|
|
1070 | va_end (args); |
|
|
1071 | return NULL; |
|
|
1072 | break; |
|
|
1073 | |
|
|
1074 | default: |
|
|
1075 | *type = CFAPI_NONE; |
|
|
1076 | va_end (args); |
|
|
1077 | return NULL; |
|
|
1078 | break; |
|
|
1079 | } |
|
|
1080 | } |
|
|
1081 | void * |
|
|
1082 | cfapi_map_out_of_map (int *type, ...) |
|
|
1083 | { |
|
|
1084 | va_list args; |
|
|
1085 | static int rv; |
|
|
1086 | mapstruct *map; |
|
|
1087 | int x, y; |
|
|
1088 | |
|
|
1089 | va_start (args, type); |
|
|
1090 | map = va_arg (args, mapstruct *); |
656 | map = va_arg (args, maptile *); |
1091 | x = va_arg (args, int); |
657 | x = va_arg (args, int); |
1092 | y = va_arg (args, int); |
658 | y = va_arg (args, int); |
1093 | |
659 | |
1094 | rv = out_of_map (map, x, y); |
660 | map->at (x, y).flags_ &= ~P_UPTODATE; |
1095 | va_end (args); |
|
|
1096 | *type = CFAPI_INT; |
|
|
1097 | return &rv; |
|
|
1098 | } |
|
|
1099 | |
661 | |
1100 | void * |
|
|
1101 | cfapi_map_update_position (int *type, ...) |
|
|
1102 | { |
|
|
1103 | va_list args; |
|
|
1104 | mapstruct *map; |
|
|
1105 | int x, y; |
|
|
1106 | |
|
|
1107 | va_start (args, type); |
|
|
1108 | |
|
|
1109 | map = va_arg (args, mapstruct *); |
|
|
1110 | x = va_arg (args, int); |
|
|
1111 | y = va_arg (args, int); |
|
|
1112 | |
|
|
1113 | update_position (map, x, y); |
|
|
1114 | va_end (args); |
662 | va_end (args); |
1115 | *type = CFAPI_NONE; |
663 | *type = CFAPI_NONE; |
1116 | return NULL; |
664 | return NULL; |
1117 | } |
665 | } |
1118 | |
666 | |
1119 | void * |
667 | void * |
1120 | cfapi_map_delete_map (int *type, ...) |
668 | cfapi_map_delete_map (int *type, ...) |
1121 | { |
669 | { |
1122 | va_list args; |
670 | abort (); |
1123 | mapstruct *map; |
|
|
1124 | |
|
|
1125 | va_start (args, type); |
|
|
1126 | |
|
|
1127 | map = va_arg (args, mapstruct *); |
|
|
1128 | |
|
|
1129 | delete_map (map); |
|
|
1130 | |
|
|
1131 | va_end (args); |
|
|
1132 | *type = CFAPI_NONE; |
|
|
1133 | return NULL; |
|
|
1134 | } |
671 | } |
1135 | |
672 | |
1136 | void * |
673 | void * |
1137 | cfapi_map_message (int *type, ...) |
674 | cfapi_map_message (int *type, ...) |
1138 | { |
675 | { |
1139 | va_list args; |
676 | va_list args; |
1140 | mapstruct *map; |
677 | maptile *map; |
1141 | char *string; |
678 | char *string; |
1142 | int color; |
679 | int color; |
1143 | |
680 | |
1144 | va_start (args, type); |
681 | va_start (args, type); |
1145 | map = va_arg (args, mapstruct *); |
682 | map = va_arg (args, maptile *); |
1146 | string = va_arg (args, char *); |
683 | string = va_arg (args, char *); |
1147 | color = va_arg (args, int); |
684 | color = va_arg (args, int); |
1148 | |
685 | |
1149 | va_end (args); |
686 | va_end (args); |
1150 | |
687 | |
… | |
… | |
1155 | |
692 | |
1156 | void * |
693 | void * |
1157 | cfapi_map_get_object_at (int *type, ...) |
694 | cfapi_map_get_object_at (int *type, ...) |
1158 | { |
695 | { |
1159 | va_list args; |
696 | va_list args; |
1160 | mapstruct *map; |
697 | maptile *map; |
1161 | int x, y; |
698 | int x, y; |
1162 | object *rv; |
699 | object *rv; |
1163 | |
700 | |
1164 | va_start (args, type); |
701 | va_start (args, type); |
1165 | map = va_arg (args, mapstruct *); |
702 | map = va_arg (args, maptile *); |
1166 | x = va_arg (args, int); |
703 | x = va_arg (args, int); |
1167 | y = va_arg (args, int); |
704 | y = va_arg (args, int); |
1168 | |
705 | |
1169 | va_end (args); |
706 | va_end (args); |
1170 | |
707 | |
1171 | rv = get_map_ob (map, x, y); |
708 | rv = GET_MAP_OB (map, x, y); |
1172 | *type = CFAPI_POBJECT; |
709 | *type = CFAPI_POBJECT; |
1173 | return rv; |
710 | return rv; |
1174 | } |
711 | } |
1175 | |
712 | |
1176 | void * |
713 | void * |
1177 | cfapi_map_get_flags (int *type, ...) |
714 | cfapi_map_get_flags (int *type, ...) |
1178 | { |
715 | { |
1179 | va_list args; |
716 | va_list args; |
1180 | sint16 x, y; |
717 | sint16 x, y; |
1181 | sint16 *nx, *ny; |
718 | sint16 *nx, *ny; |
1182 | static mapstruct *map; |
719 | static maptile *map; |
1183 | mapstruct **newmap; |
720 | maptile **newmap; |
1184 | static int rv; |
721 | static int rv; |
1185 | |
722 | |
1186 | va_start (args, type); |
723 | va_start (args, type); |
1187 | |
724 | |
1188 | map = va_arg (args, mapstruct *); |
725 | map = va_arg (args, maptile *); |
1189 | newmap = va_arg (args, mapstruct **); |
726 | newmap = va_arg (args, maptile **); |
1190 | x = va_arg (args, int); |
727 | x = va_arg (args, int); |
1191 | y = va_arg (args, int); |
728 | y = va_arg (args, int); |
1192 | |
729 | |
1193 | nx = va_arg (args, sint16 *); |
730 | nx = va_arg (args, sint16 *); |
1194 | ny = va_arg (args, sint16 *); |
731 | ny = va_arg (args, sint16 *); |
… | |
… | |
1204 | cfapi_map_present_arch_by_name (int *type, ...) |
741 | cfapi_map_present_arch_by_name (int *type, ...) |
1205 | { |
742 | { |
1206 | va_list args; |
743 | va_list args; |
1207 | object *rv; |
744 | object *rv; |
1208 | int x, y; |
745 | int x, y; |
1209 | mapstruct *map; |
746 | maptile *map; |
1210 | char *msg; |
747 | char *msg; |
1211 | |
748 | |
1212 | va_start (args, type); |
749 | va_start (args, type); |
1213 | |
750 | |
1214 | msg = va_arg (args, char *); |
751 | msg = va_arg (args, char *); |
1215 | map = va_arg (args, mapstruct *); |
752 | map = va_arg (args, maptile *); |
1216 | x = va_arg (args, int); |
753 | x = va_arg (args, int); |
1217 | y = va_arg (args, int); |
754 | y = va_arg (args, int); |
1218 | |
755 | |
1219 | va_end (args); |
756 | va_end (args); |
1220 | |
757 | |
… | |
… | |
1713 | rv = &op->stats.exp; |
1250 | rv = &op->stats.exp; |
1714 | *type = CFAPI_LONG; |
1251 | *type = CFAPI_LONG; |
1715 | break; |
1252 | break; |
1716 | |
1253 | |
1717 | case CFAPI_OBJECT_PROP_OWNER: |
1254 | case CFAPI_OBJECT_PROP_OWNER: |
1718 | rv = get_owner (op); |
1255 | rv = op->owner; |
1719 | *type = CFAPI_POBJECT; |
1256 | *type = CFAPI_POBJECT; |
1720 | break; |
1257 | break; |
1721 | |
1258 | |
1722 | case CFAPI_OBJECT_PROP_PRESENT: |
1259 | case CFAPI_OBJECT_PROP_PRESENT: |
1723 | { |
1260 | { |
… | |
… | |
1765 | case CFAPI_OBJECT_PROP_MERGEABLE: |
1302 | case CFAPI_OBJECT_PROP_MERGEABLE: |
1766 | { |
1303 | { |
1767 | object *op2; |
1304 | object *op2; |
1768 | op2 = va_arg (args, object *); |
1305 | op2 = va_arg (args, object *); |
1769 | |
1306 | |
1770 | ri = CAN_MERGE (op, op2); |
1307 | ri = object::can_merge_slow (op, op2); |
1771 | rv = &ri; |
1308 | rv = &ri; |
1772 | } |
1309 | } |
1773 | *type = CFAPI_INT; |
1310 | *type = CFAPI_INT; |
1774 | break; |
1311 | break; |
1775 | |
1312 | |
… | |
… | |
1922 | rv = &ri; |
1459 | rv = &ri; |
1923 | *type = CFAPI_INT; |
1460 | *type = CFAPI_INT; |
1924 | break; |
1461 | break; |
1925 | |
1462 | |
1926 | case CFAPI_PLAYER_PROP_IP: |
1463 | case CFAPI_PLAYER_PROP_IP: |
1927 | rv = op->contr->socket.host; |
1464 | rv = op->contr->ns->host; |
1928 | *type = CFAPI_STRING; |
1465 | *type = CFAPI_STRING; |
1929 | break; |
1466 | break; |
1930 | |
1467 | |
1931 | case CFAPI_PLAYER_PROP_MARKED_ITEM: |
1468 | case CFAPI_PLAYER_PROP_MARKED_ITEM: |
1932 | rv = find_marked_object (op); |
1469 | rv = find_marked_object (op); |
… | |
… | |
2042 | if (op->nrof > (uint32) iarg) |
1579 | if (op->nrof > (uint32) iarg) |
2043 | decrease_ob_nr (op, op->nrof - iarg); |
1580 | decrease_ob_nr (op, op->nrof - iarg); |
2044 | else if (op->nrof < (uint32) iarg) |
1581 | else if (op->nrof < (uint32) iarg) |
2045 | { |
1582 | { |
2046 | object *tmp; |
1583 | object *tmp; |
2047 | player *pl; |
|
|
2048 | |
1584 | |
2049 | op->nrof = iarg; |
1585 | op->nrof = iarg; |
2050 | if (op->env != NULL) |
1586 | if (op->env != NULL) |
2051 | { |
1587 | { |
2052 | tmp = is_player_inv (op->env); |
1588 | tmp = op->in_player (); |
2053 | if (!tmp) |
1589 | if (!tmp) |
2054 | { |
1590 | { |
2055 | for (pl = first_player; pl; pl = pl->next) |
1591 | for_all_players (pl) |
2056 | if (pl->ob->container == op->env) |
1592 | if (pl->ob->container == op->env) |
|
|
1593 | { |
|
|
1594 | tmp = pl->ob; |
2057 | break; |
1595 | break; |
2058 | if (pl) |
|
|
2059 | tmp = pl->ob; |
|
|
2060 | else |
1596 | } |
2061 | tmp = NULL; |
|
|
2062 | } |
1597 | } |
2063 | else |
1598 | else |
2064 | { |
1599 | { |
2065 | sum_weight (tmp); |
1600 | sum_weight (tmp); |
2066 | fix_player (tmp); |
1601 | tmp->update_stats (); |
2067 | } |
1602 | } |
2068 | if (tmp) |
1603 | if (tmp) |
2069 | esrv_send_item (tmp, op); |
1604 | esrv_send_item (tmp, op); |
2070 | } |
1605 | } |
2071 | else |
1606 | else |
… | |
… | |
2203 | iarg = va_arg (args, int); |
1738 | iarg = va_arg (args, int); |
2204 | |
1739 | |
2205 | if (op->weight != iarg) |
1740 | if (op->weight != iarg) |
2206 | { |
1741 | { |
2207 | object *tmp; |
1742 | object *tmp; |
2208 | player *pl; |
|
|
2209 | |
1743 | |
2210 | op->weight = iarg; |
1744 | op->weight = iarg; |
2211 | if (op->env != NULL) |
1745 | if (op->env != NULL) |
2212 | { |
1746 | { |
2213 | tmp = is_player_inv (op->env); |
1747 | tmp = op->in_player (); |
2214 | if (!tmp) |
1748 | if (!tmp) |
2215 | { |
1749 | { |
2216 | for (pl = first_player; pl; pl = pl->next) |
1750 | for_all_players (pl) |
2217 | if (pl->ob->container == op->env) |
1751 | if (pl->ob->container == op->env) |
|
|
1752 | { |
|
|
1753 | tmp = pl->ob; |
2218 | break; |
1754 | break; |
2219 | if (pl) |
|
|
2220 | tmp = pl->ob; |
|
|
2221 | else |
1755 | } |
2222 | tmp = NULL; |
|
|
2223 | } |
1756 | } |
2224 | else |
1757 | else |
2225 | { |
1758 | { |
2226 | sum_weight (tmp); |
1759 | sum_weight (tmp); |
2227 | fix_player (tmp); |
1760 | tmp->update_stats (); |
2228 | } |
1761 | } |
2229 | if (tmp) |
1762 | if (tmp) |
2230 | esrv_send_item (tmp, op); |
1763 | esrv_send_item (tmp, op); |
2231 | } |
1764 | } |
2232 | else |
1765 | else |
… | |
… | |
2347 | break; |
1880 | break; |
2348 | |
1881 | |
2349 | case CFAPI_OBJECT_PROP_OWNER: |
1882 | case CFAPI_OBJECT_PROP_OWNER: |
2350 | oparg = va_arg (args, object *); |
1883 | oparg = va_arg (args, object *); |
2351 | |
1884 | |
2352 | set_owner (op, oparg); |
1885 | op->set_owner (oparg); |
2353 | break; |
1886 | break; |
2354 | |
1887 | |
2355 | case CFAPI_OBJECT_PROP_CHEATER: |
1888 | case CFAPI_OBJECT_PROP_CHEATER: |
2356 | set_cheat (op); |
1889 | set_cheat (op); |
2357 | break; |
1890 | break; |
… | |
… | |
2492 | if (op->contr) |
2025 | if (op->contr) |
2493 | { |
2026 | { |
2494 | oparg = va_arg (args, object *); |
2027 | oparg = va_arg (args, object *); |
2495 | |
2028 | |
2496 | op->contr->mark = oparg; |
2029 | op->contr->mark = oparg; |
2497 | if (oparg) |
|
|
2498 | op->contr->mark_count = oparg->count; |
|
|
2499 | } |
2030 | } |
2500 | break; |
2031 | break; |
2501 | |
2032 | |
2502 | case CFAPI_PLAYER_PROP_PARTY: |
2033 | case CFAPI_PLAYER_PROP_PARTY: |
2503 | if (op->contr) |
2034 | if (op->contr) |
… | |
… | |
2594 | } |
2125 | } |
2595 | |
2126 | |
2596 | void * |
2127 | void * |
2597 | cfapi_object_drain (int *type, ...) |
2128 | cfapi_object_drain (int *type, ...) |
2598 | { |
2129 | { |
2599 | va_list args; |
2130 | abort (); |
|
|
2131 | } |
2600 | |
2132 | |
|
|
2133 | void * |
|
|
2134 | cfapi_object_fix (int *type, ...) |
|
|
2135 | { |
|
|
2136 | va_list args; |
2601 | object *op; |
2137 | object *op; |
2602 | int ds; |
|
|
2603 | |
2138 | |
2604 | va_start (args, type); |
2139 | va_start (args, type); |
2605 | |
2140 | |
2606 | op = va_arg (args, object *); |
2141 | op = va_arg (args, object *); |
2607 | ds = va_arg (args, int); |
|
|
2608 | |
2142 | |
2609 | va_end (args); |
2143 | va_end (args); |
2610 | |
2144 | |
2611 | drain_specific_stat (op, ds); |
2145 | op->update_stats (); |
2612 | |
|
|
2613 | *type = CFAPI_NONE; |
|
|
2614 | return NULL; |
|
|
2615 | } |
|
|
2616 | |
|
|
2617 | void * |
|
|
2618 | cfapi_object_fix (int *type, ...) |
|
|
2619 | { |
|
|
2620 | va_list args; |
|
|
2621 | object *op; |
|
|
2622 | |
|
|
2623 | va_start (args, type); |
|
|
2624 | |
|
|
2625 | op = va_arg (args, object *); |
|
|
2626 | |
|
|
2627 | va_end (args); |
|
|
2628 | |
|
|
2629 | fix_player (op); |
|
|
2630 | |
2146 | |
2631 | *type = CFAPI_NONE; |
2147 | *type = CFAPI_NONE; |
2632 | return NULL; |
2148 | return NULL; |
2633 | } |
2149 | } |
2634 | |
2150 | |
… | |
… | |
2682 | op = va_arg (args, object *); |
2198 | op = va_arg (args, object *); |
2683 | |
2199 | |
2684 | va_end (args); |
2200 | va_end (args); |
2685 | |
2201 | |
2686 | send_removed_object (op); |
2202 | send_removed_object (op); |
2687 | remove_ob (op); |
2203 | op->remove (); |
2688 | *type = CFAPI_NONE; |
2204 | *type = CFAPI_NONE; |
2689 | return NULL; |
2205 | return NULL; |
2690 | } |
2206 | } |
2691 | |
2207 | |
2692 | void * |
2208 | void * |
… | |
… | |
2699 | |
2215 | |
2700 | op = va_arg (args, object *); |
2216 | op = va_arg (args, object *); |
2701 | |
2217 | |
2702 | va_end (args); |
2218 | va_end (args); |
2703 | |
2219 | |
2704 | free_object (op); |
2220 | op->destroy (); |
2705 | |
2221 | |
2706 | *type = CFAPI_NONE; |
2222 | *type = CFAPI_NONE; |
2707 | return NULL; |
2223 | return NULL; |
2708 | } |
2224 | } |
2709 | |
2225 | |
… | |
… | |
2726 | *type = CFAPI_POBJECT; |
2242 | *type = CFAPI_POBJECT; |
2727 | return object_create_clone (op); |
2243 | return object_create_clone (op); |
2728 | } |
2244 | } |
2729 | else |
2245 | else |
2730 | { |
2246 | { |
2731 | object *tmp; |
2247 | object *tmp = op->clone (); |
2732 | |
|
|
2733 | tmp = get_object (); |
|
|
2734 | copy_object (op, tmp); |
|
|
2735 | *type = CFAPI_POBJECT; |
2248 | *type = CFAPI_POBJECT; |
2736 | return tmp; |
2249 | return tmp; |
2737 | } |
2250 | } |
2738 | } |
2251 | } |
2739 | void * |
2252 | void * |
… | |
… | |
2775 | break; |
2288 | break; |
2776 | |
2289 | |
2777 | case 3: |
2290 | case 3: |
2778 | op = va_arg (args, object *); |
2291 | op = va_arg (args, object *); |
2779 | |
2292 | |
2780 | rv = is_player_inv (op); |
2293 | rv = op->in_player (); |
2781 | break; |
2294 | break; |
2782 | |
2295 | |
2783 | default: |
2296 | default: |
2784 | rv = NULL; |
2297 | rv = NULL; |
2785 | *type = CFAPI_NONE; |
2298 | *type = CFAPI_NONE; |
… | |
… | |
2803 | *type = CFAPI_POBJECT; |
2316 | *type = CFAPI_POBJECT; |
2804 | switch (ival) |
2317 | switch (ival) |
2805 | { |
2318 | { |
2806 | case 0: |
2319 | case 0: |
2807 | va_end (args); |
2320 | va_end (args); |
2808 | return get_object (); |
2321 | return object::create (); |
2809 | break; |
2322 | break; |
2810 | |
2323 | |
2811 | case 1: /* Named object. Nearly the old plugin behavior, but we don't add artifact suffixes */ |
2324 | case 1: /* Named object. Nearly the old plugin behavior, but we don't add artifact suffixes */ |
2812 | { |
2325 | { |
2813 | char *sval; |
2326 | char *sval; |
… | |
… | |
2816 | |
2329 | |
2817 | op = get_archetype_by_object_name (sval); |
2330 | op = get_archetype_by_object_name (sval); |
2818 | |
2331 | |
2819 | if (strncmp (query_name (op), ARCH_SINGULARITY, ARCH_SINGULARITY_LEN) == 0) |
2332 | if (strncmp (query_name (op), ARCH_SINGULARITY, ARCH_SINGULARITY_LEN) == 0) |
2820 | { |
2333 | { |
2821 | free_object (op); |
2334 | op->destroy (); |
2822 | /* Try with archetype names... */ |
2335 | /* Try with archetype names... */ |
2823 | op = get_archetype (sval); |
2336 | op = get_archetype (sval); |
2824 | if (strncmp (query_name (op), ARCH_SINGULARITY, ARCH_SINGULARITY_LEN) == 0) |
2337 | if (strncmp (query_name (op), ARCH_SINGULARITY, ARCH_SINGULARITY_LEN) == 0) |
2825 | { |
2338 | { |
2826 | free_object (op); |
2339 | op->destroy (); |
2827 | *type = CFAPI_NONE; |
2340 | *type = CFAPI_NONE; |
2828 | va_end (args); |
2341 | va_end (args); |
2829 | return NULL; |
2342 | return NULL; |
2830 | } |
2343 | } |
2831 | } |
2344 | } |
… | |
… | |
2845 | cfapi_object_insert (int *type, ...) |
2358 | cfapi_object_insert (int *type, ...) |
2846 | { |
2359 | { |
2847 | va_list args; |
2360 | va_list args; |
2848 | object *op; |
2361 | object *op; |
2849 | object *orig; |
2362 | object *orig; |
2850 | mapstruct *map; |
2363 | maptile *map; |
2851 | int flag, x, y; |
2364 | int flag, x, y; |
2852 | int itype; |
2365 | int itype; |
2853 | char *arch_string; |
2366 | char *arch_string; |
2854 | void *rv = NULL; |
2367 | void *rv = NULL; |
2855 | |
2368 | |
… | |
… | |
2859 | itype = va_arg (args, int); |
2372 | itype = va_arg (args, int); |
2860 | |
2373 | |
2861 | switch (itype) |
2374 | switch (itype) |
2862 | { |
2375 | { |
2863 | case 0: |
2376 | case 0: |
2864 | map = va_arg (args, mapstruct *); |
2377 | map = va_arg (args, maptile *); |
2865 | orig = va_arg (args, object *); |
2378 | orig = va_arg (args, object *); |
2866 | flag = va_arg (args, int); |
2379 | flag = va_arg (args, int); |
2867 | x = va_arg (args, int); |
2380 | x = va_arg (args, int); |
2868 | y = va_arg (args, int); |
2381 | y = va_arg (args, int); |
2869 | |
2382 | |
2870 | rv = insert_ob_in_map_at (op, map, orig, flag, x, y); |
2383 | rv = insert_ob_in_map_at (op, map, orig, flag, x, y); |
2871 | *type = CFAPI_POBJECT; |
2384 | *type = CFAPI_POBJECT; |
2872 | break; |
2385 | break; |
2873 | |
2386 | |
2874 | case 1: |
2387 | case 1: |
2875 | map = va_arg (args, mapstruct *); |
2388 | map = va_arg (args, maptile *); |
2876 | orig = va_arg (args, object *); |
2389 | orig = va_arg (args, object *); |
2877 | flag = va_arg (args, int); |
2390 | flag = va_arg (args, int); |
2878 | |
2391 | |
2879 | rv = insert_ob_in_map (op, map, orig, flag); |
2392 | rv = insert_ob_in_map (op, map, orig, flag); |
2880 | *type = CFAPI_POBJECT; |
2393 | *type = CFAPI_POBJECT; |
… | |
… | |
2981 | } |
2494 | } |
2982 | |
2495 | |
2983 | void * |
2496 | void * |
2984 | cfapi_object_clear (int *type, ...) |
2497 | cfapi_object_clear (int *type, ...) |
2985 | { |
2498 | { |
2986 | va_list args; |
2499 | abort (); |
2987 | object *op; |
|
|
2988 | |
|
|
2989 | va_start (args, type); |
|
|
2990 | |
|
|
2991 | op = va_arg (args, object *); |
|
|
2992 | |
|
|
2993 | va_end (args); |
|
|
2994 | |
|
|
2995 | clear_object (op); |
|
|
2996 | *type = CFAPI_NONE; |
|
|
2997 | return NULL; |
|
|
2998 | } |
2500 | } |
2999 | |
2501 | |
3000 | void * |
2502 | void * |
3001 | cfapi_object_reset (int *type, ...) |
2503 | cfapi_object_reset (int *type, ...) |
3002 | { |
2504 | { |
… | |
… | |
3035 | } |
2537 | } |
3036 | |
2538 | |
3037 | void * |
2539 | void * |
3038 | cfapi_object_clean_object (int *type, ...) |
2540 | cfapi_object_clean_object (int *type, ...) |
3039 | { |
2541 | { |
3040 | va_list args; |
2542 | abort (); |
3041 | object *op; |
|
|
3042 | |
|
|
3043 | va_start (args, type); |
|
|
3044 | op = va_arg (args, object *); |
|
|
3045 | |
|
|
3046 | clean_object (op); |
|
|
3047 | va_end (args); |
|
|
3048 | *type = CFAPI_NONE; |
|
|
3049 | return NULL; |
|
|
3050 | } |
2543 | } |
3051 | |
2544 | |
3052 | void * |
2545 | void * |
3053 | cfapi_object_on_same_map (int *type, ...) |
2546 | cfapi_object_on_same_map (int *type, ...) |
3054 | { |
2547 | { |
… | |
… | |
3266 | object *op; |
2759 | object *op; |
3267 | object *originator; |
2760 | object *originator; |
3268 | int x, y, randompos, ttype; |
2761 | int x, y, randompos, ttype; |
3269 | va_list args; |
2762 | va_list args; |
3270 | static int rv = 0; |
2763 | static int rv = 0; |
3271 | mapstruct *map; |
2764 | maptile *map; |
3272 | |
2765 | |
3273 | va_start (args, type); |
2766 | va_start (args, type); |
3274 | op = va_arg (args, object *); |
2767 | op = va_arg (args, object *); |
3275 | ttype = va_arg (args, int); |
2768 | ttype = va_arg (args, int); |
3276 | |
2769 | |
… | |
… | |
3290 | break; |
2783 | break; |
3291 | |
2784 | |
3292 | case 1: |
2785 | case 1: |
3293 | x = va_arg (args, int); |
2786 | x = va_arg (args, int); |
3294 | y = va_arg (args, int); |
2787 | y = va_arg (args, int); |
3295 | map = va_arg (args, mapstruct *); |
2788 | map = va_arg (args, maptile *); |
3296 | |
2789 | |
3297 | va_end (args); |
2790 | va_end (args); |
3298 | if (x < 0 || y < 0) |
2791 | if (x < 0 || y < 0) |
3299 | { |
2792 | { |
3300 | x = map->enter_x; |
2793 | x = map->enter_x; |
3301 | y = map->enter_y; |
2794 | y = map->enter_y; |
3302 | } |
2795 | } |
3303 | |
2796 | |
3304 | /* |
2797 | /* |
3305 | originator = get_object(); |
2798 | originator = object::create(); |
3306 | EXIT_PATH(originator) = add_string(map->path); |
2799 | EXIT_PATH(originator) = add_string(map->path); |
3307 | EXIT_X(originator) = x; |
2800 | EXIT_X(originator) = x; |
3308 | EXIT_Y(originator) = y; |
2801 | EXIT_Y(originator) = y; |
3309 | printf("B Transfer: X=%d, Y=%d, OP=%s\n", x, y, op->name);*/ |
2802 | printf("B Transfer: X=%d, Y=%d, OP=%s\n", x, y, op->name);*/ |
3310 | /*enter_exit(op, originator); */ |
2803 | /*enter_exit(op, originator); */ |
3311 | insert_ob_in_map_at (op, map, NULL, 0, x, y); |
2804 | insert_ob_in_map_at (op, map, NULL, 0, x, y); |
3312 | /*printf("A Transfer: X=%d, Y=%d, MAP=%s\n", x, y, op->map->name); |
2805 | /*printf("A Transfer: X=%d, Y=%d, MAP=%s\n", x, y, op->map->name); |
3313 | free_object(originator); |
2806 | originator->destroy (); |
3314 | */ |
2807 | */ |
3315 | *type = CFAPI_INT; |
2808 | *type = CFAPI_INT; |
3316 | return &rv; |
2809 | return &rv; |
3317 | break; |
2810 | break; |
3318 | |
2811 | |
… | |
… | |
3391 | drop (author, op); |
2884 | drop (author, op); |
3392 | |
2885 | |
3393 | if (author->type == PLAYER) |
2886 | if (author->type == PLAYER) |
3394 | { |
2887 | { |
3395 | author->contr->count = 0; |
2888 | author->contr->count = 0; |
3396 | author->contr->socket.update_look = 1; |
2889 | author->contr->ns->floorbox_update (); |
3397 | } |
2890 | } |
3398 | |
2891 | |
3399 | *type = CFAPI_NONE; |
2892 | *type = CFAPI_NONE; |
3400 | return NULL; |
2893 | return NULL; |
3401 | } |
2894 | } |
… | |
… | |
3482 | } |
2975 | } |
3483 | |
2976 | |
3484 | void * |
2977 | void * |
3485 | cfapi_object_teleport (int *type, ...) |
2978 | cfapi_object_teleport (int *type, ...) |
3486 | { |
2979 | { |
3487 | mapstruct *map; |
2980 | maptile *map; |
3488 | int x, y; |
2981 | int x, y; |
3489 | object *who; |
2982 | object *who; |
3490 | static int result; |
2983 | static int result; |
3491 | va_list args; |
2984 | va_list args; |
3492 | |
2985 | |
3493 | va_start (args, type); |
2986 | va_start (args, type); |
3494 | who = va_arg (args, object *); |
2987 | who = va_arg (args, object *); |
3495 | map = va_arg (args, mapstruct *); |
2988 | map = va_arg (args, maptile *); |
3496 | x = va_arg (args, int); |
2989 | x = va_arg (args, int); |
3497 | y = va_arg (args, int); |
2990 | y = va_arg (args, int); |
3498 | |
2991 | |
3499 | if (!out_of_map (map, x, y)) |
2992 | if (!out_of_map (map, x, y)) |
3500 | { |
2993 | { |
… | |
… | |
3507 | result = 1; |
3000 | result = 1; |
3508 | return &result; |
3001 | return &result; |
3509 | } |
3002 | } |
3510 | |
3003 | |
3511 | send_removed_object (who); |
3004 | send_removed_object (who); |
3512 | remove_ob (who); |
3005 | who->remove (); |
3513 | |
3006 | |
3514 | for (tmp = who; tmp != NULL; tmp = tmp->more) |
3007 | for (tmp = who; tmp != NULL; tmp = tmp->more) |
3515 | tmp->x = x + freearr_x[k] + (tmp->arch == NULL ? 0 : tmp->arch->clone.x), |
3008 | tmp->x = x + freearr_x[k] + (tmp->arch == NULL ? 0 : tmp->arch->clone.x), |
3516 | tmp->y = y + freearr_y[k] + (tmp->arch == NULL ? 0 : tmp->arch->clone.y); |
3009 | tmp->y = y + freearr_y[k] + (tmp->arch == NULL ? 0 : tmp->arch->clone.y); |
3517 | |
3010 | |
… | |
… | |
3634 | |
3127 | |
3635 | case CFAPI_PARTY_PROP_PLAYER: |
3128 | case CFAPI_PARTY_PROP_PLAYER: |
3636 | *type = CFAPI_PPLAYER; |
3129 | *type = CFAPI_PPLAYER; |
3637 | obarg = va_arg (args, object *); |
3130 | obarg = va_arg (args, object *); |
3638 | |
3131 | |
3639 | pl = (obarg ? obarg->contr : first_player); |
3132 | pl = (obarg ? (player *)obarg->contr : first_player); |
3640 | rv = NULL; |
3133 | rv = NULL; |
3641 | for (; pl != NULL; pl = pl->next) |
3134 | for (; pl != NULL; pl = pl->next) |
3642 | if (pl->ob->contr->party == party) |
3135 | if (pl->ob->contr->party == party) |
3643 | { |
3136 | { |
3644 | rv = (void *) pl; |
3137 | rv = (void *) pl; |
… | |
… | |
3739 | return NULL; |
3232 | return NULL; |
3740 | } |
3233 | } |
3741 | |
3234 | |
3742 | /*****************************************************************************/ |
3235 | /*****************************************************************************/ |
3743 | |
3236 | |
3744 | /* Plugins initialization. Browses the plugins directory and call */ |
3237 | /* Plugins initialisation. Browses the plugins directory and call */ |
3745 | |
3238 | |
3746 | /* initOnePlugin for each file found. */ |
3239 | /* initOnePlugin for each file found. */ |
3747 | |
3240 | |
3748 | /* Returns 0 if at least one plugin was successfully loaded, -1 if not */ |
3241 | /* Returns 0 if at least one plugin was successfully loaded, -1 if not */ |
3749 | |
3242 | |
… | |
… | |
3756 | size_t l; |
3249 | size_t l; |
3757 | char buf[MAX_BUF]; |
3250 | char buf[MAX_BUF]; |
3758 | char buf2[MAX_BUF]; |
3251 | char buf2[MAX_BUF]; |
3759 | int result; |
3252 | int result; |
3760 | |
3253 | |
3761 | LOG (llevInfo, "Initializing plugins\n"); |
3254 | LOG (llevInfo, "Initialising plugins\n"); |
3762 | strcpy (buf, LIBDIR); |
3255 | strcpy (buf, LIBDIR); |
3763 | strcat (buf, "/plugins/"); |
3256 | strcat (buf, "/plugins/"); |
3764 | LOG (llevInfo, "Plugins directory is %s\n", buf); |
3257 | LOG (llevInfo, "Plugins directory is %s\n", buf); |
3765 | |
3258 | |
3766 | plugins_init_perl (); |
3259 | plugins_init_perl (); |