Keyframe CreateKeyframe(JSONClass pose, AnimationStep step = null, int insertionIndex = -1)
{
if (step == null)
{
step = animationPattern.CreateStepAtPosition(animationPattern.steps.Length);
}
step.containingAtom.GetStorableByID("scale").SetFloatParamValue("scale", 0);
step.containingAtom.mainController.GetComponent <SphereCollider>().radius = 0.06f;
Keyframe k = new Keyframe(pose, step);
if (insertionIndex >= 0)
{
keyframes.Insert(insertionIndex, k);
}
else
{
keyframes.Add(k);
}
lastCount = keyframes.Count;
FreeControllerV3 stepMC = step.containingAtom.mainController;
stepMC.canGrabPosition = false;
stepMC.canGrabRotation = false;
LayoutKeys();
return(k);
}
/// <summary>
/// Starts <see cref="Animation"/> of this <see cref="AnimateProp"/>.
/// </summary>
/// <param name="animationStep"><see cref="FusionEnums.AnimationStep"/> to be played.</param>
/// <param name="instant">Whether play the animation instant.</param>
/// <param name="playInstantPreviousSteps">Whether play previous steps.</param>
/// <param name="spawnAndRestore">Whether restore the <see cref="SavedAnimation"/> before playing.</param>
public void Play(AnimationStep animationStep, bool instant = false, bool playInstantPreviousSteps = false, bool spawnAndRestore = false)
{
if (spawnAndRestore)
{
RestoreAnimation();
SpawnProp();
}
if (playInstantPreviousSteps)
{
for (AnimationStep prevStep = AnimationStep.First; prevStep < animationStep; prevStep++)
{
SetInstantAnimationStep(prevStep);
}
}
if (instant)
{
SetInstantAnimationStep(animationStep);
return;
}
Animation[AnimationType.Offset][animationStep].SetAllUpdate(true);
Animation[AnimationType.Rotation][animationStep].SetAllUpdate(true);
AnimationStep = animationStep;
IsPlaying = true;
}
public void Delete(bool is_get)
{
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_014d: Unknown result type (might be due to invalid IL or missing references)
if (!isDelete)
{
isDelete = true;
isGet = is_get;
if (is_get)
{
targetObject = MonoBehaviourSingleton <StageObjectManager> .I.self;
Bounds bounds = targetObject._collider.get_bounds();
distance = Vector3.Distance(bounds.get_center(), _transform.get_position());
distanceAnim.Set(parameter.getAnimTime, 0f, 1f, parameter.distanceAnim, 0f, null);
distanceAnim.Play();
speedAnim.Set(parameter.getAnimTime, 0f, parameter.rotateSpeed, parameter.rotateSpeedAnim, 0f, null);
speedAnim.Play();
scaleAnim.Set(parameter.getAnimTime, 0f, 1f, parameter.scaleAnim, 0f, null);
scaleAnim.Play();
moveTime = 0f;
animationStep = AnimationStep.OPEN;
announceInfo = MonoBehaviourSingleton <InGameManager> .I.CreateDropAnnounceInfoList(deliveryInfo, itemInfo, true);
}
else
{
this.get_gameObject().SetActive(false);
}
}
}
Keyframe FindKeyframeByStep(AnimationStep step)
{
return(keyframes.Find((k) =>
{
return k.step == step;
}));
}
private void Update()
{
if (_animationStep == AnimationStep.Idle)
{
return;
}
if (_animationStep == AnimationStep.JumpOnBoat1)
{
var pA = _playerPosition;
var pB = playerInBoat.position;
var d = Vector3.Distance(pA, pB);
var m = (pA + pB) / 2;
var h = d * .3f;
var q1 = m + new Vector3(0, h, 0);
LerpTo(pA, q1, AnimationStep.JumpOnBoat2);
return;
}
if (_animationStep == AnimationStep.JumpOnBoat2)
{
var pA = _playerPosition;
var pB = playerInBoat.position;
var d = Vector3.Distance(pA, pB);
var m = (pA + pB) / 2;
var h = d * .3f;
var q1 = m + new Vector3(0, h, 0);
LerpTo(q1, pB, AnimationStep.DriveBoat);
return;
}
if (_waitingForAnimation)
{
_player.transform.position = playerInBoat.transform.position;
if (boatAnimator.GetCurrentAnimatorStateInfo(0).normalizedTime >= 1f)
{
boatAnimator.Play("BoatEnd");
_animationStep = AnimationStep.Idle;
Game.Instance.StopWaiting();
_player.RegisterMovementFinishedCallback(() => { Game.Instance.HandleFinishedMovement(_player); });
_player.SetField(_targetField);
}
return;
}
if (_animationStep == AnimationStep.DriveBoat)
{
_waitingForAnimation = true;
Game.Instance.GetWalkAudio().Play();
boatAnimator.Play("BoatStart");
}
}
private void Deactivate()
{
_lastStep = null;
_transition = null;
if (_camExposureBackup != 0f)
{
_camExposureJSON.val = _camExposureBackup;
_camExposureBackup = 0f;
}
if (_navigationHologridEnabledBackup != null)
{
_navigationHologridRenderer.enabled = _navigationHologridEnabledBackup.Value;
_navigationHologridEnabledBackup = null;
}
if (_navigationRigActive)
{
RestorePassenger();
_navigationRigBackup?.Restore();
_navigationRigBackup = null;
_navigationRigActive = false;
}
if (_windowCameraActive)
{
_windowCameraBackup?.Restore();
_windowCameraBackup = null;
_windowCameraActive = false;
}
}
void UpdateAnimationStep(float timeStep)
{
// HACK deal with two of first frame
if (NormalizedTime == 0f && AnimationSteps.FirstOrDefault(x => x.NormalizedTime == 0f) != null)
{
return;
}
// var c = _master.Muscles.Count;
var c = BodyParts.Count;
var animStep = new AnimationStep();
animStep.TimeStep = timeStep;
animStep.NormalizedTime = NormalizedTime;
// animStep.RootPositions = Enumerable.Repeat(Vector3.zero, c).ToList();
animStep.Velocities = Enumerable.Repeat(Vector3.zero, c).ToList();
animStep.RotaionVelocities = Enumerable.Repeat(Quaternion.identity, c).ToList();
animStep.AngularVelocities = Enumerable.Repeat(Vector3.zero, c).ToList();
// animStep.NormalizedAngularVelocities = Enumerable.Repeat(Vector3.zero, c).ToList();
// animStep.RootRotations = Enumerable.Repeat(Quaternion.identity, c).ToList();
animStep.RootAngles = Enumerable.Repeat(Vector3.zero, c).ToList();
animStep.Positions = Enumerable.Repeat(Vector3.zero, c).ToList();
animStep.Rotaions = Enumerable.Repeat(Quaternion.identity, c).ToList();
animStep.Velocity = transform.position - _lastVelocityPosition;
animStep.Names = BodyParts.Select(x => x.Name).ToList();
animStep.SensorIsInTouch = new List <float>(SensorIsInTouch);
_lastVelocityPosition = transform.position;
var rootBone = BodyParts[0];
foreach (var bodyPart in BodyParts)
{
var i = BodyParts.IndexOf(bodyPart);
if (i == 0)
{
animStep.Rotaions[i] = Quaternion.Inverse(_baseRotation) * bodyPart.Transform.rotation;
animStep.Positions[i] = bodyPart.Transform.position - bodyPart.InitialRootPosition;
animStep.RootAngles[i] = animStep.Rotaions[i].eulerAngles;
}
else
{
animStep.Rotaions[i] = Quaternion.Inverse(_baseRotation) * bodyPart.Transform.rotation;
animStep.RootAngles[i] = animStep.Rotaions[i].eulerAngles;
animStep.Positions[i] = bodyPart.Transform.position - rootBone.Transform.position;
}
if (NormalizedTime != 0f)
{
animStep.Velocities[i] = bodyPart.Transform.position - _lastPosition[i];
animStep.RotaionVelocities[i] = JointHelper002.FromToRotation(_lastRotation[i], bodyPart.Transform.rotation);
animStep.AngularVelocities[i] = animStep.RotaionVelocities[i].eulerAngles;
}
_lastPosition[i] = bodyPart.Transform.position;
_lastRotation[i] = bodyPart.Transform.rotation;
}
animStep.CenterOfMass = GetCenterOfMass();
animStep.TransformPosition = transform.position;
animStep.TransformRotation = transform.rotation;
AnimationSteps.Add(animStep);
}
public void StartAnimation(Player player, Field targetField)
{
_player = player;
_targetField = targetField;
_playerPosition = _player.transform.position;
_animationStep = AnimationStep.JumpOnBoat1;
_waitingForAnimation = false;
_moveTimer = 0f;
}
private void LoadCharacterRig(string name, string[] lines)
{
Display = new GCharacter();
int partnum = Int32.Parse(lines[0]);
for (int i = 0; i < partnum; i++)
{
GPart part = new GPart();
string partName = lines[i * 3 + 1];
part.BaseTexture.Add(new Sprite(new Texture("../../../Resources/Graphics/Character/" + name + "/" + partName + "/Front.png")));
part.BaseTexture.Add(new Sprite(new Texture("../../../Resources/Graphics/Character/" + name + "/" + partName + "/Right.png")));
part.BaseTexture.Add(new Sprite(new Texture("../../../Resources/Graphics/Character/" + name + "/" + partName + "/Back.png")));
part.BaseTexture.Add(new Sprite(new Texture("../../../Resources/Graphics/Character/" + name + "/" + partName + "/Left.png")));
string[] rotCenterStrings = lines[i * 3 + 2].Split(" ");
part.RotationCenter = new Vector2f(float.Parse(rotCenterStrings[0]), float.Parse(rotCenterStrings[1]));
string[] originStrings = lines[i * 3 + 3].Split(" ");
part.Origin = new Vector3f(float.Parse(originStrings[0]), float.Parse(originStrings[1]), float.Parse(originStrings[1]));
Display.Parts.Add(part);
}
Display.State.ID = 0;
Display.State.facing = 0;
Display.State.elapsed = Time.Zero;
int animnum = Int32.Parse(lines[partnum * 3 + 1]);
for (int i = 0; i < animnum; i++)
{
Animation animation = new Animation();
string animName = lines[partnum * 3 + 2 + i];
string[] amimLines = File.ReadAllLines("../../../Resources/Graphics/Character/" + name + "/Animations/" + animName + ".txt");
int sum = 0;
for (int j = 0; j < partnum; j++)
{
AnimationPart part = new AnimationPart();
int animSteps = Int32.Parse(amimLines[sum++]);
for (int k = 0; k < animSteps; k++)
{
AnimationStep step = new AnimationStep();
string[] stepInfo = amimLines[sum++].Split(" ");
step.Duration = Time.FromSeconds(float.Parse(stepInfo[0]));
step.Rotation = float.Parse(stepInfo[1]);
part.Steps.Add(step);
}
animation.Parts.Add(part);
}
if (amimLines.Last() == "Y")
{
animation.Repeatable = true;
}
else
{
animation.Repeatable = false;
}
Display.Animations.Add(animation);
}
}
internal AnimationStepSettings(AnimationStep animationStep, AnimationType animationType)
{
Step = animationStep;
Type = animationType;
foreach (Coordinate coordinate in Enum.GetValues(typeof(Coordinate)))
{
CoordinateSettings.Add(new CoordinateSetting(coordinate, animationType, animationStep));
}
}
void PerformLoad(JSONClass jc)
{
// legacy
if (saveStore.val != saveStore.defaultVal)
{
jc["keyframes"] = JSON.Parse(saveStore.val).AsObject["keyframes"].AsArray;
// remove it from future use
saveStore.val = saveStore.defaultVal;
}
else
{
if (jc["keyframes"] == null)
{
animationPattern.DestroyAllSteps();
return;
}
}
int index = 0;
List <AnimationStep> accountedFor = new List <AnimationStep>();
JSONArray keyframes = jc["keyframes"].AsArray;
for (int i = 0; i < keyframes.Count; i++)
{
JSONClass pose = keyframes[i].AsObject;
if (index < animationPattern.steps.Length)
{
AnimationStep step = animationPattern.steps[index];
if (step != null)
{
CreateKeyframe(pose, step);
accountedFor.Add(step);
}
}
else
{
CreateKeyframe(pose);
}
index++;
}
List <AnimationStep> existingSteps = animationPattern.steps.ToList();
existingSteps.ForEach((step) =>
{
if (accountedFor.Contains(step) == false)
{
step.DestroyStep();
}
});
}
void Start()
{
if (saveStore.val == saveStore.defaultVal)
{
saveJSON = new JSONClass();
saveJSON["keyframes"] = new JSONArray();
animationPattern.DestroyAllSteps();
return;
}
saveJSON = JSON.Parse(saveStore.val).AsObject;
int index = 0;
List <AnimationStep> accountedFor = new List <AnimationStep>();
JSONArray keyframes = saveJSON["keyframes"].AsArray;
for (int i = 0; i < keyframes.Count; i++)
{
JSONClass pose = keyframes[i].AsObject;
if (index < animationPattern.steps.Length)
{
AnimationStep step = animationPattern.steps[index];
if (step != null)
{
CreateKeyframe(pose, step);
accountedFor.Add(step);
}
}
else
{
CreateKeyframe(pose);
}
index++;
}
List <AnimationStep> existingSteps = animationPattern.steps.ToList();
existingSteps.ForEach((step) =>
{
if (accountedFor.Contains(step) == false)
{
step.DestroyStep();
}
});
if (SuperController.singleton.GetSelectedAtom() != containingAtom)
{
uiVisible.SetVal(false);
keyUI.canvas.enabled = false;
ui.canvas.enabled = false;
}
}
private void UpdateNavigationRigRotation(AnimationStep currentStep)
{
var navigationRig = SuperController.singleton.navigationRig;
var navigationRigRotation = currentStep.transform.rotation;
if (!SuperController.singleton.MonitorRig.gameObject.activeSelf)
{
navigationRigRotation *= Quaternion.Euler(0, navigationRig.eulerAngles.y - _possessor.transform.eulerAngles.y, 0f);
}
navigationRig.rotation = navigationRigRotation;
}
public void Push(AnimationStep anim_step, double xValue, double yValue, double zValue)
{
var values = new ArrayList();
values.Add(xValue);
values.Add(yValue);
values.Add(zValue);
KeyValuePair<AnimationStep, ArrayList> keyValue_temp =
new KeyValuePair<AnimationStep, ArrayList>(anim_step, values);
key_points.Add(keyValue_temp);
}
private void LerpTo(Vector3 start, Vector3 end, AnimationStep nextStep)
{
_player.transform.position = Vector3.Lerp(start, end, _moveTimer);
_moveTimer += Player.LerpingModifier * Time.deltaTime;
if (_moveTimer >= 1f)
{
_animationStep = nextStep;
_moveTimer = 0f;
}
}
private void UpdateNavigationRigPosition(AnimationStep currentStep)
{
var navigationRig = SuperController.singleton.navigationRig;
var up = navigationRig.up;
var positionOffset = navigationRig.position + currentStep.transform.position - _possessor.autoSnapPoint.position;
// Adjust the player height so the user can adjust as needed
var playerHeightAdjustOffset = Vector3.Dot(positionOffset - navigationRig.position, up);
navigationRig.position = positionOffset + up * -playerHeightAdjustOffset;
SuperController.singleton.playerHeightAdjust += playerHeightAdjustOffset;
}
void UpdateAnimationStep(float timeStep)
{
// HACK deal with two of first frame
if (NormalizedTime == 0f && AnimationSteps.FirstOrDefault(x => x.NormalizedTime == 0f) != null)
{
return;
}
var c = _master.Muscles.Count;
var animStep = new AnimationStep();
animStep.TimeStep = timeStep;
animStep.NormalizedTime = NormalizedTime;
animStep.RootPositions = Enumerable.Repeat(Vector3.zero, c).ToList();
animStep.Velocities = Enumerable.Repeat(Vector3.zero, c).ToList();
animStep.RotaionVelocities = Enumerable.Repeat(Quaternion.identity, c).ToList();
animStep.AngularVelocities = Enumerable.Repeat(Vector3.zero, c).ToList();
// animStep.NormalizedAngularVelocities = Enumerable.Repeat(Vector3.zero, c).ToList();
animStep.RootRotations = Enumerable.Repeat(Quaternion.identity, c).ToList();
animStep.RootAngles = Enumerable.Repeat(Vector3.zero, c).ToList();
animStep.Positions = Enumerable.Repeat(Vector3.zero, c).ToList();
animStep.Rotaions = Enumerable.Repeat(Quaternion.identity, c).ToList();
animStep.Velocity = transform.position - _lastVelocityPosition;
_lastVelocityPosition = transform.position;
var rootBone = _animBones[0];
// Quaternion rootRotation = rootBone.rotation;
var toRootSpace = Quaternion.Inverse(_master.Muscles[0].Rigidbody.rotation) * rootBone.rotation;
foreach (var m in _master.Muscles)
{
var i = _master.Muscles.IndexOf(m);
var animBone = _animBones[i];
Quaternion rootRotation = Quaternion.Inverse(rootBone.rotation * toRootSpace) * animBone.rotation;
animStep.RootPositions[i] = animBone.position - rootBone.position;
animStep.RootRotations[i] = rootRotation;
animStep.RootAngles[i] = rootRotation.eulerAngles;
animStep.Positions[i] = animBone.position - transform.parent.position;
animStep.Rotaions[i] = animBone.rotation * Quaternion.Inverse(transform.parent.rotation);
if (NormalizedTime != 0f)
{
animStep.Velocities[i] = animStep.Positions[i] - _lastPosition[i];
animStep.RotaionVelocities[i] = JointHelper001.FromToRotation(_lastRotation[i], animStep.Rotaions[i]);
animStep.AngularVelocities[i] = animStep.RotaionVelocities[i].eulerAngles;
}
_lastPosition[i] = animStep.Positions[i];
_lastRotation[i] = animStep.Rotaions[i];
}
AnimationSteps.Add(animStep);
}
/// <summary>
/// Sets the specified <paramref name="coordinate"/> to the maximum or minimum value.
/// </summary>
/// <param name="animationType">Wanted <see cref="FusionEnums.AnimationType"/>.</param>
/// <param name="animationStep"><see cref="FusionEnums.AnimationStep"/> of <paramref name="animationType"/>.</param>
/// <param name="coordinate"><see cref="FusionEnums.Coordinate"/> of <paramref name="animationStep"/>.</param>
/// <param name="maximum"><see langword="true"/> sets <paramref name="coordinate"/> to maximum value; otherwise minimum.</param>
public void SetCoordinateAt(AnimationType animationType, AnimationStep animationStep, Coordinate coordinate, bool maximum)
{
CoordinateSetting coordinateSetting = Animation[animationType][animationStep][coordinate];
if (animationType == AnimationType.Offset)
{
SecondOffset[(int)coordinate] = (maximum ? coordinateSetting.Maximum : coordinateSetting.Minimum) * coordinateSetting.MaxMinRatio - Offset[(int)coordinate];
}
else
{
SecondRotation[(int)coordinate] = (maximum ? coordinateSetting.Maximum : coordinateSetting.Minimum) * coordinateSetting.MaxMinRatio - Rotation[(int)coordinate];
}
Attach();
}
public IEnumerator Process(MonoBehaviour m, AnimationStep step, AnimationStateAction action)
{
triggered = true;
bool oneLoop = true;
while (oneLoop)
{
if (HasDelay())
{
yield return(delayYield);
}
if (enterEvents.GetPersistentEventCount() > 0)
{
enterEvents.Invoke();
}
for (float t = 0f; t < 1f; t += Time.deltaTime / time)
{
if ((t + (Time.deltaTime / time)) > 1f)
{
t = 1f;
}
action(t, speed.GetValue(), curve);
if (step == AnimationStep.FixedUpdate)
{
yield return(fixedUpdateYield);
}
else
{
yield return(null);
}
}
if (exitEvents.GetPersistentEventCount() > 0)
{
exitEvents.Invoke();
}
if (IsLoop() == false)
{
oneLoop = false;
}
}
}
public override void Init()
{
try
{
_step = containingAtom.parentAtom.GetComponentInChildren <AnimationStep>();
if (_step == null)
{
throw new Exception("Can only apply DirectorStep on AnimationStep");
}
InitControls();
}
catch (Exception e)
{
SuperController.LogError("Failed to initialize plugin: " + e);
}
}
public override void Callback()
{
switch (currentStep)
{
case AnimationStep.STEP1:
audioManager.PlayMenuSFX();
scoreCanvas.SetActive(true);
currentStep = showNewHighLabel ? AnimationStep.STEP2 : AnimationStep.STEP3;
timeOut = 0.5f;
break;
case AnimationStep.STEP2:
highScoreLabel.SetActive(true);
audioManager.PlayMenuSFX();
currentStep = AnimationStep.STEP3;
break;
case AnimationStep.STEP3:
audioManager.PlayMenuSFX();
globalScoreCanvas.SetActive(true);
currentStep = AnimationStep.STEP4;
timeOut = 0.5f;
break;
case AnimationStep.STEP4:
timeOut = 0.01f;
if (sessionScore > 0)
{
AudioManager.Instance.PlayCoinSFX();
sessionScore = sessionScore - 1;
globalScore = globalScore + 1;
}
else
{
currentStep = AnimationStep.STEP5;
}
break;
default:
highScoreLabel.SetActive(false);
audioManager.PlayMenuSFX();
timeOut = 99;
break;
}
}
private void MoveStep(int actualRow, int targetRow)
{
if (actualRow == -1 || targetRow == -1 || targetRow >= dataGridView.Rows.Count || targetRow >= editor.Zoom1Archive.Animation[editor.ActualGraphicID, editor.ActualAlternativeID].AnimationStepCount)
{
return;
}
DataGridViewRow rowToMove = dataGridView.Rows[actualRow];
dataGridView.Rows.Remove(rowToMove);
this.cellValueCodeChanged = true;
dataGridView.Rows.Insert(targetRow, rowToMove);
AnimationStep step = this.editor.Zoom1Archive.Animation[editor.ActualGraphicID, editor.ActualAlternativeID][actualRow];
this.editor.Zoom1Archive.Animation[editor.ActualGraphicID, editor.ActualAlternativeID].RemoveAnimationStep(actualRow);
this.editor.Zoom1Archive.Animation[editor.ActualGraphicID, editor.ActualAlternativeID].InsertAnimationStep(step, targetRow);
this.dataGridView.CurrentCell = this.dataGridView.Rows[targetRow].Cells[0];
this.editor.UserMadeChanges(true);
}
public PEnvironment(string name, Game game)
{
Game = game;
try
{
LoadGraphics(name);
}
catch (FileNotFoundException fileNotFoundException)
{
Console.WriteLine("No graphics setup file for " + name);
Console.WriteLine("Initializing as default texture");
GPart defPart = new GPart();
defPart.BaseTexture.Add(new Sprite(new Texture("../../../Resources/Graphics/default.png")));
GCharacter defCharacter = new GCharacter();
defCharacter.Parts.Add(defPart);
AnimationStep defStep = new AnimationStep();
defStep.Duration = Time.FromSeconds(1f);
defStep.Rotation = 0;
AnimationPart defAnimPart = new AnimationPart();
defAnimPart.Steps.Add(defStep);
Animation defAnim = new Animation();
defAnim.Parts.Add(defAnimPart);
defCharacter.Animations.Add(defAnim);
Display = defCharacter;
}
catch (DirectoryNotFoundException directoryNotFoundException)
{
Console.WriteLine("No graphics setup file for " + name);
Console.WriteLine("Initializing as default texture");
GPart defPart = new GPart();
defPart.BaseTexture.Add(new Sprite(new Texture("../../../Resources/Graphics/default.png")));
GCharacter defCharacter = new GCharacter();
defCharacter.Parts.Add(defPart);
AnimationStep defStep = new AnimationStep();
defStep.Duration = Time.FromSeconds(1f);
defStep.Rotation = 0;
AnimationPart defAnimPart = new AnimationPart();
defAnimPart.Steps.Add(defStep);
Animation defAnim = new Animation();
defAnim.Parts.Add(defAnimPart);
defCharacter.Animations.Add(defAnim);
Display = defCharacter;
}
}
public virtual void Drop(Vector3 _dropPos, Vector3 _targetPos)
{
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
isOpend = false;
animationTimer = 0f;
animationStep = AnimationStep.MOVE_TO_TARGET_POS;
targetObject = MonoBehaviourSingleton <StageObjectManager> .I.self;
dropPos = _dropPos;
_transform.set_position(_dropPos);
targetPos = _targetPos;
if (animEventProcessor != null)
{
animEventProcessor.CrossFade(startAnimHash, 0f);
}
}
/// <summary>
/// Plays specified <paramref name="animationStep"/> instantly.
/// </summary>
/// <param name="animationStep">Wanted <see cref="FusionEnums.AnimationStep"/>.</param>
public void SetInstantAnimationStep(AnimationStep animationStep)
{
List <CoordinateSetting> offsetSettings = Animation[AnimationType.Offset][animationStep].CoordinateSettings.Where(x => x.IsSetted).ToList();
List <CoordinateSetting> rotationSettings = Animation[AnimationType.Rotation][animationStep].CoordinateSettings.Where(x => x.IsSetted).ToList();
offsetSettings.ForEach(x =>
{
float val;
if (x.IsIncreasing)
{
val = x.Maximum * x.MaxMinRatio;
}
else
{
val = x.Minimum * x.MaxMinRatio;
}
x.IsIncreasing = !x.IsIncreasing;
SecondOffset[(int)x.Coordinate] = val - Offset[(int)x.Coordinate];
});
rotationSettings.ForEach(x =>
{
float val;
if (x.IsIncreasing)
{
val = x.Maximum * x.MaxMinRatio;
}
else
{
val = x.Minimum * x.MaxMinRatio;
}
x.IsIncreasing = !x.IsIncreasing;
SecondRotation[(int)x.Coordinate] = val - Rotation[(int)x.Coordinate];
});
Attach();
}
public void LoadDefault()
{
GPart defPart = new GPart();
defPart.BaseTexture.Add(new Sprite(new Texture("../../../Resources/Graphics/default.png")));
GCharacter defCharacter = new GCharacter();
defCharacter.Parts.Add(defPart);
AnimationStep defStep = new AnimationStep();
defStep.Duration = Time.FromSeconds(1f);
defStep.Rotation = 0;
AnimationPart defAnimPart = new AnimationPart();
defAnimPart.Steps.Add(defStep);
Animation defAnim = new Animation();
defAnim.Parts.Add(defAnimPart);
defCharacter.Animations.Add(defAnim);
Display = defCharacter;
}
private JSONStorableBool GetStepPassengerTarget(AnimationStep currentStep)
{
// Get the step's DirectorStep script
var directorStepStorableID = currentStep.containingAtom.GetStorableIDs().FirstOrDefault(id => id.EndsWith("DirectorStep"));
if (directorStepStorableID == null)
{
return(null);
}
var directorStepStorable = currentStep.containingAtom.GetStorableByID(directorStepStorableID);
// Get the Passenger setting (an atom ID)
var passengerAtomID = directorStepStorable.GetStringChooserParamValue("Passenger");
if (passengerAtomID == "None")
{
return(null);
}
// Get the specified atom
var passengerAtom = SuperController.singleton.GetAtomByUid(passengerAtomID);
if (passengerAtom == null)
{
FailOnce("Atom " + passengerAtomID + " specified in step " + currentStep.containingAtom.name + " does not exit");
return(null);
}
var passengerStorableID = passengerAtom.GetStorableIDs().FirstOrDefault(id => id.EndsWith("Passenger"));
if (passengerStorableID == null)
{
FailOnce("Atom " + passengerAtomID + " does not have the Passenger script");
return(null);
}
var passengerStorable = passengerAtom.GetStorableByID(passengerStorableID);
return(passengerStorable?.GetBoolJSONParam("Active"));
}
void InsertKey()
{
if (keyframes.Count <= 1)
{
AddKey();
return;
}
float currentTime = time.val;
JSONClass pose = GetPoseFromPerson();
int index = GetLastFrameIndex(currentTime);
Keyframe last = keyframes[index];
int nextIndex = index + 1;
if (nextIndex >= keyframes.Count)
{
nextIndex = 0;
}
Keyframe next = keyframes[nextIndex];
float nextTimeStep = next.step.timeStep;
AnimationStep newStep = animationPattern.CreateStepAfterStep(last.step);
newStep.transitionToTime = currentTime - last.step.timeStep;
next.step.transitionToTime = nextTimeStep - currentTime;
Keyframe newKey = CreateKeyframe(pose, newStep, nextIndex);
UpdateSaveStore();
time.SetVal(animationPattern.GetTotalTime());
SuperController.singleton.SelectController(newKey.step.containingAtom.mainController);
}
public override void Callback()
{
switch (currentStep) {
case AnimationStep.STEP1:
audioManager.PlayMenuSFX();
scoreCanvas.SetActive(true);
currentStep = showNewHighLabel ? AnimationStep.STEP2 : AnimationStep.STEP3;
timeOut = 0.5f;
break;
case AnimationStep.STEP2:
highScoreLabel.SetActive(true);
audioManager.PlayMenuSFX();
currentStep = AnimationStep.STEP3;
break;
case AnimationStep.STEP3:
audioManager.PlayMenuSFX();
globalScoreCanvas.SetActive(true);
currentStep = AnimationStep.STEP4;
timeOut = 0.5f;
break;
case AnimationStep.STEP4:
timeOut = 0.01f;
if (sessionScore > 0) {
AudioManager.Instance.PlayCoinSFX();
sessionScore = sessionScore - 1;
globalScore = globalScore + 1;
} else {
currentStep = AnimationStep.STEP5;
}
break;
default:
highScoreLabel.SetActive(false);
audioManager.PlayMenuSFX();
timeOut = 99;
break;
}
}
private void LoadProjectile(string name)
{
GPart part = new GPart();
part.BaseTexture.Add(new Sprite(new Texture("../../../Resources/Graphics/Environment/" + name + "/" + "Front.png")));
part.BaseTexture.Add(new Sprite(new Texture("../../../Resources/Graphics/Environment/" + name + "/" + "Right.png")));
part.BaseTexture.Add(new Sprite(new Texture("../../../Resources/Graphics/Environment/" + name + "/" + "Back.png")));
part.BaseTexture.Add(new Sprite(new Texture("../../../Resources/Graphics/Environment/" + name + "/" + "Left.png")));
GCharacter character = new GCharacter();
character.Parts.Add(part);
AnimationStep step = new AnimationStep();
step.Duration = Time.FromSeconds(1f);
step.Rotation = 0;
AnimationPart animPart = new AnimationPart();
animPart.Steps.Add(step);
Animation anim = new Animation();
anim.Parts.Add(animPart);
character.Animations.Add(anim);
Display = character;
}
public void OpenDropObject()
{
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
if (!isOpend)
{
isOpend = true;
SoundManager.PlayOneShotUISE(10000071);
if (animEventProcessor != null)
{
animEventProcessor.CrossFade(openAnimHash, 0f);
}
effect = EffectManager.GetEffect("ef_btl_treasurebox_01", null);
effect.set_position(_transform.get_position());
rymFX component = effect.GetComponent <rymFX>();
if (component != null)
{
component.AutoDelete = true;
component.LoopEnd = true;
}
MonoBehaviourSingleton <CoopNetworkManager> .I.RewardGet(rewardId);
if (deliveryInfo != null && deliveryInfo.Count > 0)
{
SoundManager.PlayOneShotUISE(40000155);
}
else if (isRare)
{
SoundManager.PlayOneShotUISE(40000154);
}
else
{
SoundManager.PlayOneShotUISE(10000064);
}
animationStep = AnimationStep.OPEN;
}
}
public void LoadGraphics(string name)
{
try
{
GPart part = new GPart();
part.BaseTexture.Add(new Sprite(new Texture("../../../Resources/Graphics/Environment/" + name + "/" +
name + ".png")));
GCharacter character = new GCharacter();
character.Parts.Add(part);
AnimationStep step = new AnimationStep();
step.Duration = Time.FromSeconds(1f);
step.Rotation = 0;
AnimationPart animPart = new AnimationPart();
animPart.Steps.Add(step);
Animation anim = new Animation();
anim.Parts.Add(animPart);
character.Animations.Add(anim);
Display = character;
}
catch (LoadingFailedException e)
{
Console.WriteLine("No graphics file for " + name);
}
}
// baseStep steps
public static void AnimationStep(int index, BattleAnimation battleAnimation, AnimationStep baseStep)
{
if(!battleAnimation.hideButtons)
{
EditorGUILayout.BeginHorizontal();
if(GUILayout.Button("Remove", GUILayout.Width(100)))
{
battleAnimation.RemoveStep(index);
return;
}
if(index > 0)
{
if(GUILayout.Button("Move Up", GUILayout.Width(100)))
{
battleAnimation.MoveStepUp(index);
return;
}
}
if(index < battleAnimation.step.Length-1)
{
if(GUILayout.Button("Move Down", GUILayout.Width(100)))
{
battleAnimation.MoveStepDown(index);
return;
}
}
baseStep.stepEnabled = EditorGUILayout.Toggle("Step enabled", baseStep.stepEnabled, GUILayout.Width(200));
GUILayout.FlexibleSpace();
if(GUILayout.Button("Copy", GUILayout.Width(100)))
{
battleAnimation.InsertStep(baseStep.GetCopy(battleAnimation), index+1);
return;
}
if(GUILayout.Button("Move To", GUILayout.Width(100)))
{
battleAnimation.MoveStepTo(baseStep.moveTo, index);
}
baseStep.moveTo = EditorGUILayout.IntField(baseStep.moveTo, GUILayout.Width(50));
if(baseStep.moveTo < 0) baseStep.moveTo = 0;
else if(baseStep.moveTo >= battleAnimation.step.Length) baseStep.moveTo = battleAnimation.step.Length-1;
EditorGUILayout.EndHorizontal();
}
if(baseStep is RandomAStep) {}
else
{
baseStep.next = EditorGUILayout.IntField("Next step", baseStep.next, GUILayout.Width(200));
}
EditorGUILayout.Separator();
}
public static void ShowTab(int index, BattleAnimation battleAnimation, AnimationStep baseStep)
{
if(baseStep is WaitAStep) BattleAnimationTabs.WaitAStep(index, battleAnimation, (WaitAStep)baseStep);
else if(baseStep is GoToAStep) BattleAnimationTabs.GoToAStep(index, battleAnimation, (GoToAStep)baseStep);
else if(baseStep is RandomAStep) BattleAnimationTabs.RandomAStep(index, battleAnimation, (RandomAStep)baseStep);
else if(baseStep is CheckRandomAStep) BattleAnimationTabs.CheckRandomAStep(index, battleAnimation, (CheckRandomAStep)baseStep);
else if(baseStep is CheckFormulaAStep) BattleAnimationTabs.CheckFormulaAStep(index, battleAnimation, (CheckFormulaAStep)baseStep);
else if(baseStep is WaitForButtonAStep) BattleAnimationTabs.WaitForButtonAStep(index, battleAnimation, (WaitForButtonAStep)baseStep);
else if(baseStep is CheckDifficultyAStep) BattleAnimationTabs.CheckDifficultyAStep(index, battleAnimation, (CheckDifficultyAStep)baseStep);
else if(baseStep is CheckUserAStep) BattleAnimationTabs.CheckUserAStep(index, battleAnimation, (CheckUserAStep)baseStep);
else if(baseStep is PlayAnimationAStep) BattleAnimationTabs.PlayAnimationAStep(index, battleAnimation, (PlayAnimationAStep)baseStep);
else if(baseStep is StopAnimationAStep) BattleAnimationTabs.StopAnimationAStep(index, battleAnimation, (StopAnimationAStep)baseStep);
else if(baseStep is CallAnimationAStep) BattleAnimationTabs.CallAnimationAStep(index, battleAnimation, (CallAnimationAStep)baseStep);
else if(baseStep is PlaySoundAStep) BattleAnimationTabs.PlaySoundAStep(index, battleAnimation, (PlaySoundAStep)baseStep);
else if(baseStep is StopSoundAStep) BattleAnimationTabs.StopSoundAStep(index, battleAnimation, (StopSoundAStep)baseStep);
else if(baseStep is CalculateAStep) BattleAnimationTabs.CalculateAStep(index, battleAnimation, (CalculateAStep)baseStep);
else if(baseStep is DamageMultiplierAStep) BattleAnimationTabs.DamageMultiplierAStep(index, battleAnimation, (DamageMultiplierAStep)baseStep);
else if(baseStep is ActivateDamageAStep) BattleAnimationTabs.ActivateDamageAStep(index, battleAnimation, (ActivateDamageAStep)baseStep);
else if(baseStep is RestoreControlAStep) BattleAnimationTabs.RestoreControlAStep(index, battleAnimation, (RestoreControlAStep)baseStep);
else if(baseStep is SetCamPosAStep) BattleAnimationTabs.SetCamPosAStep(index, battleAnimation, (SetCamPosAStep)baseStep);
else if(baseStep is FadeCamPosAStep) BattleAnimationTabs.FadeCamPosAStep(index, battleAnimation, (FadeCamPosAStep)baseStep);
else if(baseStep is SetInitialCamPosAStep) BattleAnimationTabs.SetInitialCamPosAStep(index, battleAnimation, (SetInitialCamPosAStep)baseStep);
else if(baseStep is FadeToInitialCamPosAStep) BattleAnimationTabs.FadeToInitialCamPosAStep(index, battleAnimation, (FadeToInitialCamPosAStep)baseStep);
else if(baseStep is ShakeCameraAStep) BattleAnimationTabs.ShakeCameraAStep(index, battleAnimation, (ShakeCameraAStep)baseStep);
else if(baseStep is RotateCamAroundAStep) BattleAnimationTabs.RotateCamAroundAStep(index, battleAnimation, (RotateCamAroundAStep)baseStep);
else if(baseStep is MountCameraAStep) BattleAnimationTabs.MountCameraAStep(index, battleAnimation, (MountCameraAStep)baseStep);
else if(baseStep is FadeObjectAStep) BattleAnimationTabs.FadeObjectAStep(index, battleAnimation, (FadeObjectAStep)baseStep);
else if(baseStep is FadeCameraAStep) BattleAnimationTabs.FadeCameraAStep(index, battleAnimation, (FadeCameraAStep)baseStep);
else if(baseStep is SetToPositionAStep) BattleAnimationTabs.SetToPositionAStep(index, battleAnimation, (SetToPositionAStep)baseStep);
else if(baseStep is MoveToAStep) BattleAnimationTabs.MoveToAStep(index, battleAnimation, (MoveToAStep)baseStep);
else if(baseStep is MoveToDirectionAStep) BattleAnimationTabs.MoveToDirectionAStep(index, battleAnimation, (MoveToDirectionAStep)baseStep);
else if(baseStep is RotateToAStep) BattleAnimationTabs.RotateToAStep(index, battleAnimation, (RotateToAStep)baseStep);
else if(baseStep is RotationAStep) BattleAnimationTabs.RotationAStep(index, battleAnimation, (RotationAStep)baseStep);
else if(baseStep is LookAtAStep) BattleAnimationTabs.LookAtAStep(index, battleAnimation, (LookAtAStep)baseStep);
else if(baseStep is SpawnPrefabAStep) BattleAnimationTabs.SpawnPrefabAStep(index, battleAnimation, (SpawnPrefabAStep)baseStep);
else if(baseStep is DestroyPrefabAStep) BattleAnimationTabs.DestroyPrefabAStep(index, battleAnimation, (DestroyPrefabAStep)baseStep);
else if(baseStep is SetVariableAStep) BattleAnimationTabs.SetVariableAStep(index, battleAnimation, (SetVariableAStep)baseStep);
else if(baseStep is RemoveVariableAStep) BattleAnimationTabs.RemoveVariableAStep(index, battleAnimation, (RemoveVariableAStep)baseStep);
else if(baseStep is CheckVariableAStep) BattleAnimationTabs.CheckVariableAStep(index, battleAnimation, (CheckVariableAStep)baseStep);
else if(baseStep is SetNumberVariableAStep) BattleAnimationTabs.SetNumberVariableAStep(index, battleAnimation, (SetNumberVariableAStep)baseStep);
else if(baseStep is RemoveNumberVariableAStep) BattleAnimationTabs.RemoveNumberVariableAStep(index, battleAnimation, (RemoveNumberVariableAStep)baseStep);
else if(baseStep is CheckNumberVariableAStep) BattleAnimationTabs.CheckNumberVariableAStep(index, battleAnimation, (CheckNumberVariableAStep)baseStep);
else if(baseStep is SendMessageAStep) BattleAnimationTabs.SendMessageAStep(index, battleAnimation, (SendMessageAStep)baseStep);
else if(baseStep is BroadcastMessageAStep) BattleAnimationTabs.BroadcastMessageAStep(index, battleAnimation, (BroadcastMessageAStep)baseStep);
else if(baseStep is AddComponentAStep) BattleAnimationTabs.AddComponentAStep(index, battleAnimation, (AddComponentAStep)baseStep);
else if(baseStep is RemoveComponentAStep) BattleAnimationTabs.RemoveComponentAStep(index, battleAnimation, (RemoveComponentAStep)baseStep);
else if(baseStep is AddItemAStep) BattleAnimationTabs.AddItemAStep(index, battleAnimation, (AddItemAStep)baseStep);
else if(baseStep is RemoveItemAStep) BattleAnimationTabs.RemoveItemAStep(index, battleAnimation, (RemoveItemAStep)baseStep);
else if(baseStep is CheckItemAStep) BattleAnimationTabs.CheckItemAStep(index, battleAnimation, (CheckItemAStep)baseStep);
else if(baseStep is SetPlayerPrefsAStep) BattleAnimationTabs.SetPlayerPrefsAStep(index, battleAnimation, (SetPlayerPrefsAStep)baseStep);
else if(baseStep is GetPlayerPrefsAStep) BattleAnimationTabs.GetPlayerPrefsAStep(index, battleAnimation, (GetPlayerPrefsAStep)baseStep);
else if(baseStep is HasPlayerPrefsAStep) BattleAnimationTabs.HasPlayerPrefsAStep(index, battleAnimation, (HasPlayerPrefsAStep)baseStep);
else if(baseStep is CustomStatisticAStep) BattleAnimationTabs.CustomStatisticAStep(index, battleAnimation, (CustomStatisticAStep)baseStep);
else if(baseStep is ClearStatisticAStep) BattleAnimationTabs.ClearStatisticAStep(index, battleAnimation, (ClearStatisticAStep)baseStep);
// last
else if(baseStep is AnimationStep) BattleAnimationTabs.AnimationStep(index, battleAnimation, (AnimationStep)baseStep);
}
public static AnimationStep[] Add(AnimationStep n, AnimationStep[] list)
{
ArrayList tmp = new ArrayList();
foreach(AnimationStep str in list) tmp.Add(str);
tmp.Add(n);
return tmp.ToArray(typeof(AnimationStep)) as AnimationStep[];
}
public static AnimationStep[] Remove(int index, AnimationStep[] list)
{
ArrayList tmp = new ArrayList();
foreach(AnimationStep str in list) tmp.Add(str);
tmp.RemoveAt(index);
return tmp.ToArray(typeof(AnimationStep)) as AnimationStep[];
}
