void Start()
{
Sliceable2D slicer = GetComponent <Sliceable2D>();
if (slicer != null)
{
slicer.AddAnchorResultEvent(sliceEvent);
}
}
static public List <Merge2D> PolygonMergeAll(Polygon2D slicePolygon, Layer layer = null)
{
List <Merge2D> result = new List <Merge2D> ();
if (layer == null)
{
layer = Layer.Create();
}
foreach (Sliceable2D id in Sliceable2D.GetListLayer(layer))
{
result.Add(id.PolygonMerge(slicePolygon));
}
return(result);
}
private void CreatePolygon(Polygon2D newPolygon, Transform transform)
{
GameObject newGameObject = new GameObject();
newGameObject.transform.parent = transform;
newGameObject.transform.position = new Vector3(0, 0, visuals.zPosition + 0.01f);
newGameObject.AddComponent <Rigidbody2D> ();
newGameObject.AddComponent <ColliderLineRenderer2D> ().color = Color.black;
Sliceable2D smartSlicer = newGameObject.AddComponent <Sliceable2D> ();
smartSlicer.textureType = Sliceable2D.TextureType.Mesh2D;
smartSlicer.materialSettings.material = material;
newPolygon.CreatePolygonCollider(newGameObject);
newPolygon.CreateMesh(newGameObject, new Vector2(1, 1), Vector2.zero, PolygonTriangulator2D.Triangulation.Advanced);
}
void OnCollisionEnter2D(Collision2D collision)
{
if (collision.collider.name.Contains("Terrain"))
{
Vector2D pos = new Vector2D(transform.position);
Polygon2D.defaultCircleVerticesCount = 15;
Polygon2D slicePolygon = Polygon2D.Create(Polygon2D.PolygonType.Circle, 2f);
Polygon2D slicePolygonDestroy = Polygon2D.Create(Polygon2D.PolygonType.Circle, 2.5f);
slicePolygon = slicePolygon.ToOffset(pos);
slicePolygonDestroy = slicePolygonDestroy.ToOffset(pos);
foreach (Sliceable2D id in Sliceable2D.GetListCopy())
{
Slice2D result = Slicer2D.API.PolygonSlice(id.shape.GetLocal().ToWorldSpace(id.transform), slicePolygon);
if (result.GetPolygons().Count > 0)
{
foreach (Polygon2D p in new List <Polygon2D>(result.GetPolygons()))
{
if (slicePolygonDestroy.PolyInPoly(p) == true)
{
result.GetPolygons().Remove(p);
}
}
if (result.GetPolygons().Count > 0)
{
id.PerformResult(result.GetPolygons(), new Slice2D());
}
else
{
// Polygon is Destroyed!!!
Destroy(id.gameObject);
}
}
}
Destroy(gameObject);
Polygon2D.defaultCircleVerticesCount = 25;
}
}
Sliceable2D GetSlicerInZone()
{
foreach (Sliceable2D slicer in Sliceable2D.GetList())
{
if (slicer.limit.counter > 0)
{
continue;
}
if (Math2D.PolyCollidePoly(slicer.shape.GetWorld(), GetAIZone()) == false)
{
continue;
}
return(slicer);
}
return(null);
}
static public List <Merge2D> ComplexMergeAll(List <Vector2D> slice, Layer layer = null)
{
List <Merge2D> result = new List <Merge2D> ();
if (layer == null)
{
layer = Layer.Create();
}
foreach (Sliceable2D id in Sliceable2D.GetListLayer(layer))
{
Merge2D sliceResult = id.ComplexMerge(slice);
if (sliceResult.polygons.Count > 0)
{
result.Add(sliceResult);
}
}
return(result);
}
void OnGUI()
{
inspectorPosition = Vector3.zero;
Vector2D pos = new Vector2D(Camera.main.ScreenToWorldPoint(UnityEngine.Input.mousePosition));
foreach (Sliceable2D slicer in Sliceable2D.GetList())
{
Polygon2D poly = slicer.shape.GetWorld();
if (poly.PointInPoly(pos))
{
Rect rect = poly.GetBounds();
inspectorPosition = new Vector2(rect.center.x, rect.center.y + rect.height / 2);
originalSize = slicer.GetComponent <DemoSlicer2DInspectorTracker>().originalSize;
currentSize = poly.GetArea();
sliced = slicer.limit.counter;
}
}
if (Vector3.zero == inspectorPosition)
{
return;
}
Vector2 p = Camera.main.WorldToScreenPoint(inspectorPosition);
TextWithShadow(p.x, p.y, "Original Size: " + (int)originalSize + " (100%)");
inspectorPosition.y += 1;
p = Camera.main.WorldToScreenPoint(inspectorPosition);
float currentSizePercent = (float)System.Math.Round((currentSize / originalSize) * 100);
TextWithShadow(p.x, p.y, "Current Size: " + (int)currentSize + " (" + currentSizePercent + "%)");
inspectorPosition.y += 1;
p = Camera.main.WorldToScreenPoint(inspectorPosition);
TextWithShadow(p.x, p.y, "Sliced: " + sliced + " times");
}
public void CopyTracker(Slice2D slice, Sliceable2D slicer)
{
foreach (Slicer2DLinearTrackedController trackerComponent in Object.FindObjectsOfType <Slicer2DLinearTrackedController>())
{
if (trackerComponent.trackerObject == this)
{
continue;
}
Dictionary <Sliceable2D, Tracker.Object> list = new Dictionary <Sliceable2D, Tracker.Object>(trackerComponent.trackerObject.trackerList);
foreach (KeyValuePair <Sliceable2D, Tracker.Object> pair in list)
{
if (pair.Key != slicer)
{
continue;
}
foreach (GameObject g in slice.GetGameObjects())
{
Sliceable2D newSlicer = g.GetComponent <Sliceable2D>();
Tracker.Object t = null;
trackerList.TryGetValue(newSlicer, out t);
if (t == null)
{
t = new Tracker.Object();
t.firstPosition = pair.Value.firstPosition;
t.lastPosition = pair.Value.lastPosition;
t.tracking = true;
trackerComponent.trackerObject.trackerList.Add(newSlicer, t);
}
}
}
}
}
public List <Slice2D> Update(Vector2D position, float timer, Layer layer)
{
List <Slice2D> result = new List <Slice2D>();
foreach (Sliceable2D slicer in Sliceable2D.GetListCopy())
{
if (slicer.MatchLayers(layer) == false)
{
continue;
}
Trail.Object trail = null;
trailList.TryGetValue(slicer, out trail);
if (trail == null)
{
trail = new Trail.Object();
trailList.Add(slicer, trail);
}
if (trail.lastPosition != null)
{
if (Vector2D.Distance(trail.lastPosition, position) > 0.05f)
{
trail.pointsList.Insert(0, new Trail.Point(position, timer));
}
}
else
{
trail.pointsList.Insert(0, new Trail.Point(position, timer));
}
foreach (Trail.Point trailPoint in new List <Trail.Point>(trail.pointsList))
{
if (trailPoint.Update() == false)
{
trail.pointsList.Remove(trailPoint);
}
}
if (trail.pointsList.Count > 1)
{
Vector2D firstPoint = null;
Vector2D lastPoint = null;
bool insideState = false;
foreach (Trail.Point trailPoint in trail.pointsList)
{
bool inside = false;
if (slicer.shape.GetLocal().PointInPoly(trailPoint.position.InverseTransformPoint(slicer.transform)))
{
inside = true;
}
switch (insideState)
{
case true:
// Slice!
if (inside == false)
{
lastPoint = trailPoint.position;
insideState = false;
break;
}
break;
case false:
if (inside == false)
{
// Searching For Start of Slice
firstPoint = trailPoint.position;
insideState = true;
}
break;
}
if (lastPoint != null)
{
break;
}
}
if (firstPoint != null && lastPoint != null)
{
Sliceable2D.complexSliceType = Sliceable2D.SliceType.Regular;
Slice2D slice = slicer.LinearSlice(new Pair2D(firstPoint, lastPoint));
if (slice.GetGameObjects().Count > 0)
{
trailList.Remove(slicer);
result.Add(slice);
}
;
}
}
trail.lastPosition = position;
}
return(result);
}
void UpdateAI(int id)
{
if (controller.Playing(id))
{
return;
}
// Slicing the biggest object in the scene only
Sliceable2D biggestObject = GetSlicerInZone();
if (biggestObject != null)
{
controller.ClearActions(id);
Polygon2D poly = biggestObject.shape.GetWorld();
// Predict rigidbody movement
Rigidbody2D rb = biggestObject.GetComponent <Rigidbody2D>();
Vector2 pos = rb.position;
Vector2 gravity = Physics2D.gravity;
Vector2 force = rb.velocity;
// Get center of the object
Vector2 centerOffset = poly.GetBounds().center - pos;
float timer = 0;
while (timer < 0.25f)
{
float delta = 0.1f;
pos += force * delta;
force += gravity * delta;
timer += delta;
}
centerOffset += pos;
// Random slice rotation
double sliceRotation = Random.Range(0f, Mathf.PI * 2);
// Get bounds of an object to know the slice size
Rect bounds = poly.GetBounds();
float sliceSize = Mathf.Sqrt(bounds.width * bounds.width + bounds.height * bounds.height) * 1f;
Vector2D firstPoint = new Vector2D(centerOffset);
firstPoint.Push(sliceRotation, sliceSize);
Vector2D secondPoint = new Vector2D(centerOffset);
secondPoint.Push(sliceRotation, -sliceSize);
// How fast to perform actions?
float actionTime = 0.125f * 0.6f;
controller.SetMouse(firstPoint.ToVector2(), actionTime, id);
controller.PressMouse(actionTime, id);
controller.MoveMouse(secondPoint.ToVector2(), actionTime, id);
controller.ReleaseMouse(actionTime, id);
controller.SetMouse(Vector2.zero, id);
controller.Play(id);
}
}
public List <Slice2D> Update(Vector2D position, float timer, Layer layer)
{
List <Slice2D> result = new List <Slice2D>();
foreach (Sliceable2D slicer in Sliceable2D.GetListCopy())
{
if (slicer.MatchLayers(layer) == false)
{
continue;
}
Trail.Object trail = null;
trailList.TryGetValue(slicer, out trail);
if (trail == null)
{
trail = new Trail.Object();
trailList.Add(slicer, trail);
}
if (trail.lastPosition != null)
{
if (Vector2D.Distance(trail.lastPosition, position) > 0.05f)
{
trail.pointsList.Add(new Trail.Point(position, timer));
}
}
else
{
trail.pointsList.Add(new Trail.Point(position, timer));
}
if (trail.pointsList.Count > 1)
{
foreach (Trail.Point trailPoint in new List <Trail.Point>(trail.pointsList))
{
if (trailPoint.Update() == false)
{
trail.pointsList.Remove(trailPoint);
}
}
List <Vector2D> points = new List <Vector2D>();
foreach (Trail.Point trailPoint in trail.pointsList)
{
points.Add(trailPoint.position);
}
Sliceable2D.complexSliceType = Sliceable2D.SliceType.Regular;
Slice2D slice = slicer.ComplexSlice(points);
if (slice.GetGameObjects().Count > 0)
{
trailList.Remove(slicer);
result.Add(slice);
}
;
}
trail.lastPosition = position;
}
return(result);
}
public void Update()
{
for (int id = 0; id < 10; id++)
{
Vector2 pos = input.GetInputPosition(id);
if (input.GetInputClicked(id))
{
linearPair[id] = new Pair2(pos, pos);
startedSlice = false;
}
// Start Slice If Possible
if (startSliceIfPossible)
{
if (startedSlice == true)
{
if (Sliceable2D.PointInSlicerComponent(pos.ToVector2D()) == null)
{
startedSlice = false;
}
}
else if (startedSlice == false)
{
if (Sliceable2D.PointInSlicerComponent(pos.ToVector2D()) != null)
{
startedSlice = true;
}
else
{
linearPair[id].a = pos;
}
}
}
// End Slice If Possible
if (input.GetInputHolding(id))
{
linearPair[id].b = pos;
if (endSliceIfPossible)
{
if (input.GetSlicingEnabled(id))
{
if (LinearSlice(GetPair(id).ToPair2D()))
{
linearPair[id].a = pos;
if (startSliceIfPossible)
{
linearPair[id] = new Pair2(pos, pos);
startedSlice = false;
}
}
}
}
}
if (input.GetInputReleased(id))
{
if (input.GetSlicingEnabled(id))
{
LinearSlice(GetPair(id).ToPair2D());
}
}
}
}
public void Update(Vector2 position, float minVertexDistance = 1f)
{
List <Sliceable2D> slicer2DList = Sliceable2D.GetListCopy();
Vector2D trackedPos;
foreach (Sliceable2D slicer in slicer2DList)
{
Tracker.Object tracker = null;
trackerList.TryGetValue(slicer, out tracker);
if (tracker == null)
{
tracker = new Tracker.Object();
trackerList.Add(slicer, tracker);
}
trackedPos = new Vector2D(slicer.transform.transform.InverseTransformPoint(position));
if (tracker.lastPosition != null)
{
if (slicer.shape.GetLocal().PointInPoly(trackedPos))
{
if (tracker.tracking == false)
{
tracker.pointsList.Add(tracker.lastPosition);
}
tracker.tracking = true;
if (tracker.pointsList.Count < 1 || (Vector2D.Distance(trackedPos, tracker.pointsList.Last()) > minVertexDistance))
{
tracker.pointsList.Add(trackedPos);
}
}
else if (tracker.tracking == true)
{
tracker.tracking = false;
/*
*
* Vector2D posA = new Vector2D(tracker.pointsList.Last());
* Vector2D posB = new Vector2D(trackedPos);
*
* float rot = (floatVector2D.Atan2(posB, posA);
*
* posB.Push(rot, 1);
*
* tracker.pointsList.Add(posB);
*/
tracker.pointsList.Add(trackedPos);
// Test
List <Vector2D> slicePoints = new List <Vector2D>();
foreach (Vector2D point in tracker.pointsList)
{
slicePoints.Add(new Vector2D(slicer.transform.TransformPoint(point.ToVector2())));
}
Slice2D slice = slicer.ComplexSlice(slicePoints);
if (slice.GetGameObjects().Count > 0)
{
CopyTracker(slice, slicer);
}
;
trackerList.Remove(slicer);
}
else
{
if (tracker.tracking == false && tracker.lastPosition != null)
{
if (trackedPos.x != tracker.lastPosition.x && trackedPos.y != tracker.lastPosition.y)
{
bool collision = Math2D.LineIntersectPoly(new Pair2D(trackedPos, tracker.lastPosition), slicer.shape.GetLocal());
if (collision)
{
tracker.firstPosition = tracker.lastPosition;
tracker.tracking = true;
}
}
}
}
}
if (tracker != null)
{
tracker.lastPosition = trackedPos;
}
}
}
public void Update(Vector2 position, float minVertexDistance = 1f)
{
List <Sliceable2D> slicer2DList = Sliceable2D.GetListCopy();
Vector2D trackedPos;
foreach (Sliceable2D slicer in slicer2DList)
{
Tracker.Object tracker = null;
trackerList.TryGetValue(slicer, out tracker);
if (tracker == null)
{
tracker = new Tracker.Object();
trackerList.Add(slicer, tracker);
}
trackedPos = new Vector2D(slicer.transform.transform.InverseTransformPoint(position));
if (tracker.lastPosition != null)
{
if (slicer.shape.GetLocal().PointInPoly(trackedPos))
{
if (tracker.tracking == false)
{
tracker.firstPosition = tracker.lastPosition;
}
tracker.tracking = true;
}
else if (tracker.tracking == true)
{
tracker.tracking = false;
if (tracker.firstPosition != null)
{
tracker.lastPosition = trackedPos;
Pair2D slicePair = new Pair2D(new Vector2D(slicer.transform.TransformPoint(tracker.firstPosition.ToVector2())), new Vector2D(slicer.transform.TransformPoint(tracker.lastPosition.ToVector2())));
Slice2D slice = slicer.LinearSlice(slicePair);
if (slice.GetGameObjects().Count > 0)
{
CopyTracker(slice, slicer);
}
;
}
trackerList.Remove(slicer);
}
else
{
if (tracker.tracking == false && tracker.lastPosition != null)
{
if (trackedPos.x != tracker.lastPosition.x && trackedPos.y != tracker.lastPosition.y)
{
bool collision = Math2D.LineIntersectPoly(new Pair2D(trackedPos, tracker.lastPosition), slicer.shape.GetLocal());
if (collision)
{
tracker.firstPosition = tracker.lastPosition;
tracker.tracking = true;
}
}
}
}
}
if (tracker != null)
{
tracker.lastPosition = trackedPos;
}
}
}
public void Update()
{
for (int id = 0; id < 10; id++)
{
Vector2 pos = input.GetInputPosition(id);
if (input.GetInputClicked(id))
{
pointsList[id].Clear();
pointsList[id].Add(pos);
startedSlice = false;
}
if (pointsList[id].Count() < 1)
{
return;
}
if (input.GetInputHolding(id))
{
Vector2 posMove = pointsList[id].Last();
bool added = false;
int loopCount = 0;
while ((Vector2.Distance(posMove, pos) > minVertexDistance * visuals.visualScale))
{
float direction = (float)Vector2D.Atan2(pos, posMove);
posMove = posMove.Push(direction, minVertexDistance * visuals.visualScale);
if (startSliceIfPossible == true && startedSlice == false)
{
if (Sliceable2D.PointInSlicerComponent(posMove.ToVector2D()) != null)
{
while (pointsList[id].Count() > 2)
{
pointsList[id].RemoveAt(0);
}
startedSlice = true;
}
}
pointsList[id].Add(posMove);
added = true;
loopCount++;
if (loopCount > 150)
{
break;
}
}
if (endSliceIfPossible == true && added)
{
if (ComplexMerge(GetPoints(id).ToVector2DList()) == true)
{
pointsList[id].Clear();
if (startSliceIfPossible)
{
pointsList[id].Add(pos);
startedSlice = false;
}
}
}
}
if (input.GetInputReleased(id))
{
startedSlice = false;
Sliceable2D.complexSliceType = complexSliceType;
ComplexMerge(GetPoints(id).ToVector2DList());
pointsList[id].Clear();
}
}
}
void OnRenderObject()
{
Text text = GetComponent <Text> ();
text.text = "objects " + Sliceable2D.GetListCount();
}
void Start()
{
Sliceable2D slicer = GetComponent <Sliceable2D>();
slicer.AddResultEvent(SliceEvent);
}
