private void OnLoadLevel(LevelAsset levelAsset)
{
towerParentObject.DestroyChildren();
var towerPrefab = levelAsset.TowerPrefab;
Instantiate(towerPrefab, towerParentObject.transform);
}
internal void SetData(LevelAsset data, LevelAsset save)
{
Texture2D image = new Texture2D(data.Width, data.Height);
float pixelsPerUnit = 0.2f;
if (data.Height > data.Width)
{
pixelsPerUnit = data.Height / Configs.LEVEL_ENTRANCE_FRAME_SIZE / Configs.SCREEN_WIDTH;
}
else
{
pixelsPerUnit = data.Width / Configs.LEVEL_ENTRANCE_FRAME_SIZE / Configs.SCREEN_WIDTH;
}
if (save != null)
{
image.SetPixels(save.Data);
}
else
{
Color[] greyed = new Color[data.Data.Length];
for (int i = 0; i < data.Data.Length; i++)
{
greyed[i] = SmallTricks.Utils.ConvertGreyscale(data.Data[i]);
}
image.SetPixels(greyed);
}
image.filterMode = FilterMode.Point;
image.Apply();
Art.sprite = Sprite.Create(image, new Rect(0.0f, 0.0f, image.width, image.height), new Vector2(0.5f, 0.5f), pixelsPerUnit);
mData = data;
mSave = save;
StartCoroutine(UpdateLoves());
}
public static List <LevelAsset> ConstructFromFolderCONFIG(string path)
{
Debug.LogWarning("ConstructFromFolderCONFIG is deprecated, please use ConstructFromFolder instead");
string[] Levels = Directory.GetFiles(path, "*.config");
List <LevelAsset> levelAssets = new List <LevelAsset>();
for (int i = 0; i < Levels.Length; i++)
{
string[] content = File.ReadAllLines(Levels[i]);
string imagePath = content[2];
byte[] imageData = File.ReadAllBytes(Environment.GetPath("demo") + "/" + imagePath);
Texture2D texture = new Texture2D(2, 2);
texture.LoadImage(imageData);
LevelAsset level = ScriptableObject.CreateInstance <LevelAsset>();
level.LevelName = content[0];
level.Difficulty = (DifficultyLevel)int.Parse(content[1]);
level.LevelTexture = texture;
levelAssets.Add(level);
Debug.Log("Created Level");
}
return(levelAssets);
}
public void EnterLevelSelect(WorldPin worldPin)
{
lastUsedPin = worldPin;
levelSelect.SetActive(true);
LevelAsset asset = DataUtils.loadLevelAsset(worldPin.worldType);
TextMeshProUGUI title = levelSelect.transform.GetChild(0).Find("title").GetComponent <TextMeshProUGUI>();
title.text = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(worldPin.worldType.ToString());
int i = 0;
int lastUnlocked = 0;
for (; i < asset.stageNames.Length; i++)
{
buttons[i].Init(this, asset.stageNames[i], title);
if (buttons[i].Unlocked && i > lastUnlocked)
{
lastUnlocked = i;
}
}
for (; i < buttons.Length; i++)
{
buttons[i].gameObject.SetActive(false);
}
buttons[lastUnlocked].GetComponent <Button>().onClick.Invoke();
}
public static void StartLevel(LevelAsset levelAsset)
{
s_CurrentLevel = levelAsset;
AsyncOperation operation = SceneManager.LoadSceneAsync(levelAsset.SceneAsset.name);
operation.completed += StartPlayer;
}
//Initialises panel using LevelAsset
private void InitPanel(LevelAsset _level)
{
LevelName.text = _level.LevelName;
/*Black magic - The ternery operator is a condensed form of 'if' statement
* if you wanna find out more google "C# ternery" */
Difficulty.text = (_level.Difficulty == DifficultyLevel.Easy ? "Easy" :
_level.Difficulty == DifficultyLevel.Medium ? "Medium" :
_level.Difficulty == DifficultyLevel.Hard ? "Hard" : "Extreme");
//Sets panel color based on level difficulty
if (Difficulty.text == "Easy")
{
gameObject.GetComponent <Image>().color = Easy;
}
else if (Difficulty.text == "Medium")
{
gameObject.GetComponent <Image>().color = Medium;
}
else if (Difficulty.text == "Hard")
{
gameObject.GetComponent <Image>().color = Hard;
}
else if (Difficulty.text == "Extreme")
{
gameObject.GetComponent <Image>().color = Extreme;
}
else //If there are something horrible has happened and there is no level
// difficulty default to gray.
{
gameObject.GetComponent <Image>().color = Color.gray;
}
}
//custom element to display the hex grid as toggle buttons and return the selection
Vector2 hexGrid(Vector2 selection, LevelAsset level, int hexSize, Rect gridRect)
{
GUILayout.BeginVertical();
for (int y = 0; y < level.gridHeight; y++)
{
GUILayout.BeginHorizontal();
if (y % 2 == 1)
{
GUILayout.Space(hexSize / 2);
}
for (int x = 0; x < level.gridWidth; x++)
{
Rect hexRect = new Rect(gridRect.x + x * hexSize + (y % 2 == 1 ? hexSize / 2 : 0), gridRect.y + y * hexSize, hexSize, hexSize);
if (level.grid[y][x] == null)
{
level.grid[y][x] = new HexInfo(x, y);
}
if (level.grid[y][x].pathId >= nextPathPoint)
{
nextPathPoint = level.grid[y][x].pathId + 1;
}
if (hexDisplay((x == selection.x && y == selection.y), level, level.grid[y][x], hexSize, hexRect))
{
selection = new Vector2(x, y);
}
}
if (y % 2 == 0)
{
GUILayout.Space(hexSize / 2);
}
GUILayout.EndHorizontal();
}
GUILayout.EndVertical();
return(selection);
}
public static void GameOver()
{
Debug.Log("GameOver");
StopPlaying();
SceneManager.UnloadSceneAsync(s_CurrentLevel.name);
s_CurrentLevel = AssetRoot.Levels[AssetRoot.Levels.Count - 1];
AsyncOperation operation = SceneManager.LoadSceneAsync("Scenes/GameOver");
}
private void ConstructLevel()
{
LevelAsset myTarget = (LevelAsset)target;
rootContainer = new GameObject();
rootContainer.transform.position = new Vector3(0, 0, -100);
cameraGameObject = new GameObject();
cameraGameObject.transform.position = new Vector3(0, 4, -100);
cameraGameObject.transform.eulerAngles = new Vector3(90, 0, 0);
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;
if (editorMode == EditorMode.Select)
{
var editorSelect = GameObject.Instantiate(Resources.Load <GameObject> ("EditorSelect"));
AssignObjectToGrid(editorSelect, (int)selectPos.x, (int)selectPos.z);
editorSelect.transform.localPosition = new Vector3(editorSelect.transform.localPosition.x, 2, editorSelect.transform.localPosition.z);
}
foreach (var tile in myTarget.Tiles)
{
var gameObjectTile = GameObject.Instantiate(Resources.Load <GameObject>("Tile"));
foreach (var piece in tile.Pieces)
{
GameObject tilePiece = null;
if (piece.PieceType == PieceType.Hero)
{
tilePiece = GameObject.Instantiate(Resources.Load <GameObject>("Hero"));
}
if (piece.PieceType == PieceType.GoalPos)
{
tilePiece = GameObject.Instantiate(Resources.Load <GameObject>("GoalPos"));
}
if (piece.PieceType == PieceType.Cube)
{
tilePiece = GameObject.Instantiate(Resources.Load <GameObject>("Stand"));
}
if (tilePiece != null)
{
tilePiece.transform.parent = gameObjectTile.transform;
tilePiece.transform.localEulerAngles = new Vector3(0, 0, 0);
tilePiece.transform.localPosition = new Vector3(0, -0.5f, 0);
}
}
AssignObjectToGrid(gameObjectTile, (int)tile.Pos.x, (int)tile.Pos.z);
}
SetHideFlagsRecursively(rootContainer);
}
public static void DispatchSetGameData(LevelAsset level, LevelAsset save)
{
ReceivedActions.Enqueue(() =>
{
self.Level = level;
self.Save = save;
self.InitWorld();
self.InitPallete();
});
}
public void LoadLevel(LevelAsset level)
{
if (level == null || level.LevelTexture == null)
{
Debug.LogError("Incomplete level asset: " + level.name);
return;
}
GameStarted = false;
m_LevelToLoad = level;
SceneManager.LoadScene("LevelScene");
}
internal void UpdateSavedData(string key, LevelAsset data)
{
if (AllSaves.ContainsKey(key))
{
AllSaves[key] = data;
}
else
{
AllSaves.Add(key, data);
}
}
public LevelAsset Convert()
{
LevelAsset level = ScriptableObject.CreateInstance <LevelAsset>();
level.LevelName = name;
level.Difficulty = (DifficultyLevel)difficulty;
level.PublicKey = PublicKey;
level.PrivateKey = PrivateKey;
level.SaveKey = Savekey;
Texture2D tex = new Texture2D(1, 1);
tex.LoadImage(image);
level.LevelTexture = tex;
return(level);
}
// Use this for initialization
void Awake()
{
//Parses our inspector list to a dictionary
for (int i = 0; i < pairs.Length; i++)
{
pairs[i].tile.name = pairs[i].Name;
objectDictionary.Add(pairs[i].Key, pairs[i].tile);
}
//TODO: WTF is this! The map creator class should probably be a service clas
// that could have a level object passes to it along with a world object
// to attach the necessary objects to
currentLevel = GameManager.ins.LevelToLoad;
Player = GameManager.ins.Player;
}
private void OnLoadLevel(LevelAsset level)
{
switch (type)
{
case Type.Title:
textComponent.text = level.LevelName;
break;
case Type.Description:
textComponent.text = level.LevelDescription;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
private void InitWorld()
{
GameCamera.transform.position = new Vector3(Level.Width / 2, Level.Height / 2, -20);
if (Save == null)
{
Save = new LevelAsset(Level, true);
}
for (int i = 0; i < Level.Data.Length; i++)
{
int y = i / Level.Width;
int x = i - y * Level.Width;
Color color = Level.Data[i];
Vector3Int pos = new Vector3Int(x, y, 0);
Canvas.SetTileFlags(pos, TileFlags.None);
Canvas.SetTile(pos, WhiteTile);
Canvas.SetTileFlags(pos, TileFlags.None);
Canvas.SetColor(pos, Save.Data[i]);
MarkerOverlay.SetTileFlags(pos, TileFlags.None);
if (color.a != 0f)
{
MarkerOverlay.SetTile(pos, Markers[Array.IndexOf(Level.Palette, color)]);
}
}
// zoom camera properly
int heightPixels = (int)(Level.Height / Configs.ART_IN_WINDOW_RATIO);
int widthPixels = (int)(Level.Width / Configs.ART_IN_WINDOW_RATIO);
float camSize = Configs.ZOOM_MIN;
if (heightPixels / widthPixels > Configs.WINDOW_RATIO)
{
// too high
camSize = heightPixels / Configs.WINDOW_RATIO / Configs.PIXEL_WIDTH_CAM_RATIO;
}
else
{
// too wide
camSize = widthPixels / Configs.PIXEL_WIDTH_CAM_RATIO;
}
GameController.ZoomTo(camSize);
}
public void loadLevel(LevelAsset level, Spawner start)
{
clearGrid();
setUpGrid(level.gridWidth, level.gridHeight);
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
grid[y, x].setHeight(level.grid[y][x].height);
grid[y, x].locked = level.grid[y][x].path;
grid[y, x].path = level.grid[y][x].path;
grid[y, x].pathId = level.grid[y][x].pathId;
grid[y, x].setColor(level.colors[level.grid[y][x].color]);
if (level.grid[y][x].start)
{
GameObject newSpawn = Instantiate(start.gameObject, grid[y, x].transform.position + grid[y, x].spawnOffset, Quaternion.identity) as GameObject;
Spawner spawn = newSpawn.GetComponent <Spawner>();
spawn.startNode = grid[y, x];
spawn.setWave(0);
spawners.Add(spawn);
}
grid[y, x].nextNodes = new List <HexController>();
for (int i = 0; i < 6; i++)
{
bool active = ((level.grid[y][x].nextPositions & (1 << i)) != 0);
if (active)
{
Vector2 pathPoint = (y % 2 == 0) ? HexInfo.pathPointsEven[i] : HexInfo.pathPointsOdd[i];
Vector2 next = level.grid[y][x].position + pathPoint;
if (next.x >= 0 && next.y >= 0 && next.x < width && next.y < height)
{
grid[y, x].nextNodes.Add(grid[(int)next.y, (int)next.x]);
}
}
}
}
}
}
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;
}
}
}
public void Load(object context, LevelAsset levelAsset, Func<IPlan, object, bool> filter)
{
var reader = _kernel.Get<ILevelReader>(_currentNode, levelAsset.LevelDataFormat.ToString());
var levelBytes = Encoding.ASCII.GetBytes(levelAsset.LevelData);
var node = _kernel.Hierarchy.Lookup(context);
using (var stream = new MemoryStream(levelBytes))
{
foreach (var entity in reader.Read(stream, context, filter))
{
var existingNode = _kernel.Hierarchy.Lookup(entity);
if (existingNode != null)
{
// Remove it from the hierarchy if it's already there.
_kernel.Hierarchy.RemoveNode(existingNode);
}
_kernel.Hierarchy.AddChildNode(node, existingNode);
}
}
}
void OnGUI()
{
//string[] filePaths = Directory.GetFiles(@"\Assets\Levels", "*.asset");
LevelAsset[] levels = AssetDatabase.LoadAllAssetsAtPath("Assets/Levels/*") as LevelAsset[];
if (levels != null)
{
foreach (LevelAsset level in levels)
{
GUILayout.Label(level.name);
}
}
//if(filePaths != null)
// foreach(string file in filePaths)
// GUILayout.Label(file);
GUILayout.BeginHorizontal();
GUILayout.BeginVertical();
GUILayout.Label("Width:");
GUILayout.Label("Height:");
GUILayout.EndVertical();
GUILayout.BeginVertical();
width = EditorGUILayout.IntField(width);
height = EditorGUILayout.IntField(height);
GUILayout.EndVertical();
GUILayout.EndHorizontal();
newLevelName = GUILayout.TextField(newLevelName);
if (GUILayout.Button("New Level"))
{
LevelAsset newLevel = ScriptableObject.CreateInstance(typeof(LevelAsset)) as LevelAsset;
AssetDatabase.CreateAsset(newLevel, "Assets/Levels/" + newLevelName + ".asset");
//PrefabUtility.InstantiatePrefab(hexObject);
//setUpGrid(width, height);
//hexGrid.setUpGrid(width, height);
}
}
public LevelAsset(LevelAsset asset, bool toGray)
{
Name = asset.Name;
Width = asset.Width;
Height = asset.Height;
Palette = new Color[asset.Palette.Length];
for (int i = 0; i < Palette.Length; i++)
{
Palette[i] = new Color(asset.Palette[i].r, asset.Palette[i].g, asset.Palette[i].b, asset.Palette[i].a);
}
Data = new Color[asset.Data.Length];
for (int i = 0; i < Data.Length; i++)
{
if (toGray)
{
Data[i] = SmallTricks.Utils.ConvertGreyscale(asset.Data[i]);
}
else
{
Data[i] = new Color(asset.Data[i].r, asset.Data[i].g, asset.Data[i].b, asset.Data[i].a);
}
}
}
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 void OnLoadLevel(LevelAsset levelAsset)
{
bulletListAsset = levelAsset.BulletList;
currentBulletIndex = 0;
remainingItemsSignal.Dispatch(bulletListAsset.Prefabs.Length);
}
public override void OnInspectorGUI()
{
bool reconstruct = false;
LevelAsset myTarget = (LevelAsset)target;
var editorModeCached = editorMode;
string[] editorModeOptions = { "Select", "Add" };
editorMode = (EditorMode)EditorGUILayout.Popup("Mode", (int)editorMode, editorModeOptions);
if (editorModeCached != editorMode)
{
reconstruct = true;
}
if (editorMode == EditorMode.Add)
{
string[] pieceOptions = Enum.GetNames(typeof(PieceType));
pieceType = (PieceType)EditorGUILayout.Popup("Piece Type", (int)pieceType, pieceOptions);
}
if (cameraGameObject != null)
{
EditorGUI.DrawPreviewTexture(new Rect(0 + windowOffset.x, 0 + windowOffset.y, windowSize.x, windowSize.y), editorRenderTexture);
}
var tmpMousePos = Event.current.mousePosition;
tmpMousePos -= windowOffset;
tmpMousePos -= windowSize * 0.5f;
var mousePosInGrid = new Vector3(Mathf.RoundToInt(tmpMousePos.x / windowGridSize), 0, -Mathf.RoundToInt(tmpMousePos.y / windowGridSize));
if (Event.current.type == EventType.MouseDown && IsPositionWithinWindow(Event.current.mousePosition))
{
if (editorMode == EditorMode.Select)
{
selectPos = mousePosInGrid;
selectableTile = myTarget.Tiles.Find(x => { return(x.Pos == mousePosInGrid); });
reconstruct = true;
}
else if (editorMode == EditorMode.Add)
{
if (pieceType == PieceType.Tile)
{
if (Event.current.button == 0)
{
if (!myTarget.Tiles.Exists(x => { return(x.Pos == mousePosInGrid); }))
{
myTarget.Tiles.Add(new TileData(mousePosInGrid));
reconstruct = true;
}
}
if (Event.current.button == 1)
{
var posibleTile = myTarget.Tiles.Find(x => { return(x.Pos == mousePosInGrid); });
if (posibleTile != null)
{
myTarget.Tiles.Remove(posibleTile);
reconstruct = true;
}
}
}
else
{
var posibleTile = myTarget.Tiles.Find(x => { return(x.Pos == mousePosInGrid); });
if (Event.current.button == 0)
{
if (posibleTile != null && posibleTile.Pieces.Count == 0)
{
posibleTile.Pieces.Add(new PieceData(pieceType));
reconstruct = true;
}
}
if (Event.current.button == 1)
{
if (posibleTile != null && posibleTile.Pieces.Count != 0)
{
posibleTile.Pieces = new List <PieceData>();
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.01f;
cameraGameObject.transform.position += new Vector3(mouseDir.x, 0, -mouseDir.y);
mousePos = Event.current.mousePosition;
}
}
if (reconstruct)
{
DestroyLevel();
ConstructLevel();
}
if (editorMode == EditorMode.Select && selectableTile != null)
{
EditorGUILayout.BeginVertical();
GUILayout.Space(windowOffset.y + windowSize.y);
ReorderableListGUI.Title("Selection");
ReorderableListGUI.ListField <PieceData>(selectableTile.Pieces, SelectionOfPieceDrawer);
EditorGUILayout.EndVertical();
}
EditorUtility.SetDirty(myTarget);
}
private LevelAsset.SubPuzzleNode GetSubPuzzleNode(LevelAsset levelAsset)
{
return(levelAsset.subPuzzleNodes[0]);
}
/// <summary>
/// Loads a level entity into the game hierarchy, with the specified
/// context as the place to load entities. Normally you'll pass in the
/// game world here, but you don't have to. For example, if you wanted to
/// load the level into an entity group, you would pass the entity group
/// as the context instead.
/// </summary>
/// <param name="context">Usually the current game world, but can be any object in the hierarchy.</param>
/// <param name="levelAsset">The level to load.</param>
public void Load(object context, LevelAsset levelAsset)
{
Load(context, levelAsset, null);
}
public void ClearSaveData(LevelAsset level)
{
SimpleSerializer.ClearKey(level.SaveKey);
}
public void ResetData(LevelAsset level)
{
ClearSaveData(level);
level.LevelData.SaveTime = 0f;
level.LevelData.Offset = Vector2.zero;
}
//custom element to display the hex in the grid
//provides more buttons for the selected cell
bool hexDisplay(bool toggle, LevelAsset level, HexInfo hex, int hexSize, Rect hexRect)
{
//if not toggled, display empty hex with info
if (!toggle)
{
Color tempColor = GUI.backgroundColor;
Color color;
if (level.colors != null && hex.color < level.colors.Length)
{
color = level.colors[hex.color];
}
else
{
color = Color.white;
}
color.a = 1;
GUI.backgroundColor = color;
string content = "" + hex.pathId;
toggle = GUILayout.Toggle(toggle, content, skin.customStyles[0], GUILayout.Height(hexSize), GUILayout.Width(hexSize));
GUI.backgroundColor = tempColor;
}
//if it is toggled, display the more complex button
else
{
GUILayout.Space(hexSize);
//path gui contains the toggle in the center and toggles for next positions on each edge
if (hex.path)
{
Color tempColor = GUI.color;
Color color;
if (level.colors != null && hex.color < level.colors.Length)
{
color = level.colors[hex.color];
}
else
{
color = Color.white;
}
color.a = 1;
GUI.color = color;
GUI.DrawTexture(hexRect, hexBackTex);
//bool result = GUI.Button(hexRect, hexBack, skin.customStyles[0]);
if (alphaButton(hexRect, hexInnerTex))
{
setBase(hex);
}
Vector2[] pathPoints = (((int)hex.position.y) % 2) == 0 ? HexInfo.pathPointsEven : HexInfo.pathPointsOdd;
//draw each segment button
for (int i = 0; i < 6; i++)
{
bool active = ((hex.nextPositions & (1 << i)) != 0);
bool result = alphaToggle(active, hexRect, hexSegmentTexs[i]);
if (active && !result)
{
hex.nextPositions = (byte)(hex.nextPositions & (~(1 << i)));
}
else if (!active && result)
{
hex.nextPositions = (byte)(hex.nextPositions | (byte)(1 << i));
Vector2 next = hex.position + pathPoints[i];
if (next.x >= 0 && next.y >= 0 && next.x < level.gridWidth && next.y < level.gridHeight && !level.grid[(int)next.y][(int)next.x].path)
{
setPath(level.grid[(int)next.y][(int)next.x]);
}
}
}
GUI.color = tempColor;
GUI.Label(hexRect, "" + hex.pathId, skin.label);
}
//base gui only contains the toggle in the center
else
{
Color tempColor = GUI.color;
Color color;
if (level.colors != null && hex.color < level.colors.Length)
{
color = level.colors[hex.color];
}
else
{
color = Color.white;
}
color.a = 1;
GUI.color = color;
GUI.DrawTexture(hexRect, hexBackTex);
//bool result = GUI.Button(hexRect, hexBack, skin.customStyles[0]);
if (alphaButton(hexRect, hexInnerTex))
{
setPath(hex);
}
GUI.color = tempColor;
GUI.Label(hexRect, "" + hex.pathId, skin.label);
}
}
return(toggle);
}
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);
}
public override void OnInspectorGUI()
{
if (skin == null)
{
skin = EditorGUIUtility.Load("LevelEditorSkin.guiskin") as GUISkin;
}
if (hexBackTex == null)
{
hexBackTex = EditorGUIUtility.Load("Textures/hexagon_back.png") as Texture2D;
}
if (hexInnerTex == null)
{
hexInnerTex = EditorGUIUtility.Load("Textures/hexagon_inner.png") as Texture2D;
}
for (int i = 0; i < 6; i++)
{
if (hexSegmentTexs[i] == null)
{
hexSegmentTexs[i] = EditorGUIUtility.Load("Textures/hexagon_" + i + ".png") as Texture2D;
}
}
//let the default inspector handle the easy stuff
DrawDefaultInspector();
LevelAsset level = target as LevelAsset;
//make sure that the grid is the correct size, also initiallizes any nulls
if (level.grid == null || level.grid.Count != level.gridHeight || (level.grid.Count != 0 && level.grid[0].Count != level.gridWidth))
{
level.grid = createGrid(level.gridWidth, level.gridHeight, level.grid);
}
//grid editor
showGrid = EditorGUILayout.Foldout(showGrid, "Grid");
if (Event.current.type == EventType.Repaint)
{
gridShowRect = GUILayoutUtility.GetLastRect();
}
if (showGrid)
{
if (level.grid != null && level.grid.Count == level.gridHeight && level.grid.Count > 0 && level.grid[0].Count == level.gridWidth)
{
gridRect = new Rect(gridShowRect.x, gridShowRect.yMax, hexSize * level.gridHeight, hexSize * level.gridWidth);
gridSelection = hexGrid(gridSelection, level, hexSize, gridRect);
//GUILayout.Space(level.gridHeight * hexSize);
}
else
{
GUILayout.Label("Grid size changed, recreate grid");
}
}
//next path point
GUILayout.BeginHorizontal();
GUILayout.Label("Next Path ID");
nextPathPoint = EditorGUILayout.IntField(nextPathPoint);
GUILayout.EndHorizontal();
//grid selection editor, changes HexInfo values for selected cell
if (gridSelection.x != -1 && level.grid.Count != 0 && level.grid[0].Count != 0)
{
showHex = EditorGUILayout.Foldout(showHex, "Hex " + gridSelection.ToString());
if (showHex && gridSelection.y < level.grid.Count && gridSelection.x < level.grid[0].Count)
{
hexEditor(level.grid[(int)gridSelection.y][(int)gridSelection.x]);
}
}
//preset menu for base cells
showBasePreset = EditorGUILayout.Foldout(showBasePreset, "Base Preset");
if (showBasePreset)
{
GUILayout.BeginHorizontal();
GUILayout.Space(15);
GUILayout.BeginVertical();
GUILayout.Label("Color");
GUILayout.Label("Height");
GUILayout.EndVertical();
GUILayout.BeginVertical();
baseColor = EditorGUILayout.IntField(baseColor);
baseHeight = EditorGUILayout.FloatField(baseHeight);
GUILayout.EndVertical();
GUILayout.EndHorizontal();
}
//preset menu for path cells
showPathPreset = EditorGUILayout.Foldout(showPathPreset, "Path Preset");
if (showPathPreset)
{
GUILayout.BeginHorizontal();
GUILayout.Space(15);
GUILayout.BeginVertical();
GUILayout.Label("Color");
GUILayout.Label("Height");
GUILayout.EndVertical();
GUILayout.BeginVertical();
pathColor = EditorGUILayout.IntField(pathColor);
pathHeight = EditorGUILayout.FloatField(pathHeight);
GUILayout.EndVertical();
GUILayout.EndHorizontal();
}
//tells the editor to save the changes to disk
EditorUtility.SetDirty(level);
}
public Task LoadAsync(object context, LevelAsset levelAsset)
{
Load(context, levelAsset);
return new Task(() => { });
}
public Task LoadAsync(object context, LevelAsset levelAsset, Func<IPlan, object, bool> filter)
{
Load(context, levelAsset, filter);
return new Task(() => { });
}
public static void DispatchRenderLevels()
{
ReceivedActions.Enqueue(() =>
{
// fill saves
foreach (KeyValuePair <string, LevelAsset> entry in DataManager.Instance.AllSaves)
{
LevelAsset levelData = null;
if (DataManager.Instance.AllLevels.TryGetValue(entry.Key, out levelData))
{
// love first
if (DataManager.Instance.LoveLevels.Contains(entry.Key))
{
if (!self.FavoriteViewObjects.HasLoad(entry.Key))
{
GameObject go = Instantiate(self.LevelEntrancePrefab);
LevelEntrance le = go.GetComponent <LevelEntrance>();
le.SetData(levelData, entry.Value);
le.beloved = true;
self.FavoriteViewObjects.AddChild(go, entry.Key);
}
}
else
{
if (!self.TrendingViewObjects.HasLoad(entry.Key))
{
GameObject go = Instantiate(self.LevelEntrancePrefab);
LevelEntrance le = go.GetComponent <LevelEntrance>();
le.SetData(levelData, entry.Value);
self.TrendingViewObjects.AddChild(go, entry.Key);
}
}
}
else
{
Debug.LogWarning("Has save data without level data");
}
}
// fill all levels
foreach (KeyValuePair <string, LevelAsset> entry in DataManager.Instance.AllLevels)
{
if (!DataManager.Instance.AllSaves.ContainsKey(entry.Key))
{
if (DataManager.Instance.LoveLevels.Contains(entry.Key))
{
if (!self.FavoriteViewObjects.HasLoad(entry.Key))
{
GameObject go = Instantiate(self.LevelEntrancePrefab);
LevelEntrance le = go.GetComponent <LevelEntrance>();
le.SetData(entry.Value, null);
le.beloved = true;
self.FavoriteViewObjects.AddChild(go, entry.Key);
}
}
else
{
if (!self.TrendingViewObjects.HasLoad(entry.Key))
{
GameObject go = Instantiate(self.LevelEntrancePrefab);
LevelEntrance le = go.GetComponent <LevelEntrance>();
le.SetData(entry.Value, null);
self.TrendingViewObjects.AddChild(go, entry.Key);
}
}
}
}
if (DataManager.Instance.LoveLevels.Count == 0)
{
self.TrendingToggle.OnClicked();
self.OnClickedTrending();
}
self.TrendingViewObjects.transform.parent.GetComponent <TrendingContents>().CompleteLoad();
});
}
