Esempio n. 1
0
 public void Clear()
 {
     SpeedModifier   = 1.0f;
     Loft            = 0.0f;
     Strength        = 0.0f;
     CreatableId     = Guid.Empty;
     Pronoun         = PronounModifier.Pronouns.None;
     Reset           = ResetModifier.Resets.None;
     Color           = Classification.Colors.None;
     Pitch           = PitchModifier.PitchDirections.None;
     Turn            = TurnModifier.TurnDirections.None;
     Make            = MakeObjectModifier.MakeObjects.None;
     Item            = ObjectModifier.ModifierObjects.None;
     TaskId          = TaskModifier.TaskIds.SIZEOF;
     Direction       = Programming.Directions.None;
     Facial          = Face.FaceState.NotApplicable;
     ExpressEmitter  = ExpressModifier.Emitters.NotApplicable;
     Verb            = GameThing.Verbs.None;
     MissileBehavior = MissileChassis.BehaviorFlags.TerrainFollowing;
     Constraints     = ConstraintModifier.Constraints.None;
     SoundUpid       = String.Empty;
     Points          = 0;
     PlayerIndex     = GamePadSensor.PlayerId.Dynamic;
     ScoreBucket     = ScoreBucket.NotApplicable;
 }
        public override ActionSet ComposeActionSet(Reflex reflex, GameActor gameActor)
        {
            ClearActionSet(actionSet);
            //UpdateCanBlend(reflex);

            if (!reflex.targetSet.AnyAction)
            {
                return(actionSet);
            }

            TurnModifier         turnMod         = reflex.GetModifierByType(typeof(TurnModifier)) as TurnModifier;
            GamePadStickFilter   stickFilt       = reflex.Data.GetFilterByType(typeof(GamePadStickFilter)) as GamePadStickFilter;
            GamePadTriggerFilter triggerFilt     = reflex.Data.GetFilterByType(typeof(GamePadTriggerFilter)) as GamePadTriggerFilter;
            MouseFilter          mouseFilt       = reflex.Data.GetFilterByType(typeof(MouseFilter)) as MouseFilter;
            TouchGestureFilter   touchFilt       = reflex.Data.GetFilterByType(typeof(TouchGestureFilter)) as TouchGestureFilter;
            KeyBoardKeyFilter    keyBoardKeyFilt = reflex.Data.GetFilterByType(typeof(KeyBoardKeyFilter)) as KeyBoardKeyFilter;

            // Will be modified depending on stick or trigger position.
            float speedModifier = 1.0f;

            //
            // Start by looking at the input filters to attenuate speed.
            //

            if (stickFilt != null)
            {
                // Note that we take the sign into account further below.
                // For now, just get the magnitude.
                speedModifier *= (float)Math.Abs(stickFilt.stickPosition.X);
            }
            else if (triggerFilt != null)
            {
                speedModifier *= triggerFilt.triggerValue;
            }
            else if (mouseFilt != null)
            {
                // Note that we take the sign into account further below.
                // For now, just get the magnitude.
                speedModifier *= Math.Abs(mouseFilt.ScreenPosition.X);
            }
            else if (touchFilt != null)
            {
                if (touchFilt.type == TouchGestureFilterType.Rotate)
                {
                    reflex.Task.GameActor.Chassis.WasTouchRotated = true;
                }
            }

            // Decide if we're turning toward a particular direction or
            // setting a turn rate.  Note, this will miss some cases
            // that we clean up further down.  The failure is rooted
            // in TurnModifier if you want to go fix it.  :-)

            Vector3 desiredHeading = Vector3.Zero;
            float   targetHeading  = 0;

            // See if the modifiers want to give us an absolute direction.
            reflex.ModifyHeading(gameActor, Modifier.ReferenceFrames.World, ref desiredHeading);
            targetHeading = MyMath.ZRotationFromDirection(desiredHeading);

            // If we have a desiredHeading, use that, else assume we're just turning.
            if (desiredHeading != Vector3.Zero)
            {
                // We were given an absolute direction, use it.
                actionSet.AddActionTarget(Action.AllocHeadingAction(reflex, targetHeading, speedModifier));
            }
            else
            {
                // Determine which relative direction we should use.
                TurnModifier.TurnDirections direction = TurnModifier.TurnDirections.None;

                if (turnMod != null)
                {
                    // If a turn modifier was specified, use its direction.
                    direction = turnMod.direction;
                }
                else if (stickFilt != null)
                {
                    // No turn modifier but we have a gamepad stick, use it to determine turn direction.
                    direction = stickFilt.stickPosition.X > 0 ? TurnModifier.TurnDirections.Right : TurnModifier.TurnDirections.Left;
                }
                else if (triggerFilt != null)
                {
                    // No turn modifier but we have a gamepad trigger, use it to determine turn direction.
                    // Basically this automatically maps left trigger to left turn and right trigger to right turn.
                    direction = triggerFilt.trigger == GamePadTriggerFilter.GamePadTrigger.LeftTrigger ? TurnModifier.TurnDirections.Left : TurnModifier.TurnDirections.Right;
                }
                else if (mouseFilt != null)
                {
                    // No turn modifier but we do have mouse input.
                    direction = mouseFilt.ScreenPosition.X > 0 ? TurnModifier.TurnDirections.Right : TurnModifier.TurnDirections.Left;
                    // This scaling by 2 has no real justification except
                    // that it matches the magnitude of the original code
                    // so this is more compatible with older games.
                    speedModifier *= 2.0f;
                }
                else if (touchFilt != null)
                {
                    // No turn modifier but we do have touch input.
                    if (touchFilt.type == TouchGestureFilterType.Rotate)
                    {
                        if (touchFilt.DeltaRotation < 0)
                        {
                            direction = TurnModifier.TurnDirections.Left;
                        }
                        else if (touchFilt.DeltaRotation > 0)
                        {
                            direction = TurnModifier.TurnDirections.Right;
                        }
                    }
                    else if (touchFilt.type == TouchGestureFilterType.Tap)
                    {
                        direction = TurnModifier.TurnDirections.Toward;
                    }
                }
                else if (keyBoardKeyFilt != null)
                {
                    if (reflex.targetSet != null)
                    {
                        Vector2 dir = (Vector2)(reflex.targetSet.Param);
                        if (dir.X == 1)
                        {
                            direction = TurnModifier.TurnDirections.Right;
                        }
                        else if (dir.X == -1)
                        {
                            direction = TurnModifier.TurnDirections.Left;
                        }
                    }
                }
                else
                {
                    // Nothing exists that would help us decide which way we should turn, choose left.
                    // This could be the user programming WHEN DO Turn
                    direction = TurnModifier.TurnDirections.Left;
                }

                // Calculate the new direction we want to face.
                switch (direction)
                {
                // Turn to our left.
                case TurnModifier.TurnDirections.Left:
                {
                    float angle = 0.0f;

                    if (touchFilt != null && touchFilt.type == TouchGestureFilterType.Rotate)
                    {
                        angle = gameActor.Movement.RotationZ + Math.Abs(touchFilt.DeltaRotation);
                    }
                    else
                    {
                        angle = gameActor.Movement.RotationZ + MathHelper.PiOver2;
                    }
                    desiredHeading = new Vector3((float)Math.Cos(angle), (float)Math.Sin(angle), 0);

                    actionSet.AddActionTarget(Action.AllocTurnSpeedAction(reflex, speedModifier), 0);
                }
                break;

                // Turn to our right.
                case TurnModifier.TurnDirections.Right:
                {
                    float angle = 0.0f;

                    if (touchFilt != null && touchFilt.type == TouchGestureFilterType.Rotate)
                    {
                        angle = gameActor.Movement.RotationZ - Math.Abs(touchFilt.DeltaRotation);
                    }
                    else
                    {
                        angle = gameActor.Movement.RotationZ - MathHelper.PiOver2;
                    }

                    desiredHeading = new Vector3((float)Math.Cos(angle), (float)Math.Sin(angle), 0);

                    actionSet.AddActionTarget(Action.AllocTurnSpeedAction(reflex, -speedModifier), 0);
                }
                break;

                // Turn to face the direction we are moving.
                case TurnModifier.TurnDirections.Forward:
                {
                    float angle = MyMath.ZRotationFromDirection(gameActor.Movement.Velocity);
                    desiredHeading = new Vector3((float)Math.Cos(angle), (float)Math.Sin(angle), 0);

                    actionSet.AddActionTarget(Action.AllocHeadingAction(reflex, targetHeading, speedModifier));
                }
                break;

                // Turn to face the sensed object.
                case TurnModifier.TurnDirections.Toward:
                    // We're probably here because of WHEN Mouse Left DO Turn Toward.
                    // This is another case where we want a Heading Action.
                    if (reflex.targetSet.Nearest != null)
                    {
                        speedModifier = 1;

                        // If we're doing mouse-look (WHEN Mouse Over DO Turn Toward) try
                        // and create a bit of a dead-zone in the middle.
                        bool mouseOver = false;
                        foreach (Filter f in reflex.Filters)
                        {
                            MouseFilter mf = f as MouseFilter;
                            if (mf != null && mf.type == MouseFilterType.Hover)
                            {
                                mouseOver = true;
                                break;
                            }
                        }

                        desiredHeading = reflex.targetSet.Nearest.Direction;
                        targetHeading  = MyMath.ZRotationFromDirection(desiredHeading);

                        // If mouseOver, calc damping to slow down turning when already looking
                        // in the direction we want.  This helps make it less twitchy.
                        float dampingFactor = 1.0f;
                        if (mouseOver)
                        {
                            float dot = Vector3.Dot(desiredHeading, gameActor.Movement.Heading);

                            float deadzoneAngle = 0.96f;
                            float dampzoneAngle = 0.9f;

                            // If very close to center, just treat as zero.
                            if (dot > deadzoneAngle)
                            {
                                dampingFactor = 0;
                            }
                            else if (dot > dampzoneAngle)
                            {
                                // Not in center, but close so damp turning.
                                // The closer we are to already looking in the correct direction, increase damping.
                                dampingFactor = MyMath.RemapRange(dot, deadzoneAngle, dampzoneAngle, 0, 1);
                                // Smooth the result to flatten out the center.
                                dampingFactor = MyMath.SmoothStep(0, 1, dampingFactor);
                            }
                        }

                        actionSet.AddActionTarget(Action.AllocHeadingAction(reflex, targetHeading, dampingFactor * speedModifier));
                    }
                    break;
                }
            }

            return(actionSet);
        }   // end of ComposeActionSet()