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

	}
Ejemplo n.º 6
0
 // 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];
        */
    }
Ejemplo n.º 8
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);
    }
Ejemplo n.º 9
0
 //The grid should be generated on game start
 void Awake()
 {
     instance = this;
     setSizes();
     createGrid();
     generateAndShowPath();
 }
Ejemplo n.º 10
0
 void Awake()
 {
     instance = this;
     setSizes();
     createGrid();
     generateAndShowPath();
     Messenger.AddListener("characterMoved", switchOriginAndDestTiles);
 }
Ejemplo n.º 11
0
    void Awake()
    {
        _instance = this;

        if( gridController == null )
        {
            Debug.LogError("No IGridController assigned or found in scene.");
        }
    }
Ejemplo n.º 12
0
	void Start () {
        //Dependancy "GridManager"
        gridManagerObject = GameObject.FindGameObjectWithTag("GridManager");
        gridManager = gridManagerObject.GetComponent<GridManager>();
        //Dependancy "GridVariables"
        gridVar = GetComponent<GridVariables>();
   
        UpdateLayer();
    }
Ejemplo n.º 13
0
    void Start()
    {
        gridManager = GameObject.FindObjectOfType<GridManager>();
        worldPlacer = GameObject.FindObjectOfType<WorldPlacer>();
        itemMenu = GameObject.FindObjectsOfType<ItemMenu>();
        moneyManager = GameObject.FindObjectOfType<MoneyManager>();

        importMenu = GameObject.FindObjectOfType<ImportMenu>();
    }
Ejemplo n.º 14
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> ();
 }
Ejemplo n.º 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;
    }
Ejemplo n.º 16
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;
    }
Ejemplo n.º 18
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);
    }
Ejemplo n.º 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;
    }
Ejemplo n.º 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);
	}
Ejemplo n.º 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);
    }
Ejemplo n.º 22
0
    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>();
    }
Ejemplo n.º 23
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!");
    }
Ejemplo n.º 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();
	}
Ejemplo n.º 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);
    }
Ejemplo n.º 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);
				}
			}
		}

	}
Ejemplo n.º 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();
            }
        }
Ejemplo n.º 29
0
    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);
    }
Ejemplo n.º 30
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);
        }