コード例 #1
0
 public CollisionInfo collidesWithPoints(List <Vector2> points)
 {
     foreach (Vector2 pos in points)
     {
         Vector2 gridPos = MapTools.mapToGridCoords(pos);
         if (Game1.world.get((int)gridPos.X, (int)gridPos.Y).Type.Collision)
         {
             return(new CollisionInfo(true, Vector2.Zero, true));
         }
         else
         {
             foreach (CollisionBox box in collisionBoxes)
             {
                 if (box.collidesWithMovingPoint(pos, Vector2.Zero))
                 {
                     if (!(box is FreeGravityBox))
                     {
                         return(new CollisionInfo(true, box.speed));
                     }
                     return(new CollisionInfo(true, Vector2.Zero));
                 }
             }
         }
     }
     return(new CollisionInfo(false, Vector2.Zero));
 }
コード例 #2
0
        public Rocket(ContentManager content, float x, float y, float width, float height, Vector2 movingDirection) : base(content, x, y, width, height)
        {
            textureTest                           = Game1.cManager.Load <Texture2D>("themes/" + Game1.world.currentTheme + "/items/rocket");
            this.travelSpeed                      = 15f;
            angle                                 = MapTools.VectorToAngle(movingDirection);
            particleEmitter                       = new RoundParticleEmitter(ParticleType.SPARK, new Vector2(0, 0));
            particleEmitter.pLifeTime             = 100;
            particleEmitter.pMinLifeTime          = 70;
            particleEmitter.pLoop                 = false;
            particleEmitter.pPerUpdate            = 100;
            particleEmitter.pSize                 = new Vector2(5, 5);
            particleEmitter.pVelocity             = 10;
            particleEmitter.pMinVelocity          = 5;
            particleEmitter.pIlluminationStrength = 1;
            particleEmitter.pBounceFactor         = 0.5f;
            particleEmitter.pDampenFactor         = 0.97f;
            particleEmitter.pGravityFactor        = 0.3f;

            smokeEmitter                       = new ConeParticleEmitter(ParticleType.ENGINE, new Vector2(0, 0), 0, 10);
            smokeEmitter.pLifeTime             = 40;
            smokeEmitter.pMinLifeTime          = 30;
            smokeEmitter.pLoop                 = false;
            smokeEmitter.pPerUpdate            = 1;
            smokeEmitter.pSize                 = new Vector2(15, 15);
            smokeEmitter.pVelocity             = 7;
            smokeEmitter.pMinVelocity          = 5;
            smokeEmitter.pIlluminationStrength = 0.0005f;
            smokeEmitter.pBounceFactor         = 0.0f;
            smokeEmitter.pDampenFactor         = 0.97f;
            smokeEmitter.pGravityFactor        = -0.02f;
            smokeEmitter.start();
            oldPos = pos;
        }
コード例 #3
0
 public override void update()
 {
     if (activated)
     {
         for (int i = 0; i < pPerUpdate; i++)
         {
             double coneRadians = (coneRadius * Math.PI) / 180.0;
             double angle       = (random.NextDouble() * coneRadians * 2) + direction - coneRadians;
             float  v           = pVelocity;
             if (pMinVelocity != -1)
             {
                 v = (float)random.NextDouble() * (pVelocity - pMinVelocity) + pMinVelocity;
             }
             int lifeTime = pLifeTime;
             if (pMinLifeTime != -1)
             {
                 lifeTime = (int)(random.NextDouble() * (pLifeTime - pMinLifeTime) + pMinLifeTime);
             }
             Vector2  velocity = MapTools.AngleToVector((float)angle) * v;
             Particle particle = new Particle(particleType, pos, pSize, velocity, lifeTime, pLoop, pFrameskip);
             particle.illuminationStrength = pIlluminationStrength;
             particle.gravityFactor        = pGravityFactor;
             particle.bounceFactor         = pBounceFactor;
             particle.dampenFactor         = pDampenFactor;
             Game1.world.particles.Add(particle);
         }
     }
 }
