예제 #1
0
        protected virtual void CollideWith(CollidableObject obj)
        {
            if (obj == null)
            {
                return;
            }

            else if (obj is Unit)
            {
                Unit unit = (Unit)obj;
                if (IsCollide(unit))
                {
                    Vel.Y = -Maxvel.Y * 3;
                    Vel.X = -Vel.X * XBound;
                    HP   -= unit.Attack;
                    OnCollide(unit);
                }
            }
            else if (obj is Bullet)
            {
                Bullet bullet = (Bullet)obj;
                if (IsCollide(bullet))
                {
                    //HPとかはbulletクラス
                    OnCollide(bullet);
                }
            }
        }
예제 #2
0
        /// <summary>
        /// Updates the collisions between a list of entities and a particular object
        /// by brute force iteration over all the entities.
        /// </summary>
        /// <param name="entities"></param>
        /// <param name="obj"></param>
        private void UpdateObjectEntityCollisions(List <CollidableObject> entities, CollidableObject obj)
        {
            foreach (var item in entities)
            {
                Vector2 penDepth;
                if (obj.CheckCollision(item, out penDepth))
                {
                    RecordCollision(obj, item);

                    CollisionType type = CollisionType.stay;

                    if (!wasCollidingWith(obj, item))//Weren't colliding before-> collision enter
                    {
                        type = CollisionType.enter;
                    }

                    Player player = obj as Player;
                    if (player != null)
                    {
                        GameEventManager.Instance.PlayerCollision(player, item, penDepth, type);
                    }
                    else
                    {
                        GameEventManager.Instance.NonPlayerCollision(obj, item, penDepth);
                    }
                }
            }
        }
    private void OnSelectedObjectManipulatorTriggerEnter(Collider otherCollider)
    {
        ObjectManipulator currentObjectManipulator = objectManipulationInputController.CurrentObjectManipulator;
        CollidableObject  componentInParent        = otherCollider.gameObject.GetComponentInParent <CollidableObject>();

        if (componentInParent != null && currentObjectManipulator != null)
        {
            switch (objectManipulationInputController.GetCollisionRule(componentInParent))
            {
            case CollisionRuleResult.Stack:
            case CollisionRuleResult.StackXNormal:
                break;

            case CollisionRuleResult.Intersect:
                break;

            case CollisionRuleResult.NotAllowed:
                currentObjectManipulator.CollisionIsValid = false;
                break;

            case CollisionRuleResult.Squash:
                componentInParent.IsSquashed = true;
                break;
            }
        }
    }
예제 #4
0
 public NonPlayerCollisionEventArgs(CollidableObject collider, object colllidedWith, Vector2 collisionDepth, CollisionType collisionType)
 {
     this.collider       = collider;
     this.colllidedWith  = colllidedWith;
     this.collisionDepth = collisionDepth;
     this.collisionType  = collisionType;
 }
