public override void Initialize(Stage stage)
{
base.Initialize(stage);
if (actor.Parm.HasParm("AddToAIQB") && actor.Parm.GetBool("AddToAIQB"))
stage.GetQB<AIQB>().AddLiveEnemy(actor);
if (actor.PhysicsObject.physicsType == PhysicsObject.PhysicsType.Box)
{
//if we are a platform
if (actor.Parm.HasParm("Platform") && actor.Parm.GetBool("Platform"))
{
actor.PhysicsObject.CollisionInformation.CollisionRules.Group = PhysicsQB.platformGroup;
bloodOnDamage = false;
}
else
actor.PhysicsObject.CollisionInformation.CollisionRules.Group = PhysicsQB.normalAIGroup;
actor.PhysicsObject.CollisionInformation.Entity.IsAffectedByGravity = false;
stunnable = false;
}
else if(actor.PhysicsObject.physicsType == PhysicsObject.PhysicsType.CylinderCharacter)
{
actor.PhysicsObject.CollisionInformation.CollisionRules.Group = PhysicsQB.normalAIGroup;
actor.PhysicsObject.CylinderCharController.HorizontalMotionConstraint.Speed = 0;
}
}
/// <summary>
/// Creates a camera.
/// </summary>
/// <param name="position">Initial position of the camera.</param>
/// <param name="speed">Speed of the camera per second.</param>
/// <param name="pitch">Initial pitch angle of the camera.</param>
/// <param name="yaw">Initial yaw value of the camera.</param>
/// <param name="projectionMatrix">Projection matrix used.</param>
public FreeCamera(Vector3 position, float speed, float pitch, float yaw, Matrix projectionMatrix, Stage stage)
{
Position = position;
Speed = speed;
Yaw = yaw;
Pitch = pitch;
ProjectionMatrix = projectionMatrix;
ControlsQB controlsQB = stage.GetQB<ControlsQB>();
moveForward = controlsQB.GetInputAction("MoveForward");
moveRight = controlsQB.GetInputAction("MoveRight");
moveUp = controlsQB.GetInputAction("FreeCamMoveUp");
rotateUp = controlsQB.GetInputAction("FreeCamRotateUp");
rotateRight = controlsQB.GetInputAction("FreeCamRotateRight");
speedMultiplier = controlsQB.GetInputAction("FreeCamSpeed");
}
// position and rotation come from world parm file, which we dont have access to here
/*public PhysicsObject(PhysicsType physicsType, Model model, Vector3 position, float mass)
{
this.physicsType = physicsType;
int id = idCounter++;
if (DisableMass)
mass = -1.0f;
switch (physicsType)
{
case PhysicsType.Box:
spaceObject = PhysicsHelpers.ModelToPhysicsBox(model, position, mass);
// boxes contain a broadphase entry which is what shows up in ray casts, so we need to make sure its tag is set to the right id
// this will need to be done fore anything that is an ibroadphaseentryowner
((IBroadPhaseEntryOwner)spaceObject).Entry.Tag = id;
break;
case PhysicsType.StaticMesh:
spaceObject = PhysicsHelpers.ModelToStaticMesh(model, new BEPUphysics.MathExtensions.AffineTransform(position));
//staticmesh's are not ibroadphaseentryowners...they will turn directly on the raycast, so nothing else to set the tag on
break;
case PhysicsType.None:
spaceObject = null;
this.position = position;
return;
}
spaceObject.Tag = id;
Stage.ActiveStage.GetQB<PhysicsQB>().Space.Add(spaceObject);
}*/
/// <summary>
/// Create a physics object
/// </summary>
/// <param name="actor">Actor that we are attached to</param>
/// <param name="Parm">Actor's parm file</param>
/// <param name="model">Actors model (so we can size the collider)</param>
/// <param name="position">Position (from world parm)</param>
/// <param name="rotation">Rotation (from world parm)</param>
public PhysicsObject(Actor actor, ParameterSet Parm, Model model, Vector3 position, Vector3 rotation, Stage stage)
{
// **rotation comes in from file as ( pitch, yaw, roll )**
this.actor = actor;
this.physicsType = GameLib.PhysicsObject.PhysicsTypeFromString(Parm.GetString("PhysicsType"));
this.position = position;
this.rotation = Matrix.CreateFromYawPitchRoll(rotation.Y, rotation.X, rotation.Z);
if (ForceStaticMesh)
this.physicsType = PhysicsType.StaticMesh;
switch (this.physicsType)
{
case PhysicsType.Box:
{
float mass;
if (DisableMass)
mass = -1.0f;
else
mass = Parm.GetFloat("Mass");
BEPUphysics.Entities.Entity entity = PhysicsHelpers.ModelToPhysicsBox(model, position, mass, rotation.X, rotation.Y, rotation.Z);
entity.CollisionInformation.OwningActor = actor;
spaceObject = entity;
break;
}
case PhysicsType.StaticMesh:
BEPUphysics.Collidables.StaticMesh mesh = PhysicsHelpers.ModelToStaticMesh(model, new BEPUphysics.MathExtensions.AffineTransform(Quaternion.CreateFromRotationMatrix( this.rotation ), position));
mesh.OwningActor = actor;
spaceObject = mesh;
break;
case PhysicsType.Character:
{
float mass = Parm.GetFloat("Mass");
float scaleRadius = 1.0f;
if (Parm.HasParm("ScaleRadius"))
scaleRadius = Parm.GetFloat("ScaleRadius");
characterController = PhysicsHelpers.ModelToCharacterController(model, position, mass, scaleRadius);
spaceObject = characterController.Body;
characterController.Body.CollisionInformation.OwningActor = actor;
stage.GetQB<PhysicsQB>().AddToSpace(CharacterController);
return;
}
case PhysicsType.CylinderCharacter:
{
float mass = Parm.GetFloat("Mass");
float scaleRadius = 1.0f;
if (Parm.HasParm("ScaleRadius"))
scaleRadius = Parm.GetFloat("ScaleRadius");
if (Parm.HasParm("ColliderDims"))
{
Vector2 v = Parm.GetVector2("ColliderDims");
cylinderCharController = new CylinderCharacterController(position, v.Y, v.X, mass);
}
else
cylinderCharController = PhysicsHelpers.ModelToCylinderCharacterController(model, position, mass, scaleRadius);
cylinderCharController.Body.Orientation = Quaternion.CreateFromYawPitchRoll(rotation.Y, rotation.X, rotation.Z);
spaceObject = cylinderCharController.Body;
cylinderCharController.Body.CollisionInformation.OwningActor = actor;
stage.GetQB<PhysicsQB>().AddToSpace(cylinderCharController);
return;
}
case PhysicsType.TriggerVolume:
{
DetectorVolume detectorVolume = new DetectorVolume(PhysicsHelpers.ModelToTriangleMesh(model, position));
detectorVolume.OwningActor = actor;
spaceObject = detectorVolume;
detectorVolume.EntityBeganTouching += new EntityBeginsTouchingVolumeEventHandler(detectorVolume_EntityBeganTouching);
detectorVolume.EntityStoppedTouching += new EntityStopsTouchingVolumeEventHandler(detectorVolume_EntityStoppedTouching);
break;
}
case PhysicsType.None:
spaceObject = null;
this.position = position;
this.rotation = Matrix.CreateFromYawPitchRoll(rotation.Y, rotation.X, rotation.Z);
return;
}
stage.GetQB<PhysicsQB>().AddToSpace(spaceObject);
}
public override void Initialize(Stage stage)
{
track = 0.0f;
track = actor.PhysicsObject.Position.Z;
Space = stage.GetQB<PhysicsQB>().Space;
//input actions
ControlsQB controlsQB = stage.GetQB<ControlsQB>();
strum = controlsQB.GetInputAction("Strum");
A = controlsQB.GetInputAction("A");
B = controlsQB.GetInputAction("B");
Y = controlsQB.GetInputAction("Y");
X = controlsQB.GetInputAction("X");
leftBumper = controlsQB.GetInputAction("LeftBumper");
rightBumper = controlsQB.GetInputAction("RightBumper");
triggers = controlsQB.GetInputAction("Triggers");
leftAxisX = controlsQB.GetInputAction("MoveRight");
guitarJump = controlsQB.GetInputAction("GuitarJump");
//set move direction
//TODO: look this up in a parm
MoveDirection = PlayerDirection.Right;
//get attack list
attacks = new Engine.AttackSystem.ComboSystem("MoveList");
//set camera
CameraQB cameraQB = stage.GetQB<CameraQB>();
PlayerCamera playerCamera = new PlayerCamera(actor.PhysicsObject, CameraQB.DefaultProjectionMatrix);
playerCamera.Reset();
cameraQB.JumpToCamera(playerCamera);
//animations
playerAnimation = actor.GetAgent<PlayerAnimationAgent>();
State = PlayerState.Normal;
facing = PlayerDirection.Right;
//dashing & lock on range
if (Player.PhysicsObject.physicsType == PhysicsObject.PhysicsType.Character)
{
Player.PhysicsObject.CollisionInformation.CollisionRules.Group = PhysicsQB.playerGroup;
if (Player.Parm.HasParm("DashSpeed"))
Player.PhysicsObject.CharacterController.DashSpeed = Player.Parm.GetFloat("DashSpeed");
if (Player.Parm.HasParm("DashTime"))
Player.PhysicsObject.CharacterController.DashTime = Player.Parm.GetFloat("DashTime");
}
//combat
input = new ButtonInput();
smash = 0;
//support for the flow mechanic
flow = new Flow();
//Load the player sounds here
AudioQB AQB = Stage.ActiveStage.GetQB<AudioQB>();
int index = 0;
while (Player.Parm.HasParm("Sound" + index))
{
AQB.AddSound(Player.Parm.GetString("Sound" + index));
index++;
}
if(!Stage.Editor)
isStrumMode = Stage.SaveGame.getStrumMode();
}
public override void Initialize(Stage stage)
{
guitarCont = Stage.Content.Load<Texture2D>("UI/Tutorial/guitarContinueTut");
guitarContDim = new Rectangle((int)(Renderer.ScreenWidth * .5f) - 150, (int)(Renderer.ScreenHeight * .7f), 300, 100);
controllerCont = Stage.Content.Load<Texture2D>("UI/Tutorial/controllerContinueTut");
controllerContDim = new Rectangle((int)(Renderer.ScreenWidth * .5f) - 150, (int)(Renderer.ScreenHeight * .7f), 300, 100);
stage.GetQB<TriggerQB>().RegisterDrawFunction(Draw);
numTuts = actor.Parm.GetInt("Num");
#if INPUTREQUIRED
unpauseInput = new InputAction[numTuts][];
allInputsRequired = new bool[numTuts];
#endif
killEnemies = new bool[numTuts];
spawnEnemy = new bool[numTuts];
triggerDelay = new float[numTuts];
tutImgs = new Microsoft.Xna.Framework.Graphics.Texture2D[numTuts];
imgDim = new Rectangle[numTuts];
//get the control scheme
cQB = stage.GetQB<ControlsQB>();
#if !INPUTREQUIRED
Red = cQB.GetInputAction("B");
strum = cQB.GetInputAction("Strum");
#endif
gp = cQB.GetGamePadType();
Vector2 pos, size;
switch (gp)
{
case Microsoft.Xna.Framework.Input.GamePadType.Guitar:
case Microsoft.Xna.Framework.Input.GamePadType.AlternateGuitar:
for (int j = 0; j < numTuts; j++)
{
#if INPUTREQUIRED
GetInput(j,actor.Parm.GetString("GuitarInput" + j), ref cQB);
#endif
tutImgs[j] = Stage.Content.Load<Texture2D>("UI/Tutorial/" + actor.Parm.GetString("GuitarImage" + j));
pos = actor.Parm.GetVector2("GuitarImagePos" + j);
size = actor.Parm.GetVector2("GuitarImageSize" + j);
imgDim[j] = new Rectangle((int)pos.X, (int)pos.Y, (int)size.X, (int)size.Y);
}
break;
default:
for (int j = 0; j < numTuts; j++)
{
#if INPUTREQUIRED
GetInput(j, actor.Parm.GetString("ControllerInput" + j), ref cQB);
#endif
tutImgs[j] = Stage.Content.Load<Texture2D>("UI/Tutorial/" + actor.Parm.GetString("ControllerImage" + j));
pos = actor.Parm.GetVector2("ControllerImagePos" + j);
size = actor.Parm.GetVector2("ControllerImageSize" + j);
imgDim[j] = new Rectangle((int)pos.X, (int)pos.Y, (int)size.X, (int)size.Y);
}
break;
}
for (int i = 0; i < numTuts; i++)
{
#if INPUTREQUIRED
if (actor.Parm.HasParm("AllInputsRequired" + i))
allInputsRequired[i] = actor.Parm.GetBool("AllInputsRequired" + i);
else
allInputsRequired[i] = false;
#endif
if (actor.Parm.HasParm("SpawnEnemy" + i))
spawnEnemy[i] = actor.Parm.GetBool("SpawnEnemy" + i);
else
spawnEnemy[i] = false;
if (actor.Parm.HasParm("KillEnemies" + i))
killEnemies[i] = actor.Parm.GetBool("KillEnemies" + i);
else
killEnemies[i] = false;
if (actor.Parm.HasParm("TriggerDelay" + i))
triggerDelay[i] = actor.Parm.GetFloat("TriggerDelay" + i);
else
triggerDelay[i] = 0;
}
if (actor.Parm.HasParm("EndLevel"))
returnToMenu = actor.Parm.GetBool("EndLevel");
actor.RegisterUpdateFunction(Update);
UsingOnTriggerEnter = true;
UsingOnTriggerStay = false;
UsingOnTriggerExit = false;
base.Initialize(stage);
}
public override void Initialize(Stage stage)
{
if (actor.Parm.HasParm("DieOnTrigger"))
DieOnTrigger = actor.Parm.GetBool("DieOnTrigger");
// if there is an input action param, we require a button push to trigger
if (actor.Parm.HasParm("InputAction"))
{
requiresButtonPush = true;
ControlsQB cqb = stage.GetQB<ControlsQB>();
inputAction = cqb.GetInputAction(actor.Parm.GetString("InputAction"));
}
// only pay for what we use
if ( UsingOnTriggerEnter )
actor.RegisterBeginCollideFunction(BeginCollide);
if ( UsingOnTriggerExit )
actor.RegisterEndCollideFunction(EndCollide);
if ( UsingOnTriggerStay )
actor.RegisterUpdateFunction(Update);
}
public override void Initialize(Stage stage)
{
base.Initialize(stage);
if (stage.Parm.HasParm("AIRangedSpeedScalar"))
speed *= stage.Parm.GetFloat("AIRangedSpeedScalar");
missileOffset = Vector2.Zero;
if(actor.Parm.HasParm("MissileOffset"))
missileOffset = actor.Parm.GetVector2("MissileOffset");
timeForPogoSkip = .1f;
percAnimForSplat = .45f;
if (actor.Parm.HasParm("MaxJumps"))
maxRocketJumps = actor.Parm.GetInt("MaxJumps");
if (actor.Parm.HasParm("MinJumps"))
minRocketJumps = actor.Parm.GetInt("MinJumps");
if (actor.Parm.HasParm("MaxAttacks"))
maxRocketAttacks = actor.Parm.GetInt("MaxAttacks");
if (actor.Parm.HasParm("MinAttacks"))
minRocketAttacks = actor.Parm.GetInt("MinAttacks");
if (actor.Parm.HasParm("PogoStartTime"))
pogoStartTime = actor.Parm.GetFloat("PogoStartTime");
if (actor.Parm.HasParm("PogoSkipTime"))
timeForPogoSkip = actor.Parm.GetFloat("PogoSkipTime");
if (actor.Parm.HasParm("PercAnimForSplat"))
percAnimForSplat = actor.Parm.GetFloat("PercAnimForSplat");
jumpSpeed = 22;
spawnerIndex = -1;
GetNumJumps();
if (actor.PhysicsObject.physicsType == PhysicsObject.PhysicsType.CylinderCharacter)
{
actor.PhysicsObject.CylinderCharController.HorizontalMotionConstraint.Speed = speed;
actor.PhysicsObject.CollisionInformation.CollisionRules.Group = PhysicsQB.normalAIGroup;
}
shouldAttack = true;
target = PlayerAgent.Player;
state = AIState.Moving;
type = EnemyType.Ranged;
actor.RegisterUpdateFunction(Update);
actor.RegisterDeathFunction(DieFX);
enemyAnimationAgent = actor.GetAgent<RangedEnemyAnimationAgent>();
FaceTargetSnappedToPlane();
Vector3 zero = Vector3.Zero;
_myMissile = stage.GetQB<ActorQB>().CreateActor("Missile", "Missile", ref zero, ref zero, stage);
_myMissile.ShutDown();
}
public override void Initialize(Stage stage)
{
soundName = actor.Parm.GetString("SoundName");
if (actor.Parm.HasParm("Volume"))
volume = actor.Parm.GetFloat("Volume");
if (actor.Parm.HasParm("Pitch"))
pitch = actor.Parm.GetFloat("Pitch");
if (actor.Parm.HasParm("Pan"))
pan = actor.Parm.GetFloat("Pan");
if (actor.Parm.HasParm("Type"))
{
switch (actor.Parm.GetString("Type"))
{
case "Zone":
soundTriggerType = SoundTriggerType.Zone;
break;
case "OneShot":
soundTriggerType = SoundTriggerType.OneShot;
break;
}
}
if (soundTriggerType == SoundTriggerType.Zone)
{
AudioQB audioQB = stage.GetQB<AudioQB>();
soundHandle = audioQB.CreateSoundInstance(soundName);
audioQB.ChangeSoundPan(soundHandle, pan);
audioQB.ChangeSoundPitch(soundHandle, pitch);
audioQB.ChangeSoundVolume(soundHandle, volume);
audioQB.SetSoundLooped(soundHandle, true);
UsingOnTriggerExit = true;
}
else
{
UsingOnTriggerExit = false;
}
UsingOnTriggerEnter = true;
UsingOnTriggerStay = false;
base.Initialize(stage); // let the trigger volume base class initialize itself
}
