// Use this for initialization
void Start()
{
romanceMusic.Play();
spyMusic.Play();
spyMusic.volume = .75f;
romanceMusic.volume = .75f;
rhythmUI.StartSong(replayMode);
nextDirection = GameDirection.none;
cluck = false;
checks = 0;
replayFrameNumber = 0;
if (!replayMode)
{
replayQueue = new List <replayFrame>();
}
GameObject.Find("ReplayButton").GetComponent <Image> ().enabled = false;
GameObject.Find("ReplayButtonText").GetComponent <Text> ().enabled = false;
// SwitchToDatingSimMode ();
// checks++;
}
public Tux(int top, int left)
: base()
{
Top = top;
Left = left;
imgNormal = new AnimateImage(Files.tux_normal, 200, GameDirection.Left, GameDirection.Right);
imgSmall = new AnimateImage(Files.tux_small, 200, GameDirection.Left, GameDirection.Right);
Width = imgNormal.CurImage(direction).Width;
Height = imgNormal.CurImage(direction).Height;
curimg = imgNormal;
direction = GameDirection.Right;
firePressed = false;
mode = MainGameObjectMode.Normal;
immortializeEnd = DateTime.Now;
immortialize = false;
GamePhysics.JumpData jumping = new GamePhysics.JumpData();
jumping.direction = GameDirection.None;
jumping.distance = 0;
this.jumping = jumping;
wantNext = new Queue<WantNext>();
}
public GameInstruction(InstructionType type, GameObject go, GameDirection direction, float value)
{
this.type = type;
this.go = go;
this.direction = direction;
this.value = value;
}
public static GameDirection RandomSingle(this GameDirection input)
{
List <GameDirection> options = new List <GameDirection>();
if (input.Test(GameDirection.North))
{
options.Add(GameDirection.North);
}
if (input.Test(GameDirection.East))
{
options.Add(GameDirection.East);
}
if (input.Test(GameDirection.South))
{
options.Add(GameDirection.South);
}
if (input.Test(GameDirection.West))
{
options.Add(GameDirection.West);
}
if (options.Count == 0)
{
return(GameDirectionHelper.Nil);
}
return(options[Random.Range(0, options.Count)]);
}
public static GameDirection RotateCCW(GameDirection input)
{
if (input == Nil)
{
return(Nil);
}
if (input == All)
{
return(All);
}
GameDirection output = Nil;
if (input.Test(GameDirection.North))
{
output |= GameDirection.West;
}
if (input.Test(GameDirection.East))
{
output |= GameDirection.South;
}
if (input.Test(GameDirection.South))
{
output |= GameDirection.East;
}
if (input.Test(GameDirection.West))
{
output |= GameDirection.North;
}
return(output);
}
/**
* Return in degrees
*/
public static float AngleFrom(GameDirection from, GameDirection to)
{
switch (from)
{
case GameDirection.North:
switch (to)
{
case GameDirection.North: return(0f);
case GameDirection.East: return(90f);
case GameDirection.South: return(180f);
case GameDirection.West: return(270f);
}
break;
case GameDirection.East:
switch (to)
{
case GameDirection.North: return(270f);
case GameDirection.East: return(0f);
case GameDirection.South: return(90f);
case GameDirection.West: return(180f);
}
break;
case GameDirection.South:
switch (to)
{
case GameDirection.North: return(180f);
case GameDirection.East: return(270f);
case GameDirection.South: return(0f);
case GameDirection.West: return(90f);
}
break;
case GameDirection.West:
switch (to)
{
case GameDirection.North: return(90f);
case GameDirection.East: return(180f);
case GameDirection.South: return(270f);
case GameDirection.West: return(0f);
}
break;
}
return(0f);
}
public override void Check(out Dictionary<string, float> newpos)
{
base.Check(out newpos);
float newtop = newpos["top"];
float newleft = newpos["left"];
switch (direction)
{
case GameDirection.Right: newleft += Globals.ImmortializeStarMove.X * GameAI.FrameFactor; break;
case GameDirection.Left: newleft -= Globals.ImmortializeStarMove.X * GameAI.FrameFactor; break;
}
switch (flyDirection)
{
case GameDirection.Top: newtop -= Globals.ImmortializeStarMove.Y * GameAI.FrameFactor; break;
case GameDirection.Bottom: newtop += Globals.ImmortializeStarMove.Y * GameAI.FrameFactor; break;
}
if (flyDirection == GameDirection.Top)
distance += Globals.ImmortializeStarMove.Y * GameAI.FrameFactor;
if (distance > 200)
{
flyDirection = GameDirection.Bottom;
distance = 0;
}
// check if direction is ok
GamePhysics.CrashDetection(this, World.StickyElements, World.MovingElements, getEvent, ref newtop, ref newleft);
Enemy crashedInEnemy = GamePhysics.CrashEnemy(this, World.Enemies, getEvent, ref newtop, ref newleft);
if (GamePhysics.SimpleCrashDetections(this, World.StickyElements, World.MovingElements, true, newtop, newleft))
{
World.MovingElements.Remove(this);
return;
}
if (newtop != 0)
Top += newtop;
else
flyDirection = GameDirection.Top;
if (newleft != 0)
Left += newleft;
else
{
switch (direction)
{
case GameDirection.Right: direction = GameDirection.Left; break;
case GameDirection.Left: direction = GameDirection.Right; break;
}
}
runs++;
// away?
if (runs >= 150 || Top > World.Settings.LevelHeight)
{
World.MovingElements.Remove(this);
}
}
public Fire(GameDirection direction, float top, float left)
: base(GetDraw.Image(Files.fire), top, left)
{
this.direction = direction;
flyDirection = GameDirection.Bottom;
flyTopCount = 0;
runs = 0;
}
public Mushroom(MushroomType mtype, GameDirection direction, float top, float left)
: base(Mushroom.GetMushroomImage(mtype),
top - Mushroom.GetMushroomImage(mtype).Height,
left)
{
this.mtype = mtype;
distance = 0;
this.direction = direction;
}
public ImmortializeStar(GameDirection direction, float top, float left)
: base(GetDraw.Image(Files.star),
top - GetDraw.Image(Files.star).Height,
left)
{
this.direction = direction;
flyDirection = GameDirection.Top;
distance = 0;
runs = 0;
}
public static int CountContains(this GameDirection input, params GameDirection[] tests)
{
int count = 0;
foreach (GameDirection test in tests)
{
if (input.Test(test))
{
count++;
}
}
return(count);
}
public void ChangeGameDirection()
{
this._direction = this._direction == GameDirection.DIRECTION_FORWARDS ? GameDirection.DIRECTION_BACKWARDS : GameDirection.DIRECTION_FORWARDS;
//if (this.Direction == GameDirection.DIRECTION_FORWARDS)
//{
// this.Direction = GameDirection.DIRECTION_BACKWARDS;
//}
//else
//{
// this.Direction = GameDirection.DIRECTION_FORWARDS;
//}
}
public void HandleExclamation(int oxygen, GameDirection direction)
{
const int oxygenLimit = 3;
bool isExclamationActive = oxygen <= oxygenLimit;
Exclamation.SetActive(isExclamationActive);
Exclamation.transform.SetParent(direction == GameDirection.Down ? ExclamationParentDown : ExclamationParentUp, false);
// if (isExclamationActive
// && (isExclamationActive != _isExclamationActivePrev))
// {
// Sfx.Instance.Play("OxygenWarning");
// }
_isExclamationActivePrev = isExclamationActive;
}
float GetSpeedUpValue(Vector2 normal, string colTag, GameDirection direction)
{
float ret = 0;
//if (colTag == "Paddle" && normal.y == 1)
//{
switch (direction)
{
case GameDirection.GD_HORIZONTAL:
ret += speedUp.x * normal.x;
break;
case GameDirection.GD_VERTICAL:
ret += speedUp.y * normal.y;
break;
}
//}
return(ret);
}
private IEnumerator SwimUpCoroutine()
{
_isMoving = true;
Sfx.Instance.Play("SwimUpRotate");
const float moveDuration = 1.5f;
int amountOfMovement = Mathf.Abs((_tiles.Count - 1) - PlayerRowIndex);
Direction = GameDirection.Up;
CoroutineStarter.Run(Player.PlayMoveAnim(moveDuration, Direction));
const float spaceBetweenTiles = 1.5f;
Vector3 scrollAmount = (Direction == GameDirection.Up ? Vector3.up : Vector3.down) * spaceBetweenTiles * amountOfMovement;
Vector3 cameraSrc = CameraTransform.position;
Vector3 cameraTarget = cameraSrc + scrollAmount;
Player.Exclamation.transform.SetParent(Player.ExclamationParentUp, false);
Curve.Tween(MoveCurve,
moveDuration,
t =>
{
CameraTransform.position = Vector3.Lerp(cameraSrc, cameraTarget, t);
},
() =>
{
CameraTransform.position = cameraTarget;
});
EndTileRoot.SetActive(true);
EndTileRoot.GetComponent <Tile>().Index = (-1, 2);
OnReturnStage = true;
yield return(new WaitForSeconds(moveDuration));
_isMoving = false;
}
public static GridPos Adjacent(this GridPos me, GameDirection dir)
{
if (dir == GameDirection.North)
{
return(new GridPos(me.x, me.z + 1));
}
if (dir == GameDirection.East)
{
return(new GridPos(me.x + 1, me.z));
}
if (dir == GameDirection.South)
{
return(new GridPos(me.x, me.z - 1));
}
if (dir == GameDirection.West)
{
return(new GridPos(me.x - 1, me.z));
}
return(GridPos.Invalid);
}
public void Init(GameObject head, int segments = 1, GameDirection direction = GameDirection.Right)
{
Direction = direction;
Segments.Clear();
Segments.Add(head);
GameObject pseg = head;
for (int i = 0; i < segments; i++)
{
float x, y;
switch (direction)
{
case GameDirection.Up:
x = pseg.X;
y = pseg.Y + pseg.Height;
break;
case GameDirection.Down:
x = pseg.X;
y = pseg.Y - pseg.Height;
break;
case GameDirection.Left:
x = pseg.X + pseg.Width;
y = pseg.Y;
break;
default:
x = pseg.X - pseg.Width;
y = pseg.Y;
break;
}
GameObject nseg = new GameObject(x, y, pseg.Width, pseg.Height);
Segments.Add(nseg);
pseg = nseg;
}
}
public override void onOver(GameEventHandler geventhandler, GameElement who, GameDirection direction)
{
base.onOver(geventhandler, who, direction);
if (who == GameElement.MGO)
{
switch (World.MGO.Mode)
{
case MainGameObjectMode.Small:
case MainGameObjectMode.Normal:
geventhandler(GameEvent.gotFireFlower, new Dictionary<GameEventArg, object>());
break;
case MainGameObjectMode.NormalFire:
Dictionary<GameEventArg, object> pointsArgs = new Dictionary<GameEventArg,object>();
pointsArgs[GameEventArg.points] = 10;
geventhandler(GameEvent.gotPoints, pointsArgs);
break;
}
World.StickyElements.Remove(this);
}
}
public GameDirection DirectionTo(GridPos adj)
{
GameDirection result = GameDirectionHelper.Nil;
if (adj.z > z)
{
result |= GameDirection.North;
}
if (adj.x > x)
{
result |= GameDirection.East;
}
if (adj.z < z)
{
result |= GameDirection.South;
}
if (adj.x < x)
{
result |= GameDirection.West;
}
return(result);
}
public static int Count(this GameDirection input)
{
int total = 0;
if (input.Test(GameDirection.North))
{
total++;
}
if (input.Test(GameDirection.East))
{
total++;
}
if (input.Test(GameDirection.South))
{
total++;
}
if (input.Test(GameDirection.West))
{
total++;
}
return(total);
}
public IEnumerator PlayMoveAnim(float duration, GameDirection direction)
{
Vector3 scale = Visual.transform.localScale;
if (direction == GameDirection.Down)
{
scale.y = -Mathf.Abs(scale.y);
}
else
{
scale.y = Mathf.Abs(scale.y);
}
Visual.transform.localScale = scale;
if (_idleCoroutine != null)
{
CoroutineStarter.Stop(_idleCoroutine);
}
yield return(CoroutineStarter.Run(PlayFxCoroutine(MoveSprites, duration, 9)));
PlayIdleAnim(direction);
}
public override void onOver(GameEventHandler geventhandler, GameElement who, GameDirection direction)
{
base.onOver(geventhandler, who, direction);
if (color == BrickColor.Ice && who == GameElement.MGO && direction == GameDirection.Top)
{
switch (World.MGO.Direction)
{
case GameDirection.Left:
for (int i = 0; i < 2; i++)
{
fillMgoMoveQueue(MoveType.goLeft);
}
break;
case GameDirection.Right:
for (int i = 0; i < 2; i++)
{
fillMgoMoveQueue(MoveType.goRight);
}
break;
}
}
}
public void PlayIdleAnim(GameDirection direction)
{
Vector3 scale = Visual.transform.localScale;
if (direction == GameDirection.Down)
{
scale.y = -Mathf.Abs(scale.y);
}
else
{
scale.y = Mathf.Abs(scale.y);
}
Visual.transform.localScale = scale;
if (_idleCoroutine != null)
{
CoroutineStarter.Stop(_idleCoroutine);
}
_idleCoroutine = CoroutineStarter.Run(PlayFxCoroutine(IdleSprites, 999, 4));
}
public IEnumerator PlayDeadAnim(float duration, GameDirection direction)
{
Vector3 scale = Visual.transform.localScale;
if (direction == GameDirection.Down)
{
scale.y = -Mathf.Abs(scale.y);
}
else
{
scale.y = Mathf.Abs(scale.y);
}
Visual.transform.localScale = scale;
if (_idleCoroutine != null)
{
CoroutineStarter.Stop(_idleCoroutine);
}
Visual.sprite = DeadSprite;
yield return(CoroutineStarter.Run(PlayFlipCoroutine(duration)));
}
public static bool Test(this GameDirection input, GameDirection test)
{
return((input & test) == test);
}
public override void Check(out Dictionary<string, float> newpos)
{
base.Check(out newpos);
float newtop = newpos["top"];
float newleft = newpos["left"];
switch (direction)
{
case GameDirection.Right: newleft += Globals.FireMove.X * GameAI.FrameFactor; break;
case GameDirection.Left: newleft -= Globals.FireMove.X * GameAI.FrameFactor; break;
}
if (runs >= 50)
{
switch(flyDirection)
{
case GameDirection.Bottom: newtop += Globals.FireMove.Y * GameAI.FrameFactor; break;
case GameDirection.Top: newtop -= Globals.FireMove.Y * GameAI.FrameFactor; break;
}
}
runs++;
if (flyDirection == GameDirection.Top)
flyTopCount++;
if (flyTopCount > 10)
{
flyDirection = GameDirection.Bottom;
flyTopCount = 0;
}
// check if direction is ok
GamePhysics.CrashDetection(this, World.StickyElements, World.MovingElements, getEvent, ref newtop, ref newleft);
Enemy crashedInEnemy = GamePhysics.CrashEnemy(this, World.Enemies, getEvent, ref newtop, ref newleft);
if (GamePhysics.SimpleCrashDetections(this, World.StickyElements, World.MovingElements, true, newtop, newleft))
{
World.MovingElements.Remove(this);
return;
}
if (crashedInEnemy != null) // crashed in some enemy
{
if (crashedInEnemy.fireCanDelete) // fire can delete it?
{
crashedInEnemy.Remove();
World.MovingElements.Remove(this);
}
else // crashed in enemy and fire can't delete it --> remove fire
World.MovingElements.Remove(this);
return;
}
if (newtop != 0)
Top += newtop;
else if (runs >= 52) // 50 -> start moving, +1 -> nothing moved, so use +2!
flyDirection = GameDirection.Top;
if (newleft != 0)
Left += newleft;
else
World.MovingElements.Remove(this);
// away?
if (runs >= 200 || Top > World.Settings.LevelHeight)
{
World.MovingElements.Remove(this);
}
}
public override void onOver(GameEventHandler geventhandler, GameElement who, GameDirection direction)
{
base.onOver(geventhandler, who, direction);
if (who == GameElement.MGO)
{
geventhandler(GameEvent.gotImmortialize, new Dictionary<GameEventArg, object>());
World.MovingElements.Remove(this);
}
}
public static GameDirection Opposite(this GameDirection input)
{
return(GameDirectionHelper.Opposite(input));
}
public static GameDirection Invert(this GameDirection input)
{
return(GameDirectionHelper.Invert(input));
}
public override void Check(out Dictionary<string, float> newpos)
{
base.Check(out newpos);
float newtop = newpos["top"];
float newleft = newpos["left"];
bool falling = false;
if (distance < 120)
{
newtop -= Globals.MushroomMove.GO_Y * GameAI.FrameFactor;
distance += Globals.MushroomMove.GO_Y * GameAI.FrameFactor;
}
else
{
// falling?
falling = GamePhysics.Falling(World.StickyElements, World.MovingElements, World.Enemies, newtop, newleft, this);
if (falling)
newtop += Globals.MushroomMove.GO_Y * GameAI.FrameFactor;
}
if (direction == GameDirection.Left)
newleft -= Globals.MushroomMove.GO_X * GameAI.FrameFactor;
else if (direction == GameDirection.Right)
newleft += Globals.MushroomMove.GO_X * GameAI.FrameFactor;
// check if direction is ok
GamePhysics.CrashDetection(this, World.StickyElements, World.MovingElements, getEvent, ref newtop, ref newleft);
// run in standing mgo?
GameDirection _direction;
if (GamePhysics.SingleCrashDetection(this, World.MGO, out _direction, ref newtop, ref newleft, true))
GotMushroom();
if (newtop != 0)
Top += newtop;
if (newleft != 0)
Left += newleft;
if (!falling && newleft == 0)
direction = direction == GameDirection.Left ? GameDirection.Right : GameDirection.Left;
// away?
if (Top > World.Settings.LevelHeight)
World.MovingElements.Remove(this);
}
public override void onOver(GameEventHandler geventhandler, GameElement who, GameDirection direction)
{
base.onOver(geventhandler, who, direction);
if (got < canGet && DateTime.Now > canGetNext &&
direction == GameDirection.Bottom && who == GameElement.MGO)
{
switch (btype)
{
case BoxType.GoodMushroom: getGoodie(BoxType.GoodMushroom); break;
case BoxType.PoisonMushroom: getGoodie(BoxType.PoisonMushroom); break;
case BoxType.LiveMushroom: getGoodie(BoxType.LiveMushroom); break;
case BoxType.FireFlower: getGoodie(BoxType.FireFlower); break;
case BoxType.ModeDependent:
switch(World.MGO.Mode)
{
case MainGameObjectMode.Small:
getGoodie(BoxType.GoodMushroom); break;
case MainGameObjectMode.Normal:
case MainGameObjectMode.NormalFire:
getGoodie(BoxType.FireFlower); break;
}
break;
case BoxType.Star: getGoodie(BoxType.Star); break;
case BoxType.ImmortializeStar: getGoodie(BoxType.ImmortializeStar); break;
}
got++;
canGetNext = DateTime.Now.AddMilliseconds(200);
}
}
public GridPosDir(GridPos pos, GameDirection dir)
{
this.pos = pos;
this.dir = dir;
}
public override void onOver(GameEventHandler geventhandler, GameElement who, GameDirection direction)
{
base.onOver(geventhandler, who, direction);
if (who == GameElement.MGO)
{
if (base.Name != null && base.Name != "" && World.Script != null)
World.Script.callFunction(base.Name, "finishedLevel", geventhandler);
Dictionary<GameEventArg, object> args = new Dictionary<GameEventArg, object>();
args[GameEventArg.nextLevel] = nextLevel;
args[GameEventArg.nextLevelStartAt] = startAt;
geventhandler(GameEvent.finishedLevel, args);
}
}
public void Update(Draw d, GameDirection direction, float left, float top, int width, int height)
{
d.DrawImage(images[(int)direction, cur], left, top, width, height);
if ((DateTime.Now - last).TotalMilliseconds >= milliSecPerFrame && Refresh)
{
cur++;
last = DateTime.Now;
}
if (cur >= images.GetLength(1))
cur = 0;
}
public override bool getCrashEvent(GameObject go, GameDirection cidirection)
{
if (go is MainGameObject && cidirection == GameDirection.Top)
{
small = 2;
return true;
}
return false;
}
public static bool Within(this GameDirection input, GameDirection test)
{
return((input & test) == input);
}
public virtual void onOver(GameEventHandler geventhandler, GameElement who, GameDirection direction)
{
if (base.Name != null && base.Name != "" && World.Script != null)
World.Script.callFunction(base.Name, "onOver", geventhandler, who, direction);
}
public override void onOver(GameEventHandler geventhandler, GameElement who, GameDirection direction)
{
base.onOver(geventhandler, who, direction);
if (who == GameElement.MGO)
GotMushroom();
}
public override bool getCrashEvent(GameObject go, GameDirection cidirection)
{
return false;
}
public SnakeEventArgs(List <GameObject> segments, GameDirection direction)
{
Segments = new List <GameObject>(segments);
Direction = direction;
}
public static GameDirection RotateCCW(this GameDirection input)
{
return(GameDirectionHelper.RotateCCW(input));
}
public override void Check(out Dictionary<string, float> newpos)
{
base.Check(out newpos);
float newtop = newpos["top"];
float newleft = newpos["left"];
// falling?
bool falling = GamePhysics.Falling(World.StickyElements, World.MovingElements, World.Enemies, newtop, newleft, this);
if (falling)
newtop += Globals.ObjFalling * GameAI.FrameFactor;
if (turtleMode == TurtleMode.Small && (DateTime.Now - startSmall).Seconds >= 3)
{
TurtleMode = TurtleMode.Normal;
}
// direction
if (!falling)
{
float move = 0;
switch (turtleMode)
{
case TurtleMode.Normal: move = Globals.Turtle.Normal * GameAI.FrameFactor; break;
case TurtleMode.Small: move = 0; break;
case TurtleMode.SmallRunning: move = Globals.Turtle.Fast * GameAI.FrameFactor; break;
}
if (direction == GameDirection.Right)
newleft += move;
else
newleft -= move;
}
// check if direction is ok
GamePhysics.CrashDetection(this, World.StickyElements, World.MovingElements, getEvent, ref newtop, ref newleft);
Enemy crashedInEnemy = GamePhysics.CrashEnemy(this, World.Enemies, getEvent, ref newtop, ref newleft);
bool removedEnemy = false;
if (turtleMode == TurtleMode.SmallRunning && crashedInEnemy != null && crashedInEnemy.turtleCanRemove)
{
base.Remove(crashedInEnemy);
removedEnemy = true;
}
// run in standing mgo?
GameDirection _direction;
if (GamePhysics.SingleCrashDetection(this, World.MGO, out _direction, ref newtop, ref newleft, true) && !getCrashEvent(this, _direction))
World.MGO.getEvent(GameEvent.crashInEnemy, new Dictionary<GameEventArg, object>());
if (newtop != 0)
Top += newtop;
if (newleft != 0)
Left += newleft;
if (!falling && (newleft == 0 || (crashedInEnemy != null && !removedEnemy)))
{
if (turtleMode == TurtleMode.Normal || turtleMode == TurtleMode.SmallRunning)
direction = direction == GameDirection.Left ? GameDirection.Right : GameDirection.Left;
}
// dead?
if (Top > World.Settings.LevelHeight)
base.Remove();
}
public abstract bool getCrashEvent(GameObject go, GameDirection cidirection);
public override bool getCrashEvent(GameObject go, GameDirection cidirection)
{
if ((go is Enemy && go != this) || go is Mushroom)
return true;
if (cidirection == GameDirection.Top)
{
switch (turtleMode)
{
case TurtleMode.Normal:
TurtleMode = TurtleMode.Small;
break;
case TurtleMode.Small:
TurtleMode = TurtleMode.SmallRunning;
break;
case TurtleMode.SmallRunning:
TurtleMode = TurtleMode.Small;
break;
}
startSmall = DateTime.Now;
World.MGO.Move(MoveType.jumpTop, -1, false, GameInstruction.Nothing);
return true;
}
else if (cidirection == GameDirection.Left || cidirection == GameDirection.Right)
{
if (turtleMode == TurtleMode.Small)
{
turtleMode = TurtleMode.SmallRunning;
direction = cidirection == GameDirection.Left ? GameDirection.Right : GameDirection.Left;
return true;
}
}
return false;
}
public ActionStruct(GameAction action = GameAction.Idle, GameDirection direction = GameDirection.None)
{
this.action = action;
this.direction = direction;
}
// Update is called once per frame
void Update()
{
if (checks >= 5)
{
dm.EnablePressSpaceText();
}
if (replayMode)
{
if (replayFrameNumber < replayQueue.Count && rhythmUI.timeToBeat(Time.time) > replayQueue[replayFrameNumber].beat)
{
cluck = replayQueue[replayFrameNumber].cluck;
nextDirection = replayQueue[replayFrameNumber].nextDirection;
replayFrameNumber++;
}
}
else
{
if (cluck || nextDirection != GameDirection.none)
{
replayFrame frameData = new replayFrame();
frameData.beat = rhythmUI.timeToBeat(Time.time);
frameData.cluck = cluck;
frameData.nextDirection = nextDirection;
replayQueue.Add(frameData);
if (cluck)
{
if (Random.value < .5)
{
audio.PlayOneShot(squawk1);
}
else
{
audio.PlayOneShot(squawk2);
}
}
if (nextDirection == GameManager.GameDirection.chicken)
{
if (Random.value < .5)
{
audio.PlayOneShot(clucks1);
}
else
{
audio.PlayOneShot(clucks2);
}
}
}
}
if (datingSimMode == true)
{
dm.cluck = cluck;
cluck = false;
dm.nextDirection = nextDirection;
nextDirection = GameDirection.none;
return;
}
if (cluck)
{
Debug.Log("cluck check");
annoyedNPC = true;
questionMark.Appear();
cluck = false;
}
if (nextDirection != GameDirection.none)
{
checks++;
if (nextDirection == GameDirection.romance || nextDirection == GameDirection.chicken || annoyedNPC)
{
SwitchToDatingSimMode();
}
if (nextDirection == GameDirection.spy)
{
switch (checks)
{
case 1: //move to cubicle
spyMusic.volume = 1f;
romanceMusic.volume = 0f;
playerController.pushAction(PlayerController.Movement.action.move, 2, new Vector2(1, 3));
playerController.pushAction(PlayerController.Movement.action.crouchRight, 5);
playerController.pushAction(PlayerController.Movement.action.move, 2, new Vector2(1, 4));
playerController.pushAction(PlayerController.Movement.action.move, 2, new Vector2(2, 4));
playerController.pushAction(PlayerController.Movement.action.crouchRight, 5);
break;
case 2: // duck behind file cabinet
playerController.pushAction(PlayerController.Movement.action.move, 2, new Vector2(3, 4));
playerController.pushAction(PlayerController.Movement.action.move, 2, new Vector2(3, 3));
playerController.pushAction(PlayerController.Movement.action.move, 4, new Vector2(5, 3));
playerController.pushAction(PlayerController.Movement.action.crouchLeft, 5);
break;
case 3: // move to other cubicle
playerController.pushAction(PlayerController.Movement.action.move, 2, new Vector2(4, 3));
playerController.pushAction(PlayerController.Movement.action.move, 4, new Vector2(4, 1));
playerController.pushAction(PlayerController.Movement.action.move, 4, new Vector2(5, 1));
playerController.pushAction(PlayerController.Movement.action.crouchLeft, 5);
break;
case 4: //duck behind potted plant
playerController.pushAction(PlayerController.Movement.action.move, 6, new Vector2(2, 1));
playerController.pushAction(PlayerController.Movement.action.wait, .5f);
playerController.pushAction(PlayerController.Movement.action.move, 1, new Vector2(4, 1));
playerController.pushAction(PlayerController.Movement.action.move, .5f, new Vector2(4, 0));
playerController.pushAction(PlayerController.Movement.action.crouchLeft, 1);
break;
case 5: //move to file cabinet
playerController.pushAction(PlayerController.Movement.action.move, 2, new Vector2(4, 1));
playerController.pushAction(PlayerController.Movement.action.move, 1.5f, new Vector2(0, 1));
playerController.pushAction(PlayerController.Movement.action.crouchRight, 0);
break;
}
}
nextDirection = GameDirection.none;
}
}
public override void Check(out Dictionary<string, float> newpos)
{
base.Check(out newpos);
float newtop = newpos["top"];
float newleft = newpos["left"];
// falling?
bool falling = GamePhysics.Falling(World.StickyElements, World.MovingElements, World.Enemies, newtop, newleft, this);
if (falling)
newtop += Globals.ObjFalling * GameAI.FrameFactor;
// direction
if (!falling)
{
switch (direction)
{
case GameDirection.Left: newleft -= Globals.Gumba_X * GameAI.FrameFactor; break;
case GameDirection.Right: newleft += Globals.Gumba_X * GameAI.FrameFactor; break;
}
}
// check if direction is ok
GamePhysics.CrashDetection(this, World.StickyElements, World.MovingElements, getEvent, ref newtop, ref newleft);
Enemy crashedInEnemy = GamePhysics.CrashEnemy(this, World.Enemies, getEvent, ref newtop, ref newleft);
// run in standing mgo?
GameDirection crashInDirection;
if (GamePhysics.SingleCrashDetection(this, World.MGO, out crashInDirection, ref newtop, ref newleft, true) && !getCrashEvent(this, crashInDirection))
World.MGO.getEvent(GameEvent.crashInEnemy, new Dictionary<GameEventArg, object>());
if (newtop != 0)
Top += newtop;
if (newleft != 0)
Left += newleft;
if (!falling && newleft == 0 && direction != GameDirection.None)
{
direction = direction == GameDirection.Left ? GameDirection.Right : GameDirection.Left;
}
// dead?
if (Top > World.Settings.LevelHeight)
base.Remove();
}
public dImage CurImage(GameDirection direction)
{
return images[(int)direction, cur];
}
