public override void OnMouseMove(Point location)
{
if (moving)
{
Point move = new Point(location.X - mouseStart.X, location.Y - mouseStart.Y);
if (!Util.Ctrl)
{
move = LayerEditor.Layer.Definition.SnapToGrid(move);
}
move = new Point(move.X - moved.X, move.Y - moved.Y);
if (move.X != 0 || move.Y != 0)
{
if (resizeAction == null)
{
LevelEditor.Perform(resizeAction = new EntityResizeAction(LayerEditor.Layer, Ogmo.EntitySelectionWindow.Selected, new Size(move.X, move.Y)));
}
else
{
resizeAction.DoAgain(new Size(move.X, move.Y));
}
moved = new Point(move.X + moved.X, move.Y + moved.Y);
Ogmo.EntitySelectionWindow.RefreshSize();
}
}
}
public override void GetEditableAttributes(LevelEditor levelEditor)
{
Rect guiRect = new Rect((Screen.width / 2) - 140, (Screen.height / 2) - 110, 110, 20);
_gravityHandler.IsInverted = GUI.Toggle(guiRect, _gravityHandler.IsInverted, "Invert Gravity");
_initVerticalOrientation = _gravityHandler.IsInverted;
}
void Awake()
{
S = this;
canvas = GameObject.Find("EditorUI").GetComponent <Canvas>();
Interfacing.CreateEntity = CreateEntity;
Interfacing.PerformInterfaceSpawn = PerformInterfaceSpawn;
Interfacing.PerformInterfaceDie = PerformInterfaceDie;
Interfacing.PerformInterfaceTeleport = PerformInterfaceTeleport;
Interfacing.PerformInterfaceUpdateRotation = PerformInterfaceUpdateRotation;
var instrPanel = canvas.transform.Find("InstrPanel");
instrPanel.Find("Passability").GetComponent <StickyButton>().PressedChanged += OnPassabilityModeChanged;
instrPanel.Find("EntitySet").GetComponent <StickyButton>().PressedChanged += (obj, val) => isInEntitySetMode = val;
instrPanel.Find("Runes").GetComponent <StickyButton>().PressedChanged += (obj, val) => isInRuneDrawingMode = val;
instrPanel.Find("TriggerZone").GetComponent <StickyButton>().PressedChanged += OnTriggerModeChanged;
triggerCombo = instrPanel.Find("TriggerCombo").GetComponent <ComboBox>();
sbvisParent = GameObject.Find("EditorSBTileVis");
trigVisParent = GameObject.Find("EditorTriggerTileVis");
Logger.LogAction = msg => UnityEngine.Debug.Log(msg);
OnLoad();
}
static void CreateInstance()
{
if (mInstance == null)
{
mInstance = new LevelEditor();
}
}
private static void InitLevelEditor()
{
// Get existing open window or if none, make a new one:
LevelEditor window = (LevelEditor)EditorWindow.GetWindow(typeof(LevelEditor));
window.Show();
}
// ----- SETUP -----
public void Setup()
{
_levelEditor = LevelEditor.Instance;
_undoStack = new FiniteStack <int[, , ]>();
_redoStack = new FiniteStack <int[, , ]>();
SetupClickListeners();
}
public static void SerializeLevel()
{
LevelEditor window = CreateInstance <LevelEditor>();
window.position = new Rect(Screen.width / 2, Screen.height / 2, 250, 100);
window.Show();
}
public Game(IDtoRepository dtoRepository)
{
_dtoRepository = dtoRepository;
Types = new TypeRepository(_dtoRepository);
_level = new Level(Types);
Editor = new LevelEditor(Types, _level);
}
private static void ReceivePackets(int channel = -1)
{
int i = 0;
int max = 10;
if (channel != -1)
{
i = channel;
max = channel + 1;
}
for (i = 0; i < max; i++)
{
while (SteamNetworking.IsP2PPacketAvailable(out uint messageSize, i))
{
Console.WriteLine("Packet available of size: " + messageSize);
byte[] pubDest = new byte[messageSize];
if (SteamNetworking.ReadP2PPacket(pubDest, messageSize, out uint bytesRead, out CSteamID steamIdRemote, i))
{
switch (i)
{
case BB_LevelData:
IsActive = true;
WorldConfigFile config = (WorldConfigFile)CalcHelper.ConvertToObject(pubDest);
config.LoadIntoEditor();
break;
case BB_Ready:
_playersReadyCount++;
break;
case BB_StartTime:
_startTime = new DateTime((long)CalcHelper.ConvertToObject(pubDest));
break;
case BB_TileIdChange:
Packet.TileIdChange packet = (Packet.TileIdChange)CalcHelper.ConvertToObject(pubDest);
LevelEditor.UpdateTileFromP2P(packet);
break;
case BB_AllEntities:
UpdateEntities(pubDest);
break;
case BB_EntityUpdate:
UpdateEntities(pubDest);
break;
}
// Relay message to others.
if (IsHost)
{
var allButSender = (from client in OtherPlayers
where client != steamIdRemote
select client).ToList();
Send(pubDest, EP2PSend.k_EP2PSendReliable, i, allButSender);
}
}
}
}
}
/// <summary>
/// 继续GameInit最后一个步骤
/// </summary>
/// <returns></returns>
private bool GameInitContinueInit()
{
//模式
switch (GameManager.Mode)
{
case GameMode.Game: return(true);
case GameMode.LoaderDebug:
GameManager.GameMediator.CallAction(GamePartName.LevelLoader, "ACTION_DEBUG_LEVEL_LOADER", Main.Main.Instance.LevelDebugTarget);
GameInitHideGameInitUi(false);
break;
case GameMode.CoreDebug:
GameManager.GameMediator.CallAction(GamePartName.LevelManager, "ACTION_DEBUG_CORE", Main.Main.Instance.CoreDebugBase);
GameInitHideGameInitUi(false);
break;
case GameMode.Level:
GameManager.GameMediator.CallAction(GamePartName.LevelLoader, "LoadLevel", Main.Main.Instance.LevelDebugTarget);
GameInitHideGameInitUi(true);
break;
case GameMode.LevelEditor:
LevelEditor levelEditor = (LevelEditor)GameManager.RegisterManager(typeof(LevelEditor), false);
levelEditor.StartDebugLevelEditor(Main.Main.Instance.LevelDebugTarget);
GameInitHideGameInitUi(true);
break;
}
return(false);
}
public override void OnMouseRightClick(Point location)
{
if (!drawing)
{
LevelEditor.Perform(new GridClearSelectionAction(LayerEditor.Layer));
}
}
public static void ShowWindow()
{
LevelEditor editor = EditorWindow.GetWindow(typeof(LevelEditor)) as LevelEditor;
editor.Init();
editor.Show();
}
private void CreateManagers()
{
GameObject levelEditorGo = new GameObject("Level Editor");
levelEditor = levelEditorGo.AddComponent <LevelEditor>();
sceneObjects.Add(levelEditorGo);
GameObject objectManagerGo = new GameObject("Object Manager");
objectManager = objectManagerGo.AddComponent <LevelEditorObjectManager>();
objectManager.Resources = resources;
objectManager.PoolObjects = true;
sceneObjects.Add(objectManagerGo);
GameObject saveManagerGo = new GameObject("Save Manager");
saveManager = saveManagerGo.AddComponent <LevelEditorSaveManager>();
saveManager.ObjectManager = objectManager;
sceneObjects.Add(saveManagerGo);
levelEditor.ObjectManager = objectManager;
levelEditor.SaveManager = saveManager;
}
private void OnGUI()
{
levelScriptable = (MonsterConfig)EditorGUILayout.ObjectField(levelScriptable, typeof(MonsterConfig), false);
if (GUI.Button(new Rect(30, 30, 50, 30), "Load"))
{
LevelEditor levelEditorWindow = (LevelEditor)GetWindow(typeof(LevelEditor));
if (levelScriptable != null)
{
Debug.Log(levelScriptable.rooms);
if (levelScriptable.rooms.Count > 0)
{
foreach (BaseNode node in levelScriptable.rooms)
{
levelEditorWindow.NewNode(node.x, node.y);
}
}
}
levelEditorWindow.Show();
}
/*
* EditorGUILayout.LabelField("Quedan cosas por hacer aca. Pero iria un espacio para cargar un prefab/scriptable object de un nivel.");
* EditorGUILayout.LabelField("Una vez lleno ese espacio, podemos clickear LOAD y se abriria la ventana de Level Editor");
* EditorGUILayout.LabelField("Cerrando a su vez esta ventana y la ventana de Start Up");
*/
}
// Use this for initialization
void Start()
{
//Grid Creator, Clear, Create, Rename
GameObject[] rootObjects = SceneManager.GetActiveScene().GetRootGameObjects(); //loadedScene.GetRootGameObjects();
GameObject SquareGridRef = null;
for (int i = 0; i < rootObjects.Length; i++)
{
if (rootObjects[i].name == "SquareGrid")
{
SquareGridRef = rootObjects[i];
break;
}
}
SquareGridCreator creator = SquareGridRef.GetComponent <SquareGridCreator>();
creator.ClearGrid();
creator.CreateGrid();
creator.RenameGrid();
//Get Level Editor, Get Level of Index
LevelEditor tempEditor = SquareGridRef.GetComponent <LevelEditor>();
Debug.Log("Load Level Index: " + levelIndex);
tempEditor.getLevel(levelIndex);
}
public override void OnMouseLeftDown(Point location)
{
Point node = LayerEditor.MouseSnapPosition;
if (Ogmo.EntitySelectionWindow.Selected.Count == 1)
{
Entity e = Ogmo.EntitySelectionWindow.Selected[0];
if (e.Definition.NodesDefinition.Enabled)
{
if (e.Nodes.Contains(node))
{
moving = true;
moveEntity = e;
moveIndex = e.Nodes.FindIndex(p => p == node);
}
else if (e.Nodes.Count != e.Definition.NodesDefinition.Limit)
{
LevelEditor.Perform(new EntityAddNodeAction(LayerEditor.Layer, e, node));
}
}
}
else
{
LevelEditor.StartBatch();
foreach (var e in Ogmo.EntitySelectionWindow.Selected)
{
if (e.Definition.NodesDefinition.Enabled && e.Nodes.Count != e.Definition.NodesDefinition.Limit && !e.Nodes.Contains(node))
{
LevelEditor.BatchPerform(new EntityAddNodeAction(LayerEditor.Layer, e, node));
}
}
LevelEditor.EndBatch();
}
}
public void StartCopyingSelectedItems()
{
var clonedItems = new List <ItemEditor>( );
LevelEditor level = getLevel( );
var editors = selectedEditors( );
foreach (ItemEditor eachEditor in editors)
{
ItemEditor clone = eachEditor.Clone( );
int nextItemNumber = level.GetNextItemNumber( );
ItemProperties itemProperties = clone.ItemProperties;
itemProperties.Name = @"{0}_{1}".FormatWith(itemProperties.Name.TrimEnd(_toTrim), nextItemNumber);
itemProperties.Id = level.GenerateId(nextItemNumber);
clone.IsSelected = true;
eachEditor.IsSelected = false;
clonedItems.Add(clone);
}
IoC.Memento.BeginCommand("Copy {0} item(s)".FormatWith(clonedItems.Count));
level.AddEditors(clonedItems);
IoC.Model.SelectEditors(new SelectedEditors(clonedItems));
startMoving( );
}
public static void OpenLayoutManager()
{
LayoutEditor lee = new LayoutEditor();
lee.StartPosition = FormStartPosition.CenterParent;
lee.Owner = ReubenController.MainWindow;
if (ActiveEditor != null)
{
if (ActiveEditor is LevelEditor)
{
LevelEditor le = (LevelEditor)ActiveEditor;
lee.ShowDialog(le.CurrentLevel.Type, le.CurrentLevel.GraphicsBank, le.CurrentLevel.AnimationBank, le.CurrentLevel.Palette, le.CurrentLayout);
}
else
{
WorldEditor we = (WorldEditor)ActiveEditor;
lee.ShowDialog(we.CurrentWorld.Type, 0x70, we.CurrentWorld.GraphicsBank, we.CurrentWorld.Palette, we.CurrentLayout);
}
}
else
{
lee.ShowDialog();
}
}
public MainWindowViewModel()
{
startWindow = null;
levelContent = null;
openLevelForm = null;
dialogManager = new DialogManager();
IsLevelOpen = false;
model = new LevelEditor();
UpdateTitle();
Closing = new Command(OnClosingExecute);
BindStartWindow = new Command <StartWindow>(OnBindStartWindowExecute);
BindLevelContent = new Command <LevelContent>(OnBindLevelContentExecute);
BindOpenLevelForm = new Command <OpenLevelForm>(OnBindOpenLevelFormExecute);
CreateNewLevel = new Command(OnCreateNewLevelExecute);
OpenExistsLevel = new Command(OnOpenExistsLevelExecute);
DeleteCurrentLevel = new Command(OnDeleteCurrentLevelExecute);
CopyMgElemsFromExistsLevel = new Command(OnCopyMgElemsFromExistsLevelExecute);
ExportToXml = new Command(OnExportToXmlExecute);
ExportToXmlLL8Extras = new Command(OnExportToXmlLL8ExtrasExecute);
TryLoadLastLevel = new Command(OnTryLoadLastLevelExecute);
}
public static void OpenGraphicsEditor()
{
GraphicsEditor ge = new GraphicsEditor();
ge.StartPosition = FormStartPosition.CenterParent;
ge.Owner = ReubenController.MainWindow;
if (ActiveEditor != null)
{
if (ActiveEditor is LevelEditor)
{
LevelEditor le = (LevelEditor)ActiveEditor;
ge.ShowDialog(le.CurrentLevel.GraphicsBank, le.CurrentLevel.AnimationBank, le.CurrentLevel.Palette);
}
else
{
WorldEditor we = (WorldEditor)ActiveEditor;
ge.ShowDialog(0x70, we.CurrentWorld.GraphicsBank, we.CurrentWorld.Palette);
}
}
else
{
ge.ShowDialog();
}
}
public static void OpenBlockEditor()
{
Map16Editor me = new Map16Editor();
me.StartPosition = FormStartPosition.CenterParent;
me.Owner = ReubenController.MainWindow;
if (ActiveEditor != null)
{
if (ActiveEditor is LevelEditor)
{
LevelEditor le = (LevelEditor)ActiveEditor;
me.ShowDialog(le.CurrentLevel.Type, 0, le.CurrentLevel.GraphicsBank, le.CurrentLevel.AnimationBank, le.CurrentLevel.Palette);
}
else
{
WorldEditor we = (WorldEditor)ActiveEditor;
me.ShowDialog(we.CurrentWorld.Type, 0, 0x70, we.CurrentWorld.GraphicsBank, we.CurrentWorld.Palette);
}
}
else
{
me.ShowDialog();
}
}
// Transforms the tile identification type read from the file to a integer used as internal representation in the level editor
// For index, parse the string to int
// For name, transverse the Tiles and try to match on game object name or EMPTY
// Defaults to LevelEditor.GetEmpty() (-1)
private int TileStringRepresentationToInt(string tileString)
{
switch (_loadMethod)
{
case TileIdentificationMethod.Index:
try {
return(int.Parse(tileString));
}
catch (FormatException) {
Debug.LogError("Error: Trying to load a Name based level using Index loading");
return(LevelEditor.GetEmpty());
}
catch (ArgumentNullException) {
Debug.LogError("Error: Encountered a null in the file");
return(LevelEditor.GetEmpty());
}
case TileIdentificationMethod.Name:
if (tileString == "EMPTY")
{
return(LevelEditor.GetEmpty());
}
for (int i = 0; i < _tiles.Count; i++)
{
if (_tiles[i].name == tileString)
{
return(i);
}
}
return(LevelEditor.GetEmpty());
default:
return(LevelEditor.GetEmpty());
}
}
public override void OnMouseLeftClick(System.Drawing.Point location)
{
if (Ogmo.EntitiesWindow.CurrentEntity != null)
{
LevelEditor.Perform(new EntityAddAction(LayerEditor.Layer, new Entity(LayerEditor.Layer, Ogmo.EntitiesWindow.CurrentEntity, Util.Ctrl ? LevelEditor.MousePosition : LayerEditor.MouseSnapPosition)));
}
}
public void LoadLevel()
{
string folder = Application.dataPath + "/LevelData";
string levelfile = "";
if (LoadlevelName.text == "")
{
levelfile = "new_level.json";
}
else
{
levelfile = LoadlevelName.text + ".json";
}
string path = Path.Combine(folder, levelfile);
if (File.Exists(path))
{
EditorObject[] Objectsfound = FindObjectsOfType <EditorObject>();
foreach (EditorObject obj in Objectsfound)
{
Destroy(obj.gameObject);
}
PlayerPlaced = false;
string json = File.ReadAllText(path);
level = JsonUtility.FromJson <LevelEditor>(json);
CreateFromFile();
}
else
{
SaveLoadMessage.text = levelfile + " Could not be found !";
LoadlevelName.DeactivateInputField();
}
}
public virtual void Initialize(LevelEditor editor, string name)
{
this.editor = editor;
this.scene = editor.GetScene();
this.name = name;
this.target = scene.FindEntity(name);
}
private static bool CreateMusicListPrefix(LevelEditor __instance, ref float ___numButtonsLoad)
{
List <string> trackList = new List <string> {
"Home_Base_v2",
"Level1_1",
"Level1_2",
"Level1_3",
"Level2_1",
"Level2_2",
"Level2_3",
"Level3_1",
"Level3_2",
"Level3_3",
"Level4_1",
"Level4_2",
"Level4_3",
"Level5_1",
"Level5_2",
"Level5_3",
"Level6"
};
trackList.AddRange(CustomMusicManager.GetCustomMusic().Keys);
__instance.ActivateLoadMenu();
___numButtonsLoad = trackList.Count;
__instance.OpenObjectLoad(trackList);
__instance.StartCoroutine(SetScrollBarPlacement(__instance));
return(false);
}
void OnSceneGUI()
{
LevelEditor myScript = (LevelEditor)target;
// If we are in edit mode and the user clicks (right click, middle click or alt+left click)
if (myScript.editmode)
{
if (Event.current.type == EventType.MouseUp)
{
if (Event.current.button == 1)
{
endPos = GetSpawnPosition(new Vector3(0, 0, 0));
myScript.EditEvent(startPos, endPos);
}
}
else if (Event.current.type == EventType.MouseDown)
{
if (Event.current.button == 1)
{
startPos = GetSpawnPosition(new Vector3(0, 0, 0));
}
}
myScript.UpdateHovePosition(GetSpawnPosition(new Vector3(0, 0, 0)));
// Mark the event as used
Event.current.Use();
} // End if __editMode
} // End OnSceneGUI
public GameObject CreateTrack()
{
GameObject gameObject = Resource.LoadPrefabInstance("Group", true);
gameObject.GetComponent <CustomName>().customName_ = "Music Track";
var component = gameObject.AddComponent <ZEventListener>();
var track = new MusicTrack()
{
Name = "Unknown"
};
track.NewVersion();
track.WriteObject(component);
gameObject.ForEachILevelEditorListener(delegate(ILevelEditorListener listener)
{
listener.LevelEditorStart(true);
});
MonoBehaviour[] components = gameObject.GetComponents <MonoBehaviour>();
foreach (MonoBehaviour monoBehaviour in components)
{
monoBehaviour.enabled = false;
}
LevelEditor editor = G.Sys.LevelEditor_;
editor.AddGameObjectSilent(ref objectHandle, gameObject, null);
return(gameObject);
}
// ----------------------- //
// change mode of the game //
public void change_mode(Modes _mode)
{
mode = _mode;
//clear roots
root = new Node(null);
ui_root = new UI();
collision_manager.clear();
//create content based on mode
if (mode == Modes.Normal)
{
generate_game_world("../Worlds/created_level.txt");
var button_size = new Vector2(96, 64);
Button button_menu = new Button("Back", Global.WINDOW_SIZE - button_size, button_size);
button_menu._set_parent(ui_root);
button_menu.set_action(change_to_menu);
}
else if (mode == Modes.Editor)
{
LevelEditor level_editor = new LevelEditor(GetScreenWidth(), GetScreenHeight());
level_editor._set_parent(ui_root);
}
else if (mode == Modes.Menu)
{
MainMenu main_menu = new MainMenu(new Vector2(GetScreenWidth(), GetScreenHeight()));
main_menu._set_parent(ui_root);
}
}
public override void OnMouseLeftUp(Point location)
{
if (drawing)
{
drawing = false;
drawTo = LayerEditor.MouseSnapPosition;
Rectangle rect = LayerEditor.Layer.GetGridRectangle(mouseStart, drawTo);
rect.X /= LayerEditor.Layer.Definition.Grid.Width;
rect.Width /= LayerEditor.Layer.Definition.Grid.Width;
rect.Y /= LayerEditor.Layer.Definition.Grid.Height;
rect.Height /= LayerEditor.Layer.Definition.Grid.Height;
if (rect.IntersectsWith(new Rectangle(0, 0, LayerEditor.Layer.GridCellsX, LayerEditor.Layer.GridCellsY)))
{
LevelEditor.Perform(new GridSelectAction(LayerEditor.Layer, rect));
}
}
if (moving)
{
moving = false;
LevelEditor.EndBatch();
}
}
void Awake()
{
if (Instance == null)
{
Instance = this;
}
}
public IEnumerator Start()
{
random = UnityEngine.Random.Range(0, 100);
levelEditor = _Loader.levelEditor; //(LevelEditor)FindObjectOfType(typeof(LevelEditor));
if (!_MapLoader.shapes.Contains(this) && shape)
_MapLoader.shapes.Add(this);
while (!IsInitialized || ControlPointCount == 0)
yield return null;
if(shape)
GenerateMesh();
}
// Display any special visuals and perform any event based functionality
public override void OnInspectorGUI ()
{
levelEditor = (LevelEditor)target;
if (levelEditor == null) {
return;
}
EditorUtility.SetDirty (levelEditor); // Force the level object to update in the editor via changing state
LoadResources ();
DisplayHeader ();
// Update any tools and selections
UpdateFunctionality ();
}
public override void Initialize(LevelEditor editor, string name)
{
base.Initialize(editor, name);
light = (Light)target;
}
public EntityLayerEditor(LevelEditor levelEditor, EntityLayer layer)
: base(levelEditor, layer)
{
Layer = layer;
}
void OnApplicationQuit()
{
//release reference on exit
_instance = null;
}
public LayerEditor(LevelEditor levelEditor, Layer layer)
{
LevelEditor = levelEditor;
Layer = layer;
DrawMatrix = Matrix.Identity;
}
public void OnEnable() {
grid = (LevelEditor)target;
}
// Use this for initialization
void Awake()
{
if (inst != null)
inst = this;
}
public TileLayerEditor(LevelEditor levelEditor, TileLayer layer)
: base(levelEditor, layer)
{
Layer = layer;
}
public GridLayerEditor(LevelEditor levelEditor, GridLayer layer)
: base(levelEditor, layer)
{
Layer = layer;
}
//EDITOR
public bool isValidEnemy(LevelEditor thelevel)
{
var positionTMP = startPosition;
for(int i=0; i<moveList.Count; i++)
{
switch(moveList[i].state)
{
case MOVE.LEFT:
positionTMP.x++;
break;
case MOVE.RIGHT:
positionTMP.x--;
break;
case MOVE.UP:
positionTMP.y++;
break;
case MOVE.DOWN:
positionTMP.y--;
break;
default:
break;
}
if((thelevel.getBlocState((int)positionTMP.x, (int)positionTMP.y, isHelicopter ? 3 : 1) == BLOCSTATE.CUBE) || (!isHelicopter && (thelevel.getBlocState((int)positionTMP.x, (int)positionTMP.y, isHelicopter ? 2 : 0) != BLOCSTATE.CUBE)))
{
return false;
}
}
return (int)positionTMP.x == (int)startPosition.x && (int)positionTMP.y == (int)startPosition.y;
}
// Use this for initialization
void Start()
{
isInHidingMode = false;
inEnemyTest = false;
actualMode = EDITMODE.CUBE;
placementCube = cursor.transform.FindChild("PlacementCube").gameObject;
deleteCube = cursor.transform.FindChild("DeleteCube").gameObject;
placementSpecial = cursorSpecial.transform.FindChild("PlacementSpecial").gameObject;
deleteSpecial = cursorSpecial.transform.FindChild("DeleteSpecial").gameObject;
playerSpawnValid = playerSpawn.transform.FindChild("SpawnValid").gameObject;
playerSpawnInvalid = playerSpawn.transform.FindChild("SpawnInvalid").gameObject;
playerFinishValid = playerFinish.transform.FindChild("FinishValid").gameObject;
playerFinishInvalid = playerFinish.transform.FindChild("FinishInvalid").gameObject;
canonCursorValid = canonCursor.transform.FindChild("CanonValid").gameObject;
canonCursorInvalid = canonCursor.transform.FindChild("CanonInvalid").gameObject;
cameraEnValid = cameraEnCursor.transform.FindChild("CameraValid").gameObject;
cameraEnInvalid = cameraEnCursor.transform.FindChild("CameraInvalid").gameObject;
cameraRotationCursor = cameraEnCursor.transform.FindChild("CubePosition").gameObject;
enemyHelicoValid = enemyHelicoCursor.transform.FindChild("HelicoValid").gameObject;
enemyHelicoHover = enemyHelicoCursor.transform.FindChild("HelicoHover").gameObject;
enemyHelicoInvalid = enemyHelicoCursor.transform.FindChild("HelicoInvalid").gameObject;
enemyValid = enemyCursor.transform.FindChild("EnemyValid").gameObject;
enemyHover = enemyCursor.transform.FindChild("EnemyHover").gameObject;
enemyInvalid = enemyCursor.transform.FindChild("EnemyInvalid").gameObject;
cursorWayValid = cursorEdit.transform.FindChild("WayEditValid").gameObject;
cursorWayAction = cursorEdit.transform.FindChild("ActionEdit").gameObject;
listUIEnemy = new Dictionary<Enemy, List<GameObject>>();
listLevelSaved = new List<string>();
actualSizeSelected = 0;
actualActionSelected = (int)MOVE.WAIT;
actualFileSelected = 0;
actualLevel = new LevelEditor(maxWidth, maxHeight, maxVolume);
for(int i = 0; i<widthLevelDefault; i++)
{
for(int j=0; j<heightLevelDefault; j++)
{
var go = (GameObject)Instantiate(cubeBase, new Vector3(j*2, 0f, i*2), cubeBase.transform.rotation);
actualLevel.setCube(i, j, 0, go);
go.SetActive(true);
}
}
}
