private UnityAction FilteredTransition(int i)
{
return(() =>
{
if (!FilterManager.IsHappy || FilterManager.IsAlmostDark)
{
return;
}
m_levels[i].transform.position = m_gridElements.LevelCurrent.transform.position;
if (i > 0)
{
m_levels[i - 1].GetComponent <GenerateLevel>().SetActiveLevel(false);
}
GenerateLevel nextLevel = m_levels[i].GetComponent <GenerateLevel>();
nextLevel.SetShadowMode(false);
m_gridElements.LevelCurrent = nextLevel;
InLevelSlot(m_gridElements.LevelCurrent);
nextLevel.SetActiveLevel(true);
TankScript.TankList.ForEach((TankScript tank) => tank.DestroyBullets());
if (i == 3)
{
PlayerScript.playerRef.transform.Find("Tank").GetComponent <TankScript>().allowHeavy = true;
}
if (PlayerBlock.PlayerStarter != null)
{
PlayerBlock.PlayerStarter.TeleportPlayer();
}
});
}
private void Start()
{
var main = GameObject.Find("Main");
this.ms = main.GetComponent <TargetManagerBehaviour>();
this.shipPrefab = ReferenceBuffer.Instance.EditorInput.shipPrefab;
var rb = main.GetComponent <ReferenceBuffer>();
this.gl = new GenerateLevel(this.ms, rb);
///Generate the environment
this.gl.CylinderBasePrefab(new Vector3(40, 1, 40), true);
///...
/// Player!
this.player = this.gl.Player(new Vector3(0, 0, 0), true, true, true);
this.mainCamera = GameObject.Find("MainCamera");
CamHandling camHandling = this.mainCamera.GetComponent <CamHandling>();
camHandling.target = this.player.transform;
///...
//GameObject.Find("ScrollableInfoText").SetActive(false);
this.GenerateEntites();
string text = File.ReadAllText(@"C:\Users\ASUS G751JY\source\repos\11111 Unity\UserCode\UserLevel\UserLevelMain.cs");
_ = ReferenceBuffer.Instance.capp.ApplyToSelectedTarget(text, this.targetSphere);
}
void Start()
{
GameVars.init();
GenerateLevel level = new GenerateLevel(5, 30);
//foreach (Resource wall in level.resources) { Instantiate(Resources.Load(wall.resource), wall.location, wall.angle); }
StartCoroutine("SpawnWave", new Wave());
}
public override void OnStartLocalPlayer()
{
GenerateLevel serverInfo = GameObject.FindGameObjectWithTag("LevelModel").GetComponent <GenerateLevel>();
if (playerNumber == -1)
{
playerNumber = serverInfo.assignPlayer;
++serverInfo.assignPlayer;
int workingIndex = 0;
switch (playerNumber)
{
case 2:
workingIndex = serverInfo.playerTwoIndex;
break;
case 3:
workingIndex = serverInfo.playerThreeIndex;
break;
case 4:
workingIndex = serverInfo.playerFourIndex;
break;
}
int offset = (playerNumber - 1) * 8;
GetComponent <SpriteRenderer>().sprite = spriteList[0 + offset];
SetPlayerIndex(serverInfo.indexToPosition(workingIndex));
GetComponent <SpriteRenderer>().sortingOrder = playerIndex.y + 101;
transform.position = new Vector3(playerIndex.x, -playerIndex.y + 0.5f, 0);
}
base.OnStartLocalPlayer();
// Initalize things here, maybe grab a spawn location?
}
// get the state and store the the type of game that is being dealt with
void Start()
{
StateToLoad level = Component.FindObjectOfType(typeof(StateToLoad)) as StateToLoad;
if (!level)
{
return;
}
level.FetchData();
_type = level.GetStateType();
_gameNameId = level.GetNameID();
//create the level with the data from the state
GenerateLevel.Generate(level.GetByteData(), out _lowTiles, out _midTiles, out _highTiles, _lowPlane, _midPlane, _highPlane);
//set up each tile
foreach (Tile t in Component.FindObjectsOfType(typeof(Tile)) as Tile[])
{
t.GetNeighbors();
}
PlaneManager.PM.ReassociateTiles();
Destroy(level.gameObject);
}
void Start()
{
/// References!
var main = GameObject.Find("Main");
this.lm = main.GetComponent <LevelManager>();
var rb = main.GetComponent <ReferenceBuffer>();
this.ms = main.GetComponent <TargetManagerBehaviour>();
var gl = new GenerateLevel(this.ms, rb);
///
/// Problem Text and Code!
var infoText = rb.InfoTextObject;
infoText.GetComponent <Text>().text = ProblemDesctiptions.level3;
rb.ShowCode.SetText(InitialCodes.Level3);
///...
/// Value Initialization
this.gatheredTheSphere = false;
this.placedTHeSphere = false;
///...
/// Base
GameObject baseCylinder = gl.CylinderBasePrefab(new Vector3(30, 1, 30), true);
///...
/// Player and cam!
this.player = gl.Player(this.initialPlayerPosition, true, true, true);
this.mainCamera = GameObject.Find("MainCamera");
CamHandling camHandling = this.mainCamera.GetComponent <CamHandling>();
camHandling.target = this.player.transform;
///...
/// Enitites!
this.target = gl.GenerateEntity(
EntityType.Target,
new Vector3(7, 0, 0),
PrimitiveType.Sphere,
Color.white,
null, "Level3Actor123");
this.toTransport = gl.GenerateEntity(
EntityType.NonTarget,
new Vector3(-7, 0, 0),
PrimitiveType.Sphere,
Color.red,
null, "Level3ToTranport567");
this.destination = gl.GenerateEntity(
EntityType.NonTarget,
new Vector3(5, 0, 5),
PrimitiveType.Cube,
Color.gray,
null, "Level3FinalPosition789");
///...
}
private void Start()
{
generateLevel = ScriptableObject.CreateInstance("GenerateLevel") as GenerateLevel;
dataReader = ScriptableObject.CreateInstance("DataReader") as DataReader;
StartCoroutine(Regenerate());
}
void Awake()
{
dictionary = GameObject.Find("Dictionary");
dictionaryOpened = false;
dictionary.SetActive(dictionaryOpened);
levelGenerator = GetComponent <GenerateLevel>();
}
//Use this for initialization
void Start()
{
viewMesh = new Mesh();
viewMesh.name = "View mesh";
GetComponent <MeshFilter>().mesh = viewMesh;
levelgenerator = GetComponentInParent <GenerateLevel>();
parent = GetComponentInParent <Boss>().gameObject.transform;
}
void OnEnable()
{
DontDestroyOnLoad(this.gameObject);
levelGen = GetComponent <GenerateLevel>();
SceneManager.sceneLoaded += OnSceneLoaded; //this only makes sense if this object persists through scenes
UnityEventManager.StartListeningInt("MoMDeath", IsGameOver);
UnityEventManager.StartListening("StartGame", StartNewGame);
}
private void generateLevel()
{
GameObject levelGeneratorObject = Instantiate(levelGen, Vector3.zero, Quaternion.identity);
GenerateLevel levelGenerator = levelGeneratorObject.GetComponent <GenerateLevel> ();
levelGenerator.numEnemies = 12 + ((5 + levelNum) * levelNum) / 5;
levelGenerator.width = 35 + levelNum * 3;
levelGenerator.height = 35 + levelNum * 3;
}
public override void OnStartServer()
{
GenerateLevel serverInfo = GameObject.FindGameObjectWithTag("LevelModel").GetComponent <GenerateLevel>();
playerNumber = serverInfo.assignPlayer;
++serverInfo.assignPlayer;
SetPlayerIndex(serverInfo.indexToPosition(serverInfo.playerOneIndex));
GetComponent <SpriteRenderer>().sortingOrder = playerIndex.y + 101;
transform.position = new Vector3(playerIndex.x, playerIndex.y + 0.5f, 0);
}
private void MineStart()
{
playerGO = GameObject.FindGameObjectWithTag("Player");
generateLevel = FindObjectOfType <GenerateLevel>();
_gridBehavior = FindObjectOfType <GridBehavior>();
oreGenerator = FindObjectOfType <OreGenerator>();
_nextLevelLoadController = FindObjectOfType <NextLevelLoadController>();
progressBar = FindObjectOfType <ProgressBar>();
_chancesGenerator = FindObjectOfType <ChancesGenerator>();
}
void Awake()
{
//Check if instance already exists
if (instance == null)
{
instance = this;
this.onHeroHitPlatformEvent = new OnHeroHitPlatformEvent();
this.onHeroHitPlatformEvent.AddListener(onHeroHitPlatform);
}
}
private void generateLevel()
{
GameObject levelGeneratorObject = Instantiate(levelGen, Vector3.zero, Quaternion.identity);
GenerateLevel levelGenerator = levelGeneratorObject.GetComponent <GenerateLevel> ();
// 11 enemies at floor 1 with grid size of 30x30
// 27 enemies at floor 5 with grid size of 42x42
// 66 enemies at floor 10 with grid size of 57x57
levelGenerator.numEnemies = (int)((20 + ((5 + 2.5 * levelNum) * (4 + 2.5 * levelNum)) / 5) / 3);
levelGenerator.width = 12 + (levelNum + 5) * 3;
levelGenerator.height = 12 + (levelNum + 5) * 3;
}
private void Start()
{
chunkList = new List <Chunk>();
generator = GameObject.FindGameObjectWithTag("Core").GetComponent <GenerateLevel>();
chunkList.Add(new Chunk(generator.AddChunk(0, 0), new Vector2(0, 0)));
chunkList.Add(new Chunk(generator.AddChunk(0, -1), new Vector2(0, -1)));
chunkList.Add(new Chunk(generator.AddChunk(1, 0), new Vector2(1, 0)));
chunkList.Add(new Chunk(generator.AddChunk(1, -1), new Vector2(1, -1)));
chunkList.Add(new Chunk(generator.AddChunk(-1, 0), new Vector2(-1, 0)));
chunkList.Add(new Chunk(generator.AddChunk(-1, -1), new Vector2(-1, -1)));
}
bool CanAttack()
{
Vector3 nearest = GenerateLevel.NearestTarget(GenerateLevel.Pits, Location);
if (Vector3.Distance(nearest, Location) > 2 && canAttack)
{
return(true);
}
else
{
return(false);
}
}
void Reset(int lvl)
{
GenerateLevel.ClearMapParts();
_map = GenerateLevel.Instance.LoadLevel(lvl);
_lastDir = EDirecton.NONE;
_position = _map.Start;
_toFillCount = 0;
_dirMove = Vector2.zero;
_hasWin = false;
TextNextLvl.SetActive(false);
var newFloatCoords = GenerateLevel.IntToFloatCoordinates(_position);
Player.transform.position = new Vector3(newFloatCoords.x, Player.transform.position.y, newFloatCoords.y);
}
void Awake()
{
changeScene = GameObject.FindGameObjectWithTag("ChangeScene").GetComponent <ChangeScene>();
changeScene.fieldSceneManager = this;
plane = GameObject.FindGameObjectWithTag("Ground");
optionPanel = Instantiate(Resources.Load("Prefabs/OptionPanel"), Vector3.zero, Quaternion.identity) as GameObject;
optionPanel.GetComponent <Options>().Create(canvas);
genLevel = GetComponent <GenerateLevel>();
if (changeScene.randomLevel)
{
GoToMap.gameObject.SetActive(false);
}
}
IEnumerator AnimateFaceRotation(Vector3 contactPoint)
{
animating = true;
//FindClosestPivot(contactPoint);
// DEBUGHighlightPivot ();
FindFaceToRotateByPivot();
Quaternion origin = smallRubikPivot.transform.localRotation;
Quaternion target = smallRubikPivot.transform.localRotation * Quaternion.AngleAxis(90f, smallRubikPivot.transform.localPosition);
Quaternion bigRubikOrigin = bigRubikPivot.transform.localRotation;
Quaternion bigRubikTarget = bigRubikPivot.transform.localRotation * Quaternion.AngleAxis(90f, bigRubikPivot.transform.localPosition);
float journey = 0f;
float duration = 1f;
sfx.PlayRandom("CubeFaceRotationSound", bigRubikPivot.position);
//animating
while (journey <= duration)
{
journey = journey + Time.deltaTime;
float percent = Mathf.Clamp01(journey / duration);
smallRubikPivot.localRotation = Quaternion.Slerp(origin, target, percent);
bigRubikPivot.localRotation = Quaternion.Slerp(bigRubikOrigin, bigRubikTarget, percent);
yield return(null);
}
smallRubikPivot.localRotation = target;
bigRubikPivot.localRotation = bigRubikTarget;
// reset parent for rooms to rubik (from pivot)
foreach (Transform r in smallRubikRooms)
{
r.parent = smallRubik;
}
foreach (Transform r in bigRubikRooms)
{
r.parent = bigRubik;
}
GenerateLevel.RecollorPassages();
animating = false;
}
private void Awake()
{
if (onDescending == null)
{
new UnityEvent();
}
_player = GameObject.FindGameObjectWithTag("Player");
_gridBehavior = FindObjectOfType <GridBehavior>();
_csGlobal = FindObjectOfType <CsGlobal>();
oreGenerator = FindObjectOfType <OreGenerator>();
generateLevel = FindObjectOfType <GenerateLevel>();
progressBar = FindObjectOfType <ProgressBar>();
_canvas = FindObjectOfType <Canvas>();
_dataController = FindObjectOfType <DataController>();
}
void ManifestLevel(int index)
{
if (index >= Levels.Length)
{
currentLevel = Levels.Length - 1;
index = currentLevel;
}
CameraTransform.localPosition = cameraRootPosition;
levelState.Clear();
levelState.AddFrame();
levelState.Current.YCamera = 0;
generatedLevel = GenerateLevel.Generate(ref constants, Levels[index], ref playerObject, Camera.transform, levelState.Current, levelState.Objects);
levelState.SaveStates();
lastMoveResult = MoveResult.None;
}
void OnSceneGUI()
{
GenerateLevel generator = (GenerateLevel)target;
Handles.color = Color.red;
int half_tile = Mathf.FloorToInt((float)generator.tile_size / 2);
long width = generator.tile_size * generator.width + half_tile;
long height = generator.tile_size * generator.height + half_tile;
Handles.DrawLine(new Vector3(-half_tile, -half_tile, 0), new Vector3(-half_tile, height, 0));
Handles.DrawLine(new Vector3(-half_tile, -half_tile, 0), new Vector3(width, -half_tile, 0));
Handles.DrawLine(new Vector3(width, -half_tile, 0), new Vector3(width, height, 0));
Handles.DrawLine(new Vector3(-half_tile, height, 0), new Vector3(width, height, 0));
}
public override void OnInspectorGUI()
{
GenerateLevel mapGen = (GenerateLevel)target;
if (DrawDefaultInspector())
{
if (mapGen.autoUpdate)
{
mapGen.GenMap();
}
}
if (GUILayout.Button("Generate"))
{
mapGen.GenMap();
}
}
public void LevelCompletedButton()
{
if (HandleTextFile.lvlName == "100")
{
GenerateLevel.LevelGenerate();
}
else if (HandleTextFile.lvlName == "102")
{
SceneManager.LoadScene("Map");
}
else
{
SceneManager.LoadScene("Map");
}
}
void Start()
{
if (!isServer)
{
return;
}
lineRender = GetComponent <LineRenderer>();
foodPile = new GameObject[amount];
spawnPoints = new Vector3[amount];
GenerateLevel.SpawnObjects(amount, radius, clusterDist, Location, foodPile, InitialSpawn, LayerMask.NameToLayer("Food"));
for (int i = 0; i < amount; i++)
{
spawnPoints[i] = foodPile[i].transform.position;
foodPile[i].SetActive(false);
foodPile[i].GetComponent <FoodObject>().RpcDestroy();
}
StartCoroutine(SpawnFood());
}
public void Awake()
{
//ensure only one level generator exists at any given time
if (!instance)
{
instance = this;
}
else if (instance != this)
{
Destroy(this);
}
if (player == null)
{
player = GameObject.FindWithTag("Player");
}
}
// Use this for initialization
void Start()
{
gl = FindObjectOfType (typeof(GenerateLevel)) as GenerateLevel;
start_time = Time.time;
GameObject timer = gameObject.transform.GetChild (0).gameObject;
Color c = gameObject.GetComponent<SpriteRenderer> ().color;
timer.GetComponent<SpriteRenderer> ().color = new Color (c.r, c.g, c.b, 0.3f);
// play fade in sound
which_note = Random.Range (0, synth_notes.Length);
AudioSource audio_source = timer.GetComponent<AudioSource> ();
AudioClip clip = synth_notes [which_note];
audio_source.clip = clip;
audio_source.volume = 0.5f;
//audio_source.Play ();
}
private void GenerateRandomLevel(int numberOfRooms, int roomsMaxWight, int roomsMaxHeight, int roomsMinWight, int roomsMinHeight)
{
var numberOfAttempts = 1;
var i = 0;
while (i < numberOfAttempts)
{
DestroyCanvasObjects();
var layout = GenerateLevel.Generate(numberOfRooms, roomsMinWight, roomsMaxWight, roomsMinHeight, roomsMaxHeight);
var minX = layout.Rooms.Min(a => a.Position.X);
var maxX = layout.Rooms.Max(a => a.Position.X);
var minY = layout.Rooms.Min(a => a.Position.Y);
var maxY = layout.Rooms.Max(a => a.Position.Y);
var maxRoomSide = Mathf.Max(roomsMaxWight, roomsMaxHeight, roomsMinWight, roomsMinHeight);
var sizeX = maxX - minX + maxRoomSide * 3;
var sizeY = maxY - minY + maxRoomSide * 3;
var Xoffset = -minX + 3 + maxRoomSide;
var Yoffset = -minY + 3 + maxRoomSide;
ConstractorUI.UIConstractor.GetComponent <ConstractorUI>().InstantiateLevelField(sizeX, sizeY);
var levelStructure = Globals.LevelStructure;
GenerateRooms(Xoffset, Yoffset, levelStructure, layout);
GenerateDoors(Xoffset, Yoffset, levelStructure, layout);
var isLevelPassable = GenerateItemsFromTemplate(Xoffset, Yoffset, levelStructure, layout);
if (isLevelPassable)
{
DrawLevel(Xoffset, Yoffset, levelStructure);
return;
}
roomsMaxWight++;
roomsMaxHeight++;
roomsMinWight++;
roomsMinHeight++;
i++;
}
}
private string DGAP_Aux(GenerateLevel gl)
{
if (gl == null)
{
return("_ ");
}
if (gl == m_gridElements.LevelCurrent)
{
return("C ");
}
if (gl == m_gridElements.LevelLast)
{
return("L ");
}
if (gl == m_gridElements.LevelNext)
{
return("N ");
}
return("X ");
}
// Use this for initialization
void Start()
{
gl = FindObjectOfType(typeof(GenerateLevel)) as GenerateLevel;
start_time = Time.time;
GameObject timer = gameObject.transform.GetChild(0).gameObject;
Color c = gameObject.GetComponent <SpriteRenderer> ().color;
timer.GetComponent <SpriteRenderer> ().color = new Color(c.r, c.g, c.b, 0.3f);
// play fade in sound
which_note = Random.Range(0, synth_notes.Length);
AudioSource audio_source = timer.GetComponent <AudioSource> ();
AudioClip clip = synth_notes [which_note];
audio_source.clip = clip;
audio_source.volume = 0.5f;
//audio_source.Play ();
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
GenerateLevel generator = (GenerateLevel)target;
GUILayout.BeginHorizontal();
if (GUILayout.Button("Generate"))
{
generator.ResetDungeonVoid(true);
}
if (GUILayout.Button("Clear"))
{
generator.ClearDungeon(true);
}
GUILayout.EndHorizontal();
}
//####################################################################################################
void Start()
{
_screenHeight = Screen.height / 2;
// _cameraZ = -Camera.main.transform.position.z / 2.0f + 0.5f;
_cameraZ = -Camera.main.transform.position.z / 2.0f;
_player = GameObject.FindGameObjectWithTag("Player");
_camera = Camera.main.transform;
_scoreBoard = GameObject.FindWithTag("Scoreboard").GetComponent<TextMesh>();
_hiScoreBoard = GameObject.FindWithTag("HiScoreboard").GetComponent<TextMesh>();
_pauseMenu = GameObject.FindWithTag("UpgradeMenu");
_pauseMenu.SetActive(true);
_startResume = _pauseMenu.GetComponentInChildren<TextMesh>();
_genLevel = GameObject.FindWithTag("LevelGenerator").GetComponent<GenerateLevel>();
//start in Menu, game paused
Time.timeScale = 0;
_playerStartPosition = _player.transform.position;
_startPosition = transform.position;
_player.transform.position = _player.transform.position - Vector3.up * 100.0f;
}
void Awake()
{
current = this;
}