예제 #5
0
        private void CollideWith(CollidableObject obj)
        {
            if (obj == null)
            {
                return;
            }

            if (obj is Bullet)
            {
                CollidableObject bullet = obj;

                if (IsCollide(bullet))
                {
                    OnCollide(bullet);
                    bullet.OnCollide(this);
                    asd.Engine.AddObject2D(new ItemGetEffect_PenetrateTriShot(new asd.Vector2DF(320, 240)));
                }
            }

            if (obj is PenetrateBullet)
            {
                CollidableObject bullet = obj;

                if (IsCollide(bullet))
                {
                    OnCollide(bullet);
                    //bullet.OnCollide(this);
                    asd.Engine.AddObject2D(new ItemGetEffect_PenetrateTriShot(new asd.Vector2DF(320, 240)));
                }
            }
        }
 private void removeObjectManipulators()
 {
     modifyObjectManipulators(delegate(GameObject go, DecorationLayoutData data)
     {
         ManipulatableObjectEffects component = go.GetComponent <ManipulatableObjectEffects>();
         if ((bool)component)
         {
             UnityEngine.Object.Destroy(component);
         }
         ManipulatableObject component2 = go.GetComponent <ManipulatableObject>();
         if ((bool)component2)
         {
             component2.OnRemoved           -= onObjectRemoved;
             component2.BeforeParentChanged -= onBeforeManipulatableObjectReParented;
             component2.AfterParentChanged  -= onAfterManipulatableObjectReParented;
             UnityEngine.Object.Destroy(component2);
         }
         CollidableObject component3 = go.GetComponent <CollidableObject>();
         if ((bool)component3)
         {
             UnityEngine.Object.Destroy(component3);
         }
         for (int i = 0; i < sceneModifiers.Length; i++)
         {
             sceneModifiers[i].ObjectRemoved(data, go);
         }
     });
 }
        private void linkManipulatableObjectWithDefinition(ManipulatableObject mo, CollidableObject co, DecorationLayoutData data)
        {
            CollisionRuleSetDefinitionKey collisionRuleSet = null;

            switch (data.Type)
            {
            case DecorationLayoutData.DefinitionType.Decoration:
            {
                if (decorationDefinitions.TryGetValue(data.DefinitionId, out var value2))
                {
                    collisionRuleSet = value2.RuleSet;
                    mo.Type          = DecorationLayoutData.DefinitionType.Decoration;
                    mo.DefinitionId  = value2.Id;
                }
                break;
            }

            case DecorationLayoutData.DefinitionType.Structure:
            {
                if (structureDefinitions.TryGetValue(data.DefinitionId, out var value))
                {
                    collisionRuleSet = value.RuleSet;
                    mo.Type          = DecorationLayoutData.DefinitionType.Structure;
                    mo.DefinitionId  = value.Id;
                }
                break;
            }
            }
            co.CollisionRuleSet = collisionRuleSet;
        }
예제 #8
0
 public CollisionRuleResult GetCollisionRule(CollidableObject installedDecoration)
 {
     if (CurrentlySelectedObject != null)
     {
         CollidableObject component = CurrentlySelectedObject.GetComponent <CollidableObject>();
         if (component == null || component.CollisionRuleSet == null || installedDecoration == null || component.CollisionRuleSet == null)
         {
             Log.LogError(this, "Problem: Installed decoration or selected object is not tracked properly and the placement rule cannot be found. Defaulting to stacking");
             return(CollisionRuleResult.Stack);
         }
         if (decorationInstallationRulesets.ContainsKey(installedDecoration.CollisionRuleSet.Id))
         {
             CollisionRuleSetDefinition collisionRuleSetDefinition = decorationInstallationRulesets[component.CollisionRuleSet.Id];
             CollisionRuleDefinition[]  installedItemRules         = collisionRuleSetDefinition.InstalledItemRules;
             foreach (CollisionRuleDefinition collisionRuleDefinition in installedItemRules)
             {
                 if (collisionRuleDefinition.InstalledItem.Id == installedDecoration.CollisionRuleSet.Id)
                 {
                     return(collisionRuleDefinition.Result);
                 }
             }
             throw new InvalidOperationException(string.Format("No rule was found for the combination {0} and {1} on of the selected object {0} and the installed object", component.CollisionRuleSet.Id, installedDecoration.CollisionRuleSet.Id, CurrentlySelectedObject, installedDecoration.gameObject));
         }
         Log.LogErrorFormatted(this, "Unknown rule: {0}, found for the selected item {1}. Defaulting to stacking", installedDecoration.CollisionRuleSet.Id, CurrentlySelectedObject);
         return(CollisionRuleResult.Stack);
     }
     throw new InvalidOperationException("Selected item is null");
 }
예제 #9
0
        //want do we want to do now that we have collided with an object?
        private void HandleCollisions(CollidableObject collidableObjectCollider, CollidableObject collidableObjectCollidee)
        {
            //did the "as" typecast return a valid object?
            if (collidableObjectCollidee != null)
            {
                if (collidableObjectCollidee.ActorType == ActorType.CollidablePickup)
                {
                    #region DEMO COLLISION RESPONSE FOR PICKUPS
                    EventDispatcher.Publish(new EventData(collidableObjectCollidee, EventActionType.OnRemoveActor, EventCategoryType.SystemRemove));

                    //after fixing the event dispatcher update() method we can not successfully increment UI and/or send other events (e.g. play sound)
                    object[] additionalEventParams = { AppData.PlayerOneProgressControllerID, 1 };
                    EventDispatcher.Publish(new EventData(EventActionType.OnHealthDelta, EventCategoryType.Player, additionalEventParams));

                    object[] additionalParameters = { "boing" };
                    EventDispatcher.Publish(new EventData(EventActionType.OnPlay, EventCategoryType.SoundStart, additionalParameters));

                    //do whatever you want here when you hit a collidable pickup...
                    #endregion
                }
                //add else if statements here for all the responses that you want your player to have
                else if (collidableObjectCollidee.ActorType == ActorType.CollidableDoor)
                {
                }
                else if (collidableObjectCollidee.ActorType == ActorType.CollidableAmmo)
                {
                }
            }
        }
