SCX/Car.pm

   1 #!/usr/bin/perl -w
   2
   3 package SCX::Car;
   4
   5 use strict;
   6
   7 sub new {
   8         my ($class, $args) = @_;
   9
  10         my $self = {
  11                 gui      => $args->{gui},
  12                 driver   => $args->{driver} || '--',
  13                 throttle => undef,
  14                 button   => undef,
  15                 fuel     => 0,
  16                 lap      => 0,
  17                 laptime  => 0,
  18                 avg_lap  => 0,
  19                 car_img  => $args->{car_img},
  20                 id       => $args->{id},
  21                 track    => $args->{track},
  22         };
  23
  24         bless $self, $class;
  25
  26         $self->set_order($self->{id});
  27
  28         return $self;
  29 }
  30
  31 sub gui { return shift->{gui}; }
  32
  33 sub track { return shift->{track}; }
  34
  35 sub same {
  36         my ($self, $key, $val) = @_;
  37
  38         return 1 if !defined $self->{$key} && !defined $val
  39                 || (defined $self->{$key} && defined $val
  40                         && $self->{$key} eq $val);
  41
  42         $self->{$key} = $val;
  43         return undef;
  44 }
  45
  46 sub set_throttle {
  47         my ($self, $val, $button, $time) = @_;
  48
  49         return if $self->same('throttle', $val)
  50                 && $self->same('button', $button);
  51
  52         if ($self->track->{start_in_progress} && $val) {
  53                 $self->{early_start} = 1;
  54                 $self->gui->set_name($self->{order}, 'Early start!');
  55         }
  56
  57         if ($self->{in_pit_lane} && defined $val) {
  58                 $self->{last_finish_time} = $time;
  59                 if ($val > 3) {
  60                         $self->leave_pit_lane;
  61                 }
  62         }
  63
  64         $self->gui->set_throttle($self->{order}, $val, $button);
  65 }
  66
  67
  68 sub set_fuel {
  69         my ($self, $val) = @_;
  70
  71         return if $self->same('fuel', $val);
  72         $self->gui->set_fuel($self->{order}, $val);
  73 }
  74
  75 sub set_light {
  76         # TODO
  77 }
  78
  79 sub set_backbutton {
  80         # TODO
  81 }
  82
  83 sub set_model {
  84         my ($self, $name) = @_;
  85
  86         return if $self->same('car_img', $name);
  87         $self->gui->set_car_icon($self->{order}, $name);
  88 }
  89
  90 sub set_lap {
  91         my ($self, $lap_nr) = @_;
  92
  93         if (!$lap_nr) {
  94                 $self->{avg_lap} = undef;
  95                 $self->{lap} = $lap_nr;
  96                 $self->gui->set_avg_lap($self->{order}, undef);
  97                 $self->gui->set_lap($self->{order}, $lap_nr);
  98                 return;
  99         }
 100
 101         return if $self->same('lap', $lap_nr);
 102         if (defined $self->{lap} && defined $self->track->{race_rounds}
 103                 && $self->track->{race_rounds} > 0
 104                 && $self->{lap} > $self->track->{race_rounds}) {
 105                 $self->{finished} = 1;
 106                 $self->print_state;
 107         }
 108         $self->gui->set_lap($self->{order}, $lap_nr);
 109         if ($self->track->{race_running} && $self->{lap} > 1) {
 110                 my $now = $self->{last_finish_time};
 111                 my $avg = ($now - $self->track->{race_running_since})
 112                         / ($self->{lap} - 1);
 113                 $self->{avg_lap} = $avg;
 114                 $self->gui->set_avg_lap($self->{order}, $self->{avg_lap});
 115         }
 116 }
 117
 118 sub set_laptime {
 119         my ($self, $lap_time) = @_;
 120
 121         if (!defined $lap_time) {
 122                 $self->gui->set_best_lap($self->{order}, undef);
 123                 $self->{best_lap} = undef;
 124         }
 125
 126         return if $self->same('laptime', $lap_time);
 127
 128         $self->gui->set_laptime($self->{order}, $lap_time);
 129
 130         return if !defined $lap_time || $lap_time <= 1.0
 131                 || $self->{in_pit_lane};
 132
 133         return if $self->{finished};
 134
 135         return if defined $self->{best_lap} && $self->{best_lap} <= $lap_time;
 136
 137         $self->{best_lap} = $lap_time;
 138         my $global = $self->{track}->check_best_lap($lap_time,
 139                 $self->{driver});
 140
 141         $self->gui->set_best_lap($self->{order}, $lap_time, $global);
 142 }
 143
 144 sub set_driver {
 145         my ($self, $driver_name) = @_;
 146
 147         return if $self->same('driver', $driver_name);
 148         $self->gui->set_name($self->{order}, $driver_name);
 149 }
 150
 151 sub enter_pit_lane {
 152         my ($self) = @_;
 153
 154         return if $self->{in_pit_lane};
 155
 156         $self->{in_pit_lane} = 1;
 157         $self->print_state;
 158 }
 159
 160 sub leave_pit_lane {
 161         my ($self) = @_;
 162
 163         return if !$self->{in_pit_lane};
 164
 165         $self->{in_pit_lane} = 0;
 166         $self->print_state;
 167 }
 168
 169 sub set_order {
 170         my ($self, $pos) = @_;
 171
 172         $self->{order} = $pos;
 173
 174         $self->gui->set_name($self->{order}, $self->{driver});
 175         $self->gui->set_car_icon($self->{order}, $self->{car_img});
 176         $self->gui->set_throttle($self->{order}, $self->{throttle},
 177                 $self->{button});
 178         $self->gui->set_lap($self->{order}, $self->{lap});
 179         $self->gui->set_laptime($self->{order}, $self->{laptime});
 180         $self->gui->set_best_lap($self->{order}, $self->{best_lap});
 181         $self->gui->set_avg_lap($self->{order}, $self->{avg_lap});
 182         $self->gui->set_fuel($self->{order}, $self->{fuel});
 183         $self->gui->set_car_id($self->{order}, $self->{id} + 1);
 184         $self->gui->set_distance($self->{order},
 185                 $self->{time_diff}, $self->{lap_diff}, $self->{grey_diff});
 186         $self->print_state;
 187 }
 188
 189 sub print_state {
 190         my ($self) = @_;
 191
 192         if ($self->{in_pit_lane}) {
 193                 $self->{state} = 'pit';
 194         } elsif ($self->{finished}) {
 195                 $self->{state} = 'finished';
 196         } elsif ($self->{early_start}) {
 197                 $self->{state} = 'disqualified';
 198         } else {
 199                 $self->{state} = 'greenflag';
 200         }
 201
 202         $self->gui->set_state($self->{order}, $self->{state});
 203 }
 204
 205 sub reset {
 206         my ($self) = @_;
 207
 208         $self->set_lap(0);
 209         $self->set_laptime(undef);
 210         $self->{finished} = 0;
 211         $self->{in_pit_lane} = 0;
 212         $self->{early_start} = undef;
 213         $self->{last_finish_time} = undef;
 214         $self->{first_finish_time} = undef;
 215         $self->{time_diff} = undef;
 216         $self->{lap_diff} = undef;
 217         $self->{total_time} = undef;
 218         $self->{grey_diff} = undef;
 219 }
 220
 221 sub finish_line {
 222         my ($self, $time, $regular) = @_;
 223
 224         if (defined $self->{last_finish_time}
 225                 && $time - $self->{last_finish_time} < 2) {
 226
 227                 $self->{last_finish_time} = $time;
 228                 if ($regular && $self->{in_pit_lane}) {
 229                         $self->leave_pit_lane;
 230                 }
 231                 return undef;
 232         }
 233
 234         if ($regular) {
 235                 if (defined $self->{first_finish_time}) {
 236                         $self->set_laptime($time - $self->{first_finish_time});
 237                 }
 238         } else {
 239                 $self->enter_pit_lane;
 240         }
 241
 242         $self->{first_finish_time} = $self->{last_finish_time} = $time;
 243
 244         if ($self->track->{race_running}) {
 245                 $self->set_lap($self->{lap} + 1);
 246         } elsif ($self->track->{qualification_running} && !$self->{finished}) {
 247                 $self->set_lap($self->{lap} + 1);
 248                 if ($self->{lap} > $self->track->{race_rounds}) {
 249                         $self->{finished} = 1;
 250                         $self->print_state;
 251                 }
 252         }
 253
 254         return 1;
 255 }
 256
 257 sub recalc_distance {
 258         my ($self, $lap_first, $time_first, $finishing) = @_;
 259
 260         return if !defined $lap_first || !defined $self->{lap}
 261                 || !defined $time_first || !defined $self->{first_finish_time};
 262
 263         $self->{total_time} = undef;
 264         $self->{lap_diff} = undef;
 265         $self->{time_diff} = undef;
 266         $self->{grey_diff} = undef;
 267
 268         if ($self->{lap} == $lap_first) {
 269                 if ($self->{first_finish_time} == $time_first) {
 270                         $self->{total_time} = $self->{first_finish_time}
 271                                 - $self->track->{race_running_since};
 272                 } else {
 273                         $self->{time_diff} = $self->{first_finish_time}
 274                                 - $time_first;
 275                 }
 276         } else {
 277                 $self->{lap_diff} = $lap_first - $self->{lap};
 278         }
 279
 280         $self->gui->set_distance($self->{order}, $self->{total_time},
 281                 $self->{lap_diff}, $self->{time_diff}, $self->{grey_diff});
 282
 283         if ($finishing) {
 284                 $self->{finished} = 1;
 285                 $self->print_state;
 286         }
 287 }
 288
 289 sub recalc_qual_distance {
 290         my ($self, $time_first) = @_;
 291
 292         return if !defined $self->{best_lap} || $self->{best_lap} <= 0;
 293
 294         $self->{total_time} = undef;
 295         $self->{time_diff} = undef;
 296         $self->{grey_diff} = undef;
 297         $self->{lap_diff} = undef;
 298
 299         if ($self->{best_lap} == $time_first) {
 300                 $self->{total_time} = $self->{best_lap};
 301         } else {
 302                 $self->{time_diff} = $self->{best_lap} - $time_first;
 303         }
 304
 305         $self->gui->set_distance($self->{order}, $self->{total_time},
 306                 $self->{lap_diff}, $self->{time_diff}, $self->{grey_diff});
 307 }
 308
 309 sub greyout_distance {
 310         my ($self) = @_;
 311
 312         return if $self->{grey_diff};
 313         $self->{grey_diff} = 1;
 314         $self->gui->set_distance($self->{order}, $self->{total_time},
 315                 $self->{lap_diff}, $self->{time_diff}, $self->{grey_diff});
 316 }
 317
 318 1;
 319