private void ConstructLevel()
{
LevelAsset myTarget = (LevelAsset)target;
rootContainer = new GameObject();
rootContainer.transform.position = new Vector3(0, 0, 0);
cameraGameObject = new GameObject();
cameraGameObject.transform.position = new Vector3(0, 0, -100);
var camera = cameraGameObject.AddComponent <Camera> ();
cameraGameObject.hideFlags = HideFlags.HideAndDontSave;
camera.orthographic = true;
camera.clearFlags = CameraClearFlags.Color;
camera.backgroundColor = windowBackgroundColor;
editorRenderTexture = Resources.Load("EditorRenderTexture") as RenderTexture;
camera.targetTexture = editorRenderTexture;
levelEditorNode = Resources.Load("LevelEditorNode") as GameObject;
levelEditorPuzzlePivot = Resources.Load("levelEditorPuzzlePivot") as GameObject;
nodeAssetDictionary = LevelAssetHelper.ConstructDictionary(myTarget.subPuzzleNodes);
nodeDictionary = new Dictionary <string, LevelEditorNode>();
var rootNode = nodeAssetDictionary [""][0];
SpawnNode(rootNode, new Vector2(0, 4));
LevelEditorNode selectedNode;
if (!string.IsNullOrEmpty(selectableNodeId))
{
nodeDictionary.TryGetValue(selectableNodeId, out selectedNode);
if (selectedNode != null)
{
var pivot = selectedNode.puzzlePivots [selectablePuzzlePivotId];
var renderer = pivot.GetComponent <MeshRenderer> ();
var tempMaterial = new Material(renderer.sharedMaterial);
tempMaterial.color = Color.green;
renderer.sharedMaterial = tempMaterial;
}
}
}
void Start()
{
if (Director.Instance.IsAlternativeLevel)
{
additionalPieces = 1;
}
if (levelOverride == null)
{
level = Director.LevelDatabase.levels [Director.Instance.LevelIndex];
}
else
{
level = levelOverride;
}
numberOfPieces = level.numberOfPieces + new Vector2(additionalPieces, additionalPieces);
ZoomScale = numberOfPieces.x;
startScale = transform.localScale;
nodeAssetDictionary = LevelAssetHelper.ConstructDictionary(level.subPuzzleNodes);
StartCoroutine(SpawnInitialSubPuzzle());
}
private IEnumerator SpawnExtraPivots(GameObject pivot, int numberOfPivots)
{
var newPuzzlePivots = new List <PuzzlePivot>();
for (int i = 0; i < numberOfPivots; i++)
{
var additionalPieces = 0;
if (Director.Instance.IsAlternativeLevel)
{
additionalPieces = 1;
}
var numberOfPieces = nodeAsset.puzzlePivots[i].numberOfPieces + new Vector2(1, 1) * additionalPieces;
var newPuzzlePivot = SpawnExtraPivot(pivot, nodeAsset.puzzlePivots[i].type, numberOfPieces);
newPuzzlePivot.subPuzzle = this;
newPuzzlePivots.Add(newPuzzlePivot);
if (nodeAsset.collectable.isActive && i == numberOfPivots - 1)
{
collectableHelper.SpawnCollectable(newPuzzlePivot, nodeAsset.collectable.position, nodeAsset.collectable.scale);
}
}
// Wait 3 frames
for (int i = 0; i < 3; i++)
{
yield return(null);
}
foreach (var newPuzzlePivot in newPuzzlePivots)
{
yield return(SetupExtraPivot(newPuzzlePivot));
yield return(null);
}
var childrenNodes = LevelAssetHelper.GetChildrenNodes(gameBoard.nodeAssetDictionary, id);
if (childrenNodes.Count > 0)
{
var newSubPuzzleLayer = subPuzzleLayer + 1;
ArrangePiecePosition(activePuzzlePivot.pieces);
gameBoard.ZoomToLayer(newSubPuzzleLayer);
int n = 0;
foreach (var childrenNode in childrenNodes)
{
var piece = activePuzzlePivot.pieces[n];
var scale = 4;
var aspectRatio = piece.transform.localScale.y / piece.transform.localScale.x;
var pictureSize = new Vector2(scale, scale * aspectRatio);
var subPuzzle = GameObject.Instantiate(gameBoard.subPuzzlePrefab).GetComponent <SubPuzzle> ();
subPuzzle.Initialize(gameBoard, childrenNode.id, newSubPuzzleLayer, pictureSize);
subPuzzle.transform.parent = piece.transform.parent;
subPuzzle.transform.localPosition = piece.transform.localPosition;
subPuzzle.parentSubPuzzle = this;
subPuzzle.SpawnSubPuzzle();
subPuzzle.ActivateSubPuzzle();
subPuzzle.completedSubPuzzle += () => {
piece.gameObject.SetActive(true);
if (AlllSubPuzzlesComplete())
{
backgroundQuad.GetComponent <MeshRenderer> ().enabled = true;
}
SetActiveSubPuzzle(subPuzzle);
};
subPuzzles.Add(subPuzzle);
n++;
}
// Wait 3 frames
for (int i = 0; i < 3; i++)
{
yield return(null);
}
for (int i = 0; i < n; i++)
{
activePuzzlePivot.pieces[i].gameObject.SetActive(false);
}
backgroundQuad.GetComponent <MeshRenderer> ().enabled = false;
var camera = GameObject.Find("CameraPivot/Main Camera");
var newPos = camera.transform.position - subPuzzles [0].gameObject.transform.position;
newPos.z = 0;
gameBoard.transform.position += newPos;
SetActiveSubPuzzle(subPuzzles [0], false);
}
}
public override void OnInspectorGUI()
{
if (EditorApplication.isPlaying)
{
return;
}
bool reconstruct = false;
LevelAsset myTarget = (LevelAsset)target;
var editorModeCached = editorMode;
string[] editorModeOptions = { "Select", "Add" };
if (GUILayout.Button("Play Level"))
{
DestroyLevel();
EditorApplication.isPlaying = false;
EditorSceneManager.OpenScene("Assets/Scenes/LevelScene.unity");
var gameBoard = GameObject.Find("GameBoard").GetComponent <GameBoard> ();
gameBoard.levelOverride = myTarget;
EditorApplication.isPlaying = true;
}
myTarget.isMasterPuzzle = EditorGUILayout.Toggle("IsMasterPuzzle:", myTarget.isMasterPuzzle);
editorMode = (EditorMode)EditorGUILayout.Popup("Mode", (int)editorMode, editorModeOptions);
myTarget.picture = EditorGUILayout.ObjectField("GoalTexture", myTarget.picture, typeof(Texture), false) as Texture;
if (GUILayout.Button("Clear Nodes"))
{
myTarget.subPuzzleNodes.Clear();
myTarget.subPuzzleNodes.Add(new LevelAsset.SubPuzzleNode("0"));
reconstruct = true;
}
if (editorModeCached != editorMode)
{
reconstruct = true;
}
if (cameraGameObject != null)
{
EditorGUI.DrawPreviewTexture(new Rect(0 + windowOffset.x, 0 + windowOffset.y, windowSize.x, windowSize.y), editorRenderTexture);
}
var selectionId = "0";
if (editorMode == EditorMode.Select && !string.IsNullOrEmpty(selectableNodeId))
{
selectionId = selectableNodeId;
}
if (!string.IsNullOrEmpty(selectableNodeId))
{
EditorGUILayout.BeginVertical();
GUILayout.Space(windowOffset.y + windowSize.y);
var selectedNodeAsset = LevelAssetHelper.GetNodeAsset(nodeAssetDictionary, selectableNodeId);
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("SelectionId:");
EditorGUILayout.LabelField(selectionId);
EditorGUILayout.EndHorizontal();
var puzzlePivotAsset = selectedNodeAsset.puzzlePivots [selectablePuzzlePivotId];
puzzlePivotAsset.numberOfPieces = EditorGUILayout.Vector2Field("Number of Pieces:", puzzlePivotAsset.numberOfPieces);
puzzlePivotAsset.type = (PuzzlePivotType)EditorGUILayout.EnumPopup("Type:", puzzlePivotAsset.type);
selectedNodeAsset.collectable.isActive = EditorGUILayout.Toggle("Has Collectable:", selectedNodeAsset.collectable.isActive);
if (selectedNodeAsset.collectable.isActive)
{
selectedNodeAsset.collectable.position = EditorGUILayout.Vector2Field("Position of collectable:", selectedNodeAsset.collectable.position);
selectedNodeAsset.collectable.scale = EditorGUILayout.Vector2Field("Scale of collectable:", selectedNodeAsset.collectable.scale);
}
EditorGUILayout.EndVertical();
if (GUILayout.Button("Add PuzzlePivot"))
{
selectedNodeAsset.puzzlePivots.Add(new LevelAsset.PuzzlePivot());
reconstruct = true;
}
if (GUILayout.Button("Add Node"))
{
myTarget.subPuzzleNodes.Add(new LevelAsset.SubPuzzleNode(selectedNodeAsset.id + "-" + LevelAssetHelper.GetChildrenNodes(nodeAssetDictionary, selectedNodeAsset.id).Count));
reconstruct = true;
}
}
var tmpMousePos = Event.current.mousePosition;
tmpMousePos -= windowOffset;
tmpMousePos -= windowSize * 0.5f;
if (Event.current.type == EventType.MouseDown && IsPositionWithinWindow(Event.current.mousePosition))
{
if (editorMode == EditorMode.Select)
{
var mousePosInWindow = new Vector3(tmpMousePos.x / 50, -tmpMousePos.y / 50, 0);
var hits = Physics.RaycastAll(cameraGameObject.transform.position + mousePosInWindow, Vector3.forward, 200);
selectableNodeId = String.Empty;
if (hits.Length > 0)
{
if (hits [0].collider.gameObject.GetComponent <LevelEditorNode> () != null)
{
selectableNodeId = hits[0].collider.gameObject.GetComponent <LevelEditorNode>().nodeId;
}
if (hits [0].collider.gameObject.GetComponent <LevelEditorPuzzlePivot> () != null)
{
var levelEditorPuzzlePivot = hits [0].collider.gameObject.GetComponent <LevelEditorPuzzlePivot> ();
selectableNodeId = levelEditorPuzzlePivot.parent.nodeId;
selectablePuzzlePivotId = levelEditorPuzzlePivot.parent.puzzlePivots.IndexOf(levelEditorPuzzlePivot);
}
}
reconstruct = true;
}
}
if (Event.current.button == 2)
{
if (Event.current.type == EventType.MouseDown)
{
mousePos = Event.current.mousePosition;
}
if (Event.current.type == EventType.MouseDrag)
{
var mouseDir = (mousePos - Event.current.mousePosition) * 0.02f;
cameraGameObject.transform.position += new Vector3(mouseDir.x, -mouseDir.y, 0);
mousePos = Event.current.mousePosition;
}
}
if (reconstruct)
{
DestroyLevel();
ConstructLevel();
}
EditorUtility.SetDirty(myTarget);
}
