Inheritance: MonoBehaviour
示例#1
0
 void Start()
 {
     onBeat = false;
     clicked = false;
     onePerBeat = false;
     scriptMaster = GameObject.FindGameObjectWithTag("GameController").GetComponent<GridManager>();
 }
示例#2
0
    // 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);
    }
示例#3
0
	void Awake()
	{
		instance = this;
		//ICI: modifier cette affectation pour s'ajuster au personnage actuel
		player = GameObject.Find ("Player").transform.GetChild(actualPlayer).gameObject;

	}
 //The grid should be generated on game start
 void Awake()
 {
     instance = this;
     setSizes();
     createGrid();
     generateAndShowPath();
 }
 /// <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 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!");
    }
示例#7
0
	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;
	    }
	}
 // 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];
        */
    }
示例#10
0
文件: GridManager.cs 项目: VicBoss/KR
 void Awake()
 {
     instance = this;
     setSizes();
     createGrid();
     generateAndShowPath();
     Messenger.AddListener("characterMoved", switchOriginAndDestTiles);
 }
示例#11
0
	void Start () {
        //Dependancy "GridManager"
        gridManagerObject = GameObject.FindGameObjectWithTag("GridManager");
        gridManager = gridManagerObject.GetComponent<GridManager>();
        //Dependancy "GridVariables"
        gridVar = GetComponent<GridVariables>();
   
        UpdateLayer();
    }
示例#12
0
    void Start()
    {
        gridManager = GameObject.FindObjectOfType<GridManager>();
        worldPlacer = GameObject.FindObjectOfType<WorldPlacer>();
        itemMenu = GameObject.FindObjectsOfType<ItemMenu>();
        moneyManager = GameObject.FindObjectOfType<MoneyManager>();

        importMenu = GameObject.FindObjectOfType<ImportMenu>();
    }
示例#13
0
 // 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> ();
 }
    void Awake()
    {
        _instance = this;

        if( gridController == null )
        {
            Debug.LogError("No IGridController assigned or found in scene.");
        }
    }
示例#15
0
    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;
    }
示例#16
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);
    }
示例#17
0
    // 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;
    }
示例#19
0
    //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;
    }
示例#20
0
	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);
	}
示例#21
0
    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);
    }
示例#22
0
	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!");
    }
    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>();
    }
示例#24
0
    //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();
	}
示例#25
0
    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);
    }
示例#27
0
	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);
				}
			}
		}

	}
示例#28
0
        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);
    }
示例#30
0
 public void SetToCellPosition(GridCell gc)
 {
     currentCell        = gc;
     transform.position = GridManager.CellToWorldPos(currentCell);
 }
示例#31
0
    //Snap to current cell

    public virtual void Start()
    {
        currentCell        = GridManager.Instance.WorldPosToGridCell(transform.position);
        transform.position = GridManager.CellToWorldPos(currentCell);
    }
示例#32
0
    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);
    }
