Inheritance: MonoBehaviour
    // Start is called before the first frame update
    void Start()
    {
        audioSource = GetComponent <AudioSource>();
        manager     = FindObjectOfType <MiniGameManager>();

        speed = 4.0f;
    }
Esempio n. 2
0
    void Awake()
    {
        _instance = this;
        SaveLoad.LoadData(miniGameList.GameList);

        MiniGamesList.CurrentGame = miniGameDetails;
    }
	public void InitializePanelWithTrainerData() {
		DebugBot.DebugFunctionCall("TFitnessUI; InitializePanelWithTrainerData(); ", debugFunctionCalls);
		
		Player currentPlayer = trainerModuleScript.gameController.masterTrainer.PlayerList[trainerModuleScript.gameController.masterTrainer.CurPlayer-1];
		// SET PENDING values from trainer data:
		if(pendingFitnessManager == null) {
			pendingFitnessManager = new FitnessManager(currentPlayer);
			//CopyFitnessComponentList(currentPlayer.masterTrialsList[currentPlayer.currentTrialForEdit].fitnessManager.masterFitnessCompList, pendingFitnessManager.masterFitnessCompList);
			InitializePanelFitnessCompList();
		}
		if(pendingMiniGameManager == null) {
			pendingMiniGameManager = new MiniGameManager(currentPlayer);		
		}
		currentPlayer.masterTrialsList[currentPlayer.currentTrialForEdit].fitnessManager.UpdatePopulationSize(); // Tie this into Population!!!!!
		currentPlayer.masterTrialsList[currentPlayer.currentTrialForEdit].fitnessManager.SetMasterFitnessComponentList(); // add fitnessComp lists from brain and minigame
		pendingFitnessManager.SetMasterFitnessComponentList();

		// OLD:
		List<FitnessComponent> dataFitnessComponentList = currentPlayer.masterTrialsList[currentPlayer.currentTrialForEdit].fitnessManager.masterFitnessCompList;
		CopyFitnessComponentList(dataFitnessComponentList, pendingFitnessManager.masterFitnessCompList);
		// NEW:
		List<FitnessComponent> dataBrainFitnessComponentList = currentPlayer.masterTrialsList[currentPlayer.currentTrialForEdit].fitnessManager.brainFitnessComponentList;
		CopyFitnessComponentList(dataBrainFitnessComponentList, pendingFitnessManager.brainFitnessComponentList);
		List<FitnessComponent> dataGameFitnessComponentList = currentPlayer.masterTrialsList[currentPlayer.currentTrialForEdit].fitnessManager.gameFitnessComponentList;
		CopyFitnessComponentList(dataGameFitnessComponentList, pendingFitnessManager.gameFitnessComponentList);

		InitializePanelFitnessCompList();

		valuesChanged = false;
		applyPressed = false;

		UpdateUIWithCurrentData();
	}
    private void Start()
    {
        miniGameManager = GameObject.Find("Minigame").GetComponent <MiniGameManager>();
        audioManager    = GameObject.Find("Audio").GetComponent <AudioManager>();

        this.gameObject.name    = "item";
        this.transform.position = RndStartV();

        itemNr = RndSpriteIndex();

        if (itemNr == 0)
        {
            // gazelle has bigger image -> double the size of the collider
            GetComponent <BoxCollider2D>().size = new Vector2(1.2f, 1f);
        }
        else
        {
            // default collider size
            GetComponent <BoxCollider2D>().size = new Vector2(0.5f, 0.5f);
        }

        spriteRenderer        = GetComponent <SpriteRenderer>();
        spriteRenderer.sprite = itemSprites[itemNr];

        if (itemNr == miniGameManager.correctItemToBeCollected)
        {
            correctItem = true;
        }
    }
Esempio n. 5
0
 void Start()
 {
     //Debug.Log(tm= GameObject.FindGameObjectWithTag("vehicle").GetComponent<TimeBasedMiniGame>());
     //  mg.panel = GameObject.Find("Panel");
     //panel.SetActive(false);
     mg = GameObject.Find("Canvas new").GetComponent <MiniGameManager>();
 }
