public override void Initialize(bool addToManagers)
{
LoadStaticContent(ContentManagerName);
// Not instantiating for LayeredTileMap Map in Screens\GameScreen (Screen) because properties on the object prevent it
SolidCollisions = new FlatRedBall.TileCollisions.TileShapeCollection();
PlayerList = new FlatRedBall.Math.PositionedObjectList <MyNewGame.Entities.Player>();
PlayerList.Name = "PlayerList";
DoorList = new FlatRedBall.Math.PositionedObjectList <MyNewGame.Entities.Door>();
DoorList.Name = "DoorList";
gumIdb = new FlatRedBall.Gum.GumIdb();
// normally we wait to set variables until after the object is created, but in this case if the
// TileShapeCollection doesn't have its Visible set before creating the tiles, it can result in
// really bad performance issues, as shapes will be made visible, then invisible. Really bad perf!
if (SolidCollisions != null)
{
SolidCollisions.Visible = false;
}
FlatRedBall.TileCollisions.TileShapeCollectionLayeredTileMapExtensions.AddCollisionFromTilesWithProperty(SolidCollisions, Map, "SolidCollision");
PostInitialize();
base.Initialize(addToManagers);
if (addToManagers)
{
AddToManagers();
}
}
public override void Initialize(bool addToManagers)
{
LoadStaticContent(ContentManagerName);
Map = tiled;
SolidCollision = new FlatRedBall.TileCollisions.TileShapeCollection();
CloudCollision = new FlatRedBall.TileCollisions.TileShapeCollection();
base.Initialize(addToManagers);
}
void OnTurtleListVsSolidCollisionCollisionOccurred(Entities.Turtle first, FlatRedBall.TileCollisions.TileShapeCollection second)
{
var collisionReposition = first.AxisAlignedRectangleInstance.LastMoveCollisionReposition;
var hasCollidedWithWall = collisionReposition.X != 0;
if (hasCollidedWithWall)
{
var isWallToTheRight = collisionReposition.X < 0;
if (isWallToTheRight && first.horin == 1)
{
first.horin = -1; //LEFT
}
else if (!isWallToTheRight && first.horin == -1)
{
first.horin = 1; //RIGHT
}
}
}
public override void Initialize(bool addToManagers)
{
LoadStaticContent(ContentManagerName);
PlayerBoat = new Pirates.Entities.Boat(ContentManagerName, false);
PlayerBoat.Name = "PlayerBoat";
BoatList = new FlatRedBall.Math.PositionedObjectList <Pirates.Entities.Boat>();
BoatList.Name = "BoatList";
DockList = new FlatRedBall.Math.PositionedObjectList <Pirates.Entities.Dock>();
DockList.Name = "DockList";
PlayerInstance = new Pirates.Entities.Player(ContentManagerName, false);
PlayerInstance.Name = "PlayerInstance";
UIBoatLayer = new FlatRedBall.Graphics.Layer();
UIBoatLayer.Name = "UIBoatLayer";
SandCollision = new FlatRedBall.TileCollisions.TileShapeCollection();
SandCollision.Name = "SandCollision";
WaterCollision = new FlatRedBall.TileCollisions.TileShapeCollection();
WaterCollision.Name = "WaterCollision";
DirtCollision = new FlatRedBall.TileCollisions.TileShapeCollection();
DirtCollision.Name = "DirtCollision";
HulkCollision = new FlatRedBall.TileCollisions.TileShapeCollection();
HulkCollision.Name = "HulkCollision";
RockCollision = new FlatRedBall.TileCollisions.TileShapeCollection();
RockCollision.Name = "RockCollision";
CannonballList = new FlatRedBall.Math.PositionedObjectList <Pirates.Entities.Cannonball>();
CannonballList.Name = "CannonballList";
SpeedMeter = new Pirates.Entities.UI.SpeedMeter(ContentManagerName, false);
SpeedMeter.Name = "SpeedMeter";
ExplosionList = new FlatRedBall.Math.PositionedObjectList <Pirates.Entities.Animations.Explosion>();
ExplosionList.Name = "ExplosionList";
ButtonPistol = GameScreenGum.GetGraphicalUiElementByName("ButtonPistol") as Pirates.GumRuntimes.ButtonRuntime;
ButtonShotgun = GameScreenGum.GetGraphicalUiElementByName("ButtonShotgun") as Pirates.GumRuntimes.ButtonRuntime;
BulletList = new FlatRedBall.Math.PositionedObjectList <Pirates.Entities.Bullet>();
BulletList.Name = "BulletList";
EnemyList = new FlatRedBall.Math.PositionedObjectList <Pirates.Entities.Skeleton>();
EnemyList.Name = "EnemyList";
InventoryBar = GameScreenGum.GetGraphicalUiElementByName("InventoryBarInstance") as Pirates.GumRuntimes.InventoryForms.InventoryBarRuntime;
InventoryGui = GameScreenGum.GetGraphicalUiElementByName("InventoryGui") as Pirates.GumRuntimes.InventoryForms.InventoryGuiRuntime;
// normally we wait to set variables until after the object is created, but in this case if the
// TileShapeCollection doesn't have its Visible set before creating the tiles, it can result in
// really bad performance issues, as shapes will be made visible, then invisible. Really bad perf!
SandCollision.Visible = false;
FlatRedBall.TileCollisions.TileShapeCollectionLayeredTileMapExtensions.AddCollisionFromTilesWithType(SandCollision, Terrain, "Sand");
// normally we wait to set variables until after the object is created, but in this case if the
// TileShapeCollection doesn't have its Visible set before creating the tiles, it can result in
// really bad performance issues, as shapes will be made visible, then invisible. Really bad perf!
WaterCollision.Visible = false;
FlatRedBall.TileCollisions.TileShapeCollectionLayeredTileMapExtensions.AddCollisionFromTilesWithType(WaterCollision, Terrain, "Water");
// normally we wait to set variables until after the object is created, but in this case if the
// TileShapeCollection doesn't have its Visible set before creating the tiles, it can result in
// really bad performance issues, as shapes will be made visible, then invisible. Really bad perf!
DirtCollision.Visible = false;
FlatRedBall.TileCollisions.TileShapeCollectionLayeredTileMapExtensions.AddCollisionFromTilesWithType(DirtCollision, Terrain, "Dirt");
// normally we wait to set variables until after the object is created, but in this case if the
// TileShapeCollection doesn't have its Visible set before creating the tiles, it can result in
// really bad performance issues, as shapes will be made visible, then invisible. Really bad perf!
HulkCollision.Visible = false;
FlatRedBall.TileCollisions.TileShapeCollectionLayeredTileMapExtensions.AddCollisionFromTilesWithType(HulkCollision, Terrain, "Hulk");
// normally we wait to set variables until after the object is created, but in this case if the
// TileShapeCollection doesn't have its Visible set before creating the tiles, it can result in
// really bad performance issues, as shapes will be made visible, then invisible. Really bad perf!
RockCollision.Visible = false;
FlatRedBall.TileCollisions.TileShapeCollectionLayeredTileMapExtensions.AddCollisionFromTilesWithType(RockCollision, Terrain, "Rock");
PostInitialize();
base.Initialize(addToManagers);
if (addToManagers)
{
AddToManagers();
}
}
public bool CollideAgainst(FlatRedBall.TileCollisions.TileShapeCollection shapeCollection, FlatRedBall.Math.Geometry.AxisAlignedRectangle thisCollision, bool isCloudCollision = false)
{
return(CollideAgainst(() => shapeCollection.CollideAgainstSolid(thisCollision), isCloudCollision));
}
private bool DetermineIfHorizontalVelocityShouldBePreserved(float oldHorizontalVelocity, FlatRedBall.TileCollisions.TileShapeCollection shapeCollection,
Microsoft.Xna.Framework.Vector2 repositionVector)
{
const float maxSlope = 80; // degrees
var maxSlopeInRadians = Microsoft.Xna.Framework.MathHelper.ToRadians(maxSlope);
// The reposition is the normal of the slope, so it's the X
// That is, on a slope like this:
// \
// \
// \
// \
// \
// If the slope ^^ is nearly 90, then the X will be nearly 1. To get that, we will do the sin of the slope
var maxRepositionDirectionX = System.Math.Sin(maxSlopeInRadians);
bool collidedWithSlopeGreaterThanMax = repositionVector.Y <= 0;
if (collidedWithSlopeGreaterThanMax == false)
{
if (repositionVector.X != 0 || repositionVector.Y != 0)
{
var normalized = Microsoft.Xna.Framework.Vector2.Normalize(repositionVector);
if (normalized.X > maxRepositionDirectionX || normalized.X < -maxRepositionDirectionX)
{
collidedWithSlopeGreaterThanMax = true;
}
}
}
var shouldBePreserved = collidedWithSlopeGreaterThanMax == false;
return(shouldBePreserved);
}
public bool CollideAgainst(FlatRedBall.TileCollisions.TileShapeCollection shapeCollection, bool isCloudCollision = false)
{
var positionBefore = this.Position;
var velocityBefore = this.Velocity;
var collided = CollideAgainst(() => shapeCollection.CollideAgainstSolid(this), isCloudCollision);
if (collided)
{
currentSlope = 0;
}
var wasMovedHorizontally = this.X != positionBefore.X;
var wasSlowedByPolygons = wasMovedHorizontally && shapeCollection.LastCollisionPolygons.Count != 0;
if (wasSlowedByPolygons)
{
var repositionVector = new Microsoft.Xna.Framework.Vector2(0, 1);
foreach (var rect in this.Collision.AxisAlignedRectangles)
{
if (rect.LastMoveCollisionReposition.X != 0)
{
repositionVector = rect.LastMoveCollisionReposition;
break;
}
}
var shouldPreserve = DetermineIfHorizontalVelocityShouldBePreserved(velocityBefore.X, shapeCollection, repositionVector);
if (shouldPreserve)
{
// This was an attempt to fix snagging...
// The problem is that when a rectangle collides
// against a polygon, the point on the polygon may
// be the one that defines the reposition direction.
// This means a rectangle could be sitting on a slope
// but still have a perfectly vertical reposition. I tried
// to fix this by only getting reposition vectors from the polygon
// but that caused the platformer to hop in place in some situations.
//float maxYMap = float.NegativeInfinity;
//for (int i = 0; i < shapeCollection.LastCollisionPolygons.Count; i++)
//{
// var polygon = shapeCollection.LastCollisionPolygons[i];
// for (int j = 0; j < polygon.Points.Count; j++)
// {
// maxYMap = Math.Max(maxYMap, polygon.AbsolutePointPosition(j).Y);
// }
//}
//for(int i = 0; i < shapeCollection.LastCollisionAxisAlignedRectangles.Count; i++)
//{
// var rectangle = shapeCollection.LastCollisionAxisAlignedRectangles[i];
// maxYMap = Math.Max(maxYMap, rectangle.Y + rectangle.ScaleY);
//}
//float maxCollisionOffset = 0;
//foreach(var rectangle in this.Collision.AxisAlignedRectangles)
//{
// maxCollisionOffset = -rectangle.RelativeY + rectangle.ScaleY;
//}
//float maxYAfterReposition = maxCollisionOffset + maxYMap;
// keep the velocity and the position:
var xDifference = positionBefore.X - this.Position.X;
var tangent = new Microsoft.Xna.Framework.Vector2(repositionVector.Y, -repositionVector.X);
currentSlope = Microsoft.Xna.Framework.MathHelper.ToDegrees((float)System.Math.Atan2(tangent.Y, tangent.X));
if (DirectionFacing == HorizontalDirection.Left)
{
currentSlope *= -1;
}
var multiplier = xDifference / tangent.X;
this.Velocity.X = velocityBefore.X;
this.Position.X = positionBefore.X;
this.Position.Y += multiplier * tangent.Y;
//this.Position.Y = Math.Min(this.Position.Y, maxYAfterReposition);
this.ForceUpdateDependenciesDeep();
}
}
return(collided);
}
public override void Initialize(bool addToManagers)
{
LoadStaticContent(ContentManagerName);
// Not instantiating for FlatRedBall.TileGraphics.LayeredTileMap Map in Screens\GameScreen (Screen) because properties on the object prevent it
// Not instantiating for FlatRedBall.TileCollisions.TileShapeCollection SolidCollision in Screens\GameScreen (Screen) because properties on the object prevent it
// Not instantiating for FlatRedBall.TileCollisions.TileShapeCollection CloudCollision in Screens\GameScreen (Screen) because properties on the object prevent it
A_BrickList = new FlatRedBall.Math.PositionedObjectList <Super_Marios_Bros.Entities.A_Brick>();
A_BrickList.Name = "A_BrickList";
MarioInstance = new Super_Marios_Bros.Entities.Mario(ContentManagerName, false);
MarioInstance.Name = "MarioInstance";
Lucky_blockList = new FlatRedBall.Math.PositionedObjectList <Super_Marios_Bros.Entities.Lucky_block>();
Lucky_blockList.Name = "Lucky_blockList";
GumbaList = new FlatRedBall.Math.PositionedObjectList <Super_Marios_Bros.Entities.Gumba>();
GumbaList.Name = "GumbaList";
A_Brick_being_destroyedList = new FlatRedBall.Math.PositionedObjectList <Super_Marios_Bros.Entities.A_Brick_being_destroyed>();
A_Brick_being_destroyedList.Name = "A_Brick_being_destroyedList";
CombinedShapeCollection = new FlatRedBall.TileCollisions.TileShapeCollection();
MushroomList = new FlatRedBall.Math.PositionedObjectList <Super_Marios_Bros.Entities.Mushroom>();
MushroomList.Name = "MushroomList";
TurtleList = new FlatRedBall.Math.PositionedObjectList <Super_Marios_Bros.Entities.Turtle>();
TurtleList.Name = "TurtleList";
DeadMarioInstance = new Super_Marios_Bros.Entities.DeadMario(ContentManagerName, false);
DeadMarioInstance.Name = "DeadMarioInstance";
CoinList = new FlatRedBall.Math.PositionedObjectList <Super_Marios_Bros.Entities.Coin>();
CoinList.Name = "CoinList";
MarioInstanceVsGumbaListAxisAlignedRectangleInstance = FlatRedBall.Math.Collision.CollisionManager.Self.CreateRelationship(MarioInstance, GumbaList);
MarioInstanceVsGumbaListAxisAlignedRectangleInstance.SetSecondSubCollision(item => item.AxisAlignedRectangleInstance);
MarioInstanceVsGumbaListAxisAlignedRectangleInstance.Name = "MarioInstanceVsGumbaListAxisAlignedRectangleInstance";
MarioInstanceVsGumbaListAxisAlignedRectangleInstance.SetMoveCollision(1f, 1f);
{
var temp = new FlatRedBall.Math.Collision.DelegateCollisionRelationship <Super_Marios_Bros.Entities.Mario, FlatRedBall.TileCollisions.TileShapeCollection>(MarioInstance, SolidCollision);
var isCloud = false;
temp.CollisionFunction = (first, second) =>
{
return(first.CollideAgainst(second, isCloud));
}
;
FlatRedBall.Math.Collision.CollisionManager.Self.Relationships.Add(temp);
MarioInstanceVsSolidCollision = temp;
}
MarioInstanceVsSolidCollision.Name = "MarioInstanceVsSolidCollision";
{
var temp = new FlatRedBall.Math.Collision.DelegateSingleVsListRelationship <Super_Marios_Bros.Entities.Mario, Entities.Lucky_block>(MarioInstance, Lucky_blockList);
var isCloud = false;
temp.CollisionFunction = (first, second) =>
{
return(first.CollideAgainst(second, isCloud));
}
;
FlatRedBall.Math.Collision.CollisionManager.Self.Relationships.Add(temp);
MarioInstanceVsLucky_blockList = temp;
}
MarioInstanceVsLucky_blockList.Name = "MarioInstanceVsLucky_blockList";
GumbaListAxisAlignedRectangleInstanceVsSolidCollision = FlatRedBall.Math.Collision.CollisionManagerTileShapeCollectionExtensions.CreateTileRelationship(FlatRedBall.Math.Collision.CollisionManager.Self, GumbaList, SolidCollision);
GumbaListAxisAlignedRectangleInstanceVsSolidCollision.SetFirstSubCollision(item => item.AxisAlignedRectangleInstance);
GumbaListAxisAlignedRectangleInstanceVsSolidCollision.Name = "GumbaListAxisAlignedRectangleInstanceVsSolidCollision";
GumbaListAxisAlignedRectangleInstanceVsSolidCollision.SetMoveCollision(0f, 1f);
{
var temp = new FlatRedBall.Math.Collision.DelegateSingleVsListRelationship <Super_Marios_Bros.Entities.Mario, Entities.A_Brick>(MarioInstance, A_BrickList);
var isCloud = false;
temp.CollisionFunction = (first, second) =>
{
return(first.CollideAgainst(second, isCloud));
}
;
FlatRedBall.Math.Collision.CollisionManager.Self.Relationships.Add(temp);
MarioInstanceVsA_BrickList = temp;
}
MarioInstanceVsA_BrickList.Name = "MarioInstanceVsA_BrickList";
MarioInstanceAxisAlignedRectangleInstanceVsGumbaListLeftMarioDead = FlatRedBall.Math.Collision.CollisionManager.Self.CreateRelationship(MarioInstance, GumbaList);
MarioInstanceAxisAlignedRectangleInstanceVsGumbaListLeftMarioDead.SetFirstSubCollision(item => item.AxisAlignedRectangleInstance);
MarioInstanceAxisAlignedRectangleInstanceVsGumbaListLeftMarioDead.SetSecondSubCollision(item => item.LeftMarioDead);
MarioInstanceAxisAlignedRectangleInstanceVsGumbaListLeftMarioDead.Name = "MarioInstanceAxisAlignedRectangleInstanceVsGumbaListLeftMarioDead";
MarioInstanceAxisAlignedRectangleInstanceVsGumbaListRightMarioDead = FlatRedBall.Math.Collision.CollisionManager.Self.CreateRelationship(MarioInstance, GumbaList);
MarioInstanceAxisAlignedRectangleInstanceVsGumbaListRightMarioDead.SetFirstSubCollision(item => item.AxisAlignedRectangleInstance);
MarioInstanceAxisAlignedRectangleInstanceVsGumbaListRightMarioDead.SetSecondSubCollision(item => item.RightMarioDead);
MarioInstanceAxisAlignedRectangleInstanceVsGumbaListRightMarioDead.Name = "MarioInstanceAxisAlignedRectangleInstanceVsGumbaListRightMarioDead";
MarioInstanceAxisAlignedRectangleInstanceVsMushroomListAxisAlignedRectangleInstance = FlatRedBall.Math.Collision.CollisionManager.Self.CreateRelationship(MarioInstance, MushroomList);
MarioInstanceAxisAlignedRectangleInstanceVsMushroomListAxisAlignedRectangleInstance.SetFirstSubCollision(item => item.AxisAlignedRectangleInstance);
MarioInstanceAxisAlignedRectangleInstanceVsMushroomListAxisAlignedRectangleInstance.SetSecondSubCollision(item => item.AxisAlignedRectangleInstance);
MarioInstanceAxisAlignedRectangleInstanceVsMushroomListAxisAlignedRectangleInstance.Name = "MarioInstanceAxisAlignedRectangleInstanceVsMushroomListAxisAlignedRectangleInstance";
MarioInstanceAxisAlignedRectangleInstanceVsMushroomListAxisAlignedRectangleInstance.SetMoveCollision(1f, 1f);
{
var temp = new FlatRedBall.Math.Collision.DelegateListVsSingleRelationship <Entities.Mushroom, FlatRedBall.TileCollisions.TileShapeCollection>(MushroomList, SolidCollision);
var isCloud = false;
temp.CollisionFunction = (first, second) =>
{
return(first.CollideAgainst(second, isCloud));
}
;
FlatRedBall.Math.Collision.CollisionManager.Self.Relationships.Add(temp);
MushroomListVsSolidCollision = temp;
}
MushroomListVsSolidCollision.Name = "MushroomListVsSolidCollision";
{
var temp = new FlatRedBall.Math.Collision.DelegateListVsListRelationship <Entities.Mushroom, Entities.A_Brick>(MushroomList, A_BrickList);
var isCloud = false;
temp.CollisionFunction = (first, second) =>
{
return(first.CollideAgainst(second, isCloud));
}
;
FlatRedBall.Math.Collision.CollisionManager.Self.Relationships.Add(temp);
MushroomListVsA_BrickList = temp;
}
MushroomListVsA_BrickList.CollisionLimit = FlatRedBall.Math.Collision.CollisionLimit.All;
MushroomListVsA_BrickList.Name = "MushroomListVsA_BrickList";
{
var temp = new FlatRedBall.Math.Collision.DelegateListVsListRelationship <Entities.Mushroom, Entities.Lucky_block>(MushroomList, Lucky_blockList);
var isCloud = false;
temp.CollisionFunction = (first, second) =>
{
return(first.CollideAgainst(second, isCloud));
}
;
FlatRedBall.Math.Collision.CollisionManager.Self.Relationships.Add(temp);
MushroomListVsLucky_blockList = temp;
}
MushroomListVsLucky_blockList.CollisionLimit = FlatRedBall.Math.Collision.CollisionLimit.All;
MushroomListVsLucky_blockList.Name = "MushroomListVsLucky_blockList";
{
var temp = new FlatRedBall.Math.Collision.DelegateListVsSingleRelationship <Entities.Turtle, FlatRedBall.TileCollisions.TileShapeCollection>(TurtleList, SolidCollision);
var isCloud = false;
temp.CollisionFunction = (first, second) =>
{
return(first.CollideAgainst(second, first.AxisAlignedRectangleInstance, isCloud));
}
;
FlatRedBall.Math.Collision.CollisionManager.Self.Relationships.Add(temp);
TurtleListAxisAlignedRectangleInstanceVsSolidCollision = temp;
}
TurtleListAxisAlignedRectangleInstanceVsSolidCollision.Name = "TurtleListAxisAlignedRectangleInstanceVsSolidCollision";
{
var temp = new FlatRedBall.Math.Collision.DelegateListVsListRelationship <Entities.Gumba, Entities.Turtle>(GumbaList, TurtleList);
var isCloud = false;
temp.CollisionFunction = (first, second) =>
{
return(first.CollideAgainst(second, isCloud));
}
;
FlatRedBall.Math.Collision.CollisionManager.Self.Relationships.Add(temp);
GumbaListVsTurtleList = temp;
}
GumbaListVsTurtleList.CollisionLimit = FlatRedBall.Math.Collision.CollisionLimit.All;
GumbaListVsTurtleList.Name = "GumbaListVsTurtleList";
MarioInstanceAxisAlignedRectangleInstanceVsTurtleListAxisAlignedRectangleInstance = FlatRedBall.Math.Collision.CollisionManager.Self.CreateRelationship(MarioInstance, TurtleList);
MarioInstanceAxisAlignedRectangleInstanceVsTurtleListAxisAlignedRectangleInstance.SetFirstSubCollision(item => item.AxisAlignedRectangleInstance);
MarioInstanceAxisAlignedRectangleInstanceVsTurtleListAxisAlignedRectangleInstance.SetSecondSubCollision(item => item.AxisAlignedRectangleInstance);
MarioInstanceAxisAlignedRectangleInstanceVsTurtleListAxisAlignedRectangleInstance.Name = "MarioInstanceAxisAlignedRectangleInstanceVsTurtleListAxisAlignedRectangleInstance";
MarioInstanceAxisAlignedRectangleInstanceVsTurtleListAxisAlignedRectangleInstance.SetMoveCollision(0f, 1f);
{
var temp = new FlatRedBall.Math.Collision.DelegateListVsSingleRelationship <Entities.Turtle, FlatRedBall.TileCollisions.TileShapeCollection>(TurtleList, CombinedShapeCollection);
var isCloud = false;
temp.CollisionFunction = (first, second) =>
{
return(first.CollideAgainst(second, first.AxisAlignedRectangleInstance, isCloud));
}
;
FlatRedBall.Math.Collision.CollisionManager.Self.Relationships.Add(temp);
TurtleListAxisAlignedRectangleInstanceVsCombinedShapeCollection = temp;
}
TurtleListAxisAlignedRectangleInstanceVsCombinedShapeCollection.Name = "TurtleListAxisAlignedRectangleInstanceVsCombinedShapeCollection";
MarioInstanceVsCoinList = FlatRedBall.Math.Collision.CollisionManager.Self.CreateRelationship(MarioInstance, CoinList);
MarioInstanceVsCoinList.Name = "MarioInstanceVsCoinList";
Forms = new Super_Marios_Bros.FormsControls.Screens.Mario_Main_GUIForms(Mario_Main_GUI);
// normally we wait to set variables until after the object is created, but in this case if the
// TileShapeCollection doesn't have its Visible set before creating the tiles, it can result in
// really bad performance issues, as shapes will be made visible, then invisible. Really bad perf!
if (SolidCollision != null)
{
SolidCollision.Visible = false;
}
FlatRedBall.TileCollisions.TileShapeCollectionLayeredTileMapExtensions.AddCollisionFromTilesWithType(SolidCollision, Map, "SolidCollision", false);
// normally we wait to set variables until after the object is created, but in this case if the
// TileShapeCollection doesn't have its Visible set before creating the tiles, it can result in
// really bad performance issues, as shapes will be made visible, then invisible. Really bad perf!
if (CloudCollision != null)
{
CloudCollision.Visible = false;
}
FlatRedBall.TileCollisions.TileShapeCollectionLayeredTileMapExtensions.AddCollisionFromTilesWithType(CloudCollision, Map, "CloudCollision", false);
// normally we wait to set variables until after the object is created, but in this case if the
// TileShapeCollection doesn't have its Visible set before creating the tiles, it can result in
// really bad performance issues, as shapes will be made visible, then invisible. Really bad perf!
if (CombinedShapeCollection != null)
{
CombinedShapeCollection.Visible = false;
}
PostInitialize();
base.Initialize(addToManagers);
if (addToManagers)
{
AddToManagers();
}
}
void OnTurtleListVsSolidCollisionCollisionOccurredTunnel(Entities.Turtle first, FlatRedBall.TileCollisions.TileShapeCollection second)
{
if (this.TurtleListVsSolidCollisionCollisionOccurred != null)
{
TurtleListVsSolidCollisionCollisionOccurred(first, second);
}
}
void OnMushroomListVsSolidCollisionCollisionOccurredTunnel(Entities.Mushroom first, FlatRedBall.TileCollisions.TileShapeCollection second)
{
if (this.MushroomListVsSolidCollisionCollisionOccurred != null)
{
MushroomListVsSolidCollisionCollisionOccurred(first, second);
}
}
void OnGumbaListAxisAlignedRectangleInstanceVsSolidCollisionCollisionOccurredTunnel(Entities.Gumba first, FlatRedBall.TileCollisions.TileShapeCollection second)
{
if (this.GumbaListAxisAlignedRectangleInstanceVsSolidCollisionCollisionOccurred != null)
{
GumbaListAxisAlignedRectangleInstanceVsSolidCollisionCollisionOccurred(first, second);
}
}
public override void Initialize(bool addToManagers)
{
LoadStaticContent(ContentManagerName);
SolidCollision = new FlatRedBall.TileCollisions.TileShapeCollection();
PlayerInstance = new Soccer.Entities.Player(ContentManagerName, false);
PlayerInstance.Name = "PlayerInstance";
{
var temp = new FlatRedBall.Math.Collision.DelegateCollisionRelationship <Soccer.Entities.Player, FlatRedBall.TileCollisions.TileShapeCollection>(PlayerInstance, SolidCollision);
var isCloud = false;
temp.CollisionFunction = (first, second) =>
{
return(first.CollideAgainst(second, first.AxisAlignedRectangleInstance, isCloud));
}
;
FlatRedBall.Math.Collision.CollisionManager.Self.Relationships.Add(temp);
PlayerInstanceAxisAlignedRectangleInstanceVsSolidCollision = temp;
}
PlayerInstanceAxisAlignedRectangleInstanceVsSolidCollision.Name = "PlayerInstanceAxisAlignedRectangleInstanceVsSolidCollision";
// Not instantiating for LayeredTileMap Map in Screens\GameScreen (Screen) because properties on the object prevent it
BallList = new FlatRedBall.Math.PositionedObjectList <Soccer.Entities.Ball>();
BallList.Name = "BallList";
BallListVsPlayerInstanceAxisAlignedRectangleInstance = FlatRedBall.Math.Collision.CollisionManager.Self.CreateRelationship(BallList, PlayerInstance);
BallListVsPlayerInstanceAxisAlignedRectangleInstance.SetSecondSubCollision(item => item.AxisAlignedRectangleInstance);
BallListVsPlayerInstanceAxisAlignedRectangleInstance.Name = "BallListVsPlayerInstanceAxisAlignedRectangleInstance";
BallListVsPlayerInstanceAxisAlignedRectangleInstance.SetBounceCollision(0f, 1f, 0.5f);
BallListVsSolidCollision = FlatRedBall.Math.Collision.CollisionManagerTileShapeCollectionExtensions.CreateTileRelationship(FlatRedBall.Math.Collision.CollisionManager.Self, BallList, SolidCollision);
BallListVsSolidCollision.Name = "BallListVsSolidCollision";
BallListVsSolidCollision.SetBounceCollision(0f, 1f, 0.8f);
GoalCollision = new FlatRedBall.TileCollisions.TileShapeCollection();
{
var temp = new FlatRedBall.Math.Collision.DelegateCollisionRelationship <Soccer.Entities.Player, FlatRedBall.TileCollisions.TileShapeCollection>(PlayerInstance, GoalCollision);
var isCloud = false;
temp.CollisionFunction = (first, second) =>
{
return(first.CollideAgainst(second, first.AxisAlignedRectangleInstance, isCloud));
}
;
FlatRedBall.Math.Collision.CollisionManager.Self.Relationships.Add(temp);
PlayerInstanceAxisAlignedRectangleInstanceVsGoalCollision = temp;
}
PlayerInstanceAxisAlignedRectangleInstanceVsGoalCollision.Name = "PlayerInstanceAxisAlignedRectangleInstanceVsGoalCollision";
BallListCollisionCircleVsGoalCollision = FlatRedBall.Math.Collision.CollisionManagerTileShapeCollectionExtensions.CreateTileRelationship(FlatRedBall.Math.Collision.CollisionManager.Self, BallList, GoalCollision);
BallListCollisionCircleVsGoalCollision.SetFirstSubCollision(item => item.CollisionCircle);
BallListCollisionCircleVsGoalCollision.Name = "BallListCollisionCircleVsGoalCollision";
GoalDisplay = new FlatRedBall.Sprite();
GoalDisplay.Name = "GoalDisplay";
PlayerInstanceBallCatchAreaVsBallListCollisionCircle = FlatRedBall.Math.Collision.CollisionManager.Self.CreateRelationship(PlayerInstance, BallList);
PlayerInstanceBallCatchAreaVsBallListCollisionCircle.SetFirstSubCollision(item => item.BallCatchArea);
PlayerInstanceBallCatchAreaVsBallListCollisionCircle.SetSecondSubCollision(item => item.CollisionCircle);
PlayerInstanceBallCatchAreaVsBallListCollisionCircle.Name = "PlayerInstanceBallCatchAreaVsBallListCollisionCircle";
UpSpringCollision = new FlatRedBall.TileCollisions.TileShapeCollection();
PlayerInstanceAxisAlignedRectangleInstanceVsUpSpringCollision = FlatRedBall.Math.Collision.CollisionManagerTileShapeCollectionExtensions.CreateTileRelationship(FlatRedBall.Math.Collision.CollisionManager.Self, PlayerInstance, UpSpringCollision);
PlayerInstanceAxisAlignedRectangleInstanceVsUpSpringCollision.SetFirstSubCollision(item => item.AxisAlignedRectangleInstance);
PlayerInstanceAxisAlignedRectangleInstanceVsUpSpringCollision.Name = "PlayerInstanceAxisAlignedRectangleInstanceVsUpSpringCollision";
BallListCollisionCircleVsUpSpringCollision = FlatRedBall.Math.Collision.CollisionManagerTileShapeCollectionExtensions.CreateTileRelationship(FlatRedBall.Math.Collision.CollisionManager.Self, BallList, UpSpringCollision);
BallListCollisionCircleVsUpSpringCollision.SetFirstSubCollision(item => item.CollisionCircle);
BallListCollisionCircleVsUpSpringCollision.Name = "BallListCollisionCircleVsUpSpringCollision";
// normally we wait to set variables until after the object is created, but in this case if the
// TileShapeCollection doesn't have its Visible set before creating the tiles, it can result in
// really bad performance issues, as shapes will be made visible, then invisible. Really bad perf!
if (SolidCollision != null)
{
SolidCollision.Visible = false;
}
FlatRedBall.TileCollisions.TileShapeCollectionLayeredTileMapExtensions.AddCollisionFromTilesWithType(SolidCollision, Map, "Solid");
// normally we wait to set variables until after the object is created, but in this case if the
// TileShapeCollection doesn't have its Visible set before creating the tiles, it can result in
// really bad performance issues, as shapes will be made visible, then invisible. Really bad perf!
if (GoalCollision != null)
{
GoalCollision.Visible = false;
}
FlatRedBall.TileCollisions.TileShapeCollectionLayeredTileMapExtensions.AddCollisionFromTilesWithType(GoalCollision, Map, "Goal");
// normally we wait to set variables until after the object is created, but in this case if the
// TileShapeCollection doesn't have its Visible set before creating the tiles, it can result in
// really bad performance issues, as shapes will be made visible, then invisible. Really bad perf!
if (UpSpringCollision != null)
{
UpSpringCollision.Visible = false;
}
FlatRedBall.TileCollisions.TileShapeCollectionLayeredTileMapExtensions.AddCollisionFromTilesWithType(UpSpringCollision, Map, "Spring");
PostInitialize();
base.Initialize(addToManagers);
if (addToManagers)
{
AddToManagers();
}
}