示例#33
0
        public void Outboundwormhole(string ip, string outfile, double xgate, double ygate, double zgate)
        {
            BoundingSphereD gate = new BoundingSphereD(new Vector3D(xgate, ygate, zgate), Config.InRadiusGate);

            foreach (var entity in MyAPIGateway.Entities.GetTopMostEntitiesInSphere(ref gate))
            {
                var grid = (entity as VRage.Game.ModAPI.IMyCubeGrid);
                if (grid != null)
                {
                    var playerInCharge = MyAPIGateway.Players.GetPlayerControllingEntity(entity);
                    if (playerInCharge != null && OwnershipUtils.GetOwner(entity as MyCubeGrid) == playerInCharge.IdentityId)//hasrighttomove(playerInCharge, entity as MyCubeGrid))
                    {
                        var WormholeDrives = new List <IMyJumpDrive>();
                        var gts            = MyAPIGateway.TerminalActionsHelper.GetTerminalSystemForGrid(grid);
                        gts.GetBlocksOfType(WormholeDrives);
                        if (Config.DontNeedJD)
                        {
                            List <MyCubeGrid> grids = GridFinder.FindGridList(grid.EntityId.ToString(), playerInCharge as MyCharacter, Config.IncludeConnectedGrids);
                            if (grids == null)
                            {
                                return;
                            }
                            if (grids.Count == 0)
                            {
                                return;
                            }
                            var filename = playerInCharge.SteamUserId.ToString() + "_" + grid.GetFriendlyName() + "_" + DateTime.Now.ToString("yyyy_MM_dd_HH_mm_ss");

                            Sandbox.Game.MyVisualScriptLogicProvider.CreateLightning(new Vector3D(xgate, ygate, zgate));
                            if (GridManager.SaveGrid(CreatePath(outfile, filename), filename, ip, Config.KeepOriginalOwner, Config.ExportProjectorBlueprints, grids))
                            {
                                foreach (var delgrid in grids)
                                {
                                    delgrid.Delete();
                                }
                            }
                        }
                        else if (WormholeDrives.Count > 0)
                        {
                            foreach (var WormholeDrive in WormholeDrives)
                            {
                                if (WormholeDrive.OwnerId == playerInCharge.IdentityId && WormholeDrive.Enabled && WormholeDrive.CurrentStoredPower == WormholeDrive.MaxStoredPower && (WormholeDrive.BlockDefinition.SubtypeId.ToString() == Config.JumpDriveSubid || Config.WorkWithAllJD))
                                {
                                    WormholeDrive.CurrentStoredPower = 0;
                                    if (Config.DisableJD)
                                    {
                                        foreach (var jd in WormholeDrives)
                                        {
                                            jd.Enabled = false;
                                        }
                                    }
                                    List <MyCubeGrid> grids = GridFinder.FindGridList(grid.EntityId.ToString(), playerInCharge as MyCharacter, Config.IncludeConnectedGrids);
                                    if (grids == null)
                                    {
                                        return;
                                    }
                                    if (grids.Count == 0)
                                    {
                                        return;
                                    }
                                    var filename = playerInCharge.SteamUserId.ToString() + "_" + playerInCharge.DisplayName + "_" + grid.DisplayName + "_" + DateTime.Now.ToString("yyyy_MM_dd_HH_mm_ss");

                                    Sandbox.Game.MyVisualScriptLogicProvider.CreateLightning(new Vector3D(xgate, ygate, zgate));
                                    if (GridManager.SaveGrid(CreatePath(outfile, filename), filename, ip, Config.KeepOriginalOwner, Config.ExportProjectorBlueprints, grids))
                                    {
                                        foreach (var delgrid in grids)
                                        {
                                            delgrid.Delete();
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
 public void StartSimulation(List <Cell> inPath)
 {
     startCell = GridManager.GetCellAt(transform.position);
     path.AddRange(inPath);
     enabled = true;
 }
示例#35
0
 public static GridItem BelongsTo(Weapon wep)
 {
     return(GridManager.SnapToGrid(wep.transform.position));
 }
示例#36
0
    public void FindSelectableTiles()
    {
        ComputeAdjacencyList(null);
        GetCurrentTile();

        Queue <Tile> process = new Queue <Tile>();

        process.Enqueue(currentTile); //add first tile to queue
        currentTile.visited = true;
        //currentTile.parent = null;

        while (process.Count > 0)
        {
            Tile t = process.Dequeue();


            var enemy = t.CheckEnemyOccupied(t.gridCoord);
            if (enemy != null)
            {
                t.enemyOccupied = true;
            }
            //selectableTiles.Add(t);

            if (t.distance <= remainingMove)
            {
                if (t.blocked)
                {
                    return;
                }

                if (!t.occupied)
                {
                    t.selectable = true;
                }
            }
            else
            {
                if (t.blocked)
                {
                    return;
                }
                t.inAttackRange = true;
            }

            if (t.distance < remainingMove + Range)
            {
                foreach (Tile tile in t.adjacencyList)
                {
                    if (t.blocked)
                    {
                        return;
                    }
                    if (!tile.visited)
                    {
                        tile.parent   = t;
                        tile.visited  = true;
                        tile.distance = 1 + t.distance;
                        process.Enqueue(tile);
                    }
                }
            }

            //double check
            if (t.occupied)
            {
                enemy = t.CheckEnemyOccupied(t.gridCoord);
                if (enemy != null)
                {
                    t.enemyOccupied = true;
                }
            }
        }
        GridManager.UpdateTilesGrid();
    }
示例#37
0
    private void Start()
    {
        gm = GetComponent <GridManager>();

        // Setup level characteristics for GridManager
        if (currentLevel == 0)
        {
            currentLevel = 1;
        }
        if (overrideLevelData)
        {
            LevelData newLevelData = new LevelData(inspectorGridWidth, inspectorGridHeight, 4, 0);
            gm.ReceiveLevelData(newLevelData.LevelTable[0]);
        }
        else
        {
            gm.ReceiveLevelData(levelData.LevelTable[LevelDataIndex]);
        }
        gm.Init();


        // Setup GridObjectManager
        gom = GetComponent <GridObjectManager>();
        if (overrideSpawnSequence.Length > 0)
        {
            for (int i = 0; i < overrideSpawnSequence.Length; i++)
            {
                gom.insertSpawnSequences.Add(overrideSpawnSequence[i].Clone());
            }
        }

        if (VerboseConsole)
        {
            debugHUD = GameObject.FindGameObjectWithTag("Debug HUD").GetComponent <DebugHUD>();
        }
        display = GameObject.FindGameObjectWithTag("Game Display").GetComponent <GameDisplay>();


        // Setup Player
        Vector2Int startLocation = new Vector2Int(0, 0);

        if (overrideSpawnSequence.Length > 0)
        {
            startLocation = overrideSpawnSequence[0].playerSpawnLocation;
        }

        GameObject player = Instantiate(gom.playerPrefab, gm.GridToWorld(startLocation), Quaternion.identity);

        if (VerboseConsole)
        {
            Debug.Log(player.name + " has been instantiated.");
        }

        if (VerboseConsole)
        {
            Debug.Log("Adding Player to Grid.");
        }
        gm.AddObjectToGrid(player, startLocation);
        this.player = player.GetComponent <Player>();
        this.player.currentWorldLocation = gm.GridToWorld(startLocation);
        this.player.targetWorldLocation  = gm.GridToWorld(startLocation);
        if (VerboseConsole)
        {
            Debug.Log("Player successfully added to Grid.");
        }

        this.player.NextLevel(levelData.LevelTable[LevelDataIndex].jumpFuelAmount);

        // Initialize Game Object Manager now that player exists
        gom.Init();

        this.player.OnPlayerAdvance += OnTick;
    }
示例#38
0
        private void btn_salva_Click(object sender, System.EventArgs e)
        {
            DocsPAWA.DocsPaWR.InfoUtente infoUtente = new DocsPAWA.DocsPaWR.InfoUtente();
            infoUtente = UserManager.getInfoUtente(this.Page);

            if (txt_titolo.Text == null || txt_titolo.Text == "")
            {
                MessageBox1.Alert("Indicare un nome per il salvataggio del criterio di ricerca");
            }
            else
            {
                if (schedaRicerca != null && schedaRicerca.ProprietaNuovaRicerca != null)
                {
                    schedaRicerca.ProprietaNuovaRicerca.Id = Int32.Parse(this.idRicercaSalvata);

                    schedaRicerca.ProprietaNuovaRicerca.Titolo = txt_titolo.Text;
                    if (rbl_share.Items[0].Selected)
                    {
                        schedaRicerca.ProprietaNuovaRicerca.Condivisione = DocsPAWA.ricercaDoc.SchedaRicerca.NuovaRicerca.ModoCondivisione.Utente;
                    }
                    else if (rbl_share.Items[1].Selected)
                    {
                        schedaRicerca.ProprietaNuovaRicerca.Condivisione = DocsPAWA.ricercaDoc.SchedaRicerca.NuovaRicerca.ModoCondivisione.Ruolo;
                    }

                    try
                    {
                        string             msg        = string.Empty;
                        string             pagina     = string.Empty;
                        string             _searchKey = schedaRicerca.getSearchKey();
                        System.Web.UI.Page currentPg  = schedaRicerca.Pagina;

                        if (string.IsNullOrEmpty(_searchKey))
                        {
                            pagina = currentPg.ToString();
                        }
                        else
                        {
                            pagina = _searchKey;
                        }

                        //Verifico se salvare anche la griglia
                        string idGriglia = string.Empty;
                        Grid   tempGrid  = new Grid();
                        if (ddl_ric_griglie.Visible)
                        {
                            idGriglia = ddl_ric_griglie.SelectedValue;
                            if (!string.IsNullOrEmpty(idGriglia) && idGriglia.Equals("-2"))
                            {
                                tempGrid = GridManager.CloneGrid(GridManager.SelectedGrid);
                            }
                        }

                        if (!schedaRicerca.verificaNomeModifica(txt_titolo.Text, infoUtente, pagina, this.idRicercaSalvata))
                        {
                            schedaRicerca.Modifica(null, this.showGridPersonalization, idGriglia, tempGrid, GridManager.SelectedGrid.GridType);
                            msg = "Il criterio di ricerca è stato modificato con nome '" + txt_titolo.Text + "'";
                            msg = msg.Replace("\"", "\\\"");
                            DropDownList ddl = (DropDownList)schedaRicerca.Pagina.FindControl("ddl_Ric_Salvate");
                            Session["idRicSalvata"]             = schedaRicerca.ProprietaNuovaRicerca.Id.ToString();
                            schedaRicerca.ProprietaNuovaRicerca = null;
                        }
                        else
                        {
                            msg = "Esiste già una ricerca salvata con questo nome!";
                        }

                        CloseAndPostback(msg);
                    }
                    catch (Exception ex)
                    {
                        MessageBox1.Alert("Errore nel salvataggio della ricerca. Verificare i dati inseriti.");
                    }
                }
            }
        }
示例#39
0
        protected void loadFields()
        {
            InfoUtente infoUtente = UserManager.getInfoUtente(this);

            DocsPaWR.DocsPaWebService    docspaws = ProxyManager.getWS();
            DocsPAWA.DocsPaWR.SearchItem itemOld  = docspaws.RecuperaRicerca(Int32.Parse(idRicercaSalvata));
            txt_titolo.Text    = itemOld.descrizione;
            schedaRicerca.Tipo = itemOld.tipo;
            if (!string.IsNullOrEmpty(itemOld.owner_idPeople.ToString()))
            {
                this.rbl_share.SelectedValue = "usr";
            }
            else
            {
                this.rbl_share.SelectedValue = "grp";
            }

            DocsPAWA.DocsPaWR.Utente userHome  = (DocsPAWA.DocsPaWR.Utente)Session["userData"];
            DocsPAWA.DocsPaWR.Ruolo  userRuolo = (DocsPAWA.DocsPaWR.Ruolo)Session["userRuolo"];

            rbl_share.Items[0].Text = rbl_share.Items[0].Text.Replace("@usr@", userHome.descrizione);
            rbl_share.Items[1].Text = rbl_share.Items[1].Text.Replace("@grp@", userRuolo.descrizione);

            if (schedaRicerca.ProprietaNuovaRicerca.Condivisione == SchedaRicerca.NuovaRicerca.ModoCondivisione.Utente)
            {
                rbl_share.Items[0].Selected = true;
                rbl_share.Items[1].Selected = false;
            }
            else
            {
                rbl_share.Items[0].Selected = false;
                rbl_share.Items[1].Selected = true;
            }

            this.pnl_griglie_custom.Visible = this.showGridPersonalization;
            if (!IsPostBack && this.showGridPersonalization)
            {
                this.ddl_ric_griglie.Items.Clear();
                //Vuol dire c'è una griglia temporanea
                if (GridManager.SelectedGrid != null && string.IsNullOrEmpty(GridManager.SelectedGrid.GridId))
                {
                    ListItem it = new ListItem("Griglia temporanea", "-2");
                    this.ddl_ric_griglie.Items.Add(it);
                }

                string visibility = rbl_share.SelectedValue;
                bool   allGrids   = true;

                if (visibility.Equals("grp"))
                {
                    allGrids = false;
                }

                GridBaseInfo[] listGrid = GridManager.GetGridsBaseInfo(infoUtente, GridManager.SelectedGrid.GridType, allGrids);

                Dictionary <string, GridBaseInfo> tempIdGrid = new Dictionary <string, GridBaseInfo>();

                if (listGrid != null && listGrid.Length > 0)
                {
                    foreach (GridBaseInfo gb in listGrid)
                    {
                        ListItem it = new ListItem(gb.GridName, gb.GridId);
                        this.ddl_ric_griglie.Items.Add(it);
                        tempIdGrid.Add(gb.GridId, gb);
                    }
                    if (!string.IsNullOrEmpty(schedaRicerca.gridId) && tempIdGrid != null && tempIdGrid.Count > 0)
                    {
                        if (tempIdGrid.ContainsKey(schedaRicerca.gridId))
                        {
                            this.ddl_ric_griglie.SelectedValue = schedaRicerca.gridId;
                        }
                    }
                }
            }
        }
示例#40
0
 void Start()
 {
     GridManagerObject = GridManager.instance;
     lerp = false;
 }
示例#41
0
 public override void execute()
 {
     GridManager.MoveDown();
 }
示例#42
0
 public override void execute()
 {
     GridManager.MoveRight();
 }
示例#43
0
 public void Start()
 {
     grid = FindObjectOfType <GridManager>();
 }
示例#44
0
 public ShapeMovement(GridManager gridManager)
 {
     _gridManager = gridManager;
 }
示例#45
0
        protected void Page_Load(object sender, System.EventArgs e)
        {
            Utils.startUp(this);

            if (!IsPostBack)
            {
                this.listGrid        = null;
                this.gridIdPreferred = string.Empty;
                SetTema();
                SetUserRole();
                InfoUtente infoUtente = UserManager.getInfoUtente(this);
                this.ddl_ric_griglie.Items.Clear();

                if (GridManager.SelectedGrid != null)
                {
                    this.listGrid = GridManager.GetGridsBaseInfo(infoUtente, GridManager.SelectedGrid.GridType, true);
                }
                else
                {
                    this.listGrid = GridManager.GetGridsBaseInfo(infoUtente, GridTypeEnumeration.Document, true);
                }

                if (this.listGrid != null && this.listGrid.Length > 0)
                {
                    int count = 0;
                    foreach (GridBaseInfo gb in this.listGrid)
                    {
                        if (!gb.IsSearchGrid && !gb.GridId.Equals("-1"))
                        {
                            ListItem it = new ListItem(gb.GridName, gb.GridId);
                            this.ddl_ric_griglie.Items.Add(it);
                            if (gb.IsPreferred)
                            {
                                this.gridIdPreferred = gb.GridId;
                            }
                            count++;
                        }
                    }
                    if (count > 0)
                    {
                        this.pnl_scelta.Visible = false;
                        this.nuova_g.Visible    = true;
                    }
                    else
                    {
                        //Ho solo la griglia standard quindi non posso modificare nulla devo per forza crearne una nuova
                        this.pnl_scelta.Visible         = false;
                        this.nuova_g.Visible            = true;
                        this.rbl_save.Items[0].Selected = true;
                        this.rbl_save.Items[1].Enabled  = false;
                    }
                }
                string result = string.Empty;
                if (Request.QueryString["tabRes"] != string.Empty && Request.QueryString["tabRes"] != null)
                {
                    result = Request.QueryString["tabRes"].ToString();
                }
                this.hid_tab_est.Value       = result;
                this.bDeleteExtender.Enabled = false;
                //    SetFocus();
            }
        }
 void Awake()
 {
     gridManager = GetComponent();
 }
示例#47
0
 public void Initialize(GridManager owner, Vector2Int originalTileIndex)
 {
     TileOwner = owner;
     SetTileIndex(originalTileIndex, true);
 }
 //private bool test = false;
 // Start is called before the first frame update
 void Start()
 {
     gridManager = GameObject.FindGameObjectWithTag("Grid Holder").GetComponent <GridManager>();
 }
 private void Awake()
 {
     gridReference = GetComponent <GridManager>();
 }
示例#50
0
 void Start()
 {
     gridManager = GetComponentInParent <GridManager>();
 }
示例#51
0
 void Start()
 {
     initObject();
     loadPosition();
     GridManager.loadGrid(sih);
 }
    protected override void UnitUpdate()
    {
        //Do your stuff here


        //First combat (part of move timer?)
        Tile tile = GetComponentInParent <Tile>();

        if (terrified)
        {
            if (this.hometile.coord == tile.coord)
            {
                terrified = false;
            }
            else
            {
                MoveUnit(this.hometile.coord - tile.coord);
            }
            return;
        }

        GridManager grid    = this.transform.root.GetComponent <GridManager>();
        Cultist     cultist = tile.GetComponentInChildren <Cultist>();
        Zombie      zombie  = tile.GetComponentInChildren <Zombie>();
        Victim      victim  = tile.GetComponentInChildren <Victim>();

        if (cultist != null)
        {
            Debug.Log("MORTAL COMMBAAAAT C");
            //MORTAL COMBAAAAT
            cultist.LoseHealth(1);
            LoseHealth(1);
        }
        else if (zombie != null)
        {
            Debug.Log("MORTAL COMMBAAAAT Z");
            //MORTAL COMBAAAAT
            zombie.LoseHealth(1);
            LoseHealth(1);
        }
        else if (victim != null)
        {
            //Free the victims from their oppressors!
            victim.LoseHealth(1);
        }
        else
        {
            //No combat or victims to save.
            //First:  Think with your pants.
            Succubus foundSuccubus = LocateClosestGridEntity <Succubus>(1);
            if (foundSuccubus != null)
            {
                //Hey there cute stuff
                MoveUnit(foundSuccubus.GetComponentInParent <Tile>().coord - tile.coord);
            }
            else if (grid.IsValidTile(enemyLocation))
            {
                //Check if we have an alert
                if (enemyLocation == tile.coord)
                {
                    //Set it to null, we got to the point.
                    enemyLocation.Set(-1, -1);
                }
                else
                {
                    MoveUnit(enemyLocation - tile.coord);
                }
            }
            else
            {
                Cultist foundCultist = LocateClosestGridEntity <Cultist>(1);
                if (foundCultist != null)
                {
                    //WE FOUND A CULTIST, F**K EM UP
                    Debug.Log("FOUND A CULTIST, GET EM");
                    MoveUnit(foundCultist.GetComponentInParent <Tile>().coord - tile.coord);
                }
                else if (!(tile is Castle))
                {
                    //We arn't on a castle, and there is nothing else to do.

                    //Go home
                    MoveUnit(this.hometile.coord - tile.coord);
                }
            }
        }
    }
    // Use this for initialization
    void Start()
    {
        Vector2 v = GridManager.V2round(transform.position);

        GridManager.grid[(int)v.x, (int)v.y] = transform;
    }
 void Start()
 {
     gridManager = GameObject.Find("Grid").GetComponent <GridManager>();
     item        = GetComponent <Item>();
 }
示例#55
0
    public override void OnInspectorGUI()
    {
        gm = (GridManager)target;

        //DrawDefaultInspector();

        EditorGUILayout.Space();


        cont = new GUIContent("Randomize Grid On Start", "check to regenerate the tiles when the scene is loaded\nthis will generate all the units as well");
        gm.randomizeGridUponStart = EditorGUILayout.Toggle(cont, gm.randomizeGridUponStart);

        cont = new GUIContent("Randomize Unit On Start", "check to regenerate the units on the grid when the scene is loaded\nexisting unit will be removed");
        gm.randomizeUnitUponStart = EditorGUILayout.Toggle(cont, gm.randomizeUnitUponStart);

        cont         = new GUIContent("Show Gizmo", "check to show gizmos on scene view");
        gm.showGizmo = EditorGUILayout.Toggle(cont, gm.showGizmo);

        EditorGUILayout.Space();

        int type = (int)gm.type;

        cont  = new GUIContent("Grid Type:", "Turn mode to be used in this scene");
        contL = new GUIContent[tileTypeLabel.Length];
        for (int i = 0; i < contL.Length; i++)
        {
            contL[i] = new GUIContent(tileTypeLabel[i], tileTypeTooltip[i]);
        }
        type    = EditorGUILayout.IntPopup(cont, type, contL, intVal);
        gm.type = (_TileType)type;

        cont        = new GUIContent("Grid Size:", "The size of a single tile of the grid");
        gm.gridSize = EditorGUILayout.FloatField(cont, gm.gridSize);


        EditorGUILayout.BeginHorizontal();
        cont     = new GUIContent("Num of Column:", "the width(x-axis) of the area to cover for the whole grid");
        gm.width = EditorGUILayout.FloatField(cont, gm.width, GUILayout.ExpandWidth(true));
        //~ gm.width=EditorGUILayout.FloatField(cont, gm.width, GUILayout.MinWidth(160));
        //~ gm.width=Mathf.Round(Mathf.Clamp(gm.width, 0, 50));
        //~ cont=new GUIContent("Actual:"+(gm.width*gm.gridSize).ToString("f2"), "after multiply the GridSize");
        //~ EditorGUILayout.LabelField(cont, GUILayout.ExpandWidth(true));
        EditorGUILayout.EndHorizontal();

        EditorGUILayout.BeginHorizontal();
        cont      = new GUIContent("Num of Row:", "the length(z-axis) of the area to cover for the whole grid");
        gm.length = EditorGUILayout.FloatField(cont, gm.length, GUILayout.ExpandWidth(true));
        //~ gm.length=EditorGUILayout.FloatField(cont, gm.length, GUILayout.MinWidth(160));
        //~ gm.length=Mathf.Round(Mathf.Clamp(gm.length, 0, 50));
        //~ cont=new GUIContent("Actual:"+(gm.length*gm.gridSize).ToString("f2"), "after multiply the GridSize");
        //~ EditorGUILayout.LabelField(cont, GUILayout.ExpandWidth(true));
        EditorGUILayout.EndHorizontal();

        cont          = new GUIContent("Area Height:", "the position of the grid on y-axis\nThis is a relative value from the GridManager's transform");
        gm.baseHeight = EditorGUILayout.FloatField(cont, gm.baseHeight);
        //cont=new GUIContent("Max Height:", "the position of the grid on y-axis\nThis is a relative value from the GridManager's transform");
        //gm.maxHeight=EditorGUILayout.FloatField(cont, gm.maxHeight);

        cont = new GUIContent("GridToTileSizeRatio:", "the size ratio of a single unit in the grid with respect to an individual tile");
        gm.gridToTileSizeRatio = EditorGUILayout.FloatField(cont, gm.gridToTileSizeRatio);
        gm.gridToTileSizeRatio = Mathf.Max(0, gm.gridToTileSizeRatio);

        cont = new GUIContent("UnwalkableTileRate:", "the percentage of the unwalkable tile of the whole grid");
        gm.unwalkableRate = EditorGUILayout.FloatField(cont, gm.unwalkableRate);
        gm.unwalkableRate = Mathf.Clamp(gm.unwalkableRate, 0f, 1f);

        if (gm.unwalkableRate > 0)
        {
            cont           = new GUIContent("UseObstacle:", "the percentage of the unwalkable tile of the whole grid");
            gm.useObstacle = EditorGUILayout.Toggle(cont, gm.useObstacle);

            bool changedFlag = GUI.changed;


            if (gm.useObstacle)
            {
                for (int n = 0; n < obstacleList.Count; n++)
                {
                    GUI.changed = false;

                    bool flag = false;
                    if (n == 0)
                    {
                        flag = gm.enableInvUnwalkable;
                    }
                    else if (n == 1)
                    {
                        flag = gm.enableVUnwalkable;
                    }
                    else
                    {
                        if (gm.obstaclePrefabList.Contains(obstacleList[n]))
                        {
                            flag = true;
                        }
                    }

                    cont = new GUIContent("  -  " + obstacleNameList[n] + ":", "");
                    flag = EditorGUILayout.Toggle(cont, flag);

                    if (n == 0)
                    {
                        gm.enableInvUnwalkable = flag;
                    }
                    else if (n == 1)
                    {
                        gm.enableVUnwalkable = flag;
                    }
                    else
                    {
                        if (GUI.changed)
                        {
                            if (gm.obstaclePrefabList.Contains(obstacleList[n]))
                            {
                                gm.obstaclePrefabList.Remove(obstacleList[n]);
                            }
                            else
                            {
                                gm.obstaclePrefabList.Add(obstacleList[n]);
                            }

                            GUI.changed = false;
                        }
                    }
                }
            }

            if (gm.obstaclePrefabList.Count == 0)
            {
                if (!gm.enableInvUnwalkable && !gm.enableVUnwalkable)
                {
                    gm.enableVUnwalkable = true;
                }
            }

            EditorGUILayout.Space();
            if (!GUI.changed)
            {
                GUI.changed = changedFlag;
            }
        }
        else
        {
            EditorGUILayout.Space();
        }


        cont             = new GUIContent("AddCollectible:", "check to add collectible items to the grid when generating the grid");
        gm.addColletible = EditorGUILayout.Toggle(cont, gm.addColletible);

        if (gm.addColletible)
        {
            EditorGUILayout.BeginHorizontal();
            cont = new GUIContent("CollectibleCount (min/max):", "The number of collectible to be spawned on the grid");
            EditorGUILayout.LabelField(cont, GUILayout.MinWidth(170), GUILayout.MaxWidth(170));
            gm.minCollectibleCount = EditorGUILayout.IntField(gm.minCollectibleCount, GUILayout.MaxWidth(30));
            gm.maxCollectibleCount = EditorGUILayout.IntField(gm.maxCollectibleCount, GUILayout.MaxWidth(30));
            EditorGUILayout.EndHorizontal();

            bool changedFlag = GUI.changed;

            if (collectibleList.Count > 0)
            {
                for (int n = 0; n < collectibleList.Count; n++)
                {
                    GUI.changed = false;

                    bool flag = false;
                    if (gm.collectiblePrefabList.Contains(collectibleList[n]))
                    {
                        flag = true;
                    }

                    cont = new GUIContent("  -  " + collectibleNameList[n] + ":", "");
                    flag = EditorGUILayout.Toggle(cont, flag);

                    if (GUI.changed)
                    {
                        if (gm.collectiblePrefabList.Contains(collectibleList[n]))
                        {
                            gm.collectiblePrefabList.Remove(collectibleList[n]);
                        }
                        else
                        {
                            gm.collectiblePrefabList.Add(collectibleList[n]);
                        }

                        GUI.changed = false;
                    }
                }
            }
            else
            {
                EditorGUILayout.LabelField("- No collectible in CollectibleManager -");
            }

            EditorGUILayout.Space();
            if (!GUI.changed)
            {
                GUI.changed = changedFlag;
            }
        }
        else
        {
            EditorGUILayout.Space();
        }


        //cont=new GUIContent("Tile Prefab:", "the gameObject prefab to be used as the tile");
        //gm.tilePrefab=(GameObject)EditorGUILayout.ObjectField(cont, gm.tilePrefab, typeof(GameObject), false);

        if (gm.type == _TileType.Hex)
        {
            cont             = new GUIContent("HexTile Prefab:", "the gameObject prefab to be used as the tile");
            gm.hexTilePrefab = (GameObject)EditorGUILayout.ObjectField(cont, gm.hexTilePrefab, typeof(GameObject), false);
        }
        else if (gm.type == _TileType.Square)
        {
            cont = new GUIContent("SquareTile Prefab:", "the gameObject prefab to be used as the tile");
            gm.squareTilePrefab = (GameObject)EditorGUILayout.ObjectField(cont, gm.squareTilePrefab, typeof(GameObject), false);
        }


        if (gc != null)
        {
            if (gc.playerFactionID.Count != gm.playerPlacementAreas.Count)
            {
                gm.playerPlacementAreas = MatchRectListLength(gm.playerPlacementAreas, gc.playerFactionID.Count);
            }

            for (int i = 0; i < gc.playerFactionID.Count; i++)
            {
                EditorGUILayout.Space();
                cont = new GUIContent("Player (ID:" + gc.playerFactionID[i] + ") Placement Area:", "The area on the grid which player will be able to place the starting unit, as shown as the green colored square on the gizmo");
                gm.playerPlacementAreas[i] = EditorGUILayout.RectField(cont, gm.playerPlacementAreas[i]);
            }

            if (gc.playerFactionID.Count == 0)
            {
                EditorGUILayout.Space();
                EditorGUILayout.LabelField("No player faction set in GameControl");
            }
        }
        else
        {
            gc = (GameControlTB)FindObjectOfType(typeof(GameControlTB));
        }
        EditorGUILayout.Space();


        //cont=new GUIContent("Player Placement Area:", "The area on the grid which player will be able to place the starting unit, as shown as the green colored square on the gizmo");
        //gm.playerPlacementArea=EditorGUILayout.RectField(cont,  gm.playerPlacementArea);


        //~ showIndicatorList
        string label = "Indicators (Show)";

        if (showIndicatorList)
        {
            label = "Indicators (Hide)";
        }
        cont = new GUIContent(label, "list of various indicators used in run time. Optional. If left empty the defaults will be loaded");
        showIndicatorList = EditorGUILayout.Foldout(showIndicatorList, cont);
        if (showIndicatorList)
        {
            gm.indicatorSelect  = (Transform)EditorGUILayout.ObjectField("IndicatorSelect:", gm.indicatorSelect, typeof(Transform), false);
            gm.indicatorCursor  = (Transform)EditorGUILayout.ObjectField("IndicatorCursor:", gm.indicatorCursor, typeof(Transform), false);
            gm.indicatorHostile = (Transform)EditorGUILayout.ObjectField("IndicatorHostile:", gm.indicatorHostile, typeof(Transform), false);
        }

        //~ gm.playerPlacementArea=EditorGUILayout.RectField("Player Placement Area:", gm.playerPlacementArea);

        int num;

        label = "Faction (Show)";
        if (showFactionList)
        {
            label = "Faction (Hide)";
        }
        cont            = new GUIContent(label, "list of factions in this scene.");
        showFactionList = EditorGUILayout.Foldout(showFactionList, cont);
        if (showFactionList)
        {
            GUILayout.BeginHorizontal();    GUILayout.Space(15);
            GUILayout.BeginVertical();

            cont = new GUIContent("Add Faction", "add a new faction to the list");
            if (GUILayout.Button(cont))
            {
                Faction fac = new Faction();
                fac.factionID = gm.factionList.Count;
                fac.color     = new Color(UnityEngine.Random.Range(0f, 1f), UnityEngine.Random.Range(0f, 1f), UnityEngine.Random.Range(0f, 1f), 1);
                gm.factionList.Add(fac);
            }


            for (int i = 0; i < gm.factionList.Count; i++)
            {
                Rect rectBase = EditorGUILayout.BeginVertical();
                GUILayout.Space(5);
                rectBase.width += 5;      rectBase.height += 0;
                GUI.Box(rectBase, "");

                Faction fac = gm.factionList[i];
                cont          = new GUIContent("ID:", "The ID of the faction. 2 factions entry will the same ID will be recognised as 1 faction in runtime. Player's faction's ID is 0 by default");
                fac.factionID = EditorGUILayout.IntField(cont, fac.factionID);
                cont          = new GUIContent("Color:", "Color of the faction. This is simply for gizmo purpose to identify different spawn area in SceneView");
                fac.color     = EditorGUILayout.ColorField(cont, fac.color);

                cont = new GUIContent("Add Area", "add an additional spawn area for the faction");
                if (GUILayout.Button(cont))
                {
                    FactionSpawnInfo sInfo = new FactionSpawnInfo();
                    if (fac.spawnInfo.Count > 0)
                    {
                        sInfo.area.x      = fac.spawnInfo[fac.spawnInfo.Count - 1].area.x;
                        sInfo.area.y      = fac.spawnInfo[fac.spawnInfo.Count - 1].area.y;
                        sInfo.area.width  = fac.spawnInfo[fac.spawnInfo.Count - 1].area.width;
                        sInfo.area.height = fac.spawnInfo[fac.spawnInfo.Count - 1].area.height;
                    }
                    fac.spawnInfo.Add(sInfo);
                }

                GUILayout.BeginHorizontal();    GUILayout.Space(10);
                GUILayout.BeginVertical();

                for (int nn = 0; nn < fac.spawnInfo.Count; nn++)
                {
                    FactionSpawnInfo sInfo = fac.spawnInfo[nn];

                    Rect rectSub = EditorGUILayout.BeginVertical();
                    rectSub.x -= 5; rectSub.width += 10;        rectSub.height += 5;
                    GUI.Box(rectSub, "");



                    int spawnQuota = (int)sInfo.spawnQuota;
                    cont  = new GUIContent("SpawnQuota:", "type of spawning algorithm to be used");
                    contL = new GUIContent[spawnQuotaLabel.Length];
                    for (int n = 0; n < contL.Length; n++)
                    {
                        contL[n] = new GUIContent(spawnQuotaLabel[n], spawnQuotaTooltip[n]);
                    }
                    spawnQuota       = EditorGUILayout.IntPopup(cont, spawnQuota, contL, intVal);
                    sInfo.spawnQuota = (_SpawnQuota)spawnQuota;

                    if (sInfo.spawnQuota == _SpawnQuota.UnitBased)
                    {
                        cont            = new GUIContent("Number to Spawn:", "number of unit to spawn for this spawn area");
                        sInfo.unitCount = EditorGUILayout.IntField(cont, sInfo.unitCount, GUILayout.MaxHeight(14));
                    }
                    else if (sInfo.spawnQuota == _SpawnQuota.BudgetBased)
                    {
                        cont         = new GUIContent("Spawn Budget:", "Point budget allocated for the units to be spawned");
                        sInfo.budget = EditorGUILayout.IntField(cont, sInfo.budget, GUILayout.MaxHeight(14));
                    }


                    cont       = new GUIContent("Spawn Area:", "The area covered in which the units will be spawned in");
                    sInfo.area = EditorGUILayout.RectField(cont, sInfo.area);


                    cont  = new GUIContent("Rotation:", "The direction which the unit spawned in this area will be facing");
                    contL = new GUIContent[rotationLabel.Length];
                    for (int n = 0; n < contL.Length; n++)
                    {
                        contL[n] = new GUIContent(rotationLabel[n], "");
                    }
                    sInfo.unitRotation = EditorGUILayout.IntPopup(cont, sInfo.unitRotation, contL, intVal);


                    label = "Unit Prefab Pool (Show)";
                    if (sInfo.showUnitPrefabList)
                    {
                        label = "Unit Prefab Pool (Hide)";
                    }
                    cont = new GUIContent(label, "the list possible unit to be spawned in the area specified");
                    sInfo.showUnitPrefabList = EditorGUILayout.Foldout(sInfo.showUnitPrefabList, label);
                    if (sInfo.showUnitPrefabList)
                    {
                        num = sInfo.unitPrefabs.Length;
                        num = EditorGUILayout.IntField("  num of prefab:", num, GUILayout.MaxHeight(14));
                        if (num != sInfo.unitPrefabs.Length)
                        {
                            sInfo.unitPrefabs = MatchUnitPrefabListLength(sInfo.unitPrefabs, num);
                        }
                        if (num != sInfo.unitPrefabsMax.Length)
                        {
                            sInfo.unitPrefabsMax = MatchUnitPrefabMaxListLength(sInfo.unitPrefabsMax, num);
                        }
                        for (int n = 0; n < num; n++)
                        {
                            int unitID = -1;
                            for (int m = 0; m < unitList.Count; m++)
                            {
                                if (unitList[m] == sInfo.unitPrefabs[n])
                                {
                                    unitID = m;
                                    break;
                                }
                            }

                            EditorGUILayout.BeginHorizontal();
                            if (sInfo.spawnQuota == _SpawnQuota.UnitBased)
                            {
                                unitID = EditorGUILayout.IntPopup("   - unit" + n + "(max): ", unitID, unitNameList, intVal, GUILayout.MaxHeight(13));
                                sInfo.unitPrefabsMax[n] = EditorGUILayout.IntField(sInfo.unitPrefabsMax[n], GUILayout.MaxWidth(25));
                            }
                            else if (sInfo.spawnQuota == _SpawnQuota.BudgetBased)
                            {
                                unitID = EditorGUILayout.IntPopup("   - unit" + n + "(max): ", unitID, unitNameList, intVal);
                            }
                            EditorGUILayout.EndHorizontal();

                            if (unitID >= 0)
                            {
                                sInfo.unitPrefabs[n] = unitList[unitID];
                            }
                            else
                            {
                                sInfo.unitPrefabs[n] = null;
                            }
                        }
                    }

                    int totalUnitCount = 0;
                    for (int n = 0; n < sInfo.unitPrefabsMax.Length; n++)
                    {
                        totalUnitCount += sInfo.unitPrefabsMax[n];
                    }

                    sInfo.unitCount = Mathf.Min(totalUnitCount, sInfo.unitCount);

                    cont = new GUIContent("Remove area", "remove this spawn area");
                    if (GUILayout.Button(cont))
                    {
                        fac.spawnInfo.Remove(sInfo);
                    }

                    EditorGUILayout.EndVertical();
                }


                GUILayout.EndVertical();
                GUILayout.Space(10);
                GUILayout.EndHorizontal();

                GUILayout.Space(5);
                if (GUILayout.Button("Remove Faction"))
                {
                    gm.factionList.Remove(fac);
                }
                GUILayout.Space(5);

                EditorGUILayout.EndVertical();

                GUILayout.Space(5);
            }
            GUILayout.Space(10);
            GUILayout.EndVertical();
            //~ GUILayout.Space (5);
            GUILayout.EndHorizontal();
        }


        EditorGUILayout.Space();
        cont = new GUIContent("Generate Grid", "Procedurally generate a new grid with the configured setting\nPlease note that generate a large map (30x30 and above) might take a while");
        if (GUILayout.Button(cont))
        {
            GenerateGrid();
        }

        cont = new GUIContent("Generate Unit", "Procedurally place unit on the grid with the configured setting");
        if (GUILayout.Button(cont))
        {
            GenerateUnit();
        }

        //~ if(GUILayout.Button("testGenerate")) TestGenerate();
        //~ if(GUILayout.Button("testDestroy")) TestDestroy();
        EditorGUILayout.Space();


        if (GUI.changed)
        {
            EditorUtility.SetDirty(gm);
        }
    }
示例#56
0
    public static List <Tile> GenerateSquareGrid(GridManager gm)
    {
        if (gm.squareTilePrefab == null)
        {
            gm.squareTilePrefab = Resources.Load("SquareTile", typeof(GameObject)) as GameObject;
        }
        Transform parentTransform = gm.transform;

        int   counter = 0;
        float highestY = -Mathf.Infinity;         float lowestY = Mathf.Infinity;
        float highestX = -Mathf.Infinity;         float lowestX = Mathf.Infinity;
        float gridSizeFactor = gm.gridToTileSizeRatio * gm.gridSize;

        List <Tile> tileList = new List <Tile>();

        for (int x = 0; x < gm.width; x++)
        {
            for (int y = 0; y < gm.length; y++)
            {
                float posX = x * gridSizeFactor;
                float posY = y * gridSizeFactor;

                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.squareTilePrefab);
                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;
                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);
    }
示例#57
0
    public override void IterateOpenSet()
    {
        //Track how many iterations have taken place to find this pathway
        OpenSetIterations++;

        //Once the openset has been exhausted its time to complete the pathway
        if (OpenSet.Count <= 0)
        {
            //Get the completed pathway
            List <Node> Pathway = GridManager.Instance.GetCompletedPathway(PathStart, PathEnd);

            //If the path is empty, then no pathway was able to be found between the target nodes
            if (Pathway == null)
            {
                //Print a failure message and reset the grid
                Log.Print("Unable to find a valid pathway using Dijkstras algorithm.");
                FindingPathway = false;
                GridManager.Instance.HideAllParentIndicators();
                return;
            }

            //Announce the pathway has been found
            Log.Print("Dijkstras pathfinding completed after " + OpenSetIterations + " iterations.");

            //Hide all the neighbour indicators
            GridManager.Instance.HideAllParentIndicators();

            //Change the type of all nodes in the pathway to display it in the game
            foreach (Node PathStep in Pathway)
            {
                PathStep.SetType(NodeType.Pathway);
            }

            //Complete the process
            FindingPathway = false;
            return;
        }

        //Find the new current node, then iterate through all its neighbours
        Node Current = GridManager.Instance.FindCheapestNode(OpenSet);

        OpenSet.Remove(Current);
        foreach (Node Neighbour in GridManager.Instance.GetTraversableNeighbours(Current))
        {
            //Ignore nodes not listed in the open set
            if (!OpenSet.Contains(Neighbour))
            {
                continue;
            }

            //check if its cheaper to travel over this neighbour
            float NeighbourCost = Current.FScore + GridManager.FindHeuristic(Current, Neighbour);
            if (NeighbourCost < Neighbour.FScore)
            {
                //update this neighbour as the best way to travel
                Neighbour.FScore = NeighbourCost;
                Neighbour.Parent = Current;
                Neighbour.ToggleParentIndicator(true);
                Neighbour.PointIndicator(Neighbour.GetDirection(Current));
            }
        }
    }
示例#58
0
 private void Start()
 {
     gridManager       = GridManager.instance;
     outlineController = OutlineController.instance;
 }
示例#59
0
        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);
        }
示例#60
0
 public override void execute()
 {
     GridManager.MoveLeft();
 }