public static TimeSpan TimeForGetLayers(int iterations, IEnumerable <int> layersToCheck = null)
{
var layerMasking = new LayerMasker(POSSIBLE_LAYERS.Length);
var stopwatch = new Stopwatch();
int[] layers = layersToCheck == null ? new int[] { 0, 2, 5 } : layersToCheck.ToArray();
uint mask = layerMasking.Mask(layers);
// For caching
int myLayer;
foreach (var i in layerMasking.Layers(mask))
{
myLayer = i;
}
stopwatch.Start();
for (int it = 0; it < iterations; it++)
{
foreach (var i in layerMasking.Layers(mask))
{
myLayer = i;
}
}
stopwatch.Stop();
return(stopwatch.Elapsed);
}
/// <summary>
/// Adds the given entity (non-terrain object) to its recorded location, removing it from the map it is currently a part of. Returns true if the
/// entity was added, and false otherwise (eg., collision detection would not allow it, etc.)
/// </summary>
/// <param name="entity">Entity to add.</param>
/// <returns>True if the entity was successfully added to the map, false otherwise.</returns>
public bool AddEntity(IGameObject entity)
{
if (entity.CurrentMap == this)
{
return(false);
}
if (entity.Layer < 1)
{
return(false);
}
if (!entity.IsWalkable && (!LayerMasker.HasLayer(LayersBlockingWalkability, entity.Layer) || !WalkabilityView[entity.Position]))
{
return(false);
}
if (!entity.IsTransparent && !LayerMasker.HasLayer(LayersBlockingTransparency, entity.Layer))
{
return(false);
}
if (!_entities.Add(entity, entity.Position))
{
return(false);
}
entity.CurrentMap?.RemoveEntity(entity);
entity.OnMapChanged(this);
return(true);
}
public void Mask()
{
var masker = new LayerMasker();
var mask = masker.Mask(0, 2, 5);
Assert.Equal((uint)37, mask);
mask = masker.Mask(31);
Assert.Equal(2147483648, mask);
mask = masker.Mask(Enumerable.Range(0, 32));
Assert.Equal(uint.MaxValue, masker.AllLayers);
Assert.Equal(masker.AllLayers, mask);
mask = masker.NoLayers;
Assert.Equal((uint)0, mask);
masker = new LayerMasker(3);
mask = masker.Mask(0, 2, 5);
Assert.Equal((uint)5, mask); // 5 should be excluded since only 3 layers
mask = masker.Mask(Enumerable.Range(0, 32));
Assert.Equal((uint)7, masker.AllLayers);
Assert.Equal(masker.AllLayers, mask); // All layers that don't exist are ignored
}
static void Main(string[] args)
{
WindowUtilities.OpenWindow();
LayerMasker mask = new LayerMasker(3);
Level testLevel = new Level(96, 96, 2, mask.Mask((int)LayerNames.ITEMS));
LevelRenderer levelRenderer = new LevelRenderer(testLevel);
Entity player = new Entity();
DisplayInfo d = new DisplayInfo(player, '@', Color.White);
player.AddComponent(d);
ToolQualities t = new ToolQualities();
player.AddComponent(t);
testLevel.EnterLevel(player);
Entity tree = new Entity();
tree.AddComponent(new DisplayInfo(tree, '|', Color.ForestGreen));
tree.AddComponent(new Tree(tree));
testLevel.Add(tree, (4, 4));
Globals.AddPanel(levelRenderer);
MessageLog.AddMessage("Press ? for help");
while (true)
{
Terminal.Clear();
Globals.DrawAndInput();
Terminal.Refresh();
}
}
public void MaskAllBelow()
{
var masker = new LayerMasker();
var mask = masker.MaskAllBelow(3);
Assert.Equal((uint)15, mask);
mask = masker.MaskAllBelow(7);
Assert.Equal((uint)255, mask);
mask = masker.MaskAllBelow(0);
Assert.Equal((uint)1, mask);
mask = masker.MaskAllBelow(31);
Assert.Equal(uint.MaxValue, mask);
masker = new LayerMasker(3);
mask = masker.MaskAllBelow(2);
Assert.Equal(masker.AllLayers, mask);
Assert.Equal((uint)7, masker.AllLayers);
mask = masker.MaskAllBelow(1);
Assert.Equal((uint)3, mask);
mask = masker.MaskAllBelow(31);
Assert.Equal((uint)7, masker.AllLayers);
Assert.Equal(masker.AllLayers, mask); // Layers should be ignored that don't exist
}
public void GetLayers()
{
var masker = new LayerMasker();
int[] layers = { 0, 2, 5 };
var mask = masker.Mask(layers);
var layerReturn = masker.Layers(mask).ToEnumerable().ToArray();
layers = layers.OrderByDescending(i => i).ToArray();
_output.WriteLine("Actual layers");
_output.WriteLine(layers.ExtendToString());
_output.WriteLine("Returned layers:");
_output.WriteLine(layerReturn.ExtendToString());
Assert.Equal(layers.Length, layerReturn.Length);
for (var i = 0; i < layers.Length; i++)
{
Assert.Equal(layers[i], layerReturn[i]);
}
masker = new LayerMasker(3);
layerReturn = masker.Layers(mask).ToEnumerable().ToArray();
layers = layers.OrderByDescending(i => i).Where(i => i < 3).ToArray();
Assert.Equal(layers.Length, layerReturn.Length);
for (var i = 0; i < layers.Length; i++)
{
Assert.Equal(layers[i], layerReturn[i]);
}
}
public void MaskAllAbove()
{
var masker = new LayerMasker();
var mask = masker.MaskAllAbove(3);
Assert.Equal(uint.MaxValue - 7, mask);
mask = masker.MaskAllAbove(8);
Assert.Equal(uint.MaxValue - 255, mask);
mask = masker.MaskAllAbove(0);
Assert.Equal(uint.MaxValue, mask);
mask = masker.MaskAllAbove(31);
Assert.Equal(2147483648, mask);
masker = new LayerMasker(3);
mask = masker.MaskAllAbove(2);
Assert.Equal((uint)4, mask);
mask = masker.MaskAllAbove(1);
Assert.Equal((uint)6, mask);
mask = masker.MaskAllAbove(3);
Assert.Equal((uint)0, mask); // Layers should be ignored that don't exist
}
public void Layers()
{
var masker = new LayerMasker();
int[] layers = new int[] { 0, 2, 5 };
var mask = masker.Mask(layers);
var layerReturn = masker.Layers(mask).ToArray();
layers = layers.OrderByDescending(i => i).ToArray();
Console.WriteLine("Actual layers");
Console.WriteLine(layers.ExtendToString());
Console.WriteLine("Returned layers:");
Console.WriteLine(layerReturn.ExtendToString());
Assert.AreEqual(layers.Length, layerReturn.Length);
for (int i = 0; i < layers.Length; i++)
{
Assert.AreEqual(layers[i], layerReturn[i]);
}
masker = new LayerMasker(3);
layerReturn = masker.Layers(mask).ToArray();
layers = layers.OrderByDescending(i => i).Where(i => i < 3).ToArray();
Assert.AreEqual(layers.Length, layerReturn.Length);
for (int i = 0; i < layers.Length; i++)
{
Assert.AreEqual(layers[i], layerReturn[i]);
}
}
/// <summary>
/// Gets all objects encountered at the given position, in order from the highest existing layer in the layer mask downward. Layer mask defaults
/// to all layers.
/// </summary>
/// <param name="x">X-value of the position to get objects for.</param>
/// <param name="y">Y-value of the position to get objects for.</param>
/// <param name="layerMask">Layer mask for which layers can return an object. Defaults to all layers.</param>
/// <returns>All objects encountered at the given position, in order from the highest existing layer in the mask downward.</returns>
public IEnumerable <IGameObject> GetObjects(int x, int y, uint layerMask = uint.MaxValue)
{
foreach (var entity in _entities.GetItems(x, y, layerMask))
{
yield return(entity);
}
if (LayerMasker.HasLayer(layerMask, 0) && _terrain[x, y] != null)
{
yield return(_terrain[x, y]);
}
}
public void GlobalSetup()
{
_masker = new LayerMasker(NumberOfLayers);
_allMask = _halfMask = 0;
for (int i = 0; i < NumberOfLayers; i++)
{
_allMask = _masker.AddLayers(_allMask, i);
if (i % 2 == 0)
{
_halfMask = _masker.AddLayers(_halfMask, i);
}
}
}
/// <summary>
/// Gets all objects encountered at the given position that are castable to type ObjectType, in order from the highest existing layer in the layer
/// mask downward. Layer mask defaults to all layers.
/// </summary>
/// <typeparam name="ObjectType">Type of objects to return.</typeparam>
/// <param name="x">X-value of the position to get objects for.</param>
/// <param name="y">Y-value of the position to get objects for.</param>
/// <param name="layerMask">Layer mask for which layers can return an object. Defaults to all layers.</param>
/// <returns>All objects encountered at the given position that are castable to the given type, in order from the highest existing layer
/// in the mask downward.</returns>
public IEnumerable <ObjectType> GetObjects <ObjectType>(int x, int y, uint layerMask = uint.MaxValue) where ObjectType : class, IGameObject
{
foreach (var entity in _entities.GetItems(x, y, layerMask))
{
if (entity is ObjectType e)
{
yield return(e);
}
}
if (LayerMasker.HasLayer(layerMask, 0) && _terrain[x, y] is ObjectType t)
{
yield return(t);
}
}
private void Paint(Vector3 loc, Color c)
{
RaycastHit hit;
Vector3 dir = transform.TransformDirection(UnityEngine.Random.onUnitSphere * .1f);
// Avoid raycast backward as we're in a 2D space
if (dir.z < 0)
{
dir.z = UnityEngine.Random.Range(0f, 1f);
}
// Raycast around the position to splash everwhere we can
int ground = LayerMasker.GetLayerMask(Layers.Ground);
int blood = LayerMasker.GetLayerMask(Layers.Blood);
if (Physics.Raycast(loc, dir, out hit, 1.5f, ground) &&
Physics.OverlapSphereNonAlloc(hit.point, 0.2f, null, blood) < 3)
{
PaintDecal(hit, c);
}
}
private void EmitDirectionalBlood(DamagePack pack)
{
// Determine Position to emit blood from:
Vector3 position = pack.damaged.owner.position;
RaycastHit hit;
if (Physics.Raycast(position, Vector3.down, out hit, 5F, LayerMasker.GetLayerMask(Layers.Ground)))
{
position = hit.point;
}
else
{
// We'll set the 'y' to zero which should be near the floor...
position.y = 0;
}
// Obtain lateral impact direction
Vector3 impactDir = pack.damager.impactDirection;
Vector2 projectileDir = new Vector2(impactDir.x, impactDir.z);
// Queue Up Blood with the GoreManager
//GoreManager.Instance.QueueSplat(position, projectileDir);
}
public void AddLayer()
{
var masker = new LayerMasker();
var mask = masker.Mask(0); // First layer;
mask = masker.AddLayers(mask, 3);
Assert.Equal(masker.Mask(0, 3), mask);
mask = masker.AddLayers(mask, 31);
Assert.Equal(masker.Mask(0, 3, 31), mask);
masker = new LayerMasker(2);
mask = masker.Mask(1);
mask = masker.AddLayers(mask, 0);
Assert.Equal(masker.Mask(1, 0), mask);
mask = masker.AddLayers(mask, 3); // Out of range
Assert.Equal(masker.Mask(0, 1), mask); // Should be same since we added a layer out of range
mask = masker.AddLayers(mask, 31); // Out of range
Assert.Equal(masker.Mask(0, 1), mask); // Should be same since we added a layer out of range
}
