Report

using System;

using System.Collections.Generic;

using System.Linq;

using UnityEngine;

using UnityEngine.SceneManagement;

using UnityEngine.Serialization;

using Random = UnityEngine.Random;

public class GameManager : MonoBehaviour

{

   [Header("step by step means that \nthe game is played one step at a time \n"+

           "using the space bar")]

   public bool stepByStep;

   [Header("random games means that \nthe game is played with a random amount of people \n"+

           "with different types of people")]

   public bool RandomGames;

   [Header("**FILL IN AT EACH PLAYTEST** \nthe ID for the playtest session")]

   public int playtestSession = 0;

   [Header("the parameters changed and player settings")]

   public string descriptionOfGame = null;

   #region Tiles

   [Header("Tiles\nyou can state the amount of each tile\n" +

           "there will be in the deck")]

   public Tile grass;

   public int numberOfGrass;

   public Tile woodChips;

   public int numberOfWoodChips;

   public Tile hay;

   public int numberOfHay;

   public Tile soil;

   public int numberOfSoil;

   public Tile feather;

   public int numberOfFeathers;

   public Tile twigs;

   public int numberOfTwigs;

    #endregion

   [Header("the objectives cards put into a list")]

   public List<Objectives> objectives;

   [Header("Game settings \nthe amount of tiles dealt in a round")]

   public int dealAmount = 5;

   public Vector2 minMaxPeople = new Vector2(0,6);

   [Header("if true then the player who places a \ncuckoo will receive nothing. \n" +

           "The player who the cuckoo egg affects\nwill receive the cuckoo \n" +

           "egg into their nest (0) and loose a \nrandom egg they had bet on the tile")]

   public bool newCuckooEggRules = false;

   [FormerlySerializedAs("evemNewerCuckooEggRules")]

   [Header("if true then the player who places a \ncuckoo will receive nothing. \n" +

           "The player who the cuckoo egg affects\nwill receive the cuckoo \n" +

           "egg into their nest (0) and loose a \nrandom egg they had bet on the tile")]

   public bool evenNewerCuckooEggRules = false;

   [Header("if true then if a tile has bets on it \nand is a draw, then the tile will\n" +

           "stay on the table (dealtCards[]) and \nbe used in the next round.\n" +

           "Note: if a tile has no bets it will be \ndiscarded into usedTiles[]")]

   public bool ifCardIsDrawThenLeaveIt = false;

   [Header("**THE FOLLOWING IS FOR VIEWING ONLY**\nthe deck is the tiles that \n" +

           "can be used and dealt"), SerializeField]

   private List<Tile> deck = new();

   [Header("vector3 list of the (player, tile, egg value)"),SerializeField]

   private List<Vector3> bets;

   [Header("the current Tiles that are dealt on the \"table\"")]

   public List<Tile> dealtTiles;

   [FormerlySerializedAs("usedCards")] [Header("the tiles that have been discarded \nAKA cards that have not been won in rounds"),SerializeField]

   private List<Tile> usedTiles;

   [Header("the list of players in the game")]

   public PlayerController[] players;

   [Header("the players whose turn it is")]

   public int playersTurn = 0;

   [Header("the player who won the game")]

   public int winner = -1;

   [Header("the ID of the current game")]

   public int gameNumber = 0;

   [Header("the current round")]

   public int rounds = 0;

   #region private vars

   private bool allBetsPlaced;

   private bool gameOver = false;

   private UGS_Analytics analytics;

   private int cardsUsed = 0;

   private bool draw = false;

   private bool inSection = false;

   private const float Tolerance = 0.000000001f;

   private bool section1 = false;

   private bool section2 = false;

   private bool section3 = false;

   private bool section4 = false;

   private bool section5 = false;

   private bool section6 = false;

   #endregion

   // Start is called before the first frame update

   private void Start()

   {

       // declare variable

       Tile tile;

       // repeat amount of times there is meant to be the tile in the deck

       for(int i = 0; i < numberOfGrass; i++)

       {

           //create the tile in the scene

           tile = Instantiate(grass);

           //add the tile to the deck

           deck.Add(tile);

       }

       // repeat for other tiles

       for(int i = 0; i < numberOfWoodChips; i++){

           tile = Instantiate(woodChips);

           deck.Add(tile);

       }

       for(int i = 0; i < numberOfHay; i++){

           tile = Instantiate(hay);

           deck.Add(tile);

       }

       for(int i = 0; i < numberOfTwigs; i++){

           tile = Instantiate(twigs);

           deck.Add(tile);

       }

       for(int i = 0; i < numberOfSoil; i++){

           tile = Instantiate(soil);

           deck.Add(tile);

       }

       for(int i = 0; i < numberOfFeathers; i++){

           tile = Instantiate(feather);

           deck.Add(tile);

       }

       //get all the players in the scene

       players = FindObjectsOfType<PlayerController>();

       //change the order of players every game

       ShufflePlayers();

       if (RandomGames)

       {

           List<PlayerController> newPlayer = players.ToList();

           int RPC = Random.Range(Convert.ToInt32(minMaxPeople.x), Convert.ToInt32(minMaxPeople.y)+1);

           while (newPlayer.Count != RPC)

           {

               int PTR = Random.Range(0, newPlayer.Count-1);

               newPlayer[PTR].gameObject.SetActive(false);

               newPlayer.RemoveAt(PTR);

           }

           players = newPlayer.ToArray();

           dealAmount = players.Length + 1;

       }

       //shuffle the objectives

       ShuffleObjectives();

       // declare a variable to keep count

       int j = 0;

       //for each player

       foreach(PlayerController player in players){

           //give the player a number

           player.playerNumber = j;

           //sync the play session var in player

           player.playtestSession = playtestSession;

           //give the player their objective

           DealObjective(player);

           //increase integer

           j++;

           //tell player its a new game and get set up

           player.NewGame();

       }

       // set up analytics var

       analytics = FindObjectOfType<UGS_Analytics>();

       //shuffle the tiles

       ShuffleTiles();

       //tell the game it can proceed with section one

       section1 = true;

   }

