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         my $prev = $self->{fuel};
  72         return if $self->same('fuel', $val);
  73         if (defined $val && defined $prev && $val < 8) {
  74                 if ($val == $prev + 1 && !$self->{in_pit_lane}) {
  75                         print STDERR $self->track->{now}, ' car ',
  76                                 $self->{id}, ' missed pit lane entry', "\n";
  77                         $self->enter_pit_lane;
  78                 }
  79         }
  80
  81         $self->gui->set_fuel($self->{order}, $val);
  82 }
  83
  84 sub set_light {
  85         # TODO
  86 }
  87
  88 sub set_backbutton {
  89         # TODO
  90 }
  91
  92 sub set_model {
  93         my ($self, $name) = @_;
  94
  95         return if $self->same('car_img', $name);
  96         $self->gui->set_car_icon($self->{order}, $name);
  97 }
  98
  99 sub set_lap {
 100         my ($self, $lap_nr) = @_;
 101
 102         if (!$lap_nr) {
 103                 $self->{avg_lap} = undef;
 104                 $self->{lap} = $lap_nr;
 105                 $self->gui->set_avg_lap($self->{order}, undef);
 106                 $self->gui->set_lap($self->{order}, $lap_nr);
 107                 return;
 108         }
 109
 110         return if $self->same('lap', $lap_nr);
 111         if (defined $self->{lap} && defined $self->track->{race_rounds}
 112                 && $self->track->{race_rounds} > 0
 113                 && $self->{lap} > $self->track->{race_rounds}) {
 114                 $self->{finished} = 1;
 115                 $self->print_state;
 116         }
 117         $self->gui->set_lap($self->{order}, $lap_nr);
 118         if ($self->track->{race_running} && $self->{lap} > 1) {
 119                 my $now = $self->{last_finish_time};
 120                 my $avg = ($now - $self->track->{race_running_since})
 121                         / ($self->{lap} - 1);
 122                 $self->{avg_lap} = $avg;
 123                 $self->gui->set_avg_lap($self->{order}, $self->{avg_lap});
 124         }
 125 }
 126
 127 sub set_laptime {
 128         my ($self, $lap_time) = @_;
 129
 130         if (!defined $lap_time) {
 131                 $self->gui->set_best_lap($self->{order}, undef);
 132                 $self->{best_lap} = undef;
 133         }
 134
 135         return if $self->same('laptime', $lap_time);
 136
 137         $self->gui->set_laptime($self->{order}, $lap_time);
 138
 139         return if !defined $lap_time || $lap_time <= 1.0
 140                 || $self->{in_pit_lane};
 141
 142         return if $self->{finished};
 143
 144         return if defined $self->{best_lap} && $self->{best_lap} <= $lap_time;
 145
 146         $self->{best_lap} = $lap_time;
 147         my $global = $self->{track}->check_best_lap($lap_time,
 148                 $self->{driver});
 149
 150         $self->gui->set_best_lap($self->{order}, $lap_time, $global);
 151 }
 152
 153 sub set_driver {
 154         my ($self, $driver_name) = @_;
 155
 156         return if $self->same('driver', $driver_name);
 157         $self->gui->set_name($self->{order}, $driver_name);
 158 }
 159
 160 sub enter_pit_lane {
 161         my ($self) = @_;
 162
 163         return if $self->{in_pit_lane};
 164
 165         $self->{in_pit_lane} = 1;
 166         $self->print_state;
 167 }
 168
 169 sub leave_pit_lane {
 170         my ($self) = @_;
 171
 172         return if !$self->{in_pit_lane};
 173
 174         $self->{in_pit_lane} = 0;
 175         $self->print_state;
 176 }
 177
 178 sub set_order {
 179         my ($self, $pos) = @_;
 180
 181         $self->{order} = $pos;
 182
 183         $self->gui->set_name($self->{order}, $self->{driver});
 184         $self->gui->set_car_icon($self->{order}, $self->{car_img});
 185         $self->gui->set_throttle($self->{order}, $self->{throttle},
 186                 $self->{button});
 187         $self->gui->set_lap($self->{order}, $self->{lap});
 188         $self->gui->set_laptime($self->{order}, $self->{laptime});
 189         $self->gui->set_best_lap($self->{order}, $self->{best_lap});
 190         $self->gui->set_avg_lap($self->{order}, $self->{avg_lap});
 191         $self->gui->set_fuel($self->{order}, $self->{fuel});
 192         $self->gui->set_car_id($self->{order}, $self->{id} + 1);
 193         $self->gui->set_distance($self->{order},
 194                 $self->{time_diff}, $self->{lap_diff}, $self->{grey_diff});
 195         $self->print_state;
 196 }
 197
 198 sub print_state {
 199         my ($self) = @_;
 200
 201         if ($self->{in_pit_lane}) {
 202                 $self->{state} = 'pit';
 203         } elsif ($self->{finished}) {
 204                 $self->{state} = 'finished';
 205         } elsif ($self->{early_start}) {
 206                 $self->{state} = 'disqualified';
 207         } else {
 208                 $self->{state} = 'greenflag';
 209         }
 210
 211         $self->gui->set_state($self->{order}, $self->{state});
 212 }
 213
 214 sub reset {
 215         my ($self) = @_;
 216
 217         $self->set_lap(0);
 218         $self->set_laptime(undef);
 219         $self->{finished} = 0;
 220         $self->{in_pit_lane} = 0;
 221         $self->{early_start} = undef;
 222         $self->{last_finish_time} = undef;
 223         $self->{first_finish_time} = undef;
 224         $self->{time_diff} = undef;
 225         $self->{lap_diff} = undef;
 226         $self->{total_time} = undef;
 227         $self->{grey_diff} = undef;
 228         $self->print_state;
 229 }
 230
 231 sub finish_line {
 232         my ($self, $time, $regular) = @_;
 233
 234         if (defined $self->{last_finish_time}
 235                 && $time - $self->{last_finish_time} < 2) {
 236
 237                 $self->{last_finish_time} = $time;
 238                 if ($regular && $self->{in_pit_lane}) {
 239                         $self->leave_pit_lane;
 240                 }
 241                 return undef;
 242         }
 243
 244         if ($regular) {
 245                 if (defined $self->{first_finish_time}) {
 246                         $self->set_laptime($time - $self->{first_finish_time});
 247                 }
 248         } else {
 249                 $self->enter_pit_lane;
 250         }
 251
 252         $self->{first_finish_time} = $self->{last_finish_time} = $time;
 253
 254         if ($self->track->{race_running}) {
 255                 $self->set_lap($self->{lap} + 1);
 256         } elsif ($self->track->{qualification_running} && !$self->{finished}) {
 257                 $self->set_lap($self->{lap} + 1);
 258                 if ($self->{lap} > $self->track->{race_rounds}) {
 259                         $self->{finished} = 1;
 260                         $self->print_state;
 261                 }
 262         }
 263
 264         return 1;
 265 }
 266
 267 sub recalc_distance {
 268         my ($self, $lap_first, $time_first, $finishing) = @_;
 269
 270         return if !defined $lap_first || !defined $self->{lap}
 271                 || !defined $time_first || !defined $self->{first_finish_time};
 272
 273         $self->{total_time} = undef;
 274         $self->{lap_diff} = undef;
 275         $self->{time_diff} = undef;
 276         $self->{grey_diff} = undef;
 277
 278         if ($self->{lap} == $lap_first) {
 279                 if ($self->{first_finish_time} == $time_first) {
 280                         $self->{total_time} = $self->{first_finish_time}
 281                                 - $self->track->{race_running_since};
 282                 } else {
 283                         $self->{time_diff} = $self->{first_finish_time}
 284                                 - $time_first;
 285                 }
 286         } else {
 287                 $self->{lap_diff} = $lap_first - $self->{lap};
 288         }
 289
 290         $self->gui->set_distance($self->{order}, $self->{total_time},
 291                 $self->{lap_diff}, $self->{time_diff}, $self->{grey_diff});
 292
 293         if ($finishing) {
 294                 $self->{finished} = 1;
 295                 $self->print_state;
 296         }
 297 }
 298
 299 sub recalc_qual_distance {
 300         my ($self, $time_first) = @_;
 301
 302         return if !defined $self->{best_lap} || $self->{best_lap} <= 0;
 303
 304         $self->{total_time} = undef;
 305         $self->{time_diff} = undef;
 306         $self->{grey_diff} = undef;
 307         $self->{lap_diff} = undef;
 308
 309         if ($self->{best_lap} == $time_first) {
 310                 $self->{total_time} = $self->{best_lap};
 311         } else {
 312                 $self->{time_diff} = $self->{best_lap} - $time_first;
 313         }
 314
 315         $self->gui->set_distance($self->{order}, $self->{total_time},
 316                 $self->{lap_diff}, $self->{time_diff}, $self->{grey_diff});
 317 }
 318
 319 sub greyout_distance {
 320         my ($self) = @_;
 321
 322         return if $self->{grey_diff};
 323         $self->{grey_diff} = 1;
 324         $self->gui->set_distance($self->{order}, $self->{total_time},
 325                 $self->{lap_diff}, $self->{time_diff}, $self->{grey_diff});
 326 }
 327
 328 1;
 329