Esempio n. 6
0
    private void Start()
    {
        HUD            = GameObject.Find("HUD");
        startGamePanel = GameObject.Find("Panel-StartGame");
        introPanel     = GameObject.Find("Panel-Introduction");
        deathPanel     = GameObject.Find("Panel-DeathScreen");
        ScoreScreen    = GameObject.Find("ScoreScreen");

        txtCountdown   = GameObject.Find("Text-Countdown").GetComponent <TextMeshProUGUI>();
        txtItemCounter = GameObject.Find("Text-Progress").GetComponent <TextMeshProUGUI>();

        txtSuccess        = ScoreScreen.gameObject.transform.GetChild(1).GetComponent <TextMeshProUGUI>();
        txtItemsCollected = ScoreScreen.transform.GetChild(2).GetComponent <TextMeshProUGUI>();
        txtBtnNextPart    = ScoreScreen.transform.GetChild(3).GetChild(0).GetComponent <TextMeshProUGUI>();
        btnBackToHQ       = ScoreScreen.transform.GetChild(4).gameObject;

        introPanel.SetActive(false);
        deathPanel.SetActive(false);
        ScoreScreen.SetActive(false);
        txtCountdown.transform.gameObject.SetActive(false);

        miniGameManager = GameObject.Find("Minigame").GetComponent <MiniGameManager>();
        miniGameManager.PauseGame(true);

        InstantiateHearts();
    }
Esempio n. 7
0
    private void Update()
    {
        float progress = 1;

        if (!done)
        {
            progress -= leftProgress;
            progress += rightProgress;
        }

        Vector3 newPos = Vector3.zero;

        newPos.x  = moveCurve.Evaluate(progress / 3) * 1.5f;
        bottlePos = startPos + newPos;

        saltBottle.transform.position = Vector3.Lerp(saltBottle.transform.position, bottlePos, Time.deltaTime * 15f);

        if (Points == 120 && !done)
        {
            done = true;
            animator.SetTrigger("Done");
            MiniGameManager.SetPlayerDone(m_player);
        }

        Delta += Time.deltaTime;

        if (Delta - LastInputDelta > .5f)
        {
            Salt.Stop();
        }
    }
Esempio n. 8
0
    public void StickTape()
    {
        bool missed = true;

        for (int i = 0; i < m_holes.Length; i++)
        {
            float distance = Vector2.Distance(m_tape.position, m_holes[i].transform.position);
            if (distance < m_fixDistance && !m_holes[i].isFixed)
            {
                m_holes[i].Fix();
                missed = false;

                m_holesFixed++;
                if (m_holesFixed >= m_holeCount)
                {
                    MiniGameManager.SetPlayerDone(m_player);
                    m_tape.gameObject.SetActive(false);
                }
            }
        }

        if (missed)
        {
            Instantiate(m_missedPrefab, m_tape.position, Quaternion.identity);
        }

        m_tape.transform.position = m_tapeStartPos;
    }
    // Start is called before the first frame update
    void Start()
    {
        manager = FindObjectOfType <MiniGameManager>();

        speed      = 0.5f;
        maxStamina = 30.0f;
        stamina    = maxStamina;
    }
Esempio n. 10
0
    private void Awake()
    {
        Instance = this;

        rock     = new Element(MiniGame.rock, MiniGame.scissors, MiniGame.paper);
        paper    = new Element(MiniGame.paper, MiniGame.rock, MiniGame.scissors);
        scissors = new Element(MiniGame.scissors, MiniGame.paper, MiniGame.rock);
    }
    void Start()
    {
        mgm      = mini_game_manager_object.GetComponent <MiniGameManager> ();
        animator = gameObject.GetComponent <Animator>();

        animator.enabled = false;
        pos = new Vector3(1000, 1000);
    }
