/// <summary>
/// Add a collision behavior.
/// </summary>
/// <param name="behavior">Behavior to add.</param>
public void AddCollisionBehavior(CollisionBehavior behavior)
{
if (!HasCollisionBehavior(behavior))
{
collisionModes.Add(behavior);
}
}
public void CanApplyCollisionForce()
{
NativeArray <AgentKinematics> agents = new NativeArray <AgentKinematics>(1, Allocator.Persistent);
NativeArray <float3> steering = new NativeArray <float3>(1, Allocator.Persistent);
NativeArray <int> agentMovementTypes = new NativeArray <int>(1, Allocator.Persistent);
NativeArray <AgentMovement> movementTypes = new NativeArray <AgentMovement>(1, Allocator.Persistent);
movementTypes[0] = new AgentMovement()
{
mass = 1f, topSpeed = 1f, turnSpeed = 1f
};
int height = 1;
CollisionBehavior job = new CollisionBehavior()
{
minDistance = 0.01f,
movement = agentMovementTypes,
movementConfigs = movementTypes,
collision = new AgentCollision()
{
radius = 0.5f, height = height
},
steering = steering,
agents = agents,
};
/// test no steering forces are applied
/// when the target and source are the same
SpatialMapData target = new SpatialMapData()
{
position = float3.zero, height = height
};
job.ApplyCollisionForce(0, target);
Assert.AreEqual(float3.zero, steering[0]);
steering[0] = float3.zero;
/// test steering forces can be applied
/// when the agents are within collision distance
target = new SpatialMapData()
{
mass = 1f, radius = 0.5f,
position = new float3(1f, 0, 0),
height = height
};
job.ApplyCollisionForce(0, target);
Assert.AreEqual(new float3(-1f, 0, 0), steering[0]);
agents.Dispose();
steering.Dispose();
movementTypes.Dispose();
agentMovementTypes.Dispose();
}
public bool IsPhasing; //Used for Blinking? maybe deal damage to self if stuck in enemy to discourage it
public CollisionComponent(CollisionBehavior behavior = CollisionBehavior.Block, AABB collisionRectangle = new AABB(), Vector2 offset = new Vector2(), bool isWall = false, bool isPhysical = false)
{
Behavior = behavior;
SetIsPhysical();
CollisionRectangle = collisionRectangle;
Offset = offset;
IsWall = isWall;
IsPhysical = isPhysical;
}
public Entity(State _state, Texture2D _image, string _tag = "Entity [Default]",
Vector2?_pos = null, float _size = 0.0f,
float _rotation = 0f, ScrollBehavior _scroll = ScrollBehavior.Wrap,
CollisionBehavior _collision = CollisionBehavior.Null,
bool _enabled = false, bool _visible = false,
bool _drawGUI = false, ControlScheme _schema = null,
ColorSet _set = null)
{
Initialize(_state, _image, _tag, _pos, _size, _rotation, _set, _scroll, _collision, _enabled, _visible, _drawGUI, _schema);
}
/// <summary>
/// Determines if this entity has the specified collision behavior.
/// </summary>
/// <param name="behavior">Behavior to check for.</param>
/// <returns>Returns true if behavior is included in collisionModes.</returns>
public bool HasCollisionBehavior(CollisionBehavior behavior)
{
foreach (CollisionBehavior mode in collisionModes)
{
if (behavior == mode)
{
return(true);
}
}
return(false);
}
public void CanCheckForCollisions()
{
int height = 1;
float radius = 1f;
float3 start = new float3(0.25f, 0, 0);
AgentKinematics self = new AgentKinematics()
{
position = float3.zero
};
SpatialMapData target = new SpatialMapData()
{
position = start, height = height
};
CollisionBehavior job = new CollisionBehavior()
{
minDistance = 0.01f,
collision = new AgentCollision()
{
radius = radius, height = height
}
};
/// test 2D circle intersection
bool result;
result = job.Collision(self, target);
Assert.AreEqual(true, result); // inside
target.position += new float3(0.25f, 0, 0);
result = job.Collision(self, target);
Assert.AreEqual(true, result); // on the edge
target.position += new float3(1f, 0, 0);
result = job.Collision(self, target);
Assert.AreEqual(false, result); // outside
/// test height intersection
target.position = new float3(0, 0.5f, 0);
result = job.Collision(self, target);
Assert.AreEqual(true, result); // inside (collision)
target.position = new float3(0, 1f, 0);
result = job.Collision(self, target);
Assert.AreEqual(false, result); // above (no collision)
target.position = new float3(0, -1f, 0);
result = job.Collision(self, target);
Assert.AreEqual(false, result); // below (no collision)
}
private void Awake()
{
if (Instance)
{
Destroy(this);
return;
}
Instance = this;
spawnPos = transform.position;
movement = GetComponent <Movement>();
gravity = GetComponent <Gravity>();
colBehavior = GetComponent <CollisionBehavior>();
col = GetComponent <Collider2D>();
rend = GetComponent <SpriteRenderer>();
trail = GetComponent <TrailRenderer>();
deadDetection = GetComponent <DeadDetection>();
}
protected void Initialize(State _state,
Texture2D _image, string _tag = "Entity [Default]",
Vector2?_pos = null, float _size = 0.0f,
float _rotation = 0f, ColorSet _set = null,
ScrollBehavior _scroll = ScrollBehavior.Wrap,
CollisionBehavior _collision = CollisionBehavior.Null,
bool _enabled = false, bool _visible = false,
bool _drawGUI = false, ControlScheme _schema = null)
{
SetState(_state); // Store the current state.
SetImage(_image); // File the image to draw with.
SetTag(_tag); // Add a tag for the element.
SetColorSet(_set); // Set the colors we'd like to use.
SetDimensions(_size); // By default, base the size off of the image's picture.
SetRotation(_rotation); // By default this will be 0, but, we can customize on creation. Useful for spawning.
SetScrollModes(_scroll); // Wrap entity by default.
SetCollisionModes(_collision); // Do not collide by default.
SetFlags(_enabled, _visible); // Set these flags up by default.
CreateControlScheme(_schema);
}
public static List<ICommand> GetDiffCommands(string sourcePath, string targetPath, CollisionBehavior collisionBehavior = CollisionBehavior.Undefined)
{
var targetManager = Factory.Instance.GetSourceDataManager();
var sourceManager = Factory.Instance.GetTargetDataManager();
sourceManager.SerializationPath = sourcePath;
targetManager.SerializationPath = targetPath;
IDataIterator sourceDataIterator = sourceManager.ItemIterator;
IDataIterator targetDataIterator = targetManager.ItemIterator;
var engine = new DataEngine();
var commands = new List<ICommand>();
commands.AddRange(GenerateDiff(sourceDataIterator, targetDataIterator));
//if an item is found to be deleted AND added, we can be sure it's a move
var deleteCommands = commands.OfType<DeleteItemCommand>();
var shouldBeUpdateCommands =
commands.OfType<AddItemCommand>()
.Select(a => new
{
Added = a,
Deleted = deleteCommands.FirstOrDefault(d => d.ItemID == a.ItemID)
}).Where(u => u.Deleted != null).ToList();
foreach (var command in shouldBeUpdateCommands)
{
commands.AddRange(command.Deleted.GenerateUpdateCommand(command.Added));
commands.Remove(command.Added);
commands.Remove(command.Deleted);
//now, this one is an assumption, but would go wrong without the assumption anyway: this assumption is in fact safer
//if the itempath of a delete command starts with this delete command, it will be moved along to the new node, not deleted, just leave it alone
commands.RemoveAll(c => c is DeleteItemCommand && ((DeleteItemCommand)c).ItemPath.StartsWith(command.Deleted.ItemPath));
}
commands.ForEach(_ => _.CollisionBehavior = collisionBehavior);
engine.ProcessCommands(ref commands);
return commands;
}
public VelocityModifier(Vector2 modifier, CollisionBehavior behavior, float parameter = 1.0f)
{
this.Modifier = modifier;
this.Behavior = behavior;
this.Parameter = parameter;
}
public static List <ICommand> GetDiffCommands(HashSet <string> targetItemIDs, CollisionBehavior collisionBehavior,
IDataIterator sourceDataIterator, IDataIterator targetDataIterator, DataEngine engine)
{
var commands = new List <ICommand>();
commands.AddRange(GenerateDiff(sourceDataIterator, targetDataIterator));
//if an item is found to be deleted AND added, we can be sure it's a move
var deleteCommands = commands.OfType <DeleteItemCommand>();
var shouldBeUpdateCommands =
commands.OfType <AddItemCommand>()
.Select(a => new
{
Added = a,
Deleted = deleteCommands.FirstOrDefault(d => d.ItemID == a.ItemID)
}).Where(u => u.Deleted != null).ToList();
foreach (var command in shouldBeUpdateCommands)
{
commands.AddRange(command.Deleted.GenerateUpdateCommand(command.Added));
commands.Remove(command.Added);
commands.Remove(command.Deleted);
//now, this one is an assumption, but would go wrong without the assumption anyway: this assumption is in fact safer
//if the itempath of a delete command starts with this delete command, it will be moved along to the new node, not deleted, just leave it alone
//but we will skip items which are not in the target folder
commands.RemoveAll(c =>
c is DeleteItemCommand &&
((DeleteItemCommand)c).ItemPath.StartsWith(command.Deleted.ItemPath) &&
targetItemIDs.Contains(((DeleteItemCommand)c).ItemID));
}
commands.ForEach(_ => _.CollisionBehavior = collisionBehavior);
return(commands);
}
public VelocityModifier(Vector2 modifier, CollisionBehavior behavior)
{
this.Modifier = modifier;
this.Behavior = behavior;
}
public CollisionComponent()
{
_collisionBehavior = CollisionBehavior.None;
}
public static List <ICommand> GetDiffCommands(string sourcePath, string targetPath, CollisionBehavior collisionBehavior = CollisionBehavior.Undefined)
{
var targetManager = Factory.Instance.GetSourceDataManager();
var sourceManager = Factory.Instance.GetTargetDataManager();
sourceManager.SerializationPath = sourcePath;
targetManager.SerializationPath = targetPath;
IDataIterator sourceDataIterator = sourceManager.ItemIterator;
IDataIterator targetDataIterator = targetManager.ItemIterator;
var engine = new DataEngine();
var commands = new List <ICommand>();
commands.AddRange(GenerateDiff(sourceDataIterator, targetDataIterator));
//if an item is found to be deleted AND added, we can be sure it's a move
var deleteCommands = commands.OfType <DeleteItemCommand>();
var shouldBeUpdateCommands =
commands.OfType <AddItemCommand>()
.Select(a => new
{
Added = a,
Deleted = deleteCommands.FirstOrDefault(d => d.ItemID == a.ItemID)
}).Where(u => u.Deleted != null).ToList();
foreach (var command in shouldBeUpdateCommands)
{
commands.AddRange(command.Deleted.GenerateUpdateCommand(command.Added));
commands.Remove(command.Added);
commands.Remove(command.Deleted);
//now, this one is an assumption, but would go wrong without the assumption anyway: this assumption is in fact safer
//if the itempath of a delete command starts with this delete command, it will be moved along to the new node, not deleted, just leave it alone
commands.RemoveAll(c => c is DeleteItemCommand && ((DeleteItemCommand)c).ItemPath.StartsWith(command.Deleted.ItemPath));
}
commands.ForEach(_ => _.CollisionBehavior = collisionBehavior);
engine.ProcessCommands(ref commands);
return(commands);
}
public static List <ICommand> GetDiffCommands(string sourcePath, string targetPath, bool includeSecurity, string version, CollisionBehavior collisionBehavior = CollisionBehavior.Undefined)
{
IncludeSecurity = includeSecurity;
Version = version;
var sourceManager = Factory.Instance.GetSourceDataManager();
var targetManager = Factory.Instance.GetTargetDataManager();
sourceManager.SerializationPath = sourcePath;
targetManager.SerializationPath = targetPath;
IDataIterator sourceDataIterator = sourceManager.ItemIterator ?? new EmptyIterator();
IDataIterator targetDataIterator = targetManager.ItemIterator;
var commands = GetCommands(sourceDataIterator, targetDataIterator);
var engine = new DataEngine();
engine.ProcessCommands(ref commands);
return(commands);
}
public static List <ICommand> GetDiffCommands(string sourcePath, string targetPath, CollisionBehavior collisionBehavior = CollisionBehavior.Undefined)
{
var sourceManager = Factory.Instance.GetSourceDataManager();
var targetManager = Factory.Instance.GetTargetDataManager();
sourceManager.SerializationPath = sourcePath;
targetManager.SerializationPath = targetPath;
IDataIterator sourceDataIterator = sourceManager.ItemIterator ?? new EmptyIterator();
IDataIterator targetDataIterator = targetManager.ItemIterator;
var engine = new DataEngine();
var targetItemIDs = GetItemIDs(targetPath);
var commands = GetDiffCommands(targetItemIDs, collisionBehavior, sourceDataIterator, targetDataIterator, engine);
engine.ProcessCommands(ref commands);
return(commands);
}
public CollisionComponent()
{
_collisionBehavior = CollisionBehavior.None;
}
public VelocityModifier(Vector2 modifier, CollisionBehavior behavior)
{
this.Modifier = modifier;
this.Behavior = behavior;
}
