public override bool Use()
{
Vector3 plantPos = PlayerController.activeCharacter.GetInteractPosition();
// Check if plant won't collide with anything else
BoxCollider2D col = plantToPlant.GetComponent <BoxCollider2D> ();
RaycastHit2D[] hits = Physics2D.BoxCastAll(col.bounds.center, col.bounds.extents, 0, new Vector2(0, 0), 0);
int defaultLayer = LayerMask.NameToLayer("Default");
foreach (RaycastHit2D hit in hits)
{
if (hit.collider.gameObject.layer != defaultLayer)
{
return(false);
}
}
// THIS ASSUMES ONLY ONE SCENE IS IN PLAY AND NEEDS TO CHANGE WHEN WE INCORPORATE SAVING WHEN MULTIPLE SCENES ARE ACTIVE
GameObject sceneRoot = SceneController.RetrieveSceneRootObjs() [0];
TerrainController terrainC = sceneRoot.GetComponentInChildren <TerrainController> ();
InteractivePlant newPlant = GameObject.Instantiate(Resources.Load <GameObject> ("Prefabs/Terrain/" + prefabName)).GetComponent <InteractivePlant>();
newPlant.transform.SetParent(terrainC.manMadeItemHolder.transform);
newPlant.transform.position = plantPos;
newPlant.Plant();
return(true);
}
public void Awake()
{
_fileSource = MapboxConvenience.Instance.FileSource;
MapVisualization.Initialize(this, _fileSource);
_tiles = new Dictionary <Vector2, UnityTile>();
terrainControllerScript = TerrainController.GetComponent <TerrainController>();
}
private void Spawn()
{
int num = Random.Range(minSpawnNumber, maxSpawnNumber);
int totalWeight = 0;
foreach (var spawnSet in spawnSets)
{
totalWeight += spawnSet.weight;
}
for (int i = 0; i < num; i++)
{
int r = Random.Range(0, totalWeight - 1);
foreach (var spawnSet in spawnSets)
{
r -= spawnSet.weight;
if (r <= 0)
{
Vector3 position = GetSpawnPoint();
if (position == PlayerController.Zero)
{
break;
}
CancerController cancer = Get(spawnSet.cancerName);
cancer.transform.position = position;
TerrainController.BakeNavMesh();
break;
}
}
}
}
/*
* -------------------------------------------------------------------------
* MARK: LIFECYCLE FUNCTIONS
* -------------------------------------------------------------------------
*/
void Awake()
{
terrainController = GameObject.FindGameObjectWithTag("Terrain").GetComponent <TerrainController>();
GameObject[] groundTiles = GameObject.FindGameObjectsWithTag("Ground Tile");
tileRenderers = groundTiles.Select((tile) => tile.GetComponent <Renderer>())
.Cast <Renderer>()
.ToArray();
tileControllers = groundTiles.Select((tile) => tile.GetComponent <GroundTileController>())
.Cast <GroundTileController>()
.ToArray();
foreach (GameObject tile in groundTiles)
{
if (tile.transform.position.x + 1 > gridSizeX)
{
gridSizeX = (int)tile.transform.position.x + 1;
}
if (tile.transform.position.z + 1 > gridSizeZ)
{
gridSizeZ = (int)tile.transform.position.z + 1;
}
}
groundHashtable = new GroundHashtable(this);
groundGraph = new GroundGraph(this);
groundGraph.ConstructGraph();
}
protected override IEnumerator Init()
{
NetworkClient nc = CustomNetworkManager.AddPlayer();
if (nc != null)
{
TerrainController tc = GameObject.FindObjectOfType <TerrainController>();
if (tc != null)
{
yield return(tc.GenerateTerrain(LoadingPanel.OnProgress));
}
tc.CreateLight();
if (Parent != null)
{
Parent.Activate <GameState_Play>();
}
}
else
{
nc.Disconnect();
CustomNetworkManager.Stop();
Deactivate <GameState_AddPlayer>();
}
yield return(base.Init());
}
private void Awake()
{
if (Singleton == null)
{
Singleton = this;
}
}
void Initialize()
{
mesh = new Mesh();
activeBlock = new ColorBlock();
activeBlock.normalColor = activeColor;
activeBlock.highlightedColor = highLightColor;
activeBlock.pressedColor = pressedColor;
activeBlock.colorMultiplier = 1;
inActiveBlock = new ColorBlock();
inActiveBlock.normalColor = inActiveColor;
inActiveBlock.highlightedColor = highLightColor;
inActiveBlock.pressedColor = pressedColor;
inActiveBlock.colorMultiplier = 1;
raiseButton.onClick.AddListener(delegate { ButtonSelect(raiseButton, 0); });
lowerButton.onClick.AddListener(delegate { ButtonSelect(lowerButton, 1); });
biomeButton.onClick.AddListener(delegate { ButtonSelect(biomeButton, 2); });
sizeText.text = sizeSlider.value.ToString();
strengthText.text = strengthSlider.value.ToString();
sizeSlider.onValueChanged.AddListener(delegate { SetSliderText(sizeSlider.value, sizeText, 0); });
strengthSlider.onValueChanged.AddListener(delegate { SetSliderText(strengthSlider.value, strengthText, 1); });
terrainController = TerrainController.thisTerrainController;
}
// Find all GridTiles in a radius around point
public static List <GridTile> FindGridTilesAround(Vector3 point, float circleRadius)
{
List <GridTile> gridTiles = new List <GridTile>();
GridTile middleTile = FindClosestGridTile(point);
TerrainController terrain = TerrainController.thisTerrainController;
float startTile = -circleRadius;
float endTile = circleRadius;
if (middleTile == null)
{
return(gridTiles);
}
for (float i = startTile - 1; i < endTile; i += terrain.tileSize)
{
for (float j = startTile - 1; j < endTile; j += terrain.tileSize)
{
GridTile tile = FindClosestGridTile(new Vector3(middleTile.position.x + i, 0, middleTile.position.z + j));
if (tile == null)
{
continue;
}
if (Vector3.Distance(new Vector3(tile.position.x, 0, tile.position.z), new Vector3(point.x, 0, point.z)) < circleRadius)
{
gridTiles.Add(FindClosestGridTile(tile.position));
}
}
}
return(gridTiles);
}
void CheckSelectedTile()
{
RaycastHit hit;
TerrainController terrain = TerrainController.thisTerrainController;
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray, out hit, float.MaxValue, terrainLayer))
{
highlighter.Clear();
GridTile tile = GridTile.FindClosestGridTile(hit.point - new Vector3(terrain.tileSize / 2, 0, terrain.tileSize / 2));
if (tile == null)
{
return;
}
for (int i = 0; i < 4; i++)
{
vert[i] = tile.gridNodes[i].position + new Vector3(0, 0.3f, 0);
}
highlighter.vertices = vert;
highlighter.triangles = tri;
highlighter.uv = uv;
UIScript.GetInstance().SetActiveTile(tile);
}
highlighter.RecalculateNormals();
GetComponent <MeshFilter>().mesh = highlighter;
}
/*
* -------------------------------------------------------------------------
* MARK: LIFECYCLE FUNCTIONS
* -------------------------------------------------------------------------
*/
void Awake()
{
terrainController = GameObject.FindGameObjectWithTag("Terrain").GetComponent <TerrainController>();
wallControllers = GameObject.FindGameObjectsWithTag("Wall")
.Select((wall) => wall.GetComponent <WallController>())
.Cast <WallController>()
.ToArray();
}
// Start is called before the first frame update
void Awake()
{
gameRefModel = FindObjectOfType <GameRefModel>();
gameRefController = FindObjectOfType <GameRefController>();
networkSyncManager = FindObjectOfType <NetworkSyncManager>();
terrainController = FindObjectOfType <TerrainController>();
realtime = FindObjectOfType <Realtime>();
}
public void StartTerrain()
{
Debug.Log("Initializing terrain.");
//TerrainController.OnRenderComplete += OnRenderComplete;
//NPCControll.OnNpcDestroyed += OnNpcDestroyed;
TerrainController.Init();
UIcam = GameObject.Find("BlackBackground");
}
void Awake()
{
InitializeEntityScript();
toggleableScript = GetComponent <ToggleableScript>();
boxCollider = GetComponent <BoxCollider2D>();
terrainController = GameObject.Find("TerrainController").GetComponent <TerrainController>();//replace this with something better
InitializeWheelableScript();
}
public void SetUp(TerrainController terrainController)
{
this.terrainController = terrainController;
meshFilter.mesh = new Mesh();
chunk = new TerrainChunk(Resolution, meshFilter.sharedMesh);
chunk.ConstructMesh();
chunk.ChangeTriangles(CreateTriangles());
MakePerlinTerrain();
}
private float nextShoot; // time of the next shot
void Start()
{
barrel = barrelObj.transform;
cannon = CannonObj.transform;
terrainComp = terrainObj.GetComponent <TerrainController>();
filledTiles = new List <Vector3>();
StartCoroutine("Play");
}
protected override IEnumerator Init()
{
TerrainController terrain = GameObject.FindObjectOfType <TerrainController>();
yield return(terrain.GenerateTerrain(LoadingPanel.OnProgress));
CreateLight();
yield return(base.Init());
}
void Awake()
{
InitializeEntityScript();
toggleableScript = GetComponent <ToggleableScript>();
boxCollider = GetComponent <BoxCollider2D>();
entityController = GameObject.Find("EntityController").GetComponent <EntityController>();
terrainController = GameObject.Find("TerrainController").GetComponent <TerrainController>();
player = GameObject.Find("Player");
InitializeWheelableScript();
}
void OnDisable()
{
terrain = TerrainController.thisTerrainController;
if (terrain != null)
{
WindVisualizer.instance.StopVisualizeWind();
}
toggle.isOn = false;
}
void Awake()
{
if (!Instance)
{
Instance = this;
}
else
{
Debug.Log("Only one terrain controller allowed per scene. Destroying duplicate.");
Destroy(this);
}
}
void Awake()
{
Application.runInBackground = true;
int poolThreads = Mathf.Min(3, Mathf.Max(SystemInfo.processorCount - 1, 1));
MyThreadPool.StartThreadPool(poolThreads);
// Set this to the terraincontroller
thisTerrainController = this;
worldController.Reset();
}
public void Awake()
{
if (File.Exists(path + "Rules.json"))
{
rules = JSONSaver.Load <RuleController>(path + "Rules.json");
}
else
{
JSONSaver.Save <RuleController>(path + "Rules.json", rules);
}
if (File.Exists(path + "Terrains.json"))
{
terrains = JSONSaver.Load <TerrainController>(path + "Terrains.json");
}
else
{
JSONSaver.Save <TerrainController>(path + "Terrains.json", terrains);
}
if (File.Exists(path + "Units.json"))
{
units = JSONSaver.Load <UnitController>(path + "Units.json");
}
else
{
JSONSaver.Save <UnitController>(path + "Units.json", units);
}
if (File.Exists(path + "Sprites.json"))
{
sprites = JSONSaver.Load <SpriteController>(path + "Sprites.json");
}
else
{
JSONSaver.Save <SpriteController>(path + "Sprites.json", sprites);
}
if (File.Exists(path + "Clips.json"))
{
clips = JSONSaver.Load <ClipController>(path + "Clips.json");
}
else
{
JSONSaver.Save <ClipController>(path + "Clips.json", clips);
}
rules.Awake();
terrains.Awake();
units.Awake();
sprites.Awake();
clips.Awake();
}
public void Encode()
{
Debug.Log("EncodeHeightMaps");
TerrainController TC = TerrainController.Instance;
AHMS = new HeightmapSerial[TC.TerrainList.Count];
for (int Idx = 0; Idx < TC.TerrainList.Count; Idx++)
{
HeightmapSerial HMS = new HeightmapSerial();
HMS.Encode(TC.TerrainList[Idx]);
AHMS[Idx] = HMS;
}
}
public override void OnInspectorGUI()
{
if (_target == null)
{
_target = target as TerrainController;
}
DrawDefaultInspector();
DrawTileOptions();
DrawButtons();
}
void Start()
{
source = GetComponent <AudioSource> ();
Random.seed = (int)System.DateTime.Now.Ticks;
GetComponent <SpriteRenderer> ().sprite = sprites [Random.Range(0, 1)];
GameObject.Find("Glaze").GetComponent <SpriteRenderer> ().sprite = sprites [Random.Range(2, 5)];
GameObject.Find("Sprinkles").GetComponent <SpriteRenderer> ().sprite = sprites [Random.Range(6, 8)];
terrainController = GameObject.Find("Background").GetComponent <TerrainController> ();
rb = GetComponent <Rigidbody2D>(); //grab the rididbody
rb.gravityScale = 0;
}
public void Decode()
{
TerrainController TC = TerrainController.Instance;
TC.Heightmaps.Clear();
if (AHMS != null)
{ //In case we are loading a blank track
foreach (HeightmapSerial HMS in AHMS)
{
TC.Heightmaps.Add(HMS);
}
}
TC.LoadedNewTerrainHeightmaps = true;
}
public void Initialize(string cityName, int cityMap, TerrainController terrainController)
{
Title.SetTitle(cityName);
GameFacade.CurrentCityName = cityName;
InitializeMap(cityMap);
InitializeMouse();
ZoomLevel = 5; //screen always starts at far zoom, city visible.
CityRenderer.m_ZoomProgress = 0;
JoinLotProgress = new UIJoinLotProgress();
JoinLotProgress.BindController <JoinLotProgressController>();
terrainController.Init(CityRenderer);
CityRenderer.SetController(terrainController);
}
public void VisualizeWind()
{
terrain = TerrainController.thisTerrainController;
if (uvs == null)
{
uvs = new Vector2[terrain.chunks.Count][][];
buffereduvs = new Vector2[terrain.chunks.Count][][];
for (int i = 0; i < uvs.Length; i++)
{
uvs[i] = new Vector2[intpSteps][];
buffereduvs[i] = new Vector2[intpSteps][];
}
}
StartCoroutine("_VisualizeWind");
}
private void CheckSetup()
{
if (_setupCompleted)
{
return;
}
child = new GameObject("Colliders").transform;
child.parent = transform;
terrainController = GetComponent <TerrainController>();
_loadingCircle = TerrainUtilities.GenerateLoadingCircle(preloadRadius);
_collisionUsers = new List <TerrainCollisionUser>();
_collisionTileBuffer = new Dictionary <IntegerCoordinate2D, TerrainCollisionTile>();
_currentCenterLoadingStates = new Dictionary <IntegerCoordinate2D, LoadingState>();
_currentLoadingCenters = new HashSet <IntegerCoordinate2D>();
_setupCompleted = true;
}
public override void OnInspectorGUI()
{
TerrainController TC = (TerrainController)target;
DrawDefaultInspector();
if (GUILayout.Button("Generate"))
{
TC.GenerateTerrain();
}
if (GUILayout.Button("Destroy Trees"))
{
TC.DestroyTrees();
}
}
protected override IEnumerator Init()
{
GUIContainer.LoadingPanel.gameObject.SetActive(true);
if (CustomNetworkManager.RunServer() != null)
{
TerrainController tc = GameObject.FindObjectOfType <TerrainController>();
yield return(tc.GenerateTerrain(LoadingPanel.OnProgress));
tc.CreateLight();
}
if (Parent != null)
{
Parent.Activate <GameState_Play>();
}
yield return(base.Init());
}
public DefaultPlacementManager(TerrainController tc)
{
controller = tc;
}
public HeightBiasedPlacementManager(TerrainController tc, float ideal, int bias)
: base(tc, bias)
{
idealHeight = ideal;
}
public PlantPlacementManager(TerrainController tc)
: base(tc, 2)
{
}
public PreferentialPlacementManager(TerrainController tc, int bias)
: base(tc)
{
candidateCount = bias;
}
public TypedPlacementManager(TerrainController tc, System.Type t, PlacementManager d)
: base(tc)
{
placementType = t;
delegateManager = d;
minDistance = 5.0f;
}
public WildfirePlacementManager(TerrainController tc, float idealHeight)
: base(tc, idealHeight, 2)
{
}
void Start()
{
source = GetComponent<AudioSource> ();
Random.seed = (int)System.DateTime.Now.Ticks;
GetComponent<SpriteRenderer> ().sprite = sprites [Random.Range (0, 1)];
GameObject.Find ("Glaze").GetComponent<SpriteRenderer> ().sprite = sprites [Random.Range (2, 5)];
GameObject.Find ("Sprinkles").GetComponent<SpriteRenderer> ().sprite = sprites [Random.Range (6, 8)];
terrainController = GameObject.Find ("Background").GetComponent<TerrainController> ();
rb = GetComponent<Rigidbody2D>(); //grab the rididbody
rb.gravityScale = 0;
}
