void Fall(int side)
        {
            int oppositeSide = side % 2 == 0 ? (side + 1) : (side - 1);

            transform.parent.GetComponentInChildren <LoggingActivityInteractPrompt>().HideUI();

            ApplyFallingForce(oppositeSide);
            hasFallen = true;

            foreach (ForestTreeSnapSpot snap in transform.GetComponentsInChildren <ForestTreeSnapSpot>())
            {
                snap.enabled = false;
            }
            LoggingActivityPlayerBehavior.UnsnapPlayer();
            GetComponent <ForestTreeBehavior>().enabled = false;

            int qualityAverage = QualityMinigame.CalculateAverageGrade();

            qualityAverage = Mathf.Clamp(qualityAverage, 0, maxQualityGrade.GetHashCode());

            QualityGrade gatheredQuality = (QualityGrade)qualityAverage;

            HomesteadStockpile.UpdateTreesCountAtGrade(gatheredQuality, 1);

            Debug.Log("Gathered Grade: " + gatheredQuality);

            //Visually phase tree out
            Invoke("PhaseOutTree", 5);
        }
Beispiel #2
0
 public static void SetSnapInfo(LogBehavior log, Transform snapLoc, bool canSnap, int qualityIndex)
 {
     currentActivity = LoggingActivity.SPLITTING;
     logToSplit      = log;
     snapLocation    = snapLoc;
     canSnapPlayer   = canSnap;
     logsRemaining   = HomesteadStockpile.GetLogsCountAtIndex(qualityIndex);
 }
    public bool HasInStockpile()
    {
        bool hasTrees    = HomesteadStockpile.GetTreesCountAtGrade(treeGrade) >= trees;
        bool hasLogs     = HomesteadStockpile.GetLogsCountAtGrade(logGrade) >= logs;
        bool hasFirewood = HomesteadStockpile.GetFirewoodCountAtGrade(firewoodGrade) >= firewood;

        return(hasTrees && hasLogs && hasFirewood);
    }
Beispiel #4
0
    void UpdateResources()
    {
        currencyCount.text          = PlayerResources.GetCurrentCurrencyValue().ToString();
        buildingMaterialsCount.text = PlayerResources.GetCurrentBuildingMaterialsValue().ToString();
        toolPartsCount.text         = PlayerResources.GetCurrentToolPartsValue().ToString();
        bookPagesCount.text         = PlayerResources.GetCurrentBookPagesValue().ToString();

        felledTreesCount.text = HomesteadStockpile.GetTreesCountAsString();
        logsCount.text        = HomesteadStockpile.GetLogsCountAsString();
        firewoodCount.text    = HomesteadStockpile.GetFirewoodCountAsString();
    }
        public void UpdateLogPile()
        {
            int logsCount = HomesteadStockpile.GetLogsCountAtGrade(qualityGrade);

            interactableLog.SetActive(logsCount > 0);

            for (int i = 0; i < logPileGroup.childCount; i++)
            {
                logPileGroup.GetChild(i).gameObject.SetActive(logsCount > (15 - i));
            }
        }
 void PhaseOutLogs()
 {
     if (HomesteadStockpile.GetTreesCountAtGrade(maxQualityGrade) > 0)
     {
         Invoke("ResetInteractableFelledTree", 1.0f);
     }
     else
     {
         transform.parent.GetComponentInChildren <LoggingActivityInteractPrompt>().HideUI();
     }
     associatedLogPile.UpdateLogPile();
     gameObject.SetActive(false);
 }
        public void UpdateFelledTreePile()
        {
            int treesCount = HomesteadStockpile.GetTreesCountAtGrade(qualityGrade);

            interactableFelledTree.SetActive(treesCount > 0);

            felledTreePileGroup.GetChild(0).gameObject.SetActive(treesCount > 6);
            felledTreePileGroup.GetChild(1).gameObject.SetActive(treesCount > 5);
            felledTreePileGroup.GetChild(2).gameObject.SetActive(treesCount > 4);
            felledTreePileGroup.GetChild(3).gameObject.SetActive(treesCount > 3);
            felledTreePileGroup.GetChild(4).gameObject.SetActive(treesCount > 2);
            felledTreePileGroup.GetChild(5).gameObject.SetActive(treesCount > 1);
        }
        public void UpdateFirewoodPile()
        {
            int[] firewoodArray = HomesteadStockpile.GetAllFirewoodCount();
            int   totalFirewod  = 0;

            for (int i = 0; i < firewoodArray.Length; i++)
            {
                totalFirewod += firewoodArray[i];
            }

            transform.GetChild(0).gameObject.SetActive(totalFirewod > 0);
            transform.GetChild(1).gameObject.SetActive(totalFirewod > 10);
            transform.GetChild(2).gameObject.SetActive(totalFirewod > 25);
            transform.GetChild(3).gameObject.SetActive(totalFirewod > 50);
            transform.GetChild(4).gameObject.SetActive(totalFirewod > 100);
        }
        void SawThrough(int loc)
        {
            if (locationFullySawed[0] && locationFullySawed[1])
            {
                LoggingActivityPlayerBehavior.UnsnapPlayer();

                int qualityAverage = QualityMinigame.CalculateAverageGrade();
                qualityAverage = Mathf.Clamp(qualityAverage, 0, maxQualityGrade.GetHashCode());

                QualityGrade gatheredQuality = (QualityGrade)qualityAverage;

                HomesteadStockpile.UpdateLogsCountAtGrade(gatheredQuality, 3);
                HomesteadStockpile.UpdateTreesCountAtGrade(maxQualityGrade, -1);

                Debug.Log("Gathered Grade: " + gatheredQuality);

                Invoke("PhaseOutLogs", 1.0f);
            }
        }