Esempio n. 12
0
    void Start()
    {
        _miniGameManager = GetComponent <MiniGameManager>();

        SetupProps();
        // todo after propCount set
        UpdatePropCountUI();
    }
Esempio n. 13
0
 public MiniGame(MiniGameManager.GameType gameTypeParam)
 {
     players = new List<string>();
     allPlayers = new List<string>();
     gameId = nextId;
     nextId++;
     gameType = gameTypeParam;
 }
Esempio n. 14
0
 private void Awake()
 {
     if (instance != null && instance != this)
     {
         Destroy(this.gameObject);
         return;
     }
     instance = this;
 }
Esempio n. 15
0
 private void CheckEligibility()
 {
     if ((fanPoint - (gamesPlayed * fanPointGameCondition)) >= fanPointGameCondition)
     {
         newGame = true;
         MiniGameManager.RestartGame();
         SceneManager.LoadScene("00_MiniGameScene");
     }
 }
Esempio n. 16
0
    void Awake()
    {
        if (Instance == null)
        {
            Instance = this.GetComponent <MiniGameManager> ();
        }

        mGeneratePreference();
    }
    private void Start()
    {
        miniGameManager       = GameObject.Find("Minigame").GetComponent <MiniGameManager>();
        spriteRenderer        = GetComponent <SpriteRenderer>();
        spriteRenderer.sprite = obstacles[RndSpriteIndex()];

        this.gameObject.name    = "obstacle";
        this.transform.position = RndStartV();
    }
Esempio n. 18
0
 private void Start()
 {
     _controller     = transform.GetComponent <RBCharacterController>();
     _manager        = GameObject.FindObjectOfType <MiniGameManager>().GetComponent <MiniGameManager>();
     _currentState   = State.Idle;
     unstunSegment   = _manager.AI_StunDuration / _controller._mashLimit;
     _players        = FindPlayers();
     currentWaypoint = Vector2.zero;
     dodgeDirection  = Vector2.zero;
 }
Esempio n. 19
0
 public void Button_PlayChampionship()
 {
     if (TourneyAnnounced && !ChampionshipPlayed)
     {
         ChampionshipPlayed = true;
         newGame            = true;
         MiniGameManager.RestartGame();
         SceneManager.LoadScene("00_MiniGameScene");
     }
 }
Esempio n. 20
0
    private void Update()
    {
        if (m_beats == 60 && !done)
        {
            done = true;
            StartCoroutine(HammerIdle());
            MiniGameManager.SetPlayerDone(m_player);
        }

    }
    void Awake()
    {
        // hence we Should only have one shop instance at all time
        if (instance != null)
        {
            Destroy(instance);
        }

        instance = this;
    }
Esempio n. 22
0
    private void Start()
    {
        rigid2D              = GetComponent <Rigidbody2D>();
        rigid2D.constraints  = RigidbodyConstraints2D.FreezeRotation;
        rigid2D.gravityScale = 0.0f;
        rigid2D.drag         = SPEED; // removes inertia

        hudManager      = GameObject.Find("HUD").GetComponent <HUDManagerMinigame01>();
        miniGameManager = GameObject.Find("Minigame").GetComponent <MiniGameManager>();
        audioManager    = GameObject.Find("Audio").GetComponent <AudioManager>();
    }
Esempio n. 23
0
    void Start()
    {
        sprite = player.transform.GetComponent <Rigidbody2D> ();

        exhibits         = GameObject.Find("GameManager").GetComponent <Exhibits>();
        minigame_manager = GameObject.Find("MiniGameManager").GetComponent <MiniGameManager> ();

        in_mini_game = false;

        StartCoroutine(StartMusic());
    }
Esempio n. 24
0
 private void Awake()
 {
     if (instance != null)
     {
         Destroy(this);
     }
     else
     {
         instance = this;
     }
 }
