public void Reset()
{
this.position = initialPosition;
sprite.PlayAnimation(idleAnimation);
waitTime = 0.0f;
direction = FaceDirection.Left;
}
//plays an animation that is on this animator and creates a coroutine that can be yielded to
public IEnumerator PlayClipYield(string clipName, float angle)
{
if (!animations.ContainsKey(clipName))
{
yield break;
}
//if same direction is already playing break out of coroutine
if (currentAni != null && currentAni.name == clipName && currentAni.isPlaying)
{
if (currentAni.getCurrentDirGroup.direction == FaceDirection.GetDirectionFromAngle(angle, currentAni.use8wayDir))
{
yield break;
}
}
//stop whatever clip was already playing
if (currentAni != null && currentAni.isPlaying && currentAni != animations[clipName])
{
currentAni.Stop();
}
currentAni = animations[clipName];
yield return(StartCoroutine(currentAni.PlayAnimationYield(angle)));
}
public MovementActionResult SetPositionOnBoard(int placementX, int placementY, FaceDirection facingDirection)
{
if (IsLocationWithinBoard(placementX, placementY))
{
_locationX = placementX;
_locationY = placementY;
_facingDirection = facingDirection;
return(new MovementActionResult(MovementStatus.RobotPlacementSuccessful));
}
else if (placementX > _tableSize - 1)
{
return(new MovementActionResult(MovementStatus.MoveXOutOfBoardMaxSize));
}
else if (placementX < 0)
{
return(new MovementActionResult(MovementStatus.MoveXOutOfBoardMinSize));
}
else if (placementY > _tableSize - 1)
{
return(new MovementActionResult(MovementStatus.MoveYOutOfBoardMaxSize));
}
else if (placementY < 0)
{
return(new MovementActionResult(MovementStatus.MoveYOutOfBoardMinSize));
}
return(new MovementActionResult(MovementStatus.MoveCannotBeDetermined));
}
public static BlockFace GenerateFace(FaceDirection direction)
{
switch (direction)
{
case FaceDirection.Front:
return(new BlockFace(F1, F2));
case FaceDirection.Back:
return(new BlockFace(BK1, BK2));
case FaceDirection.Top:
return(new BlockFace(T1, T2));
case FaceDirection.Bottom:
return(new BlockFace(B1, B2));
case FaceDirection.Left:
return(new BlockFace(L1, L2));
case FaceDirection.Right:
return(new BlockFace(R1, R2));
default:
return(default);
}
}
public FaceEmission(Color32 color, byte distance, FaceDirection faceDirection, int indexVerticesBegin)
{
this.color = color;
this.distance = distance;
this.faceDirection = faceDirection;
this.indexVerticesBegin = indexVerticesBegin;
}
//TODO : rewrite rotation
public static FaceDirection Rotate(FaceDirection face, Vector3 rotation)
{
var vector = FaceVectors[face];
var quat = Quaternion.Euler(rotation);
return(PrincipleFace(quat * vector));
}
/******
* ANGLES
*****/
//gets the proper direction based on the given angle and returns the direction group
DirectionGroup frameGroupFromAngle(float angle)
{
FaceDirection.Direction direction;
if (angle < 0)
{
direction = FaceDirection.Direction.None;
}
else
{
direction = FaceDirection.GetDirectionFromAngle(angle, use8wayDir);
}
DirectionGroup groupToPlay = null;
foreach (DirectionGroup frameGroup in frameGroups)
{
if (frameGroup.direction == direction)
{
groupToPlay = frameGroup;
break;
}
}
return(groupToPlay);
}
private int GetAdjacentVoxel(VoxelMap map, IntVector3 key, FaceDirection dir, out IntVector3 adjacentVoxel)
{
switch (dir)
{
case FaceDirection.TOP: adjacentVoxel = key.Translate(0, 1, 0); break;
case FaceDirection.BOTTOM: adjacentVoxel = key.Translate(0, -1, 0); break;
case FaceDirection.RIGHT: adjacentVoxel = key.Translate(1, 0, 0); break;
case FaceDirection.LEFT: adjacentVoxel = key.Translate(-1, 0, 0); break;
case FaceDirection.FRONT: adjacentVoxel = key.Translate(0, 0, 1); break;
case FaceDirection.BACK: adjacentVoxel = key.Translate(0, 0, -1); break;
default:
adjacentVoxel = IntVector3.ZERO;
return(0);
}
if (adjacentVoxel.x < 0 ||
adjacentVoxel.y < 0 ||
adjacentVoxel.z < 0 ||
adjacentVoxel.x >= map.Columns ||
adjacentVoxel.y >= map.Rows ||
adjacentVoxel.z >= map.Pages)
{
return(0);
}
else
{
return(VoxelMap[adjacentVoxel]);
}
}
/// <summary>
/// Paces back and forth along a platform, waiting at either end.
/// </summary>
public void Update(GameTime gameTime)
{
float elapsed = (float)gameTime.ElapsedGameTime.TotalSeconds;
// Calculate tile position based on the side we are walking towards.
float posX = Position.X + localBounds.Width / 2 * (int)direction;
int tileX = (int)Math.Floor(posX / Tile.Width) - (int)direction;
int tileY = (int)Math.Floor(Position.Y / Tile.Height);
if (waitTime > 0)
{
// Wait for some amount of time.
waitTime = Math.Max(0.0f, waitTime - (float)gameTime.ElapsedGameTime.TotalSeconds);
if (waitTime <= 0.0f)
{
// Then turn around.
direction = (FaceDirection)(-(int)direction);
}
}
else
{
// If we are about to run into a wall or off a cliff, start waiting.
if (Level.GetCollision(tileX + (int)direction, tileY - 1) == TileCollision.Impassable ||
Level.GetCollision(tileX + (int)direction, tileY) == TileCollision.Passable)
{
waitTime = MaxWaitTime;
}
else
{
// Move in the current direction.
Vector2 velocity = new Vector2((int)direction * MoveSpeed * elapsed, 0.0f);
position = position + velocity;
}
}
}
public void tick()
{
getSprites().setSprites(-1, -1);
int sprite = -1;
if (inCombat())
{
Combat.combatLoop(this);
}
if (getFollow().getFollowing() != null && !isFrozen())
{
getFollow().followEntity();
return;
}
if (minimumCoords == null || maximumCoords == null) return; //cannot process walking
if (misc.randomDouble(1) > 0.8 && walkType == WalkType.RANGE && !inCombat() && !isDead() && !isFrozen())
{
int tgtX = getLocation().getX() + misc.random(-1, 2); //random number from -1,0,1
int tgtY = getLocation().getY() + misc.random(-1, 2); //random number from -1,0,1
sprite = WalkingQueue.direction(getLocation().getX(), getLocation().getY(), tgtX, tgtY);
if(tgtX > maximumCoords.getX() || tgtX < minimumCoords.getX() || tgtY > maximumCoords.getY() || tgtY < minimumCoords.getY())
{
sprite = -1;
}
if (sprite != -1)
{
sprite >>= 1;
faceDirection = (FaceDirection)sprite;
getSprites().setSprites(sprite, -1);
setLocation(new Location(tgtX, tgtY, getLocation().getZ()));
}
return;
}
}
void MoveByInput()
{
if (Input.GetKey(KeyCode.W))
{
curState = CharacterState.Walk;
transform.Translate(Vector2.up * Time.deltaTime * MoveSpeed);
}
else if (Input.GetKey(KeyCode.A))
{
curState = CharacterState.Walk;
transform.Translate(Vector2.left * Time.deltaTime * MoveSpeed);
curDirection = FaceDirection.Left;
}
else if (Input.GetKey(KeyCode.S))
{
curState = CharacterState.Walk;
transform.Translate(Vector2.down * Time.deltaTime * MoveSpeed);
}
else if (Input.GetKey(KeyCode.D))
{
curState = CharacterState.Walk;
transform.Translate(Vector2.right * Time.deltaTime * MoveSpeed);
curDirection = FaceDirection.Right;
}
else if (Input.GetKey(KeyCode.Space))
{
curState = CharacterState.Attack;
}
else
{
curState = CharacterState.Idle;
}
}
/// <summary>
/// Generates the mesh data for a face of a cube
/// </summary>
/// <param name="dir">direction of face</param>
/// <param name="pointPos">point position of the cube</param>
public void GenerateCubeFace(FaceDirection dir, Vector3 pointPos, int cubetype)
{
int vertIndex = vertices.Count;
switch (dir)
{
case FaceDirection.xp:
vertices.AddRange(new Vector3[] { pointPos + new Vector3(0.5f, -0.5f, -0.5f),
pointPos + new Vector3(0.5f, 0.5f, -0.5f),
pointPos + new Vector3(0.5f, -0.5f, 0.5f),
pointPos + new Vector3(0.5f, 0.5f, 0.5f) });
break;
case FaceDirection.xm:
vertices.AddRange(new Vector3[] { pointPos + new Vector3(-0.5f, -0.5f, -0.5f),
pointPos + new Vector3(-0.5f, -0.5f, 0.5f),
pointPos + new Vector3(-0.5f, 0.5f, -0.5f),
pointPos + new Vector3(-0.5f, 0.5f, 0.5f) });
break;
case FaceDirection.yp:
vertices.AddRange(new Vector3[] { pointPos + new Vector3(-0.5f, 0.5f, -0.5f),
pointPos + new Vector3(-0.5f, 0.5f, 0.5f),
pointPos + new Vector3(0.5f, 0.5f, -0.5f),
pointPos + new Vector3(0.5f, 0.5f, 0.5f) });
break;
case FaceDirection.ym:
vertices.AddRange(new Vector3[] { pointPos + new Vector3(-0.5f, -0.5f, -0.5f),
pointPos + new Vector3(0.5f, -0.5f, -0.5f),
pointPos + new Vector3(-0.5f, -0.5f, 0.5f),
pointPos + new Vector3(0.5f, -0.5f, 0.5f) });
break;
case FaceDirection.zp:
vertices.AddRange(new Vector3[] { pointPos + new Vector3(-0.5f, -0.5f, 0.5f),
pointPos + new Vector3(0.5f, -0.5f, 0.5f),
pointPos + new Vector3(-0.5f, 0.5f, 0.5f),
pointPos + new Vector3(0.5f, 0.5f, 0.5f) });
break;
case FaceDirection.zm:
vertices.AddRange(new Vector3[] { pointPos + new Vector3(-0.5f, -0.5f, -0.5f),
pointPos + new Vector3(-0.5f, 0.5f, -0.5f),
pointPos + new Vector3(0.5f, -0.5f, -0.5f),
pointPos + new Vector3(0.5f, 0.5f, -0.5f) });
break;
}
triangles.AddRange(new int[] { vertIndex, vertIndex + 1, vertIndex + 2 });
triangles.AddRange(new int[] { vertIndex + 2, vertIndex + 1, vertIndex + 3 });
if (cubetype == 1)
{
colors.AddRange(Enumerable.Repeat(Color.green, 4).ToArray());
}
else if (cubetype == 2)
{
colors.AddRange(Enumerable.Repeat(Color.red, 4).ToArray());
}
}
private void UpdateSprite(EnumData.EnemyState enemyState, FaceDirection faceDirection)
{
switch (enemyType)
{
case EnumData.MonsterBreed.Cyclops:
UpdateEnemyAnimation(enemyState, faceDirection, cyclopsEnemyDisplayData);
break;
case EnumData.MonsterBreed.Centaur:
UpdateEnemyAnimation(enemyState, faceDirection, centaurEnemyDisplayData);
break;
case EnumData.MonsterBreed.Snakes:
UpdateEnemyAnimation(enemyState, faceDirection, snakeEnemyDisplayData);
break;
case EnumData.MonsterBreed.Minotaur:
UpdateEnemyAnimation(enemyState, faceDirection, minnataurEnemyDisplayData);
break;
case EnumData.MonsterBreed.ZeusHead:
UpdateEnemyAnimation(enemyState, faceDirection, zeusHeadEnemyDisplayData);
break;
case EnumData.MonsterBreed.MirrorKnight:
UpdateEnemyAnimation(enemyState, faceDirection, mirrorKnightEnemyDisplayData);
break;
}
}
public void Flip(FaceDirection newDirection)
{ /*
* //flip scale
* Vector3 theScale = mySprite.localScale;
* theScale.x *= -1;
* //mySprite.localScale= theScale;
*
* //flip location
* Vector3 newLocalPosition = mySprite.localPosition;
* newLocalPosition.x *= -1;
* mySprite.localPosition = newLocalPosition;
*/
if (newDirection == FaceDirection.RIGHT)
{
mySprite.localPosition = rightPosition;
mySprite.localScale = rightScale;
}
else if (newDirection == FaceDirection.LEFT)
{
mySprite.localPosition = leftPosition;
mySprite.localScale = leftScale;
}
else if (newDirection == FaceDirection.UP)
{
mySprite.localPosition = upPosition;
mySprite.localScale = upScale;
}
else
{
mySprite.localPosition = downPosition;
mySprite.localScale = downScale;
}
}
public static Vector2 GetVector2(this FaceDirection faceDirection)
{
var direction = Vector2.Zero;
if (faceDirection.HasFlag(FaceDirection.Up))
{
direction += new Vector2(0, -1);
}
if (faceDirection.HasFlag(FaceDirection.Down))
{
direction += new Vector2(0, 1);
}
if (faceDirection.HasFlag(FaceDirection.Left))
{
direction += new Vector2(-1, 0);
}
if (faceDirection.HasFlag(FaceDirection.Right))
{
direction += new Vector2(1, 0);
}
if (direction != Vector2.Zero)
{
direction.Normalize();
}
return(direction);
}
void UpdateEnemyAnimation(EnumData.EnemyState enemyState, FaceDirection faceDirection, EnemyDisplayData enemyDisplayData)
{
switch (enemyState)
{
case EnumData.EnemyState.Idle:
break;
case EnumData.EnemyState.Walking:
UpdateDirectionSprite(enemyDisplayData.walkSprite, faceDirection);
break;
case EnumData.EnemyState.Petrified:
currentAnimationSpriteGroup = enemyDisplayData.petrificationSprite;
break;
case EnumData.EnemyState.Pushed:
break;
case EnumData.EnemyState.PhysicsControlled:
break;
case EnumData.EnemyState.PrimaryMoveUse:
UpdateDirectionSprite(enemyDisplayData.primaryMove, faceDirection);
break;
case EnumData.EnemyState.SecondaryMoveUse:
UpdateDirectionSprite(enemyDisplayData.secondaryMove, faceDirection);
break;
}
}
void OnTriggerEnter2D(Collider2D other)
{
if (other.gameObject.CompareTag("Wall") || (gameObject.CompareTag("Player1") && other.gameObject.CompareTag("Player2")) ||
(gameObject.CompareTag("Player2") && other.gameObject.CompareTag("Player1")))
{
switch (dir)
{
case FaceDirection.Down:
dir = FaceDirection.Up;
anim.SetTrigger("UpWalk");
break;
case FaceDirection.Up:
dir = FaceDirection.Down;
anim.SetTrigger("DownWalk");
break;
case FaceDirection.Left:
dir = FaceDirection.Right;
anim.SetTrigger("RightWalk");
break;
case FaceDirection.Right:
dir = FaceDirection.Left;
anim.SetTrigger("LeftWalk");
break;
}
}
}
void EnemyMove()
{
transform.position = nextPosition;
dir = nextDir;
switch (dir)
{
case FaceDirection.Up:
anim.SetTrigger("UpWalk");
//transform.position = new Vector2(nextPosition.x, nextPosition.y + 0.1f);
break;
case FaceDirection.Down:
anim.SetTrigger("DownWalk");
//transform.position = new Vector2(nextPosition.x, nextPosition.y - 0.1f);
break;
case FaceDirection.Left:
anim.SetTrigger("LeftWalk");
//transform.position = new Vector2(nextPosition.x - 0.1f, nextPosition.y);
break;
case FaceDirection.Right:
anim.SetTrigger("RightWalk");
//transform.position = new Vector2(nextPosition.x + 0.1f, nextPosition.y);
break;
}
}
public void NotifyFaceDirection(IAttackableUnit u, Vector2 direction, bool isInstant = true, float turnTime = 0.0833f)
{
var height = _navGrid.GetHeightAtLocation(direction);
var fd = new FaceDirection(u, direction.X, direction.Y, height, isInstant, turnTime);
_packetHandlerManager.BroadcastPacketVision(u, fd, Channel.CHL_S2C);
}
/**
* Constructor accepting the origin, direction and halfScale. This
* initialises the coordinates
*/
public VoxelFace(Vector3 origin, FaceDirection dir, float halfScale)
{
this.Origin = origin;
this.Direction = dir;
InitialiseCoordinates(halfScale);
}
private void Update()
{
if (player == null)
{
player = GameObject.FindGameObjectWithTag("Player");
}
if (!mySpriteRenderer.isVisible)
{
return;
}
if (dir == FaceDirection.LEFT)
{
mySpriteRenderer.flipX = false;
}
else if (dir == FaceDirection.RIGHT)
{
mySpriteRenderer.flipX = true;
}
if (player.transform.position.x < transform.position.x)
{
dir = FaceDirection.LEFT;
}
else
{
dir = FaceDirection.RIGHT;
}
}
public override void BeginToUse(Actor actorUsing, OnUsed <Actor> onUseBegin, OnUsed <Actor> onDynamicItemUsed)
{
//Casting projectile here
this.actorUsing = actorUsing;
onUseOver = onDynamicItemUsed;
attack = actorUsing.currentAttack;
projectileTypeThrown = actorUsing.currentAttack.projectiles;
actorHadAuthority = actorUsing.hasAuthority();
gameObjectInstanceId = actorUsing.gameObject.GetInstanceID();
ownerId = actorUsing.ownerId;
//Debug.LogError("PProjectile to throw type "+projectileTypeThrown.ToString());
GameObject gToSpawn = Resources.Load(projectileTypeThrown.ToString()) as GameObject;
if (gToSpawn == null)
{
Debug.LogError("gToSpawn is null");
return;
}
liveProjectile = GridManager.InstantiateGameObject(gToSpawn).GetComponent <ProjectileUtil>();
liveProjectile.transform.position = GridManager.instance.cellToworld(actorUsing.positionToSpawnProjectile);
initPos = liveProjectile.transform.position;
finalPos = actorUsing.actorTransform.position + (liveProjectile.projectileTileTravelDistance * GridManager.instance.GetFacingDirectionOffsetVector3(actorUsing.Facing));
tileMovementDirection = actorUsing.Facing;
liveProjectile.Initialise(this);
//if (projectileTypeThrown==EnumData.Projectiles.FlamePillar)
//{
// liveProjectile.transform.position = actorUsing.actorTransform.position + GridManager.instance.GetFacingDirectionOffsetVector3(actorUsing.Facing);
// finalPos = actorUsing.actorTransform.position + GridManager.instance.GetFacingDirectionOffsetVector3(actorUsing.Facing) + (liveProjectile.projectileTileTravelDistance * GridManager.instance.GetFacingDirectionOffsetVector3(actorUsing.Facing));
//}
}
public MovementActionResult(int?x, int?y, FaceDirection facedirection, MovementStatus movementStatus)
{
LocationX = x;
LocationY = y;
Direction = facedirection;
Status = movementStatus;
}
public void SendPlayerCurrentInfo(Vector2 pos, FaceDirection dir, int player)
{
int count = 0;
switch (dir)
{
case FaceDirection.Up:
count = 0;
break;
case FaceDirection.Down:
count = 1;
break;
case FaceDirection.Left:
count = 2;
break;
case FaceDirection.Right:
count = 3;
break;
}
byte[] byteToSend = new byte[msgLen];
string posStr = ",6" + "," + player.ToString() + "," + pos.ToString() + "," + count.ToString();
byteToSend = Encoding.ASCII.GetBytes(posStr);
serverSocket.Send(byteToSend);
}
/*
* void CameraMove(string str)
* {
* if(gameObject.name == "Player1" && PlayerStatusControl_Level2._instance.isPlayer1)
* {
* camAnimator.SetTrigger(str);
* }else if(gameObject.name == "Player2" && !PlayerStatusControl_Level2._instance.isPlayer1)
* {
* camAnimator.SetTrigger(str);
* }
* }
*/
private void OnCollisionEnter2D(Collision2D other)
{
if (other.gameObject.CompareTag("Player1") || other.gameObject.CompareTag("Player2"))
{
return;
}
switch (dir)
{
case FaceDirection.Down:
dir = FaceDirection.Up;
anim.SetTrigger("UpWalk");
break;
case FaceDirection.Up:
dir = FaceDirection.Down;
anim.SetTrigger("DownWalk");
break;
case FaceDirection.Left:
dir = FaceDirection.Right;
anim.SetTrigger("RightWalk");
break;
case FaceDirection.Right:
dir = FaceDirection.Left;
anim.SetTrigger("LeftWalk");
break;
}
}
public void StartPush(Actor actorToPush, FaceDirection directionOfPush)
{
actorToPush.mapperList.Add(new OneDNonCheckingMapper(directionOfPush));
actorToPush.Facing = directionOfPush;
actorToPush.isPushed = true;
actorToPush.isHeadCollisionWithOtherActor = false;
}
public static Vector3d GetVectorPlaneFromEdx(string edx, FaceDirection dir, int location)
{
Dictionary <string, string> outputKeys = GetOutputKeys(edx);
List <double> sequenceX = outputKeys["spacing_x"].Split(',')
.ToList().ConvertAll(v => Convert.ToDouble(v));
List <double> sequenceY = outputKeys["spacing_y"].Split(',')
.ToList().ConvertAll(v => Convert.ToDouble(v));
List <double> sequenceZ = outputKeys["spacing_z"].Split(',')
.ToList().ConvertAll(v => Convert.ToDouble(v));
List <double> accumulateX = Util.Accumulate(sequenceX).ToList();
List <double> accumulateY = Util.Accumulate(sequenceY).ToList();
List <double> positionZ = Util.Accumulate(sequenceZ).ToList().Zip(sequenceZ, (a, b) => a - (b / 2)).ToList();
if (dir == FaceDirection.X)
{
return(new Vector3d(accumulateX[location], 0, 0));
}
else if (dir == FaceDirection.Y)
{
return(new Vector3d(0, accumulateY[location], 0));
}
else
{
return(new Vector3d(0, 0, positionZ[location]));
}
}
public void SendPlayerAllInfo(int player, Vector2 pos, FaceDirection dir, int fire, Vector2 firePos, float hp, int teleport)
{
int dirCount = 0;
switch (dir)
{
case FaceDirection.Up:
dirCount = 0;
break;
case FaceDirection.Down:
dirCount = 1;
break;
case FaceDirection.Left:
dirCount = 2;
break;
case FaceDirection.Right:
dirCount = 3;
break;
}
byte[] byteToSend = new byte[msgLen];
string infoStr = ",11" + "," + player.ToString() + "," + pos.ToString() + "," + dirCount.ToString() + ","
+ fire.ToString() + "," + firePos.ToString() + "," + hp.ToString() + "," + teleport.ToString();
byteToSend = Encoding.ASCII.GetBytes(infoStr);
serverSocket.Send(byteToSend);
}
public static FaceDirection FlipDirection(FaceDirection face)
{
switch (face)
{
case FaceDirection.XIncreasing:
return(FaceDirection.XDecreasing);
case FaceDirection.YIncreasing:
return(FaceDirection.YDecreasing);
case FaceDirection.ZIncreasing:
return(FaceDirection.ZDecreasing);
case FaceDirection.XDecreasing:
return(FaceDirection.XIncreasing);
case FaceDirection.YDecreasing:
return(FaceDirection.YIncreasing);
case FaceDirection.ZDecreasing:
return(FaceDirection.ZIncreasing);
case FaceDirection.None:
return(FaceDirection.None);
default:
throw new ArgumentOutOfRangeException(nameof(face), face, null);
}
}
public Actor GetTheLastActorInChain(Actor firstActor, FaceDirection directionToParseChain)
{
bool foundLastElementInChain = false;
Actor temp = firstActor;
Actor prevActor = null;
Actor nextActor = null;
while (!foundLastElementInChain)
{
prevActor = temp;
nextActor = prevActor.GetNextPetrifiedActorInDirection(directionToParseChain);
if (prevActor.gameObject.GetInstanceID() == nextActor.gameObject.GetInstanceID())
{
foundLastElementInChain = true;
}
else
{
temp = nextActor;
}
}
return(nextActor);
}
public static Vector3Int Neighbor(int x, int y, int z, FaceDirection direction)
{
switch (direction)
{
case FaceDirection.XIncreasing:
return(new Vector3Int(x + 1, y, z));
case FaceDirection.YIncreasing:
return(new Vector3Int(x, y + 1, z));
case FaceDirection.ZIncreasing:
return(new Vector3Int(x, y, z + 1));
case FaceDirection.XDecreasing:
return(new Vector3Int(x - 1, y, z));
case FaceDirection.YDecreasing:
return(new Vector3Int(x, y - 1, z));
case FaceDirection.ZDecreasing:
return(new Vector3Int(x, y, z - 1));
default:
throw new ArgumentOutOfRangeException(nameof(direction), direction, null);
}
}
public void SnapBackAfterCollision()
{
//Snapping back to previous position because of head on collision
//Debug.Log("bcurrentMovePointCellPosition " + currentMovePointCellPosition + " previousMovePointCellPosition " + previousMovePointCellPosition);
Vector3Int prevPos = previousMovePointCellPosition;
headOnCollisionCell = currentMovePointCellPosition;
previousMovePointCellPosition = currentMovePointCellPosition;
currentMovePointCellPosition = prevPos;
headOnCollisionFaceDirection = Facing;
switch (headOnCollisionFaceDirection)
{
case FaceDirection.Up:
Facing = FaceDirection.Down;
break;
case FaceDirection.Down:
Facing = FaceDirection.Up;
break;
case FaceDirection.Left:
Facing = FaceDirection.Right;
break;
case FaceDirection.Right:
Facing = FaceDirection.Left;
break;
}
//Debug.Log("acurrentMovePointCellPosition " + currentMovePointCellPosition + " previousMovePointCellPosition " + previousMovePointCellPosition);
}
public ShootingTrap(Level level, Point pos, FaceDirection dir)
{
if (dir == FaceDirection.Left)
effects = SpriteEffects.FlipHorizontally;
tex = level.Content.LoadTexture2D("Traps/Shooting");
this.pos = new Vector2(pos.X + (dir == FaceDirection.Left ? 35 : 0), pos.Y + 6);
this.level = level;
}
public Npc(int id) {
this.id = id;
npcDef = NpcData.forId(id);
skills = new NpcSkills(this);
skills.setMaxLevel(NpcSkills.SKILL.HITPOINTS, npcDef.getHitpoints()); //this must be first.
skills.setCurLevel(NpcSkills.SKILL.HITPOINTS, npcDef.getHitpoints());
this.setWalkType(WalkType.RANGE);
this.faceDirection = FaceDirection.NORTH;
this.updateFlags = new AppearanceUpdateFlags(this);
}
// public BlockFace GetFace(FaceDirection faceDirection, int textureIndex, FaceLight[] faceLights, FaceDirection[] shadedEdges, float size)
public BlockFace GetFace(FaceDirection faceDirection, int textureIndex, FaceLight[] faceLights, FaceDirection[] shadedEdges, float size)
//public BlockFace GetFace(FaceDirection faceDirection, int textureIndex, float size)
{
if (blockFaces != null)
return blockFaces [(int)faceDirection];
else
{
if (size != 0)
return new BlockFace(faceDirection, textureIndex, size);
else
return new BlockFace(faceDirection, textureIndex, faceLights, shadedEdges);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="level">The level this platform belongs to.</param>
/// <param name="position">Where the platform is in the level.</param>
/// <param name="faceDirection">The direction it is moving.</param>
/// <param name="moveSpeed">How fast it is moving.</param>
/// <param name="maxWaitTime">How long it will wait before turning around.</param>
public GlidingPlatform(Level level, Vector2 position, FaceDirection faceDirection,
float moveSpeed, float maxWaitTime, TileMovement glidermovement, string name)
{
this.level = level; //We need to know what level the platform is in.
Position = position; //We need to know its position in that level.
this.direction = faceDirection; //We need to know what direction it will be moving.
this.moveSpeed = moveSpeed; //We need to know how fast it moves.
this.maxWaitTime = maxWaitTime; //We need to know how long it waits before changing directions.
this.glidermovement = glidermovement;
this.name = name;
//Equiped with these different fields, we can create a variety of glidingPlatforms with minimal effort.
//We can create slow platforms, fast platforms, and platforms moving different directions.
LoadContent();
}
public Color32 GetColorByFaceDirection(FaceDirection faceDirection)
{
switch (faceDirection)
{
case FaceDirection.top:
return top;
case FaceDirection.back:
return side;
case FaceDirection.left:
return side;
case FaceDirection.right:
return side;
case FaceDirection.front:
return side;
case FaceDirection.bottom:
return bottom;
}
return new Color32();
}
public HIVShot(Level level, Vector2 position, double y, double x, FaceDirection fd)
{
this.level = level;
basePosition = position;
this.position = position;
if (fd == FaceDirection.Left)
{
xvelocity = -velocity;
y *= -1;
}
else
{
xvelocity = velocity;
y *= -1;
}
time = 0.0f;
angle = Math.Atan2(y, x);
LoadContent();
}
public void ChangeFacingDirection(FaceDirection direction)
{
animState = AnimationState.Turn;
_unit._facingDirection = direction;
if (direction == FaceDirection.Up)
{
_anim = backSkelAnim;
_anim.gameObject.transform.localScale = new Vector3(1, 1, 1);
frontSkelAnim.gameObject.SetActive(false);
backSkelAnim.gameObject.SetActive(true);
//print("Up");
}
else if (direction == FaceDirection.Right)
{
_anim = frontSkelAnim;
_anim.gameObject.transform.localScale = new Vector3(-1, 1, 1);
frontSkelAnim.gameObject.SetActive(true);
backSkelAnim.gameObject.SetActive(false);
// print("Right");
}
else if(direction == FaceDirection.Down)
{
_anim = frontSkelAnim;
_anim.gameObject.transform.localScale = new Vector3(1, 1, 1);
frontSkelAnim.gameObject.SetActive(true);
backSkelAnim.gameObject.SetActive(false);
// print("Down");
}
else if (direction == FaceDirection.Left)
{
_anim = backSkelAnim;
_anim.gameObject.transform.localScale = new Vector3(-1, 1, 1);
frontSkelAnim.gameObject.SetActive(false);
backSkelAnim.gameObject.SetActive(true);
// print("Left");
}
}
public void CacheFaces(bool[] faces, int textureIndex, FaceLight[][] faceLights, FaceDirection[] shadedEdges)
//public void CacheFaces(bool[] faces, int textureIndex)
{
if (faces.Length != 6)
throw new ArgumentException("faces.Length should be 6 in this order back, front, top, bottom, left, right", "faces");
if (faceLights.Length != 6)
throw new ArgumentException("faceLights.Length should be 6 in this order back, front, top, bottom, left, right", "faceLights");
blockFaces = new BlockFace[6];
count = 0;
for (int i = 0; i < 6; i++)
{
if (faces [i])
{
blockFaces [i] = new BlockFace((FaceDirection)i, textureIndex, faceLights [i], shadedEdges);
count++;
} else
blockFaces [i] = null;
}
}
public void ApplyFaceLight(FaceDirection faceDirection, FaceLight faceLight)
{
bool highQuality = false;
if (highQuality)
{
for (int i = 0; i < vertices.Length; i++)
ApplyVertexColor(i, faceLight);
} else
{
var vv = new Vector3(-0.5f, -0.5f, -0.5f) + faceLight.position;
float x = vv.x;
float y = vv.y;
float z = vv.z;
if (x < 0)
x = -x;
if (y < 0)
y = -y;
if (z < 0)
z = -z;
var d = (x + y + z) / 3;
if (d < 9)
{
float dv = d * 11;
var lightColor = faceLight.color32;
float r = dv < lightColor.r ? lightColor.r - dv : 0;
float g = dv < lightColor.g ? lightColor.g - dv : 0;
float b = dv < lightColor.b ? lightColor.b - dv : 0;
if (r > 0 || g > 0 || b > 0)
{
var vertexColor = colors32 [0];
if (r > 0)
vertexColor.r += Convert.ToByte(r);
if (g > 0)
vertexColor.g += Convert.ToByte(g);
if (b > 0)
vertexColor.b += Convert.ToByte(b);
colors32 [0] = vertexColor;
colors32 [1] = vertexColor;
colors32 [2] = vertexColor;
colors32 [3] = vertexColor;
}
}
}
}
public BlockFace(FaceDirection faceDirection, int textureIndex, float s)
{
this.faceDirection = faceDirection;
triangles = new int[]{ 0, 1, 2, 0, 2, 3 };
byte c = 32;
colors32 = new Color32[]
{
new Color32(c, c, c, 255),
new Color32(c, c, c, 255),
new Color32(c, c, c, 255),
new Color32(c, c, c, 255)
};
switch (faceDirection)
{
case FaceDirection.back:
vertices = new Vector3[]
{
new Vector3(1.0f - s, s, 1.0f - s),
new Vector3(1.0f - s, 1.0f - s, 1.0f - s),
new Vector3(s, 1.0f - s, 1.0f - s),
new Vector3(s, s, 1.0f - s)
};
normals = new Vector3[]
{
Vector3.forward,
Vector3.forward,
Vector3.forward,
Vector3.forward
};
uv = CubesUVs.cubesUVs [textureIndex].side;
break;
case FaceDirection.front:
vertices = new Vector3[]
{
new Vector3(s, s, s),
new Vector3(s, 1.0f - s, s),
new Vector3(1.0f - s, 1.0f - s, s),
new Vector3(1.0f - s, s, s)
};
normals = new Vector3[]
{
Vector3.back,
Vector3.back,
Vector3.back,
Vector3.back
};
uv = CubesUVs.cubesUVs [textureIndex].side;
break;
case FaceDirection.top:
vertices = new Vector3[]
{
new Vector3(s, 1.0f - s, s),
new Vector3(s, 1.0f - s, 1.0f - s),
new Vector3(1.0f - s, 1.0f - s, 1.0f - s),
new Vector3(1.0f - s, 1.0f - s, s)
};
normals = new Vector3[]
{
Vector3.up,
Vector3.up,
Vector3.up,
Vector3.up
};
uv = CubesUVs.cubesUVs [textureIndex].top;
break;
case FaceDirection.bottom:
vertices = new Vector3[]
{
new Vector3(1.0f - s, s, s),
new Vector3(1.0f - s, s, 1.0f - s),
new Vector3(s, s, 1.0f - s),
new Vector3(s, s, s)
};
normals = new Vector3[]
{
Vector3.down,
Vector3.down,
Vector3.down,
Vector3.down
};
uv = CubesUVs.cubesUVs [textureIndex].bottom;
break;
case FaceDirection.left:
vertices = new Vector3[]
{
new Vector3(s, s, 1.0f - s),
new Vector3(s, 1.0f - s, 1.0f - s),
new Vector3(s, 1.0f - s, s),
new Vector3(s, s, s)
};
normals = new Vector3[]
{
Vector3.left,
Vector3.left,
Vector3.left,
Vector3.left
};
uv = CubesUVs.cubesUVs [textureIndex].side;
break;
case FaceDirection.right:
vertices = new Vector3[]
{
new Vector3(1.0f - s, s, s),
new Vector3(1.0f - s, 1.0f - s, s),
new Vector3(1.0f - s, 1.0f - s, 1.0f - s),
new Vector3(1.0f - s, s, 1.0f - s)
};
normals = new Vector3[]
{
Vector3.right,
Vector3.right,
Vector3.right,
Vector3.right
};
uv = CubesUVs.cubesUVs [textureIndex].side;
break;
}
}
public void Update(GameTime gameTime)
{
float elapsed = (float)gameTime.ElapsedGameTime.TotalSeconds;
// Calculate tile position based on the side we are moving towards.
float posX = Position.X + localBounds.Width / 2 * (int)direction;
int tileX = (int)Math.Floor(posX / Tile.Width) - (int)direction;
int tileY = (int)Math.Floor(Position.Y / Tile.Height);
if (waitTime > 0)
{
// Wait for some amount of time.
waitTime = Math.Max(0.0f, waitTime - (float)gameTime.ElapsedGameTime.TotalSeconds);
if (waitTime <= 0.0f)
{
// Then turn around.
direction = (FaceDirection)(-(int)direction);
}
}
else
{
//If we're about to run into a wall that isn't a MovableTile move in other direction.
if (Level.GetCollision(tileX + (int)direction, tileY) == TileCollision.Impassable ||
Level.GetCollision(tileX + (int)direction, tileY) == TileCollision.Platform)
{
velocity = new Vector2(0.0f, 0.0f);
waitTime = MaxWaitTime;
}
else
{
// Move in the current direction.
velocity = new Vector2((int)direction * MoveSpeed * elapsed, 0.0f);
position = position + velocity;
}
}
if (level.movableTiles.Count > 0)
{
//If we're about to run into a MovableTile move in other direction.
foreach (var movableTile in level.movableTiles)
{
if (BoundingRectangle != movableTile.BoundingRectangle)
{
if (BoundingRectangle.Intersects(movableTile.BoundingRectangle))
{
direction = (FaceDirection)(-(int)direction);
velocity = new Vector2((int)direction * MoveSpeed * elapsed, 0.0f);
}
}
}
}
}
public override void handleInput(Input.InputState inputState)
{
if( currentState == State.Attacking )
return;
if (currentState == State.Neutral && (inputState.IsNewButtonPress(Buttons.A) || inputState.IsNewKeyPress(Keys.Space)))
{
currentState = State.Attacking;
attackState = AttackState.Diagonal;
velocity = Vector2.Zero;
stateTimer = 0;
return;
}
if (currentState == State.Neutral)
{
velocity = inputState.currentGamePadState.ThumbSticks.Left;
velocity.Y *= -1f;
acceleration = Vector2.Zero;
}
else
{
acceleration = inputState.currentGamePadState.ThumbSticks.Left * 0.1f;
acceleration.Y *= -1f;
return;
}
if (velocity.X < 0f && Math.Abs(velocity.X) > Math.Abs(velocity.Y) )
{
currentSourceRect = WalkingLeft;
faceDir = FaceDirection.Left;
}
else if (velocity.X > 0f && Math.Abs(velocity.X) > Math.Abs(velocity.Y))
{
currentSourceRect = WalkingRight;
faceDir = FaceDirection.Right;
}
else if (velocity.Y < 0f )
{
currentSourceRect = WalkingUp;
faceDir = FaceDirection.Up;
}
else if (velocity.Y > 0f)
{
currentSourceRect = WalkingDown;
faceDir = FaceDirection.Down;
}
if (Keyboard.GetState().GetPressedKeys().Length > 0)
{
velocity = Vector2.Zero;
if( inputState.currentKeyboardState.IsKeyDown(Keys.W) )
{
currentSourceRect = WalkingUp;
faceDir = FaceDirection.Up;
velocity.Y = -1;
}
if (inputState.currentKeyboardState.IsKeyDown(Keys.A))
{
currentSourceRect = WalkingLeft;
faceDir = FaceDirection.Left;
velocity.X = -1;
}
if (inputState.currentKeyboardState.IsKeyDown(Keys.S))
{
currentSourceRect = WalkingDown;
faceDir = FaceDirection.Down;
velocity.Y = 1;
}
if (inputState.currentKeyboardState.IsKeyDown(Keys.D))
{
currentSourceRect = WalkingRight;
faceDir = FaceDirection.Right;
velocity.X = 1;
}
if (velocity != Vector2.Zero)
velocity.Normalize();
}
//velocity.Normalize();
velocity *= maxSpeed;
animSpeed = velocity.Length() / 18f;
}
Vector2 velocity; //current veloctity of the enemy
#endregion Fields
#region Constructors
/// <summary>
/// Constructor for the Enemy class, creates a new object of type Enemy.
/// </summary>
/// <param name="level">current level object</param>
/// <param name="position">starting position of the enemy sprite</param>
/// <param name="spriteSet">string representing the enemy type to create</param>
/// <param name="enemyTextures">earray containing the enemy animation textures</param>
/// <param name="walkLeft">should the enemy walk left?</param>
public Enemy(Level level, Vector2 position, String spriteSet, Texture2D[] enemyTextures, bool walkLeft)
{
switch (spriteSet) //switch to the required enemy type and initialise it
{
case "Armour": this.enemyType = EnemyType.Armour;
armour = new Armour();
this.textureStart = armour.textureStart;
this.value = armour.value;
this.speed = armour.speed;
break;
case "Body": this.enemyType = EnemyType.Body;
body = new Body();
this.textureStart = body.textureStart;
this.value = body.value;
this.speed = body.speed;
break;
case "Robe": this.enemyType = EnemyType.Robe;
robe = new Robe();
this.textureStart = robe.textureStart;
this.value = robe.value;
this.speed = robe.speed;
break;
}
this.level = level; //initialise the level object
this.position = position; //initialise the starting position of the enemy
if (walkLeft) //if the enemy is to walk left
this.direction = FaceDirection.Left; //set directional state to left
else //if the enemy is to walk right
this.direction = FaceDirection.Right; //set directional state to right
this.enemyTextures = enemyTextures; //initialise the array of enemy textures
active = true; //enemy is currently active (i.e. running)
deactiveLimit = 0; //the enemy has been deactivated for 0 iterations
defeated = false; //enemy is not yet defeated
//load the remaining enemy content
LoadContent();
}
public void ApplyFaceLights(FaceDirection faceDirection, FaceLight[] faceLights)
{
for (int i = 0; i < faceLights.Length; i++)
ApplyFaceLight(faceDirection, faceLights [i]);
}
public override void SetFaceDirection(FaceDirection faceDirection)
{
if (faceDirection == FaceDirection.Ccw)
GL.FrontFace(FrontFaceDirection.Ccw);
else if (faceDirection == FaceDirection.Cw)
GL.FrontFace(FrontFaceDirection.Cw);
}
/// <summary>
/// Paces back and forth along a platform, waiting at either end.
/// </summary>
public void Update(GameTime gameTime)
{
float elapsed = (float)gameTime.ElapsedGameTime.TotalSeconds;
// Calculate tile position based on the side we are walking towards.
float posX = Position.X + localBounds.Width / 2 * (int)direction;
int tileX = (int)Math.Floor(posX / Tile.Width) - (int)direction;
int tileY = (int)Math.Floor(Position.Y / Tile.Height);
if (waitTime > 0)
{
// Wait for some amount of time.
waitTime = Math.Max(0.0f, waitTime - (float)gameTime.ElapsedGameTime.TotalSeconds);
if (waitTime <= 0.0f)
{
// Then turn around.
direction = (FaceDirection)(-(int)direction);
}
}
else
{
// If we are about to run into a wall or off a cliff, start waiting.
if (Level.GetCollision(tileX + (int)direction, tileY - 1) == TileCollision.Impassable ||
Level.GetCollision(tileX + (int)direction, tileY) == TileCollision.Passable)
{
waitTime = MaxWaitTime;
}
else
{
// Move in the current direction.
Vector2 velocity = new Vector2((int)direction * MoveSpeed * elapsed, 0.0f);
position = position + velocity;
}
}
}
/// <summary>
/// Gets Gad Yaakov's sprite for the specified face direction and index.
/// </summary>
/// <param name="direction">The face direction.</param>
/// <param name="index">The index.</param>
private Bitmap GetYaakovSprite(FaceDirection direction, int index)
{
if (this.FaceDirection == FaceDirection.Left)
{
switch (index)
{
case 0:
return Resources.yaakov_left0;
case 1:
return Resources.yaakov_left1;
case 2:
return Resources.yaakov_left2;
case 3:
return Resources.yaakov_left3;
case 4:
return Resources.yaakov_left4;
case 5:
return Resources.yaakov_left5;
}
}
else if (this.FaceDirection == FaceDirection.Right)
{
switch (index)
{
case 0:
return Resources.yaakov_right0;
case 1:
return Resources.yaakov_right1;
case 2:
return Resources.yaakov_right2;
case 3:
return Resources.yaakov_right3;
case 4:
return Resources.yaakov_right4;
case 5:
return Resources.yaakov_right5;
}
}
return null;
}
TiletypeShape GetRelativeTile(DFCoord2d position, FaceDirection direction)
{
DFCoord2d relativePosition = new DFCoord2d(position.x, position.y);
switch (direction)
{
case FaceDirection.North:
relativePosition.y--;
break;
case FaceDirection.South:
relativePosition.y++;
break;
case FaceDirection.East:
relativePosition.x++;
break;
case FaceDirection.West:
relativePosition.x--;
break;
}
return GetSingleTile(relativePosition);
}
public void Droped()
{
State = PowerState.Drop; sprite.PlayAnimation(dropAnimation);
// shif the position near to throwing position
direction = Level.Player.Direction;
position = Level.Player.Position - new Vector2(-(int)direction * Level.Player.BoundingRectangle.Width / 2 * 0.8f,
Level.Player.BoundingRectangle.Height * .61f);
}
void AddSideFace(DFCoord2d position, FaceDirection direction)
{
Layer topLayer = Layer.Top;
Layer bottomLayer = Layer.Base;
float currentFloorHeight = -0.5f * tileHeight;
float adjacentFloorHeight = -0.5f * tileHeight;
switch (GetSingleTile(position))
{
case TiletypeShape.WALL:
currentFloorHeight = 0.5f * tileHeight;
topLayer = Layer.Top;
break;
case TiletypeShape.RAMP:
case TiletypeShape.FLOOR:
currentFloorHeight = floorHeight - (0.5f * tileHeight);
topLayer = Layer.Floor;
break;
default:
break;
}
switch (GetRelativeTile(position, direction))
{
case TiletypeShape.WALL:
adjacentFloorHeight = 0.5f * tileHeight;
bottomLayer = Layer.Top;
break;
case TiletypeShape.FLOOR:
adjacentFloorHeight = floorHeight - (0.5f * tileHeight);
bottomLayer = Layer.Floor;
break;
default:
break;
}
if (currentFloorHeight <= adjacentFloorHeight)
return;
int startindex = finalVertices.Count;
int uvPos = 0;
switch (direction)
{
case FaceDirection.North:
finalVertices.Add(AdjustForRamps(new Vector3((position.x + 0.5f) * tileWidth, currentFloorHeight, -(position.y - 0.5f) * tileWidth), topLayer));
finalVertices.Add(AdjustForRamps(new Vector3((position.x - 0.5f) * tileWidth, currentFloorHeight, -(position.y - 0.5f) * tileWidth), topLayer));
finalVertices.Add(AdjustForRamps(new Vector3((position.x + 0.5f) * tileWidth, adjacentFloorHeight, -(position.y - 0.5f) * tileWidth), bottomLayer));
finalVertices.Add(AdjustForRamps(new Vector3((position.x - 0.5f) * tileWidth, adjacentFloorHeight, -(position.y - 0.5f) * tileWidth), bottomLayer));
uvPos = position.x;
break;
case FaceDirection.South:
finalVertices.Add(AdjustForRamps(new Vector3((position.x - 0.5f) * tileWidth, currentFloorHeight, -(position.y + 0.5f) * tileWidth), topLayer));
finalVertices.Add(AdjustForRamps(new Vector3((position.x + 0.5f) * tileWidth, currentFloorHeight, -(position.y + 0.5f) * tileWidth), topLayer));
finalVertices.Add(AdjustForRamps(new Vector3((position.x - 0.5f) * tileWidth, adjacentFloorHeight, -(position.y + 0.5f) * tileWidth), bottomLayer));
finalVertices.Add(AdjustForRamps(new Vector3((position.x + 0.5f) * tileWidth, adjacentFloorHeight, -(position.y + 0.5f) * tileWidth), bottomLayer));
uvPos = 16 - position.x;
break;
case FaceDirection.East:
finalVertices.Add(AdjustForRamps(new Vector3((position.x + 0.5f) * tileWidth, currentFloorHeight, -(position.y + 0.5f) * tileWidth), topLayer));
finalVertices.Add(AdjustForRamps(new Vector3((position.x + 0.5f) * tileWidth, currentFloorHeight, -(position.y - 0.5f) * tileWidth), topLayer));
finalVertices.Add(AdjustForRamps(new Vector3((position.x + 0.5f) * tileWidth, adjacentFloorHeight, -(position.y + 0.5f) * tileWidth), bottomLayer));
finalVertices.Add(AdjustForRamps(new Vector3((position.x + 0.5f) * tileWidth, adjacentFloorHeight, -(position.y - 0.5f) * tileWidth), bottomLayer));
uvPos = position.y;
break;
case FaceDirection.West:
finalVertices.Add(AdjustForRamps(new Vector3((position.x - 0.5f) * tileWidth, currentFloorHeight, -(position.y - 0.5f) * tileWidth), topLayer));
finalVertices.Add(AdjustForRamps(new Vector3((position.x - 0.5f) * tileWidth, currentFloorHeight, -(position.y + 0.5f) * tileWidth), topLayer));
finalVertices.Add(AdjustForRamps(new Vector3((position.x - 0.5f) * tileWidth, adjacentFloorHeight, -(position.y - 0.5f) * tileWidth), bottomLayer));
finalVertices.Add(AdjustForRamps(new Vector3((position.x - 0.5f) * tileWidth, adjacentFloorHeight, -(position.y + 0.5f) * tileWidth), bottomLayer));
uvPos = 16 - position.y;
break;
default:
break;
}
finalUVs.Add(new Vector2(-(float)(uvPos + 1) / 16.0f, -(float)(0) / 16.0f));
finalUVs.Add(new Vector2(-(float)(uvPos) / 16.0f, -(float)(0) / 16.0f));
finalUVs.Add(new Vector2(-(float)(uvPos + 1) / 16.0f, -(float)(0 + 1) / 16.0f));
finalUVs.Add(new Vector2(-(float)(uvPos) / 16.0f, -(float)(0 + 1) / 16.0f));
finalVertexColors.Add(GetColor(position));
finalVertexColors.Add(GetColor(position));
finalVertexColors.Add(GetColor(position));
finalVertexColors.Add(GetColor(position));
finalFaces.Add(startindex);
finalFaces.Add(startindex + 1);
finalFaces.Add(startindex + 2);
finalFaces.Add(startindex + 1);
finalFaces.Add(startindex + 3);
finalFaces.Add(startindex + 2);
}
/// <summary>
/// Paces back and forth along a platform, waiting at either end.
/// </summary>
public override void Update()
{
if (Manager.Level.Player.IsAlive)
{
float elapsed = (float)Manager.GameTime.ElapsedGameTime.TotalSeconds;
// Calculate tile position based on the side we are walking towards.
float posX = Position.X + localBounds.Width / 2 * (int)direction;
int tileX = (int)Math.Floor(posX / Tile.Width) - (int)direction;
int tileY = (int)Math.Floor(Position.Y / Tile.Height);
if (waitTime > 0)
{
// Wait for some amount of time.
waitTime = Math.Max(0.0f, waitTime - (float)Manager.GameTime.ElapsedGameTime.TotalSeconds);
if (waitTime <= 0.0f)
{
// Then turn around.
direction = (FaceDirection)(-(int)direction);
}
}
else
{
// If we are about to run into a wall or off a cliff, start waiting.
if (Manager.Level.GetCollision(tileX + (int)direction, tileY - 1) == TileCollision.Impassable ||
Manager.Level.GetCollision(tileX + (int)direction, tileY) == TileCollision.Passable)
{
waitTime = MaxWaitTime;
}
else
{
// Move in the current direction.
Vector2 velocity = new Vector2((int)direction * MoveSpeed * elapsed, 0.0f);
Position = Position + velocity;
}
}
// Touching an enemy instantly kills the player
if (this.BoundingRectangle.Intersects(Manager.Level.Player.BoundingRectangle))
{
Manager.Level.Player.OnKilled(this);
}
}
}
// Moves back and forth between stopper blocks waiting at either end briefly
public void Update(GameTime gameTime)
{
float elapsed = (float)gameTime.ElapsedGameTime.TotalSeconds;
if (waitTime > 0)
{
// Wait for some amount of time.
waitTime = Math.Max(0.0f, waitTime - (float)gameTime.ElapsedGameTime.TotalSeconds);
if (waitTime <= 0.0f)
{
// Then turn around.
direction = (FaceDirection)(-(int)direction);
hitStopper = false;
}
}
else
{
HandleCollisions();
if (hitStopper)
waitTime = MaxWaitTime;
else
{
// Move in the current direction.
if (moveVertical)
velocity = new Vector2(0.0f, (int)direction * currMoveSpeed * elapsed);
else
velocity = new Vector2((int)direction * currMoveSpeed * elapsed, 0.0f);
position += velocity;
if (playerContact)
{
// Move player while on the moving platform
level.Player.Position += this.velocity;
}
}
}
// If platform is out of bounds remove it from level
if (this.position.X < 0 || this.position.X > level.Width * Tile.Width || this.position.Y < 0 || this.position.Y > level.Height * Tile.Height)
this.Remove();
}
public void OnHurt(float damage)
{
if (damage == -1)
if (IsPollutant)
{ hurtTime = MaxHurtTime; return; }
else
{ direction = (FaceDirection)(-(int)direction); return; }
health -= damage;
if (health <= 0.0f) sprite.PlayAnimation(dieAnimation);
}
public HalfVector2[] GetTextureMapping(FaceDirection faceDir)
{
return BlockDictionary.Instance.GetTextureMapping(m_type, faceDir);
}
/// <summary>
/// Paces back and forth along a platform, waiting at either end.
/// </summary>
public void Update(GameTime gameTime)
{
if (!IsAlive) return;
float elapsed = (float)gameTime.ElapsedGameTime.TotalSeconds;
if (hurtTime > 0.0f) hurtTime = Math.Max(0.0f, hurtTime - elapsed);
// Calculate tile position based on the side we are walking towards.
float posX = Position.X + (orientation == Orientation.Horizontal ? BoundingCircle.Radius * (int)direction : 0);
int tileX = (int)Math.Floor(posX / Tile.Width) - (orientation == Orientation.Horizontal ? (int)direction : 0);
float posY = Position.Y + (orientation == Orientation.Vertical ? BoundingCircle.Radius * (int)direction : 0);
int tileY = (int)Math.Floor(posY / Tile.Height);
if (waitTime > 0)
{
// Wait for some amount of time.
waitTime = Math.Max(0.0f, waitTime - (float)gameTime.ElapsedGameTime.TotalSeconds);
}
else
{
// If we are about to run into a wall or off a cliff, start waiting.
TileCollision collision = Level.GetCollision(tileX + (orientation == Orientation.Horizontal ? (int)direction : 0), tileY);
if (collision == TileCollision.Impassable || collision == TileCollision.Reverse
|| collision == TileCollision.Left || collision == TileCollision.Up
|| collision == TileCollision.Right || collision == TileCollision.Down
|| collision == TileCollision.SlopeMinus || collision == TileCollision.SlopePlus)
{
waitTime = MaxWaitTime;
Orientation previousType = orientation;
if (collision == TileCollision.Up || collision == TileCollision.Down)
{
orientation = Orientation.Vertical;
direction = collision == TileCollision.Up ? FaceDirection.Down : FaceDirection.Up;
}
if (collision == TileCollision.Left || collision == TileCollision.Right)
{
orientation = Orientation.Horizontal;
direction = collision == TileCollision.Left ? FaceDirection.Right : FaceDirection.Left;
}
// Then turn around.
direction = (FaceDirection)(-(int)direction);
if (previousType != orientation) waitTime = 0.0f;
}
else
{
// Move in the current direction.
Vector2 velocity = new Vector2(orientation == Orientation.Horizontal ? (int)direction : 0.0f,
orientation == Orientation.Vertical ? (int)direction : 0.0f);
position = position + velocity * MoveSpeed * elapsed;
position = new Vector2((float)Math.Round(Position.X), (float)Math.Round(Position.Y));
}
}
}
private int IterateOnFace(FaceDirection direction, ref Vector3Int index)
{
int i1;
switch(direction)
{
case FaceDirection.XIncreasing:
case FaceDirection.XDecreasing:
i1 = index.Y;
index.Y = (i1 + 1) % SizeInBlocks;
if(index.Y < i1)
{
index.Z = (index.Z + 1) % SizeInBlocks;
}
break;
case FaceDirection.YIncreasing:
case FaceDirection.YDecreasing:
i1 = index.X;
index.X = (i1 + 1) % SizeInBlocks;
if(index.X < i1)
{
index.Z = (index.Z + 1) % SizeInBlocks;
}
break;
case FaceDirection.ZIncreasing:
case FaceDirection.ZDecreasing:
i1 = index.Y;
index.Y = (i1 + 1) % SizeInBlocks;
if(index.Y < i1)
{
index.X = (index.X + 1) % SizeInBlocks;
}
break;
}
return m_mappingFunction(index.X, index.Y, index.Z);
}
/// <summary>
/// Paces back and forth along a platform, waiting at either end.
/// </summary>
public void Update(GameTime gameTime)
{
float elapsed = (float)gameTime.ElapsedGameTime.TotalSeconds;
// Calculate tile position based on the side we are walking towards.
float posX = Position.X + localBounds.Width / 2 * (int)direction;
//in tileX = (int)Math.Floor(posX / Tile.Width) - (int)direction;
//int tileY = (int)Math.Floor(Position.Y / Tile.Height);
if (waitTime > 0)
{
// Wait for some amount of time.
waitTime = Math.Max(0.0f, waitTime - (float)gameTime.ElapsedGameTime.TotalSeconds);
if (waitTime <= 0.0f)
{
// Then turn around.
direction = (FaceDirection)(-(int)direction);
}
}
else
{
// Move in the current direction.
Vector2 velocity = new Vector2((int)direction * MoveSpeed * elapsed, 0.0f);
position = position + velocity;
}
}
public void Update(GameTime gameTime)
{
float elapsed = (float)gameTime.ElapsedGameTime.TotalSeconds;
if (!IsAlive)
return;
float posX = Position.X + localBounds.Width / 2 * (int)direction;
int tileX = (int)Math.Floor(posX / Tile.Width) - (int)direction;
int tileY = (int)Math.Floor(Position.Y / Tile.Height);
if (waitTime > 0)
{
waitTime = Math.Max(0.0f, waitTime - (float)gameTime.ElapsedGameTime.TotalSeconds);
if (waitTime <= 0.0f)
direction = (FaceDirection)(-(int)direction);
}
else
{
if (Level.GetCollision(tileX + (int)direction, tileY - 1) == TileCollision.Impassable || Level.GetCollision(tileX + (int)direction, tileY) == TileCollision.Passable)
waitTime = MaxWaitTime;
else
{
Vector2 velocity = new Vector2((int)direction * MoveSpeed * elapsed, 0.0f);
Position = Position + velocity;
}
}
}