コード例 #4
0
        public override void Draw(SpriteBatch spriteBatch)
        {
            angle = MapTools.VectorToAngle(endPoint - startPoint);

            startPoint = spawnPos;
            LineRenderer.DrawLine(spriteBatch, startPoint, endPoint, Color.Black, 3);
#pragma warning disable CS0618 // Typ oder Element ist veraltet
            spriteBatch.Draw(
                textureTest,
                //position: spawnPos,
                destinationRectangle: new Rectangle((int)spawnPos.X, (int)spawnPos.Y, (int)size.X, (int)size.Y + 1 + (int)((pos - spawnPos).Length())),
                sourceRectangle: new Rectangle(0, 0, (int)(textureTest.Width * 0.51f), textureTest.Height + 1 + (int)((pos - spawnPos).Length() * ((float)textureTest.Height / size.Y))),
                color: new Color(255, 255, 255, alpha),
                rotation: angle - (float)(Math.PI * 0.5f),
                origin: new Vector2(textureTest.Width * 0.25f, 0),
                scale: new Vector2(2f * (size.X / (float)textureTest.Width), 1f * ((size.Y) / (float)textureTest.Height)),
                effects: SpriteEffects.FlipVertically,
                layerDepth: 1f);
#pragma warning restore CS0618 // Typ oder Element ist veraltet

            spriteBatch.Draw(
                textureTest,
                position: pos,
                sourceRectangle: new Rectangle((int)(textureTest.Width * 0.51f), 0, (int)(textureTest.Width * 0.51f), textureTest.Height),
                color: new Color(255, 255, 255, alpha),
                rotation: angle - (float)(Math.PI * 0.5f),
                origin: new Vector2(textureTest.Width * 0.25f, -textureTest.Height * 1f),
                scale: new Vector2(2f * (size.X / (float)textureTest.Width), 1 * (size.Y / (float)textureTest.Height)),
                effects: SpriteEffects.None,
                layerDepth: 1f);
        }
コード例 #5
0
        public void drawIllumination(SpriteBatch spriteBatch)
        {
            Vector2 startVec = MapTools.mapToGridCoords(Game1.getCam().Pos);

            for (int x = (int)startVec.X - 100; x < (int)startVec.X + 100; x++)
            {
                for (int y = (int)startVec.Y - 64; y < (int)startVec.Y + 64; y++)
                {
                    if (x > 0 && y > 0 && x < width && y < height && blocks[x, y] != airDefault)
                    {
                        blocks[x, y].drawIllumination(spriteBatch, x, y);
                    }
                }
            }

            foreach (Item item in items)
            {
                item.drawIllumination(spriteBatch);
            }

            foreach (Particle particle in particles)
            {
                particle.drawIllumination(spriteBatch);
            }
        }
コード例 #6
0
        public override void Draw(SpriteBatch spriteBatch)
        {
            if (sourceRect.Width == 0)
            {
                sourceRect = new Rectangle(0, 0, textureTest.Width, textureTest.Height);
            }

            angle = MapTools.VectorToAngle(WorldInfo.gravity) - (float)Math.PI * 0.5f;

            if (Game1.running && collidesWithPoint(Game1.getPlayer().getCenter()))
            {
                //Console.WriteLine("hit");
                Game1.getPlayer().die();
            }

            spriteBatch.Draw(
                textureTest,
                position: pos,
                sourceRectangle: sourceRect,
                color: new Color(r, g, b, alpha),
                rotation: angle,
                origin: new Vector2(sourceRect.Width * 0.5f, sourceRect.Width * 0.5f),
                scale: new Vector2(1 * (size.X / (float)sourceRect.Width), 1 * (size.Y / (float)sourceRect.Height)),
                effects: SpriteEffects.None,
                layerDepth: 1);
            //LineRenderer.DrawLine(spriteBatch, pos, pos - new Vector2(size.X, size.X) * 0.5f, Color.Red, 3f);
        }