Esempio n. 25
0
    // Use this for initialization
    void Start()
    {
        pos = transform.position;
        current_direction = Direction.Down;

        mini_game_manager = mini_game_manager_object.GetComponent <MiniGameManager> ();
        animator          = gameObject.GetComponent <Animator>();

        animator.enabled = false;

        audio.clip = hit;
    }
 private void Awake()
 {
     if (instance == null)
     {
         instance = this;
     }
     else if (instance != this)
     {
         Destroy(gameObject);
     }
     DontDestroyOnLoad(gameObject);
 }
Esempio n. 27
0
	// Constructor Methods:
	public Trial() {
		DebugBot.DebugFunctionCall("Trial; Trial(); Constructor", debugFunctionCalls);

		miniGameManager = new MiniGameManager(playerRef);
		fitnessManager = new FitnessManager(playerRef);
		//miniGameManager.playerRef = playerRef;
		//miniGameManager.gameType = MiniGameManager.MiniGameType.None;
		//masterMiniGame.Shout ();  // DEBUG METHOD
		numberOfPlays = 1;
		maxEvaluationTimeSteps = 30;
		power = 1f;
		weight = 1f;
	}
Esempio n. 28
0
    // Start is called before the first frame update
    void Start()
    {
        if (Instance == null)
        {
            Instance = this;
        }
        else
        {
            Destroy(gameObject);
        }

        gameState = miniGameRocketDodgeState.Pending;
    }
Esempio n. 29
0
 private void Awake()
 {
     // Singleton
     if (instance == null)
     {
         instance = this;
     }
     else
     {
         Destroy(this.gameObject);
     }
     DontDestroyOnLoad(this.gameObject);
 }
Esempio n. 30
0
    private void Awake()
    {
        // 퀵 등록
        script = this;

        // 초기 설정 호출
        mpm.Init();
        manager.Init();

        // 메인게임 씬 제거
        GameObject deleteObj = FindObjectsOfType <LoadingManager>()[0].transform.root.gameObject;

        Destroy(deleteObj);
    }
    // Start is called before the first frame update
    void Start()
    {
        manager = FindObjectOfType <MiniGameManager>();

        maxContagion = 30.0f;
        contagion    = 0.0f;
        inDanger     = false;
        infected     = false;

        speed     = 0.25f + Random.Range(0.0f, 1.25f);
        direction = Vector2.down;

        InvokeRepeating("ChangePath", 1.0f, 1.0f);
    }
Esempio n. 32
0
    // Constructor Methods:
    public Trial()
    {
        DebugBot.DebugFunctionCall("Trial; Trial(); Constructor", debugFunctionCalls);

        miniGameManager = new MiniGameManager(playerRef);
        fitnessManager  = new FitnessManager(playerRef);
        //miniGameManager.playerRef = playerRef;
        //miniGameManager.gameType = MiniGameManager.MiniGameType.None;
        //masterMiniGame.Shout ();  // DEBUG METHOD
        numberOfPlays          = 1;
        maxEvaluationTimeSteps = 30;
        power  = 1f;
        weight = 1f;
    }