Beispiel #10
0
        void Split()
        {
            ApplySplitForce();

            LoggingActivityPlayerBehavior.UnsnapPlayer();

            int qualityAverage = QualityMinigame.CalculateAverageGrade(HomesteadStockpile.GetLogsCountAtGrade(maxQualityGrade));

            qualityAverage = Mathf.Clamp(qualityAverage, 0, maxQualityGrade.GetHashCode());

            QualityGrade gatheredQuality = (QualityGrade)qualityAverage;

            HomesteadStockpile.UpdateFirewoodCountAtGrade(gatheredQuality, QualityMinigame.GetUngradedFirewood());

            QualityMinigame.ClearUngradedFirewood();

            Debug.Log("Gathered Grade: " + gatheredQuality);

            Invoke("PhaseOutFirewood", 5f);
        }
Beispiel #11
0
    IEnumerator WaitForFirewoodGrade()
    {
        yield return(new WaitUntil(() => !QualityMinigame.IsGradeListEmpty()));

        UnsnapPlayer();

        int qualityAverage = QualityMinigame.CalculateAverageGrade(HomesteadStockpile.GetLogsCountAtGrade(QualityMinigame.GetLastMaxFirewoodGrade()));

        qualityAverage = Mathf.Clamp(qualityAverage, 0, QualityMinigame.GetLastMaxFirewoodGrade().GetHashCode());

        QualityGrade gatheredQuality = (QualityGrade)qualityAverage;

        int ungradedCount = QualityMinigame.GetUngradedFirewood();

        HomesteadStockpile.UpdateFirewoodCountAtGrade(gatheredQuality, ungradedCount);

        QualityMinigame.ClearUngradedFirewood();

        Debug.Log("Gathered Grade: " + gatheredQuality);
        // Debug.Log("Gathered Count: " + ungradedCount);
    }
Beispiel #12
0
        // public bool PlayerCanStore()
        // {
        //  return HomesteadStockpile.GetFirewoodCountAtGrade(qualityGrade) < PlayerSkills.GetMaxLumberFirewoodValue();
        // }

        // public QualityGrade GetQualityGrade() { return qualityGrade; }

        // public bool HasBeenSplit() { return hasBeenSplit; }

        public void ChopLog()
        {
            HomesteadStockpile.UpdateLogsCountAtGrade(maxQualityGrade, -1);
            if (HomesteadStockpile.GetLogsCountAtGrade(maxQualityGrade) > 0)
            {
                associatedLogPile.UpdateLogPile();
            }

            QualityMinigame.IncrementUngradedFirewood();
            QualityMinigame.SetLastMaxFirewoodGrade(maxQualityGrade);

            // hasBeenSplit = true;

            if (HomesteadStockpile.GetLogsCountAtGrade(maxQualityGrade) <= 0)
            {
                LoggingActivityPlayerBehavior.SetLogsRemaining(HomesteadStockpile.GetLogsCountAtGrade(maxQualityGrade));
                LoggingActivityPlayerBehavior.SetCanPerformAction(false);

                PlayerHud.ToggleQualityGame(true);
                QualityMinigame.StartGame();

                StartCoroutine(SplitAfterGrade());
            }
        }
 public void SubtractFromStockpile()
 {
     HomesteadStockpile.UpdateTreesCountAtGrade(treeGrade, -trees);
     HomesteadStockpile.UpdateLogsCountAtGrade(logGrade, -logs);
     HomesteadStockpile.UpdateFirewoodCountAtGrade(firewoodGrade, -firewood);
 }
