Esempio n. 1
0
        public void OnTangibleAdded(Tangible t)
        {
            Debug.Log("Tangible added: " + t.Id);
            var e = GetExampleTangible(t.Id);

            e.Update(t, _offset);
        }
Esempio n. 2
0
        /// <summary>
        /// Add unique damage behaviour here
        /// </summary>
        /// <param name="target"></param>
        /// <param name="gameTime"></param>
        public override void doDamage(Tangible target, GameTime gameTime)
        {
            explosionEngine.createSmallExplosion(position);

            assets.explosionsSFX[9].Play();
            assets.explosionsSFX[10].Play();
            base.doDamage(target, gameTime);
        }
    public void OnTangibleAdded(Tangible t)
    {
        TangibleData tangible = GetTangibleWithId(t.Id);

        tangible.GameObject.GetComponent <SpawnTangibleCollider>().puckIndex = t.PatternId;
        Debug.Log(tangible.GameObject.GetComponent <SpawnTangibleCollider>().puckIndex);
        tangible.Update(t, _offset);
    }
    public void OnTangibleUpdated(Tangible t)
    {
        //Debug.Log("Tangible Updated: " + t.Id);
        TangibleData tangible = GetTangibleWithId(t.Id);

        tangible.Update(t, _offset);
        //Debug.Log(tangible.Transform.position);
    }
Esempio n. 5
0
 /// <summary>
 /// Deal damage and destroy the projectile.
 /// </summary>
 /// <param name="target"></param>
 /// <param name="gameTime"></param>
 public override void collide(Tangible target, GameTime gameTime)
 {
     if (target != owner)
     {
         doDamage(target, gameTime);
         destroy();
     }
 }
Esempio n. 6
0
 public void AddTangible(Tangible t)
 {
     if (_tangibles != null && !_tangibles.Contains(t))
     {
         _tangibles.Add(t);
         _sim.InvokeUpdate();
     }
 }
Esempio n. 7
0
        public void OnTangibleUpdated(Tangible t)
        {
            ExampleTangibleData e;

            if (_tangibleMap.TryGetValue(t.Id, out e))
            {
                e.Update(t, _offset);
            }
        }
 public void ActivateTangible()
 {
     Debug.Log("Activate Tangible");
     _tangible = GetTangible();
     _simView.AddTangible(_tangible);
     OnButtonBg.color  = SelectedButtonColor;
     OnLabel.color     = SelectedTextColor;
     OffButtonBg.color = UnselectedButtonColor;
     OffLabel.color    = UnselectedTextColor;
 }
    public void OnTangibleRemoved(Tangible t)
    {
        Debug.Log("Tangible Removed: " + t.Id);
        TangibleData tangible = GetTangibleWithId(t.Id);

        //replaced destroy for setting tangible collider activity
        tangible.GameObject.GetComponent <SpawnTangibleCollider>().puck.gameObject.SetActive(false);
        //Debug.Log(tangible.GameObject + "onRemoved");
        ReturnTangible(t.Id);
    }
Esempio n. 10
0
 public void RemoveTangible(Tangible t)
 {
     if (_tangibles != null && _tangibles.Contains(t))
     {
         _tangibles.Remove(t);
         if (_tangibles.Count <= 0)
         {
             _sim.InvokeUpdate();
         }
     }
 }