Esempio n. 33
0
    // Start is called before the first frame update
    void Start()
    {
        miniGameManager = MiniGameManager.instance;

        miniGameManager.onChangeState += () =>
        {
            if (miniGameManager.state == State.FIRSTMG)
            {
                _currentCollectibleInstantiated      = 0;
                miniGameManager.collectiblesPickedUp = 0;
                StartCoroutine(FirstMinigame());
            }
        };
    }
	public void SetMiniGameType(MiniGameManager.MiniGameType newGameType, MiniGameSettingsBase gameSettings) {  // Change game type and re-instantiate miniGameInstance
		DebugBot.DebugFunctionCall("Trial; SetMiniGameType(); " + gameType.ToString(), debugFunctionCalls);
		miniGameInstance = null;
		gameType = newGameType;  // Update GameType to new Type!
		
		// CREATE mini-game instance!  !!!!!!!!!!!!! Come back to this for Improvement Later!!!!!!!
		if(newGameType == MiniGameType.None) {
			miniGameInstance = new MiniGameBase();
			//miniGameInstance = newGameInstance as MiniGame;
		}
		/*else if(newGameType == MiniGameType.MoveToTarget3D) {
			MiniGameMoveToTarget3D newGameInstance = new MiniGameMoveToTarget3D();
			miniGameInstance = newGameInstance;
		}
		else if(newGameType == MiniGameType.CreatureSwimBasic) {
            // SHOULD the input/output Lists depend on the Agent's full Genome, or should the minigame have control over hookups?
            // ... Maybe eventually the Agent's genome should dictate, but for now, to avoid a complete re-write, will leave the ability
            // ... of miniGame's to choose which input/output neurons to hook up. Save that change for the big NEAT update where creature
            // ... topologies can morph and differ within a population.
            Debug.Log("BROKEN!! MiniGameManager public void SetMiniGameType(MiniGameManager.MiniGameType newGameType)");
			CritterGenome templateBody = playerRef.masterPopulation.templateGenome;
			//MiniGameCreatureSwimBasic newGameInstance = new MiniGameCreatureSwimBasic(templateBody);
			//miniGameInstance = newGameInstance;
		}*/
		else if(newGameType == MiniGameType.CritterWalkBasic) {
            CritterGenome templateBody = playerRef.masterPopulation.templateGenome;
            //Debug.Log("playerRef.masterPopulation.templateBodyGenome: " + playerRef.masterPopulation.templateBodyGenome.creatureBodySegmentGenomeList[0].addOn1.ToString());
            //Debug.Log("templateBody: " + templateBody.creatureBodySegmentGenomeList[0].addOn1.ToString());
			MiniGameCritterWalkBasic newGameInstance = new MiniGameCritterWalkBasic(templateBody);
            newGameInstance.UseSettings((MiniGameCritterWalkBasicSettings)gameSettings);
            newGameInstance.InitializeGame();
			miniGameInstance = newGameInstance;
            Debug.Log("miniGameInstance.inputChannelsList.Count: " + miniGameInstance.inputChannelsList.Count.ToString() + "miniGameInstance.outputChannelsList.Count: " + miniGameInstance.outputChannelsList.Count.ToString());
		}
		/*else if(newGameType == MiniGameType.RobotArmSimple) {
			MiniGameRobotArm newGameInstance = new MiniGameRobotArm();
			miniGameInstance = newGameInstance;
		}
		else if(newGameType == MiniGameType.PhysXWorm) {
			MiniGamePhysXWorm newGameInstance = new MiniGamePhysXWorm();
			miniGameInstance = newGameInstance;
		}
		else if(newGameType == MiniGameType.BallCatch) {
			MiniGameBallCatch newGameInstance = new MiniGameBallCatch();
			miniGameInstance = newGameInstance;
		}
		else if(newGameType == MiniGameType.ObstacleNavigation) {
			MiniGameObstacleNavigation newGameInstance = new MiniGameObstacleNavigation();
			miniGameInstance = newGameInstance;
		}
		else if(newGameType == MiniGameType.PoleBalancing2D) {
			MiniGamePoleBalancing2D newGameInstance = new MiniGamePoleBalancing2D();
			miniGameInstance = newGameInstance;
		}
		else if(newGameType == MiniGameType.SpaceshipShooter) {
			MiniGameSpaceshipShooter newGameInstance = new MiniGameSpaceshipShooter();
			miniGameInstance = newGameInstance;
		}*/

		SetInputOutputArrays(); // Haven't set input/output lists for the minigame yet....
	}
Esempio n. 35
0
 public void BuildTexturesCurAgentPerTick(Player player, MiniGameManager miniGameManager, int agentIndex)
 {
     DataManager dataManager = player.dataManager;
     BuildTexturesCurAgentBrainDiagramTick(player, miniGameManager, agentIndex);
 }