예제 #10
0
파일: Archer.cs 프로젝트: postoakt/archer
 public Archer(ContentManager content)
 {
     texture = content.Load<Texture2D>("Player\\player");
     position.X = 0;
     position.Y = SCREEN_HEIGHT - texture.Height;
     collidable = new CollidableObject(texture, position, 0.0f);
     collidable.Origin = new Vector2(0, 0);
 }
예제 #11
0
 public override void OnCollide(CollidableObject obj)
 {
     Singleton.Getsingleton();
     //Singleton.singleton.itemhaving = サブクラスで定義
     //Singleton.singleton.itemcount = 0; サブクラスで定義
     asd.Engine.Sound.Play(itemGet);
     Dispose();
 }
예제 #12
0
 //Record a collision between object 1 and object 2 (one way only)
 private void RecordCollision(CollidableObject o1, CollidableObject o2)
 {
     if (!collisionsThisFrame.ContainsKey(o1))
     {
         collisionsThisFrame.Add(o1, new HashSet <CollidableObject>());
     }
     collisionsThisFrame[o1].Add(o2);
 }
예제 #13
0
 public override void OnCollide(CollidableObject obj)
 {
     base.OnCollide(obj);
     //Singleton.Getsingleton();
     Singleton.singleton.movebomb_flag = true;
     //asd.Engine.Sound.Play(itemGet);
     //Dispose();
 }
예제 #14
0
 public override void OnCollide(CollidableObject otherObject)
 {
     if (otherObject is PlayerShip)
     {
         (otherObject as PlayerShip).Damage(1);
         Kill = true;
     }
 }
예제 #15
0
 public ArcheryTarget(ContentManager content)
 {
     texture = content.Load<Texture2D>("bullsEye");
     position = new Vector2(SCREEN_WIDTH - texture.Width, 0);
     collidable = new CollidableObject(texture, position, 0.0f);
     collidable.Origin = new Vector2(0, 0);
     moveVelocity = MOVE_SPEED;
 }
예제 #16
0
        public void UpdateZombe(GameTime gameTime, CollidableObject player)
        {
            Move(player);

            position = phys.Update(gameTime, position);
            Vector2 nulled = new Vector2(0, 0);

            phys.Force = nulled;
        }
 //how do we want this object to respond to collisions?
 private void HandleCollisions(CollidableObject collidableObjectCollider, CollidableObject collidableObjectCollidee)
 {
     if (collidableObjectCollidee.ActorType == ActorType.CollidablePickup)
     {
         //remove the object?
         EventDispatcher.Publish(new EventData(collidableObjectCollidee, EventActionType.OnRemoveActor, EventCategoryType.SystemRemove));
         //publish an event to play a sound, increment a score
     }
 }
예제 #18
0
 public override void OnCollide(CollidableObject obj)
 {
     base.OnCollide(obj);
     //Singleton.Getsingleton();
     Singleton.singleton.itemhaving = 4;
     Singleton.singleton.itemcount  = 0;
     //asd.Engine.Sound.Play(itemGet);
     //Dispose();
 }
예제 #19
0
        private void HandleObjectCategoryEvent(EventData eventData)
        {
            if (eventData.EventActionType == EventActionType.OnRemoveActor)
            {
                CollidableObject collidableObject = eventData.Parameters[0] as CollidableObject;

                this.PhysicsSystem.RemoveBody(collidableObject.Body);
            }
        }
예제 #20
0
    public void OnEnable()
    {
        CollidableObject component = GetComponent <CollidableObject>();

        if (component != null)
        {
            component.ReloadColliders();
        }
        base.enabled = false;
    }
