void Awake()
{
if (!save)
{
LevelEditorManager.AddTexture(tileId, GetComponent <MeshRenderer>().material.mainTexture);
}
}
private IEnumerator LaunchEditor(LevelFile level)
{
currentLevel = level;
splash.SetActive(true);
var async = SceneManager.LoadSceneAsync("Game", LoadSceneMode.Single);
while (!async.isDone)
{
loadingBar.Progress = async.progress * 0.7f;
yield return(null);
}
Destroy(FindObjectOfType <GameManager>());
LevelEditorManager levelEditorManager = FindObjectOfType <LevelEditorManager>();
levelEditorManager.SetEditorFunctions(OnSaveLevel, OnDeleteLevel);
#if UNITY_EDITOR
levelEditorManager.LoadEditor(level, officialLevels, customLevels, delegate(float progress) { loadingBar.Progress = 0.7f + progress * 0.3f; });
#else
levelEditorManager.LoadEditor(level, new List <LevelFile>(), customLevels, delegate(float progress) { loadingBar.Progress = 0.7f + progress * 0.3f; });
#endif
while (loadingBar.Progress < 0.95f)
{
yield return(null);
}
loadingBar.Progress = 1.0f;
splash.SetActive(false);
}
// Use this for initialization
void Start()
{
if (instance == null)
{
instance = this;
}
//deactivate this button when exported to platforms
if (!Application.isEditor)
{
LevelEditorBtn.gameObject.SetActive(false);
}
levelCount = Resources.LoadAll("Levels").Length - 1;
editorManager = EditorManager.Instance;
boardManager = editorManager.GetBoardManager();
pieceBoard = boardManager.pieceBoard;
SetDefaultStart();
LevelEditorBtn.onClick.AddListener(delegate() { ChangeEditorState(); });
mixBoardBtn.onClick.AddListener(delegate() { CreateRandomLevel(); });
executeSolutionBtn.onClick.AddListener(delegate() { ExecuteSolutionFunc(); });
saveLevelBtn.onClick.AddListener(delegate() { SaveLevel(); });
loadLevelBtn.onClick.AddListener(delegate() { LoadLevelFunc(); });
stopSolution.onClick.AddListener(delegate() { StopSolution(); });
}
public void Return()
{
sHelper.GetInstance().EnableCamera(true);
LevelEditorManager.Instance().EnableCamera(false);
LevelEditorManager.Instance().EnableObjects(false);
DestroyLevelEditor();
sHelper.GetInstance().EnableObjects(true);
}
// Use this for initialization
void Start()
{
lvlEMan = GetComponent <LevelEditorManager>();
XPlus = int.Parse(lvlEMan.sliderX.maxValue.ToString());
YPlus = int.Parse(lvlEMan.sliderY.maxValue.ToString());
arrGameFigures = new GameObject[XPlus * 2 + 1, YPlus * 2 + 1];
}
// Use this for initialization
void Start()
{
lvlEditMan = FindObjectOfType(typeof(LevelEditorManager)) as LevelEditorManager;
bgMan = FindObjectOfType(typeof(BackgroundManager)) as BackgroundManager;
xPlus = bgMan.XPlus;
yPlus = bgMan.YPlus;
tMan = FindObjectOfType(typeof(TouchManager)) as TouchManager;
}
public void DoClicked()
{
if (save)
{
LevelEditorManager.SaveToXML();
}
else
{
editorController.SetSelectedTile(tileId, GetComponent <MeshRenderer>().material.mainTexture);
}
}
void Awake()
{
instance = this;
if (Timer.instance == null)
{
Timer.instance = new GameObject().AddComponent <Timer>();
Timer.instance.gameObject.name = "Timer";
}
// Bird Controllers
for (int i = 0; i < birds.Count; i++)
{
// Panel and Sprite
GameObject birdController = Instantiate(birdsPanel.gameObject) as GameObject;
birdController.transform.SetParent(bottomPanel.transform);
birdController.transform.position = new Vector3(i * 100 + 42, 40);
Sprite birdSprite = birds[i].GetComponent <SpriteRenderer>().sprite;
birdController.transform.GetChild(0).GetComponent <Image>().sprite = birdSprite;
// Add Button
AddBirdCommand addBird = new AddBirdCommand(birds[i].name, birdController.transform);
addBirdRef.Add(birds[i].name, addBird);
Button addButton = birdController.transform.GetChild(1).GetComponent <Button>();
addButton.onClick.AddListener(delegate
{
commandManager.ExecuteCommand(addBird);
});
// Remove Button
RemoveBirdCommand removeBird = new RemoveBirdCommand(birds[i].name, birdController.transform);
Button removeButton = birdController.transform.GetChild(2).GetComponent <Button>();
removeButton.onClick.AddListener(delegate { commandManager.ExecuteCommand(removeBird); });
}
// Guarda index dos blocos/porcos pelo tipo -> para encontrar prefab pelo tipo
for (int i = 0; i < blocks.Count; i++)
{
typePrefabIndex.Add(blocks[i].name, i);
}
for (int i = 0; i < pigs.Count; i++)
{
typePrefabIndex.Add(pigs[i].name, i);
}
// Se modo de previsaulização, esconde menus, e ignora atalhos
if (isPreview)
{
EnableMenu(false);
ConfirmMenu.SetActive(true);
}
AddBlockCommand.BlocksEditor = blocksParent;
}
void CreateEditorPlane()
{
for (int i = 0; i < canvasSize.x; i++)
{
for (int k = 0; k < canvasSize.y; k++)
{
GameObject tgo = Instantiate(editorEmptyTile, new Vector3(i * 10, k * 10, 0), editorEmptyTile.transform.rotation) as GameObject;
tgo.transform.parent = transform;
tgo.name = "tile_" + i + "_" + k;
tgo.GetComponent <MeshRenderer> ().material.SetTexture("_MainTex", LevelEditorManager.GetTexture(LevelEditorManager.GetTile(i, k)));
}
}
}
public void Awake()
{
// grab game master
gameMaster = GetComponent<GameMaster>();
// grab child managers
hubManager = GetComponentInChildren<HubManager>();
levelEditorManager = GetComponentInChildren<LevelEditorManager>();
dungeonManager = GetComponentInChildren<DungeonManager>();
cipherManager = GetComponentInChildren<CipherManager>();
motiveManager = GetComponentInChildren<MotiveManager>();
networkManager = GetComponentInChildren<NetworkManager>();
}
void Start()
{
gm = GameObject.FindGameObjectWithTag("GameManager").GetComponent <GameManager>();
editor = GameObject.FindGameObjectWithTag("LevelEditorManager").GetComponent <LevelEditorManager>();
SpriteData playerSprite = new SpriteData();
playerSprite.x = 0;
playerSprite.y = 0;
playerSprite.prefabIndex = 0;
spritesList.SpriteData.Add(playerSprite);
ResetLevel();
}
/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
Services.AddService(typeof(GraphicsDeviceManager), _graphics);
GameplayManager gameplayManager = new GameplayManager(this);
LevelEditorManager levelEditorManager = new LevelEditorManager(this);
StartMenuManager startMenuManager = new StartMenuManager(this);
Components.Add(gameplayManager);
Components.Add(levelEditorManager);
Components.Add(startMenuManager);
_managers.Add(GameState.Gameplay, gameplayManager);
_managers.Add(GameState.LevelEditor, levelEditorManager);
_managers.Add(GameState.StartMenu, startMenuManager);
base.Initialize();
}
void Start()
{
editor = GameObject.FindGameObjectWithTag("LevelEditorManager").GetComponent <LevelEditorManager>();
}
// called whenever the editor window is created
public void OnEnable()
{
manager = new LevelEditorManager();
CreateLockedTileTexture();
}
// Use this for initialization
void Awake()
{
Debug.Log("creando los planos");
Camera.main.GetComponent <LevelEditorCamera>().SetupBounds(canvasSize);
LevelEditorManager.Init(Mathf.FloorToInt(canvasSize.x), Mathf.FloorToInt(canvasSize.y));
}
void Start()
{
quantityText.text = quantity.ToString();
editor = GameObject.FindGameObjectWithTag("LevelEditorManager").GetComponent <LevelEditorManager>();
}
// Update is called once per frame
void Update()
{
RaycastHit hit;
Ray touchRay = new Ray(transform.position, Vector3.forward);
int rayDistance = 20;
Debug.DrawRay(transform.position, Vector3.forward * rayDistance);
if (pathMode)
{
if (Physics.Raycast(touchRay, out hit, rayDistance))
{
if (hit.transform.tag == "planosEditor")
{
string[] cellname = hit.transform.name.Split('_');
LevelEditorManager.SetTile(int.Parse(cellname [1]), int.Parse(cellname [2]), selectedTileId);
if (int.Parse(cellname [1]) == enemyX || int.Parse(cellname [2]) == enemyY)
{
Cursor.SetCursor(normalCursor, new Vector2(0, 0), CursorMode.ForceSoftware);
if (Input.GetMouseButtonDown(0))
{
hit.transform.GetComponent <Renderer>().material.color = Color.green;
//aqui habria que guardar el tile, y tintarlo o algo para que se vea
enemyX = int.Parse(cellname [1]);
enemyY = int.Parse(cellname [2]);
}
}
else
{
Cursor.SetCursor(blockedCursor, new Vector2(0, 0), CursorMode.ForceSoftware);
}
}
}
}
else
{
if (Input.GetKey(KeyCode.LeftShift))
{
if (Input.GetMouseButton(0))
{
if (Physics.Raycast(touchRay, out hit, rayDistance))
{
if (hit.transform.tag == "planosEditor")
{
if (selectedTileId < 0)
{
return;
}
hit.transform.GetComponent <MeshRenderer> ().material.SetTexture("_MainTex", selectedTileTexture);
// RELLENO LA LISTA DE TILES
string[] cellname = hit.transform.name.Split('_');
LevelEditorManager.SetTile(int.Parse(cellname [1]), int.Parse(cellname [2]), selectedTileId);
}
}
}
}
else
{
if (Input.GetMouseButtonDown(0))
{
if (Physics.Raycast(touchRay, out hit, rayDistance))
{
if (hit.transform.tag == "planosEditor")
{
if (selectedTileId < 0)
{
return;
}
hit.transform.GetComponent <MeshRenderer> ().material.SetTexture("_MainTex", selectedTileTexture);
// RELLENO LA LISTA DE TILES
string[] cellname = hit.transform.name.Split('_');
LevelEditorManager.SetTile(int.Parse(cellname [1]), int.Parse(cellname [2]), selectedTileId);
Debug.Log(selectedTileId);
if (selectedTileId > 300)
{
pathMode = true;
enemyX = int.Parse(cellname [1]);
enemyY = int.Parse(cellname [2]);
}
}
else if (hit.transform.tag == "botonEditor")
{
hit.transform.GetComponent <LevelEditorButton> ().DoClicked();
}
else if (hit.transform.tag == "tabEditor")
{
hit.transform.GetComponent <LevelEditorTab> ().DoClicked();
}
}
}
}
}
posMouse = Camera.main.ScreenToWorldPoint(Input.mousePosition);
transform.position = new Vector3(posMouse.x, posMouse.y, transform.position.z);
}
public void Edit()
{
DestroySketchEditor();
LevelEditorManager.isPreview = false;
LevelEditorManager.Instance().EnableMenu(true);
}
// Use this for initialization
void Start()
{
editorManager = EditorManager.Instance;
boardManager = editorManager.GetBoardManager();
lvlEditorManager = editorManager.GetLevelEditorManager();
}