Esempio n. 36
0
    public void BuildTexturesCurAgentBrainDiagramTick(Player player, MiniGameManager miniGameManager, int agentIndex)
    {
        int[] layerSizes = player.masterPopulation.masterAgentArray[agentIndex].genome.layerSizes;
        int totalNodes = 0;
        for(int i = 0; i < layerSizes.Length; i++) { // for each layer:
            for(int j = 0; j < layerSizes[i]; j++) { // For each node in that layer:
                totalNodes++;
            }
        }
        int texWidth = totalNodes;
        int texHeight = 1;
        curAgentBrainDiagramNumNodes = totalNodes;
        //Debug.Log ("numNodes: " + curAgentBrainDiagramNumNodes.ToString());
        texCurAgentBrainDiagramTick.Resize(texWidth, texHeight);

        int linearIndex = 0;
        for(int l = 0; l < layerSizes.Length; l++) {  // Loop through each brain Layer:

            for(int x = 0; x < layerSizes[l]; x++) {
                float pixValueRaw;
                if(l == 0) {  // input layer:
                    pixValueRaw = (miniGameManager.brainInput[x][0] + 1f) * 0.5f; // normalize to 0-1 range
                }
                else if(l == (layerSizes.Length - 1)) {  // output layer
                    pixValueRaw = (miniGameManager.brainOutput[x][0] + 1f) * 0.5f; // normalize to 0-1 range
                }
                else {  // hidden layer
                    //pixValueRaw = (player.masterPopulation.masterAgentArray[agentIndex].brain.layerOutput[l][x] + 1f) * 0.5f; // normalize to 0-1 range
                    pixValueRaw = (player.masterPopulation.masterAgentArray[agentIndex].brain.layerOutput[l-1][x] + 1f) * 0.5f; // normalize to 0-1 range
                }
                texCurAgentBrainDiagramTick.SetPixel(linearIndex, 0, new Color(pixValueRaw, ((float)l + 1f)/(float)layerSizes.Length, ((float)x + 1f)/(float)layerSizes[l]));
                // R: node value,  G: inverse layer index,  B: inverse node index
                linearIndex++;
            }
        }
        texCurAgentBrainDiagramTick.Apply ();
    }
Esempio n. 37
0
 public SumoMiniGame(MiniGameManager.GameType gameTypeParam)
     : base(gameTypeParam)
 {
     ballType = new Dictionary<string, int>();
 }
Esempio n. 38
0
 /******************** Private methods *********************/
 void Awake()
 {
     if(Instance == null)
     {
         //If I am the first instance, make me the Singleton
         Instance = this;
         DontDestroyOnLoad(this);
     }
     else
     {
         //If a Singleton already exists and you find
         //another reference in scene, destroy it!
         if(this != Instance)
         {
             Destroy(this.gameObject);
         }
     }
 }
    public void InitializePanelWithTrainerData()
    {
        DebugBot.DebugFunctionCall("TMiniGameUI; InitializePanelWithTrainerData(); ", debugFunctionCalls);

        Player currentPlayer = trainerModuleScript.gameController.masterTrainer.PlayerList[trainerModuleScript.gameController.masterTrainer.CurPlayer-1];
        // SET PENDING values from trainer data:
        if(pendingMiniGameManager == null) {
            //DebugBot.DebugFunctionCall("TMiniGameUI; New InitializePanelWithTrainerData(); ", debugFunctionCalls);
            pendingMiniGameManager = new MiniGameManager(currentPlayer);

            InitializePanelInputList();
            InitializePanelOutputList();
        }

        // if game-type has changed -- this should only happen when clicking CANCEL ?  -- as Apply sets data from pendingData
        if(currentPlayer.masterTrialsList[currentPlayer.currentTrialForEdit].miniGameManager.gameType != pendingMiniGameManager.gameType) {
            pendingMiniGameManager.SetMiniGameType(currentPlayer.masterTrialsList[currentPlayer.currentTrialForEdit].miniGameManager.gameType);
        }
        List<BrainInputChannel> dataInputChannelsList = currentPlayer.masterTrialsList[currentPlayer.currentTrialForEdit].miniGameManager.miniGameInstance.inputChannelsList;
        CopyInputChannelsList(dataInputChannelsList, pendingMiniGameManager.miniGameInstance.inputChannelsList);
        InitializePanelInputList();
        List<BrainOutputChannel> dataOutputChannelList = currentPlayer.masterTrialsList[currentPlayer.currentTrialForEdit].miniGameManager.miniGameInstance.outputChannelsList;
        CopyOutputChannelsList(dataOutputChannelList, pendingMiniGameManager.miniGameInstance.outputChannelsList);
        InitializePanelOutputList();

        currentPlayer.masterTrialsList[currentPlayer.currentTrialForEdit].miniGameManager.SetInputOutputArrays();

        if(!dropDownPopulated) {  // So it only creates buttons on startup
            foreach (string type in System.Enum.GetNames(typeof(MiniGameManager.MiniGameType))) {
                DebugBot.DebugFunctionCall("TMiniGameUI; " + type, debugFunctionCalls);
                GameObject button = (GameObject)Instantiate (buttonDropDownOptionPrefab);
                button.GetComponentInChildren<Text>().text = type;
                string enumType = "";
                enumType = type;
                button.GetComponent<Button>().onClick.AddListener (
                    () => {ChooseMiniGame(enumType);}
                    );
                button.transform.SetParent(dropDownChooseMiniGamePanel);
            }
            dropDownPopulated = true;
        }

        valuesChanged = false;
        applyPressed = false;

        UpdateUIWithCurrentData();
    }