예제 #21
0
        //Check whether object 1 and 2 were colliding last frame
        private bool wasCollidingWith(CollidableObject o1, CollidableObject o2)
        {
            HashSet <CollidableObject> set;

            if (collisionsLastFrame.TryGetValue(o1, out set))
            {
                return(set.Contains(o2));
            }
            return(false);
        }
        public override bool CollisionSkin_callbackFn(CollisionSkin collider, CollisionSkin collidee)
        {
            CollidableObject collidableObject = collider.Owner.ExternalData as CollidableObject;

            if (collidableObject.ActorType == GDLibrary.ActorType.Pickup)
            {
                int x = 0;
            }

            return(true);
        }
예제 #23
0
        private void DoShowInfo()
        {
            Vector3          pos, normal;
            CollidableObject pickedObject = mouseManager.GetPickedObject(cameraManager, 10, 1000, out pos, out normal) as CollidableObject;

            //does this object return true in the predicate
            if (collisionPredicate(pickedObject))
            {
                //get info about the health value of the pickup
                int value = (pickedObject as PickupCollidableObject).Value;
                System.Diagnostics.Debug.WriteLine(pickedObject.ID + ", " + value);
            }
        }
예제 #24
0
            /// <summary>
            /// Detects a pixel level collision between two CollidableObjects.
            /// </summary>
            /// <param name="collidable">The CollidableObject to check a collision against</param>
            /// <returns>True if colliding, false if not.</returns>
            public bool IsColliding(CollidableObject collidable)
            {
                bool retval = false;

                if (this.BoundingRectangle.Intersects(collidable.BoundingRectangle))
                {
                    if (IntersectPixels(this.Transform, this.Texture.Width, this.Texture.Height, this.TextureData, collidable.Transform, collidable.Texture.Width, collidable.Texture.Height, collidable.TextureData))
                    {
                        retval = true;
                    }
                }

                return(retval);
            }
    public override void setParent(Transform parent)
    {
        base.setParent(parent);

        CollidableObject childCollidableObject = null;

        for (int i = 0; i < thisTransform.childCount; ++i)
        {
            if ((childCollidableObject = thisTransform.GetChild(i).GetComponent <CollidableObject>()) != null)
            {
                childCollidableObject.setStartParent(thisTransform);
            }
        }
    }
예제 #26
0
    public static string AsText(this CollidableObject obj)
    {
        switch (obj)
        {
        case CollidableObject.Player: return("player");

        case CollidableObject.Enemy: return("enemy");

        case CollidableObject.Platform: return("platform");

        case CollidableObject.Shield: return("shield");

        default: return("empty");
        }
    }
예제 #27
0
        private void DoRemove()
        {
            Vector3          pos, normal;
            CollidableObject pickedObject = mouseManager.GetPickedObject(cameraManager, 10, 1000, out pos, out normal) as CollidableObject;

            //does this object return true in the predicate
            if (collisionPredicate(pickedObject))
            {
                object[] parameters = { pickedObject };
                EventDispatcher.Publish(new EventData(EventCategoryType.Object, EventActionType.OnRemoveActor, parameters));

                //publish other events...
                //play sound, increment player health, start countdown, increment UI
            }
        }
