--- deliantra/server/lib/cf.pm 2006/12/14 05:09:32 1.86 +++ deliantra/server/lib/cf.pm 2006/12/21 22:41:35 1.93 @@ -18,6 +18,8 @@ use strict; +sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload + our %COMMAND = (); our %COMMAND_TIME = (); our %EXTCMD = (); @@ -25,7 +27,7 @@ _init_vars; our @EVENT; -our $LIBDIR = maps_directory "perl"; +our $LIBDIR = datadir . "/ext"; our $TICK = MAX_TIME * 1e-6; our $TICK_WATCHER; @@ -74,13 +76,19 @@ }; } +@safe::cf::global::ISA = @cf::global::ISA = 'cf::attachable'; +@safe::cf::object::ISA = @cf::object::ISA = 'cf::attachable'; +@safe::cf::player::ISA = @cf::player::ISA = 'cf::attachable'; +@safe::cf::client::ISA = @cf::client::ISA = 'cf::attachable'; +@safe::cf::map::ISA = @cf::map::ISA = 'cf::attachable'; @safe::cf::object::player::ISA = @cf::object::player::ISA = 'cf::object'; # we bless all objects into (empty) derived classes to force a method lookup # within the Safe compartment. for my $pkg (qw( + cf::global cf::object cf::object::player - cf::client_socket cf::player + cf::client cf::player cf::arch cf::living cf::map cf::party cf::region )) { @@ -132,42 +140,36 @@ ############################################################################# -=head2 EVENTS AND OBJECT ATTACHMENTS - -=over 4 - -=item $object->attach ($attachment, key => $value...) - -=item $object->detach ($attachment) +=head2 ATTACHABLE OBJECTS -Attach/detach a pre-registered attachment to an object. +You can define and attach attachments to each "attachable" object in +crossfire+ (objects, players, clients, maps and the special "global" +class). In the following description, CLASS can be any of C, +C C, C or C. -=item $player->attach ($attachment, key => $value...) - -=item $player->detach ($attachment) - -Attach/detach a pre-registered attachment to a player. - -=item $map->attach ($attachment, key => $value...) +=over 4 -=item $map->detach ($attachment) +=item cf::CLASS::attachment $name, ... -Attach/detach a pre-registered attachment to a map. +Register an attachment by name through which attachable objects can refer +to this attachment. -=item $bool = $object->attached ($name) +=item $bool = $attachable->attached ($name) -=item $bool = $player->attached ($name) +Checks wether the named attachment is currently attached to the object. -=item $bool = $map->attached ($name) +=item $attachable->attach ($attachment, key => $value...) -Checks wether the named attachment is currently attached to the object. +=item $attachable->detach ($attachment) -=item cf::attach_global ... +Attach/detach a pre-registered attachment either to a specific object +(C<$attachable>) or all objects of the given class (if C<$attachable> is a +class in a static method call). -Attach handlers for global events. +You can attach to global events by using the C class. -This and all following C-functions expect any number of the -following handler/hook descriptions: +These method calls expect any number of the following handler/hook +descriptions: =over 4 @@ -179,6 +181,12 @@ registered at priority C<-1000>, so lower priorities should not be used unless you know what you are doing. +=item type => $type + +(Only for C<< cf::object->attach >> calls), limits the attachment to the +given type of objects only (the additional parameter C can be +used to further limit to the given subtype). + =item on_I => \&cb Call the given code reference whenever the named event happens (event is @@ -197,54 +205,20 @@ =back -=item cf::attach_to_type $object_type, $subtype, ... - -Attach handlers for a specific object type (e.g. TRANSPORT) and -subtype. If C<$subtype> is zero or undef, matches all objects of the given -type. - -=item cf::attach_to_objects ... - -Attach handlers to all objects. Do not use this except for debugging or -very rare events, as handlers are (obviously) called for I objects in -the game. - -=item cf::attach_to_players ... - -Attach handlers to all players. - -=item cf::attach_to_maps ... - -Attach handlers to all maps. - -=item cf:register_attachment $name, ... - -Register an attachment by name through which objects can refer to this -attachment. - -=item cf:register_player_attachment $name, ... - -Register an attachment by name through which players can refer to this -attachment. - -=item cf:register_map_attachment $name, ... - -Register an attachment by name through which maps can refer to this -attachment. - =cut # the following variables are defined in .xs and must not be re-created our @CB_GLOBAL = (); # registry for all global events our @CB_OBJECT = (); # all objects (should not be used except in emergency) our @CB_PLAYER = (); +our @CB_CLIENT = (); our @CB_TYPE = (); # registry for type (cf-object class) based events our @CB_MAP = (); my %attachment; -sub _attach_cb($\%$$$) { - my ($registry, $undo, $event, $prio, $cb) = @_; +sub _attach_cb($$$$) { + my ($registry, $event, $prio, $cb) = @_; use sort 'stable'; @@ -253,23 +227,16 @@ @{$registry->[$event]} = sort { $a->[0] cmp $b->[0] } @{$registry->[$event] || []}, $cb; - - push @{$undo->{cb}}, [$event, $cb]; } # attach handles attaching event callbacks # the only thing the caller has to do is pass the correct # registry (== where the callback attaches to). -sub _attach(\@$@) { +sub _attach { my ($registry, $klass, @arg) = @_; + my $object_type; my $prio = 0; - - my %undo = ( - registry => $registry, - cb => [], - ); - my %cb_id = map +("on_" . lc $EVENT[$_][0], $_) , grep $EVENT[$_][1] == $klass, 0 .. $#EVENT; while (@arg) { @@ -278,17 +245,26 @@ if ($type eq "prio") { $prio = shift @arg; + } elsif ($type eq "type") { + $object_type = shift @arg; + $registry = $CB_TYPE[$object_type] ||= []; + + } elsif ($type eq "subtype") { + defined $object_type or Carp::croak "subtype specified without type"; + my $object_subtype = shift @arg; + $registry = $CB_TYPE[$object_type + $object_subtype * NUM_SUBTYPES] ||= []; + } elsif ($type eq "package") { my $pkg = shift @arg; while (my ($name, $id) = each %cb_id) { if (my $cb = $pkg->can ($name)) { - _attach_cb $registry, %undo, $id, $prio, $cb; + _attach_cb $registry, $id, $prio, $cb; } } } elsif (exists $cb_id{$type}) { - _attach_cb $registry, %undo, $cb_id{$type}, $prio, shift @arg; + _attach_cb $registry, $cb_id{$type}, $prio, shift @arg; } elsif (ref $type) { warn "attaching objects not supported, ignoring.\n"; @@ -298,23 +274,19 @@ warn "attach argument '$type' not supported, ignoring.\n"; } } - - \%undo } -sub _attach_attachment { +sub _object_attach { my ($obj, $name, %arg) = @_; return if exists $obj->{_attachment}{$name}; - my $res; - if (my $attach = $attachment{$name}) { my $registry = $obj->registry; for (@$attach) { my ($klass, @attach) = @$_; - $res = _attach @$registry, $klass, @attach; + _attach $registry, $klass, @attach; } $obj->{$name} = \%arg; @@ -323,76 +295,47 @@ } $obj->{_attachment}{$name} = undef; - - $res->{attachment} = $name; - $res } -*cf::object::attach = -*cf::player::attach = -*cf::map::attach = sub { - my ($obj, $name, %arg) = @_; - - _attach_attachment $obj, $name, %arg; +sub cf::attachable::attach { + if (ref $_[0]) { + _object_attach @_; + } else { + _attach shift->_attach_registry, @_; + } }; # all those should be optimised -*cf::object::detach = -*cf::player::detach = -*cf::map::detach = sub { +sub cf::attachable::detach { my ($obj, $name) = @_; - delete $obj->{_attachment}{$name}; - reattach ($obj); + if (ref $obj) { + delete $obj->{_attachment}{$name}; + reattach ($obj); + } else { + Carp::croak "cannot, currently, detach class attachments"; + } }; -*cf::object::attached = -*cf::player::attached = -*cf::map::attached = sub { +sub cf::attachable::attached { my ($obj, $name) = @_; exists $obj->{_attachment}{$name} -}; - -sub attach_global { - _attach @CB_GLOBAL, KLASS_GLOBAL, @_ -} - -sub attach_to_type { - my $type = shift; - my $subtype = shift; - - _attach @{$CB_TYPE[$type + $subtype * NUM_SUBTYPES]}, KLASS_OBJECT, @_ -} - -sub attach_to_objects { - _attach @CB_OBJECT, KLASS_OBJECT, @_ -} - -sub attach_to_players { - _attach @CB_PLAYER, KLASS_PLAYER, @_ -} - -sub attach_to_maps { - _attach @CB_MAP, KLASS_MAP, @_ } -sub register_attachment { - my $name = shift; - - $attachment{$name} = [[KLASS_OBJECT, @_]]; -} - -sub register_player_attachment { - my $name = shift; - - $attachment{$name} = [[KLASS_PLAYER, @_]]; -} +for my $klass (qw(GLOBAL OBJECT PLAYER CLIENT MAP)) { + eval "#line " . __LINE__ . " 'cf.pm' + sub cf::\L$klass\E::_attach_registry { + (\\\@CB_$klass, KLASS_$klass) + } -sub register_map_attachment { - my $name = shift; + sub cf::\L$klass\E::attachment { + my \$name = shift; - $attachment{$name} = [[KLASS_MAP, @_]]; + \$attachment{\$name} = [[KLASS_$klass, \@_]]; + } + "; + die if $@; } our $override; @@ -432,6 +375,8 @@ =item $bool = $player->invoke (EVENT_PLAYER_XXX, ...) +=item $bool = $client->invoke (EVENT_CLIENT_XXX, ...) + =item $bool = $map->invoke (EVENT_MAP_XXX, ...) Generate a global/object/player/map-specific event with the given arguments. @@ -446,11 +391,13 @@ ############################################################################# -=head2 METHODS VALID FOR ALL CORE OBJECTS +=head2 METHODS VALID FOR ALL ATTACHABLE OBJECTS + +Attachable objects includes objects, players, clients and maps. =over 4 -=item $object->valid, $player->valid, $map->valid +=item $object->valid Just because you have a perl object does not mean that the corresponding C-level object still exists. If you try to access an object that has no @@ -462,10 +409,6 @@ =cut -*cf::object::valid = -*cf::player::valid = -*cf::map::valid = \&cf::_valid; - ############################################################################# # object support @@ -494,7 +437,7 @@ if (my $attach = $attachment{$name}) { for (@$attach) { my ($klass, @attach) = @$_; - _attach @$registry, $klass, @attach; + _attach $registry, $klass, @attach; } } else { warn "object uses attachment '$name' that is not available, postponing.\n"; @@ -560,7 +503,7 @@ () } -attach_to_objects +cf::object->attach ( prio => -1000000, on_clone => sub { my ($src, $dst) = @_; @@ -572,7 +515,7 @@ %{$dst->{_attachment}} = %{$src->{_attachment}} if exists $src->{_attachment}; }, -; +); ############################################################################# # command handling &c @@ -611,7 +554,7 @@ $EXTCMD{$name} = [$cb, $caller]; } -attach_to_players +cf::player->attach ( on_command => sub { my ($pl, $name, $params) = @_; @@ -641,7 +584,7 @@ cf::override; }, -; +); sub register { my ($base, $pkg) = @_; @@ -720,8 +663,6 @@ } sub load_extensions { - my $LIBDIR = maps_directory "perl"; - for my $ext (<$LIBDIR/*.ext>) { next unless -r $ext; eval { @@ -743,7 +684,7 @@ unlink "$path.pst"; }; -attach_to_maps prio => -10000, package => cf::mapsupport::; +cf::map->attach (prio => -10000, package => cf::mapsupport::); ############################################################################# # load/save perl data associated with player->ob objects @@ -753,7 +694,7 @@ } # TODO: compatibility cruft, remove when no longer needed -attach_to_players +cf::player->attach ( on_load => sub { my ($pl, $path) = @_; @@ -765,7 +706,7 @@ } } }, -; +); ############################################################################# @@ -866,16 +807,18 @@ The following fucntions and emthods are available within a safe environment: - cf::object contr pay_amount pay_player + cf::object contr pay_amount pay_player map cf::object::player player cf::player peaceful + cf::map trigger =cut for ( - ["cf::object" => qw(contr pay_amount pay_player)], + ["cf::object" => qw(contr pay_amount pay_player map)], ["cf::object::player" => qw(player)], ["cf::player" => qw(peaceful)], + ["cf::map" => qw(trigger)], ) { no strict 'refs'; my ($pkg, @funs) = @$_; @@ -1025,7 +968,7 @@ undef $dirty; } - my $idle = Event->idle (min => $TICK * 2.8, max => 10, repeat => 0, cb => sub { + my $idle = Event->idle (min => $TICK * 2.8, max => 10, repeat => 0, data => WF_AUTOCANCEL, cb => sub { db_sync; }); @@ -1049,12 +992,12 @@ db_dirty; } - attach_global - prio => 10000, + cf::global->attach ( + prio => 10000, on_cleanup => sub { db_sync; }, - ; + ); } ############################################################################# @@ -1085,7 +1028,9 @@ eval { # cancel all watchers - $_->cancel for Event::all_watchers; + for (Event::all_watchers) { + $_->cancel if $_->data & WF_AUTOCANCEL; + } # unload all extensions for (@exts) { @@ -1171,9 +1116,9 @@ unshift @INC, $LIBDIR; $TICK_WATCHER = Event->timer ( - prio => 1, - async => 1, + prio => 0, at => $NEXT_TICK || 1, + data => WF_AUTOCANCEL, cb => sub { cf::server_tick; # one server iteration @@ -1193,6 +1138,7 @@ Event->io (fd => IO::AIO::poll_fileno, poll => 'r', prio => 5, + data => WF_AUTOCANCEL, cb => \&IO::AIO::poll_cb); 1