// Use this for initialization
void Start()
{
spriteShapeController = terrain.GetComponent <SpriteShapeController>();
spline = spriteShapeController.spline;
GenerateWayPoints();
}
static void SetToLine(SpriteShapeController spriteShapeController)
{
spriteShapeController.spline.Clear();
spriteShapeController.spline.InsertPointAt(0, new Vector3(-kMaxSideSize, 0.0f, 0));
spriteShapeController.spline.InsertPointAt(1, new Vector3(kMaxSideSize, 0.0f, 0));
spriteShapeController.spline.isOpenEnded = true;
}
// Start is called before the first frame update
void Start()
{
//Get components
spriteController = GetComponent <SpriteShapeController>();
spriteRenderer = GetComponent <SpriteShapeRenderer>();
growthSpeed = maxLinearSpeed;
steering.Orientation = Mathf.PI / 2.0f; // Starting 90degrees (upwards)
for (int node = 0; node < SplineCount; node++)
{
Spline.SetTangentMode(node, ShapeTangentMode.Continuous);
}
//Set min thickness for top of spline
Spline.SetHeight(TopNodeIndex, minThickness);
//Setting spriteShapeCorrectly
if (spriteShape == null)
{
spriteShape = spriteController.spriteShape;
}
else
{
spriteController.spriteShape = spriteShape;
}
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
GUI.enabled = !EditorApplication.isPlaying;
if (GUILayout.Button("Auto Select PolygonCollider2Ds"))
{
pc2dw.autoSelectTargetLists();
}
if (GUILayout.Button("Cut PolygonCollider2D"))
{
if (EditorApplication.isPlaying)
{
throw new UnityException("You must be in Edit Mode to use this function!");
}
pc2dwCurrent = pc2dw;
pc2dw.cleanTargetLists();
stencilShape = new Shape(stencil);
//PolygonCollider2D
int originalCount = pc2dw.pc2dTargets.Count;
for (int i = 0; i < originalCount; i++)
{
PolygonCollider2D pc2d = (PolygonCollider2D)pc2dw.pc2dTargets[i];
cutCollider(new Shape(pc2d), stencilShape);
}
//SpriteShape
originalCount = pc2dw.spriteShapeTargets.Count;
for (int i = 0; i < originalCount; i++)
{
SpriteShapeController ssc = (SpriteShapeController)pc2dw.spriteShapeTargets[i];
cutCollider(new Shape(ssc), stencilShape);
}
}
}
// Start is called before the first frame update
void Start()
{
spriteShapeController = GetComponent <SpriteShapeController>();
spline = spriteShapeController.spline;
UpdateArrowPosition();
}
// Start is called before the first frame update
void Start()
{
shape = GetComponent <SpriteShapeController>();
iceGround = GetComponent <IceGround>();
shape.enabled = false;
iceGround.enabled = false;
}
// Use this for initialization. Plant the Prefabs on Startup
void Start()
{
SpriteShapeController ssc = GetComponent <SpriteShapeController>();
Spline spl = ssc.spline;
for (int i = 1; i < spl.GetPointCount() - 1; ++i)
{
if (Random.Range(0, 100) > (100 - m_RandomFactor))
{
var go = GameObject.Instantiate(m_Prefab);
go.transform.position = spl.GetPosition(i);
if (m_UseNormals)
{
Vector3 lt = Vector3.Normalize(spl.GetPosition(i - 1) - spl.GetPosition(i));
Vector3 rt = Vector3.Normalize(spl.GetPosition(i + 1) - spl.GetPosition(i));
float a = Angle(Vector3.up, lt);
float b = Angle(lt, rt);
float c = a + (b * 0.5f);
if (b > 0)
{
c = (180 + c);
}
go.transform.rotation = Quaternion.Euler(0, 0, c);
}
}
}
}
static void RenderSpline(SpriteShapeController m_SpriteShapeController, GizmoType gizmoType)
{
if (UnityEditor.EditorTools.ToolManager.activeToolType == typeof(SpriteShapeEditorTool))
{
return;
}
var m_Spline = m_SpriteShapeController.spline;
var oldMatrix = Handles.matrix;
var oldColor = Handles.color;
Handles.matrix = m_SpriteShapeController.transform.localToWorldMatrix;
Handles.color = Color.grey;
var pointCount = m_Spline.GetPointCount();
for (var i = 0; i < (m_Spline.isOpenEnded ? pointCount - 1 : pointCount); ++i)
{
Vector3 p1 = m_Spline.GetPosition(i);
Vector3 p2 = m_Spline.GetPosition((i + 1) % pointCount);
var t1 = p1 + m_Spline.GetRightTangent(i);
var t2 = p2 + m_Spline.GetLeftTangent((i + 1) % pointCount);
Vector3[] bezierPoints = Handles.MakeBezierPoints(p1, p2, t1, t2, m_SpriteShapeController.splineDetail);
Handles.DrawAAPolyLine(bezierPoints);
}
Handles.matrix = oldMatrix;
Handles.color = oldColor;
}
void Start()
{
maxDistance = 24f;
centerPoint = spriteshapeFront.transform.GetComponent <Renderer>().bounds.center.x;
prefabTop = spriteshapeTop.GetComponent <SpriteShapeController>();
prefab = spriteshape.GetComponent <SpriteShapeController>();
prefabFront = spriteshapeFront.GetComponent <SpriteShapeController>();
prefabOpp = spriteshapeOpp.GetComponent <SpriteShapeController>();
prefabBase = spriteshapeBase.GetComponent <SpriteShapeController>();
pathfinder = AIMap.GetComponent <AstarPath>();
int points = prefab.spline.GetPointCount();
for (int i = 0; i < points; i++)
{
Debug.Log(prefab.spline.GetHeight(i));
}
Debug.Log(spriteshapeFront.transform.GetComponent <Renderer>().bounds.center.x);
minX = prefab.spline.GetPosition(2).x;
maxX = prefab.spline.GetPosition(0).x;
startPoint = prefabTop.spline.GetPosition(2).x;
endPoint = 1.45f;
p = prefab.spline.GetPosition(0);
p1 = prefab.spline.GetPosition(1);
pt = prefabTop.spline.GetPosition(1);
pt1 = prefabTop.spline.GetPosition(2);
pb = prefabBase.spline.GetPosition(1);
pb1 = prefabBase.spline.GetPosition(2);
po = prefabOpp.spline.GetPosition(0);
po1 = prefabOpp.spline.GetPosition(1);
//Debug.Log(minX);
//Debug.Log(maxX);
}
private int GetAngleRange(int index)
{
int startPoint = 0;
SpriteShapeController sc = SplineEditorCache.GetTarget();
return(GetAngleRange(sc, index, ref startPoint));
}
// Start is called before the first frame update
void Start()
{
Debug.Log("Hi");
float distance_Between_points = Scale / numberOfPoints;
shape = GetComponent <SpriteShapeController>();
shape.spline.SetPosition(2, shape.spline.GetPosition(2) + Vector3.right * Scale);
shape.spline.SetPosition(3, shape.spline.GetPosition(3) + Vector3.right * Scale);
for (int i = 0; i < numberOfPoints; i++)
{
float xPosition = shape.spline.GetPosition(i + 1).x + distance_Between_points;
shape.spline.InsertPointAt(i + 2, new Vector3(xPosition, TerrainDiversity * Mathf.PerlinNoise(i * Random.Range(5.0f, 5 + 10), 0)));
float random = Random.Range(1, TreeSpawning);
if (Tree && random == 1)
{
GameObject theTree = Instantiate(Tree, new Vector2(transform.position.x + shape.spline.GetPosition(i).x, shape.spline.GetPosition(i).y + 8), Quaternion.identity);
theTree.transform.localScale = new Vector3(Random.Range(1.8f, 2.2f), Random.Range(1.9f, 2.3f), Random.Range(1.8f, 2.2f));
}
}
for (int i = 2; i < numberOfPoints + 2; i++)
{
shape.spline.SetTangentMode(i, ShapeTangentMode.Continuous);
shape.spline.SetLeftTangent(i, new Vector3(-Edgesmoothness, 0, 0));
shape.spline.SetRightTangent(i, new Vector3(Edgesmoothness, 0, 0));
}
}
private Vector3 GetLastPoint(GameObject g)
{
SpriteShapeController spriteShapeController = g.GetComponent <SpriteShapeController>();
Vector3 point = Vector3.zero;
Spline s = spriteShapeController.spline;
int count = s.GetPointCount();
for (int i = 0; i < count; i++)
{
Vector3 temp = s.GetPosition(i);
if (temp.y <= -150f)
{
continue;
}
if (temp.x > point.x)
{
point = temp;
}
}
return(point);
}
public static SpriteShapeController CreateSpriteShapeControllerFromSelection()
{
var objName = "New SpriteShapeController";
GameObject gameObject = new GameObject(objName, typeof(SpriteShapeController));
SpriteShapeController spriteShapeController = gameObject.GetComponent <SpriteShapeController>();
if (Selection.activeObject is SpriteShape)
{
spriteShapeController.spriteShape = (SpriteShape)Selection.activeObject;
objName = spriteShapeController.spriteShape.name;
}
else if (Selection.activeObject is GameObject)
{
var activeGO = (GameObject)Selection.activeObject;
var prefabType = PrefabUtility.GetPrefabAssetType(activeGO);
if (prefabType != PrefabAssetType.Regular && prefabType != PrefabAssetType.Model)
{
GameObjectUtility.SetParentAndAlign(gameObject, activeGO);
}
}
gameObject.name = GameObjectUtility.GetUniqueNameForSibling(gameObject.transform.parent, objName);
Undo.RegisterCreatedObjectUndo(gameObject, Contents.createSpriteShapeString);
Selection.activeGameObject = gameObject;
spriteShapeController.spline.Clear();
SpriteShapeEditorAnalytics.instance.eventBus.spriteShapeRendererEvent.Invoke(gameObject.GetComponent <SpriteShapeRenderer>());
return(spriteShapeController);
}
void Awake()
{
if (!target)
{
target = GetComponent <SpriteShapeController>();
}
}
public static SpriteShapeController CreateSpriteShapeController()
{
GameObject gameObject = new GameObject("New SpriteShapeController", typeof(SpriteShapeController));
SpriteShapeController spriteShapeController = gameObject.GetComponent <SpriteShapeController>();
spriteShapeController.spline.Clear();
return(spriteShapeController);
}
static void SetToSquare(SpriteShapeController spriteShapeController)
{
spriteShapeController.spline.Clear();
spriteShapeController.spline.InsertPointAt(0, new Vector3(-kMaxSideSize, -kMaxSideSize, 0));
spriteShapeController.spline.InsertPointAt(1, new Vector3(-kMaxSideSize, kMaxSideSize, 0));
spriteShapeController.spline.InsertPointAt(2, new Vector3(kMaxSideSize, kMaxSideSize, 0));
spriteShapeController.spline.InsertPointAt(3, new Vector3(kMaxSideSize, -kMaxSideSize, 0));
}
void Awake()
{
transform.hasChanged = false;
if (myCollider is EdgeCollider2D)
{
spriteShapeController = GetComponent <SpriteShapeController>();
}
}
private int ResolveSpriteIndex(List <int> spriteIndices, ISelection selection, ref List <int> startPoints)
{
var spriteIndexValue = spriteIndices.FirstOrDefault();
SpriteShapeController sc = SplineEditorCache.GetTarget();
if (sc == null || sc.spriteShape == null)
{
return(-1);
}
// Either SpriteShape Asset or SpriteShape Data has changed.
List <ShapeAngleRange> angleRanges = GetAngleRangeSorted(sc.spriteShape);
if (m_SpriteShapeHashCode != sc.spriteShapeHashCode)
{
GenerateSegments(sc, angleRanges);
m_SpriteShapeHashCode = sc.spriteShapeHashCode;
m_SelectedPoint = -1;
}
if (sc.spriteShape != null)
{
if (selection.single != -1)
{
m_SelectedAngleRange = GetAngleRange(sc, selection.single, ref m_SelectedPoint);
startPoints.Add(m_SelectedPoint);
spriteIndexValue = m_Spline.GetSpriteIndex(m_SelectedPoint);
}
else
{
m_SelectedAngleRange = -1;
foreach (var index in selection)
{
int startPoint = index;
int angleRange = GetAngleRange(sc, index, ref startPoint);
if (m_SelectedAngleRange != -1 && angleRange != m_SelectedAngleRange)
{
m_SelectedAngleRange = -1;
break;
}
startPoints.Add(startPoint);
m_SelectedAngleRange = angleRange;
}
}
}
if (m_SelectedAngleRange != -1)
{
spriteSelector.UpdateSprites(sc.spriteShape.angleRanges[m_SelectedAngleRange].sprites.ToArray());
}
else
{
spriteIndexValue = -1;
}
return(spriteIndexValue);
}
void Awake()
{
if (groundEditable == null)
{
groundEditable = GameObject.FindWithTag("GroundEditable");
}
spriteShapeController = gameObject.GetComponent <SpriteShapeController>();
spline = spriteShapeController.spline;
}
public void setSSC(Object obj)
{
if (obj is GameObject)
{
SpriteShapeController ssc = ((GameObject)obj).GetComponent <SpriteShapeController>();
if (ssc)
{
this.ssc = ssc;
}
}
}
private void Start()
{
Vector3 pos = AvgVector(vertexPos);
pos.z = 5;
_vortex = Instantiate(vortexPrefab, pos, vortexPrefab.transform.rotation);
GameManager.GetInstance().OnEndingRoundEvent().AddListener(OnEndRound);
_spriteShape = GetComponent <SpriteShapeController>();
Destroy(gameObject, destructionTime);
StartCoroutine(StartTrigger(delayActivation));
}
private void Awake()
{
spriteShapeController = this.GetComponent <SpriteShapeController>();
positions = new Vector3[]
{
new Vector3(1, 1, 0),
new Vector3(1, -1, 0),
new Vector3(-1, -1, 0),
new Vector3(-1, 1, 0)
};
}
public static float MIN_POINT_DISTANCE = 0.05f;//the closest two adjacent points can be in a sprite shape spline
private static TerrainData convertToVectorPath(this SpriteShapeController ssc)
{
Vector2[] vectorPath = new Vector2[ssc.spline.GetPointCount()];
for (int i = 0; i < vectorPath.Length; i++)
{
vectorPath[i] = ssc.spline.GetPosition(i);
}
return(new TerrainData(
vectorPath,
ssc.gameObject
));
}
public void AddMapNode(Vector3 node)
{
// Bad practice :(
if (DataList == null)
{
DataList = new List <Vector3>();
rootShape = GetComponent <SpriteShapeController>();
}
DataList.Add(node);
UpdateRoots();
}
public IEnumerator Test8FindStartingPoint()
{
SpriteShapeController spriteShapeController = newSpriteShapeController(3);
spriteShapeController.spline.SetPosition(0, new Vector3(0, 0));
spriteShapeController.spline.SetPosition(1, new Vector3(1, -1));
spriteShapeController.spline.SetPosition(2, new Vector3(2, -1));
yield return(null);
Assert.AreEqual(0, SpriteShapeCalculator.FindStartingPointIndex(spriteShapeController, 1, new Vector2(0.5f, -0.5f)));
Assert.AreEqual(1, SpriteShapeCalculator.FindStartingPointIndex(spriteShapeController, 1, new Vector2(1.5f, -1f)));
}
// Awake is called when object is constructed
void Awake()
{
Line = this.transform.GetChild(0).gameObject;
Wall = this.transform.GetChild(1).gameObject;
Terrain = this.transform.GetChild(2).gameObject;
SpawnedObjects = this.transform.GetChild(3).gameObject;
lineSpriteShapeController = Line.GetComponent <SpriteShapeController>();
lineSpriteShapeController.spline.Clear();
terrainSpriteShapeController = Terrain.GetComponent <SpriteShapeController>();
terrainSpriteShapeController.spline.Clear();
}
static GameObject CreateDragGO(SpriteShape spriteShape, Vector3 position)
{
SpriteShapeController spriteShapeController = SpriteShapeEditorUtility.CreateSpriteShapeController();
GameObject gameObject = spriteShapeController.gameObject;
gameObject.transform.position = position;
gameObject.hideFlags = HideFlags.HideAndDontSave;
spriteShapeController.spriteShape = spriteShape;
SpriteShapeEditorUtility.SetShapeFromAsset(spriteShapeController);
return(gameObject);
}
public void UpdateOneStat(Stats _statToDebug, float StatToDebugValue)
{
if (shapeController == null)
{
shapeController = GetComponent <SpriteShapeController>();
}
float percentage = (StatToDebugValue / MaxStatValue(_statToDebug));
Vector3 newPointPos = GetStatMinPosition(_statToDebug) - ((GetStatMinPosition(_statToDebug) - GetStatMaxPosition(_statToDebug)) * percentage);
shapeController.spline.SetPosition((int)_statToDebug, newPointPos);
}
public IEnumerator Test225DegShape()
{
SpriteShapeController spriteShapeController = newSpriteShapeController(3);
spriteShapeController.spline.SetPosition(0, new Vector3(0, 0));
spriteShapeController.spline.SetPosition(1, new Vector3(-1, 0));
spriteShapeController.spline.SetPosition(2, new Vector3(-1, -1));
yield return(null);
Assert.AreEqual(180, SpriteShapeCalculator.Angle(spriteShapeController, 0));
Assert.AreEqual(225, SpriteShapeCalculator.Angle(spriteShapeController, 1));
Assert.AreEqual(270, SpriteShapeCalculator.Angle(spriteShapeController, 2));
}
static void SetToOctogon(SpriteShapeController spriteShapeController)
{
float kMaxSideSizeHalf = kMaxSideSize * 0.5f;
spriteShapeController.spline.Clear();
spriteShapeController.spline.InsertPointAt(0, new Vector3(-kMaxSideSizeHalf, -kMaxSideSize, 0));
spriteShapeController.spline.InsertPointAt(1, new Vector3(-kMaxSideSize, -kMaxSideSizeHalf, 0));
spriteShapeController.spline.InsertPointAt(2, new Vector3(-kMaxSideSize, kMaxSideSizeHalf, 0));
spriteShapeController.spline.InsertPointAt(3, new Vector3(-kMaxSideSizeHalf, kMaxSideSize, 0));
spriteShapeController.spline.InsertPointAt(4, new Vector3(kMaxSideSizeHalf, kMaxSideSize, 0));
spriteShapeController.spline.InsertPointAt(5, new Vector3(kMaxSideSize, kMaxSideSizeHalf, 0));
spriteShapeController.spline.InsertPointAt(6, new Vector3(kMaxSideSize, -kMaxSideSizeHalf, 0));
spriteShapeController.spline.InsertPointAt(7, new Vector3(kMaxSideSizeHalf, -kMaxSideSize, 0));
}