예제 #28
0
        public bool IsSelectedObjectAllowedInCurrentPosition()
        {
            bool result = true;

            foreach (Collider currentCollider in CurrentObjectManipulator.CurrentColliders)
            {
                CollidableObject componentInParent = currentCollider.gameObject.GetComponentInParent <CollidableObject>();
                if (componentInParent != null && GetCollisionRule(componentInParent) == CollisionRuleResult.NotAllowed)
                {
                    result = false;
                    break;
                }
            }
            return(result);
        }
    void OnTriggerEnter2D(Collider2D other)
    {
        if (this.gameObject.tag == "Player")
        {
            switch (other.gameObject.tag)
            {
            // Handles Player and Enemy collision
            case "Enemy_1":
            case "Enemy_2":
                CollidableObject player = this.gameObject.GetComponent <CollidableObject>();
                if (!player.HasCollided)
                {
                    _explosion.Play();
                    CollidableObject enemy = other.gameObject.GetComponent <CollidableObject>();
                    gameController.Lives -= 1;
                    enemy.HasCollided     = true;
                    player.HasCollided    = true;
                }
                break;

            // Handles Player and Asteroid collision
            case "Asteroid":
                AsteroidController asteroid = other.gameObject.GetComponent <AsteroidController>();
                if (!asteroid.HasCollided)
                {
                    _ding.Play();
                    gameController.Score += 100;
                    asteroid.HasCollided  = true;
                }
                break;
            }
        }
        else if (this.gameObject.tag == "Bullet")
        {
            switch (other.gameObject.tag)
            {
            // Handles Bullet and Enemy collision
            case "Enemy_1":
            case "Enemy_2":
                _explosion.Play();
                CollidableObject enemy  = other.gameObject.GetComponent <CollidableObject>();
                CollidableObject bullet = this.gameObject.GetComponent <CollidableObject>();
                enemy.Reset();
                bullet.Reset();
                break;
            }
        }
    }
예제 #30
0
        public void Move(CollidableObject player)
        {
            Vector2 mousePosition = new Vector2(player.position.X, player.position.Y);

            Vector2 direction = mousePosition - position;

            direction.Normalize();

            rotation = (float)Math.Atan2((double)direction.Y, (double)direction.X);
            // движение к персонажу

            var directory = new Vector2((float)Math.Cos(MathHelper.ToRadians(90) - rotation), -(float)Math.Sin(MathHelper.ToRadians(90) - rotation));

            phys.Force.X = (float)Math.Sin(MathHelper.ToRadians(90) - rotation) * 4f;
            phys.Force.Y = (float)Math.Cos(MathHelper.ToRadians(90) - rotation) * 4f;
        }
예제 #31
0
        public void AddCollisionSkinVertexData(CollidableObject collidableObject)
        {
            if (!collidableObject.Body.CollisionSkin.GetType().Equals(typeof(JigLibX.Geometry.Plane)))
            {
                wf = collidableObject.Collision.GetLocalSkinWireframe();

                // if the collision skin was also added to the body
                // we have to transform the skin wireframe to the body space
                if (collidableObject.Body.CollisionSkin != null)
                {
                    collidableObject.Body.TransformWireframe(wf);
                }

                AddVertexDataForShape(wf, collidableObject.EffectParameters.DiffuseColor);
            }
        }
예제 #32
0
        private void DoLift()
        {
            if (!bCurrentlyPicking)
            {
                camera = cameraManager.ActiveCamera;
                currentPickedObject = mouseManager.GetPickedObject(cameraManager,
                                                                   pickStartDistance, pickEndDistance, out pos, out normal) as CollidableObject;
                if (currentPickedObject != null)
                {
                    Vector3 vectorDeltaFromCentreOfMass = pos - currentPickedObject.Collision.Owner.Position;
                    vectorDeltaFromCentreOfMass = Vector3.Transform(vectorDeltaFromCentreOfMass, Matrix.Transpose(currentPickedObject.Collision.Owner.Orientation));
                    cameraPickDistance          = (camera.Transform3D.Translation - pos).Length();

                    //remove any controller from any previous pick-release
                    objectController.Destroy();
                    damperController.Destroy();

                    currentPickedObject.Collision.Owner.SetActive();
                    //move object by pos (i.e. point of collision and not centre of mass)
                    objectController.Initialise(currentPickedObject.Collision.Owner, vectorDeltaFromCentreOfMass, pos);
                    //dampen velocity (linear and angular) on object to Zero
                    damperController.Initialise(currentPickedObject.Collision.Owner, ConstraintVelocity.ReferenceFrame.Body, Vector3.Zero, Vector3.Zero);
                    objectController.EnableConstraint();
                    damperController.EnableConstraint();
                    //we're picking a valid object for the first time
                    bCurrentlyPicking = true;
                }

                //if we have an object picked from the last update then move it according to the mouse pointer
                if (objectController.IsConstraintEnabled && (objectController.Body != null))
                {
                    // Vector3 delta = objectController.Body.Position - this.camera.Transform.Translation;
                    Vector3 direction = mouseManager.GetMouseRay(camera).Direction;
                    cameraPickDistance += mouseManager.GetDeltaFromScrollWheel() * 0.1f;

                    //set the desired world position
                    objectController.WorldPosition = camera.Transform3D.Translation + cameraPickDistance * direction;
                    objectController.Body.SetActive();
                }
            }
            else //releasing object
            {
                //release object from constraints and allow to behave as defined by gravity etc
                objectController.DisableConstraint();
                damperController.DisableConstraint();
            }
        }