   // Update is called once per frame

   private void Update()

   {

       //only execute if space bar pressed and stepByStep is true

       if(Input.GetKeyDown(KeyCode.Space) && stepByStep){

           Play();

       }

   }

   // Update is called once every 0.02 seconds no matter the FPS

   private void FixedUpdate()

   {

       //make sure that the game isn't already running code and its not meant to be step by step

       if (!inSection && !stepByStep)

       {

           //make the game run and play

           Play();

       }

   }

   /*

   Play()

   Function used when we want the game to advance

   the function is split into six section,

   section one

   deals the tiles on the "table"

   and clears any previous bets

   section two

   gets the players bets and places them on tiles

   section three

   distributes tiles to the winners

   this also executes cuckoo egg effects

   and places the tiles and eggs into the respective nests

   section four

   checks if the game is over (if a player has over 6 tiles)

   if its not then it resets the game and gets ready to start from section one

   section five

   if the game is over it counts the scores of each player and determines a winner

   then it sends all the data to an export file to be analyzed later

   section six

   reloads the scene (inefficient way of setting all the values back to default)

   each section will print a line so that if bugs occur we know which section it is in

   */

   private void Play(){

       //check which section we are in and execute the appropriate code

       if(section1 && !gameOver)

       {

           //print visual message for keeping track of section

           print("dealing tiles");

           //set section to true to make sure game doesnt execute code multiple times

           inSection = true;

           //increase the count for amount of rounds in the game

           rounds++;

           //deal the amount of tiles specified

           DealTiles(dealAmount);

           //no bets have been placed yet for round, so set to false

           allBetsPlaced = false;

           //next section and section finished

           section1 = false;

           section2 = true;

           inSection = false;

       }

       else if(section2 && !gameOver)

       {

           //print visual message for keeping track of section

           print("getting player bets");

           //set section to true to make sure game doesnt execute code multiple times

           inSection = true;

           //do one turn for each player

           //each player will choose a card and an egg to bet

           GetPlayerBets();

           //if all the players have placed their eggs

           if (allBetsPlaced)

           {

               //proceed to next section

               section2 = false;

               section3 = true;

           }

           //section finished

           inSection = false;

       }

       else if(section3 && !gameOver)

       {

           //print visual message for keeping track of section

           print("sorting winners");

           //set section to true to make sure game doesnt execute code multiple times

           inSection = true;

           //distribute winning tiles to everyone who won the bets

           DistributeTiles();

           //next section and section finished

           section3 = false;

           section4 = true;

           inSection = false;

       }

       else if (section4 && !gameOver)

       {

           //print visual message for keeping track of section

           print("checking game status");

           //set section to true to make sure game doesnt execute code multiple times

           inSection = true;

           //check if game should be over or if we continue onto a new round

           CheckGameStatus();

           //if game not over

           if (!gameOver)

           {

               //start a new round / it sets section1 to true

               Restart();

               //print visual message for keeping track of section

               print("starting new round");

           }

           //next section and section finished

           section4 = false;

           inSection = false;

       }

       else if (section5 && gameOver)

       {

           //print visual message for keeping track of section

           print("counting player scores");

           //set section to true to make sure game doesnt execute code multiple times

           inSection = true;

           //count the score of each player and assign the winner

           CountScore();

           //get the game id

           gameNumber = FindObjectOfType<ShowText>().game;

           //send game data to UGS_Analytics

           analytics.GameComplete(winner: players[winner].describer,

               winnerScore: players[winner].score,

               rounds: rounds,

               cardsLeft: deck.Count,

               cardsUsed: cardsUsed,

               cardsNotPickedUp: usedTiles.Count,

               playerNumber: players.Length,

               playtestSession: playtestSession,

               draw: draw,

               gameNumber: gameNumber,

               describer: descriptionOfGame

           );

           // send all the players data to UGS_Analytics

           foreach (PlayerController player in players)

           {

               //send individuals player data

               player.SendData();

           }

           //next section and section finished

           section5 = false;

           section6 = true;

           inSection = false;

       }

       else if (section6 && gameOver)

       {

           //print visual message for keeping track of section

           print("starting new game");

           //set section to true to make sure game doesnt execute code multiple times

           inSection = true;

           //load new scene

           SceneManager.LoadScene(SceneManager.GetActiveScene().name);

           //section finished / code is here in case code executes in background of loading a new scene

           section6 = false;

           inSection = false;

       }

   }

   /*

   CountScore()

   Function for counting the score of each player and deciding a winner

   EXAMPLE:

           winner = 0;

           CountScore();

           winner = 3;

   */

   private void CountScore()

