//===========================================================
/*-------------------------------------
*
* Translate function
*
* moves the block position, at the
* gamelogic level, I am unconcerned
* about what is happening with the
* pixels on-screen.
*
* ---------------------------------*/
public void BlockTranslate(int deltaX, int deltaY)
{
BlockPosition.X += deltaX;
BlockPosition.Y += deltaY;
//-- now update the collision zone
CollisionZone.Translate(deltaX, deltaY);
}
public void TestCollisionZoneCollision()
{
CollisionZone <Bullet> TestCollisionZone = new CollisionZone <Bullet>(2000, 100, -500, -500);
Vector2[] LocalPoints1 = CreateCube(Vector2.Zero, 40);
Vector2[] LocalPoints2 = CreateCube(Vector2.Zero, 40);
TestCollisionZone.AddToZone(new Bullet(null, LocalPoints1, 5, 5));
TestCollisionZone.AddToZone(new Bullet(null, LocalPoints2, 5, 5));
Assert.AreEqual(true, DetectCollisionBetweenSelfAndOthers(TestCollisionZone, TestCollisionZone.ListObjectInZoneAndOverlappingParents.First.Value));
}
private static void BuildZone(int key2, int XPos, int YPos, QuadTree quad, int key3 = 0)
{
CollisionZone ca = null;
switch (key2)
{
case 'C':
ca = CollisionZoneFactory.Instance.CheckpointZone(new Point(XPos, 0), new Point(40, quad.Bounds.Height));
ca.LookingFor = AbstractEntity.EntityType.Mario;
ca.Position = new Vector2(XPos, YPos);
ca.RaiseEnterEvent += Stage.HandleCheckpoint;
break;
case 'F':
ca = CollisionZoneFactory.Instance.Flag(new Point(XPos + 16, YPos));
ca.Position = new Vector2(XPos + 16, YPos);
ca.RaiseEnterEvent += Stage.HandleGameEnd;
ca.LookingFor = AbstractEntity.EntityType.Mario;
break;
case 'A':
ca = CollisionZoneFactory.Instance.Castle(new Point(XPos, YPos));
ca.Position = new Vector2(XPos, YPos);
break;
case 'S':
ca = CollisionZoneFactory.Instance.SmallDoor(new Point(XPos, YPos));
ca.Position = new Vector2(XPos, YPos);
((WarpZone)ca).NextArea = key3 - '0';
ca.RaiseEnterEvent += Stage.level.HandleInteractEnter;
ca.RaiseLeaveEvent += Stage.level.HandleInteractLeave;
((WarpZone)ca).RaiseWarpEvent += Stage.HandleWarp;
ca.LookingFor = AbstractEntity.EntityType.Mario;
break;
case 'L':
ca = CollisionZoneFactory.Instance.LockedDoorZone(new Point(XPos, YPos));
ca.Position = new Vector2(XPos, YPos);
for (int i = 0; i < 4; i++)
{
KeyHoleBlock b = (KeyHoleBlock)BlockFactory.Instance.KeyHoleBlock();
b.Position = new Vector2(XPos + 32 * (i - 1), YPos - b.Texture.Height - 32);
((LockedDoor)ca).KeyHoles.Add(b);
quad.Insert(b);
}
ca.LookingFor = AbstractEntity.EntityType.Mario;
ca.RaiseEnterEvent += Stage.level.HandleInteractEnter;
ca.RaiseLeaveEvent += Stage.level.HandleInteractLeave;
((WarpZone)ca).NextArea = key3 - '0';
((WarpZone)ca).RaiseWarpEvent += Stage.HandleWarp;
break;
}
quad.Insert(ca);
}
private bool DetectCollisionBetweenSelfAndOthers(CollisionZone <Bullet> BulletCollisions, Bullet ActiveBullet)
{
System.Collections.Generic.HashSet <Bullet> Obstacles = BulletCollisions.GetCollidableObjects(ActiveBullet);
foreach (Bullet ActivePlayer in Obstacles)
{
if (ActivePlayer.Collision.CollideWith(ActiveBullet.Collision, Vector2.Zero, out _, out _, out _))
{
return(true);
}
}
return(false);
}
public void TestCollisionZoneAdd()
{
CollisionZone <Bullet> TestCollisionZone = new CollisionZone <Bullet>(2000, 100, -500, -500);
Vector2[] LocalPoints1 = CreateCube(Vector2.Zero, 40);
Vector2[] LocalPoints2 = CreateCube(Vector2.Zero, 5);
TestCollisionZone.AddToZone(new Bullet(null, LocalPoints1, 5, 5));
TestCollisionZone.AddToZone(new Bullet(null, LocalPoints2, 5, 5));
Assert.AreEqual(2, TestCollisionZone.ListObjectInZoneAndOverlappingParents.Count);
Assert.AreEqual(2, TestCollisionZone.ArraySubZone[25].ListObjectInZoneAndOverlappingParents.Count);
Assert.AreEqual(TestCollisionZone.ArraySubZone[25], TestCollisionZone.ListObjectInZoneAndOverlappingParents.First.Value.Collision.ListParent.Find(TestCollisionZone.ArraySubZone[25]).Value);
Assert.AreEqual(TestCollisionZone.ArraySubZone[25], TestCollisionZone.ListObjectInZoneAndOverlappingParents.First.Next.Value.Collision.ListParent.Find(TestCollisionZone.ArraySubZone[25]).Value);
}
public Layer(FightingZone Owner)
{
ListDelayedOnlineCommand = new List <DelayedExecutableOnlineScript>();
WorldCollisions = new CollisionZone <WorldPolygon>(1, 1, 0, 0);
ListWorldCollisionPolygon = new List <WorldPolygon>();
ListImages = new List <SimpleAnimation>();
ListProp = new List <Prop>();
ListSpawnPointTeam = new List <SpawnPoint>();
ListSpawnPointNoTeam = new List <SpawnPoint>();
ListVisualEffects = new List <SimpleAnimation>();
DicRobot = new Dictionary <uint, RobotAnimation>();
DicWeaponDrop = new Dictionary <uint, WeaponDrop>();
ListVehicle = new List <Vehicle>();
ListRobotToAdd = new List <RobotAnimation>();
ListRobotToRemove = new List <uint>();
ListWeaponDropToAdd = new List <WeaponDrop>();
ListWeaponDropToRemove = new List <uint>();
GroundLevelCollision = new Polygon();
ListAttackCollisionBox = new List <Projectile>();
this.Owner = Owner;
}
public void UpdateCollisionZone(CollisionZone cz)
{
//return;
Vector3 hitNormal = Vector3.zero;
float hitDist = 0;
int count = 0;
float radius = cz.radius * VertExmotionBase.GetScaleFactor(transform);
Vector3 collisionCenter = transform.TransformPoint(cz.positionOffset);// transform.position + transform.rotation * cz.positionOffset;
cz.collisionVector = Vector3.zero;
if (Physics.CheckSphere(collisionCenter, radius, m_layerMask.value))
{
cz.collisionVector = Vector3.zero;
// //test
// Collider[] hitColliders = Physics.OverlapSphere(collisionCenter, m_collisionZones[0].radius, m_layerMask);
// int j = 0;
// while (j < hitColliders.Length)
// {
// Debug.Log("collide " + hitColliders[j].name);
// hitColliders[j].ClosestPointOnBounds( transform.position );
// j++;
// }
for (int a = 0; a < 6; ++a)//WIP : check collision on each axis
//int a = 0;
{
Vector3 dir = Vector3.zero;
switch (a)
{
case 0: dir = m_sensor.transform.forward; break;
case 1: dir = -m_sensor.transform.forward; break;
case 2: dir = m_sensor.transform.up; break;
case 3: dir = -m_sensor.transform.up; break;
case 4: dir = m_sensor.transform.right; break;
case 5: dir = -m_sensor.transform.right; break;
}
//cz.hits = Physics.SphereCastAll(collisionCenter - dir * radius / 2f, radius * m_collisionScaleFactor, dir, radius / 2f, m_layerMask.value, QueryTriggerInteraction.Collide);
cz.hits = Physics.SphereCastAll(collisionCenter - dir * radius, radius * m_collisionScaleFactor, dir, radius, m_layerMask.value, QueryTriggerInteraction.Collide);
for (int i = 0; i < cz.hits.Length; ++i)
{
//Debug.Log("collision "+Vector3.Distance (cz.hits [i].point, collisionCenter));
//Debug.DrawLine(cz.hits[i].collider.ClosestPointOnBounds(transform.position), transform.position);
if (m_ignoreColliders.Contains(cz.hits[i].collider))
{
continue;
}
Vector3 hitPos = cz.hits[i].point;
float debugoffset = .01f;
#if KVTM_DEBUG
Debug.DrawLine(cz.hits[i].collider.ClosestPointOnBounds(transform.position) + Vector3.up * a * debugoffset, transform.position + Vector3.up * a * debugoffset, Color.blue);
#endif
//Vector3 hitPos = cz.hits [i].collider.ClosestPointOnBounds(transform.position);
//if (Vector3.Distance (cz.hits [i].point, collisionCenter) < radius )
if (Vector3.Distance(hitPos, collisionCenter) < radius)
{
/*
* hitNormal = cz.hits[i].normal.normalized;
* //hitNormal += (collisionCenter-cz.hits [i].point ).normalized;
* hitNormal += (collisionCenter - hitPos).normalized;
* hitNormal.Normalize();
*/
hitNormal = -(hitPos - collisionCenter).normalized;
//if (Vector3.Dot ((transform.position - hits [i].point).normalized, hits [i].normal) >= 0)
if (Vector3.Dot((collisionCenter - hitPos).normalized, -dir) > 0)
{
//hitDist += (radius - Vector3.Distance(hitPos, collisionCenter));
hitDist += (radius - Vector3.Distance(hitPos, collisionCenter)) / 6f;
count++;
} /*
* else
* {
* if (cz.hits[i].collider as SphereCollider == null)
* {
* hitNormal = (-dir + cz.hits[i].normal).normalized;
* hitDist = radius;
* }
* else
* {
* hitNormal = cz.hits[i].normal.normalized;
* hitDist = radius - Vector3.Distance(hitPos, collisionCenter);
* }
* }*/
//count++;
} /*
* else
* {
* hitDist = cz.radius;
* hitNormal = (-m_sensor.transform.forward + cz.hits[i].normal).normalized;
* }*/
}
if (count > 0)
{
cz.collisionVector += hitNormal.normalized * hitDist * 2f;
}/*
* else
* {
* cz.collisionVector += hitNormal.normalized * radius * 2f;
* }*/
}
//cz.collisionVector /= 6f;
}
else
{
cz.collisionVector = Vector3.zero;
}
}
public Layer(FightingZone Owner, BinaryReader BR)
: this(Owner)
{
Dictionary <string, Prop> DicPropsByName = Prop.GetAllPropsByName();
int ListPolygonCount = BR.ReadInt32();
WorldCollisions = new CollisionZone <WorldPolygon>((int)Math.Max(Owner.CameraBounds.Width * 1.5, Owner.CameraBounds.Height * 1.5),
50,
(int)(Math.Min(Owner.CameraBounds.X * 1.5, -Owner.CameraBounds.X * 1.5)),
(int)(Math.Min(Owner.CameraBounds.Y * 1.5, -Owner.CameraBounds.Y * 1.5)));
for (int P = 0; P < ListPolygonCount; P++)
{
int ArrayVertexCount = BR.ReadInt32();
Vector2[] ArrayVertex = new Vector2[ArrayVertexCount];
for (int V = 0; V < ArrayVertexCount; V++)
{
ArrayVertex[V] = new Vector2(BR.ReadSingle(), BR.ReadSingle());
}
bool BlockBullets = BR.ReadBoolean();
bool IsPlatform = BR.ReadBoolean();
WorldPolygon NewPolygon;
if (GameScreen.GraphicsDevice != null)
{
NewPolygon = new WorldPolygon(ArrayVertex, GameScreen.GraphicsDevice.PresentationParameters.BackBufferWidth, GameScreen.GraphicsDevice.PresentationParameters.BackBufferHeight);
}
else
{
NewPolygon = new WorldPolygon(ArrayVertex, 1, 1);
}
NewPolygon.BlockBullets = BlockBullets;
NewPolygon.IsPlatform = IsPlatform;
NewPolygon.Collision.ListCollisionPolygon[0].ComputerCenter();
WorldCollisions.AddToZone(NewPolygon);
ListWorldCollisionPolygon.Add(NewPolygon);
}
int ArrayGroundLevelCollisionCount = BR.ReadInt32();
Vector2[] ArrayGroundLevelCollision = new Vector2[ArrayGroundLevelCollisionCount];
for (int V = 0; V < ArrayGroundLevelCollisionCount; V++)
{
ArrayGroundLevelCollision[V] = new Vector2(BR.ReadSingle(), BR.ReadSingle());
}
short[] ArrayGroundLevelCollisionIndex = new short[2];
ArrayGroundLevelCollisionIndex[0] = 0;
ArrayGroundLevelCollisionIndex[1] = 1;
if (GameScreen.GraphicsDevice != null)
{
GroundLevelCollision = new Polygon(ArrayGroundLevelCollision, ArrayGroundLevelCollisionIndex, GameScreen.GraphicsDevice.PresentationParameters.BackBufferWidth, GameScreen.GraphicsDevice.PresentationParameters.BackBufferHeight);
}
else
{
GroundLevelCollision = new Polygon(ArrayGroundLevelCollision, ArrayGroundLevelCollisionIndex, 1, 1);
}
int ListImagesCount = BR.ReadInt32();
ListImages = new List <SimpleAnimation>(ListImagesCount);
for (int P = 0; P < ListImagesCount; P++)
{
SimpleAnimation NewBackground = new SimpleAnimation(BR, true);
NewBackground.Position = new Vector2(BR.ReadSingle(), BR.ReadSingle());
NewBackground.Depth = BR.ReadSingle();
if (!Owner.IsServer)
{
NewBackground.Load(Owner.Content, "");
ListImages.Add(NewBackground);
}
}
int ListPropCount = BR.ReadInt32();
for (int P = 0; P < ListPropCount; ++P)
{
string PropName = BR.ReadString();
Prop NewProp = DicPropsByName[PropName].Copy();
NewProp.Load(BR, Owner.Content, this, Owner);
//Props are Client side only.
if (NewProp.CanRunOnServer || !Owner.IsServer)
{
ListProp.Add(NewProp);
}
}
int ListSpawnPointSPCount = BR.ReadInt32();
for (int S = 0; S < ListSpawnPointSPCount; ++S)
{
ListSpawnPointTeam.Add(SpawnPoint.Load(BR));
}
int ListSpawnPointMPCount = BR.ReadInt32();
for (int S = 0; S < ListSpawnPointMPCount; ++S)
{
ListSpawnPointTeam.Add(SpawnPoint.Load(BR));
}
}
private static IBlock BuildBlock(int key2, int key3, int key4, int XPos, int YPos, QuadTree quad, string code, List <Button> buttons)
{
IBlock block = null;
switch (key2)
{
case 'A':
foreach (Button button in buttons)
{
if (!button.Set)
{
block = button;
button.Set = true;
break;
}
}
break;
case 'B':
block = BlockFactory.Instance.BrickBlock();
if (code.Length == 4)
{
int i = 0;
while (code[3] - '0' > i)
{
BlockCommand(key3, block);
i++;
}
}
else
{
BlockCommand(key3, block);
}
break;
case 'C':
if (code.Length == 6)
{
block = BlockFactory.Instance.DisappearingBlockSkin((char)key4, char.Parse(code.Substring(4, 1)), char.Parse(code.Substring(5, 1)));
}
else if (code.Length == 5)
{
block = BlockFactory.Instance.DisappearingBlockSkin((char)key4, char.Parse(code.Substring(4, 1)));
}
else
{
block = BlockFactory.Instance.DisappearingBlockSkin((char)key4);
}
buttons[key3 - '0'].RaisePressEvent += ((DisappearingBlock)block).HandleButtonPress;
break;
case 'F':
switch (key3)
{
case 'U':
block = CreateUndergroundBlock(code[3]);
break;
case 'C':
block = BlockFactory.Instance.CastleFloorBlock();
break;
default:
block = BlockFactory.Instance.FloorBlock();
if (key3 == 'Z')
{
block.Collidable = false;
}
break;
}
break;
case 'P':
block = BuildPipeBlock(key3);
break;
case 'Q':
QuestionBlock qb = BlockFactory.Instance.QuestionBlockQ();
qb.Position = new Vector2(XPos, YPos);
ICommand qcmd = null;
//if key2 == Q, then there valid key3
switch (key3)
{
case 'C':
qcmd = new CoinItemCommand(qb);
break;
case 'M':
qcmd = new SuperMushroomItemCommand(qb);
break;
case 'F':
qcmd = new FireFlowerItemCommand(qb);
break;
case 'S':
qcmd = new StarItemCommand(qb);
break;
case 'O':
qcmd = new OneUpMushroomItemCommand(qb);
break;
case 'H':
block = BlockFactory.Instance.HiddenQuestionBlock();
BlockCommand(key3, block);
break;
case 'U':
qb.Position = new Vector2(XPos, YPos);
qb.StraightToUsed();
break;
default:
block = BlockFactory.Instance.QuestionBlock();
break;
}
if (qcmd != null)
{
quad.Insert(qb);
qb.AddCommand(qcmd);
}
break;
case 'R':
block = BlockFactory.Instance.RockBlock();
Point size = new Point()
{
X = block.Texture.Width / 3,
Y = block.Texture.Height / 3
};
block.SourceRectangle = BlockPart(key3, key4, size);
break;
case 'T':
block = BlockFactory.Instance.ToggleBlock();
for (int i = 3; i < code.Length; i++)
{
buttons[code[i] - '0'].RaisePressEvent += ((ToggleBlock)block).HandleButtonPress;
}
if (code[2] == 'H')
{
block.SourceRectangle = new Rectangle(new Point(0), new Point(block.Texture.Width, block.Texture.Height / 2));
block.Collidable = false;
((ToggleBlock)block).StartY = block.SourceRectangle.Y;
}
else
{
block.SourceRectangle = new Rectangle(new Point(0, block.Texture.Height / 2), new Point(block.Texture.Width, block.Texture.Height / 2));
((ToggleBlock)block).StartY = 32;
}
break;
case 'H':
block = BlockFactory.Instance.HiddenBrickBlock();
break;
case 'W':
switch (key3)
{
case 'U':
block = BlockFactory.Instance.WarpUpTop();
break;
case 'L':
block = BlockFactory.Instance.WarpLeft();
break;
case 'R':
block = BlockFactory.Instance.WarpRight();
break;
}
((WarpEntranceBlock)block).Warp = key4 - '0';
((WarpEntranceBlock)block).RaiseWarpEvent += Stage.HandleWarp;
break;
case 'I':
EntityWarpBlock warpBlock = (EntityWarpBlock)BlockFactory.Instance.WarpEntityTop();
ICommand wCommand = null;
switch (key3)
{
case 'C':
wCommand = new CoinItemCommand(warpBlock);
break;
case 'M':
wCommand = new SuperMushroomItemCommand(warpBlock);
break;
case 'F':
wCommand = new FireFlowerItemCommand(warpBlock);
break;
case 'S':
wCommand = new StarItemCommand(warpBlock);
break;
case 'O':
wCommand = new OneUpMushroomItemCommand(warpBlock);
break;
case 'G':
wCommand = new CreateEnemyCommand(AbstractEntity.EntityType.Goomba, warpBlock);
break;
case 'K':
wCommand = new CreateEnemyCommand(AbstractEntity.EntityType.GreenKoopa, warpBlock);
break;
case 'R':
wCommand = new CreateEnemyCommand(AbstractEntity.EntityType.RedKoop, warpBlock);
break;
case 'P':
wCommand = new CreateEnemyCommand(AbstractEntity.EntityType.PiranhaPlant, warpBlock);
break;
}
warpBlock.Command = wCommand;
warpBlock.Position = new Vector2(XPos, YPos);
Rectangle box = warpBlock.CollisionBox;
box.X -= box.Width / 2;
box.Width *= 2;
box.Y = warpBlock.CollisionBox.Y - warpBlock.TrueHeight();
box.Height = (int)(quad.Bounds.Height - YPos + warpBlock.CollisionBox.Height * 1.5);
CollisionZone hz = new CollisionZone(box)
{
LookingFor = AbstractEntity.EntityType.Mario
};
hz.RaiseEnterEvent += warpBlock.HandleEnterEvent;
hz.RaiseLeaveEvent += warpBlock.HandleLeaveEvent;
quad.Insert(warpBlock);
quad.Insert(hz);
break;
case 'Y':
block = BlockFactory.Instance.PyramidBlock();
break;
}
return(block);
}