예제 #33
0
파일: Arrow.cs 프로젝트: postoakt/archer
 public Arrow(ContentManager content, float x, float y)
 {
     changeY = 0;
     docked = true;
     inAir = true;
     isOnTarget = false;
     texture = content.Load<Texture2D>("Player\\arrow");
     Position.X = x;
     Position.Y = y;
     Origin.X = 2;
     Origin.Y = 2;
     rotation = 0;
     Collidable = new CollidableObject(texture, Position, rotation);
     Collidable.LoadTexture(texture, Origin);
     beenshot = false;
     stopxveloc = false;
     archerytarget = new ArcheryTarget(content);
 }
예제 #34
0
파일: Menu.cs 프로젝트: postoakt/archer
        public Menu(ContentManager content)
        {
            xPos = 410;
            archer = content.Load<Texture2D>("Menu\\archer");
            target = content.Load<Texture2D>("Menu\\target");
            bear = content.Load<Texture2D>("Menu\\bear");
            exit = content.Load<Texture2D>("Menu\\exit");

            archerbox = new Rectangle();
            targetbox = new Rectangle();
            bearbox = new Rectangle();
            exitbox = new Rectangle();

            archerbox.X = xPos;
            targetbox.X = xPos;
            bearbox.X = xPos;
            exitbox.X = xPos;

            archerbox.Y = ORIGARCHPOS;
            targetbox.Y = ORIGARCHPOS + 180;
            bearbox.Y = ORIGARCHPOS + 180 + 80;
            exitbox.Y = ORIGARCHPOS + 180 + 80 + 80;

            archerbox.Width = archer.Width;
            archerbox.Height = archer.Height;

            targetbox.Width = target.Width;
            targetbox.Height = target.Height;

            bearbox.Width = bear.Width;
            bearbox.Height = bear.Height;

            exitbox.Width = exit.Width;
            exitbox.Height = exit.Height;
            archerCollide = new CollidableObject(archer, new Vector2(archerbox.X, archerbox.Y));
            targetCollide = new CollidableObject(target, new Vector2(targetbox.X, targetbox.Y));
            bearCollide = new CollidableObject(bear, new Vector2(bearbox.X, bearbox.Y));
            exitCollide = new CollidableObject(exit, new Vector2(exitbox.X, exitbox.Y));
            archerCollide.Origin = new Vector2(0, 0);
            targetCollide.Origin = new Vector2(0, 0);
            bearCollide.Origin = new Vector2(0, 0);
            exitCollide.Origin = new Vector2(0, 0);
        }
예제 #35
0
파일: Nyan.cs 프로젝트: postoakt/archer
 public Nyan(ContentManager content)
 {
     rand = new Random();
     elapsed = 0;
     randlapsed = 0f;
     deadlapsed = 0f;
     isDead = false;
     nyan1 = content.Load<Texture2D>("Nyan\\nyan1");
     nyan2 = content.Load<Texture2D>("Nyan\\nyan2");
     nyanDead = content.Load<Texture2D>("Nyan\\nyandead");
     texture = nyan1;
     position.X = -300;
     position.Y = 3;
     angle = 0;
     Collidable = new CollidableObject(texture, position);
     nyanSongIsPlaying = false;
     meowHasPlayed = false;
     thudHasPlayed = false;
 }
