Assuming player.react_before.poisoned (to use a neutral syntax since syntax is the topic) sounds like a way of setting (and getting?) an event handler, how about something like the following:

sub name {
   my ($self, $name) = @_;
   $self->{name} = $name if @_ >= 2;
   return $self->{name};
}


sub react_before {
   my ($self, $event, $handler) = @_;

   if (@_ >= 2) {
      $self->{event_handlers}{$event}{before} = $handler;
   }

   return $self->{event_handlers}{$event}{before};
}


sub poisoned {
   my ($self, $poisoned) = @_;

   if (@_ >= 2) {
      if ($poisoned != $self->{poisoned}) {
         my $handler= $self->{event_handlers}{poisoned}{before};
         $poisoned = $handler->($self, 'poisoned', $val) if $handler;
      }

      if ($val != $self->{poisoned}) {
         $self->{poisoned} = $poisoned;

         my $handler = $self->{event_handlers}{poisoned}{after};
         $handler->($self, 'poisoned', $poisoned) if $handler;
      }
   }

   return $self->{poisoned};
}


$char->react_before(poisoned => \&handler);

$char->poisoned(1);

print(
   $char->name,
   ' is ',
   $char->poisoned ? 'posioned' : 'not poisoned',
   ".\n"
);
[download]

That said there are times where 'personal preference' gets in the way of writing the best code. If you (generic) are opposed to OO in all circumstances due to personal preferences you are likely to write code in a way that is one or more of more complex, more buggy, and more difficult to extend and maintain than it would be otherwise. I have a sense here that you may be going in that direction here. Seems like to me that you are going through some awful complex gyrations to avoid OO syntax, but of course you are really using OO since tie just let's you do OO while making it look like you are doing some other kind of programming. This will give you a performance hit (though I'm not sure how much the tie-ing overhead really hits performance) which can be an issue in some types of computer games (I don't know about your particular case though).