public Pause(ref global_vars vars, ref Playable playmode, ref Game1 game)
: base(game)
{
this.game = game;
this.playmode = playmode;
thisPause = this;
variables = vars;
HUDLocation = variables.HUDLOC;
layoverPosition = new Rectangle(0, 0, variables.screen_width, variables.screen_height);
pauseTimer = new Timer(vars.PAUSE_DELAY, game);
pauseTimer.Elapsed = pauseDelay;
}
public Campaign(ref global_vars vars, Player player, Texture2D map, Game1 game)
: base(game)
{
this.variables = vars;
this.player = player;
this.map = map;
this.game = game;
thisCampaign = this;
play = this;
s1 = new Vector2(40, variables.screen_height - 40);
l1 = new Rectangle(variables.screen_width - 190, variables.screen_height - 70, 50, 50);
l2 = new Rectangle(variables.screen_width - 130, variables.screen_height - 70, 50, 50);
l3 = new Rectangle(variables.screen_width - 70, variables.screen_height - 70, 50, 50);
mapPosition = new Rectangle(0, 0, variables.screen_width, variables.screen_height);
this.character = this.player.getCharacter(thisCampaign);
creepers = 0;
shadows = 0;
}
public static void handleCommand(ref Character character, ref Playable playable, ref global_vars variables, ref Game1 game)
{
keypressed = Keyboard.GetState();
//Player movement
if (keypressed.IsKeyDown(variables.CHARACTER_UP) && (character.getPosition().Y > 0))
{
character.setPosition(character.getPosition().X, character.getPosition().Y - variables.CHARACTER_DEFAULT_MOVE_SPEED);
character.move_state = global_vars.movestate.up;
}
else if (keypressed.IsKeyDown(variables.CHARACTER_DOWN) && (character.getPosition().Y < (variables.screen_height - variables.CHARACTER_HEIGHT)))
{
character.setPosition(character.getPosition().X, character.getPosition().Y + variables.CHARACTER_DEFAULT_MOVE_SPEED);
character.move_state = global_vars.movestate.down;
}
else if (keypressed.IsKeyDown(variables.CHARACTER_RIGHT) && (character.getPosition().X < variables.screen_width - variables.CHARACTER_WIDTH))
{
character.setPosition(character.getPosition().X + variables.CHARACTER_DEFAULT_MOVE_SPEED, character.getPosition().Y);
character.move_state = global_vars.movestate.right;
}
else if (keypressed.IsKeyDown(variables.CHARACTER_LEFT) && (character.getPosition().X > 0))
{
character.setPosition(character.getPosition().X - variables.CHARACTER_DEFAULT_MOVE_SPEED, character.getPosition().Y);
character.move_state = global_vars.movestate.left;
}
else character.move_state = global_vars.movestate.notmoving;
//User commands (spells, shields, etc)
//Attacks start at player's center
int posx = character.getPosition().X + (variables.CHARACTER_WIDTH / 4);
int posy = character.getPosition().Y + (variables.CHARACTER_HEIGHT / 4);
int shieldx = character.getPosition().X - (variables.SHIELD_WIDTH / 2);
int shieldy = character.getPosition().Y - (variables.SHIELD_HEIGHT / 2);
//Sheild (One at a time)
if (keypressed.IsKeyDown(variables.SHIELD) && (character.shieldOut == false))
{
try
{
bool answer = playable.notify(global_vars.notification.ShieldRequest);
if (answer)
{
character.shieldOut = true;
game.Components.Add(new Basic_Shield(10000, new Rectangle(shieldx, shieldy, variables.SHIELD_WIDTH, variables.SHIELD_HEIGHT), ref character, ref variables, ref game));
}
}
catch (Exception e) { throw e; }
}
//Basic Attack
if (keypressed.IsKeyDown(variables.ATTACK_BASIC_UP) && (character.attackReady == true))
{
character.attackReady = false;
game.Components.Add(new Basic_Attack(3000, new Rectangle(posx, posy, variables.ATTACK_SPELL_SIZE, variables.ATTACK_SPELL_SIZE), 'u', global_vars.sender.Character, ref variables, ref game));
}
else if (keypressed.IsKeyDown(variables.ATTACK_BASIC_RIGHT) && (character.attackReady == true))
{
character.attackReady = false;
game.Components.Add(new Basic_Attack(3000, new Rectangle(posx, posy, variables.ATTACK_SPELL_SIZE, variables.ATTACK_SPELL_SIZE), 'r', global_vars.sender.Character, ref variables, ref game));
}
else if (keypressed.IsKeyDown(variables.ATTACK_BASIC_LEFT) && (character.attackReady == true))
{
character.attackReady = false;
game.Components.Add(new Basic_Attack(3000, new Rectangle(posx, posy, variables.ATTACK_SPELL_SIZE, variables.ATTACK_SPELL_SIZE), 'l', global_vars.sender.Character, ref variables, ref game));
}
else if (keypressed.IsKeyDown(variables.ATTACK_BASIC_DOWN) && (character.attackReady == true))
{
character.attackReady = false;
game.Components.Add(new Basic_Attack(3000, new Rectangle(posx, posy, variables.ATTACK_SPELL_SIZE, variables.ATTACK_SPELL_SIZE), 'd', global_vars.sender.Character, ref variables, ref game));
}
//Special Ability
if (keypressed.IsKeyDown(variables.SPECIAL_ABILITY))
{
try
{
bool answer = playable.notify(global_vars.notification.SpecialRequest);
if (answer)
{
Ability_Manager.performSpecialAbility(character.getSpecial(), ref variables, ref game);
}
}
catch (Exception e) { }
}
//Exit Full Screen
// if (keypressed.IsKeyDown(Keys.Escape))
// variables.manager.ToggleFullScreen();
}
public void SetPlayable(Playable playable)
{
m_Playable = playable;
}
public virtual void OnBehaviourDone(Playable playable)
{
}
public virtual void OnBehaviourResume(Playable playable)
{
}
public override void OnPlayableCreate(Playable playable)
{
base.OnPlayableCreate(playable);
playableGraph = TimelineManager.Instance.GetGraph();
}
public override void OnGraphStop(Playable playable)
{
}
public override void PrepareFrame(Playable playable, FrameData info)
{
girl.gameObject.GetComponent <BoyController>().setVelocity();
boy.gameObject.GetComponent <BoyController>().setVelocity();
base.PrepareFrame(playable, info);
}
public override void ProcessFrame(Playable playable, FrameData info, object playerData)
{
base.ProcessFrame(playable, info, playerData);
}
public StateHandle(SimpleAnimationPlayable s, int index, Playable target)
{
m_Parent = s;
m_Index = index;
m_Target = target;
}
public Character getNewCharacter(Playable playable)
{
Character c = new Character(selectedSpecial, ref variables, ref game);
c.setPlayable(playable);
character = c;
return c;
}
// Called when the state of the playable is set to Paused
public override void OnBehaviourPause(Playable playable, FrameData info)
{
}
// NOTE; gam0022 ここでClipのパラメータを定義できる
// public float param1;
// public float param2;
// public Vector3 vec1;
public override void OnPlayableCreate(Playable playable)
{
}
public override void OnGraphStart(Playable playable)
{
_subject = subject.Resolve(playable.GetGraph().GetResolver());
}
public override void OnPlayableCreate(Playable playable)
{
director = playable.GetGraph().GetResolver() as PlayableDirector;
}
public override void OnGraphStart(Playable playable)
{
loopState = 0;
continueCount = 0;
}
public override void OnPlayableDestroy(Playable playable)
{
ClearChildTrackBindings();
}
public override void OnGraphStart(Playable playable)
{
_dialog = dialog.Resolve(playable.GetGraph().GetResolver());
}
public override void PrepareFrame(Playable playable, FrameData info)
{
base.PrepareFrame(playable, info);
}
public override void OnBehaviourPlay(Playable playable, FrameData info)
{
_dialog.gameObject.SetActive(true);
_dialog.text = dialogStr;
}
public override void OnPlayableDestroy(Playable playable)
{
base.OnPlayableDestroy(playable);
TimelineManager.Instance.OnDestroy();
}
public override void OnPlayableCreate(Playable playable)
{
propertyBlock = new MaterialPropertyBlock();
}
public override void OnGraphStart(Playable playable)
{
base.OnGraphStart(playable);
}
private void RebuildGraph(Animator animator)
{
DestroyGraph();
m_Graph = PlayableGraph.Create("PreviewGraph");
m_Graph.SetTimeUpdateMode(DirectorUpdateMode.Manual);
m_ClipPlayable = AnimationClipPlayable.Create(m_Graph, state.activeAnimationClip);
m_ClipPlayable.SetOverrideLoopTime(true);
m_ClipPlayable.SetLoopTime(false);
m_ClipPlayable.SetApplyFootIK(false);
m_CandidateClipPlayable = AnimationClipPlayable.Create(m_Graph, m_CandidateClip);
IAnimationWindowPreview[] previewComponents = FetchPostProcessComponents();
bool requiresDefaultPose = previewComponents != null && previewComponents.Length > 0;
int nInputs = requiresDefaultPose ? 3 : 2;
// Create a layer mixer if necessary, we'll connect playable nodes to it after having populated AnimationStream.
AnimationLayerMixerPlayable mixer = AnimationLayerMixerPlayable.Create(m_Graph, nInputs);
m_GraphRoot = (Playable)mixer;
// Populate custom playable preview graph.
if (previewComponents != null)
{
foreach (var component in previewComponents)
{
m_GraphRoot = component.BuildPreviewGraph(m_Graph, m_GraphRoot);
}
}
// Finish hooking up mixer.
int inputIndex = 0;
if (requiresDefaultPose)
{
AnimationMode.RevertPropertyModificationsForGameObject(state.activeRootGameObject);
EditorCurveBinding[] streamBindings = AnimationUtility.GetAnimationStreamBindings(state.activeRootGameObject);
m_DefaultPose = new AnimationClip()
{
name = "DefaultPose"
};
AnimationWindowUtility.CreateDefaultCurves(state, m_DefaultPose, streamBindings);
m_DefaultPosePlayable = AnimationClipPlayable.Create(m_Graph, m_DefaultPose);
mixer.ConnectInput(inputIndex++, m_DefaultPosePlayable, 0, 1.0f);
}
mixer.ConnectInput(inputIndex++, m_ClipPlayable, 0, 1.0f);
mixer.ConnectInput(inputIndex++, m_CandidateClipPlayable, 0, 1.0f);
if (animator.applyRootMotion)
{
var motionX = AnimationMotionXToDeltaPlayable.Create(m_Graph);
motionX.SetAbsoluteMotion(true);
motionX.SetInputWeight(0, 1.0f);
m_Graph.Connect(m_GraphRoot, 0, motionX, 0);
m_GraphRoot = (Playable)motionX;
}
var output = AnimationPlayableOutput.Create(m_Graph, "ouput", animator);
output.SetSourcePlayable(m_GraphRoot);
output.SetWeight(0.0f);
}
public virtual void OnBehaviourStart(Playable playable)
{
}
public override void OnGraphStop(Playable playable)
{
//Resources.UnloadUnusedAssets();
}
public virtual void OnBehaviourPause(Playable playable)
{
}
public override void OnBehaviourPlay(Playable playable, FrameData info)
{
//timelineObj = GameObject.Find(timelineGameObjName);
//if (timelineObj)
//{
// timeline = timelineObj.GetComponent<PlayableDirector>();
//}
//if (timeline)
//{
// var timelineAsset = timeline.playableAsset as TimelineAsset;
// foreach (var track in timelineAsset.GetOutputTracks())
// {
// var playableTrack = track as PlayableTrack;
// if (playableTrack != null)
// {
// if (playableTrack.GetClips().ToList().Count > clipIndex)
// timelineClip = playableTrack.GetClips().ToList()[clipIndex];
// }
// }
//}
player = LsyCommon.FindPlayer();
Transform display;
if (part == Part.playerFace)
{
if (player)
{
display = player.GetChild(0);
for (int i = 0; i < display.childCount; i++)
{
if (display.GetChild(i).name.StartsWith("face"))
{
testObj = display.GetChild(i).gameObject;
break;
}
}
}
}
else if (part == Part.npcFace)
{
GameObject NPC;
NPC = GameObject.Find(targetGameObjName);
if (NPC)
{
testObj = NPC;
}
}
if (testObj)
{
smr = testObj.GetComponent <SkinnedMeshRenderer>();
if (smr)
{
if (count < 1)
{
if ((int)materialIndex <= smr.materials.Length - 1)
{
mat = smr.materials[(int)materialIndex];
count++;
}
}
else
{
if ((int)materialIndex <= smr.sharedMaterials.Length - 1)
{
mat = smr.sharedMaterials[(int)materialIndex];
}
}
}
}
}
public virtual void OnGraphStop(Playable playable)
{
}
private static InequalityFlags Equals(Unknown a, Playable b)
{
return(InequalityFlags.None);
}
public void setPlayable(Playable playable)
{
this.playable = playable;
}
private static InequalityFlags Equals(Playable a, Unknown b)
{
return(InequalityFlags.None);
}
public override void OnGraphStart(Playable playable)
{
_director = playable.GetGraph().GetResolver() as PlayableDirector;
}
public override void OnGraphStart(Playable playable)
{
girl.gameObject.GetComponent <BoyController>().ctrlState = BoyController.CtrlState.NonPlayer;
boy.gameObject.GetComponent <BoyController>().ctrlState = BoyController.CtrlState.NonPlayer;
base.OnGraphStart(playable);
}
public Character getCharacter(Playable playable)
{
character.setPlayable(playable);
return character;
}
public void OnCurrentSongResponseReceived(IEnumerable<MPDSongResponseBlock> response)
{
if (response.Count() > 0)
{
Playable = PlayableFactory.CreatePlayable(response.First());
}
}