コード例 #7
0
 public override void Draw(SpriteBatch spriteBatch)
 {
     frame++;
     sourceRect = animation.getSourceRectange();
     animation.update();
     this.angle = (float)(Math.Sin(frame * 0.1f) * 0.1f) + MapTools.VectorToAngle(WorldInfo.gravity) - 3.1415f * 0.5f;
     base.Draw(spriteBatch);
 }
コード例 #8
0
 public override bool CollidesWithPlayer()
 {
     return((MapTools.distanceOfVecs(Game1.getPlayer().getCenter(), getCenter()) < size.X * 0.5f ||
             MapTools.distanceOfVecs(Game1.getPlayer().downPoint(), getCenter()) < size.X * 0.5f) ||
            MapTools.distanceOfVecs(Game1.getPlayer().upPoint(), getCenter()) < size.X * 0.5f ||
            MapTools.distanceOfVecs(Game1.getPlayer().leftPoints()[0], getCenter()) < size.X * 0.5f ||
            MapTools.distanceOfVecs(Game1.getPlayer().rightPoints()[0], getCenter()) < size.X * 0.5f
            );
 }
コード例 #9
0
        public List <Vector2> leftPoints()
        {
            List <Vector2> points = new List <Vector2>();

            points.Add(getCenter() - (new Vector2(MapTools.getXMultiplier(), MapTools.getYMultiplier())) * size.X * 0.51f);
            points.Add(getCenter() - (new Vector2(MapTools.getXMultiplier(), MapTools.getYMultiplier())) * size.X * 0.51f + WorldInfo.gravity * size.Y * 0.4f);
            points.Add(getCenter() - (new Vector2(MapTools.getXMultiplier(), MapTools.getYMultiplier())) * size.X * 0.51f - WorldInfo.gravity * size.Y * 0.4f);
            return(points);
        }
コード例 #10
0
        public List <Vector2> upPoints()
        {
            List <Vector2> points = new List <Vector2>();

            points.Add(getCenter() - WorldInfo.gravity * size.Y * 0.51f);
            points.Add(getCenter() - WorldInfo.gravity * size.Y * 0.51f + MapTools.getMultiplierVec() * size.X * 0.4f);
            points.Add(getCenter() - WorldInfo.gravity * size.Y * 0.51f - MapTools.getMultiplierVec() * size.X * 0.4f);

            return(points);
        }
コード例 #11
0
        public bool[,] getBlockSetArray()
        {
            bool[,] setArray = new bool[2, 2];

            setArray[0, 0] = Game1.world.get((int)MapTools.mapToGridCoords(getCenter() + new Vector2(-1, -1)).X, (int)MapTools.mapToGridCoords(getCenter() + new Vector2(-1, -1)).Y).Type != BlockType.AIR;
            setArray[0, 1] = Game1.world.get((int)MapTools.mapToGridCoords(getCenter() + new Vector2(-1, +1)).X, (int)MapTools.mapToGridCoords(getCenter() + new Vector2(-1, +1)).Y).Type != BlockType.AIR;
            setArray[1, 0] = Game1.world.get((int)MapTools.mapToGridCoords(getCenter() + new Vector2(+1, -1)).X, (int)MapTools.mapToGridCoords(getCenter() + new Vector2(+1, -1)).Y).Type != BlockType.AIR;
            setArray[1, 1] = Game1.world.get((int)MapTools.mapToGridCoords(getCenter() + new Vector2(+1, +1)).X, (int)MapTools.mapToGridCoords(getCenter() + new Vector2(+1, +1)).Y).Type != BlockType.AIR;

            return(setArray);
        }
コード例 #12
0
        public bool beamCollidesWithPlayer()
        {
            Player player = Game1.getPlayer();

            return(MapTools.PointCollidesWithRect(player.getCenter(),
                                                  getUpLeftBeamPoint(),
                                                  getDownRightBeamPoint()) ||
                   MapTools.PointCollidesWithRect(player.leftPoints()[0],
                                                  getUpLeftBeamPoint(),
                                                  getDownRightBeamPoint()) ||
                   MapTools.PointCollidesWithRect(player.rightPoints()[0],
                                                  getUpLeftBeamPoint(),
                                                  getDownRightBeamPoint()));
        }