   {

       //set the current winner to player 0

       winner = 0;

       //repeat for each player in game

       foreach (PlayerController player in players)

       {

           //count the players score

           player.CountScore();

           //check if score is higher than the current winners score

           if (player.score > players[winner].score)

           {

               //sets a new winner

               winner = player.playerNumber;

               //sets the draw var

               draw = false;

           }

           //checks if the scores are the same and make sure its not comparing the same player

           else if (player.score == players[winner].score && winner != player.playerNumber)

           {

               //sets the draw var

               draw = true;

           }

       }

   }

   /*

   CheckGameStatus()

   Function for checking if the game is over or not

   EXAMPLE:

           gameOver = false;

           CheckGameStatus();

           gameOver = true;

   */

   private void CheckGameStatus()

   {

       //loops through each player

       foreach (PlayerController player in players)

       {

           //checks if any player has more that 6 tiles

           if (player.tiles.Count() >= 6)

           {

               //set gameOver to true and allow the game to go to section 5

               gameOver = true;

               section5 = true;

           }

       }

   }

   /*

   Restart()

   Function for resetting round values

   resets bets and moves the left over dealtTiles[] into the usedTiles[]

   it also send a message to each player for them to take a new hand

   EXAMPLE:

           dealtTiles[soil]

           usedTiles[];

           player.hand[]

           Restart();

           dealtTiles[]

           usedTiles[soil];

           player.hand[1,2,3,4,5]

   */

   private void Restart()

   {

       //check if the tiles that had bets and drew stay in play

       //note: the tiles that have won will have already been removed from dealTiles[]

       if (!ifCardIsDrawThenLeaveIt)

       {

           //move left over tiles to usedTiles[]

           usedTiles.AddRange(dealtTiles);

           //clear the dealTiles[]

           dealtTiles.Clear();

       }

       else

       {

           //for each tile in dealTiles[]

           for(int i = 0; i < dealtTiles.Count; i++)

           {

               //if there are no bets on the tile

               if (dealtTiles[i].bets.Count <= 0)

               {

                   //move it over to usedTiles[]

                   usedTiles.Add(dealtTiles[i]);

                   dealtTiles.RemoveAt(i);

                   //remove index as there are now less items in the list

                   i--;

               }

               //if there are bets on the tile

               else

               {

                   //remove the bets

                   dealtTiles[i].bets.Clear();

               }

           }

       }

       //clear all bets recorded on the GameManager

       bets.Clear();

       //go through each player

       foreach (PlayerController player in players)

       {

           //tell them its a new round so the shuffle their eggs and take a new hand

           player.NewRound();

       }

       //set section1 to true for round to reset

       section1 = true;

   }

   /*

   DistributeTiles()

   Function for distributing the dealtTiles[] to the winners

   of each respective tile. also it execute cuckoo eggs that are in play

   EXAMPLE:

           player[0].tiles[]

           player[0].eggsInNest[]

           player[1].gotObj5 = false

           DistributeTiles()

           player[0].tiles[soil, hay]

           player[0].eggsInNest[cuckooEgg, 7]

           player[1].gotObj5 = true

   */

   private void DistributeTiles(){

       //go through each tile that was dealt

       for(int i = 0; i < dealtTiles.Count; i++)

       {

           //get the tile that may be distributed

           Tile tile = dealtTiles[i];

           //get the winner of the tile

           int winnerOfTile = tile.Winner();

           //if there was a winner / it wasn't a draw or no one bet on it

           if (winnerOfTile != -1)

           {

               //give the tile to the winner

               players[winnerOfTile].ReceiveTile(tile);

               //remove the tile from the dealtTiles[]

               dealtTiles.Remove(tile);

               //change index as number of tiles in list was reduced

               i--;

           }

       }

   }

   /*

   GetPlayerBets()

   Function for getting all the players bets they are placing for the round

   bets come in a Vector3 (player number, tile their betting on, value of egg being bet)

   the function is codded so that every round the next player starts

   round 1 = player 0 starts, round 2 = player 1 starts...

   it also checks if all the players have placed their hands,

   aka there are no more eggs to place

   EXAMPLE:

           bets[];

           Play();

           bets[(0,1,2),

               (1,2,3),

               (2,3,4)]

   */

   private void GetPlayerBets(){

       //repeat for the amount of times there are players

       for(int i = 0; i < players.Length; i++){

           //retrieve bet off the player

           Vector3 bet = players[playersTurn].Play();

           //if the player has a valid bet

           if (Math.Abs(bet.z - (-5)) > Tolerance)

           {

               //add the bet to the bet list

               bets.Add(bet);

               //add the bet to the tile

               TileManager(bet[0], bet[1], bet[2]);

           }

           //increment the count for who's players turn it is

           playersTurn++;

           //if its the last player in the list then make sure the next player

           //is the first in the list

           if (playersTurn >= players.Length)

               playersTurn = 0;

       }

       //increment the count for who's players turn it is for next round

       playersTurn++;

       //if its the last player in the list then make sure the next player

       //is the first in the list

       if(playersTurn >= players.Length)

           playersTurn = 0;

       //go through each player in list again

       foreach (PlayerController player in players)

       {

           //check if the have any eggs left in their hand

           if(player.hand.Count == 0)

               //assume all bets have been placed

               allBetsPlaced = true;

           else

           {

               //set to false if they still have a hand (round continues)

               allBetsPlaced = false;

               //break out of loop, there are still eggs in play

               break;

           }

       }

   }

