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