DriverBrain.cs

Siirry tämän tiedoston dokumentaatioon.

using System;
using System.Collections.Generic;
 
namespace Jypeli.Assets
{
    public class DriverBrain : Brain
    {
        private List<PhysicsObject> chkpoints;
 
        public List<PhysicsObject> Checkpoints
        {
            get { return chkpoints; }
            set
            {
                chkpoints = value;
                CheckpointsPassed.Value = 0;
                CheckpointsPassed.MaxValue = value.Count;
            }
        }
 
        public PhysicsObject NextCheckpoint
        {
            get
            {
                return ( CheckpointsPassed.Value < Checkpoints.Count ) ? Checkpoints[CheckpointsPassed.Value] : null;
            }
        }
 
        public IntMeter RoundsDriven { get; set; }
 
        public IntMeter CheckpointsPassed { get; set; }
 
 
        public DriverBrain( List<PhysicsObject> checkpoints, int rounds )
        {
            RoundsDriven = new IntMeter( 0 );
            RoundsDriven.MaxValue = rounds;
 
            CheckpointsPassed = new IntMeter( 0 );
            CheckpointsPassed.MaxValue = 1;
            CheckpointsPassed.UpperLimit += nextRound;
 
            Checkpoints = checkpoints;
        }
 
        private void nextRound()
        {
            CheckpointsPassed.Reset();
            ++RoundsDriven.Value;
        }
 
        public override void OnCollision( IGameObject target )
        {            
            if ( target == NextCheckpoint )
            {
                // Checkpoint reached, set next
                CheckpointsPassed.MaxValue = Checkpoints.Count;
                ++CheckpointsPassed.Value;
            }
 
            base.OnCollision( target );
        }
    }
 
    public class ComputerDriverBrain : DriverBrain
    {
        public ComputerDriverBrain( List<PhysicsObject> checkpoints, int rounds )
            : base( checkpoints, rounds )
        {
        }
 
        protected override void Update( Time time )
        {
            Automobile OwnerAuto = Owner as Automobile;
 
            if ( OwnerAuto != null )
            {
                Vector distance = NextCheckpoint.Position - OwnerAuto.Position;
                Angle turnAngle = distance.Angle - OwnerAuto.Angle;
 
                double dt = time.SinceLastUpdate.TotalSeconds;
                double dist = Math.Max( distance.Magnitude, Double.Epsilon );
                double spd = Math.Max( OwnerAuto.Velocity.Magnitude, Double.Epsilon );
                double eta = dist / spd;
                double braketime = spd / OwnerAuto.BrakeDeceleration;
                double turntime = Math.Abs( turnAngle.Radians ) / OwnerAuto.Maneuverability.Radians;                
 
                if ( turntime >= eta || braketime * OwnerAuto.KineticFriction >= eta )
                {
                    OwnerAuto.Brake( dt );
                }
 
                else
                {
                    OwnerAuto.Accelerate( dt );
                }
 
                OwnerAuto.Turn( turnAngle, dt );
            }
 
            base.Update( time );
        }
    }
}