static public void CopyRigidbody2D(Rigidbody2D originalRigidBody, Slicer2D 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;
}
}
}
public void Update(Vector2 pos)
{
float scroll = Input.GetAxis("Mouse ScrollWheel");
float newCutSize = cutSize + scroll;
if (newCutSize > 0.05f)
{
cutSize = newCutSize;
}
if (input.GetInputClicked())
{
linearPair.a = pos;
}
if (input.GetInputHolding())
{
linearPair.b = pos;
}
if (input.GetInputReleased())
{
LinearCut linearCutLine = LinearCut.Create(linearPair, cutSize * visuals.visualScale);
Slicer2D.LinearCutSliceAll(linearCutLine, sliceLayer);
}
}
//オブジェクトをスライスしたら
void SliceEvent(Slice2D slice)
{
//親稲を取得
GameObject OyaCow = transform.root.gameObject.transform.GetChild(0).gameObject;
//OyaCow.GetComponent<Cow>().SetCutted();
//cowtailをきれないようにして全フェード
OyaCow.GetComponent <Cow>().CutHead();
//スライスされた全オブジェクトを読み込み
foreach (GameObject parts in slice.GetGameObjects())
{
Rigidbody2D rb;
if (rb = parts.GetComponent <Rigidbody2D>())
{
parts.GetComponent <PolygonCollider2D>().isTrigger = false;
rb.freezeRotation = true;
rb.gravityScale = 1.0f;
rb.AddForce(new Vector2(0, 100));
}
//スライスを不可にする
Slicer2D slicer = parts.GetComponent <Slicer2D>();
slicer.enabled = false;
}
}
static public void ExplodeGameObject(GameObject CutObject, GameObject originObject)
{
Slicer2D slicerA = CutObject.GetComponent <Slicer2D>();
Slicer2D slicerB = originObject.GetComponent <Slicer2D>();
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;
CutObject.AddComponent <DestroyTimer>();
UnityEngine.Object.Destroy(CutObject.GetComponent <Slicer2D>());
UnityEngine.Object.Destroy(CutObject.GetComponent <ThinSliceRules>());
}
void Start()
{
Slicer2D slicer = GetComponent <Slicer2D>();
slicer.AddResultEvent(SliceEvent);
//テキストオブジェクトの取得
g_ScoreTexObj = GameObject.Find("ScoreText");
//スプライトのa値を初期化
if (GetComponent <SpriteRenderer>())
{
GetComponent <SpriteRenderer>().color = new Color(1, 1, 1, 1);
}
//米の大きさを取得
if (currentSize == 0)
{
currentSize = Polygon2DList.CreateFromGameObject(gameObject)[0].ToWorldSpace(transform).GetArea();
//ここかえる
currentSizePercent = (float)System.Math.Round((currentSize / GameObject.Find("DataHolder").GetComponent <Data>().GetOriginalFishTailSize()) * 100);
}
Type = GameObject.Find("DataHolder").GetComponent <Data>().GetFishIcon();
}
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 (Slicer2D slicer in Slicer2D.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();
}
bool ComplexSlice(List <Vector2D> slice)
{
if (sliceJoints)
{
Slicer2DJoints.ComplexSliceJoints(slice);
}
List <Slice2D> results = Slicer2D.ComplexSliceAll(slice, sliceLayer);
bool result = false;
foreach (Slice2D id in results)
{
if (id.GetGameObjects().Count > 0)
{
result = true;
}
eventHandler.Perform(id);
}
if (addForce == true)
{
foreach (Slice2D id in results)
{
Slicer2DAddForce.ComplexSlice(id, addForceAmount);
}
}
return(result);
}
void StartAnchor()
{
bool addEvents = false;
foreach (Collider2D collider in anchor.anchorsList)
{
if (collider != null)
{
addEvents = true;
}
}
if (addEvents == false)
{
return;
}
Slicer2D slicer = GetComponent <Slicer2D> ();
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);
}
}
private void PointSlice(Vector2 pos)
{
float rotation = 0;
switch (sliceRotation)
{
case SliceRotation.Random:
rotation = UnityEngine.Random.Range(0, Mathf.PI * 2);
break;
case SliceRotation.Vertical:
rotation = Mathf.PI / 2f;
break;
case SliceRotation.Horizontal:
rotation = Mathf.PI;
break;
}
List <Slice2D> results = Slicer2D.PointSliceAll(pos.ToVector2D(), rotation, sliceLayer);
foreach (Slice2D id in results)
{
eventHandler.Perform(id);
}
}
private void LinearSlice(Pair2D slice)
{
List <Slice2D> results = Slicer2D.LinearSliceAll(slice, null);
if (addForce == false)
{
return;
}
// Adding Physics Forces
float sliceRotation = (float)Vector2D.Atan2(slice.B, slice.A);
foreach (Slice2D id in results)
{
foreach (GameObject gameObject in id.GetGameObjects())
{
Rigidbody2D rigidBody2D = gameObject.GetComponent <Rigidbody2D> ();
if (rigidBody2D == null)
{
continue;
}
foreach (Vector2D p in id.GetCollisions())
{
PhysicsHelper2D.AddForceAtPosition(rigidBody2D, new Vector2(Mathf.Cos(sliceRotation) * addForceAmount, Mathf.Sin(sliceRotation) * addForceAmount), p.ToVector2());
}
}
}
}
public void UpdateSliceAnimations()
{
if (animationPairs.Count < 1)
{
return;
}
if (PointSlicerSlash.GetList().Count > 0)
{
return;
}
Pair2D animationPair = animationPairs.First();
Slicer2D.LinearSliceAll(animationPair, sliceLayer);
Vector3 position = animationPair.A.ToVector2();
position.z = -1;
GameObject particleGameObject = Instantiate(particlePrefab, position, Quaternion.Euler(0, 0, (float)Vector2D.Atan2(animationPair.A, animationPair.B) * Mathf.Rad2Deg));
PointSlicerSlash particle = particleGameObject.GetComponent <PointSlicerSlash>();
particle.moveTo = animationPair.B;
animationPairs.Remove(animationPair);
}
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;
Slicer2D slicer = g.GetComponent <Slicer2D>();
slicer.enabled = false;
slicer.gameObject.AddComponent <FruitSlicerFadeAway>();
//ColliderLineRenderer2D lineRenderer = g.GetComponent<ColliderLineRenderer2D>();
//lineRenderer.customColor = true;
//lineRenderer.color = Color.red;
//lineRenderer.lineWidth = 0.5f;
}
}
private void ComplexMerge(List <Vector2D> mergeSlice)
{
foreach (Slicer2D slicer in Slicer2D.GetList())
{
slicer.ComplexMerge(mergeSlice);
}
}
public void UpdateCurrentArea()
{
currentArea = 0f;
foreach (Slicer2D slicer in Slicer2D.GetListCopy())
{
currentArea += slicer.shape.GetLocal().GetArea();
}
}
private void PolygonSlice(Vector2 pos)
{
Polygon2D.defaultCircleVerticesCount = edgeCount;
Polygon2D slicePoly = Polygon2D.Create(polygonType, polygonSize * visuals.visualScale).ToOffset(pos);
Slicer2D.PolygonMergeAll(slicePoly, sliceLayer);
}
private void PolygonSlice(Vector2 pos)
{
Polygon2D.defaultCircleVerticesCount = edgeCount;
Polygon2D slicePolygon = Polygon2D.Create(polygonType, polygonSize * visuals.visualScale);
Slicer2D.PolygonSliceAll(pos.ToVector2D(), slicePolygon, polygonDestroy, sliceLayer);
}
public void ResetLevel()
{
startingArea = 0;
foreach (Slicer2D slicer in Slicer2D.GetList())
{
startingArea += slicer.shape.GetWorld().GetArea();
}
}
void Start()
{
Slicer2D slicer = GetComponent <Slicer2D>();
if (slicer != null)
{
slicer.AddAnchorResultEvent(sliceEvent);
}
}
public void Draw(Transform transform)
{
if (input.GetVisualsEnabled() == false)
{
return;
}
visuals.Clear();
for (int id = 0; id < 10; id++)
{
if (input.GetInputHolding(id))
{
if (startSliceIfPossible == false || startedSlice == true)
{
Pair2 pair = linearPair[id];
if (autocompleteDisplay)
{
pair = GetPair(id);
}
// If Stripped Line
if (strippedLinear)
{
Vector2List linearPoints = GetLinearVertices(pair, minVertexDistance * visuals.visualScale);
if (linearPoints.Count() > 1)
{
visuals.GenerateComplexMesh(linearPoints);
}
}
else
{
visuals.GenerateLinearMesh(pair);
}
if (displayCollisions)
{
List <Slice2D> results = Slicer2D.LinearSliceAll(linearPair[id].ToPair2D(), sliceLayer, false);
foreach (Slice2D slice in results)
{
foreach (Vector2D collision in slice.GetCollisions())
{
Pair2 p = new Pair2(collision.ToVector2(), collision.ToVector2());
visuals.GenerateLinearMesh(p);
}
}
}
}
}
}
visuals.Draw();
return;
}
bool PointInObjects(Vector2D pos)
{
foreach (Slicer2D slicer in Slicer2D.GetList())
{
if (slicer.shape.GetLocal().PointInPoly(pos.InverseTransformPoint(slicer.transform)))
{
return(true);
}
}
return(false);
}
void Start()
{
Slicer2D slicer = GetComponent <Slicer2D>();
slicer.AddResultEvent(SlicerEvent);
if (timer == null)
{
timer = TimerHelper.Create();
}
}
void Start()
{
Slicer2D slicer = GetComponent <Slicer2D>();
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 (Slicer2D slicer in Slicer2D.GetList())
{
instance.leftArea += slicer.shape.GetWorld().GetArea();
}
instance.leftArea = ((instance.leftArea) / instance.startingArea) * 100f;
}
static public Slicer2D PointInSlicerComponent(Vector2D point)
{
foreach (Slicer2D slicer in Slicer2D.GetList())
{
Polygon2D poly = slicer.shape.GetWorld();
if (poly.PointInPoly(point))
{
return(slicer);
}
}
return(null);
}
void SliceEvent(Slice2D slice)
{
Vector2D midPoint = SliceMidPoint(slice.slices[0]);
foreach (Slicer2D g in Slicer2D.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 = Slicer2D.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 (Slicer2D.GetList().Count < 1)
{
return;
}
if (slicesCount <= Levels[currentLevelID].allowedSlices && piecesCount == Levels[currentLevelID].allowedPieces)
{
foreach (Slicer2D slicer in Slicer2D.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 (Slicer2D slicer in Slicer2D.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(Slicer2D slicer, Slice2D sliceResult)
{
if (slicer.eventHandler.AnchorSliceEvent(sliceResult) == false)
{
return(false);
}
if (Slicer2DEventHandling.GlobalSliceEvent(sliceResult) == false)
{
return(false);
}
switch (slicer.anchor.anchorType)
{
case Slicer2D.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);
}
private void ComplexSlice(List <Vector2D> slice)
{
List <Slice2D> results = Slicer2D.ComplexSliceAll(slice, null);
if (addForce == false)
{
return;
}
foreach (Slice2D id in results)
{
Slicer2DAddForce.ComplexSlice(id, addForceAmount);
}
}
private void LinearSlice(Pair2D slice)
{
List <Slice2D> results = Slicer2D.LinearSliceAll(slice, null);
if (addForce == false)
{
return;
}
// Adding Physics Forces
foreach (Slice2D id in results)
{
Slicer2DAddForce.LinearSlice(id, addForceAmount);
}
}
public void Slice()
{
float timer = Time.realtimeSinceStartup;
foreach (Transform t in transform)
{
Polygon2D poly = Polygon2DList.CreateFromGameObject(t.gameObject)[0].ToWorldSpace(t);
Slicer2D.ComplexSliceAll(poly.pointsList, Slice2DLayer.Create());
}
Destroy(gameObject);
Debug.Log(name + " in " + (Time.realtimeSinceStartup - timer) * 1000 + "ms");
}