   /*

   TileManager(float player, float value, float tile)

   Function for assigning a bet onto a specific tile, it inserts the bet as a

   Vector 2

   player is the player who made the bet

   value is the value of the egg placed on the tile

   tile is the index of which tile the bet was placed on

   EXAMPLE:

           tile[2].bets[];

           TileManager(0,1,2);

           tile[2].bets[(0,1)];

   */

   private void TileManager(float player, float value, float tile){

       //select the tile which was bet on, and inject a vector2 with the player and value

       dealtTiles[Convert.ToInt32(tile)].bets.Add(new Vector2(player, value));

   }

   /*

   ShuffleTiles()

   Function for shuffling the deck[] of tiles in the game

   EXAMPLE:

           deck[soil,hay,twig];

           ShuffleTiles();

           deck[twig,soil,hay];

   */

   private void ShuffleTiles(){

       //create a new list that gives a new guid to the tiles and

       //orders them based on this new guid, basically making it random

       var shuffledTiles = deck.OrderBy(a => Guid.NewGuid()).ToList();

       //replace the egg list with this new randomised order of eggs

       deck = shuffledTiles;

   }

   /*

   ShuffleTiles()

   Function for shuffling the objectives[] in the game

   EXAMPLE:

           objectives[obj1,obj2,obj3];

           ShuffleObjectives();

           objectives[obj2,obj3,obj1];

   */

   private void ShuffleObjectives(){

       var shuffledCards = objectives.OrderBy(a => Guid.NewGuid()).ToList();

       objectives = shuffledCards;

   }

   private void ShufflePlayers(){

       List<PlayerController> shuffledPlayers = players.OrderBy(a => Guid.NewGuid()).ToList();

       players = shuffledPlayers.ToArray();

   }

   /*

   DealTiles(int amount)

   Function dealing the tiles from the deck[] onto the "table" for the players

   to bet on for the round

   amount is the amount of tiles to be dealt onto the table

   EXAMPLE:

           dealtTiles[];

           DealTiles(3);

           objectives[obj2,obj3,obj1];

   */

   private void DealTiles(int amount){

       //while there are less cards on the table than required

       while (dealtTiles.Count < amount)

       {

           //check if the deck is empty

           if(deck.Count <= 0)

           {

               //if used tiles also empty then we have run out of cards so break

               if (usedTiles.Count == 0)

                   break;

               //put the usedTiles into the deck

               deck = usedTiles;

               //shuffle the deck

               ShuffleTiles();

               //delete the usedTiles

               usedTiles.Clear();

           }

           //increase the integer keeping track of cards used in game

           cardsUsed++;

           //add the top card of deck to dealtTiles

           dealtTiles.Add(deck[0]);

           //remove the top card from the deck

           deck.RemoveAt(0);

       }

   }

   /*

   DealObjectives(PlayerController player)

   Function dealing the objectives to each player

   player is the player who will receive the objective

   EXAMPLE:

           player[0].objective = null;

           DealObjectives(0);

           player[0].objective = obj1;

   */

   private void DealObjective(PlayerController player){

       // assign the first objective to the player

       player.objective = Instantiate(objectives[0]);

       // remove the objective from the objectives deck

       objectives.RemoveAt(0);

   }

}

using System;

using System.Collections.Generic;

using Unity.Mathematics;

using UnityEngine;

using Random = UnityEngine.Random;

public class Tile : MonoBehaviour

{

   [Header("name of the tile")]

   public string nameOfTile;

   [Header("how many points is the tile worth")]

   public int points;

   [Header("the bets placed on the tile")]

   public List<Vector2> bets;

   #region private vars

   private int numberOfPlayers;

   private GameManager gm;

   private const float Tolerance = 0.000000001f;

   #endregion

   // Start is called before the first frame update

   private void Start()

   {

       //assign the game manager

       gm = FindObjectOfType<GameManager>();

       //get the amount of players in the game

       numberOfPlayers = gm.players.Length;

   }

   /*

   Winner()

   Function used when we need to know who won the current tile

   returns the player number that has the highest value on it

   it also executes the cuckoo egg effects on the tile

   Returns:

   int winner of the tile

   EXAMPLE:

           player[0].gotObj5 = false;

           player[1].eggsInNest[];

           Winner();

           return 1;

           player[0].gotObj5 = true;

           player[1].eggsInNest[cuckoo egg];

   */

   public int Winner()

   {

       //assume the winners score is -5

       float winnerScore = -5;

       //assume the winner is -1 (this means no one bet)

       int winner = -1;

       //bool if their is a draw

       bool draw = false;

       //go through each player in the game

       for(int currentPlayer = 0; currentPlayer < numberOfPlayers; currentPlayer++)

       {

           //set the score to 0

           float currentPlayerScore = 0;

           //for each bet on the tile

           foreach (Vector2 bet in bets)

           {

               //check if the bet is placed by the current player being checked

               if (Math.Abs(bet.x - currentPlayer) < Tolerance)

               {

                   //make sure its not the cuckoo egg being checked

                   if(Math.Abs(bet.y - 13) > Tolerance)

                       //add the bet to the current score

                       currentPlayerScore += bet.y;

               }

           }

           // if the current player has a higher score than the previous winning score

           if (currentPlayerScore > winnerScore)

           {

               //change the winning score

               winnerScore = currentPlayerScore;

               //assign a new winner

               winner = currentPlayer;

               //set draw to false

               draw = false;

           }

           //if the scores are the same

           else if (Math.Abs(currentPlayerScore - winnerScore) < Tolerance)

           {

               //set draw to true

               draw = true;

           }

       }

       //if there is no draw

       if (!draw)

       {

           //check and execute the cuckoo eggs

           GiveCuckooEgg(winner);

           //return the winner of the tile

           return winner;

       }

       //return -1 if its a draw

       return -1;

   }