コード例 #13
0
        public override void Update()
        {
            angle = MapTools.VectorToAngle(Game1.getPlayer().getCenter() - getCenter());

            if (frames % 120 == 119)
            {
                Game1.world.addItem(new Rocket(content, pos.X, pos.Y, size.X, size.Y * 0.5f, Game1.getPlayer().getCenter() - getCenter()));
                frames = 0;
            }


            frames++;
            base.Update();
        }
コード例 #14
0
        public void Draw(SpriteBatch spriteBatch)
        {
            rect.X = (int)(Math.Round(pos.X));
            rect.Y = (int)(Math.Round(pos.Y));
            SpriteEffects effect;

            if (flipped)
            {
                effect = SpriteEffects.FlipHorizontally;
            }
            else
            {
                effect = SpriteEffects.None;
            }
            sourceRectange = animation.getSourceRectange();


            spriteBatch.Draw(
                textureTest,
                position: pos,
                sourceRectangle: sourceRectange,
                color: Color.White,
                rotation: MapTools.VectorToAngle(WorldInfo.gravity) - (float)Math.PI * 0.5f,
                origin: new Vector2((float)sourceRectange.Width * 0.501f, (float)sourceRectange.Height * 0.501f),
                scale: 1,
                effects: effect,
                layerDepth: 1);

            int flameId = 0;

            foreach (GravityFlame flame in flames)
            {
                flame.draw(spriteBatch);
                flameId++;
            }

            int playerPosID = 30;

            if (!Game1.running && showPlayerPositions)
            {
                foreach (PlayerPositionShow pl in playerPositions)
                {
                    pl.Draw(spriteBatch, playerPosID);
                    playerPosID--;
                }
            }
        }
コード例 #15
0
        public override void Update()
        {
            angle += angleSpeed * 0.001f;

            raycast.dir  = MapTools.AngleToVector(angle - MathHelper.Pi * 0.5f);
            raycast.pos  = pos + raycast.dir * 10;
            hitOfRaycast = raycast.getHit();
            if (hitOfRaycast.obj is Player)
            {
                Game1.getPlayer().die();
            }
            //           Game1.world.particles.Add(new Particle(hitOfRaycast.pos.X - raycast.dir.X * 5, hitOfRaycast.pos.Y - raycast.dir.Y * 5, 5, 5, new Vector2(((float)new Random().NextDouble() - 0.5f) * 20.0f, ((float)new Random().NextDouble() - 0.5f) * 20.0f)));
            particleEmitter.pos.X     = hitOfRaycast.pos.X;
            particleEmitter.pos.Y     = hitOfRaycast.pos.Y;
            particleEmitter.Direction = angle - Math.PI * (0.5f - Math.Sign(angleSpeed) * 0.2f) + Math.PI;
            particleEmitter.update();
            base.Update();
        }
コード例 #16
0
        public CollisionInfo collidesUp()
        {
            Vector2 pos = MapTools.mapToGridCoords(upPoint());

            if (Game1.world.get((int)pos.X, (int)pos.Y).Type.Collision)
            {
                return(new CollisionInfo(true, Vector2.Zero));
            }
            else
            {
                foreach (CollisionBox box in Game1.world.collisionBoxes)
                {
                    if (collidesUpWithCollisionBox(box))
                    {
                        return(new CollisionInfo(true, box.speed));
                    }
                }
            }
            return(new CollisionInfo(false, Vector2.Zero));
        }
コード例 #17
0
        public void update(float delta)
        {
            collisionInfoDownBeginOfFrame = isGrounded();
            applySpeed();
            applyFallSpeed(delta);
            Vector2 gridCoords = MapTools.mapToGridCoords(getCenter());

            if (Game1.world.get((int)gridCoords.X, (int)gridCoords.Y).Type.Killing)
            {
                die();
            }
            animation.update();
            int flameId = 0;

            foreach (GravityFlame flame in flames)
            {
                flame.update(flameId);
                flameId++;
            }
        }