Esempio n. 40
0
 void Start()
 {
     GameObject.DontDestroyOnLoad(this.gameObject);
     gameObject.AddComponent<NetworkView>();
     networkManagerView = gameObject.GetComponent<NetworkView>();
     networkManagerView.stateSynchronization = NetworkStateSynchronization.ReliableDeltaCompressed;
     networkManagerView.observed = this.transform;
     minigameManager = MiniGameManager.Instance;
 }
Esempio n. 41
0
    public void SetMiniGameType(MiniGameManager.MiniGameType newGameType)
    {
        // Change game type and re-instantiate miniGameInstance
        DebugBot.DebugFunctionCall("Trial; SetMiniGameType(); " + gameType.ToString(), debugFunctionCalls);
        miniGameInstance = null;
        gameType = newGameType;  // Update GameType to new Type!

        // CREATE mini-game instance!  !!!!!!!!!!!!! Come back to this for Improvement Later!!!!!!!
        if(newGameType == MiniGameType.None) {
            miniGameInstance = new MiniGameBase();
            //miniGameInstance = newGameInstance as MiniGame;
        }
        else if(newGameType == MiniGameType.MoveToTarget1D) {
            MiniGameMoveToTarget1D newGameInstance = new MiniGameMoveToTarget1D();
            miniGameInstance = newGameInstance as MiniGameMoveToTarget1D;
        }
        else if(newGameType == MiniGameType.MoveToTarget2D) {
            MiniGameMoveToTarget2D newGameInstance = new MiniGameMoveToTarget2D();
            miniGameInstance = newGameInstance;
        }
        else if(newGameType == MiniGameType.MoveToTarget3D) {
            MiniGameMoveToTarget3D newGameInstance = new MiniGameMoveToTarget3D();
            miniGameInstance = newGameInstance;
        }
        else if(newGameType == MiniGameType.RobotArmFantasy) {
            MiniGameRobotArm newGameInstance = new MiniGameRobotArm();
            miniGameInstance = newGameInstance;
        }
        else if(newGameType == MiniGameType.PhysXTests) {
            MiniGamePhysXTests newGameInstance = new MiniGamePhysXTests();
            miniGameInstance = newGameInstance;
        }
        else if(newGameType == MiniGameType.PhysXWorm) {
            MiniGamePhysXWorm newGameInstance = new MiniGamePhysXWorm();
            miniGameInstance = newGameInstance;
        }

        SetInputOutputArrays();
    }