public void LoadMiniGame(MiniGameType miniGameType)
{
int gameType = 0;
List <MiniGame> games = null;
switch (miniGameType)
{
case MiniGameType.freeForAll:
gameType = 0;
games = getRandomElements(GameList.FREE_FOR_ALL_LIST);
break;
case MiniGameType.singleVsTeam:
gameType = 1;
games = getRandomElements(GameList.SINGLE_VS_TEAM_LIST);
break;
case MiniGameType.teamVsTeam:
gameType = 2;
games = getRandomElements(GameList.TEAM_VS_TEAM_LIST);
break;
}
int selectedGame = Random.Range(0, games.Count);
this.nextScene = games[selectedGame].getSceneName();
this.showPicker(gameType, games, selectedGame);
}
public Sickness(Sickness sickness)
{
this.name = sickness.name;
this.cure = sickness.cure;
this.gameType = sickness.gameType;
this.gameArgument = sickness.gameArgument;
this.Urgente = sickness.Urgente;
OnCure = new UnityEvent();
}
public void EndMiniGame(MiniGameType miniGameType)
{
foreach (var game in miniGames)
{
if (game.miniGameType == miniGameType)
{
game.miniGame.GetComponentInChildren <IMinigame>().ResetMiniGame();
}
}
gameStarted = false;
}
public void StartMiniGame(MiniGameType miniGame, OverclockRoom room)
{
if (miniGame == MiniGameType.None)
{
return; // check for implemented mini-game
}
overclocking = true;
activeRoom = room;
AudioManager.instance.PlaySFX("Overclock");
additiveSceneManager.LoadSceneMerged(miniGame.ToString());
AnalyticsManager.OnMiniGameStarted(miniGame);
}
public void LoadMiniGameTest(MiniGameType miniGameType)
{
int gameType = 0;
List <MiniGame> games = null;
games = getRandomElements(GameList.TESTING_LIST);
int selectedGame = Random.Range(0, games.Count);
this.nextScene = games[selectedGame].getSceneName();
this.showPicker(gameType, games, selectedGame);
}
public bool SetChosenAccountAt(int index, byte pointsLeft, MiniGameType gameType, MGBRewardArray gameLvlPoints)
{
if (index >= 0 && index < this._chosenAccountList.Count)
{
this._chosenAccountList[index].SetAllGames(gameType, gameLvlPoints);
this._chosenAccountList[index].AccountBase.SetPointsLeft(pointsLeft);
return(true);
}
else
{
OnErrorOcured(this, new ErrorEventArgs(ErrorMessages.IndexOutOfBounds, ErrorSources.ModelChosenAccountList));
return(false);
}
}
/// <summary>
/// Collects and Sends data when the player starts a minigame.
/// </summary>
/// <param name="miniGame">The mini game that the player started playing.</param>
public static void OnMiniGameStarted(MiniGameType miniGame)
{
Dictionary <string, object> data = new Dictionary <string, object>
{
{ "minigameName", miniGame }, // tracks minigame name
};
Analytics.CustomEvent("minigameStarted", data);
#if UNITY_EDITOR
Debug.LogWarning("Analytics: On MiniGame Started Sent");
#endif
minigameStartTime = Time.time;
}
public void StartMiniGame(MiniGameType miniGameType, QI_ItemData item, GameObject gameObject)
{
if (!gameStarted)
{
foreach (var game in miniGames)
{
if (game.miniGameType == miniGameType)
{
game.miniGame.transform.position = PlayerInformation.instance.player.position + new Vector3(1, 0, 100);
game.miniGame.GetComponentInChildren <IMinigame>().SetupMiniGame(item, gameObject, item.GameDificulty);
game.miniGame.SetActive(true);
}
}
gameStarted = true;
}
}
public void IncreaseTriesPaid(MiniGameType type)
{
switch (type)
{
case MiniGameType.PrizeWheel: PrizeWheelContentView.IncreaseTriesPaid();
break;
case MiniGameType.BreakLiner: BreakLinerContentView.IncreaseTriesPaid();
break;
case MiniGameType.TreasureHunt: TreasureHuntContentView.IncreaseTriesPaid();
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
public void SetMiniGame(UnityEvent onFinished, MiniGameType miniGame, float value)
{
OnFinished = onFinished;
nameTween.Kill();
nameTween = DOTween.Sequence();
currentMinigame = miniGame;
enabled = true;
gameObject.SetActive(true);
duration = value;
completionPerInput = 1.0f / duration;
completion = 0;
switch (currentMinigame)
{
case MiniGameType.Hold:
name.text = "HOLD";
nameTween.Append(name.transform.DOPunchScale(Vector3.one * 0.4f, 5f, 0, 0)).SetLoops(-1);
break;
case MiniGameType.Rythm:
name.text = "RYTHM";
nameTween.Append(name.transform.DOPunchScale(Vector3.one * 0.3f, 0.2f));
nameTween.PrependInterval(0.4f).SetLoops(-1);
rythmTimer = 0;
break;
case MiniGameType.Mash:
name.text = "MASH";
nameTween.Append(name.transform.DOPunchScale(Vector3.one * 0.3f, 0.125f)).SetLoops(-1);
break;
case MiniGameType.None:
OnFinished.Invoke();
enabled = false;
break;
}
nameTween.Play();
}
/// <summary>
/// Collects and Sends data when the player finishes a minigame.
/// </summary>
/// <param name="miniGame">The minigame that the player finished.</param>
/// <param name="didSucceed">Did the player succeed at the minigame?</param>
/// <param name="statModification">The base stat output for the minigame when finished.</param>
public static void OnMiniGameFinished(MiniGameType miniGame, bool didSucceed, float statModification = 0)
{
float timeSpent = Time.time - minigameStartTime;
Dictionary <string, object> data = new Dictionary <string, object>
{
{ "minigameName", miniGame }, // tracks minigame name
{ "didSucceed", didSucceed }, // tracks if player beat minigame
{ "timeSpentPlaying", timeSpent } // tracks time spent playing the minigame
};
if (miniGame == MiniGameType.SlotMachine)
{
data.Add("slotsOutput", statModification); // tracks the output for slots
}
Analytics.CustomEvent("minigameFinished", data);
#if UNITY_EDITOR
Debug.LogWarning("Analytics: On MiniGame Finished Sent");
#endif
}
//false if values out of range
//if gametype = None -> values set to default
public bool SetGame(int gameLvl, MiniGameType gameType, byte gamePoints)
{
if (gameLvl > 0 && gameLvl <= Settings.MGB_MAX_GAME_LVL &&
gamePoints >= 0 && gamePoints <= Settings.MGB_MAX_GAME_POINTS)
{
if (gameType != MiniGameType.None)
{
this._gameType = gameType;
this._gamesLeft.SetValueAt(gameLvl - 1, gamePoints);
}
else
{
this._gamesLeft.ResetAt(gameLvl - 1);
this._gameType = MiniGameType.None;
}
return(true);
}
else
{
return(false);
}
}
public void OnClick(ItemType type, int data1 = -1, int data2 = -1, string data3 = null)
{
switch (type)
{
case ItemType.MAP_NODE_BUTTON:
{
NodeType nodeType = (NodeType)data1;
MiniGameType gameType = (MiniGameType)data2;
switch (nodeType)
{
case NodeType.START:
{
GameController.instance.RunCutScene("Data/CutScenes/CutSceneTest", data3);
}
break;
case NodeType.CUT_SCENE:
{
GameController.instance.RunCutScene(mapData.GetNode(data3).cutScene, data3);
}
break;
case NodeType.GAME:
{
GameController.instance.GoToMiniGame(gameType, data3);
}
break;
case NodeType.END:
{
GameController.instance.RunCutScene("Data/CutScenes/FinalScene", data3);
}
break;
}
}
break;
}
}
public void GoToMiniGame(MiniGameType gameType, string nodeID)
{
if (currentMiniGame != null)
{
Debug.LogError("A minigame is currently in progress");
}
currentNodeID = nodeID;
switch (gameType)
{
case MiniGameType.PLATFORMER:
{
SceneManager.LoadScene("PlatformMinigame", LoadSceneMode.Additive);
}
break;
case MiniGameType.COLLECT:
{
SceneManager.LoadScene("CollectMiniGame", LoadSceneMode.Additive);
}
break;
}
}
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....
}
public void SetAllGames(MiniGameType gameType, MGBRewardArray gamesLeft)
{
this._gamesLeft = gamesLeft;
this._gameType = gameType;
}
public void MakeCalculationNumbers(Formula f, MiniGameType mgt, Difficulty d)
{
//Select the Minigame Type.
switch (mgt)
{
case MiniGameType.Furnace:
//Select the Forumula.
switch (f)
{
case Formula.Optellen:
int s0;
int s1;
int r0;
int r1;
switch (d)
{
case Difficulty.Easy:
scoreAmount = Random.Range(1, 51);
r0 = 1;
r1 = 51;
while (s0 + s1 != scoreAmount)
{
s0 = Random.Range(r0, r1);
s1 = Random.Range(r0, r1);
}
SetNumbersFurnace(s0, s1, r0, r1);
break;
case Difficulty.Normal:
scoreAmount = Random.Range(50, 101);
r0 = 50;
r1 = 101;
while (s0 + s1 != scoreAmount)
{
s0 = Random.Range(r0, r1);
s1 = Random.Range(r0, r1);
}
SetNumbersFurnace(s0, s1, r0, r1);
break;
case Difficulty.Hard:
scoreAmount = Random.Range(100, 501);
r0 = 100;
r1 = 501;
while (s0 + s1 != scoreAmount)
{
s0 = Random.Range(r0, r1);
s1 = Random.Range(r0, r1);
}
SetNumbersFurnace(s0, s1, r0, r1);
break;
}
break;
case Formula.Aftrekken:
break;
case Formula.Keer:
break;
case Formula.Delen:
break;
}
break;
}
}
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();
}
/// <summary>
/// Unloads this current minigame scene
/// </summary>
/// <param name="miniGame"></param>
public void UnloadScene(MiniGameType miniGame)
{
overclocking = false;
additiveSceneManager.UnloadScene(miniGame.ToString());
}
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....
}
public void EndMiniGame(MiniGameType miniGame, bool success, float statModification = 0)
{
int roomLevel = activeRoom.GetComponent <RoomStats>().GetRoomLevel() - 1;
if (success)
{
float moraleModifier = MoraleManager.instance.GetMoraleModifier();
switch (miniGame)
{
case MiniGameType.Security:
shipStats.Security += Mathf.RoundToInt(securityBaseAdjustments[roomLevel] * statModification * moraleModifier);
SpawnStatChangeText(Mathf.RoundToInt(securityBaseAdjustments[roomLevel] * statModification * moraleModifier), GameManager.instance.GetResourceData((int)ResourceDataTypes._Security).resourceIcon);
EventSystem.instance.chanceOfEvent += securityPercentIncrease;
break;
case MiniGameType.Asteroids:
shipStats.ShipWeapons += Mathf.RoundToInt(shipWeaponsBaseAdjustments[roomLevel] * statModification * moraleModifier);
SpawnStatChangeText(Mathf.RoundToInt(shipWeaponsBaseAdjustments[roomLevel] * statModification * moraleModifier), GameManager.instance.GetResourceData((int)ResourceDataTypes._ShipWeapons).resourceIcon);
EventSystem.instance.chanceOfEvent += asteroidPercentIncrease;
break;
case MiniGameType.CropHarvest:
shipStats.Food += Mathf.RoundToInt(foodBaseAdjustments[roomLevel] * statModification * moraleModifier);
SpawnStatChangeText(Mathf.RoundToInt(foodBaseAdjustments[roomLevel] * statModification * moraleModifier), GameManager.instance.GetResourceData((int)ResourceDataTypes._Food).resourceIcon);
EventSystem.instance.chanceOfEvent += cropPercentIncrease;
break;
case MiniGameType.StabilizeEnergyLevels:
shipStats.Energy += new Vector3(Mathf.RoundToInt(energyBaseAdjustments[roomLevel] * statModification * moraleModifier), 0, 0);
SpawnStatChangeText(Mathf.RoundToInt(energyBaseAdjustments[roomLevel] * statModification * moraleModifier), GameManager.instance.GetResourceData((int)ResourceDataTypes._Energy).resourceIcon);
EventSystem.instance.chanceOfEvent += energyPercentIncrease;
break;
case MiniGameType.SlotMachine:
shipStats.Credits += Mathf.RoundToInt(statModification * moraleModifier); // slots doesn't have a room level scaler?
SpawnStatChangeText(Mathf.RoundToInt(statModification * moraleModifier), GameManager.instance.GetResourceData((int)ResourceDataTypes._Credits).resourceIcon);
EventSystem.instance.chanceOfEvent += slotPercentIncrease;
break;
case MiniGameType.HullRepair:
shipStats.ShipHealthCurrent += new Vector2(Mathf.RoundToInt(hullRepairBaseAdjustments[roomLevel] * statModification * moraleModifier), 0);
SpawnStatChangeText(Mathf.RoundToInt(hullRepairBaseAdjustments[roomLevel] * statModification * moraleModifier), GameManager.instance.GetResourceData((int)ResourceDataTypes._HullDurability).resourceIcon);
EventSystem.instance.chanceOfEvent += hullRepairPercentIncrease;
break;
}
}
else
{
if (miniGame == MiniGameType.Asteroids)
{
shipStats.ShipHealthCurrent += new Vector2(Mathf.RoundToInt(failHullDurabilityBaseAdjustments[roomLevel] * statModification), 0);
SpawnStatChangeText(Mathf.RoundToInt(failHullDurabilityBaseAdjustments[roomLevel] * statModification), GameManager.instance.GetResourceData((int)ResourceDataTypes._HullDurability).resourceIcon);
}
}
if (success && activeRoom)
{
activeRoom.StartMinigameCooldown();
if (winSound == false)
{
AudioManager.instance.PlaySFX("De-Overclock");
winSound = true;
}
}
activeRoom = null;
//FindObjectOfType<CrewManagement>().crewManagementText.SetActive(true);
AnalyticsManager.OnMiniGameFinished(miniGame, success, statModification);
EndingStats.instance.AddToStat(1, EndingStatTypes.MinigamesPlayed);
}
private void OnDisable()
{
currentMinigame = MiniGameType.None;
gameObject.SetActive(false);
nameTween.Kill();
}
//probably shouldn't exist empty object
private MGBAccount()
{
this._accountBase = new MGBAccountBase();
this._gamesLeft = new MGBRewardArray();
this._gameType = MiniGameType.None;
}
