Beispiel #1
0
        public new void Tick(int FrameCount)
        {
            base.Tick(FrameCount);

            if (this.SubClassData == null)
            {
                if (this.Data == null)
                {
                    return;
                }
                SubClassData = Data as ProjectileTowerData;
            }

            if (ProjectileColor == Colors.Transparent)
            {
                ProjectileColor = System.Windows.Media.Color.FromRgb((byte)R.Next(255), (byte)R.Next(255), (byte)R.Next(255));
                // Arena.instance.AddToArena(TargetLaserD);
                //Arena.instance.AddToArena(TargetLaserB);
            }



            if (RefireCount > 0)
            {
                RefireCount--;
            }


            CurrentTarget = null;
            double TXV;
            double TYV;
            double V;

            //System.Windows.Media.Color bc = Color.FromScRgb(1f, (float)(Heat / Data.ShutdownHeat), 0f, 0f);//(float)(Target.LockDuration / 255)
            //Body.Fill = new System.Windows.Media.SolidColorBrush(HeatColor(Heat, Data.ShutdownHeat));
            Body.Fill = StaticHelpers.HeatBrush(Heat, Data.ShutdownHeat);

            // Are we already locked on?
            if (Target.LockedTarget != null && Target.LockedTarget.IsAlive == true)
            {
                // is the locked target still in range?
                TXV = (Target.LockedTarget.XPos - PivotPoint.X);
                TYV = (Target.LockedTarget.YPos - PivotPoint.Y);
                V   = (TXV)*(TXV) + (TYV)*(TYV);
                if (V < (SubClassData.Range * SubClassData.Range))
                {
                    CurrentTarget = Target.LockedTarget;
                    Target.LockDuration++;
                }
            }

            // Find a new target
            if (CurrentTarget == null)
            {
                CurrentTarget       = NearestCreep(SubClassData.Range);
                Target.LockedTarget = CurrentTarget;
                Target.LockDuration = 0;
                return;
            }

            // No valid targets
            if (CurrentTarget == null)
            {
                // Body.Fill = Brushes.Blue;
                return;
            }

            Point TargetPoint = new Point(CurrentTarget.XPos, CurrentTarget.YPos);

            //lastsetrotation = new CoercedAngle(StaticHelpers.Angle(PivotPoint, TargetPoint));


            if (Target.LockDuration > 0)
            {
                float MuzzleVelocity = 25;

                //     TargetLaserB.X1 = this.PivotPoint.X;
                //     TargetLaserB.Y1 = this.PivotPoint.Y;
                //    TargetLaserB.X2 = CurrentTarget.XPos;
                //    TargetLaserB.Y2 = CurrentTarget.YPos;
                //    TargetLaserB.Stroke = Brushes.Green;
                //    TargetLaserB.StrokeThickness = 1;



                //calculate the distance to the target
                TXV = (CurrentTarget.XPos - PivotPoint.X);
                TYV = (CurrentTarget.YPos - PivotPoint.Y);
                V   = Math.Sqrt((TXV)*(TXV) + (TYV)*(TYV));

                //calculate the targets velocity
                double VelocityX = TXV - Target.LockedTargetPriorX;
                double VelocityY = TYV - Target.LockedTargetPriorY;

                //save the current position to calc velocity next frame
                Target.LockedTargetPriorX = TXV;
                Target.LockedTargetPriorY = TYV;


                // calculate where the target will be in the time it takes the projectile to travel to it's current location.
                double ExPosX = CurrentTarget.XPos + (VelocityX * V / MuzzleVelocity);
                double ExPosY = CurrentTarget.YPos + (VelocityY * V / MuzzleVelocity);

                TargetPoint = new Point(ExPosX, ExPosY);

                //     TargetLaserA.X1 = this.PivotPoint.X;
                //     TargetLaserA.Y1 = this.PivotPoint.Y;
                //      TargetLaserA.X2 = ExPosX;
                //      TargetLaserA.Y2 = ExPosY;
                //      TargetLaserA.Stroke = Brushes.Red;
                //       TargetLaserA.StrokeThickness = 1;
                //Arena.instance.AddToArena(TargetLaserA);


                //calculate the distance to the new position.
                TXV = (ExPosX - PivotPoint.X);
                TYV = (ExPosY - PivotPoint.Y);
                V   = Math.Sqrt((TXV)*(TXV) + (TYV)*(TYV));

                // re-calculate where the target will be in the time it takes the projectile to travel to it's current location.
                ExPosX = CurrentTarget.XPos + (VelocityX * V / MuzzleVelocity);
                ExPosY = CurrentTarget.YPos + (VelocityY * V / MuzzleVelocity);

                //       TargetLaserC.X1 = this.PivotPoint.X;
                //       TargetLaserC.Y1 = this.PivotPoint.Y;
                //       TargetLaserC.X2 = ExPosX;
                //       TargetLaserC.Y2 = ExPosY;
                //       TargetLaserC.Stroke = Brushes.Blue;
                //       TargetLaserC.StrokeThickness = 1;
                //Arena.instance.AddToArena(TargetLaserC);

                //calculate the distance to the new position.
                TXV = (ExPosX - PivotPoint.X);
                TYV = (ExPosY - PivotPoint.Y);
                V   = Math.Sqrt((TXV)*(TXV) + (TYV)*(TYV));

                // re-re-calculate where the target will be in the time it takes the projectile to travel to it's current location.
                ExPosX = CurrentTarget.XPos + (VelocityX * V / MuzzleVelocity);
                ExPosY = CurrentTarget.YPos + (VelocityY * V / MuzzleVelocity);

                //        TargetLaserD.X1 = this.PivotPoint.X;
                //        TargetLaserD.Y1 = this.PivotPoint.Y;
                //        TargetLaserD.X2 = ExPosX;
                //        TargetLaserD.Y2 = ExPosY;
                //         TargetLaserD.Stroke = Brushes.White;
                //         TargetLaserD.StrokeThickness = 1;

                //      DoubleCollection dc = new DoubleCollection();
                //     dc.Add(1);
                //      dc.Add(4);

                //      TargetLaserD.StrokeDashArray = dc;



                TargetPoint = new Point(ExPosX, ExPosY);


                // Rotate barrel if not aligned with leading point.
                if (!IsAlignedTo(TargetPoint, SubClassData.TrackingSpeed))
                {
                    CoercedAngle diff = new CoercedAngle(StaticHelpers.Angle(PivotPoint, TargetPoint) - currentrotation.Angle);
                    if (diff.Angle > 180)
                    {
                        currentrotation.Angle -= SubClassData.TrackingSpeed;
                    }
                    else
                    {
                        currentrotation.Angle += SubClassData.TrackingSpeed;
                    }
                    //  Body.Fill = Brushes.Yellow;
                    Barrel.RenderTransform = new RotateTransform(currentrotation.Angle);
                    //return;
                }
                else
                {
                    // We are aligned (within tracking speed margin of error) with the targets predicted position.
                    currentrotation.Angle       = StaticHelpers.Angle(PivotPoint, TargetPoint);
                    this.Barrel.RenderTransform = new RotateTransform(StaticHelpers.Angle(PivotPoint, TargetPoint));

                    //Are we ready to fire?
                    if (RefireCount <= 0 && Target.LockDuration > 1 && this.Heat <= this.Data.ShutdownHeat)
                    {
                        //FIRE!!!
                        Projectile P = Projectile.Create(
                            FrameCount,
                            (float)PivotPoint.X,
                            (float)PivotPoint.Y,
                            (float)(TXV / V) * (float)MuzzleVelocity,
                            (float)(TYV / V) * (float)MuzzleVelocity,
                            Projectile.GenericHitCreep
                            );
                        RefireCount = SubClassData.RefireDelay;
                        this.Heat  += this.SubClassData.FiringHeat;
                    }
                }
            }
        }
        public HeatTowerData SubClassData;// = new ProjectileTowerData();
        //   public TargetLock Target = new TargetLock();

        //    public Creep CurrentTarget;

        // public Shape Barrel;

        //  public float RefireCount = 0;

        //  static Random R = new Random();
        //   System.Windows.Media.Color ProjectileColor = Colors.Transparent;



        public new void Tick(int Frame)
        {
            if (this.SubClassData == null)
            {
                if (this.Data == null)
                {
                    return;
                }
                SubClassData = Data as HeatTowerData;
            }



            //Shape bb = LogicalTreeHelper.FindLogicalNode(VisualObject, "_Grill") as Shape;

            //Body.Fill = new System.Windows.Media.VisualBrush(this);
            //System.Windows.Media.Color bc = Color.FromScRgb(1f, (float)(Heat / Data.ShutdownHeat), 0f, 0f);
            //Body.Fill = new System.Windows.Media.SolidColorBrush(bc);

            List <Tower> HotNeighbor       = new List <Tower>();
            float        TotalNeighborHeat = 0;

            float startingheat        = this.Heat;
            float HottestNeighborHeat = 0;

            //Make of list of neighbors who's heat level is higher than self.
            foreach (EmptyCell C in this.OwningCell.Adjacent)
            {
                Tower CT = C.Occupant as Tower;

                if (CT != null)
                {
                    if (CT.Heat / CT.Data.ShutdownHeat > startingheat / Data.ShutdownHeat)
                    {
                        HotNeighbor.Add(CT);
                        TotalNeighborHeat  += (CT.Heat - startingheat);
                        HottestNeighborHeat = Math.Max(HottestNeighborHeat, CT.Heat);
                    }
                }
            }



            if (HotNeighbor.Count > 0 && TotalNeighborHeat > 1)
            {
                float RemainingHeatAbsorb = SubClassData.HeatAbsorb;

                // if self is close to overheating, don't take more heat than capacity, and never get hotter than hottest neighbor.

                float ModifiedHeatLimit = Math.Min(this.Data.ShutdownHeat, HottestNeighborHeat);

                if (RemainingHeatAbsorb + startingheat > ModifiedHeatLimit)
                {
                    RemainingHeatAbsorb = ModifiedHeatLimit - startingheat;
                }



                //ModifiedHeatAbsorb = SubClassData.HeatAbsorb / HotNeighbor.Count;


                foreach (Tower HN in HotNeighbor)
                {
                    float SplitHeatAbsorb;
                    float HeatDiff = (HN.Heat - startingheat);

                    //figure this neighors 'share' of heat absorbtion.
                    SplitHeatAbsorb = (HeatDiff / TotalNeighborHeat) * RemainingHeatAbsorb;

                    //Take no more than half the heat differance.
                    if (HeatDiff < SplitHeatAbsorb * 2)
                    {
                        //float s = (this.Heat +CT.Heat)
                        this.Heat += HeatDiff / 2;
                        HN.Heat   -= HeatDiff / 2;
                    }
                    else
                    {
                        this.Heat += SplitHeatAbsorb;
                        HN.Heat   -= SplitHeatAbsorb;
                    }
                }
            }

            //Body.Fill = new System.Windows.Media.SolidColorBrush(HeatColor(Heat, Data.ShutdownHeat));
            Body.Fill = StaticHelpers.HeatBrush(Heat, Data.ShutdownHeat);

            base.Tick(Frame);
        }