   /*

   GiveCuckooEgg(int target)

   Function used for when we need to find and execute the cuckoo eggs on a tile

   the function will find who placed the cuckoo egg and check if they did their objective

   and if give the target the penalty of receiving a cuckoo egg

   target is the player who won the tile and therefore will be affected by the

   effects of the cuckoo eggs

   EXAMPLE:

           ** newCuckooEggRules **

           player[0].eggsInNest[];

           player[1].gotObj5 = false;

           GiveCuckooEgg(0);

           player[0].eggsInNest[cuckoo egg];

           player[1].gotObj5 = true;

           ----------------------

           ** !newCuckooEggRules **

           player[0].eggsInNest[];

           player[1].eggsInNest[];

           GiveCuckooEgg(0);

           player[0].eggsInNest[];

           player[1].eggsInNest[7];

   */

   void GiveCuckooEgg(int target)

   {

       //go through each player and reset the gotEggStolenByCuckoo, so they can place down eggsInNest

       //if they dont get affected by the cuckoo egg

       foreach (PlayerController player in gm.players)

       {

           player.gotEggStolenByCuckoo = false;

       }

       //get a list to store the target bets

       List<int> targetOptions = new();

       //for each bet on the tile

       foreach (Vector2 bet in bets)

       {

           //check if the bet was made by the target and its not a cuckoo egg

           if (Convert.ToInt32(bet.x) == target && Convert.ToInt32(bet.y) != 13)

           {

               //add the bet to target list

               targetOptions.Add(Convert.ToInt32(bet.y));

           }

       }   

       //if there are no bets to be targeted

       if (targetOptions.Count <= 0)

           return;

       //sort by smallest to highest

       targetOptions.Sort();

       //invert to highest value is first

       targetOptions.Reverse();

       //make new list to see which player has cuckoo

       List<int> playersWithCuckoos = new();

       //for each bet on tile

       foreach (Vector2 bet in bets)

       {

           //check if the bet was not made by the target and it is a cuckoo egg

           if (Convert.ToInt32(bet.x) != target && Convert.ToInt32(bet.y) == 13)

           {

               //add player to the cuckoo list

               playersWithCuckoos.Add(Convert.ToInt32(bet.x));

               print(bet);

           }

       }

       //if their is only one cuckoo egg (more than one and it cancels itself) and if we are playing with new rules

       if(playersWithCuckoos.Count == 1 && gm.newCuckooEggRules)

       {

           //egg being used is a random egg

           int egg = targetOptions[Random.Range(0, targetOptions.Count)];

           //check player that used cuckoo if it was their target

           gm.players[playersWithCuckoos[0]].ReceiveEgg(14, target);

           //remove the egg from the targets game so they dont use it again

           gm.players[target].eggsUsed.Remove(egg);

           //give the target the cuckoo egg (value 0 once in nest)

           gm.players[target].ReceiveEgg(13, playersWithCuckoos[0]);

           //remove the egg form the options

           targetOptions.Remove(egg);

           print($"success! egg taken is {egg} from player {target}, player {playersWithCuckoos[0]} gave the cuckoo egg");

       }

       else if (playersWithCuckoos.Count == 1 && gm.evenNewerCuckooEggRules)

       {

           //check player that used cuckoo if it was their target

           gm.players[playersWithCuckoos[0]].ReceiveEgg(14, target);

           //give the target the cuckoo egg (value 0 once in nest)

           gm.players[target].ReceiveEgg(13, playersWithCuckoos[0]);

           print($"success! cuckoo given to player {target}, player {playersWithCuckoos[0]} gave the cuckoo egg");

       }

       else if (!gm.newCuckooEggRules && !gm.evenNewerCuckooEggRules)

       {

           foreach (int player in playersWithCuckoos)

           {

               //check if there are any eggs to steal left

               if(targetOptions.Count == 0) return;

               //egg being used is the highest value

               int egg = targetOptions[0];

               //the player who placed the cuckoo egg places the egg in their nest and

               //checks if it was their target

               gm.players[player].ReceiveEgg(egg, target);

               //remove the egg from the targets game so they dont use it again

               gm.players[target].eggsUsed.Remove(egg);

               //give the target the cuckoo egg (value 0 once in nest)

               gm.players[target].ReceiveEgg(13, player);

               //remove the egg form the options

               targetOptions.Remove(egg);

           }

       }

   }

}

using System.Collections.Generic;

using UnityEngine;

public class UGS_Analytics : MonoBehaviour

{

   [Header("records data of the games to \nF:\\Game Design\\Unity projects\\faites vos oeufs\\Assets\\StreamingAssets")]

   public bool recordDataCsv = true;

   //private vars

   private CSVExport csv;

   // play on Awake

   private void Awake()