Beispiel #14
0
    public static void Load()
    {
        if (File.Exists(Application.persistentDataPath + folderPath + currentSaveSlot + saveSlotStrings[currentSaveSlot - 1]))
        {
            // Debug.Log("Loading...");

            BinaryFormatter data     = new BinaryFormatter();
            FileStream      file     = File.Open(Application.persistentDataPath + folderPath + currentSaveSlot + saveSlotStrings[currentSaveSlot - 1], FileMode.Open);
            SaveableData    loadData = (SaveableData)data.Deserialize(file);
            file.Close();

            //-----------------------Loading Data---------------------------------
            PlayerTools.SetOwnedToolsList(loadData.ownedTools);
            PlayerTools.SetCurrentlyEquippedTool(loadData.currentlyEquippedTool.GetToolName());
            ToolManager.EquipTool(PlayerTools.GetCurrentlyEquippedToolIndex());

            PlayerSkills.SetEfficiencySkill(loadData.efficiencySkill);
            PlayerSkills.SetContractsSkill(loadData.contractsSkill);
            PlayerSkills.SetCurrencySkill(loadData.currencySkill);
            PlayerSkills.SetEnergySkill(loadData.energySkill);
            PlayerSkills.SetBuildingMaterialsSkill(loadData.buildingMaterialsSkill);
            PlayerSkills.SetToolPartsSkill(loadData.toolPartsSkill);
            PlayerSkills.SetBookPagesSkill(loadData.bookPagesSkill);
            PlayerSkills.SetLumberTreesSkill(loadData.lumberTreesSkill);
            PlayerSkills.SetLumberLogsSkill(loadData.lumberLogsSkill);
            PlayerSkills.SetLumberFirewoodSkill(loadData.lumberFirewoodSkill);

            PlayerRooms.SetBedRoom(loadData.bedRoom);
            PlayerRooms.SetKitchenRoom(loadData.kitchenRoom);
            PlayerRooms.SetOfficeRoom(loadData.officeRoom);
            PlayerRooms.SetStudyRoom(loadData.studyRoom);
            PlayerRooms.SetWorkshopRoom(loadData.workshopRoom);

            PlayerAdditions.SetCoffeeMakerAddition(loadData.coffeeMakerAddition);
            PlayerAdditions.SetFireplaceAddition(loadData.fireplaceAddition);
            PlayerAdditions.SetFrontPorchAddition(loadData.frontPorchAddition);
            PlayerAdditions.SetWoodworkingBenchAddition(loadData.woodworkingBenchAddition);

            PlayerContracts.SetActiveContractsList(loadData.activeContracts);
            AvailableContracts.SetAvailableContracts(loadData.availableContracts);
            AvailableContracts.SetContractsToRemove(loadData.availableContractsToRemove);


            TimeManager.SetDidDailyGeneration(loadData.didDailyGeneration);
            AvailableContracts.SetAverageContractDifficulty(loadData.averageContractDifficulty);
            AvailableContracts.SetPastGeneratedContractDifficulties(loadData.pastGeneratedContractDifficulties);

            PlayerEnergy.SetCurrentEnergyValue(loadData.currentEnergy);

            PlayerResources.SetCurrentCurrencyValue(loadData.currentCurrency);
            PlayerResources.SetCurrentBuildingMaterialsValue(loadData.currentBuildingMaterials);
            PlayerResources.SetCurrentToolPartsValue(loadData.currentToolParts);
            PlayerResources.SetCurrentBookPagesValue(loadData.currentBookPages);

            HomesteadStockpile.SetAllTreesCount(loadData.homesteadTreesCount);
            HomesteadStockpile.SetAllLogsCount(loadData.homesteadLogsCount);
            HomesteadStockpile.SetAllFirewoodCount(loadData.homesteadFirewoodCount);

            TimeManager.SetCurrentTime(loadData.currentTime);

            MainMenu.SetSceneToLoad(loadData.lastSceneName);
            float[] spawnHolder = loadData.lastSceneSpawnLocation;
            MainMenu.SetLocationToSpawn(new Vector3(spawnHolder[0], spawnHolder[1], spawnHolder[2]));
            //-----------------------Done Loading----------------------------------
        }
        else
        {
            Save();
        }
    }