Esempio n. 11
0
        private void narrowCheck(Tangible target, float temp, ref Tangible currentTarget)
        {
            Color[] rawData = new Color[target.width * target.height];
            target.texture.GetData <Color>(rawData);
            Color[,] rawDataGrid = new Color[target.width, target.height];
            for (int x = 0; x < target.width; ++x)
            {
                for (int y = 0; y < target.height; ++y)
                {
                    rawDataGrid[x, y] = rawData[x + y * target.width];
                }
            }

            float distanceTo = temp * beamLength;
            // start checking pixel-by-pixel from this point
            Vector2   startFrom = new Vector2(beamDirection.X * distanceTo + position.X, beamDirection.Y * distanceTo + position.Y);
            Vector2   checkV    = startFrom;
            Point     check     = new Point((int)startFrom.X, (int)startFrom.Y);
            Rectangle hb        = target.getHitBox().getArray();
            Vector2   length;

            length = position - checkV;
            if (length.Y > 0)
            {
                check.Y -= 1;
            }
            if (length.X > 0)
            {
                check.X -= 1;
            }
            // until out of hitbox or beamLength exceeded
            while (hb.Contains(check))
            {
                Color color = rawDataGrid[Math.Abs(hb.X - check.X), Math.Abs(hb.Y - check.Y)];
                // if color is not transparent
                if (color.A != 0)
                {
                    distToTarget  = length.Length() / beamLength;
                    currentTarget = target;
                    return;
                }
                checkV.X += beamDirection.X;
                checkV.Y += beamDirection.Y;
                length    = position - checkV;
                if (length.Length() > beamLength)
                {
                    return;
                }
                check.X = (int)checkV.X;
                check.Y = (int)checkV.Y;
            }
        }
        public void Update(Tangible t, Vector3 offset)
        {
            if (Transform != null)
            {
                Transform.localPosition    = new Vector3(t.X, t.Y, 0) + offset;
                Transform.localEulerAngles = new Vector3(0, 0, t.R * Mathf.Rad2Deg);
            }

            if (Text != null)
            {
                Text.text = string.Format("Tangible {0}\nPattern {1}\nPosition {2:000.0}, {3:000.0}\nRotation {4:000.0}", t.Id, t.PatternId, t.X, t.Y, Mathf.Rad2Deg * t.R);
            }
        }
 public void DeactivateTangible()
 {
     Debug.Log("Deactivate Tangible");
     if (_tangible == null)
     {
         return;
     }
     _simView.RemoveTangible(_tangible);
     _tangible         = null;
     OnButtonBg.color  = UnselectedButtonColor;
     OnLabel.color     = UnselectedTextColor;
     OffButtonBg.color = SelectedButtonColor;
     OffLabel.color    = SelectedTextColor;
 }
        public Tangible GetTangible()
        {
            if (_rectTransform == null)
            {
                _rectTransform = GetComponent <RectTransform>();
            }

            var id       = _patternIds[_patternIndex];
            var tangible = new Tangible {
                Id        = tangibleId++,
                PatternId = id,
                Pos       =
                {
                    x = _rectTransform.anchoredPosition.x,
                    y = _rectTransform.anchoredPosition.y
                },
                R          = rotateHandle.R * Mathf.Deg2Rad,
                PointerIds = new[] { 1, 2, 3 }
            };

            return(tangible);
        }
Esempio n. 15
0
 /// <summary>
 /// Determine what kind of collision is occuring.
 /// @Written by Tristan.
 /// </summary>
 /// <param name="target"></param>
 /// <param name="gameTime"></param>
 /// <exception cref="NotImplementedException">A new kind of object that needs handling</exception>
 public override void collide(Tangible target, GameTime gameTime)
 {
     if (target is Projectile)
     {
         target.collide(this, gameTime);                 // the projectile can handle it from here
     }
     else if (target is Ship)
     {
         game.collisionHandler.shipOnShip(this, (Ship)target, gameTime);
     }
     else if (target is Asteroid)
     {
         game.collisionHandler.shipOnAsteroid(this, (Asteroid)target, gameTime);
     }
     else if (target is Planet)
     {
         game.collisionHandler.shipOnPlanet(this, (Planet)target, gameTime);
     }
     else
     {
         throw new NotImplementedException();
     }
 }
Esempio n. 16
0
 public override void collide(Tangible target, GameTime gameTime)
 {
     if (target is Projectile)
     {
         target.collide(this, gameTime);
     }
     else if (target is Ship)
     {
         game.collisionHandler.shipOnPlanet((Ship)target, this, gameTime);
     }
     else if (target is Asteroid)
     {
         game.collisionHandler.asteroidOnPlanet((Asteroid)target, this, gameTime);
     }
     else if (target is Planet)
     {
         game.collisionHandler.planetOnPlanet(this, (Planet)target, gameTime);
     }
     else
     {
         throw new NotImplementedException();
     }
 }