   {

       //assign CSV script

       csv = GetComponent<CSVExport>();

   }

   /*

   Send(string eventName, Dictionary<string, object> parameters)

   Function used when we must send data to the CSV file

   eventName is the name of the type of data being sent

   parameters is the data that is being sent to the CSV

   EXAMPLE:

           CSVFile = "";

           Send(event1, ({score,1},player,2));

           CSVFile = "event1

                       score, 1

                       player, 2";

   */

   void Send(string eventName, Dictionary<string, object> parameters)

   {

       //check if we are recording data

       if (recordDataCsv)

       {

           //record data to CSV

           csv.Record(eventName, parameters);

       }

   }

   /*

   GameComplete(string winner,

       int winnerScore,

       int rounds,

       int cardsLeft,

       int cardsUsed,

       int cardsNotPickedUp,

       int playerNumber,

       int playtestSession,

       bool draw,

       int gameNumber,

       string describer

       )

   Function used when we want to sort the data from the games data into a CSV format

   we put the data into a dictionary to be sent off

   then it send the dictionary to the Send() function

   string winner is the winner of the game

   int winnerScore is the score the winner got

   int rounds is the amount of rounds played

   int cardsLeft is the amount of tiles left in the deck

   int cardsUsed is the amount of tiles dealt in the game

   int cardsNotPickedUp are tiles that where left in the usedTiles pile

   int playerNumber is the amount of players in the game

   int playtestSession is the id of the playtest session

   bool draw is the game a draw

   int gameNumber is the number id of the game

   string describer the description of the game

   EXAMPLE:

           GameComplete(0,1,2,3)

           Send("GameCompleted", ({score,0},{winnerScore,1},{rounds,2},{cardsLeft,3})));

   */

   public void GameComplete(string winner,

       int winnerScore,

       int rounds,

       int cardsLeft,

       int cardsUsed,

       int cardsNotPickedUp,

       int playerNumber,

       int playtestSession,

       bool draw,

       int gameNumber,

       string describer = "unknown player profiles and details"

       )

   {

       //convert data into dictionary

       Dictionary<string, object> parameters = new Dictionary<string, object>()

       {

           { "Winner", winner },

           { "winnerScore", winnerScore},

           { "rounds", rounds},

           { "cardsLeft", cardsLeft },

           { "cardsUsed", cardsUsed},

           { "cardsNotPickedUp", cardsNotPickedUp},

           { "playerNumber", playerNumber},

           { "playtestSession", playtestSession},

           { "draw", draw},

           { "describer", describer},

           { "gameNumber", gameNumber}

       };

       //send off the data

       Send("GameCompleted", parameters);

   }

   /*

   GameComplete(string winner,

       int winnerScore,

       int rounds,

       int cardsLeft,

       int cardsUsed,

       int cardsNotPickedUp,

       int playerNumber,

       int playtestSession,

       bool draw,

       int gameNumber,

       string describer

       )

   Function used when we want to sort the data from the games data into a CSV format

   we put the data into a dictionary to be sent off

   then it send the dictionary to the Send() function

   int player is the player number

   string describer is the decription of the player behaviour

   int score is the score they got

   int numberOfTiles is the number of tiles the have in their nest

   int cuckooEggValue is the value of the cuckoo egg they stole

   int eggsPlaced is the amount of eggs they placed in their nest

   int eggsInNest is the amount of eggs in their nest

   int playtestSession is the id of the playtest session

   int objectiveScore is the amount of score due to completing objectves

   int tileScore is the amount of score due to collecting tiles

   int eggScore is the amount of score due to placing eggs in their nests

   string objective1 is their objective one

   string objective2 is their objective two

   string objective3 is their objective three

   int objectivesComplete is the amount of objectives complete

   int eggsLeft is the amount of eggs left in their game

   int gameNumber is the game id number

   EXAMPLE:

           PlayerData(0,"random",2,3)

           Send("Player", ({player,0},{describer,"random"},{score,2},{numberOfTiles,3})));

   */

   public void PlayerData(int player,

       string describer,

       int score,

       int numberOfTiles,

       int cuckooEggValue,

       int eggsPlaced,

       int eggsInNest,

       int playtestSession,

       int objectiveScore,

       int tileScore,

       int eggScore,

       string objective1,

       string objective2,

       string objective3,

       int objectivesComplete,

       int eggsLeft,

       int gameNumber

       )

   {

       //convert data into dictionary

       Dictionary<string, object> parameters = new Dictionary<string, object>()

       {

           { "player", player },

           { "describer", describer },

           { "score", score },

           { "numberOfTiles", numberOfTiles },

           { "cuckooEggValue", cuckooEggValue },

           { "eggsPlaced", eggsPlaced },

           { "eggsInNest", eggsInNest},

           { "playtestSession", playtestSession },

           { "objectiveScore", objectiveScore },

           { "tileScore", tileScore },

           { "eggScore", eggScore },

           { "objective1", objective1 },

           { "objective2", objective2 },

           { "objective3", objective3 },

           { "objectivesComplete", objectivesComplete },

           { "eggsLeft", eggsLeft },

           { "gameNumber", gameNumber}

       };

       //send off the data

       Send("Player", parameters);

   }

}

using System;

using System.Collections;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Text;

using UnityEngine;

public class CSVExport : MonoBehaviour

{

   public StringBuilder sb = new System.Text.StringBuilder();

