sub calcskill_kill_default {
        my ($self,$k,$v,$w) = @_;

        my $kskill = $k->skill || $self->{baseskill};
        my $vskill = $v->skill || $self->{baseskill};

        my $diff = $kskill - $vskill;                                   # difference in skill
        my $prob = 1 / ( 1 + 10 ** ($diff / $self->{baseskill}) );      # find probability of kill
        my $kadj = $self->{_adj}->[-1] || 100;
        my $vadj = $self->{_adj}->[-1] || 100;
        my $kmins = int $k->totaltime / 60;
        my $vmins = int $v->totaltime / 60;
        my $idx = 0;
        foreach my $level (@{$self->{_adj_onlinetime}}) {
                if ($kmins >= $level) {
                        $kadj = $self->{_adj}->[$idx];
#                       print "level: " . ("\t" x $idx+1) . "$level\n";
                        last;
                }
                $idx++;
        }
        $idx = 0;
        foreach my $level (@{$self->{_adj_onlinetime}}) {
                if ($vmins >= $level) {
                        $vadj = $self->{_adj}->[$idx];
#                       print "level: " . ("\t" x $idx+1) . "$level\n";
                        last;
                }
                $idx++;
        }

        my $kbonus = $kadj * $prob;
        my $vbonus = $vadj * $prob;

        my $weight = $w->weight;
        if (defined $weight and $weight != 0.0 and $weight != 1.0) {
                $kbonus *= $weight;
                $vbonus *= $weight;
        }

        $kskill += $kbonus;
        $vskill -= $vbonus;

        $k->skill($kskill);
        $v->skill($vskill);
}

sub calcskill_kill_default_init {
        my ($self) = @_;

        # initialize the adjustment levels for the ELO calculations
        $self->{_adj_onlinetime} = [];
        $self->{_adj} = [];
        foreach my $key (sort grep { /^kill_onlinetime_\d+$/ } keys %{$self->{skillcalc}}) {
                my $num = ($key =~ /(\d+)$/)[0];
                my $adjkey = "kill_adj_$num";
                next unless exists $self->{skillcalc}{$adjkey};                 # only allow matching adjustments
                push(@{$self->{_adj}}, $self->{skillcalc}{$adjkey});
                push(@{$self->{_adj_onlinetime}}, $self->{skillcalc}{$key});
        }
}

sub calcskill_kill_alternative {
        my ($self,$k,$v,$w) = @_;
        my ($kbonus, $vbonus);

        my $kskill = $k->skill || $self->{baseskill};
        my $vskill = $v->skill || $self->{baseskill};

        # don't allow player skill to go negative ...
        $kskill = 1 if $kskill < 1;
        $vskill = 1 if $vskill < 1;

        if ($kskill > $vskill) {
                # killer is better than the victim
                $kbonus = ($kskill + $vskill)**2 / $kskill**2;
                $vbonus = $kbonus * $vskill / ($vskill + $kskill);
        } else {
                # the victim is better than the killer
                $kbonus = ($vskill + $kskill)**2 / $vskill**2 * $vskill / $kskill;
                $vbonus = $kbonus * ($vskill + $self->{baseskill}) / ($vskill + $kskill);
        }

        # do not allow the victim to lose more than X points
        $vbonus = 10 if $vbonus > 10;

        $vbonus = $vskill if $vbonus > $vskill;
        $kbonus = $kskill if $kbonus > $kskill;

        # apply weapon weight to skill bonuses
        my $weight = $w->weight;
        if ($weight) {
                $kbonus *= $weight;
                $vbonus *= $weight;
        }

        $kskill += $kbonus;
        $vskill -= $vbonus;

        $k->skill($kskill);
        $v->skill($vskill);
}

# This is an example of how to create a skill calculation formula.
# Follow the comments below for details.
#
# NOTE:
#       calcskill_kill_NAME function is called for EVERY KILL EVENT.
#       calcskill_kill_NAME_init function is called once before any logs are processed.

# The name of the subroutine below should be the same as the filename w/o the ".pl" extension.
# The filename must always have the format of "calcskill_kill_BASENAME" where BASENAME is
# the unique name of the calculation, which is what is used as the configuration option.
sub calcskill_kill_example {
        # $self is a reference to the current PS::Game object.
        # $killer and $victim are references to PS::Player objects.
        # $weapon is a reference to a PS::Weapon object that was used to kill the victim.
        my ($self,$killer,$victim,$weapon) = @_;

        # always make sure the skill values default to the base value
        # if they have no skill to begin with.
        my $kskill = $killer->skill || $self->{baseskill};
        my $vskill = $victim->skill || $self->{baseskill};

        # do some calculations and determine the new values of skill
        # this example assigns 0 bonus to each player.
        my $vbonus = 0;
        my $kbonus = 0;

        # add the bonus to the killer
        $kskill += $kbonus;

        # subtract the bonus from the victim
        $vskill -= $vbonus;

        # apply the new absolute skill values to the players
        $killer->skill($kskill);
        $victim->skill($vskill);

        # that's it!, all done. Do not return anything from this function.
}

# optional INIT function. You do not need to include an init function
# if you do not need to initialize any variables before logs are processed.
# The name of the init function is calcskill_kill_BASENAME_init
# where BASENAME is the same as the function above.
sub calcskill_kill_example_init {
        # $self is a reference to the current PS::Game object.
        my ($self) = @_;
}

# Any other code in this file is run from within the PS::Game context
# (eg: $self will reference the PS::Game object). However, it's not
# recommended to include any code outside of the init function. Any extra
# functions defined here are automatically a PS::Game method.