コード例 #18
0
        public virtual CollisionInfo collidesWithMap()
        {
            Vector2 pos = MapTools.mapToGridCoords(getCenter());

            if (Game1.world.get((int)pos.X, (int)pos.Y).Type.Collision)
            {
                return(new CollisionInfo(true, Vector2.Zero));
            }
            else
            {
                foreach (CollisionBox box in Game1.world.collisionBoxes)
                {
                    if (collidesWithCollisionBox(box))
                    {
                        return(new CollisionInfo(true, speed));;
                    }
                }
            }
            return(new CollisionInfo(false, Vector2.Zero));
        }
コード例 #19
0
        public void applySpeed()
        {
            Vector2 speedVec = new Vector2((float)((speed) * Math.Round(MapTools.getXMultiplier())), (float)((speed) * Math.Round(MapTools.getYMultiplier())));

            if ((speed > 0 && !collidesRight(false)))
            {
                raycast = new Raycast(rightPoints()[0], MapTools.getMultiplierVec() + new Vector2(0.0000001f, 0.0000001f), 1000, true);
                CollisionInfo hit = raycast.getHit();

                if ((hit.pos - rightPoints()[0]).Length() < speedVec.Length())
                {
                    speedVec = hit.pos + MapTools.getMultiplierVec() * 0.1f - rightPoints()[0];
                }

                pos += speedVec;
            }
            else if ((speed < 0 && !collidesLeft(false)))
            {
                raycast = new Raycast(leftPoints()[0], -MapTools.getMultiplierVec() + new Vector2(0.0000001f, 0.0000001f), 1000, true);
                CollisionInfo hit = raycast.getHit();

                if ((hit.pos - leftPoints()[0]).Length() < speedVec.Length())
                {
                    speedVec = hit.pos - MapTools.getMultiplierVec() * 0.1f - leftPoints()[0];
                }
                pos += speedVec;
            }
            else
            {
                speed = 0;
            }

            if ((collisionInfoDownBeginOfFrame.getRealSpeed() > 0 && !collidesRight(false)) || (collisionInfoDownBeginOfFrame.getRealSpeed() < 0 && !collidesLeft(false)))
            {
                pos.X += (float)((collisionInfoDownBeginOfFrame.getRealSpeed()) * Math.Round(MapTools.getXMultiplier()));
                pos.Y += (float)((collisionInfoDownBeginOfFrame.getRealSpeed()) * Math.Round(MapTools.getYMultiplier()));
            }

            rect.X = (int)pos.X;
            rect.Y = (int)pos.Y;
        }
コード例 #20
0
        public void Draw(SpriteBatch spriteBatch)
        {
            if (Keyboard.GetState().IsKeyDown(Keys.L))
            {
                Game1.getCam().TargetZoom = 4f;
            }
            if (Keyboard.GetState().IsKeyDown(Keys.K))
            {
                Game1.getCam().TargetZoom = 2f;
            }
            if (Keyboard.GetState().IsKeyDown(Keys.J))
            {
                Game1.getCam().TargetZoom = 1f;
            }



            Vector2 startVec = MapTools.mapToGridCoords(Game1.getCam().Pos);

            for (int x = (int)startVec.X - 100; x < (int)startVec.X + 100; x++)
            {
                for (int y = (int)startVec.Y - 64; y < (int)startVec.Y + 64; y++)
                {
                    if (x > 0 && y > 0 && x < width && y < height && blocks[x, y] != airDefault)
                    {
                        blocks[x, y].draw(spriteBatch, x, y);
                    }
                }
            }

            foreach (Item item in items)
            {
                item.Draw(spriteBatch);
            }

            foreach (Particle particle in particles)
            {
                particle.draw(spriteBatch);
            }
        }
