public void Add(FlxBasic objectOrGroup, int list)
{
_list = list;
FlxTypedGroup <FlxBasic> group = FlxTypedGroup <FlxBasic> .ResolveGroup(objectOrGroup);
if (group != null)
{
int i = 0;
FlxBasic basic;
List <FlxBasic> members = group.Members;
int l = group.Length;
while (i < l)
{
basic = members[i++];
if (basic != null && basic.Exists)
{
group = FlxTypedGroup <FlxBasic> .ResolveGroup(basic);
if (group != null)
{
Add(group, list);
}
else
{
_object = (FlxObject)basic;
if (_object.Exists && _object.AllowCollisions != FlxObjectDirection.NONE)
{
_objectLeftEdge = _object.X;
_objectTopEdge = _object.Y;
_objectRightEdge = _object.X + _object.Width;
_objectBottomEdge = _object.Y + _object.Height;
AddObject();
}
}
}
}
}
else
{
_object = (FlxObject)objectOrGroup;
if (_object.Exists && _object.AllowCollisions != FlxObjectDirection.NONE)
{
_objectLeftEdge = _object.X;
_objectTopEdge = _object.Y;
_objectRightEdge = _object.X + _object.Width;
_objectBottomEdge = _object.Y + _object.Height;
AddObject();
}
}
}
public void Load(FlxBasic objectOrGroup1, FlxBasic objectOrGroup2 = null, NotifyCallback notifyCallback = null, ProcessingCallback processingCallback = null)
{
Add(objectOrGroup1, A_LIST);
if (objectOrGroup2 != null)
{
Add(objectOrGroup2, B_LIST);
_useBothLists = true;
}
else
{
_useBothLists = false;
}
_notifyCallback = notifyCallback;
_processingCallback = processingCallback;
}
public FlxBasic Remove(FlxBasic plugin)
{
List.Remove(plugin);
return(plugin);
}
/// <summary>
/// Removes an instance of a plugin from the global plugin array.
/// </summary>
/// <param name="plugin">The plugin instance you want to remove.</param>
/// <returns>The same <code>FlxBasic</code>-based plugin you passed in.</returns>
public static FlxBasic removePlugin(FlxBasic plugin)
{
plugins.RemoveAll(existingPlugin => existingPlugin == plugin);
return plugin;
}
/// <summary>
/// Adds a new plugin to the global plugin array.
/// </summary>
/// <param name="plugin">Any object that extends FlxBasic. Useful for managers and other things. See org.flixel.plugin for some examples!</param>
/// <returns>The same <code>FlxBasic</code>-based plugin you passed in.</returns>
public static FlxBasic addPlugin(FlxBasic plugin)
{
// Don't add repeats
if (!plugins.Contains(plugin))
{
plugins.Add(plugin);
}
return plugin;
}
/// <summary>
/// Checks to see if this <code>FlxObject</code> were located at the given position, would it overlap the <code>FlxObject</code> or <code>FlxGroup</code>?
/// This is distinct from overlapsPoint(), which just checks that point, rather than taking the object's size into account.
/// WARNING: Currently tilemaps do NOT support screen space overlap checks!
/// </summary>
/// <param name="x">The X position you want to check. Pretends this object (the caller, not the parameter) is located here.</param>
/// <param name="y">The Y position you want to check. Pretends this object (the caller, not the parameter) is located here.</param>
/// <param name="objectOrGroup">The object or group being tested.</param>
/// <param name="inScreenSpace">Whether to take scroll factors into account when checking for overlap. Default is false, or "only compare in world space."</param>
/// <param name="camera">Specify which game camera you want. If null getScreenXY() will just grab the first global camera. flx# - currently only one exists</param>
/// <returns></returns>
public virtual bool overlapsAt(float x, float y, FlxBasic objectOrGroup, bool inScreenSpace = false, FlxCamera camera = null)
{
if (objectOrGroup is FlxGroup)
{
bool results = false;
var group = objectOrGroup as FlxGroup;
foreach (FlxBasic member in group.Members)
{
if (overlapsAt(x, y, member, inScreenSpace, camera))
{
results = true;
// flx# - we could break here, if overlaps does not trigger anything on the remaining members
}
}
/*
int i = 0;List<FlxBasic> members = new List<FlxBasic>();
members = (objectOrGroup as FlxGroup).members;
uint length = (uint)members.Count;
while (i < length)
{
if (overlapsAt(x, y, members[i++], inScreenSpace, camera))
results = true;
}
*/
return results;
}
if (objectOrGroup is FlxTilemap)
{
var tilemap = objectOrGroup as FlxTilemap;
return tilemap.overlapsAt(tilemap.X - (x - this.X), tilemap.Y - (y - this.Y), this, inScreenSpace, camera);
}
var flxObject = objectOrGroup as FlxObject;
if(!inScreenSpace)
{
return (flxObject.X + flxObject.Width > x) && (flxObject.X < x + Width) &&
(flxObject.Y + flxObject.Height > y) && (flxObject.Y < y + Height);
}
if (camera == null)
{
camera = FlxG.camera;
}
FlxPoint objectScreenPos = flxObject.getScreenXY(null, camera);
_tagPoint.X = x - camera.Scroll.X * ScrollFactor.X; //copied from getScreenXY()
_tagPoint.Y = y - camera.Scroll.Y * ScrollFactor.Y;
_tagPoint.X += (_tagPoint.X > 0) ? 0.0000001f : -0.0000001f;
_tagPoint.Y += (_tagPoint.Y > 0) ? 0.0000001f : -0.0000001f;
return (objectScreenPos.X + flxObject.Width > _tagPoint.X) && (objectScreenPos.X < _tagPoint.X + Width) &&
(objectScreenPos.Y + flxObject.Height > _tagPoint.Y) && (objectScreenPos.Y < _tagPoint.Y + Height);
}
/// <summary>
/// Checks to see if some <code>FlxObject</code> overlaps this <code>FlxObject</code> or <code>FlxGroup</code>.
/// If the group has a LOT of things in it, it might be faster to use <code>FlxG.overlaps()</code>.
/// WARNING: Currently tilemaps do NOT support screen space overlap checks!
/// </summary>
/// <param name="objectOrGroup">The object or group being tested.</param>
/// <param name="inScreenSpace">Whether to take scroll factors into account when checking for overlap. Default is false, or "only compare in world space."</param>
/// <param name="camera">Specify which game camera you want. If null getScreenXY() will just grab the first global camera. flx# - currently only one exists</param>
/// <returns></returns>
public virtual bool overlaps(FlxBasic objectOrGroup, bool inScreenSpace = false, FlxCamera camera = null)
{
if(objectOrGroup is FlxGroup)
{
bool results = false;
var group = objectOrGroup as FlxGroup;
foreach (FlxBasic member in group.Members)
{
if (overlaps(member, inScreenSpace, camera))
{
results = true;
// flx# - we could break here, if overlaps does not trigger anything on the remaining members
}
}
/*
int i = 0;
List<FlxBasic> members = new List<FlxBasic>();
members = (objectOrGroup as FlxGroup).members;
//uint l = (uint)(ObjectOrGroup as FlxGroup).length;
uint length = (uint)members.Count;
while(i < length)
{
if(overlaps(members[i++],inScreenSpace,camera))
results = true;
}
*/
return results;
}
if (objectOrGroup is FlxTilemap)
{
// Since tilemap's have to be the caller, not the target, to do proper tile-based collisions,
// we redirect the call to the tilemap overlap here.
return (objectOrGroup as FlxTilemap).overlaps(this, inScreenSpace, camera);
}
var flxObject = objectOrGroup as FlxObject;
if(!inScreenSpace)
{
return (flxObject.X + flxObject.Width > X) && (flxObject.X < X + Width) &&
(flxObject.Y + flxObject.Height > Y) && (flxObject.Y < Y + Height);
}
if (camera == null)
{
camera = FlxG.camera;
}
FlxPoint objectScreenPos = flxObject.getScreenXY(null, camera);
getScreenXY(_tagPoint, camera);
return (objectScreenPos.X + flxObject.Width > _tagPoint.X) && (objectScreenPos.X < _tagPoint.X + Width) &&
(objectScreenPos.Y + flxObject.Height > _tagPoint.Y) && (objectScreenPos.Y < _tagPoint.Y + Height);
}
// getData
// setDirty
// findPath
// simplifyPath
// raySimplifyPath
// computePathDistance
// walkPath
public override Boolean overlaps(FlxBasic objectOrGroup, Boolean inScreenSpace = false, FlxCamera camera = null)
{
if (objectOrGroup is FlxGroup)
{
Boolean results = false;
FlxBasic basic;
int i = 0;
List<FlxBasic> members = new List<FlxBasic>();
members = (objectOrGroup as FlxGroup).Members;
while (i < members.Count)
{
basic = members[i++] as FlxBasic;
if (basic is FlxObject)
{
if (overlapsWithCallback(basic as FlxObject))
results = true;
}
else
{
if (overlaps(basic, inScreenSpace, camera))
results = true;
}
}
return results;
}
else if (objectOrGroup is FlxObject)
{
return overlapsWithCallback(objectOrGroup as FlxObject);
}
return false;
}
public void load(FlxBasic ObjectOrGroup1, FlxBasic ObjectOrGroup2 = null, Func<FlxObject, FlxObject, Boolean> NotifyCallback = null, Func<FlxObject, FlxObject, Boolean> ProcessCallback = null)
{
add(ObjectOrGroup1, A_LIST);
if(ObjectOrGroup2 != null)
{
add(ObjectOrGroup2, B_LIST);
_useBothLists = true;
}
else
_useBothLists = false;
_notifyCallback = NotifyCallback;
_processingCallback = ProcessCallback;
}
public void add(FlxBasic ObjectOrGroup, uint List)
{
_list = List;
if(ObjectOrGroup is FlxGroup)
{
uint i = 0;
FlxBasic basic;
List<FlxBasic> members = new List<FlxBasic>();
members = (ObjectOrGroup as FlxGroup).Members;
uint l = (uint)members.Count;
while(i < l)
{
basic = members[(int)i++] as FlxBasic;
if((basic != null) && basic.Exists)
{
if(basic is FlxGroup)
add(basic,List);
else if(basic is FlxObject)
{
_object = basic as FlxObject;
if(_object.Exists && Convert.ToBoolean(_object.AllowCollisions))
{
_objectLeftEdge = _object.X;
_objectTopEdge = _object.Y;
_objectRightEdge = _object.X + _object.Width;
_objectBottomEdge = _object.Y + _object.Height;
addObject();
}
}
}
}
}
else
{
_object = ObjectOrGroup as FlxObject;
if(_object.Exists && Convert.ToBoolean(_object.AllowCollisions) )
{
_objectLeftEdge = _object.X;
_objectTopEdge = _object.Y;
_objectRightEdge = _object.X + _object.Width;
_objectBottomEdge = _object.Y + _object.Height;
addObject();
}
}
}