Esempio n. 17
0
 /// <summary>
 /// Add unique damage behaviour here
 /// </summary>
 /// <param name="target"></param>
 /// <param name="gameTime"></param>
 public override void doDamage(Tangible target, GameTime gameTime)
 {
     base.doDamage(target, gameTime);
 }
Esempio n. 18
0
 public TaxLaw(Tangible Tangible, double Amount)
 {
     _Tangible = Tangible;
     _Amount   = Amount;
 }
Esempio n. 19
0
 /// <summary>
 /// Add unique damage behaviour here
 /// </summary>
 /// <param name="target"></param>
 /// <param name="gameTime"></param>
 public override void doDamage(Tangible target, GameTime gameTime)
 {
     explosionEngine.createBigExplosion(position);
     base.doDamage(target, gameTime);
 }
Esempio n. 20
0
 public void OnTangibleRemoved(Tangible t)
 {
     Debug.Log("Tangible removed: " + t.Id);
     ReturnExampleTangible(t.Id);
 }
 public void OnEngineFailedToConnect(Tangible t)
 {
     //Debug.Log("failed to connect");
 }
Esempio n. 22
0
 /// <summary>
 /// Add unique collision behaviour here
 /// </summary>
 /// <param name="target"></param>
 /// <param name="gameTime"></param>
 public override void collide(Tangible target, GameTime gameTime)
 {
     base.collide(target, gameTime);
 }
Esempio n. 23
0
        public void update(GameTime gameTime, QuadTree quadTree)
        {
            if (!beamOn)
            {
                return;
            }
            beamQuanta.Clear();
            //beamQuantum = new Rectangle((int) position.X, (int) position.Y, 1, 3);

            beamDirection = new Vector2((float)Math.Sin(rotation), (float)-Math.Cos(rotation));
            Ray2 ray = new Ray2(position, beamDirection * beamLength);


            distToTarget = 1;

            // find targets within line of fire
            /*List<Tangible> possibleCollisions = quadTree.retrieveNeighbors(owner);*/

            /* This method and may result in missed ships.
             * A different retriever using a raycast
             * will likely be necessary. -Tristan-*/

            List <Tangible> possibleCollisions = GameplayScreen.targets;

            Tangible currentTarget = null;

            foreach (Tangible target in possibleCollisions)
            {
                if (target != owner && target.isActive)
                {
                    if (ray.intersectsToRange(target.getHitBox()))
                    {
                        float temp = ray.getDistance();
                        if (temp <= distToTarget)
                        {
                            // fine hit detection
                            narrowCheck(target, temp, ref currentTarget);
                        }
                    }
                }
            }

            if (currentTarget != null)
            {
                doDamage(currentTarget, gameTime);
            }

            frameIndex = startQuanta;

            for (int i = 0; i < beamLength * distToTarget; ++i)
            {
                beamQuanta.Add(getNextQuanta());
                if (++frameIndex > 4)
                {
                    frameIndex = 0;
                }
            }

            if (--startQuanta < 0)
            {
                startQuanta = 4;
            }
            beamOn = false;
        }
Esempio n. 24
0
 public void doDamage(Tangible target, GameTime gameTime)
 {
     target.takeDamage(weaponDamage, gameTime, owner);
 }
Esempio n. 25
0
        private static void PrintTangibleCommands(Tangible tangible)
        {
            Console.WriteLine($"{tangible} has {tangible.Commands.Count()} commands.");

            foreach (var command in tangible.Commands)
            {
                Console.WriteLine($"{command} is owned by {command.Owner}.");
            }
        }
Esempio n. 26
0
 /// <summary>
 /// Add unique damage behaviour here
 /// </summary>
 /// <param name="target"></param>
 /// <param name="gameTime"></param>
 public override void doDamage(Tangible target, GameTime gameTime)
 {
     explosionEngine.createSmallExplosion(position);
     base.doDamage(target, gameTime);             // base calls destroy by default
 }