   private string contentData;

   private string folder;

   private string filePath;

   private bool firstTime = false;

   int globalIndex;

   void Awake()

   {

       folder = Application.streamingAssetsPath + "/data";

       if (!Directory.Exists(folder))

           Directory.CreateDirectory(folder);

       filePath = Path.Combine(folder, "export.csv");

       PlayerPrefs.SetInt("globalIndex",0);

   }

   public void Record(string eventName, Dictionary<string, object> data)

   {

       sb.Clear();

       sb.AppendLine(eventName);

       int index = 0;

       foreach (KeyValuePair<string,object> value in data)

       {

           string v = value.ToString();

           if (v.Length >= 2)

           {

               v = v.Substring(1);

               v = v.Remove(v.Length - 1);

           }

           sb.AppendLine(v);

       }

       SaveToFile(sb.ToString());

   }

   public void SaveToFile(string content)

   {

       using (var writer = new StreamWriter(filePath, true))

       {

           writer.Write(content);

       }

       print(folder);

   }

}

using System.Collections.Generic;

using System.Linq;

using UnityEngine;

using System;

public class PlayerController : MonoBehaviour

{

   [Header("number is assigned at the\nstart of game")]

   public int playerNumber = -1;

   [Header("describer is assigned by the\nPlayerBehaviour script")]

   public string describer;

   [Header("individual eggs and\ntheir values")]

   public List<int> eggs;

   [Header("the players hand in a round")]

   public List<int> hand;

   [Header("the amount of eggs to be\nput in the player hand\nevery round")]

   public int handAmount;

   [Header("the eggs used but not \nplaced into nest or not \ntaken by enemy cuckoo egg \n" +

           "these eggs can be reshuffled \nand put back into the players hand")]

   public List<int> eggsUsed;

   [Header("the tiles won by the player \nand placed into their nest")]

   public List<Tile> tiles;

   [Header("the eggs the player placed into their nest")]

   public List<int> eggsInNest;

   [Header("the players objective card")]

   public Objectives objective;

   [Header("the players score")]

   public int score;

   [Header("the playtest session \nAssigned by game manager")]

   public int playtestSession = 0;

   [Header("cuckoo egg target")]

   public int obj5Target = 0;

   [Header("did someone use a \ncuckoo egg on the player")]

   public bool gotEggStolenByCuckoo = false;

   [Header("the number of the game")]

   public int gameNumber;

   #region private variables

   private GameManager gm;

   private int cuckooEggValue = 0;

   private int eggsPlaced = 0;

   private int objScore = 0;

   private int tileScore = 0;

   private int eggScore = 0;

   private int objectivesComplete = 0;

   private UGS_Analytics analytics;

   private PlayerBehaviour behaviour;

   private bool gotObj5 = false;

   private const float Tolerance = 0.000000001f;

   int obj1 = 0;

   int obj2 = 0;

   int obj3 = 0;

   #endregion

   private void Awake()

   {

       //assign variables

       behaviour = GetComponent<PlayerBehaviour>();

       describer = behaviour.description;

       gm = FindObjectOfType<GameManager>();

       analytics = FindObjectOfType<UGS_Analytics>();

   }

   /*

   TakeHand(int amount)

   Function used when player puts eggs in their hand

   amount is the amount of eggs that will be placed into the players hand

   EXAMPLE:

           Eggs[1,2,3,4];

           Hand[]

           TakeHand(2);

           Eggs[1,4];

           Hand[2,3];

   */

   private void TakeHand(int amount){

       //repeat for the amount of eggs should be in the players hand

       for(int i = 0; i < amount; i++){

           //check if there are any eggs to take

           if(eggs.Count <= 0){

               //get the eggs previously used and put them back in the pile to

               //take from

               eggs = eggsUsed;

               //shuffle the eggs

               ShuffleEggs();

               //clear the used eggs list to not duplicate eggs

               eggsUsed.Clear();

           }

           //if there are eggs to take then put the top one in the players hand

           if (eggs.Count != 0)

           {

               //add egg to hand

               hand.Add(eggs[0]);

               //remove egg from pile that player can take from

               eggs.RemoveAt(0);

           }

       }

       //order the hand from lowest to highest

       hand.Sort();

       //reverse it so its highest to lowest

       hand.Reverse();

   }

   /*

   ShuffleEggs()

   Function used to shuffle the eggs

   EXAMPLE:

           Eggs[1,2,3,4];

           ShuffleEggs();

           Eggs[3,1,4,2];

   */

   private void ShuffleEggs(){

       //create a new list that gives a new guid to the eggs and

       //orders them based on this new guid, basically making it random

       var shuffledEggs = eggs.OrderBy(a => Guid.NewGuid()).ToList();

       //replace the egg list with this new randomised order of eggs

       eggs = shuffledEggs;

   }

   /*

   Play()

   Function used when the player must play

   returns a vector three with the players actions

   Returns:

   Vector3(the players number,

           the egg they are placing down,

           the tile they choose to bet on)

   EXAMPLE:

           Play();

           return Vector3(0,1,2);

   */

   public Vector3 Play(){

       //Get a value for the egg

       int egg = PickEgg();

       //Get the tile index its betting on

       int tile = PickTile();

       //return a vector3 with the details of the bet

       return new Vector3(playerNumber,egg,tile);

   }

