// Start is called before the first frame update
void Start()
{
_initialScale = transform.localScale;
_boxCollider = GetComponent <BoxCollider2D>();
if (_boxCollider == null)
{
Debug.LogError("MovementController2D requires BoxCollider2D");
}
_colliderHalfHeight = (_boxCollider.bounds.size.y / 2);
_groundLayerMask = LayerMask.NameToLayer("Ground");
if (_groundLayerMask == -1)
{
Debug.LogError("MovementController2D requires layerMask \"Ground\"");
}
// plant should appear fully grown in the selection screen
Growth = 1f;
if (UnityEngine.Random.Range(0f, 100f) < 50f)
{
_walkDirection = WalkDirection.Left;
}
else
{
_walkDirection = WalkDirection.Right;
}
_faceSpriteRender.sprite = _faceSprite_Neutral;
}
private void PickRandomWalkDirection()
{
int randomDirection = Random.Range(0, 5);
WalkDirection result = (WalkDirection)randomDirection;
this.currentWalkDirection = result;
}
public Character(System.IO.BinaryReader reader, bool sentFromServer)
: base(reader, sentFromServer)
{
myHitPoints = reader.ReadInt16();
myManaLevel = reader.ReadInt16();
ushort attribCount = reader.ReadUInt16();
for (int i = 0; i < attribCount; ++i)
{
myBaseAttributes.Add(CharAttribute.GetByID(reader.ReadUInt16()), reader.ReadByte());
}
ushort skillCount = reader.ReadUInt16();
for (int i = 0; i < skillCount; ++i)
{
myBaseSkills.Add(CharSkill.GetByID(reader.ReadUInt16()), reader.ReadByte());
}
myCurrentWalkDirection = myFacingDirection = (WalkDirection)reader.ReadByte();
if (!sentFromServer)
{
Inventory = new Inventory(this, reader);
}
}
public virtual void StartWalking(WalkDirection dir, ulong startTime, Vector2d startPos)
{
if (!IsAlive || Tools.TicksToSeconds(Map.TimeTicks - myLastCastTime) < CastAnimationDuration)
{
return;
}
myNextWalkDirection = dir;
myWalkStartTime = startTime;
myWalkStartPos = startPos;
if (dir == WalkDirection.Up || dir == WalkDirection.Down)
{
OriginX = startPos.X;
}
else
{
OriginY = startPos.Y;
}
if (IsServer)
{
System.IO.MemoryStream stream = new System.IO.MemoryStream();
stream.WriteByte((byte)myNextWalkDirection);
stream.Write(BitConverter.GetBytes(myWalkStartTime), 0, sizeof(UInt64));
stream.Write(BitConverter.GetBytes(myWalkStartPos.X), 0, sizeof(Double));
stream.Write(BitConverter.GetBytes(myWalkStartPos.Y), 0, sizeof(Double));
SendStateUpdate("StartWalking", stream);
stream.Close();
myLastWalkStateSent = Map.TimeTicks;
}
}
public void SetWalkDirectionType(WalkDirection type)
{
switch (type)
{
case WalkDirection.Up:
moveDirection += new Vector3(0, 0.2f, 0);
break;
case WalkDirection.Down:
moveDirection += new Vector3(0, -0.2f, 0);
break;
case WalkDirection.Left:
moveDirection += new Vector3(-0.2f, 0, 0);
break;
case WalkDirection.Right:
moveDirection += new Vector3(0.2f, 0, 0);
break;
case WalkDirection.None:
moveDirection += new Vector3(0, 0, 0);
break;
}
}
// Use this for initialization
void Start()
{
onGround = true;
isIdle = true;
walkDirection = WalkDirection.Right;
walkSpeed = 0.05f;
}
public bool IsInBoard(int x, int y, WalkDirection randomDirection, int stepSize)
{
switch (randomDirection)
{
case WalkDirection.None:
break;
case WalkDirection.North:
y += stepSize;
break;
case WalkDirection.South:
y -= stepSize;
break;
case WalkDirection.East:
x += stepSize;
break;
case WalkDirection.West:
x -= stepSize;
break;
}
return((x >= 0) && (x < _columns) && (y >= 0) && (y < _rows));
}
/// <summary>
/// Determines whether the bot can walk to the specified direction.
/// </summary>
/// <param name="direction">The direction.</param>
/// <returns>
/// <c>true</c> if the bot can walk to the specified direction; otherwise, <c>false</c>.
/// </returns>
public bool CanWalkTo(WalkDirection direction)
{
var cell = m_map[MyCell.Y, MyCell.X];
switch (direction)
{
case WalkDirection.Up:
return(cell.TopSide == CellSideType.Free);
case WalkDirection.Left:
return(cell.LeftSide == CellSideType.Free);
case WalkDirection.Right:
if (cell.X == m_map.GetUpperBound(1))
{
return(false);
}
return(GetMyNextCellFrom(direction).LeftSide == CellSideType.Free);
case WalkDirection.Down:
if (cell.Y == m_map.GetUpperBound(0))
{
return(false);
}
return(GetMyNextCellFrom(direction).TopSide == CellSideType.Free);
}
return(false);
}
private void UpdateAnimation(bool moving, WalkDirection direction) {
OTAnimatingSprite sprite = GetComponent<OTAnimatingSprite>();
if(isCurrentlySwinging) {
return;
}
if(moving && currentWalkDirection != direction) {
if(direction == WalkDirection.LEFT) {
sprite.PlayLoop("walkLeft");
} else {
sprite.PlayLoop("walkRight");
}
}
if(moving) {
if(!sprite.isPlaying) {
sprite.Play();
}
} else {
sprite.Pauze();
sprite.frameIndex = 1;
if (direction == WalkDirection.LEFT) {
sprite.frameIndex += 4;
}
}
if(falling) {
sprite.Pauze();
sprite.frameIndex = 0;
if (direction == WalkDirection.LEFT) {
sprite.frameIndex += 4;
}
}
}
private MazeCell GetNewAroundCell(WalkDirection direction)
{
var aroundCell = new MazeCell(m_myCell.X, m_myCell.Y);
switch (direction)
{
case WalkDirection.Down:
aroundCell.Y++;
break;
case WalkDirection.Left:
aroundCell.X--;
break;
case WalkDirection.Right:
aroundCell.X++;
break;
case WalkDirection.Up:
aroundCell.Y--;
break;
}
return(aroundCell);
}
protected void FindDirectionToTarget(Vector2 targetPosition)
{
//print ("finding direction to blockzilla");
Vector2 heading = targetPosition - (Vector2)transform.localPosition;
var dirNum = AngleDir(transform.forward, heading, transform.up);
var rotation = gameObject.transform.GetChild(0).localRotation;
//print (dirNum);
if (dirNum > 0)
{
//print ("going right");
rotation.eulerAngles = new Vector2(0, 0);
walkDirection = WalkDirection.Right;
}
else if (dirNum < 0)
{
// print ("going left");
rotation.eulerAngles = new Vector2(0, 180);
walkDirection = WalkDirection.Left;
}
//no need to get child every frame?
gameObject.transform.GetChild(0).localRotation = rotation;
}
void SetupRunAnimation()
{
NSString runKey = KeyForAnimationType(CharacterAnimation.Run);
NSString runStartKey = KeyForAnimationType(CharacterAnimation.RunStart);
NSString runStopKey = KeyForAnimationType(CharacterAnimation.RunStop);
CAAnimation runAnim = LoadAndCacheAnimation("art.scnassets/characters/explorer/run", runKey);
CAAnimation runStartAnim = LoadAndCacheAnimation("art.scnassets/characters/explorer/run_start", runStartKey);
CAAnimation runStopAnim = LoadAndCacheAnimation("art.scnassets/characters/explorer/run_stop", runStopKey);
runAnim.RepeatCount = float.MaxValue;
runStartAnim.RepeatCount = 0;
runStopAnim.RepeatCount = 0;
runAnim.FadeInDuration = 0.05f;
runAnim.FadeOutDuration = 0.05f;
runStartAnim.FadeInDuration = 0.05f;
runStartAnim.FadeOutDuration = 0.05f;
runStopAnim.FadeInDuration = 0.05f;
runStopAnim.FadeOutDuration = 0.05f;
SCNAnimationEventHandler stepLeftBlock = (animation, animatedObject, playingBackward) => {
GameSimulation.Sim.PlaySound("leftstep.caf");
};
SCNAnimationEventHandler stepRightBlock = (animation, animatedObject, playingBackward) => {
GameSimulation.Sim.PlaySound("rightstep.caf");
};
SCNAnimationEventHandler startWalkStateBlock = (animation, animatedObject, playingBackward) => {
if (InRunAnimation)
{
IsWalking = true;
}
else
{
mainSkeleton.RemoveAnimation(runKey, 0.15f);
}
};
SCNAnimationEventHandler stopWalkStateBlock = (animation, animatedObject, playingBackward) => {
IsWalking = false;
TurnOffWalkingDust();
if (changingDirection)
{
inRunAnimation = false;
InRunAnimation = true;
changingDirection = false;
playerWalkDirection = playerWalkDirection == WalkDirection.Left ? WalkDirection.Right : WalkDirection.Left;
}
};
runStopAnim.AnimationEvents = new SCNAnimationEvent[] { SCNAnimationEvent.Create(1f, stopWalkStateBlock) };
runAnim.AnimationEvents = new SCNAnimationEvent[] {
SCNAnimationEvent.Create(0.0f, startWalkStateBlock),
SCNAnimationEvent.Create(0.25f, stepRightBlock),
SCNAnimationEvent.Create(0.75f, stepLeftBlock)
};
}
//---------------------//
public void StartWalk1(WalkDirection dir = WalkDirection.Up, int duration = Config.STD_MOVETIME)
{
Task.Factory.StartNew(() =>
{
isUserStop = false;
DateTime sttime = DateTime.Now;
int ud = (dir == WalkDirection.Up || dir == WalkDirection.Left) ? -1 : 1;
string lr = (dir == WalkDirection.Left || dir == WalkDirection.Right) ? "X" : "Z";
//int lr = (dir == WalkDirection.Left) ? "X" : ((dir == WalkDirection.Right) ? "Z" : 1);
//---- pre ----//
model.HexModel.UpdateLeg(Config.LEGUP, 3, "Y", 1, 3, 5);
model.HexModel.UpdateLeg(ud * Config.GAIT_DISTANCE / 2, 3, lr, 1, 3, 5);
model.HexModel.UpdateLeg(-(ud * Config.GAIT_DISTANCE / 2), 3, lr, 2, 4, 6);
control.ExecuteOnce(new Command(model.HexModel.generate(duration)));
//Thread.Sleep(1000);
model.HexModel.UpdateLeg(-Config.LEGUP, 3, "Y", 1, 3, 5);
model.HexModel.UpdateLeg(ud * Config.GAIT_DISTANCE / 2, 3, lr, 1, 3, 5);
model.HexModel.UpdateLeg(-(ud * Config.GAIT_DISTANCE / 2), 3, lr, 2, 4, 6);
control.ExecuteOnce(new Command(model.HexModel.generate(duration)));
//Thread.Sleep(1000);
while (!isUserStop)
{
if (DateTime.Now - sttime > USRTIMEOUT)
{
return;
}
model.HexModel.UpdateLeg(Config.LEGUP, 3, "Y", 2, 4, 6);
model.HexModel.UpdateLeg(ud * Config.GAIT_DISTANCE, 3, lr, 2, 4, 6);
model.HexModel.UpdateLeg(-(ud * Config.GAIT_DISTANCE), 3, lr, 1, 3, 5);
control.ExecuteOnce(new Command(model.HexModel.generate(duration)));
//Thread.Sleep(1000);
model.HexModel.UpdateLeg(-Config.LEGUP, 3, "Y", 2, 4, 6);
model.HexModel.UpdateLeg(ud * Config.GAIT_DISTANCE, 3, lr, 2, 4, 6);
model.HexModel.UpdateLeg(-(ud * Config.GAIT_DISTANCE), 3, lr, 1, 3, 5);
control.ExecuteOnce(new Command(model.HexModel.generate(duration)));
//Thread.Sleep(1000);
model.HexModel.UpdateLeg(Config.LEGUP, 3, "Y", 1, 3, 5);
model.HexModel.UpdateLeg(ud * Config.GAIT_DISTANCE, 3, lr, 1, 3, 5);
model.HexModel.UpdateLeg(-(ud * Config.GAIT_DISTANCE), 3, lr, 2, 4, 6);
control.ExecuteOnce(new Command(model.HexModel.generate(duration)));
//Thread.Sleep(1000);
model.HexModel.UpdateLeg(-Config.LEGUP, 3, "Y", 1, 3, 5);
model.HexModel.UpdateLeg(ud * Config.GAIT_DISTANCE, 3, lr, 1, 3, 5);
model.HexModel.UpdateLeg(-(ud * Config.GAIT_DISTANCE), 3, lr, 2, 4, 6);
control.ExecuteOnce(new Command(model.HexModel.generate(duration)));
//Thread.Sleep(1000);
}
model.HexModel.UpdateLeg(Config.LEGUP, 3, "Y", 2, 4, 6);
model.HexModel.UpdateLeg(ud * Config.GAIT_DISTANCE / 2, 3, lr, 2, 4, 6);
model.HexModel.UpdateLeg(-(ud * Config.GAIT_DISTANCE / 2), 3, lr, 1, 3, 5);
control.ExecuteOnce(new Command(model.HexModel.generate(duration)));
//Thread.Sleep(1000);
model.HexModel.UpdateLeg(-Config.LEGUP, 3, "Y", 2, 4, 6);
model.HexModel.UpdateLeg(ud * Config.GAIT_DISTANCE / 2, 3, lr, 2, 4, 6);
model.HexModel.UpdateLeg(-(ud * Config.GAIT_DISTANCE / 2), 3, lr, 1, 3, 5);
control.ExecuteOnce(new Command(model.HexModel.generate(duration)));
//Thread.Sleep(1000);
});
}
public static void Send(Client client, WalkDirection direction)
{
NetworkMessage packet = new NetworkMessage();
packet.Position = 0;
packet.AddByte((byte)direction);
client.HookProxy.SendPacketToServer(packet.Data);
}
public RectangleWalkEffect(IRectangleLocator rectangleLocator, IPointLocator alignmentPointLocator,
WalkDirection direction, IPointLocator startPoint)
{
this.RectangleLocator = rectangleLocator;
this.AlignmentPointLocator = alignmentPointLocator;
this.WalkDirection = direction;
this.StartPointLocator = startPoint;
}
private WalkDirection GetInvertedDirection(WalkDirection walkDirection)
{
int index = (int)walkDirection;
index = (index + 1) % 4;
index += 1;
return((WalkDirection)index);
}
private void ReceiveCharacterMove(BinaryReader reader)
{
WalkDirection dir = (WalkDirection)reader.ReadByte();
ulong startTime = reader.ReadUInt64();
OpenTK.Vector2d startPos = new OpenTK.Vector2d(reader.ReadDouble(), reader.ReadDouble());
PlayerEntity.StartWalking(dir, startTime, startPos);
}
private void Start()
{
enemyRB = GetComponent <Rigidbody>();
player = GameObject.Find("Player");
playerFSM = GameObject.FindObjectOfType <PlayerFSM>();
dungeonCreator = GameObject.FindObjectOfType <DungeonCreator>();
direction = (WalkDirection)Random.Range(0, 4);
}
private void OnCollisionStay(Collision collision)
{
var normal = collision.contacts[0].normal;
if (normal.y <= 0)
{
// This only happens when the enemy does not collide with the player and not with the floor.
direction = (WalkDirection)((int)(direction + Random.Range(1, 4)) % 4);
}
}
public Character()
{
CollideWithEntities = true;
myCurrentWalkDirection = myFacingDirection = WalkDirection.Down;
myHitPoints = MaxHitPoints;
myManaLevel = MaxManaLevel;
Inventory = new Inventory(this, 0);
}
private KeyValuePair <MazeCell, long> GetVisitedAroundCell(WalkDirection direction)
{
var aroundCell = GetNewAroundCell(direction);
var query = from vs in m_visitedCells
where vs.Key.Equals(aroundCell)
select vs;
return(query.FirstOrDefault());
}
public PlayerCharacter(SCNNode characterNode) : base(characterNode)
{
CategoryBitMask = NodeCategory.Lava;
velocity = SCNVector3.Zero;
IsWalking = false;
changingDirection = false;
baseWalkSpeed = 0.0167f;
JumpBoost = 0.0f;
WalkSpeed = baseWalkSpeed * 2;
Jumping = false;
groundPlaneHeight = 0.0f;
playerWalkDirection = WalkDirection.Right;
cameraHelper = new SCNNode {
Position = new SCNVector3(1000f, 200f, 0f)
};
AddChildNode(cameraHelper);
CollideSphere = new SCNNode {
Position = new SCNVector3(0f, 80f, 0f)
};
SCNGeometry geo = SCNCapsule.Create(90f, 160f);
SCNPhysicsShape shape2 = SCNPhysicsShape.Create(geo, (NSDictionary)null);
CollideSphere.PhysicsBody = SCNPhysicsBody.CreateBody(SCNPhysicsBodyType.Kinematic, shape2);
CollideSphere.PhysicsBody.CollisionBitMask =
GameCollisionCategory.Banana |
GameCollisionCategory.Coin |
GameCollisionCategory.Coconut |
GameCollisionCategory.Lava;
CollideSphere.PhysicsBody.CategoryBitMask = GameCollisionCategory.Player;
AddChildNode(CollideSphere);
DustPoof = GameSimulation.LoadParticleSystemWithName("dust");
NSString artResourcePath = (NSString)GameSimulation.PathForArtResource("level/effects/effects_transparent.png");
DustPoof.ParticleImage = artResourcePath;
DustWalking = GameSimulation.LoadParticleSystemWithName("dustWalking");
DustWalking.ParticleImage = artResourcePath;
dustWalkingBirthRate = DustWalking.BirthRate;
// Load the animations and store via a lookup table.
SetupIdleAnimation();
SetupRunAnimation();
SetupJumpAnimation();
SetupBoredAnimation();
SetupHitAnimation();
PlayIdle();
}
public void SendCharacterMove(Player player, WalkDirection dir)
{
BinaryWriter writer = GetWriter();
writer.Write((byte)PacketID.CharacterMove);
writer.Write((byte)dir);
writer.Write(Map.TimeTicks);
writer.Write(player.OriginX);
writer.Write(player.OriginY);
SendPacket();
}
public void Stop()
{
if (body != null)
{
body.drag = stopDeceleration;
}
direction = WalkDirection.None;
if (animation != null)
{
StopCoroutine(animation);
}
}
private void ReverseDirectionIfAtEnd()
{
float camPosX = GameObject.FindGameObjectWithTag("MainCamera").transform.position.x;
if (_direction == WalkDirection.Left && transform.position.x < -3.5f + camPosX)
{
_direction = WalkDirection.Right;
}
else if (_direction == WalkDirection.Right && transform.position.x > 4f + camPosX)
{
_direction = WalkDirection.Left;
}
}
protected bool ReachedTarget(GameObject self, Vector2 targetDestination)
{
var dist = Vector2.Distance(self.transform.position, targetDestination);
//Find threshold such that it fits with the target
if (dist < ObjectiveRange)
{
direction = 0;
return(true);
}
return(false);
}
private void ProcessRandomWalkDirection()
{
float changeDirection = Random.RandomRange(0f, 1f);
if (changeDirection * 2 < this.directionChangeFrequency)
{
this.currentWalkDirection = WalkDirection.Idle;
}
else if (changeDirection < this.directionChangeFrequency)
{
PickRandomWalkDirection();
}
}
private void DecideLocationToMove(float chanceFactor, WalkDirection direction)
{
direction = GetInvertedDirection(direction);
if (chanceFactor <= maxFactorToPassLevel)
{
// Move to the next level!
CurrentLevel = new Level(CurrentLevel.Id + 1, (CurrentLevel.Difficulty + 1) * DifficultyFactor, direction, CurrentLevel.CurrentChamber.Entities);
}
else
{
// Generate a new chamber in the same level.
CurrentLevel.CurrentChamber = new Chamber(CurrentLevel.CurrentChamber.Id + 1, direction, CurrentLevel, CurrentLevel.CurrentChamber.Entities);
}
}
private void ProcessFollowWalkDirection()
{
float distance = Vector2.Distance(this.transform.position, Player.Get().transform.position);
if (distance > this.minimumFollowDistance)
{
ProcessRandomWalkDirection();
return;
}
if (distance < this.followStopThreshold)
{
this.currentWalkDirection = WalkDirection.Idle;
return;
}
Vector2 distances = Player.Get().transform.position - this.transform.position;
if (Mathf.Abs(distances.x) > Mathf.Abs(distances.y))
{
if (distances.x < 0)
{
this.currentWalkDirection = WalkDirection.Left;
}
else if (distances.x > 0)
{
this.currentWalkDirection = WalkDirection.Right;
}
else
{
this.currentWalkDirection = WalkDirection.Idle;
}
}
else
{
if (distances.y < 0)
{
this.currentWalkDirection = WalkDirection.Down;
}
else if (distances.y > 0)
{
this.currentWalkDirection = WalkDirection.Up;
}
else
{
this.currentWalkDirection = WalkDirection.Idle;
}
}
}
private void FixedUpdate()
{
if (Behaviour == BehaviourType.Walk && UnityEngine.Random.Range(0f, 100f) < PercChanceOfChangingWalkDirection)
{
// change direction
if (_walkDirection == WalkDirection.Right)
{
_walkDirection = WalkDirection.Left;
}
else
{
_walkDirection = WalkDirection.Right;
}
}
}
private void moveOneStep(WalkDirection dir)
{
isMoving = true;
acceptMovement = false;
switch (dir)
{
case WalkDirection.DOWN:
_gridY += 1;
break;
case WalkDirection.LEFT:
_gridX -= 1;
break;
case WalkDirection.RIGHT:
_gridX += 1;
break;
case WalkDirection.UP:
_gridY -= 1;
break;
}
currAnimation = moveStbs[dir];
walkStbs[dir].Begin();
}
private void stand(WalkDirection dir)
{
foreach (KeyValuePair<WalkDirection, Storyboard> entry in moveStbs)
{
if (entry.Value == currAnimation)
{
entry.Value.Stop();
}
}
currDir = dir;
}
private DoubleAnimation createBoxMoveAni(Box box,WalkDirection dir,double walkSpped, double by)
{
DoubleAnimation retVal = new DoubleAnimation();
Storyboard.SetTarget(retVal, box);
switch (dir)
{
case WalkDirection.DOWN:
retVal.By = scene.tileHeight;
Storyboard.SetTargetProperty(retVal, new PropertyPath("RenderTransform.(TranslateTransform.Y)"));
break;
case WalkDirection.RIGHT:
retVal.By = scene.tileWidth;
Storyboard.SetTargetProperty(retVal, new PropertyPath("RenderTransform.(TranslateTransform.X)"));
break;
case WalkDirection.LEFT:
retVal.By = -scene.tileWidth;
Storyboard.SetTargetProperty(retVal, new PropertyPath("RenderTransform.(TranslateTransform.X)"));
break;
case WalkDirection.UP:
retVal.By = -scene.tileHeight;
Storyboard.SetTargetProperty(retVal, new PropertyPath("RenderTransform.(TranslateTransform.Y)"));
break;
}
retVal.Duration = TimeSpan.FromSeconds(1 / walkSpped);
retVal.FillBehavior = FillBehavior.HoldEnd;
return retVal;
}
void SetupRunAnimation ()
{
NSString runKey = KeyForAnimationType (CharacterAnimation.Run);
NSString runStartKey = KeyForAnimationType (CharacterAnimation.RunStart);
NSString runStopKey = KeyForAnimationType (CharacterAnimation.RunStop);
CAAnimation runAnim = LoadAndCacheAnimation ("art.scnassets/characters/explorer/run", runKey);
CAAnimation runStartAnim = LoadAndCacheAnimation ("art.scnassets/characters/explorer/run_start", runStartKey);
CAAnimation runStopAnim = LoadAndCacheAnimation ("art.scnassets/characters/explorer/run_stop", runStopKey);
runAnim.RepeatCount = float.MaxValue;
runStartAnim.RepeatCount = 0;
runStopAnim.RepeatCount = 0;
runAnim.FadeInDuration = 0.05f;
runAnim.FadeOutDuration = 0.05f;
runStartAnim.FadeInDuration = 0.05f;
runStartAnim.FadeOutDuration = 0.05f;
runStopAnim.FadeInDuration = 0.05f;
runStopAnim.FadeOutDuration = 0.05f;
SCNAnimationEventHandler stepLeftBlock = (animation, animatedObject, playingBackward) => {
GameSimulation.Sim.PlaySound ("leftstep.caf");
};
SCNAnimationEventHandler stepRightBlock = (animation, animatedObject, playingBackward) => {
GameSimulation.Sim.PlaySound ("rightstep.caf");
};
SCNAnimationEventHandler startWalkStateBlock = (animation, animatedObject, playingBackward) => {
if (InRunAnimation)
IsWalking = true;
else
mainSkeleton.RemoveAnimation (runKey, 0.15f);
};
SCNAnimationEventHandler stopWalkStateBlock = (animation, animatedObject, playingBackward) => {
IsWalking = false;
TurnOffWalkingDust ();
if (changingDirection) {
inRunAnimation = false;
InRunAnimation = true;
changingDirection = false;
playerWalkDirection = playerWalkDirection == WalkDirection.Left ? WalkDirection.Right : WalkDirection.Left;
}
};
runStopAnim.AnimationEvents = new SCNAnimationEvent[] { SCNAnimationEvent.Create (1f, stopWalkStateBlock) };
runAnim.AnimationEvents = new SCNAnimationEvent[] {
SCNAnimationEvent.Create (0.0f, startWalkStateBlock),
SCNAnimationEvent.Create (0.25f, stepRightBlock),
SCNAnimationEvent.Create (0.75f, stepLeftBlock)
};
}
public PlayerCharacter (SCNNode characterNode) : base (characterNode)
{
CategoryBitMask = NodeCategory.Lava;
velocity = SCNVector3.Zero;
IsWalking = false;
changingDirection = false;
baseWalkSpeed = 0.0167f;
JumpBoost = 0.0f;
WalkSpeed = baseWalkSpeed * 2;
Jumping = false;
groundPlaneHeight = 0.0f;
playerWalkDirection = WalkDirection.Right;
cameraHelper = new SCNNode {
Position = new SCNVector3 (1000f, 200f, 0f)
};
AddChildNode (cameraHelper);
CollideSphere = new SCNNode {
Position = new SCNVector3 (0f, 80f, 0f)
};
SCNGeometry geo = SCNCapsule.Create (90f, 160f);
SCNPhysicsShape shape2 = SCNPhysicsShape.Create (geo, (NSDictionary)null);
CollideSphere.PhysicsBody = SCNPhysicsBody.CreateBody (SCNPhysicsBodyType.Kinematic, shape2);
CollideSphere.PhysicsBody.CollisionBitMask =
GameCollisionCategory.Banana |
GameCollisionCategory.Coin |
GameCollisionCategory.Coconut |
GameCollisionCategory.Lava;
CollideSphere.PhysicsBody.CategoryBitMask = GameCollisionCategory.Player;
AddChildNode (CollideSphere);
DustPoof = GameSimulation.LoadParticleSystemWithName ("dust");
NSString artResourcePath = (NSString)GameSimulation.PathForArtResource ("level/effects/effects_transparent.png");
DustPoof.ParticleImage = artResourcePath;
DustWalking = GameSimulation.LoadParticleSystemWithName ("dustWalking");
DustWalking.ParticleImage = artResourcePath;
dustWalkingBirthRate = DustWalking.BirthRate;
// Load the animations and store via a lookup table.
SetupIdleAnimation ();
SetupRunAnimation ();
SetupJumpAnimation ();
SetupBoredAnimation ();
SetupHitAnimation ();
PlayIdle ();
}
private RectAnimation createDetonateViewportAni(WalkDirection dir,int power)
{
RectAnimation retVal = new RectAnimation();
retVal.From = new Rect(0, 0, scene.tileWidth, scene.tileHeight);
switch (dir)
{
case WalkDirection.DOWN:
retVal.To = new Rect(0, power * scene.tileHeight, scene.tileWidth, scene.tileHeight);
break;
case WalkDirection.LEFT:
retVal.To = new Rect(power * -scene.tileWidth, 0, scene.tileWidth, scene.tileHeight);
break;
case WalkDirection.RIGHT:
retVal.To = new Rect(power * scene.tileWidth, 0, scene.tileWidth, scene.tileHeight);
break;
case WalkDirection.UP:
retVal.To = new Rect(0, power * -scene.tileHeight, scene.tileWidth, scene.tileHeight);
break;
}
retVal.Duration = TimeSpan.FromSeconds((double)power / detonateSpeed);
retVal.EasingFunction = new CubicEase() { EasingMode = EasingMode.EaseInOut };
Storyboard.SetTarget(retVal, detonateRects[dir]);
//detonateBrushes[dir].Viewport
Storyboard.SetTargetProperty(retVal, new PropertyPath("Fill.(ImageBrush.Viewport)"));
return retVal;
}
private void editDetonateStretchAni(WalkDirection dir, int power)
{
DoubleAnimation ani = detonateStb[dir].Children[0] as DoubleAnimation;
switch (dir)
{
case WalkDirection.DOWN:
case WalkDirection.UP:
ani.To = power * scene.tileHeight;
break;
case WalkDirection.LEFT:
case WalkDirection.RIGHT:
ani.To = power * scene.tileWidth;
break;
}
ani.Duration = TimeSpan.FromSeconds((double)power / detonateSpeed);
}
private DoubleAnimation createDetonateOffsetAni(WalkDirection dir, int power)
{
DoubleAnimation retVal = new DoubleAnimation();
switch (dir)
{
case WalkDirection.DOWN:
case WalkDirection.RIGHT:
throw new Exception("Direction DOWN and RIGHT does not need this animation");
break;
case WalkDirection.LEFT:
retVal.By = -power * scene.tileWidth;
break;
case WalkDirection.UP:
retVal.By = -power * scene.tileHeight;
break;
}
retVal.Duration = TimeSpan.FromSeconds((double)power / detonateSpeed);
retVal.FillBehavior = FillBehavior.Stop;
retVal.AutoReverse = true;
retVal.EasingFunction = new CubicEase() { EasingMode = EasingMode.EaseInOut };
Storyboard.SetTarget(retVal, detonateRects[dir]);
switch (dir)
{
case WalkDirection.UP:
Storyboard.SetTargetProperty(retVal, new PropertyPath(Canvas.TopProperty));
break;
case WalkDirection.LEFT:
Storyboard.SetTargetProperty(retVal, new PropertyPath(Canvas.LeftProperty));
break;
}
return retVal;
}
private bool validateOneStep(WalkDirection dir)
{
bool retVal = true;
Box neighborBox = null;
switch (dir)
{
case WalkDirection.DOWN:
if(gridY+1 < scene.height)
{
neighborBox = scene.boxLayer.boxOnGrid(gridX, gridY + 1);
retVal &= scene.obstacleLayer.obstacles[gridY + 1,gridX] == null;
}
else
{
return false;
}
break;
case WalkDirection.LEFT:
if (gridX - 1 >= 0)
{
neighborBox = scene.boxLayer.boxOnGrid(gridX - 1, gridY);
retVal &= scene.obstacleLayer.obstacles[gridY, gridX - 1] == null;
}
else
{
return false;
}
break;
case WalkDirection.RIGHT:
if (gridX + 1 < scene.width)
{
neighborBox = scene.boxLayer.boxOnGrid(gridX + 1, gridY);
retVal &= scene.obstacleLayer.obstacles[gridY, gridX + 1] == null;
}
else
{
return false;
}
break;
case WalkDirection.UP:
if (gridY - 1 >= 0)
{
neighborBox = scene.boxLayer.boxOnGrid(gridX, gridY - 1);
retVal &= gridY - 1 >= 0 && scene.obstacleLayer.obstacles[gridY - 1, gridX] == null;
}
else
{
return false;
}
break;
}
if (!retVal)
{
//fastern
return retVal;
}
if (neighborBox!= null)
{
retVal &= scene.boxLayer.moveBoxOne(neighborBox, dir, this);
}
return retVal;
}
private DoubleAnimation createDetonateStretchAni(WalkDirection dir, int power)
{
DoubleAnimation retVal = new DoubleAnimation();
retVal.Name = dir.ToString();
retVal.From = 0;
switch (dir)
{
case WalkDirection.DOWN:
case WalkDirection.UP:
retVal.To = power * scene.tileHeight;
break;
case WalkDirection.LEFT:
case WalkDirection.RIGHT:
retVal.To = power * scene.tileWidth;
break;
}
retVal.Duration = TimeSpan.FromSeconds((double)power / detonateSpeed);
retVal.FillBehavior = FillBehavior.Stop;
retVal.AutoReverse = true;
retVal.EasingFunction = new CubicEase() { EasingMode= EasingMode.EaseInOut};
Storyboard.SetTarget(retVal, detonateRects[dir]);
switch (dir)
{
case WalkDirection.DOWN:
case WalkDirection.UP:
Storyboard.SetTargetProperty(retVal, new PropertyPath(Shape.HeightProperty));
break;
case WalkDirection.LEFT:
case WalkDirection.RIGHT:
Storyboard.SetTargetProperty(retVal, new PropertyPath(Shape.WidthProperty));
break;
}
switch (dir)
{
case WalkDirection.DOWN:
retVal.CurrentTimeInvalidated += detonateStretchAni_TimeInvalidated;
break;
case WalkDirection.UP:
retVal.CurrentTimeInvalidated += detonateStretchAni_TimeInvalidated;
break;
case WalkDirection.LEFT:
retVal.CurrentTimeInvalidated += detonateStretchAni_TimeInvalidated;
break;
case WalkDirection.RIGHT:
retVal.CurrentTimeInvalidated += detonateStretchAni_TimeInvalidated;
break;
}
return retVal;
}
private int getActualPower(WalkDirection dir)
{
int retVal = 0;
for (int i = 0; i < owner.power; i++)
{
retVal = i;
int x = 0;
int y = 0;
switch (dir)
{
case WalkDirection.DOWN:
x = laidGridX;
y = laidGridY + i + 1;
break;
case WalkDirection.LEFT:
x = laidGridX - i - 1;
y = laidGridY;
break;
case WalkDirection.RIGHT:
x = laidGridX + i + 1;
y = laidGridY;
break;
case WalkDirection.UP:
x = laidGridX;
y = laidGridY - i - 1;
break;
}
if (x < 0 || x >= scene.width || y <0 || y >= scene.height)
{
//out of bound
break;
}
if (scene.obstacleLayer.obstacles[y, x] != null)
{
//obstacle
break;
}
if (i == owner.power - 1)
{
retVal++;
}
}
return retVal;
}
private void editDetonateOffsetAni(WalkDirection dir, int power)
{
if (dir == WalkDirection.DOWN || dir == WalkDirection.RIGHT)
{
throw new Exception("Direction DOWN and RIGHT does not need this animation");
}
DoubleAnimation ani = detonateStb[dir].Children[2] as DoubleAnimation;
switch (dir)
{
case WalkDirection.LEFT:
ani.By = -power * scene.tileWidth;
break;
case WalkDirection.UP:
ani.By = -power * scene.tileHeight;
break;
}
ani.Duration = TimeSpan.FromSeconds((double)power / detonateSpeed);
}
public RectangleWalker(IRectangleLocator rectangleLocator, WalkDirection direction)
: this(rectangleLocator, direction, null) {
}
private void editDetonateViewportAni(WalkDirection dir, int power)
{
RectAnimation ani = detonateStb[dir].Children[1] as RectAnimation;
switch (dir)
{
case WalkDirection.DOWN:
ani.To = new Rect(0, power * scene.tileHeight*10, scene.tileWidth, scene.tileHeight);
break;
case WalkDirection.LEFT:
ani.To = new Rect(power * -scene.tileWidth, 0, scene.tileWidth, scene.tileHeight);
break;
case WalkDirection.RIGHT:
ani.To = new Rect(power * scene.tileWidth, 0, scene.tileWidth, scene.tileHeight);
break;
case WalkDirection.UP:
ani.To = new Rect(0, power * -scene.tileHeight, scene.tileWidth, scene.tileHeight);
break;
}
ani.Duration = TimeSpan.FromSeconds((double)power / detonateSpeed);
}
public RectangleWalker(IRectangleLocator rectangleLocator, WalkDirection direction, IPointLocator startPointLocator) {
this.RectangleLocator = rectangleLocator;
this.Direction = direction;
this.StartPointLocator = startPointLocator;
}
public void onKick(WalkDirection dir)
{
}
public static RectangleWalkEffect Walk(IRectangleLocator rl, WalkDirection direction) {
return new RectangleWalkEffect(rl, null, direction);
}
public static RectangleWalkEffect Walk(IRectangleLocator rl, Corner start, WalkDirection direction) {
return new RectangleWalkEffect(rl, null, direction, new PointOnRectangleLocator(rl, start));
}
public bool moveBoxOne(Box box,WalkDirection dir,Player player)
{
Int32Point boxPos = boxPositions[box];
if (boxPos == null)
{
return false;
}
Int32Point newBoxPos = new Int32Point(boxPos.x, boxPos.y);
Box neighborBox = null;
switch (dir)
{
case WalkDirection.DOWN:
if (boxPos.y + 1 < boxes.GetLength(0) && scene.obstacleLayer.obstacles[boxPos.y+1,boxPos.x]==null)
{
if (boxes[boxPos.y + 1, boxPos.x] != null && boxes[boxPos.y + 1, boxPos.x].canKick)
{
neighborBox = boxes[boxPos.y + 1, boxPos.x];
}
}
else
{
return false;
}
break;
case WalkDirection.UP:
if (boxPos.y - 1 >= 0 && scene.obstacleLayer.obstacles[boxPos.y - 1, boxPos.x] == null)
{
if (boxes[boxPos.y - 1, boxPos.x] != null && boxes[boxPos.y - 1, boxPos.x].canKick)
{
neighborBox = boxes[boxPos.y - 1, boxPos.x];
}
}
else
{
return false;
}
break;
case WalkDirection.LEFT:
if (boxPos.x - 1 >= 0 && scene.obstacleLayer.obstacles[boxPos.y,boxPos.x-1]==null)
{
if (boxes[boxPos.y, boxPos.x - 1] != null && boxes[boxPos.y, boxPos.x - 1].canKick)
{
neighborBox = boxes[boxPos.y, boxPos.x - 1];
}
}
else
{
return false;
}
break;
case WalkDirection.RIGHT:
if (boxPos.x + 1 < boxes.GetLength(1) && scene.obstacleLayer.obstacles[boxPos.y,boxPos.x+1]==null)
{
if (boxes[boxPos.y, boxPos.x + 1] != null && boxes[boxPos.y, boxPos.x + 1].canKick)
{
neighborBox = boxes[boxPos.y, boxPos.x + 1];
}
}
else
{
return false;
}
break;
}
if (neighborBox != null )
{
if (!moveBoxOne(neighborBox, dir, player))
{
return false;
}
}
box.canKick = false;
DoubleAnimation ani = null;
switch (dir)
{
case WalkDirection.DOWN:
case WalkDirection.UP:
ani = createBoxMoveAni(box, dir, player.speed, scene.tileHeight);
break;
case WalkDirection.RIGHT:
case WalkDirection.LEFT:
ani = createBoxMoveAni(box, dir, player.speed, scene.tileWidth);
break;
}
Storyboard stb = new Storyboard();
stb.Children.Add(ani);
ani.Completed+=delegate(object sender,EventArgs e)
{
switch (dir)
{
case WalkDirection.DOWN:
newBoxPos.y += 1;
break;
case WalkDirection.UP:
newBoxPos.y -= 1;
break;
case WalkDirection.LEFT:
newBoxPos.x -= 1;
break;
case WalkDirection.RIGHT:
newBoxPos.x += 1;
break;
}
box.RenderTransform = new TranslateTransform(0, 0);
box.SetValue(Grid.RowProperty,newBoxPos.y);
box.SetValue(Grid.ColumnProperty, newBoxPos.x);
boxes[boxPos.y, boxPos.x] = null;
boxes[newBoxPos.y, newBoxPos.x] = box;
boxPositions[box] = newBoxPos;
box.canKick = true;
};
stb.Begin();
return true;
}