コード例 #21
0
        public CollisionInfo isGrounded()
        {
            Vector2 pos = MapTools.mapToGridCoords(downPoint() + WorldInfo.gravity * 0.1f);

            if (Game1.world.get((int)pos.X, (int)pos.Y).Type.Collision)
            {
                if (Game1.world.get((int)pos.X, (int)pos.Y).Type == BlockType.ICE)
                {
                    return(new CollisionInfo(true, Vector2.Zero, BlockType.ICE, pos));
                }
                return(new CollisionInfo(true, Vector2.Zero));
            }
            else
            {
                foreach (CollisionBox box in Game1.world.collisionBoxes)
                {
                    if (collidesDownWithCollisionBox(box))
                    {
                        return(new CollisionInfo(true, box.speed));;
                    }
                }
            }
            return(new CollisionInfo(false, Vector2.Zero));
        }
コード例 #22
0
        public Boolean collidesLeft(bool withFreeGravityBox)
        {
            Vector2        pos;
            List <Vector2> points = leftPoints();

            foreach (Vector2 point in points)
            {
                pos = MapTools.mapToGridCoords(point);
                if (Game1.world.get((int)pos.X, (int)pos.Y).Type.Collision)
                {
                    return(true);
                }
            }

            foreach (CollisionBox box in Game1.world.collisionBoxes)
            {
                if (!(box is FreeGravityBox && !withFreeGravityBox) && collidesLeftWithCollisionBox(box))
                {
                    return(true);
                }
            }

            return(false);
        }
コード例 #23
0
 public ConeParticleEmitter(ParticleType particleType, Vector2 pos, Vector2 direction, float coneRadius) : base(particleType, pos)
 {
     this.direction  = MapTools.VectorToAngle(direction);
     this.coneRadius = coneRadius;
 }
コード例 #24
0
        public CollisionInfo setLine(Vector2 pos, Vector2 dir, float length)
        {
            int x = (int)MapTools.mapToGridCoords(pos).X;
            int y = (int)MapTools.mapToGridCoords(pos).Y;

            int stepX = 1;
            int stepY = 1;

            if (dir.X < 0)
            {
                stepX = -1;
            }
            if (dir.Y < 0)
            {
                stepY = -1;
            }
            float tMaxXVal = pos.X % 16;
            float tMaxYVal = pos.Y % 16;

            if (stepX == 1)
            {
                tMaxXVal = 16f - tMaxXVal;
            }
            if (stepY == 1)
            {
                tMaxYVal = 16f - tMaxYVal;
            }

            float tMaxX = tMaxXVal / dir.X * stepX;
            float tMaxY = tMaxYVal / dir.Y * stepY;

            float tDeltaX = 16f / dir.X * stepX;
            float tDeltaY = 16f / dir.Y * stepY;

            while (true)
            {
                bool delX = false;
                if (tMaxX < tMaxY)
                {
                    tMaxX = tMaxX + tDeltaX;
                    x     = x + stepX;
                    delX  = true;
                }
                else
                {
                    tMaxY = tMaxY + tDeltaY;
                    y     = y + stepY;
                    delX  = false;
                }
                if (x < 0 || y < 0 || x >= Game1.world.width || y >= Game1.world.height)
                {
                    break;
                }
                if (Game1.world.blocks[x, y].Type.Collision)
                {
                    float min;
                    if (delX)
                    {
                        min = Math.Min(tMaxX - tDeltaX, tMaxY);
                    }
                    else
                    {
                        min = Math.Min(tMaxX, tMaxY - tDeltaY);
                    }
                    Vector2 hitPos = pos + min * dir;
                    //hitPos = new Vector2((hitPos.X - hitPos.X % 16) + hitPos.Y % 16, (hitPos.Y - hitPos.Y % 16) + hitPos.X % 16);
                    return(new CollisionInfo(true, Vector2.Zero, null, hitPos));
                }
            }

            return(new CollisionInfo(false, Vector2.Zero, null, dir * length));
        }