Beispiel #15
0
    public static void Save()
    {
        Debug.Log("Save Slot: " + currentSaveSlot);
        BinaryFormatter data = new BinaryFormatter();
        FileStream      file = File.Create(Application.persistentDataPath + folderPath + currentSaveSlot + saveSlotStrings[currentSaveSlot - 1]);

        SaveableData saveData = new SaveableData();

        //-----------------------Setting Save Data---------------------------------------------
        saveData.activeContracts            = PlayerContracts.GetActiveContractsList();
        saveData.availableContracts         = AvailableContracts.GetAvailableContracts();
        saveData.availableContractsToRemove = AvailableContracts.GetContractsToRemove();

        saveData.didDailyGeneration                = TimeManager.GetDidDailyGeneration();
        saveData.averageContractDifficulty         = AvailableContracts.GetAverageContractDifficulty();
        saveData.pastGeneratedContractDifficulties = AvailableContracts.GetPastGeneratedContractDifficuties();

        saveData.currentEnergy = PlayerEnergy.GetCurrentEnergyValue();

        saveData.currentCurrency          = PlayerResources.GetCurrentCurrencyValue();
        saveData.currentBuildingMaterials = PlayerResources.GetCurrentBuildingMaterialsValue();
        saveData.currentToolParts         = PlayerResources.GetCurrentToolPartsValue();
        saveData.currentBookPages         = PlayerResources.GetCurrentBookPagesValue();

        saveData.homesteadTreesCount    = HomesteadStockpile.GetAllTreesCount();
        saveData.homesteadLogsCount     = HomesteadStockpile.GetAllLogsCount();
        saveData.homesteadFirewoodCount = HomesteadStockpile.GetAllFirewoodCount();

        saveData.ownedTools            = PlayerTools.GetOwnedToolsList();
        saveData.currentlyEquippedTool = PlayerTools.GetCurrentlyEquippedTool();

        saveData.efficiencySkill        = PlayerSkills.GetEfficiencySkill();
        saveData.contractsSkill         = PlayerSkills.GetContractsSkill();
        saveData.currencySkill          = PlayerSkills.GetCurrencySkill();
        saveData.energySkill            = PlayerSkills.GetEnergySkill();
        saveData.buildingMaterialsSkill = PlayerSkills.GetBuildingMaterialsSkill();
        saveData.toolPartsSkill         = PlayerSkills.GetToolPartsSkill();
        saveData.bookPagesSkill         = PlayerSkills.GetBookPagesSkill();
        saveData.lumberTreesSkill       = PlayerSkills.GetLumberTreesSkill();
        saveData.lumberLogsSkill        = PlayerSkills.GetLumberLogsSkill();
        saveData.lumberFirewoodSkill    = PlayerSkills.GetLumberFirewoodSkill();

        saveData.bedRoom      = PlayerRooms.GetBedRoom();
        saveData.kitchenRoom  = PlayerRooms.GetKitchenRoom();
        saveData.officeRoom   = PlayerRooms.GetOfficeRoom();
        saveData.studyRoom    = PlayerRooms.GetStudyRoom();
        saveData.workshopRoom = PlayerRooms.GetWorkshopRoom();

        saveData.coffeeMakerAddition      = PlayerAdditions.GetCoffeeMakerAddition();
        saveData.fireplaceAddition        = PlayerAdditions.GetFireplaceAddition();
        saveData.frontPorchAddition       = PlayerAdditions.GetFrontPorchAddition();
        saveData.woodworkingBenchAddition = PlayerAdditions.GetWoodworkingBenchAddition();

        saveData.currentTime = TimeManager.GetCurrentTime();

        saveData.lastSceneName = SceneManager.GetActiveScene().name;
        Vector3 spawnHolder = SpawnLocations.GetSpawnForLoad(SceneManager.GetActiveScene().name);

        saveData.lastSceneSpawnLocation = new float[3] {
            spawnHolder.x, spawnHolder.y, spawnHolder.z
        };
        //-----------------------Done Setting Data---------------------------------------------
        data.Serialize(file, saveData);
        file.Close();
        Debug.Log("Saved here: " + Application.persistentDataPath);
    }
