/// <summary>
/// Returns whether or not the NPC can pass a collision tile.
/// </summary>
/// <param name="tile"></param>
/// <returns></returns>
public bool CanPass(CollisionTile tile)
{
return(tile == CollisionTile.WALKABLE ||
tile == CollisionTile.SLIME ||
tile == CollisionTile.PLAYER_START ||
tile == CollisionTile.PLAYER_END);
}
//------------------------------------------------------------------------------------------------------------------------
// spawnCollisionTiles()
//------------------------------------------------------------------------------------------------------------------------
public void SpawnCollisionTiles(Map levelData)
{
// Check if there are layers
if (levelData.Layers == null || levelData.Layers.Length == 0)
{
return;
}
// Setting the mainlayer to the first layer
Layer mainLayer = levelData.Layers[1];
short[,] tileNumbers = mainLayer.GetTileArray();
for (int row = 0; row < mainLayer.Height; row++)
{
for (int col = 0; col < mainLayer.Width; col++)
{
int tileNumber = tileNumbers[col, row];
if (tileNumber > 0)
{
cTile = new CollisionTile(ColSpriteSheet, ColCols, ColRows);
cTile.SetFrame(tileNumber - 1);
cTile.x = col * cTile.width + cTile.width / 2;
cTile.y = row * cTile.height + cTile.height / 2;
AddChild(cTile);
}
}
}
}
public static bool IsArrowPad(CollisionTile collision)
{
return(collision == CollisionTile.UP_ARROW ||
collision == CollisionTile.RIGHT_ARROW ||
collision == CollisionTile.DOWN_ARROW ||
collision == CollisionTile.LEFT_ARROW);
}
public static bool IsWarp(CollisionTile collision)
{
return(collision == CollisionTile.RED_WARP ||
collision == CollisionTile.BLUE_WARP ||
collision == CollisionTile.GREEN_WARP ||
collision == CollisionTile.YELLOW_WARP);
}
public static bool IsTileForGayFix(CollisionTile collision)
{
return(IsArrowPad(collision) ||
collision == CollisionTile.SPRING_PAD ||
collision == CollisionTile.ICE ||
collision == CollisionTile.SUPER_SPRING ||
collision == CollisionTile.PIT);
}
public Boolean CollidesTile(Point position)
{
if (CollisionTile.Contains(position))
{
return(true);
}
return(false);
}
//------------------------------------------------------------------------------------------------------------------------
// collisionTile()
//------------------------------------------------------------------------------------------------------------------------
private void collisionTile(GameObject _other)
{
if (_other is CollisionTile)
{
CollisionTile colltile = _other as CollisionTile;
ResolveCollision(colltile);
}
}
public static bool IsCylinderUp(CollisionTile collision)
{
return(collision == CollisionTile.WHITE_CYLINDER_UP ||
collision == CollisionTile.YELLOW_CYLINDER_UP ||
collision == CollisionTile.GREEN_CYLINDER_UP ||
collision == CollisionTile.BLUE_CYLINDER_UP ||
collision == CollisionTile.BROWN_CYLINDER_UP ||
collision == CollisionTile.SILVER_CYLINDER_UP);
}
public static bool IsCylinderSwitchRight(CollisionTile collision)
{
return(collision == CollisionTile.WHITE_SWITCH_RIGHT ||
collision == CollisionTile.YELLOW_SWITCH_RIGHT ||
collision == CollisionTile.GREEN_SWITCH_RIGHT ||
collision == CollisionTile.BLUE_SWITCH_RIGHT ||
collision == CollisionTile.BROWN_SWITCH_RIGHT ||
collision == CollisionTile.SILVER_SWITCH_RIGHT);
}
public void OnCollisionEnterTile(CollisionTile collision)
{
Collider2D collider = collision.collider;
if (collider.CompareTag("Player") && collision.tile == ground)
{
Vector3Int coordinate = collision.coordinate + offset;
if (collision.tile != grass)
{
collision.tilemap.SetTile(coordinate, grass);
}
}
}
public void SwitchWorld()
{
grid = new CollisionTile[mainGame.worldManager.CurrentWorld.manager.world.worldHeight, mainGame.worldManager.CurrentWorld.manager.world.worldWidth];
// Setup tile grid.
for (int x = 0; x < grid.GetLength(0); x++)
{
for (int y = 0; y < grid.GetLength(1); y++)
{
grid[x, y] = new CollisionTile(x * CollisionTile.SIDE_LENGTH, y * CollisionTile.SIDE_LENGTH, grid);
}
}
}
/// <summary>
/// Load graphics content for the game.
/// </summary>
/// <param name="instancePreserved"></param>
public override void Activate(bool instancePreserved)
{
if (content == null)
{
content = new ContentManager(ScreenManager.Game.Services, "Content");
}
// constructs game objects
p1Board = new Board();
cpuBoard = new Board();
tile = new CollisionTile(content, 1, new Rectangle(0, 0, CollisionTile.DIM, CollisionTile.DIM));
gridFont = content.Load <SpriteFont>("gridPos");
tileGrid = new TileGrid(CollisionTile.DIM, CollisionTile.DIM, Board.DIM, Board.DIM, tile, gridFont);
for (int i = 0; i < Board.DIM; i++)
{
for (int j = 0; j < Board.DIM; j++)
{
tileGrid.SetTile(i, j, 1);
}
}
var screenManager = (ScreenManager)ScreenManager.Game.Components[0];
var audioManager = (AudioManager)ScreenManager.Game.Components[1];
var dragonDrop = (DragonDrop <IDragAndDropItem>)ScreenManager.Game.Components[2];
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = ScreenManager.SpriteBatch;
blueCircle = content.Load <Texture2D>("ob_let");
blueCross = content.Load <Texture2D>("xb_let");
redCircle = content.Load <Texture2D>("or_let");
redCross = content.Load <Texture2D>("xr_let");
// creates a fresh deck
table = new TableClassic(this, spriteBatch, dragonDrop, tileGrid, p1Board, cpuBoard, gridFont, screenManager, audioManager, 20, 30,
blueCircle, blueCross, redCircle, redCross);
table.InitializeTable();
// once the load has finished, we use ResetElapsedTime to tell the game's
// timing mechanism that we have just finished a very long frame, and that
// it should not try to catch up.
ScreenManager.Game.ResetElapsedTime();
}
//------------------------------------------------------------------------------------------------------------------------
// ResolveCollision()
//------------------------------------------------------------------------------------------------------------------------
private void ResolveCollision(CollisionTile colltile)
{
if (x + width + _velocity.x * SPEED <= colltile.x + SPEED)
{
_velocity.x = 0;
}
else if (x + _velocity.x * SPEED >= colltile.x + colltile.width - SPEED)
{
_velocity.x = 0;
}
if (y + height + _velocity.y * SPEED <= colltile.y + SPEED)
{
_velocity.y = 0;
}
else if (y + _velocity.y * SPEED >= colltile.y + height - SPEED)
{
_velocity.y = 0;
}
}
/// <summary>
/// Spawns tiles to their positions
/// </summary>
/// <param name="leveldata"> This needs a leveldata map to read out of to get the data of the tiles </param>
private void SpawnTiles(Map leveldata)
{
foreach (Layer _layer in leveldata.Layers)
{
if (leveldata.Layers == null || leveldata.Layers.Length == 0)
{
continue;
}
short[,] _tileNumbers = _layer.GetTileArray();
for (int row = 0; row < _layer.Height; row++)
{
for (int col = 0; col < _layer.Width; col++)
{
bool _isBackgroundTile = _layer.GetBoolProperty("Background");
int _tileNumber = _tileNumbers[col, row];
TileSet _tiles = leveldata.GetTileSet(_tileNumber);
string _filenameTiles = _tiles.Image.FileName;
_filenameTiles = _filenameTiles.Remove(0, 3);
if (_tileNumber > 0 && _isBackgroundTile == false)
{
CollisionTile _tile = new CollisionTile(_filenameTiles, _tiles.Columns, _tiles.Rows);
_tile.SetFrame(_tileNumber - _tiles.FirstGId);
_tile.x = col * _tile.width;
_tile.y = row * _tile.height;
AddChild(_tile);
}
else if (_tileNumber > 0 && _isBackgroundTile == true)
{
BackgroundTile _backgroundTile = new BackgroundTile(_filenameTiles, _tiles.Columns, _tiles.Rows);
_backgroundTile.SetFrame(_tileNumber - _tiles.FirstGId);
_backgroundTile.x = col * _backgroundTile.width;
_backgroundTile.y = row * _backgroundTile.height;
AddChild(_backgroundTile);
}
}
}
}
}
/// <summary>
/// Returns whether or not a collision tile should be visible to the player.
/// </summary>
/// <param name="collision"></param>
/// <returns></returns>
public static bool ShouldDrawCollision(CollisionTile collision)
{
return(collision != CollisionTile.WALKABLE &&
collision != CollisionTile.UNWALKABLE &&
collision != CollisionTile.ENEMY_NO_WALK &&
collision != CollisionTile.PLAYER_START &&
collision != CollisionTile.DIZZY_MUSHROOM_1 &&
collision != CollisionTile.DIZZY_MUSHROOM_2 &&
collision != CollisionTile.PLAYER_END &&
collision != CollisionTile.PIT &&
collision != CollisionTile.UNWALKABLE_PROJECTILE &&
collision != CollisionTile.FAKE_PIT &&
collision != CollisionTile.FLAME &&
collision != CollisionTile.NO_WALK_PIT &&
collision != CollisionTile.FIRE_DESTROY &&
collision != CollisionTile.FAKE_COLLISION &&
collision != CollisionTile.FOUNTAIN &&
collision != CollisionTile.EVIL_WALL_POSITION &&
collision != CollisionTile.EVIL_WALL_RESTART &&
!SmileyUtil.IsWarp(collision));
}
private void CreateWorld()
{
for (int x = 0; x < TileArray.GetLength(1); x++)
{
for (int y = 0; y < TileArray.GetLength(0); y++)
{
char blockType = TileArray[y, x];
if (blockType != '.')
{
Block block = null;
int unitX = x * Global.World.TileWidth;
int unitY = y * Global.World.TileHeight;
switch (blockType)
{
case 'G':
block = new CollisionTile(new Rectangle(unitX, unitY, Global.World.TileWidth, Global.World.TileHeight), "DefaultTile");
break;
case 'D':
block = new CollisionTile(new Rectangle(unitX, unitY, Global.World.TileWidth, Global.World.TileHeight), "Dirt2");
break;
case 'S':
block = new Spike(new Rectangle(unitX, unitY, Global.World.TileWidth, Global.World.TileHeight / 2), "Spike");
break;
case 'F':
block = new Flag(new Rectangle(unitX, unitY, Global.World.TileWidth, Global.World.TileHeight), "Flag");
break;
default:
break;
}
Blocks.Add(block);
}
}
}
}
private Animation GetAnimation(CollisionTile tile)
{
switch (tile)
{
case CollisionTile.SPRING_PAD:
return(Animations.Spring);
case CollisionTile.SUPER_SPRING:
return(Animations.SuperSpring);
case CollisionTile.SILVER_SWITCH_LEFT:
case CollisionTile.SILVER_SWITCH_RIGHT:
return(Animations.SilverSwitch);
case CollisionTile.BROWN_SWITCH_LEFT:
case CollisionTile.BROWN_SWITCH_RIGHT:
return(Animations.BrownSwitch);
case CollisionTile.BLUE_SWITCH_LEFT:
case CollisionTile.MIRROR_DOWN_RIGHT:
return(Animations.BlueSwitch);
case CollisionTile.GREEN_SWITCH_LEFT:
case CollisionTile.GREEN_SWITCH_RIGHT:
return(Animations.GreenSwitch);
case CollisionTile.YELLOW_SWITCH_LEFT:
case CollisionTile.YELLOW_SWITCH_RIGHT:
return(Animations.YellowSwitch);
case CollisionTile.WHITE_SWITCH_LEFT:
case CollisionTile.WHITE_SWITCH_RIGHT:
return(Animations.WhiteSwitch);
case CollisionTile.SPIN_ARROW_SWITCH:
return(Animations.BunnySwitch);
case CollisionTile.MIRROR_SWITCH:
return(Animations.MirrorSwitch);
case CollisionTile.SHRINK_TUNNEL_SWITCH:
return(Animations.ShrinkTunnelSwitch);
case CollisionTile.SILVER_CYLINDER_DOWN:
case CollisionTile.SILVER_CYLINDER_UP:
return(Animations.SilverCylinder);
case CollisionTile.BROWN_CYLINDER_DOWN:
case CollisionTile.BROWN_CYLINDER_UP:
return(Animations.BrownCylinder);
case CollisionTile.BLUE_CYLINDER_DOWN:
case CollisionTile.BLUE_CYLINDER_UP:
return(Animations.BlueCylinder);
case CollisionTile.GREEN_CYLINDER_DOWN:
case CollisionTile.GREEN_CYLINDER_UP:
return(Animations.GreenCylinder);
case CollisionTile.YELLOW_CYLINDER_DOWN:
case CollisionTile.YELLOW_CYLINDER_UP:
return(Animations.YellowCylinder);
case CollisionTile.WHITE_CYLINDER_DOWN:
case CollisionTile.WHITE_CYLINDER_UP:
return(Animations.WhiteCylinder);
case CollisionTile.SAVE_SHRINE:
return(Animations.SaveShrine);
case CollisionTile.NO_WALK_LAVA:
case CollisionTile.WALK_LAVA:
return(Animations.Lava);
case CollisionTile.SHALLOW_WATER:
case CollisionTile.DEEP_WATER:
case CollisionTile.NO_WALK_WATER:
return(Animations.Water);
case CollisionTile.GREEN_WATER:
case CollisionTile.SHALLOW_GREEN_WATER:
return(Animations.GreenWater);
default:
return(null);
}
}
public void Update(float dt)
{
CollisionTile collisionAtPlayer = SMH.Player.Tile.Collision;
SpinDirection dir = SpinDirection.None;
//Input to change ability
if (!SMH.WindowManager.IsWindowOpen)
{
if (SMH.Input.IsPressed(Input.PreviousAbility))
{
dir = SpinDirection.Left;
}
else if (SMH.Input.IsPressed(Input.NextAbility))
{
dir = SpinDirection.Right;
}
}
if (dir != SpinDirection.None)
{
if (SelectedAbility == Ability.WATER_BOOTS && SMH.Player.IsSmileyTouchingWater())
{
if (collisionAtPlayer != CollisionTile.DEEP_WATER && collisionAtPlayer != CollisionTile.GREEN_WATER)
{
//player is on a land tile, but touching water; bump him over and change abilities
ChangeAbility(dir);
SMH.Player.GraduallyMoveTo(SMH.Player.Tile.X * 64f + 32f, SMH.Player.Tile.Y * 64f + 32f, 500);
}
else
{
//player actually on a water tile; cannot take off the sandals; play error message
SMH.Sound.PlaySound(Sound.Error);
}
}
else
{
ChangeAbility(dir);
}
}
float angle, x, y, targetX, targetY;
for (int i = 0; i < 3; i++)
{
//Move towards target slot
x = _abilitySlots[i].X;
y = _abilitySlots[i].Y;
targetX = _points[_abilitySlots[i].Slot].X;
targetY = _points[_abilitySlots[i].Slot].Y;
angle = SmileyUtil.GetAngleBetween(x, y, targetX, targetY);
if (SmileyUtil.Distance(x, y, targetX, targetY) < 600.0 * dt)
{
_abilitySlots[i].X = targetX;
_abilitySlots[i].Y = targetY;
}
else
{
_abilitySlots[i].X += 600f * (float)Math.Cos(angle) * dt;
_abilitySlots[i].Y += 600f * (float)Math.Sin(angle) * dt;
}
//Move towards correct size
if (_abilitySlots[i].Slot == 1 && _abilitySlots[i].Scale < 1f)
{
_abilitySlots[i].Scale += 3f * dt;
if (_abilitySlots[i].Scale > 1f)
{
_abilitySlots[i].Scale = 1f;
}
}
else if (_abilitySlots[i].Slot != 1 && _abilitySlots[i].Scale > SmallScale)
{
_abilitySlots[i].Scale -= 3f * dt;
if (_abilitySlots[i].Scale < SmallScale)
{
_abilitySlots[i].Scale = SmallScale;
}
}
}
}
public bool CanPass(CollisionTile collision)
{
return(true);
}
public static bool IsCylinderSwitch(CollisionTile collision)
{
return(IsCylinderSwitchLeft(collision) || IsCylinderSwitchRight(collision));
}