Beispiel #3
0
        public bool IsAlignedTo(Point TargetPoint, double tolerance)
        {
            CoercedAngle diff = new CoercedAngle(StaticHelpers.Angle(PivotPoint, TargetPoint) - currentrotation.Angle);

            return(diff.Angle < tolerance || diff.Angle > (360 - tolerance));
        }
        public new void Tick(int FrameCount)
        {
            base.Tick(FrameCount);

            if (this.SubClassData == null)
            {
                if (this.Data == null)
                {
                    return;
                }
                SubClassData = Data as BeamTowerData;
            }

            //if (ProjectileColor == Colors.Transparent)
            {
                // ProjectileColor = System.Windows.Media.Color.FromRgb((byte)R.Next(255), (byte)R.Next(255), (byte)R.Next(255));
                // Arena.instance.AddToArena(TargetLaserD);
                //Arena.instance.AddToArena(TargetLaserB);
            }

            CurrentTarget = null;
            double TXV;
            double TYV;
            double V;

            //System.Windows.Media.Color bc = Color.FromScRgb(1f, (float)(Heat / Data.ShutdownHeat), 0f, 0f);//(float)(Target.LockDuration / 255)
            //Body.Fill = new System.Windows.Media.SolidColorBrush(HeatColor(Heat, Data.ShutdownHeat));
            Body.Fill = StaticHelpers.HeatBrush(Heat, Data.ShutdownHeat);

            // Are we already locked on?
            if (Target.LockedTarget != null && Target.LockedTarget.IsAlive == true)
            {
                // is the locked target still in range?
                TXV = (Target.LockedTarget.XPos - PivotPoint.X);
                TYV = (Target.LockedTarget.YPos - PivotPoint.Y);
                V   = (TXV)*(TXV) + (TYV)*(TYV);
                if (V < (SubClassData.Range * SubClassData.Range))
                {
                    CurrentTarget = Target.LockedTarget;
                    Target.LockDuration++;
                }
            }
            else
            {
                Arena.instance.Children.Remove(Beam);
                Beam.Stroke = Brushes.Transparent;
                Arena.instance.AddToArena(Beam);
            }

            // Find a new target
            if (CurrentTarget == null)
            {
                CurrentTarget       = NearestCreep(SubClassData.Range);
                Target.LockedTarget = CurrentTarget;
                Target.LockDuration = 0;
                return;
            }

            // No valid targets
            if (CurrentTarget == null)
            {
                return;
            }

            if (RefireCount > 0)
            {
                RefireCount--;
            }

            Point TargetPoint = new Point(CurrentTarget.XPos, CurrentTarget.YPos);

            //lastsetrotation = new CoercedAngle(StaticHelpers.Angle(PivotPoint, TargetPoint));


            if (Target.LockDuration > 0)
            {
                // float MuzzleVelocity = 25;

                Beam.X1 = this.PivotPoint.X;
                Beam.Y1 = this.PivotPoint.Y;
                Beam.X2 = CurrentTarget.XPos;
                Beam.Y2 = CurrentTarget.YPos;
                // Beam.Stroke = Brushes.Green;
                Beam.StrokeThickness = 3;



                //calculate the distance to the target
                TXV = (CurrentTarget.XPos - PivotPoint.X);
                TYV = (CurrentTarget.YPos - PivotPoint.Y);
                V   = Math.Sqrt((TXV)*(TXV) + (TYV)*(TYV));



                // Rotate barrel if not aligned with leading point.
                if (!IsAlignedTo(TargetPoint, SubClassData.TrackingSpeed))
                {
                    CoercedAngle diff = new CoercedAngle(StaticHelpers.Angle(PivotPoint, TargetPoint) - currentrotation.Angle);
                    if (diff.Angle > 180)
                    {
                        currentrotation.Angle -= SubClassData.TrackingSpeed;
                    }
                    else
                    {
                        currentrotation.Angle += SubClassData.TrackingSpeed;
                    }
                    //  Body.Fill = Brushes.Yellow;
                    Barrel.RenderTransform = new RotateTransform(currentrotation.Angle);
                    //return;
                }
                else
                {
                    // We are aligned (within tracking speed margin of error) with the targets predicted position.
                    currentrotation.Angle       = StaticHelpers.Angle(PivotPoint, TargetPoint);
                    this.Barrel.RenderTransform = new RotateTransform(StaticHelpers.Angle(PivotPoint, TargetPoint));

                    //Are we ready to fire?

                    if (this.Heat > this.Data.ShutdownHeat)
                    {
                        RefireCount += 5;
                    }

                    if (RefireCount <= 0 && Target.LockDuration > 1 && this.Heat <= this.Data.ShutdownHeat)
                    {
                        //FIRE!!!

                        /*
                         * Projectile P = Projectile.Create(
                         *  FrameCount,
                         *  (float)PivotPoint.X,
                         *  (float)PivotPoint.Y,
                         *  (float)(TXV / V) * (float)MuzzleVelocity,
                         *  (float)(TYV / V) * (float)MuzzleVelocity,
                         *  Projectile.GenericHitCreep
                         *  );
                         * RefireCount = SubClassData.RefireDelay;
                         */
                        Beam.Stroke = StaticHelpers.HeatBrush((float)Target.LockDuration + 50, 100f);
                        CurrentTarget.TakeDamage(Target.LockDuration / 20);
                        this.Heat += this.SubClassData.FiringHeat;
                    }
                    else
                    {
                        Beam.Stroke = Brushes.Transparent;
                    }
                }
            }
            else
            {
                Beam.Stroke = Brushes.Transparent;
            }
        }