   /*

   PickEgg()

   Function used when the player must pick an egg to bet with

   returns am integer with the value of the egg the player is betting with

   Returns:

           integer value of egg

   EXAMPLE:

           PickEgg();

           return 2;

   */

   private int PickEgg()

   {

       //Send the current hand to the player behaviour, and return the value of

       //the egg

       int egg = behaviour.PickEgg(hand);

       //remove the egg chosen from the hand

       hand.Remove(egg);

       //if the egg is not the cuckoo egg or a null then add it the the eggsUsed list

       //note: that used eggs can be re used in the players hand when the player

       //      runs out of Eggs[]

       if(egg is not (13 or -5) && !gm.evenNewerCuckooEggRules){

           eggsUsed.Add(egg);

       }

       else if (gm.evenNewerCuckooEggRules && egg != -5)

       {

           eggsUsed.Add(egg);

       }

       //return the value of the egg

       return egg;

   }

   /*

   PickTile()

   Function used when the player must pick a tile to bet on

   returns am integer with the index of the tile the player is betting on

   Returns:

           integer index of the position of the tile

   EXAMPLE:

           PickTile();

           return 3;

   */

   private int PickTile()

   {

       //Send the current dealt tiles to the player behaviour, and return the

       //index of the tile the player will bet on

       int tile = behaviour.PickTile(gm.dealtTiles);

       //return the index of the tile the player will bet on

       return tile;

   }

   /*

   NewGame()

   Function used when a new game starts, only called once to set up variables

   such as the target for the cuckoo egg, it also shuffles the eggs and gives

   the player a new hand

   EXAMPLE:

           obj5Target = null;

           Eggs[1,2,3,4];

           Hand[];

           NewGame();

           obj5Target = 3;

           Eggs[4,1];

           Hand[3,2];

   */

   public void NewGame(){

       //calls a new round function to shuffle eggs and deal a new hand to the player

       NewRound();

       //if the player number is 0 and the cuckoo egg objective is "below" it,

       //then it will assign it the "top" player

       if (playerNumber == 0 && objective.obj5Direction == -1)

           obj5Target = gm.players.Length - 1;

       //if the player number is the "top" and the cuckoo egg objective is "on top" of it,

       //then it will assign it the "bottom" player

       else if (playerNumber == gm.players.Length - 1 && objective.obj5Direction == 1)

           obj5Target = 0;

       //otherwise assign the cuckoo egg objective using math

       //note: the obj.obj5Direction is either 1 or -1

       else

           obj5Target = playerNumber + objective.obj5Direction;

   }

   /*

   NewRound()

   Function used when a new round starts, called a few times per game,

   it shuffles the eggs and deals the player their hand

   EXAMPLE:

           Eggs[1,2,3,4];

           Hand[];

           NewGame();

           Eggs[4,1];

           Hand[3,2];

   */

   public void NewRound()

   {

       //shuffle Eggs[]

       ShuffleEggs();

       //populate the players Hand[] with the amount of eggs being dealt

       //into their hand

       TakeHand(handAmount);

   }

   /*

   PlaceEggInNest(list<int> values)

   Function used when the player must place an egg into their nest

   the egg placed into the nest is removed for the usedEggs[] in order to

   make sure the player cannot put the egg back into their hand

   values is the options of eggs the player has to place into their nest

   EXAMPLE:

           EggsInNest[1,2];

           PlaceEggInNest(values[3,4]);

           EggsInNest[1,2,4];

   */

   private void PlaceEggInNest(List<int> values)

   {

       //check if the player has eggs to be placed OR that the player has been

       //given a cuckoo egg

       if (values.Count == 0 || gotEggStolenByCuckoo)

           return;

       //Send the values to the player behaviour, and return the value of the

       //egg that will be placed into the players nest

       int eggChoice = behaviour.PlaceEggInNest(values);

       //add the egg to the players nest

       eggsInNest.Add(eggChoice);

       //remove the egg from the eggsUsed[], prevents it from being used again

       eggsUsed.Remove(eggChoice);

       //statistics to see how many eggs where placed

       eggsPlaced++;

   }

   /*

   ReceiveTile(Tile tile)

   Function used when the player has received a tile and places it in their nest

   it also calls the PlaceEggInNest() in order to place an egg with the tile

   tile is tile that was recieved

   EXAMPLE:

           tiles[hayTile,TwigTile];

           EggsInNest[1,2];

           ReceiveTile(soilTile);

           tiles[hayTile,TwigTile,soilTile];

           EggsInNest[1,2,4];

   */

   public void ReceiveTile(Tile tile)

   {

       //add tile to the players nest

       tiles.Add(tile);

       //make a list to contain the players options of eggs they can place in their nest

       List<int> eggChoices = new List<int>();

       // go through each bet placed on the tile

       foreach (Vector2 bet in tile.bets)

       {

           //if the bet was made by the player and its not a cuckoo egg

           //note: its checking if its equal but eliminating

           //the chance of a floating point value changing the result

           if (Math.Abs(bet.x - playerNumber) < Tolerance && Math.Abs(bet.y - 13) > Tolerance)

           {

               //add the value of the egg that was bet to the choices the player will have

               eggChoices.Add(Convert.ToInt32(bet.y));

           }

       }

       //place one of the eggs into the nest

       PlaceEggInNest(eggChoices);

       //checks if the tile completed an objective

       CheckObjectiveTile(tile);

   }