Beispiel #16
0
    public void ExecuteCommand()
    {
        command      = commandDropdown.options[commandDropdown.value].text;
        commandValue = int.Parse(commandInputField.text);
        if (secondaryCommmandInputField.text.Length != 0)
        {
            secondaryCommandValue = int.Parse(secondaryCommmandInputField.text);
        }

        Debug.Log("Command: " + command);
        Debug.Log("Value: " + commandValue);

        switch (command)
        {
        case "Currency Value":
            PlayerResources.SetCurrentCurrencyValue(commandValue);
            break;

        case "Energy Value":
            PlayerEnergy.SetCurrentEnergyValue(commandValue);
            break;

        case "Building Materials Value":
            PlayerResources.SetCurrentBuildingMaterialsValue(commandValue);
            break;

        case "Tool Parts Value":
            PlayerResources.SetCurrentToolPartsValue(commandValue);
            break;

        case "Book Pages Value":
            PlayerResources.SetCurrentBookPagesValue(commandValue);
            break;


        case "Active Contracts Tier":
            PlayerSkills.SetCurrentContractsTier(commandValue);
            break;

        case "Currency Tier":
            PlayerSkills.SetCurrentCurrencyTier(commandValue);
            break;

        case "Efficiency Tier":
            PlayerSkills.SetCurrentEfficiencyTier(commandValue);
            break;

        case "Energy Tier":
            PlayerSkills.SetCurrentEnergyTier(commandValue);
            break;

        case "Building Materials Tier":
            PlayerSkills.SetCurrentBuildingMaterialsTier(commandValue);
            break;

        case "Tool Parts Tier":
            PlayerSkills.SetCurrentToolPartsTier(commandValue);
            break;

        case "Book Pages Tier":
            PlayerSkills.SetCurrentBookPagesTier(commandValue);
            break;


        case "Felling Axe Tier":
            PlayerTools.GetToolByName(ToolName.FELLING_AXE).SetCurrentTier(commandValue);
            break;

        case "Crosscut Saw Tier":
            PlayerTools.GetToolByName(ToolName.CROSSCUT_SAW).SetCurrentTier(commandValue);
            break;

        case "Splitting Axe Tier":
            PlayerTools.GetToolByName(ToolName.SPLITTING_AXE).SetCurrentTier(commandValue);
            break;


        case "Bedroom Tier":
            PlayerRooms.SetBedRoomTier(commandValue);
            break;

        case "Kitchen Tier":
            PlayerRooms.SetKitchenRoomTier(commandValue);
            break;

        case "Office Tier":
            PlayerRooms.SetOfficeRoomTier(commandValue);
            break;

        case "Study Tier":
            PlayerRooms.SetStudyRoomTier(commandValue);
            break;

        case "Workshop Tier":
            PlayerRooms.SetWorkshopRoomTier(commandValue);
            break;


        case "Lumber Trees Value":
            HomesteadStockpile.SetTreesCountAtIndex(secondaryCommandValue, commandValue);
            break;

        case "Lumber Logs Value":
            HomesteadStockpile.SetLogsCountAtIndex(secondaryCommandValue, commandValue);
            break;

        case "Lumber Firewood Value":
            HomesteadStockpile.SetFirewoodCountAtIndex(secondaryCommandValue, commandValue);
            break;


        case "Lumber Trees Tier":
            PlayerSkills.SetCurrentLumberTreesTier(commandValue);
            break;

        case "Lumber Logs Tier":
            PlayerSkills.SetCurrentLumberLogsTier(commandValue);
            break;

        case "Lumber Firewood Tier":
            PlayerSkills.SetCurrentLumberFirewoodTier(commandValue);
            break;


        case "Skip To Time":
            TimeManager.SetCurrentTime((float)commandValue);
            break;

        case "Clear Active Contracts":
            PlayerContracts.SetActiveContractsList(new List <LumberContract>());
            break;

        case "Clear Available Contracts":
            AvailableContracts.SetAvailableContracts(new List <LumberContract>());
            break;
        }
    }