private void InitialzeStateManager()
{
_stateManager = new StateManager(_muffinAnimator);
IdleState idle = new IdleState(_stateManager, transform);
MoveState move = new MoveState(_stateManager, transform);
TrapState trap = new TrapState(_stateManager, transform);
DieState die = new DieState(_stateManager, transform);
SpinState spin = new SpinState(_stateManager, transform);
BlastState blast = new BlastState(_stateManager, transform);
ChocoRushState chocoRush = new ChocoRushState(_stateManager, transform);
PauseState pause = new PauseState(_stateManager, transform);
_stateManager.AddCharacterState(idle);
_stateManager.AddCharacterState(move);
_stateManager.AddCharacterState(trap);
_stateManager.AddCharacterState(die);
_stateManager.AddCharacterState(spin);
_stateManager.AddCharacterState(blast);
_stateManager.AddCharacterState(chocoRush);
_stateManager.AddCharacterState(pause);
_stateManager.SetDefaultState("Pause");
}
void Update()
{
switch (spinState)
{
case SpinState.Waiting:
waitTime -= Time.deltaTime;
spinTime = tempSpinTime;
isSpinning = false;
SetThemInactive(particleEffects);
if (waitTime <= 0)
{
spinState = SpinState.Spinning;
}
break;
case SpinState.Spinning:
spinTime -= Time.deltaTime;
waitTime = tempWaitTime;
isSpinning = true;
SetThemActive(particleEffects);
gameObject.transform.Rotate(0, 0, spinSpeed * Time.deltaTime);
if (spinTime <= 0)
{
spinState = SpinState.Waiting;
}
break;
}
}
void Start()
{
tempSpinTime = spinTime;
tempWaitTime = waitTime;
spinState = SpinState.Spinning;
circleCol = gameObject.GetComponent <CircleCollider2D>();
}
public void ThreeJRacahSymmetry()
{
foreach (ThreeJSymbol symbol in GenerateRandomThreeJSymbols(50.0, 10))
{
// compute the 3j symbol
SpinState s1 = symbol.Column1;
SpinState s2 = symbol.Column2;
SpinState s3 = symbol.Column3;
double C = SpinMath.ThreeJ(s1, s2, s3);
// form other 3j symbols related by Racah symmetry
double k1, k2, k3, n1, n2, n3;
SpinState t1, t2, t3;
// rows 1->2->3
k1 = (s2.J + s2.M + s3.J + s3.M) / 2.0;
k2 = (s1.J + s1.M + s3.J + s3.M) / 2.0;
k3 = (s1.J + s1.M + s2.J + s2.M) / 2.0;
n1 = s1.J - s1.M - k1;
n2 = s2.J - s2.M - k2;
n3 = s3.J - s3.M - k3;
t1 = new SpinState(k1, n1);
t2 = new SpinState(k2, n2);
t3 = new SpinState(k3, n3);
double CC = SpinMath.ThreeJ(t1, t2, t3);
Assert.IsTrue(TestUtilities.IsNearlyEqual(C, CC));
// transpose rows and columns
/*
* k1 = s1.J;
* k2 = (s2.J + s3.J + s1.M) / 2.0;
* k3 = (s2.J + s3.J - s1.M) / 2.0;
* n1 = s2.J - s3.J;
* n2 = s3.J - s3.M - k2;
* n3 = s3.J + s3.M - k2;
*
* t1 = new SpinState(k1, n1);
* t2 = new SpinState(k2, n2);
* t3 = new SpinState(k3, n3);
* double CT = SpinMath.ThreeJ(t1, t2, t3);
*
* Assert.IsTrue(TestUtilities.IsNearlyEqual(C, CT));
*/
}
}
public void StartSpin(float spinDelay)
{
if(isSpinning) {
return;
}
this.delay = spinDelay;
delaySpent = 0.0f;
velocity = 0;
spinningFor = 0;
haveTarget = false;
state = SpinState.Delay;
isSpinning = true;
}
private static SpinState[] GenerateRandomSpinStates(Spin j, int n)
{
int tj = (int)(2.0 * j.J);
SpinState[] result = new SpinState[n];
Random rng = new Random(1);
for (int i = 0; i < n; i++)
{
int tm = -tj + 2 * rng.Next(tj + 1);
result[i] = new SpinState(j, tm / 2.0);
}
return(result);
}
// generates only spinors of the same parity as j_min
private static SpinState[] GenerateRandomSpinStates(double j_min, double j_max, int n)
{
int tj_min = (int)Math.Truncate(2.0 * j_min);
int tj_max = (int)Math.Truncate(2.0 * j_max);
SpinState[] states = new SpinState[n];
Random rng = new Random(1);
for (int i = 0; i < n; i++)
{
int tj = tj_min + 2 * rng.Next((tj_max - tj_min) / 2);
int tm = -tj + 2 * rng.Next(tj);
states[i] = new SpinState(tj / 2.0, tm / 2.0);
}
return(states);
}
public void ThreeJExchangeSymmetry()
{
foreach (ThreeJSymbol symbol in GenerateRandomThreeJSymbols(50.0, 10))
{
SpinState s1 = symbol.Column1;
SpinState s2 = symbol.Column2;
SpinState s3 = symbol.Column3;
Console.WriteLine("( {0} {1} {2} )", s1.J, s2.J, s3.J);
Console.WriteLine("( {0} {1} {2} )", s1.M, s2.M, s3.M);
double s123 = SpinMath.ThreeJ(s1, s2, s3);
double s231 = SpinMath.ThreeJ(s2, s3, s1);
double s312 = SpinMath.ThreeJ(s3, s1, s2);
Console.WriteLine("{0},{1},{2}", s123, s231, s312);
Assert.IsTrue(TestUtilities.IsNearlyEqual(s123, s231));
Assert.IsTrue(TestUtilities.IsNearlyEqual(s123, s312));
int P;
if (((int)(s1.J + s2.J + s3.J)) % 2 == 0)
{
P = 1;
}
else
{
P = -1;
}
double s132 = SpinMath.ThreeJ(s1, s3, s2);
double s213 = SpinMath.ThreeJ(s2, s1, s3);
double s321 = SpinMath.ThreeJ(s3, s2, s1);
Console.WriteLine("{0},{1},{2}", s132, s213, s321);
Assert.IsTrue(TestUtilities.IsNearlyEqual(s123, P * s132));
Assert.IsTrue(TestUtilities.IsNearlyEqual(s123, P * s213));
Assert.IsTrue(TestUtilities.IsNearlyEqual(s123, P * s321));
}
}
public SpinningBoss()
: base(new Vector2(Screen.X, 0))
{
Tesseract.Engine.GameWorld.GameState.InstantiateCurrent(new StoryElement(LevelManager.world.Reward));
lastHit = -(float)Math.PI / 2;
leftPieces = new List<Enemy>();
rightPieces = new List<Enemy>();
emitter = ParticleFactory.CreateStream(Color.Fuchsia, 4, 2, 64);
for (int i = 0; i < 3; ++i)
{
EnemyMelee em = new EnemyMelee(Vector2.Zero, -1);
em.radius *= 0.75f;
leftPieces.Add(em);
}
for (int i = 0; i < 3; ++i)
{
EnemyMelee em = new EnemyMelee(Vector2.Zero, -1);
em.radius *= 0.75f;
rightPieces.Add(em);
}
leftOrb = new EnemyMelee(Vector2.Zero, -1);
leftOrb.radius *= 1.5f;
leftOrb.nBuild.PolyColor = Color.Fuchsia;
leftOrb.Invulnerable = true;
rightOrb = new EnemyMelee(Vector2.Zero, -1);
rightOrb.radius *= 1.5f;
rightOrb.nBuild.PolyColor = Color.Fuchsia;
rightOrb.Invulnerable = true;
spinTarget = Rotation + 1;
Rotation = 0;
state = SpinState.Spin;
stateTime = 0;
health = 8;
nBuild.PolyColor = Color.Fuchsia;
radius *= 1.5f;
Invulnerable = true;
}
///<summary>Transitions to the declerating state to stop the animation</summary>
void DecelerateAndStopTheAnimation()
{
if ( theSpinState != SpinState.Decelerating ) {
spinAnimation.From = SpinAngle;
spinAnimation.To = (SpinAngle + (OneRotation / 8));
spinAnimation.Duration = new Duration(TimeSpan.FromSeconds(SpinRate / 4));
spinAnimation.DecelerationRatio = 1.0;
spinAnimation.AccelerationRatio = 0.0;
spinAnimation.RepeatBehavior = new RepeatBehavior(1.0); // default: repeat once.
spinAnimation.Completed += RemoveAnimation;
theSpinState = SpinState.Decelerating;
this.BeginAnimation(SpinAngleProperty, spinAnimation);
}
}
void setMovingLeft()
{
float targetRotation = (targetLine / (float)totalLine);
Quaternion target = Quaternion.Euler(0, 0, targetRotation * 360.0f);
if (Mathf.Abs(transform.rotation.z - target.z) % Mathf.PI < 0.0001)
{
curLine = targetLine;
spinState = SpinState.Stop;
return;
}
transform.rotation = Quaternion.RotateTowards(transform.rotation, target, spinSpeed);
}
///<summary>Begins, or re-begins the spin animation.</summary>
void BeginSpinningAnimation()
{
switch (theSpinState)
{
case SpinState.NotSpinning:
SpinAngle = Angle;
spinAnimation = new DoubleAnimation();
break;
case SpinState.Decelerating:
break;
case SpinState.Accelerating:
case SpinState.Running:
throw new InvalidOperationException("Should not be in the Acclerating or Running state.");
}
spinAnimation.From = SpinAngle;
spinAnimation.To = (SpinAngle + (OneRotation / 8));
spinAnimation.Duration = new Duration(TimeSpan.FromSeconds(SpinRate/4));
spinAnimation.DecelerationRatio = 0.0;
spinAnimation.AccelerationRatio = 1.0;
spinAnimation.Completed += SpinContinuously;
theSpinState = SpinState.Accelerating;
this.BeginAnimation(SpinAngleProperty, spinAnimation);
}
public void SpinStateInvalid1()
{
// spin state indices are smaller than spin indices
SpinState s = new SpinState(1.0, -2.0);
}
void keyDownStateCange(float key)
{
if (spinState != SpinState.Stop || player.isDodging())
{
return;
}
if ( key > 0 )
{
spinState = SpinState.Right;
player.rightMove();
targetLine = (curLine + 3) % 4;
}
else if ( key < 0)
{
spinState = SpinState.Left;
player.leftMove();
targetLine = (curLine + 1) % 4;
}
}
public void SpinStateInvalid2()
{
// spin states indices match the parity of spin indices
SpinState s = new SpinState(1.0, 0.5);
}
void UpdateStopping()
{
velocity -= deceleration * Time.deltaTime;
if(velocity < minVelocity) {
velocity = minVelocity;
}
foreach(var go in icons) {
var localPos = go.transform.localPosition;
localPos.y -= velocity;
go.transform.localPosition = localPos;
}
for(var i = 0; i < icons.Count; i++) {
var toUpdate = icons[i];
var pos = toUpdate.transform.localPosition;
if(pos.y < -50) {
var idx = i - 1;
if(idx < 0) {
idx += icons.Count;
}
var next = icons[idx];
var nextPos = next.transform.localPosition;
pos.y = nextPos.y + 100.0f;
toUpdate.transform.localPosition = pos;
}
}
var stopPos = icons[(int)target].transform.localPosition.y;
if(Mathf.Abs(100.0f - stopPos) < minVelocity * 1.5f) {
state = SpinState.Stopped;
}
}
public void SpinStateInvalid3()
{
// spin state values are integer or half-integer
SpinState s = new SpinState(3.0, 0.75);
}
private void SetState(SpinState state)
{
this.lastHit = 0;
this.state = state;
this.stateTime = 0;
}
/// <summary>Called when the animation has slowed to a stop. Removes the animation</summary>
/// <remarks>This should only be called from the spinAnimationCompleted event.</remarks>
void RemoveAnimation(object sender, EventArgs e)
{
spinAnimation.Completed -= RemoveAnimation;
//
// We have to remember the current spin angle becuase the animation will
// reset the SpinAngleProperty back to its base value when it is removed
// from the SpinAngleProperty. The SpinAngleProperty base value is the
// animations from value.
//
double tmp = SpinAngle % OneRotation;
this.BeginAnimation(SpinAngleProperty, null);
Angle = tmp;
SpinAngle = tmp;
SetValue(SpinningPropertyKey, false);
//
// We have to 'forget' the spin animation here because once set, it never
// forget's the SpinAngleProperty base value so we will get jerks when
// spin is renabled. Said another way, simply removing the animation
// from the property does not cause it to forget its state. So, we must
// throw away the current animation and create a new one next time
// spinning is re-enabled.
//
spinAnimation = null;
theSpinState = SpinState.NotSpinning;
if (!IsEnabled)
{
SetDisabledBrushes();
}
}
/// <summary>Updates the animation to spin continuously</summary>
void SpinContinuously(object sender, EventArgs e)
{
spinAnimation.Completed -= SpinContinuously;
spinAnimation.From = SpinAngle;
spinAnimation.To = SpinAngle + OneRotation;
spinAnimation.Duration = new Duration(TimeSpan.FromSeconds(SpinRate));
spinAnimation.DecelerationRatio = 0.0;
spinAnimation.AccelerationRatio = 0.0;
spinAnimation.RepeatBehavior = RepeatBehavior.Forever;
theSpinState = SpinState.Running;
this.BeginAnimation(SpinAngleProperty, spinAnimation);
}
void UpdateDelay()
{
delaySpent += Time.deltaTime;
if(delaySpent > delay) {
audio.clip = startSound;
audio.Play ();
state = SpinState.Spinning;
}
}
void UpdateSpinning()
{
velocity += acceleration * Time.deltaTime;
if(velocity > maxVelocity) {
velocity = maxVelocity;
}
foreach(var go in icons) {
var localPos = go.transform.localPosition;
localPos.y -= velocity;
go.transform.localPosition = localPos;
}
for(var i = 0; i < icons.Count; i++) {
var toUpdate = icons[i];
var pos = toUpdate.transform.localPosition;
if(pos.y < -100) {
var idx = i - 1;
if(idx < 0) {
idx += icons.Count;
}
var next = icons[idx];
var nextPos = next.transform.localPosition;
pos.y = nextPos.y + 100.0f;
toUpdate.transform.localPosition = pos;
}
}
spinningFor += Time.deltaTime;
if(haveTarget && spinningFor >= spinTime) {
state = SpinState.Stopping;
}
}
public void SixJThreeJRelation()
{
SixJSymbol[] symbols = GenerateRandomSixJSymbols(50.0, 5);
foreach (SixJSymbol symbol in symbols)
{
Spin a = symbol.J1;
Spin b = symbol.J2;
Spin c = symbol.J3;
Spin d = symbol.J4;
Spin e = symbol.J5;
Spin f = symbol.J6;
SpinState[] ams = GenerateRandomSpinStates(a, 2);
SpinState[] bms = GenerateRandomSpinStates(b, 2);
foreach (SpinState am in ams)
{
foreach (SpinState bm in bms)
{
if (Math.Abs(am.M + bm.M) > c.J)
{
continue;
}
SpinState cm = new SpinState(c, -(am.M + bm.M));
double g1 = SpinMath.ThreeJ(am, bm, cm);
double g2 = SpinMath.SixJ(a, b, c, d, e, f);
double p = g1 * g2;
double q = 0.0;
List <double> ts = new List <double>();
SpinState[] dms = d.States();
foreach (SpinState dm in dms)
{
if (Math.Abs(dm.M + cm.M) > e.J)
{
continue;
}
SpinState em = new SpinState(e, dm.M + cm.M);
SpinState mem = new SpinState(e, -em.M);
double f1 = SpinMath.ThreeJ(dm, mem, cm);
if (Math.Abs(em.M + am.M) > f.J)
{
continue;
}
SpinState fm = new SpinState(f, em.M + am.M);
SpinState mfm = new SpinState(f, -fm.M);
double f2 = SpinMath.ThreeJ(em, mfm, am);
SpinState mdm = new SpinState(d, -dm.M);
double f3 = SpinMath.ThreeJ(fm, mdm, bm);
double t = f1 * f2 * f3;
int s = (int)Math.Round(dm.J + dm.M + em.J + em.M + fm.J + fm.M);
if (s % 2 != 0)
{
t = -t;
}
q += t;
ts.Add(t);
}
Console.WriteLine("{0} v. {1}", p, q);
//Assert.IsTrue(TestUtilities.IsNearlyEqual(p, q));
Assert.IsTrue(TestUtilities.IsSumNearlyEqual(ts, p));
}
}
}
}
