File Coverage

blib/lib/Games/3D/Link.pm

Criterion	Covered	Total	%
statement	75	95	78.9
branch	27	50	54.0
condition	6	12	50.0
subroutine	14	18	77.7
pod	12	12	100.0
total	134	187	71.6

# Link - link two objects together and allow sending signal(s) between them

package Games::3D::Link;

# (C) by Tels

use strict;

require Exporter;
use Games::3D::Signal qw/
  SIG_FLIP SIG_OFF SIG_DIE
  SIG_ACTIVATE SIG_DEACTIVATE
  signal_name
  /;
use Games::3D::Thingy;
use vars qw/@ISA $VERSION/;
@ISA = qw/Exporter Games::3D::Thingy/;

$VERSION = '0.03';

sub DEBUG () { 0; }

##############################################################################
# protected class vars

{
  sub add_timer { die ("You need to set a timer callback first.") };
  my $timer = 'Games::3D::Link';	# make it point to our add_timer()
  sub timer_provider
    {
    $timer = shift if @_ > 0;
    $timer;
    }
}

##############################################################################
# methods

sub _init
  {
  my $self = shift;

  $self->SUPER::_init(@_);

  $self->{input_states} = {};  			# for AND gates
  $self->{inputs} = {};
  $self->{outputs} = {};

  $self->{count} = 1;				# send signal only once
  $self->{delay} = 0;				# immidiately
  $self->{repeat} = 2000;			# 2 seconds if count != 1
  $self->{rand} = 0;				# exactly
  $self->{once} = 0;				# not once
  $self->{fixed_output} = undef;		# none (just releay)
  $self->{invert} = 0;				# not
  $self->{and} = 0;				# act as OR gate
  $self;
  }

# override signal() to be more complex than Thingy's default

sub signal
  {
  my ($self,$input,$sig) = @_;

#  my $id = $input; $id = $input->{id} if ref($id);
#  print "# ",$self->name()," received signal $sig from $id\n";

  die ("Unregistered input $input tried to send signal to link $self->{id}")
   if !exists $self->{inputs}->{$input};

  # if the signal is DIE, DESTROY yourself
  if ($sig == SIG_DIE)
    {
    $self->kill();
    return;
    }
  # if the signal is ACTIVATE or DEACTIVATE, (in)activate yourself
  if ($sig == SIG_ACTIVATE)
    {
    $self->activate();
    return;				# don't relay this signal
    }
  elsif ($sig == SIG_DEACTIVATE)
    {
    $self->deactivate();
    return;				# don't relay this signal
    }

  # AND gate: all inputs must be in the same state to send the signal
  if ($self->{and} && scalar keys %{$self->{inputs}} > 1)
    {
    # store the signal at the input (for AND gate)
    $self->{input_states}->{$input} = $sig;
    # and check the others
    my $in = $self->{input_states};
    foreach my $i (keys %$in)
      {
      # if not all match yet, don't send signal
      return if ($in->{$i} != $sig);
      }
    }
  return unless $self->{active} == 1;	# inactive links don't send signals

  # if we need to always send the same signal, do so
  if (defined $self->{fixed_output})
    {
    $sig = $self->{fixed_output};
    }
  # otherwise we might need to invert the signal to be sent
  elsif ($self->{invert})
    {
    $sig = Games::3D::Signal::invert($sig);			# invert()
    }

  # need to delay sending, or send more than one time
  if ($self->{count} != 1 || $self->{delay} != 0)
    {
    timer()->add_timer(
      $self->{delay}, $self->{count}, $self->{repeat}, $self->{rand},
      sub
        {
        $self->output($input,$sig);
        },
     );
    }
  else
    {
    print '# ',$self->name()," relays ",signal_name($sig),
     " from $input to outputs.\n" if DEBUG;
    # Send signal straight away.
    $self->output($input,$sig);		# send $sig to all outputs
    }
  $self->deactivate() if $self->{once};
  }

sub link
  {
  my ($self,$src,$dst) = @_;

  $self->{inputs}->{$src->{id}} = $src;
  if ($self->{and} && scalar keys %{$self->{inputs}} > 1)
    {
    $self->{input_states}->{$src->{id}} = SIG_OFF;
    }
  $self->{outputs}->{$dst->{id}} = $dst;
  $src->add_output($self);			# the link appears as output
  $dst->add_input($self);			# and input at both ends
  }

sub unlink
  {
  # unlink all inputs and outputs from ourself
  my $self = shift;

  $self->SUPER::unlink();

  $self->{input_states} = {};
  $self;
  }

# override input() to also add the input state
sub add_input
  {
  my ($self,$src) = @_;

  $self->{inputs}->{$src->{id}} = $src;
  if ($self->{and} && scalar keys %{$self->{inputs}} > 1)
    {
    $self->{input_states}->{$src->{id}} = SIG_OFF;
    }
  $self;
  }

sub delay
  {
  # Sets the initial delay of the link, the delay for each consecutive signal,
  # and the randomized offset for these times.
  # Note that the second delay only comes into play if the
  # count() was set to a value different than 1, otherwise each firing of the
  # link will use the first delay again.
  my ($self,$delay,$rand,$repeat) = @_;

  $self->{delay} = abs($delay) if defined $delay;
  $self->{repeat} = abs($repeat) if defined $repeat;
  $self->{rand} = abs($rand) if defined $rand;
  ($self->{delay},$self->{repeat},$self->{rand});
  }

sub count
  {
  # Sets the count. If != 1, the outgoing signal will be resent coun() times,
  # each time delayed by a bit specified with delay(). A count of -1 means
  # infinitely.

  my $self = shift;

  if (defined $_[0])
    {
    $self->{count} = shift;
    }
  $self->{count};
  }

sub once
  {
  my $self = shift;

  $self->{once} = ($_[0] ? 1 : 0) if @_ > 0;
  $self->{once};
  }

sub invert
  {
  my $self = shift;

  $self->{invert} = $_[0] ? 1 : 0 if @_ > 0;
  $self->{invert};
  }

sub fixed_output
  {
  my $self = shift;

  $self->{fixed_output} = shift if @_ > 0;
  $self->{fixed_output};
  }

sub and_gate
  {
  my $self = shift;

  if (@_ > 0)
    {
    $self->{and} = $_[0] ? 1 : 0;
    }
  $self->{and};
  }

1;

__END__