コード例 #25
0
        public CollisionInfo getHit()
        {
            Vector2 res = new Vector2(pos.X, pos.Y);
            List <CollisionInfo> collisionInfos = new List <CollisionInfo>();

            dir.Normalize();
            Vector2       posOnGrid        = MapTools.mapToGridCoords(pos);
            Vector2       endPointOnGrid   = MapTools.mapToGridCoords(pos) + dir * length / 16f;
            CollisionInfo raytraversalInfo = setLine(pos, dir, length);

            if (raytraversalInfo.collided)
            {
                collisionInfos.Add(new CollisionInfo(true, Vector2.Zero, null, raytraversalInfo.pos));
            }
            Player player = Game1.getPlayer();

            if (!ignorePlayer && MapTools.lineCollidesWithRect(pos, pos + dir * length, player.pos - player.size * 0.5f, player.size.X, player.size.Y).collided)
            {
                res = MapTools.lineCollidesWithRect(pos, pos + dir * length, player.pos - player.size * 0.5f, player.size.X, player.size.Y).pos;
                collisionInfos.Add(new CollisionInfo(true, Vector2.Zero, player, res));
            }
            foreach (CollisionBox box in Game1.world.collisionBoxes)
            {
                if (box.active)
                {
                    if (MapTools.lineCollidesWithRect(pos, pos + dir * length, box.pos - box.size * 0.5f, box.size.X, box.size.Y).collided)
                    {
                        res = MapTools.lineCollidesWithRect(pos, pos + dir * length, box.pos - box.size * 0.5f, box.size.X, box.size.Y).pos;
                        collisionInfos.Add(new CollisionInfo(true, Vector2.Zero, box, res));
                    }
                }
            }

            if (collisionInfos.Count == 0)
            {
                return(new CollisionInfo(true, Vector2.Zero, null, pos + dir * length));
            }

            while (collisionInfos.Count > 1)
            {
                if ((pos - collisionInfos[0].pos).LengthSquared() > (pos - collisionInfos[1].pos).LengthSquared())
                {
                    collisionInfos.RemoveAt(0);
                }
                else
                {
                    collisionInfos.RemoveAt(1);
                }
            }
            return(collisionInfos[0]);

            /*
             * while (!Game1.world.collidesWithPoint(res).collided && !Game1.getPlayer().collidesWithMovingPoint(res, Vector2.Zero))
             * {
             *  res += dir;
             *  if ((pos - res).Length() > length)
             *      break;
             * }
             *
             *
             *
             * if (Game1.getPlayer().collidesWithMovingPoint(res, Vector2.Zero))
             *  return new CollisionInfo(true, Vector2.Zero, Game1.getPlayer(), res);*/
        }
コード例 #26
0
        public void drawOutlines(SpriteBatch batch)
        {
            rect.X      = (int)(pos.X + offset.X);
            rect.Y      = (int)(pos.Y + offset.Y);
            rect.Width  = (int)size.X;
            rect.Height = (int)size.Y;
            SpriteEffects effect;

            if (flipped)
            {
                effect = SpriteEffects.FlipHorizontally;
            }
            else
            {
                effect = SpriteEffects.None;
            }
            batch.Draw(textureTest, position: pos + offset + new Vector2(1f / Game1.getCam().Zoom, 0), scale: new Vector2(1, 1), color: Color.Black, rotation: MapTools.VectorToAngle(WorldInfo.gravity) - (float)Math.PI * 0.5f, origin: new Vector2(textureTest.Width * 0.5f, textureTest.Height * 0.5f), effects: effect);
            batch.Draw(textureTest, position: pos + offset + new Vector2(0, 1f / Game1.getCam().Zoom), scale: new Vector2(1, 1), color: Color.Black, rotation: MapTools.VectorToAngle(WorldInfo.gravity) - (float)Math.PI * 0.5f, origin: new Vector2(textureTest.Width * 0.5f, textureTest.Height * 0.5f), effects: effect);
            batch.Draw(textureTest, position: pos + offset + new Vector2(-1f / Game1.getCam().Zoom, 0), scale: new Vector2(1, 1), color: Color.Black, rotation: MapTools.VectorToAngle(WorldInfo.gravity) - (float)Math.PI * 0.5f, origin: new Vector2(textureTest.Width * 0.5f, textureTest.Height * 0.5f), effects: effect);
            batch.Draw(textureTest, position: pos + offset + new Vector2(0, -1f / Game1.getCam().Zoom), scale: new Vector2(1, 1), color: Color.Black, rotation: MapTools.VectorToAngle(WorldInfo.gravity) - (float)Math.PI * 0.5f, origin: new Vector2(textureTest.Width * 0.5f, textureTest.Height * 0.5f), effects: effect);
        }
