/// <summary>
/// Constructs a new demo.
/// </summary>
/// <param name="game">Game owning this demo.</param>
public CollisionFilteringDemo(DemosGame game)
: base(game)
{
Entity toAdd;
toAdd = new Box(new Vector3(0, -.5f, 0), 50, 1, 50);
Space.Add(toAdd);
//Set up two stacks which go through each other
var firstStackGroup = new CollisionGroup();
var secondStackGroup = new CollisionGroup();
//Adding this rule to the space's collision group rules will prevent entities belong to these two groups from generating collision pairs with each other.
groupPair = new CollisionGroupPair(firstStackGroup, secondStackGroup);
CollisionRules.CollisionGroupRules.Add(groupPair, CollisionRule.NoBroadPhase);
for (int k = 0; k < 10; k++)
{
toAdd = new Box(
new Vector3(-4 + .12f * k, .5f + k, 0), 1f, 1f, 1f,
10);
toAdd.CollisionInformation.CollisionRules.Group = firstStackGroup;
Space.Add(toAdd);
toAdd = new Box(new Vector3(4 - .12f * k, .5f + k, 0),
1f, 1f, 1f, 10);
toAdd.CollisionInformation.CollisionRules.Group = secondStackGroup;
Space.Add(toAdd);
}
//Add another two boxes which ignore each other using the specific entities method; they will still collide with the stacks since they will have the default dynamic collision group.
toAdd = new Box(new Vector3(1, 3, 0), 1f, 4f, 2f, 10);
var toAdd2 = new Box(new Vector3(-1, 3, 0), 1f, 4f, 2f, 15);
CollisionRules.AddRule(toAdd, toAdd2, CollisionRule.NoBroadPhase);
Space.Add(toAdd);
Space.Add(toAdd2);
game.Camera.Position = new Vector3(0, 6, 20);
}
public CollisionBase()
{
if (!graphics.initialized)
{
graphics.rasterizerState = new RasterizerState();
graphics.rasterizerState.FillMode = FillMode.WireFrame;
graphics.rasterizerState.CullMode = CullMode.None;
graphics.vertexDeclaration = new VertexDeclaration(new VertexElement[]
{
new VertexElement(0, VertexElementFormat.Vector3, VertexElementUsage.Position, 0),
new VertexElement(12, VertexElementFormat.Color, VertexElementUsage.Color, 0)
}
);
graphics.basicEffect = new BasicEffect(Space394Game.GameInstance.GraphicsDevice);
graphics.basicEffect.VertexColorEnabled = true;
graphics.initialized = true;
esxolusGroup = new CollisionGroup();
halkGroup = new CollisionGroup();
CollisionGroupPair pairE = new CollisionGroupPair(esxolusGroup, esxolusGroup);
CollisionRules.CollisionGroupRules.Add(pairE, CollisionRule.NoBroadPhase);
CollisionGroupPair pairH = new CollisionGroupPair(halkGroup, halkGroup);
CollisionRules.CollisionGroupRules.Add(pairH, CollisionRule.NoBroadPhase);
}
else { }
}
/// <summary>
/// Defines a CollisionRule between a group and every group in a set of groups for a given space.
/// </summary>
/// <param name="group">First CollisionGroup of the pair.</param>
/// <param name="groups">Set of CollisionGroups; each group will have its CollisionRule with the first group defined.</param>
/// <param name="rule">CollisionRule to use between the pairs.</param>
public static void DefineCollisionRulesWithSet(CollisionGroup group, List<CollisionGroup> groups, CollisionRule rule)
{
foreach (CollisionGroup g in groups)
{
DefineCollisionRule(group, g, rule);
}
}
//Equals is not overriden because the hashcode because the hashcode is the default hashcode, just modified a bit.
/// <summary>
/// Defines the CollisionRule between the two groups for a given space.
/// </summary>
/// <param name="groupA">First CollisionGroup of the pair.</param>
/// <param name="groupB">Second CollisionGroup of the pair.</param>
/// <param name="rule">CollisionRule to use between the pair.</param>
public static void DefineCollisionRule(CollisionGroup groupA, CollisionGroup groupB, CollisionRule rule)
{
var pair = new CollisionGroupPair(groupA, groupB);
if (CollisionRules.CollisionGroupRules.ContainsKey(pair))
CollisionRules.CollisionGroupRules[pair] = rule;
else
CollisionRules.CollisionGroupRules.Add(pair, rule);
}
public ActorManager(ObservableCollection<PlayerView> players)
{
mContentLoader = new ContentManager(SharedResources.Game.Services, "Content");
mCueSounds = new List<Cue>();
mCueSoundsDelete = new List<Cue>();
mPlayers = players;
mActors = new Dictionary<int, Actor>();
WorldBounds = new BoundingBox(Vector3.Zero, Vector3.One);
SimSpace = new Space();
SimSpace.ForceUpdater.Gravity = new BEPUutilities.Vector3(0.0f, -89.2f, 0.0f); // 9 units = 1 meter?
CharactersCollisionGroup = new CollisionGroup();
PickupsCollisionGroup = new CollisionGroup();
CollisionGroup.DefineCollisionRule(CharactersCollisionGroup, PickupsCollisionGroup, CollisionRule.NoSolver);
Random = new Random();
mTemplates = new Dictionary<string, ActorManifest>();
CameraClippingSimObjects = new HashSet<int>();
CollisionComponent.CollisionComponentInitialized += CollisionComponentInitializedHandler;
CurrentTime = TimeSpan.Zero;
}
public Projectile(long _uniqueID, Vector3 _position, Quaternion _rotation, String _model)
: base(_uniqueID, _position, _rotation, _model)
{
ttl = TTL;
Damage = 1.0f;
Active = false;
if (!collisionSet)
{
projectileGroup = new CollisionGroup();
CollisionGroupPair pair = new CollisionGroupPair(projectileGroup, projectileGroup);
CollisionRules.CollisionGroupRules.Add(pair, CollisionRule.NoBroadPhase);
esxolusProjectileGroup = new CollisionGroup();
CollisionGroupPair pairEP = new CollisionGroupPair(esxolusProjectileGroup, projectileGroup);
CollisionRules.CollisionGroupRules.Add(pairEP, CollisionRule.NoBroadPhase);
CollisionGroupPair pairEE = new CollisionGroupPair(esxolusProjectileGroup, esxolusProjectileGroup);
CollisionRules.CollisionGroupRules.Add(pairEE, CollisionRule.NoBroadPhase);
CollisionGroupPair pairEES = new CollisionGroupPair(esxolusProjectileGroup, Ship.EsxolusShipGroup);
CollisionRules.CollisionGroupRules.Add(pairEES, CollisionRule.NoBroadPhase);
CollisionGroupPair pairEESM = new CollisionGroupPair(esxolusProjectileGroup, Ship.EsxolusMeshShipGroup);
CollisionRules.CollisionGroupRules.Add(pairEESM, CollisionRule.NoBroadPhase);
halkProjectileGroup = new CollisionGroup();
CollisionGroupPair pairHP = new CollisionGroupPair(halkProjectileGroup, projectileGroup);
CollisionRules.CollisionGroupRules.Add(pairHP, CollisionRule.NoBroadPhase);
CollisionGroupPair pairHH = new CollisionGroupPair(halkProjectileGroup, halkProjectileGroup);
CollisionRules.CollisionGroupRules.Add(pairHH, CollisionRule.NoBroadPhase);
CollisionGroupPair pairHHS = new CollisionGroupPair(halkProjectileGroup, Ship.HalkShipGroup);
CollisionRules.CollisionGroupRules.Add(pairHHS, CollisionRule.NoBroadPhase);
CollisionGroupPair pairHHSM = new CollisionGroupPair(halkProjectileGroup, Ship.HalkMeshShipGroup);
CollisionRules.CollisionGroupRules.Add(pairHHSM, CollisionRule.NoBroadPhase);
CollisionGroupPair pairEH = new CollisionGroupPair(esxolusProjectileGroup, halkProjectileGroup);
CollisionRules.CollisionGroupRules.Add(pairEH, CollisionRule.NoBroadPhase);
collisionSet = true;
}
else { }
}
public PhysicsEntity(Region tregion, bool ticks, bool cast_shadows)
: base(tregion, ticks, cast_shadows)
{
Gravity = new Location(TheRegion.PhysicsWorld.ForceUpdater.Gravity);
CGroup = CollisionUtil.Solid;
}
public bool ApplyPhysicsNetworkData(byte[] dat)
{
if (dat.Length < PhysicsNetworkDataLength)
{
return false;
}
SetMass(Utilities.BytesToFloat(Utilities.BytesPartial(dat, 0, 4)));
SetPosition(Location.FromDoubleBytes(dat, 4));
SetVelocity(Location.FromDoubleBytes(dat, 4 + 24));
SetOrientation(Utilities.BytesToQuaternion(dat, 4 + 24 + 24));
SetAngularVelocity(Location.FromDoubleBytes(dat, 4 + 24 + 24 + 16));
SetFriction(Utilities.BytesToFloat(Utilities.BytesPartial(dat, 4 + 24 + 24 + 16 + 24, 4)));
SetBounciness(Utilities.BytesToFloat(Utilities.BytesPartial(dat, 4 + 24 + 24 + 16 + 24 + 4, 4)));
// TODO: Proper flags thingy here?
byte fl = dat[4 + 24 + 24 + 16 + 24 + 4 + 4];
Visible = (fl & 1) == 1;
GenBlockShadows = (fl & 2) == 2;
byte cg = dat[4 + 24 + 24 + 16 + 24 + 4 + 4 + 1];
if (cg == 2)
{
CGroup = CollisionUtil.Solid;
}
else if (cg == 4)
{
CGroup = CollisionUtil.NonSolid;
}
else if (cg == (2 | 4))
{
CGroup = CollisionUtil.Item;
}
else if (cg == 8)
{
CGroup = CollisionUtil.Player;
}
else if (cg == (2 | 8))
{
CGroup = CollisionUtil.Water;
}
else if (cg == (2 | 4 | 8))
{
CGroup = CollisionUtil.WorldSolid;
}
else // if (cg == 16)
{
CGroup = CollisionUtil.Player;
}
return true;
}
/// <summary>
/// Removes any rule between the two groups in the space.
/// </summary>
/// <param name="groupA">First CollisionGroup of the pair.</param>
/// <param name="groupB">SecondCollisionGroup of the pair.</param>
public static void RemoveCollisionRule(CollisionGroup groupA, CollisionGroup groupB)
{
Dictionary<CollisionGroupPair, CollisionRule> dictionary = CollisionRules.CollisionGroupRules;
var pair = new CollisionGroupPair(groupA, groupB);
if (dictionary.ContainsKey(pair))
dictionary.Remove(pair);
}
/// <summary>
/// Removes any rule between a group and every group in a set of groups for a given space.
/// </summary>
/// <param name="group">First CollisionGroup of the pair.</param>
/// <param name="groups">Set of CollisionGroups; each group will have its CollisionRule with the first group removed.</param>
public static void RemoveCollisionRulesWithSet(CollisionGroup group, List<CollisionGroup> groups)
{
foreach (CollisionGroup g in groups)
{
RemoveCollisionRule(group, g);
}
}
private void setupCollisionGroups()
{
playerGroup = new CollisionGroup();
wallGroup = new CollisionGroup();
missileGroup = new CollisionGroup();
heavyAIGroup = new CollisionGroup();
normalAIGroup = new CollisionGroup();
platformGroup = new CollisionGroup();
//for player
playerNormalAIPair = new CollisionGroupPair(playerGroup, normalAIGroup);
playerHeavyAIPair = new CollisionGroupPair(playerGroup, heavyAIGroup);
playerMissilePair = new CollisionGroupPair(playerGroup, missileGroup);
//NOTE: comment this line out if the player should collide with that enemy type
CollisionRules.CollisionGroupRules.Add(playerNormalAIPair, CollisionRule.NoBroadPhase);
CollisionRules.CollisionGroupRules.Add(playerHeavyAIPair, CollisionRule.NoBroadPhase);
CollisionRules.CollisionGroupRules.Add(playerMissilePair, CollisionRule.Normal);
//for missile
CollisionRules.CollisionGroupRules.Add(new CollisionGroupPair(missileGroup, normalAIGroup), CollisionRule.NoBroadPhase);
CollisionRules.CollisionGroupRules.Add(new CollisionGroupPair(missileGroup, heavyAIGroup), CollisionRule.NoBroadPhase);
CollisionRules.CollisionGroupRules.Add(new CollisionGroupPair(missileGroup, platformGroup), CollisionRule.NoBroadPhase);
//for enemies
CollisionRules.CollisionGroupRules.Add(new CollisionGroupPair(normalAIGroup, normalAIGroup), CollisionRule.NoBroadPhase);
CollisionRules.CollisionGroupRules.Add(new CollisionGroupPair(normalAIGroup, heavyAIGroup), CollisionRule.NoBroadPhase);
CollisionRules.CollisionGroupRules.Add(new CollisionGroupPair(heavyAIGroup, heavyAIGroup), CollisionRule.NoBroadPhase);
CollisionRules.CollisionGroupRules.Add(new CollisionGroupPair(platformGroup, heavyAIGroup), CollisionRule.NoBroadPhase);
//for wall
CollisionRules.CollisionGroupRules.Add(new CollisionGroupPair(wallGroup, normalAIGroup), CollisionRule.NoBroadPhase);
CollisionRules.CollisionGroupRules.Add(new CollisionGroupPair(wallGroup, heavyAIGroup), CollisionRule.NoBroadPhase);
CollisionRules.CollisionGroupRules.Add(new CollisionGroupPair(wallGroup, missileGroup), CollisionRule.NoBroadPhase);
}
public static bool EnemyRayFilter(CollisionGroup g)
{
if (g == missileGroup ||
g == heavyAIGroup ||
g == normalAIGroup ||
g == wallGroup ||
g == playerGroup ||
g == platformGroup)
return false;
return true;
}
public void ApplyPhysicsData(BsonDocument doc)
{
if (doc.ContainsKey("ph_pos"))
{
SetPosition(Location.FromDoubleBytes(doc["ph_pos"].AsBinary, 0));
}
if (doc.ContainsKey("ph_vel"))
{
SetVelocity(Location.FromDoubleBytes(doc["ph_vel"].AsBinary, 0));
}
if (doc.ContainsKey("ph_avel"))
{
SetAngularVelocity(Location.FromDoubleBytes(doc["ph_avel"].AsBinary, 0));
}
if (doc.ContainsKey("ph_ang_x") && doc.ContainsKey("ph_ang_y") && doc.ContainsKey("ph_ang_z") && doc.ContainsKey("ph_ang_w"))
{
double ax = (double)doc["ph_ang_x"].AsDouble;
double ay = (double)doc["ph_ang_y"].AsDouble;
double az = (double)doc["ph_ang_z"].AsDouble;
double aw = (double)doc["ph_ang_w"].AsDouble;
SetOrientation(new Quaternion(ax, ay, az, aw));
}
if (doc.ContainsKey("ph_grav"))
{
SetGravity(Location.FromDoubleBytes(doc["ph_grav"].AsBinary, 0));
}
if (doc.ContainsKey("ph_bounce"))
{
SetBounciness((double)doc["ph_bounce"].AsDouble);
}
if (doc.ContainsKey("ph_frict"))
{
SetFriction((double)doc["ph_frict"].AsDouble);
}
if (doc.ContainsKey("ph_mass"))
{
SetMass((double)doc["ph_mass"].AsDouble);
}
if (doc.ContainsKey("ph_cg"))
{
int cg = doc["ph_cg"].AsInt32;
if (cg == 0)
{
CGroup = CollisionUtil.NonSolid;
}
else if (cg == 1)
{
CGroup = CollisionUtil.Solid;
}
else if (cg == 2)
{
CGroup = CollisionUtil.Player;
}
else if (cg == 3)
{
CGroup = CollisionUtil.Item;
}
else // cg == 4
{
CGroup = CollisionUtil.Water;
}
}
if (doc.ContainsKey("ph_flag"))
{
int flags = doc["ph_flag"].AsInt32;
Visible = (flags & 1) == 1;
GenBlockShadow = (flags & 2) == 2;
TransmitMe = (flags & 128) == 128;
}
}
public Game1()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
physics = new Space();
if (Environment.ProcessorCount > 1)
{
for (int i = 0; i < 10 * Environment.ProcessorCount; ++i)
{
physics.ThreadManager.AddThread();
}
}
physics.ForceUpdater.Gravity = new Vector3(0, -140, 0);
physics.TimeStepSettings.MaximumTimeStepsPerFrame = 10;
Services.AddService(typeof(Space), physics);
rand = new Random();
guyCollisionGroup = new CollisionGroup();
punchCollisionGroup = new CollisionGroup();
CollisionRules.CollisionGroupRules.Add(new CollisionGroupPair(punchCollisionGroup, guyCollisionGroup), CollisionRule.NoSolver);
}
