static public void CopyRigidbody2D(Rigidbody2D originalRigidBody, Sliceable2D slicer, Polygon2D id, double originArea)
{
if (originalRigidBody)
{
Rigidbody2D newRigidBody = slicer.GetRigibody();
newRigidBody.position = originalRigidBody.position;
newRigidBody.isKinematic = originalRigidBody.isKinematic;
newRigidBody.velocity = originalRigidBody.velocity;
newRigidBody.drag = originalRigidBody.drag;
newRigidBody.angularVelocity = originalRigidBody.angularVelocity;
newRigidBody.angularDrag = originalRigidBody.angularDrag;
newRigidBody.constraints = originalRigidBody.constraints;
newRigidBody.gravityScale = originalRigidBody.gravityScale;
newRigidBody.collisionDetectionMode = originalRigidBody.collisionDetectionMode;
newRigidBody.sharedMaterial = originalRigidBody.sharedMaterial;
//newRigidBody.sleepMode = originalRigidBody.sleepMode;
//newRigidBody.inertia = originalRigidBody.inertia;
// Center of Mass : Auto / Center
//if (slicer.centerOfMass == Slicer2D.CenterOfMass.RigidbodyOnly) {
/// newRigidBody.centerOfMass = Vector2.zero;
//}
if (slicer.recalculateMass)
{
float newArea = (float)id.ToLocalSpace(slicer.transform).GetArea();
newRigidBody.mass = originalRigidBody.mass * (float)(newArea / originArea);
}
else
{
newRigidBody.mass = originalRigidBody.mass;
}
}
}
void Update()
{
Polygon2D cameraPolygon = Polygon2D.CreateFromCamera(Camera.main);
cameraPolygon = cameraPolygon.ToRotation(Camera.main.transform.rotation.eulerAngles.z * Mathf.Deg2Rad);
cameraPolygon = cameraPolygon.ToOffset(new Vector2D(Camera.main.transform.position));
foreach (Sliceable2D slicer in Sliceable2D.GetListCopy())
{
if (Math2D.PolyCollidePoly(slicer.shape.GetWorld(), cameraPolygon) == false)
{
if (slicer.enabled == true)
{
lives--;
if (lives >= 0)
{
SpriteRenderer sr = livesObjects[lives].GetComponent <SpriteRenderer>();
sr.color = Color.white;
}
else
{
Debug.Log("lose");
}
}
Destroy(slicer.gameObject);
}
}
scoreText.text = score.ToString();
}
static public void ExplodeGameObject(GameObject CutObject, GameObject originObject)
{
Sliceable2D slicerA = CutObject.GetComponent <Sliceable2D>();
Sliceable2D slicerB = originObject.GetComponent <Sliceable2D>();
Polygon2D polyA = slicerA.shape.GetWorld();
Polygon2D polyB = slicerB.shape.GetWorld();
Rect boundsA = polyA.GetBounds();
Rect boundsB = polyB.GetBounds();
Vector2D centerA = new Vector2D(boundsA.center);
Vector2D centerB = new Vector2D(boundsB.center);
double direction = (double)Vector2D.Atan2(centerA, centerB);
Rigidbody2D rigidBody2D = CutObject.AddComponent <Rigidbody2D>();
rigidBody2D.AddForce(Vector2D.RotToVec(direction).ToVector2() * 200);
rigidBody2D.AddTorque(Random.Range(-15, 15));
cutObjects++;
CutObject.transform.Translate(0, 0, 100 - cutObjects + CutObject.transform.position.z);
CutObject.AddComponent <Mesh2D>().material = slicerA.materialSettings.material;
UnityEngine.Object.Destroy(CutObject.GetComponent <Sliceable2D>());
UnityEngine.Object.Destroy(CutObject.GetComponent <ThinSliceRules>());
}
void StartAnchor()
{
bool addEvents = false;
foreach (Collider2D collider in anchor.anchorsList)
{
if (collider != null)
{
addEvents = true;
}
}
if (addEvents == false)
{
return;
}
Sliceable2D slicer = GetComponent <Sliceable2D> ();
if (slicer != null)
{
slicer.AddResultEvent(OnAnchorSliceResult);
slicer.AddEvent(OnAnchorSlice);
}
anchor.anchorPolygons = new List <Polygon2D>();
anchor.anchorColliders = new List <Collider2D>();
foreach (Collider2D collider in anchor.anchorsList)
{
anchor.anchorPolygons.Add(Polygon2DList.CreateFromGameObject(collider.gameObject)[0]);
anchor.anchorColliders.Add(collider);
}
}
static public List <Slice2D> LinearSliceAll(Pair2D slice, Layer layer = null, bool perform = true)
{
List <Slice2D> result = new List <Slice2D> ();
if (layer == null)
{
layer = Layer.Create();
}
foreach (Sliceable2D id in Sliceable2D.GetListLayer(layer))
{
Slice2D sliceResult = id.LinearSlice(slice, perform);
if (perform)
{
if (sliceResult.GetGameObjects().Count > 0)
{
result.Add(sliceResult);
}
}
else
{
if (sliceResult.GetPolygons().Count > 0)
{
result.Add(sliceResult);
}
}
}
return(result);
}
private void ComplexMerge(List <Vector2D> mergeSlice)
{
foreach (Sliceable2D slicer in Sliceable2D.GetList())
{
slicer.ComplexMerge(mergeSlice);
}
}
void SliceEvent(Slice2D slice)
{
FruitSlicerGameManager.instance.score += 15;
foreach (GameObject g in slice.GetGameObjects())
{
Vector3 pos = g.transform.position;
pos.z = Random.Range(pos.z, 50);
g.transform.position = pos;
Rigidbody2D rb = g.GetComponent <Rigidbody2D>();
rb.AddForce(new Vector2(Random.Range(-200, 200), Random.Range(100, 200)));
rb.AddTorque(Random.Range(-100, 100));
//PolygonCollider2D collider = g.GetComponent<PolygonCollider2D>();
//collider.isTrigger = false;
Sliceable2D slicer = g.GetComponent <Sliceable2D>();
slicer.enabled = false;
slicer.gameObject.AddComponent <FruitSlicerFadeAway>();
//ColliderLineRenderer2D lineRenderer = g.GetComponent<ColliderLineRenderer2D>();
//lineRenderer.customColor = true;
//lineRenderer.color = Color.red;
//lineRenderer.lineWidth = 0.5f;
}
}
// Remove Position
static public List <Slice2D> PolygonSliceAll(Vector2D position, Polygon2D slicePolygon, bool destroy, Layer layer = null)
{
List <Slice2D> result = new List <Slice2D> ();
if (layer == null)
{
layer = Layer.Create();
}
Polygon2D slicePolygonDestroy = null;
if (destroy)
{
slicePolygonDestroy = slicePolygon.ToScale(new Vector2(1.1f, 1.1f));
slicePolygonDestroy = slicePolygonDestroy.ToOffset(position);
}
slicePolygon = slicePolygon.ToOffset(position);
foreach (Sliceable2D id in Sliceable2D.GetListLayer(layer))
{
result.Add(id.PolygonSlice(slicePolygon, slicePolygonDestroy));
}
return(result);
}
public void UpdateCurrentArea()
{
currentArea = 0f;
foreach (Sliceable2D slicer in Sliceable2D.GetListCopy())
{
currentArea += slicer.shape.GetLocal().GetArea();
}
}
public void ResetLevel()
{
startingArea = 0;
foreach (Sliceable2D slicer in Sliceable2D.GetList())
{
startingArea += slicer.shape.GetWorld().GetArea();
}
}
bool PointInObjects(Vector2D pos)
{
foreach (Sliceable2D slicer in Sliceable2D.GetList())
{
if (slicer.shape.GetLocal().PointInPoly(pos.InverseTransformPoint(slicer.transform)))
{
return(true);
}
}
return(false);
}
void Start()
{
Sliceable2D slicer = GetComponent <Sliceable2D>();
if (slicer != null)
{
slicer.AddResultEvent(SliceEvent);
}
posZ = transform.position.z - 0.1f;
}
// Recalculate area that is left
static public void UpdateLevelProgress()
{
instance.leftArea = 0;
foreach (Sliceable2D slicer in Sliceable2D.GetList())
{
instance.leftArea += slicer.shape.GetWorld().GetArea();
}
instance.leftArea = ((instance.leftArea) / instance.startingArea) * 100f;
}
void Start()
{
Sliceable2D slicer = GetComponent <Sliceable2D>();
slicer.AddResultEvent(SlicerEvent);
if (timer == null)
{
timer = TimerHelper.Create();
}
}
static public Sliceable2D PointInSlicerComponent(Vector2D point)
{
foreach (Sliceable2D slicer in Sliceable2D.GetList())
{
Polygon2D poly = slicer.shape.GetWorld();
if (poly.PointInPoly(point))
{
return(slicer);
}
}
return(null);
}
public static void SetupSprite2DGameObject(GameObject newGameObject)
{
Slicer2D.Sliceable2D sliceable = newGameObject.AddComponent <Slicer2D.Sliceable2D>();
CircleCollider2D collider = newGameObject.AddComponent <CircleCollider2D>();
Utilities2D.ColliderLineRenderer2D lineRenderer = newGameObject.AddComponent <Utilities2D.ColliderLineRenderer2D>();
lineRenderer.lineWidth = 0.25f;
newGameObject.transform.position = GetCameraPoint();
}
void SliceEvent(Slice2D slice)
{
Vector2D midPoint = SliceMidPoint(slice.slices[0]);
foreach (Sliceable2D g in Sliceable2D.GetList())
{
Vector2D center = new Vector2D(Polygon2DList.CreateFromGameObject(g.gameObject)[0].ToWorldSpace(g.transform).GetBounds().center);
Vector2D position = new Vector2D(g.transform.position);
position.Push(Vector2D.Atan2(center, midPoint), 0.2f); // + Mathf.PI / 2
g.transform.position = position.ToVector2();
}
}
void Update()
{
piecesCount = Sliceable2D.GetListCount();
slicesText.text = "Slices: " + slicesCount + " / " + Levels[currentLevelID].allowedSlices;
piecesText.text = "Pieces: " + piecesCount + " / " + Levels[currentLevelID].allowedPieces;
Vector3 pos = Camera.main.transform.position;
pos.x = pos.x * 0.95f + (float)(currentLevelID * 50f) * 0.05f;
Camera.main.transform.position = pos;
if (Sliceable2D.GetList().Count < 1)
{
return;
}
if (slicesCount <= Levels[currentLevelID].allowedSlices && piecesCount == Levels[currentLevelID].allowedPieces)
{
foreach (Sliceable2D slicer in Sliceable2D.GetListCopy())
{
slicer.gameObject.AddComponent <DivideGreenFade>();
slicer.enabled = false;
garbage.Add(slicer.gameObject);
}
DivideUIFade.instance.state = true;
DivideUIFade.instance.menuObjects[0].SetActive(false);
DivideUIFade.instance.menuObjects[1].SetActive(false);
DivideUIFade.instance.menuObjects[2].SetActive(true);
//currentLevelID++;
//Levels[currentLevelID].level.SetActive(true);
//slicesCount = 0;
}
else if (slicesCount > Levels[currentLevelID].allowedSlices)
{
foreach (Sliceable2D slicer in Sliceable2D.GetListCopy())
{
DivideGreenFade fade = slicer.gameObject.AddComponent <DivideGreenFade>();
fade.fadeTyp = DivideGreenFade.FadeType.Red;
slicer.enabled = false;
garbage.Add(slicer.gameObject);
}
DivideUIFade.instance.menuObjects[0].SetActive(false);
DivideUIFade.instance.menuObjects[1].SetActive(true);
DivideUIFade.instance.menuObjects[2].SetActive(false);
DivideUIFade.instance.state = true;
}
}
public static bool OnAnchorSlice(Sliceable2D slicer, Slice2D sliceResult)
{
if (slicer.eventHandler.AnchorSliceEvent(sliceResult) == false)
{
return(false);
}
if (EventHandling.GlobalSliceEvent(sliceResult) == false)
{
return(false);
}
switch (slicer.anchor.anchorType)
{
case Sliceable2D.AnchorType.CancelSlice:
foreach (Polygon2D polyA in new List <Polygon2D>(sliceResult.GetPolygons()))
{
bool perform = true;
foreach (Polygon2D polyB in slicer.anchor.anchorPolygons)
{
if (Math2D.PolyCollidePoly(polyA, GetPolygonInWorldSpace(slicer, polyB)))
{
perform = false;
}
}
if (perform)
{
return(false);
}
}
break;
/*
* case AnchorType.DestroySlice:
* foreach (Polygon2D polyA in new List<Polygon2D>(sliceResult.polygons)) {
* bool perform = true;
* foreach(Polygon2D polyB in polygons) {
* if (Math2D.PolyCollidePoly (polyA.pointsList, GetPolygonInWorldSpace(polyB).pointsList) ) {
* sliceResult.polygons.Remove(polyB);
* }
* }
*
* }
* break;
*/
default:
break;
}
return(true);
}
public void SetTriangulation(Sliceable2D script)
{
Slicer2D.SettingsProfile profile = Slicer2D.Settings.GetProfile();
if (profile == null || profile.triangulation == Slicer2D.Settings.Triangulation.Default)
{
script.materialSettings.triangulation = (PolygonTriangulator2D.Triangulation)EditorGUILayout.EnumPopup("Triangulation", script.materialSettings.triangulation);
}
else
{
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.EnumPopup("Triangulation", Slicer2D.Settings.GetTriangulation(script.materialSettings.triangulation));
EditorGUI.EndDisabledGroup();
}
}
public static void SetupMesh2DGameObject(GameObject newGameObject)
{
Slicer2D.Sliceable2D sliceable = newGameObject.AddComponent <Slicer2D.Sliceable2D>();
sliceable.textureType = Slicer2D.Sliceable2D.TextureType.Mesh2D;
sliceable.materialSettings.material = new Material(Shader.Find("Sprites/Default"));
sliceable.materialSettings.material.color = Color.white;
Utilities2D.ColliderLineRenderer2D lineRenderer = newGameObject.AddComponent <Utilities2D.ColliderLineRenderer2D>();
lineRenderer.lineWidth = 0.25f;
newGameObject.transform.position = GetCameraPoint();
}
public void SetComponentsCopy(Sliceable2D script)
{
Slicer2D.SettingsProfile profile = Slicer2D.Settings.GetProfile();
if (profile == null || profile.componentsCopy == Slicer2D.Settings.InstantiationMethod.Default)
{
script.instantiateMethod = (Sliceable2D.InstantiationMethod)EditorGUILayout.EnumPopup("Instantiation Method", script.instantiateMethod);
}
else
{
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.EnumPopup("Instantiation", Slicer2D.Settings.GetComponentsCopy(script.instantiateMethod));
EditorGUI.EndDisabledGroup();
}
}
public void SetBatching(Sliceable2D script)
{
Slicer2D.SettingsProfile profile = Slicer2D.Settings.GetProfile();
if (profile == null || profile.batching == Slicer2D.Settings.Batching.Default)
{
script.materialSettings.batchMaterial = EditorGUILayout.Toggle("Batch Material", script.materialSettings.batchMaterial);
}
else
{
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.Toggle("Batch Material", Slicer2D.Settings.GetBatching(script.materialSettings.batchMaterial));
EditorGUI.EndDisabledGroup();
}
}
static public Pair2 GetPair(Pair2 pair, float distance)
{
float direction = pair.a.Atan2(pair.b);
Vector2 resultA = pair.a;
Vector2 resultB = pair.b;
Vector2 pointA = pair.a;
Vector2 pointB = pair.b;
pointA = pointA.Push(direction, distance);
pointB = pointB.Push(direction, -distance);
Sliceable2D slicerA = Sliceable2D.PointInSlicerComponent(pair.a.ToVector2D());
Sliceable2D slicerB = Sliceable2D.PointInSlicerComponent(pair.b.ToVector2D());
Pair2 thresholdPairA = new Pair2(pair.a, pointA);
Pair2 thresholdPairB = new Pair2(pair.b, pointB);
if (slicerA != null)
{
List <Vector2D> pointsA = slicerA.shape.GetWorld().GetListLineIntersectPoly(thresholdPairA.ToPair2D());
if (pointsA.Count > 0)
{
pointsA = Vector2DList.GetListSortedToPoint(pointsA, pointA.ToVector2D());
resultA = pointsA[pointsA.Count - 1].ToVector2();
resultA.Push(direction, 0.05f);
}
}
if (slicerB != null)
{
List <Vector2D> pointsB = slicerB.shape.GetWorld().GetListLineIntersectPoly(thresholdPairB.ToPair2D());
if (pointsB.Count > 0)
{
pointsB = Vector2DList.GetListSortedToPoint(pointsB, pointB.ToVector2D());
resultB = pointsB[pointsB.Count - 1].ToVector2();
resultB.Push(direction, -0.05f);
}
}
return(new Pair2(resultA, resultB));
}
public void BallToMapCollision()
{
Vector2D position = new Vector2D(transform.position);
// Balls vs Map Collisions
foreach (Sliceable2D slicer in Sliceable2D.GetList())
{
foreach (Pair2D id in Pair2D.GetList(slicer.shape.GetWorld().pointsList))
{
if (Math2D.Circle.IntersectLine(id, position, radius) == true)
{
transform.Translate(direction * -speed);
SetDirection(Math2D.ReflectAngle(direction, (float)Vector2D.Atan2(id.A, id.B)));
transform.Translate(direction * speed);
}
}
}
}
void Slice()
{
Polygon2D.defaultCircleVerticesCount = 15;
Polygon2D bombPoly = Polygon2DList.CreateFromGameObject(sliceArea.gameObject)[0];
Polygon2D slicePolygon = bombPoly.ToWorldSpace(sliceArea.gameObject.transform);
Polygon2D slicePolygonDestroy = bombPoly.ToScale(new Vector2(1.05f, 1.05f)).ToWorldSpace(sliceArea.gameObject.transform);
foreach (Sliceable2D id in Sliceable2D.GetListCopy())
{
Slice2D result = Slicer2D.API.PolygonSlice(id.shape.GetWorld(), 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)
{
List <GameObject> gList = id.PerformResult(result.GetPolygons(), result);
SliceParticles(gList, result, slicePolygonDestroy);
}
else
{
// Polygon is Destroyed!!!
Destroy(id.gameObject);
}
}
}
Polygon2D.defaultCircleVerticesCount = 25;
// Destroy(this);
}
public void Update(Sliceable2D source)
{
Transform transform = source.transform;
if (updatePosition != transform.position)
{
updatePosition = transform.position;
update = true;
}
if (updateRotation != transform.rotation.eulerAngles.z)
{
updateRotation = transform.rotation.eulerAngles.z;
update = true;
}
if (source.spriteRenderer != null)
{
if (sprite != source.spriteRenderer.sprite)
{
sprite = source.spriteRenderer.sprite;
update = true;
}
if (spriteflipX != source.spriteRenderer.flipX)
{
spriteflipX = source.spriteRenderer.flipX;
update = true;
}
if (spriteflipY != source.spriteRenderer.flipY)
{
spriteflipY = source.spriteRenderer.flipY;
update = true;
}
}
}
static public List <Slice2D> ExplodeAll(Layer layer = null, int explosionSlices = 0)
{
List <Slice2D> result = new List <Slice2D> ();
if (layer == null)
{
layer = Layer.Create();
}
foreach (Sliceable2D id in Sliceable2D.GetListLayer(layer))
{
Slice2D sliceResult = id.Explode(explosionSlices);
if (sliceResult.GetGameObjects().Count > 0)
{
result.Add(sliceResult);
}
}
return(result);
}
static public List <Slice2D> ExplodeInPointAll(Vector2D point, Layer layer = null)
{
List <Slice2D> result = new List <Slice2D> ();
if (layer == null)
{
layer = Layer.Create();
}
foreach (Sliceable2D id in Sliceable2D.GetListLayer(layer))
{
Slice2D sliceResult = id.ExplodeInPoint(point);
if (sliceResult.GetGameObjects().Count > 0)
{
result.Add(sliceResult);
}
}
return(result);
}
static public List <Slice2D> ComplexCutSliceAll(ComplexCut complexCut, Layer layer = null)
{
List <Slice2D> result = new List <Slice2D> ();
if (layer == null)
{
layer = Layer.Create();
}
foreach (Sliceable2D id in Sliceable2D.GetListLayer(layer))
{
Slice2D sliceResult = id.ComplexCutSlice(complexCut);
if (sliceResult.GetGameObjects().Count > 0)
{
result.Add(sliceResult);
}
}
return(result);
}