예제 #36
0
파일: Bear.cs 프로젝트: postoakt/archer
        public CollidableObject getCollidable()
        {
            CollidableObject collidable;
            Texture2D theTexture;

            #region assignTexture
            switch (bearState)
            {
                case BearState.Walking:

                    switch (walkingAnime.currFrame)
                    {
                        case 0:
                            theTexture = bearWalk1;
                            break;
                        case 1:
                            theTexture = bearWalk2;
                            break;
                        case 2:
                            theTexture = bearWalk3;
                            break;
                        case 3:
                            theTexture = bearWalk4;
                            break;
                        default: theTexture = bearWalk1;
                            break;
                    }
                    break;
                case BearState.Rolling:
                    switch (rollingAnime.currFrame)
                    {
                        case 0:
                            theTexture = bearRoll1;
                            break;
                        case 1:
                            theTexture = bearRoll2;
                            break;
                        case 2:
                            theTexture = bearRoll3;
                            break;
                        case 3:
                            theTexture = bearRoll4;
                            break;
                        default:
                            theTexture = bearRoll1;
                            break;
                    }
                    break;
                case BearState.Jumping:
                    switch (jumpingAnime.currFrame)
                    {
                        case 0:
                            theTexture = bearJump1;
                            break;
                        case 1:
                            theTexture = bearJump2;
                            break;
                        default: theTexture = bearJump1;
                            break;
                    }
                   break;
                default: theTexture = bearWalk1;
                   break;
            }
            #endregion

            collidable = new CollidableObject(theTexture, position);
            collidable.LoadTexture(theTexture);
            collidable.Origin = new Vector2(0, 0);
            return collidable;
        }
예제 #37
0
파일: Game1.cs 프로젝트: postoakt/archer
        public void HandleCollisions()
        {
            nyanCollide = nyancat.getCollidableObject();
            bool resetarrows = false;

            foreach (Arrow arrow in bow.getArrows() )
            {
                if (!arrow.isinAir && arrow.isonTarget())
                {
                    arrow.changeArcheryTargetPosY(archeryTarget.getPosition().Y);
                }

                if (arrow.isinAir == true)
                {
                    if (arrow.getCollidableObject().IsColliding(nyanCollide))
                    {
                        nyancat.isdead();
                    }

                    switch (gameState)
                    {
                        case GameState.Target:

                                if (arrow.getCollidableObject().IsColliding(archeryTarget.getCollidable()) )
                                {
                                    arrow.isinAir = false;
                                    arrow.velocity = new Vector2(0, 0);
                                    arrow.onTarget(Math.Abs(arrow.position.Y - archeryTarget.getPosition().Y), archeryTarget, Content);
                                    targetModeScore += 50;
                                }

                                if (arrow.position.Y < 10 && arrow.position.X < 100)
                                {
                                    resetarrows = true;
                                    gameState = GameState.Menu;
                                }
                            break;
                        case GameState.Bear:
                            foreach (Bear bear in bearMode.getBears())
                            {
                                if (!bear.isDead)
                                {
                                    if ( !arrow.isDocked() && arrow.getCollidableObject().IsColliding(bear.getCollidable()) )
                                    {
                                            bear.isDead = true;
                                            bearMode.bearsKilled += 1;
                                            arrow.stopXVeloc();
                                    }

                                    if (player.getCollidable().IsColliding(bear.getCollidable()))
                                    {
                                        resetarrows = true;
                                        gameState = GameState.GameOver;
                                    }
                                }
                            }
                            break;
                        case GameState.Menu:

                            if (arrow.getCollidableObject().IsColliding(menuObjects[0])) // "Archer" logo
                            {
                                arrow.isinAir = false;
                            }
                            if (arrow.getCollidableObject().IsColliding(menuObjects[1])) // "Target" logo
                            {
                                arrow.isinAir = false;
                                resetarrows = true;
                                gameState = GameState.Target;
                                break;
                            }
                            if (arrow.getCollidableObject().IsColliding(menuObjects[2])) // "Bear" logo
                            {
                                arrow.isinAir = false;
                                resetarrows = true;
                                gameState = GameState.Bear;
                                bearMode.reset();
                                break;
                            }
                            if (arrow.getCollidableObject().IsColliding(menuObjects[3]) ) // "Exit" logo
                            {
                                this.Exit();
                            }

                            if (arrow.position.Y < 10 && arrow.position.X < 100 && !LoggedIn)          // "Login" logo
                            {
                                resetarrows = true;
                                gameState = GameState.Login;
                            }

                            break;
                    } // switch statement

                } // if isInAir
            } // foreach arrow

            if (resetarrows)
            {
                bow.resetArrows(Content);
            }
        }