void Start()
{
player = GameObject.FindGameObjectWithTag("Player").GetComponent<PlayerController>();
if (!player)
Debug.Log("EndControll.cs: Player not Found!");
playerAnimator = player.GetComponentInChildren<PlayerAnimator>();
if (!playerAnimator)
Debug.Log("EndControll.cs: PlayerAnimator not Found!");
gridManager = GameObject.FindObjectOfType<GridManager>();
if (!gridManager)
Debug.Log("EndControll.cs: Grid Manager not Found!");
ui = GameObject.FindObjectOfType<UICollectionItems>();
if (!ui)
Debug.Log("EndControll.cs: ui not Found!");
data = GameObject.FindObjectOfType<ParkourData>();
if (!data)
Debug.Log("EndControll.cs: ParkourData not Found!");
mainParkour = GameObject.FindObjectOfType<MainParkour>();
if (!mainParkour)
Debug.Log("EndControll.cs: MainParkour not Found!");
}
void Start()
{
onBeat = false;
clicked = false;
onePerBeat = false;
scriptMaster = GameObject.FindGameObjectWithTag("GameController").GetComponent<GridManager>();
}
public void Start() {
Floor floor = Helper.Find<Floor>("Floor");
gridManager = floor.GridManager;
unit = GetComponent<BaseUnit>();
soundEffectPLayer = GetComponentInChildren<SoundEffectPlayer>();
LeaveSound = unit.GetComponent<BaseUnit>().LeaveSound;
ArriveSound = unit.GetComponent<BaseUnit>().ArriveSound;
if (LeaveSound.Any() || ArriveSound.Any())
{
AudioSource audioSrc = gameObject.AddComponent<AudioSource>();
LeaveArriveEffectPlayer = gameObject.GetComponent<AudioSource>();
}
if (unit is AvatarUnit)
{
isAvatarMover = true;
currentAvatarUnit = (AvatarUnit)unit;
}
else
{
isAvatarMover = false;
}
}
/// <summary>
/// class manages all mountain peaks
/// </summary>
public MountainPeaksManager(GridManager gridManager)
{
this.gridManager = gridManager;
mountainPeaks = new MountainPeaksCoordinates(20, gridManager, this);
mountainPeaks.InitializePeaks(20);
//Debug.Log(mountainPeaks);
}
void Awake()
{
instance = this;
//ICI: modifier cette affectation pour s'ajuster au personnage actuel
player = GameObject.Find ("Player").transform.GetChild(actualPlayer).gameObject;
}
// track the game state
// track score
// track money
// track lives
// Use this for initialization
void Start()
{
curGameState = GameState.NotInGame;
gameMenu = gameObject.GetComponent<GameMenu>();
enemyManager = gameObject.GetComponent < EnemyManager> ();
gridManager = gameObject.GetComponent<GridManager> ();
}
// Use this for initialization
public override void Init()
{
CombatMoveEvent moveEvent = new CombatMoveEvent();
moveEvent.Character = Character;
m_GridManager = GameObject.FindObjectOfType<GridManager>();
GridHex targetHex = m_GridManager.UniversalNPCTarget;
GridHex currentHex = Character.transform.parent.gameObject.GetComponent<GridHex>();
if (currentHex != targetHex && targetHex.AvailableSpace >= 2)
{
moveEvent.FinalTarget = Pathfinding.PathToHex(currentHex, targetHex)[1];
OnQueueEvent(moveEvent);
}
/* // Random hex movement
GridHex currentHex = Character.transform.parent.gameObject.GetComponent<GridHex>();
List<GridHex> availableHexes = new List<GridHex>();
for (int i = 0; i < 6; i++)
{
if (currentHex.AdjacentHexes[i] != null)
availableHexes.Add(currentHex.AdjacentHexes[i]);
}
int targetHexIndex = Random.Range(0, availableHexes.Count - 1);
moveEvent.FinalTarget = availableHexes[targetHexIndex];
*/
}
// Use this for initialization
void OnTriggerEnter()
{
GameManager = GameObject.FindGameObjectWithTag ("Manager");
Grid = GameManager.GetComponent<GridManager> ();
Donjon = GameManager.GetComponent<DungeonGenerator> ();
foreach (GameObject room in Grid._Dungeon) {
Destroy (room);
}
GameObject[] endroom = GameObject.FindGameObjectsWithTag ("End");
foreach (GameObject item in endroom) {
if (item == gameObject) {
} else {
Destroy (item);
}
}
GameObject[] coins = GameObject.FindGameObjectsWithTag ("Coin");
foreach (GameObject coin in coins) {
Destroy (coin);
}
Donjon.NextLevel ();
Destroy (gameObject);
}
//The grid should be generated on game start
void Awake()
{
instance = this;
setSizes();
createGrid();
generateAndShowPath();
}
void Awake()
{
instance = this;
setSizes();
createGrid();
generateAndShowPath();
Messenger.AddListener("characterMoved", switchOriginAndDestTiles);
}
void Awake()
{
_instance = this;
if( gridController == null )
{
Debug.LogError("No IGridController assigned or found in scene.");
}
}
void Start () {
//Dependancy "GridManager"
gridManagerObject = GameObject.FindGameObjectWithTag("GridManager");
gridManager = gridManagerObject.GetComponent<GridManager>();
//Dependancy "GridVariables"
gridVar = GetComponent<GridVariables>();
UpdateLayer();
}
void Start()
{
gridManager = GameObject.FindObjectOfType<GridManager>();
worldPlacer = GameObject.FindObjectOfType<WorldPlacer>();
itemMenu = GameObject.FindObjectsOfType<ItemMenu>();
moneyManager = GameObject.FindObjectOfType<MoneyManager>();
importMenu = GameObject.FindObjectOfType<ImportMenu>();
}
// Use this for initialization
void Start()
{
squarePixelWidth = MapInfo.squarePixelWidth;
borderPixelWidth = MapInfo.borderPixelWidth;
gridPixelWidth = MapInfo.gridPixelWidth;
draggingTower = false;
gridManager = gameObject.GetComponent<GridManager> ();
inputHandler = gameObject.GetComponent<InputHandler> ();
}
public static List<Tile> GenerateHexGrid(GridManager gm)
{
if(gm.hexTilePrefab==null) gm.hexTilePrefab=Resources.Load("HexTile", typeof(GameObject)) as GameObject;
Transform parentTransform=gm.transform;
float ratio=0.745f/0.86f; //0.86628f
float hR=gm.gridToTileSizeRatio*gm.gridSize;
float wR=hR*ratio;
int counter=0;
float highestY=-Mathf.Infinity; float lowestY=Mathf.Infinity;
float highestX=-Mathf.Infinity; float lowestX=Mathf.Infinity;
List<Tile> tileList=new List<Tile>();
for(int x=0; x<gm.width; x++){
float offset=0.5f*(x%2);
int limit=0;
if(x%2==1) limit=(int)(gm.length/2);
else limit=(int)(gm.length/2+gm.length%2);
for(int y=0; y<limit; y++){
float posX=x*wR;//-widthOffset;
float posY=y*hR+hR*offset;//-lengthOffset;
if(posY>highestY) highestY=posY; if(posY<lowestY) lowestY=posY;
if(posX>highestX) highestX=posX; if(posX<lowestX) lowestX=posX;
Vector3 pos=new Vector3(posX, gm.baseHeight, posY);
GameObject obj=(GameObject)PrefabUtility.InstantiatePrefab(gm.hexTilePrefab);
obj.name="Tile"+counter.ToString();
Transform objT=obj.transform;
objT.parent=parentTransform;
objT.localPosition=pos;
objT.localRotation=Quaternion.Euler(-90, 0, 0);
objT.localScale*=gm.gridSize*1.1628f;
Tile hTile=obj.GetComponent<Tile>();
tileList.Add(hTile);
counter+=1;
}
}
float disY=(Mathf.Abs(highestY)-Mathf.Abs(lowestY))/2;
float disX=(Mathf.Abs(highestX)-Mathf.Abs(lowestX))/2;
foreach(Tile hTile in tileList){
Transform tileT=hTile.transform;
tileT.position+=new Vector3(-disX, 0, -disY);
hTile.pos=tileT.position;
}
return tileList;
}
// Use this for initialization
public void Fill()
{
cible.Clear ();
ratioMax = 0;
ratioX = 0;
ratioY = 0;
ratio = 0;
GameManager = GameObject.FindGameObjectWithTag ("Manager");
Grid = GameManager.GetComponent<GridManager> ();
RoomLists = GameManager.GetComponent<RoomManager> ();
for (int x = 0; x < Grid.DungeonLength; x++) {
for (int y = 0; y < Grid.DungeonWidth; y++) {
if (Grid._Dungeon [x, y] != null)
{
ratioX = 11 - x;
ratioY = 11 - y;
ratio = ratioX + ratioY;
if (ratio < 0) {
ratioX = x-11;
ratioY = y-11;
ratio = ratioX + ratioY;
}
if (ratio == ratioMax) {
cible.Add(Grid._Dungeon[x,y]);
} else { if (ratio > ratioMax) {
ratioMax = ratio;
cible.Clear();
cible.Add(Grid._Dungeon[x,y]);
}
}
}
}
}
foreach (GameObject room in cible) {
GameObject EndRoom = Instantiate (End) as GameObject;
EndRoom.transform.position = room.transform.position;
}
}
void Start () {
currentLines = new int[lines.Length];
currentObjects = new MovableItemOnStage[lines.Length];
dirtyFlags = new bool[lines.Length];
gridManager = GameObject.FindObjectOfType<GridManager>();
for (int i = 0; i < currentLines.Length; i++)
currentLines[i] = 0;
}
public PatchManager(int patchSize)
{
this.patchSize = patchSize;
rMin = new GlobalCoordinates(100);
rMax = new GlobalCoordinates(100);
noise = new GlobalCoordinates(100);
patchLevel = new GlobalCoordinates(100);//-1 = random,0=low,1=medium,2=high
gm = new GridManager(new Vector3(0, 0, 0), patchSize, patchSize);
SetPatchOrder(PatchOrder.LMH);
}
//to grab four edges:
//whoever wants to do this should just convert ij positions in grid to Vector3 positions
public void Awake()
{
Instance = this;
// Start with size of block, determine size of grid
if (baseSize == null) {
Debug.Log("Please assign a transform to grid's base size.");
}
BoxCollider2D box = baseSize.GetComponent<BoxCollider2D>();
xGridSize = box.size.x*xBuffer;
yGridSize = box.size.y*yBuffer;
//Doesn't really matter if collider or collider2D used
//Just select a bounds
Bounds bounds;
if(GetComponent<Collider>()!=null)
{
bounds = GetComponent<Collider>().bounds;
}
else if (GetComponent<Collider2D>()!=null)
{
bounds = GetComponent<Collider2D>().bounds;
}
else
{
Debug.LogError("ERROR! no collider attached to grid!");
bounds = new Bounds();
}
center = bounds.center;
ext = new Vector3(0, 0, 0);
float w; //width of entire grid
float h;
w = xGridSize * numColumns;
h = yGridSize * numRows;
ext.x = w / 2f;
ext.y = h / 2f;
//position of first block is at xOffset, yOffset
xOffset = (center.x - ext.x + xGridSize / 2);
yOffset = (center.y - ext.y + yGridSize / 2);
//resize grid so it matches new ext values
Vector3 newScale = new Vector3(ext.x / bounds.extents.x, ext.y / bounds.extents.y, 1f);
float extraScale = 1.1f;
transform.localScale = new Vector3(newScale.x * transform.localScale.x,
newScale.y * transform.localScale.y,
newScale.z * transform.localScale.z);
transform.localScale *= extraScale;
}
void Start () {
//Dependancy "GridManager"
gridManagerObject = GameObject.FindGameObjectWithTag("GridManager");
gridManager = gridManagerObject.GetComponent<GridManager>();
//Dependancy "GridVariables", "PlayerVariables"
gridVar = GetComponent<GridVariables>();
playerVar = GetComponent<PlayerVariables>();
//Dependancy "GridLayer"
gridLayer = GetComponent<GridLayer>();
//Set position of object based on current layer
transform.position = new Vector3(transform.position.x, gridVar.gridLayer * gridManager.tileSize);
}
static void GenerateHexGrid(GridManager gm, _TileType tileType)
{
if(tileType==_TileType.Square){
gm.width=8;
gm.length=8;
}
//clear previous tile
Tile[] allTilesInScene=(Tile[])FindObjectsOfType(typeof(Tile));
foreach(Tile tile in allTilesInScene){
if(tile.unit!=null) DestroyImmediate(tile.unit.gameObject);
DestroyImmediate(tile);
}
/*
for(int i=0; i<gm.allTiles.Count; i++){
if(gm.allTiles[i]!=null){
if(gm.allTiles[i].unit!=null) DestroyImmediate(gm.allTiles[i].unit.gameObject);
DestroyImmediate(gm.allTiles[i].gameObject);
}
}
gm.allTiles=new List<Tile>();
*/
gm.type=tileType;
if(gm.type==_TileType.Square) GridManagerEditor.GenerateSquareGrid(gm);
else if(gm.type==_TileType.Hex) GridManagerEditor.GenerateHexGrid(gm);
allTilesInScene=(Tile[])FindObjectsOfType(typeof(Tile));
List<Tile> tileList=new List<Tile>();
foreach(Tile tile in allTilesInScene){
tileList.Add(tile);
}
for(int i=0; i<tileList.Count; i++) tileList[i].gameObject.layer=8;
//set neighbour
for(int i=0; i<tileList.Count; i++){
Tile hT=tileList[i];
Vector3 pos=hT.transform.position;
Collider[] cols=Physics.OverlapSphere(pos, gm.gridSize*gm.gridToTileSizeRatio*0.6f);
List<Tile> neighbour=new List<Tile>();
foreach(Collider col in cols){
Tile hTile=col.gameObject.GetComponent<Tile>();
if(hTile!=null && hT!=hTile){
neighbour.Add(hTile);
}
}
hT.SetNeighbours(neighbour);
}
gm.GenerateGrid(false);
}
void Awake()
{
//Debug.Log("CombatManager::Start()");
m_CombatCharacters = new List<CombatCharacterController>();
for (int i = 0; i < ManualCharacterArray.Length; i++)
{
m_CombatCharacters.Add(ManualCharacterArray[i]);
}
CalculateTurnOrder();
m_GridManager = gameObject.GetComponent<GridManager>();
}
void Start () {
floorTransform = gameObject.transform.GetChild(0);
if (!floorTransform)
Debug.Log("Floor not Found.");
player = GameObject.FindGameObjectWithTag("Player").GetComponent<PlayerController>();
if (!player)
Debug.Log("Player not Found!");
gridManager = GameObject.FindObjectOfType<GridManager>();
if (!gridManager)
Debug.Log("Grid Manager not Found!");
}
//Pause function added to the move (ends)
public void Start()
{
try
{
_pauseMenuPanel = Helper.Find<RectTransform>("PauseMenuPanel");
_pauseMenuStartLocation = _pauseMenuPanel.rect.yMin;
}
catch (Exception)
{
//Continue with bussiness as usual...
//Detta händer om det inte finns någon paus-meny och knapp
}
_mover = GetComponent<Mover>();
_rotation = GetComponentInChildren<Rotation>();
Floor floor = Helper.Find<Floor>("Floor");
_gridManager = floor.GridManager;
_pathFinder = new PathFinder(_gridManager);
//Audio related
_lockAudioSourceLocation = this.gameObject.transform.rotation;
_audioComponent = this.gameObject.transform.FindChild("AudioComponent").gameObject;
_avatarSoul = GameObject.Find("AvatarSoul");
if (_avatarSoul != null) //ADD soul if it is multiple characters
{
_soulMover = _avatarSoul.GetComponentInChildren<SoulMover>();
//Om det finns en soul ta bort audio listener och ljus på avatar
AudioListener audioList = GetComponent<AudioListener>();
Light lightOnChar = GetComponentInChildren<Light>();
if (audioList != null)
{
audioList.enabled = false;
}
if (lightOnChar != null)
{
lightOnChar.enabled = false;
}
}
_soundEffectPlayer = GetComponentInChildren<SoundEffectPlayer>();
AvatarStates avatarStates = new AvatarStates(gameObject);
_stateMachine = avatarStates.GetStateMachine();
}
public void ReceiveEventMethod(StaticEventMethods eventMessage, GridManager gridmanager)
{
gridManager = gridmanager;
switch (eventMessage)
{
case StaticEventMethods.None:
break;
case StaticEventMethods.HideAndDisableObject:
HideAndDisableObject();
break;
case StaticEventMethods.ToggleHideDisableAndActiveVisibleObject:
ToggleHideAndDisableObject();
break;
case StaticEventMethods.TurnOffProjectileAndMedusa:
TurnOffProjectileAndMedusa();
break;
case StaticEventMethods.ToggleTurnOffProjectileAndMedusa:
ToggleTurnOffProjectileAndMedusa();
break;
case StaticEventMethods.MakeVisibleAndActive:
MakeVisibleAndActive();
break;
case StaticEventMethods.TurnOnProjectileAndMedusa:
TurnOnProjectileAndMedusa();
break;
case StaticEventMethods.PortalActivateAndMakeTileActive:
PortalActivateAndMakeTileActive();
break;
case StaticEventMethods.PortalDeactivate:
PortalDeactivate();
break;
case StaticEventMethods.PortalToggleActivate:
PortalToggleActivate();
break;
}
}
public MountainPeaksCoordinates(int quadrantSize, GridManager gridManager, MountainPeaksManager mountainPeaksManager)
{
gm = gridManager;
mpm = mountainPeaksManager;
globalCenter = new MountainPeaks(0,0, gm.GetPointArea(0,0), mpm);
quadrant1 = new MountainPeaks[quadrantSize, quadrantSize];
quadrant2 = new MountainPeaks[quadrantSize, quadrantSize];
quadrant3 = new MountainPeaks[quadrantSize, quadrantSize];
quadrant4 = new MountainPeaks[quadrantSize, quadrantSize];
InitialiseQuadrant(quadrant1, 1);
InitialiseQuadrant(quadrant2, 2);
InitialiseQuadrant(quadrant3, 3);
InitialiseQuadrant(quadrant4, 4);
}
public void setup(int _x, int _y, GridManager _manager){
xPos = _x;
yPos = _y;
manager = _manager;
gameObject.name = "room_" + xPos + "_" + yPos;
float offset = (float)gridSize / 2.0f;
//Debug.Log ("offset: " + offset);
transform.position = new Vector3 (xPos * gridSize - offset, yPos * gridSize - offset);
grid = new Tile[gridSize, gridSize];
indicators = new GameObject[gridSize, gridSize];
if (isFirstRoom) {
firstRoomRevealTiles = new List<RevealTile>();
}
//add the grid indicators and default the grid to null
for (int x=0; x<gridSize; x++) {
for (int y=0; y<gridSize; y++) {
GameObject newIndicator = Instantiate(gridIndicatorPrefab, Vector3.zero, new Quaternion(0,0,0,0)) as GameObject;
newIndicator.transform.parent = transform;
newIndicator.transform.localPosition = new Vector3 (x, y, 1);
indicators[x,y] = newIndicator;
grid[x,y] = null;
//put a reveal tile here
GameObject revealObj = Instantiate(revealTilePrefab, newIndicator.transform.position, Quaternion.identity) as GameObject;
if (isFirstRoom) {
RevealTile thisReveal = revealObj.GetComponent<RevealTile> ();
if (x < 1 || x > 2 || y < 1 || y > 2) {
thisReveal.isFrozen = true;
} else {
thisReveal.isFrozen = false;
}
firstRoomRevealTiles.Add (thisReveal);
}
}
}
}
public Controller()
{
_viewerServer = new Server();
_backboneServers = new BackboneServers();
_agentManager = new AgentManager(_viewerServer);
_gridManager = new GridManager(_viewerServer, _agentManager);
_scene = new SceneGraph(_viewerServer, _agentManager);
ClientConnection.Grid = _gridManager;
ClientConnection.Scene = _scene;
ClientConnection.AgentManager = _agentManager;
_viewerServer.Startup();
if(Globals.Instance.StartLoginServer)
{
_loginServer = new LoginServer();
_loginServer.Startup();
}
}
public override void OnInspectorGUI()
{
GM = (GridManager)target;
EditorGUILayout.LabelField("Scanning: " + GridManager.isScanning);
GM.DebugLvl = (GridManager.DebugLevel)EditorGUILayout.EnumPopup("Debug Level: ", GM.DebugLvl);
GUILayout.Space(10f);
GM.grid.name = EditorGUILayout.TextField("Name: ", GM.grid.name);
GM.grid.center = EditorGUILayout.Vector3Field("Center", GM.grid.center);
GM.grid.WorldSize = EditorGUILayout.Vector2Field("World Size", GM.grid.WorldSize);
GM.grid.NodeRadius = EditorGUILayout.FloatField("Node Radius", GM.grid.NodeRadius);
GM.grid.angleLimit = EditorGUILayout.IntSlider("Max Angle", GM.grid.angleLimit, 0, 90);
GM.grid.WalkableMask = LayerMaskField("Walkable Layer(s):", GM.grid.WalkableMask, true);
GUILayout.Space(10);
if (GUILayout.Button("Scan Grid"))
{
GridManager.ScanGrid();
}
GUI.backgroundColor = Color.red;
GUI.backgroundColor = Color.white;
GUILayout.Space(10);
}
public void CleanUp()
{
if (names != null)
{
names.Dispose();
names = null;
}
if (gridManager != null)
{
gridManager.Dispose();
gridManager = null;
}
if (rlv != null)
{
rlv.Dispose();
rlv = null;
}
if (client != null)
{
UnregisterClientEvents(client);
}
if (pluginManager != null)
{
pluginManager.Dispose();
pluginManager = null;
}
if (movement != null)
{
movement.Dispose();
movement = null;
}
if (commandsManager != null)
{
commandsManager.Dispose();
commandsManager = null;
}
if (ContextActionManager != null)
{
ContextActionManager.Dispose();
ContextActionManager = null;
}
if (mediaManager != null)
{
mediaManager.Dispose();
mediaManager = null;
}
if (state != null)
{
state.Dispose();
state = null;
}
if (netcom != null)
{
netcom.Dispose();
netcom = null;
}
if (mainForm != null)
{
mainForm.Load -= new EventHandler(mainForm_Load);
}
Logger.Log("RadegastInstance finished cleaning up.", Helpers.LogLevel.Debug);
}
