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->gui->set_best_lap($self->{order}, undef);
 125                 $self->{best_lap} = undef;
 126         }
 127
 128         return if $self->same('laptime', $lap_time);
 129
 130         $self->gui->set_laptime($self->{order}, $lap_time);
 131
 132         return if !defined $lap_time || $lap_time <= 1.0
 133                 || $self->{in_pit_lane};
 134
 135         return if $self->{finished};
 136
 137         return if defined $self->{best_lap} && $self->{best_lap} <= $lap_time;
 138
 139         $self->{best_lap} = $lap_time;
 140         my $global = $self->{track}->check_best_lap($lap_time,
 141                 $self->{driver});
 142
 143         $self->gui->set_best_lap($self->{order}, $lap_time, $global);
 144 }
 145
 146 sub set_driver {
 147         my ($self, $driver_name) = @_;
 148
 149         return if $self->same('driver', $driver_name);
 150         $self->gui->set_name($self->{order}, $driver_name);
 151 }
 152
 153 sub enter_pit_lane {
 154         my ($self) = @_;
 155
 156         return if $self->{in_pit_lane};
 157
 158         $self->{in_pit_lane} = 1;
 159         $self->print_state;
 160 }
 161
 162 sub leave_pit_lane {
 163         my ($self) = @_;
 164
 165         return if !$self->{in_pit_lane};
 166
 167         $self->{in_pit_lane} = 0;
 168         $self->print_state;
 169 }
 170
 171 sub set_order {
 172         my ($self, $pos) = @_;
 173
 174         $self->{order} = $pos;
 175
 176         $self->gui->set_name($self->{order}, $self->{driver});
 177         $self->gui->set_car_icon($self->{order}, $self->{car_img});
 178         $self->gui->set_throttle($self->{order}, $self->{throttle},
 179                 $self->{button});
 180         $self->gui->set_lap($self->{order}, $self->{lap});
 181         $self->gui->set_laptime($self->{order}, $self->{laptime});
 182         $self->gui->set_best_lap($self->{order}, $self->{best_lap});
 183         $self->gui->set_fuel($self->{order}, $self->{fuel});
 184         $self->gui->set_car_id($self->{order}, $self->{id} + 1);
 185         $self->gui->set_distance($self->{order},
 186                 $self->{time_diff}, $self->{lap_diff}, $self->{grey_diff});
 187         $self->print_state;
 188 }
 189
 190 sub print_state {
 191         my ($self) = @_;
 192
 193         if ($self->{in_pit_lane}) {
 194                 $self->{state} = 'pit';
 195         } elsif ($self->{finished}) {
 196                 $self->{state} = 'finished';
 197         } elsif ($self->{early_start}) {
 198                 $self->{state} = 'disqualified';
 199         } else {
 200                 $self->{state} = 'greenflag';
 201         }
 202
 203         $self->gui->set_state($self->{order}, $self->{state});
 204 }
 205
 206 sub reset {
 207         my ($self) = @_;
 208
 209         $self->set_lap(0);
 210         $self->set_laptime(undef);
 211         $self->{finished} = 0;
 212         $self->{in_pit_lane} = 0;
 213         $self->{early_start} = undef;
 214         $self->{last_finish_time} = undef;
 215         $self->{first_finish_time} = undef;
 216         $self->{time_diff} = undef;
 217         $self->{lap_diff} = undef;
 218         $self->{total_time} = undef;
 219         $self->{grey_diff} = undef;
 220         $self->print_state;
 221 }
 222
 223 sub finish_line {
 224         my ($self, $time, $regular) = @_;
 225
 226         if (defined $self->{last_finish_time}
 227                 && $time - $self->{last_finish_time} < 2) {
 228
 229                 $self->{last_finish_time} = $time;
 230                 if ($regular && $self->{in_pit_lane}) {
 231                         $self->leave_pit_lane;
 232                 }
 233                 return undef;
 234         }
 235
 236         if ($regular) {
 237                 if (defined $self->{first_finish_time}) {
 238                         $self->set_laptime($time - $self->{first_finish_time});
 239                 }
 240         } else {
 241                 $self->enter_pit_lane;
 242         }
 243
 244         $self->{first_finish_time} = $self->{last_finish_time} = $time;
 245
 246         if ($self->track->{race_running}) {
 247                 $self->set_lap($self->{lap} + 1);
 248         } elsif ($self->track->{qualification_running} && !$self->{finished}) {
 249                 $self->set_lap($self->{lap} + 1);
 250                 if ($self->{lap} > $self->track->{race_rounds}) {
 251                         $self->{finished} = 1;
 252                         $self->print_state;
 253                 }
 254         }
 255
 256         return 1;
 257 }
 258
 259 sub recalc_distance {
 260         my ($self, $lap_first, $time_first, $finishing) = @_;
 261
 262         return if !defined $lap_first || !defined $self->{lap}
 263                 || !defined $time_first || !defined $self->{first_finish_time};
 264
 265         $self->{total_time} = undef;
 266         $self->{lap_diff} = undef;
 267         $self->{time_diff} = undef;
 268         $self->{grey_diff} = undef;
 269
 270         if ($self->{lap} == $lap_first) {
 271                 if ($self->{first_finish_time} == $time_first) {
 272                         $self->{total_time} = $self->{first_finish_time}
 273                                 - $self->track->{race_running_since};
 274                 } else {
 275                         $self->{time_diff} = $self->{first_finish_time}
 276                                 - $time_first;
 277                 }
 278         } else {
 279                 $self->{lap_diff} = $lap_first - $self->{lap};
 280         }
 281
 282         $self->gui->set_distance($self->{order}, $self->{total_time},
 283                 $self->{lap_diff}, $self->{time_diff}, $self->{grey_diff});
 284
 285         if ($finishing) {
 286                 $self->{finished} = 1;
 287                 $self->print_state;
 288         }
 289 }
 290
 291 sub recalc_qual_distance {
 292         my ($self, $time_first) = @_;
 293
 294         return if !defined $self->{best_lap} || $self->{best_lap} <= 0;
 295
 296         $self->{total_time} = undef;
 297         $self->{time_diff} = undef;
 298         $self->{grey_diff} = undef;
 299         $self->{lap_diff} = undef;
 300
 301         if ($self->{best_lap} == $time_first) {
 302                 $self->{total_time} = $self->{best_lap};
 303         } else {
 304                 $self->{time_diff} = $self->{best_lap} - $time_first;
 305         }
 306
 307         $self->gui->set_distance($self->{order}, $self->{total_time},
 308                 $self->{lap_diff}, $self->{time_diff}, $self->{grey_diff});
 309 }
 310
 311 sub greyout_distance {
 312         my ($self) = @_;
 313
 314         return if $self->{grey_diff};
 315         $self->{grey_diff} = 1;
 316         $self->gui->set_distance($self->{order}, $self->{total_time},
 317                 $self->{lap_diff}, $self->{time_diff}, $self->{grey_diff});
 318 }
 319
 320 1;
 321