コード例 #27
0
 public Vector2 getDownRightBeamPoint()
 {
     return(getCenter() + new Vector2(MapTools.getXMultiplier() * size.X * 0.5f, MapTools.getYMultiplier() * size.Y * 0.5f) + WorldInfo.gravity * length);
 }
コード例 #28
0
 public Vector2 getUpLeftBeamPoint()
 {
     return(getCenter() - new Vector2(MapTools.getXMultiplier() * size.X * 0.5f, MapTools.getYMultiplier() * size.Y * 0.5f));
 }
コード例 #29
0
        public override void Update()
        {
            speed *= 1.0125f;
            Vector2 playerPos = Game1.getPlayer().getCenter();

            speed.Normalize();
            Vector2 pointRotatedUp   = getCenter() + Vector2.Transform(speed, Matrix.CreateRotationZ(0.1f));
            Vector2 pointRotatedDown = getCenter() + Vector2.Transform(speed, Matrix.CreateRotationZ(-0.1f));

            if ((playerPos - pointRotatedUp).Length() < (playerPos - pointRotatedDown).Length())
            {
                if (angleSpeed < 0)
                {
                    angleSpeed = 0;
                }
                angleSpeed += 0.001f;
            }
            if ((playerPos - pointRotatedUp).Length() > (playerPos - pointRotatedDown).Length())
            {
                if (angleSpeed > 0)
                {
                    angleSpeed = 0;
                }
                angleSpeed -= 0.001f;
            }
            angle += angleSpeed;
            speed  = MapTools.AngleToVector(angle);
            speed *= travelSpeed;

            if (collidesWithMap().collided)
            {
                destroy = true;

                Light light = new PointLight
                {
                    Position  = new Vector2(getCenter().X, getCenter().Y) - speed,
                    Scale     = new Vector2(500), // Range of the light source (how far the light will travel)
                    Radius    = 1f,
                    Intensity = 1f,

                    Color        = new Color(1f, 0.5f, 0, 1),
                    CastsShadows = false,
                    ShadowType   = ShadowType.Illuminated // Will not lit hulls themselves
                };

                ExplosionHandler.addExplosion(light);
            }
            if (CollidesWithPlayer())
            {
                Game1.getPlayer().die();

                Light light = new PointLight
                {
                    Position  = new Vector2(getCenter().X, getCenter().Y) - speed,
                    Scale     = new Vector2(1500), // Range of the light source (how far the light will travel)
                    Radius    = 1f,
                    Intensity = 1f,

                    Color      = new Color(5f, 0.5f, 0, 1),
                    ShadowType = ShadowType.Solid // Will not lit hulls themselves
                };

                ExplosionHandler.addExplosion(light);
            }
            smokeEmitter.pos       = oldPos;
            smokeEmitter.Direction = angle + Math.PI;
            smokeEmitter.update();

            if (destroy == true)
            {
                particleEmitter.pos = oldPos;
                particleEmitter.start();
                particleEmitter.update();
            }
            oldPos = pos;
            base.Update();
        }
コード例 #30
0
 public Vector2 getMovingVector()
 {
     return(new Vector2((int)(speed * MapTools.getXMultiplier()) + (int)(fallSpeed * (float)(WorldInfo.gravity.X)),
                        (int)(speed * MapTools.getYMultiplier()) + (int)(fallSpeed * (float)(WorldInfo.gravity.Y))));
 }