public static bool WillColliderOrFall(AbstractEnemy enemy)
{
if (enemy.CurrentFaceDirection == Direction.WEST)
{
StaticCollider southWestCollider = enemy.Scene.GridCollisionChecker.GetColliderAt(GridUtil.GetLeftBelowGrid(enemy.Transform.GridCoordinates));
return(enemy.Scene.GridCollisionChecker.HasBlockingColliderAt(enemy.Transform.GridCoordinates, Direction.WEST) || southWestCollider == null || !southWestCollider.BlocksMovementFrom(Direction.SOUTH));
}
else if (enemy.CurrentFaceDirection == Direction.EAST)
{
StaticCollider southEastCollider = enemy.Scene.GridCollisionChecker.GetColliderAt(GridUtil.GetRightBelowGrid(enemy.Transform.GridCoordinates));
return(enemy.Scene.GridCollisionChecker.HasBlockingColliderAt(enemy.Transform.GridCoordinates, Direction.EAST) || southEastCollider == null || !southEastCollider.BlocksMovementFrom(Direction.SOUTH));
}
throw new Exception("Wrong CurrentFaceDirection for enemy!");
}
/// <summary>
/// Updating collision meshes and stuff<para/>
/// Поиск и обновление мешей столкновений
/// </summary>
public void Update(float delta)
{
// Search for collision data if needed
// Поиск данных о столкновениях
if (CollisionActive && !CollisionsFound)
{
CollisionFile.Group col = null;
if (CollisionManager.Collisions.ContainsKey(MainMesh.Definition.ID))
{
col = CollisionManager.Collisions[MainMesh.Definition.ID];
}
else
{
if (CollisionManager.NamedCollisions.ContainsKey(MainMesh.Definition.ModelName))
{
col = CollisionManager.NamedCollisions[MainMesh.Definition.ModelName];
}
}
if (col != null)
{
Collider = new StaticCollider(
col,
MainMesh.Coords.Position,
MainMesh.Coords.Angles,
MainMesh.Coords.Scale
);
}
CollisionsFound = true;
}
// Update collisions
// Обновление коллизий
if (Collider != null)
{
if (Collider.IsEnabled != CollisionActive)
{
if (CollisionActive)
{
Collider.Enable();
}
else
{
Collider.Disable();
}
}
}
}
public HashSet <EntityInstance> ParseLevel(AbstractScene scene, string levelID)
{
HashSet <EntityInstance> entities = new HashSet <EntityInstance>();
foreach (Engine.Source.Level.Level level in world.Levels)
{
if (!level.Identifier.Equals(levelID))
{
continue;
}
float scrollSpeedModifier = 0f;
Array.Reverse(level.LayerInstances);
foreach (LayerInstance layerInstance in level.LayerInstances)
{
foreach (EntityInstance entity in layerInstance.EntityInstances)
{
entities.Add(entity);
}
string layerName = layerInstance.Identifier;
Layer currentLayer = null;
Texture2D tileSet = null;
if (layerName.StartsWith(COLLIDERS) && layerInstance.GridTiles.Length > 0)
{
currentLayer = scene.LayerManager.EntityLayer;
tileSet = null;
//continue;
}
else if (layerName.StartsWith(BACKGROUND) && layerInstance.GridTiles.Length > 0)
{
//currentLayer = RootContainer.Instance.BackgroundLayer;
currentLayer = scene.LayerManager.CreateBackgroundLayer(int.Parse(layerName[layerName.Length - 1] + ""));
tileSet = Assets.GetTexture(GetMonoGameContentName(layerInstance.TilesetRelPath));
tileGroup = new TileGroup();
}
else if (layerName.StartsWith(PARALLAX) && layerInstance.GridTiles.Length > 0)
{
//currentLayer = RootContainer.Instance.BackgroundLayer;
scrollSpeedModifier += 0.1f;
currentLayer = scene.LayerManager.CreateParallaxLayer(int.Parse(layerName[layerName.Length - 1] + ""), scrollSpeedModifier, true);
tileSet = Assets.GetTexture(GetMonoGameContentName(layerInstance.TilesetRelPath));
tileGroup = new TileGroup();
}
else if (layerName.StartsWith(FOREGROUND) && layerInstance.GridTiles.Length > 0)
{
//currentLayer = RootContainer.Instance.BackgroundLayer;
currentLayer = scene.LayerManager.CreateForegroundLayer(int.Parse(layerName[layerName.Length - 1] + ""));
tileSet = Assets.GetTexture(GetMonoGameContentName(layerInstance.TilesetRelPath));
tileGroup = new TileGroup();
}
if (layerInstance.Identifier.StartsWith(COLLIDERS))
{
currentLayer = null;
//public Dictionary<string, dynamic>[] IntGrid { get; set; }
foreach (IntGridValueInstance grid in layerInstance.IntGrid)
{
int y = (int)Math.Floor((decimal)grid.CoordId / layerInstance.CWid);
int x = (int)(grid.CoordId - y * layerInstance.CWid);
StaticCollider e = new StaticCollider(scene, (new Vector2(x, y)));
/*Entity visual = new Entity(scene.LayerManager.EntityLayer, null, new Vector2(x, y) * Config.GRID);
* visual.AddComponent(new Sprite(visual, AssetUtil.CreateRectangle(Config.GRID, Color.White)));
* visual.Visible = true;
* visual.Active = true;*/
switch (grid.V)
{
case 0:
e.AddTag("Collider");
break;
case 1:
e.AddTag("SlideWall");
break;
case 2:
//e.AddTag("Platform");
break;
case 3:
//e.AddTag("Ladder");
//e.BlocksMovement = false;
break;
case 4:
e.AddTag("Platform");
e.AddBlockedDirection(Direction.WEST);
break;
case 5:
e.AddTag("Platform");
e.AddBlockedDirection(Direction.EAST);
break;
case 6:
e.AddTag("Platform");
e.AddBlockedDirection(Direction.NORTH);
break;
case 7:
e.AddTag("Platform");
e.AddBlockedDirection(Direction.SOUTH);
break;
}
}
}
else
{
foreach (TileInstance tile in layerInstance.GridTiles)
{
//Logger.Log("Tile: " + tile.);
//if (layerInstance.Identifier.StartsWith(PARALLAX)) { currentLayer = null; continue; }
long tileId = tile.T;
int atlasGridBaseWidth = (int)layerInstance.GridSize;
int padding = 0;
int spacing = 0;
int gridSize = Config.GRID;
int gridTileX = (int)tileId - atlasGridBaseWidth * (int)Math.Floor((decimal)(tileId / atlasGridBaseWidth));
int pixelTileX = padding + gridTileX * (gridSize + spacing);
int gridTileY = (int)Math.Floor((decimal)tileId / atlasGridBaseWidth);
var pixelTileY = padding + gridTileY * (gridSize + spacing);
/*Entity e = new Entity(currentLayer, null, new Vector2(tile.Px[0], tile.Px[1]), tileSet);
* e.SourceRectangle = new Rectangle((int)tile.Src[0], (int)tile.Src[1], gridSize, gridSize);
* e.Pivot = pivot;*/
Rectangle rect = new Rectangle((int)tile.Src[0], (int)tile.Src[1], gridSize, gridSize);
Vector2 pos = new Vector2(tile.Px[0], tile.Px[1]);
Color[] data = new Color[gridSize * gridSize];
//tileSet.GetData<Color>(data);
tileSet.GetData(0, rect, data, 0, data.Length);
if (tile.F != 0)
{
Texture2D flipped = AssetUtil.CreateRectangle(gridSize, Color.Black);
flipped.SetData(data);
if (tile.F == 1)
{
flipped = AssetUtil.FlipTexture(flipped, false, true);
}
else if (tile.F == 2)
{
flipped = AssetUtil.FlipTexture(flipped, true, false);
}
else
{
flipped = AssetUtil.FlipTexture(flipped, true, true);
}
flipped.GetData(data);
}
//public void GetData<T>(int level, int arraySlice, Rectangle? rect, T[] data, int startIndex, int elementCount) where T : struct;
tileGroup.AddColorData(data, pos);
//e.Visible = false;
//e.Active = false;
//e.Pivot = new Vector2(gridSize / 2, gridSize / 2);
}
if (currentLayer != null)
{
Entity tile = new Entity(currentLayer, null, new Vector2(0, 0));
tile.SetSprite(tileGroup.GetTexture());
tile.GetComponent <Sprite>().DrawOffset = pivot;
//tile.Pivot = pivot;
}
}
}
}
return(entities);
}
/// <summary>
/// Helper method to push out physics colliders out of all colliders of the passed in collider type
/// </summary>
/// <param name="CollisionTypeToPushOut"></param>
private void PushOutOverlappingPhysicsCollliderByCategory(CustomCollider2D.ECollisionType CollisionTypeToPushOut)
{
Vector3 ClosestCollisionOffset;
Vector3 CollisionOffset;
bool DidOverlapWithAnyCollider;
bool IsOverlapValid; //
PhysicsColliderProperties ColliderProperties;
foreach (CustomCollider2D PhysicsCollider in AllActiveCollider2DComponentsInLevel[CustomCollider2D.ECollisionType.PHYSICS])
{
ClosestCollisionOffset = Vector2.zero;
DidOverlapWithAnyCollider = false;
foreach (CustomCollider2D StaticCollider in AllActiveCollider2DComponentsInLevel[CollisionTypeToPushOut])
{
IsOverlapValid = PhysicsCollider.IsPhysicsColliderOverlapping(StaticCollider);
if (!Physics2D.GetIgnoreLayerCollision(PhysicsCollider.CollisionLayer, StaticCollider.CollisionLayer) &&
IsOverlapValid)
{
if (!DictionaryOfIntersectedColliders.ContainsKey(PhysicsCollider))
{
DictionaryOfIntersectedColliders.Add(PhysicsCollider, new PhysicsColliderProperties());
DictionaryOfIntersectedColliders[PhysicsCollider].PreviousVelocity = PhysicsCollider.AssociatedPhysicsComponent.Velocity;
}
bool ShouldPushOutVertically, ShouldPushOutHorizontally;
CollisionOffset = StaticCollider.PushOutCollider(PhysicsCollider, out ShouldPushOutVertically, out ShouldPushOutHorizontally, true);
if (!DidOverlapWithAnyCollider)
{
ClosestCollisionOffset = CollisionOffset;
DidOverlapWithAnyCollider = true;
if (ShouldPushOutHorizontally)
{
PhysicsCollider.AssociatedPhysicsComponent.Velocity.x = 0;
}
if (ShouldPushOutVertically)
{
PhysicsCollider.AssociatedPhysicsComponent.Velocity.y = 0;
}
}
else
{
Vector2 PhysicsColliderCenterPoint = PhysicsCollider.GetAssociatedBounds().CenterPoint;
if (ShouldPushOutHorizontally)
{
float OriginalClosestX = Mathf.Abs(ClosestCollisionOffset.x - PhysicsColliderCenterPoint.x);
float NewPointToCheck = Mathf.Abs(CollisionOffset.x - PhysicsColliderCenterPoint.x);
if (NewPointToCheck < OriginalClosestX)
{
ClosestCollisionOffset.x = CollisionOffset.x;
}
PhysicsCollider.AssociatedPhysicsComponent.Velocity.x = 0;
}
if (ShouldPushOutVertically)
{
float OriginalClosestY = Mathf.Abs(ClosestCollisionOffset.y - PhysicsColliderCenterPoint.y);
float NewPointYToCheck = Mathf.Abs(CollisionOffset.y - PhysicsColliderCenterPoint.y);
if (NewPointYToCheck < OriginalClosestY)
{
ClosestCollisionOffset.y = CollisionOffset.y;
}
PhysicsCollider.AssociatedPhysicsComponent.Velocity.y = 0;
}
}
ColliderProperties = DictionaryOfIntersectedColliders[PhysicsCollider];
ColliderProperties.CollidedHorizontally = ColliderProperties.CollidedHorizontally || ShouldPushOutHorizontally;
ColliderProperties.CollidedVertically = ColliderProperties.CollidedVertically || ShouldPushOutVertically;
}
}
if (DidOverlapWithAnyCollider)
{
PhysicsCollider.transform.position += ClosestCollisionOffset;
}
}
}
