private void maintainBusiness()
    {
        for (short x = 0; x < 4; x++)
        {
            //int tempFocus;
            int         tempNumber;
            float       tempProgress;
            workStation useThis = business.workStations[x];
            switch (business.workStations[x].type)
            {
            case 4:
                //calculate progress since last update and add to the exsisting progress
                tempProgress = (business.customerIncrease * Time.deltaTime) / useThis.timeMain;
                tempProgress = useThis.orders[0].progress + tempProgress;

                //the store is fully dirty or unmaintained
                if (useThis.orders[0].progress == 1 && useThis.orders[0].wants[0] == 100)
                {
                    return;
                }

                if (tempProgress >= 1)
                {
                    // makes a new number to be the amount of times the bar was filled
                    tempNumber = (int)Mathf.Floor(tempProgress);

                    //make new variable to hold the progress less than 1
                    tempProgress = tempProgress - tempNumber;

                    //if the amount if full stop at full
                    if (useThis.orders[0].wants[0] == 100)
                    {
                        tempProgress = 1;
                    }
                    else
                    {
                        //add the amount and update happiness
                        useThis.orders[0].wants[0]    = useThis.orders[0].wants[0] + tempNumber;
                        business.negativeHappiness[x] = useThis.orders[0].wants[0];
                        if (business.negativeHappiness[x] > 50)
                        {
                            business.negativeHappiness[x] = 50;
                        }
                        updateHappiness();
                    }
                    upDateAmount(x, null);
                }
                foreach (employee tempEmployee in business.employeesInfo)
                {
                    if (tempEmployee.workingIn == x)
                    {
                        tempEmployee.task.progress = tempProgress;
                        upDateAmount(x, tempEmployee);
                    }
                }
                useThis.orders[0].progress = tempProgress;
                break;
            }
        }
    }
    //adds customers once a day(every 24 sec)
    private void addCustomers(workStation useThis)
    {
        //if happiness is greater than 90% increase the amount of customers that come per day/ if happiness is lower that 90 decrease
        if (business.happiness > 90)
        {
            int temp = (int)(business.happiness) - 90;
            business.customerIncrease = business.customerIncrease * (1 + (((float)temp / 100) * player.level));
        }
        else if (business.happiness < 90)
        {
            int temp = Mathf.Abs((int)(business.happiness) - 90);
            business.customerIncrease = business.customerIncrease * (1 - (((float)temp / 100) * player.level));
            if (business.customerIncrease < 2)
            {
                business.customerIncrease = 2;
            }
        }

        //update the hapiness based on customers waiting
        int percent = (int)Mathf.Floor(useThis.orders.Count / 20);

        if (percent == 0)
        {
            business.negativeHappiness[needsCustomers] = business.negativeHappiness[needsCustomers] - 1;
            if (business.negativeHappiness[needsCustomers] < 0)
            {
                business.negativeHappiness[needsCustomers] = 0;
            }
        }
        else
        {
            business.negativeHappiness[needsCustomers] = business.negativeHappiness[needsCustomers] + percent;
            if (business.negativeHappiness[needsCustomers] > 50)
            {
                business.negativeHappiness[needsCustomers] = 50;
            }
        }
        updateHappiness();

        int tempCustomers = (int)Mathf.Round(business.customerIncrease);

        //update the customers waiting
        for (int x = 0; x < tempCustomers; x++)
        {
            int[] want  = new int[] { 0 };
            order order = new order(mainControl.getName(), want, false);
            useThis.orders.Add(order);
        }
        upDateAmount(needsCustomers);
    }
Beispiel #3
0
    public void setUpStoreInfo(int station)
    {
        workStation useThis = business.workStations[station];

        //calculate the filth created since created since last tick
        storeInfo[0] = business.customerIncrease / useThis.timeMain;

        foreach (employee employee in business.employeesInfo)
        {
            if (employee.workingIn == station)
            {
                //creates the amount of progress in the last update taking into account the focus multiplyer
                float progress = ((employee.focus * employee.focusMultiplyer[station]) / (useThis.timeMain / employee.timeMultiplyer[station])) * player.decreaseAmount * (player.skillPercent[0] / 100F);
                progress = progress * getWorkForHappiness(employee);
                if (player.playerEmployee.workingIn == station)
                {
                    progress = progress * ((100 + player.percentEffect) / 100F);
                }
                storeInfo[1] = storeInfo[1] + progress;
            }
        }
        storeInfo[2] = storeInfo[1] - storeInfo[0];
        storeInfo[3] = useThis.orders[0].wants[0] + useThis.orders[0].progress;
    }
    //this is the template that runs each workstation depending on there type
    private void updateStations(int place, workStation useThis)
    {
        int   tempFocus;
        int   tempNumber;
        float tempProgress;

        switch (useThis.type)
        {
        case 0:
            //set the amount of focus that the player has in this work station
            tempFocus = player.focus[place];

            //creates the amount of progress in the last update taking into account the focus multiplyer
            tempProgress = (tempFocus * player.playerEmployee.focusMultiplyer[place] * Time.deltaTime) / (useThis.timeMain / player.playerEmployee.timeMultiplyer[place]);
            //adds the progresses together to get the current progress
            tempProgress = tempProgress + useThis.orders[0].progress;

            if (tempProgress >= 1)
            {
                // makes a new number to be the amount of times the bar was filled
                tempNumber = (int)Mathf.Floor(tempProgress);

                //make new variable to hold the progress less than 1
                tempProgress = tempProgress - tempNumber;
                useThis.orders[0].wants[1] = useThis.orders[0].wants[1] + tempNumber;
                upDateAmount(place);
            }
            useThis.slider.value       = tempProgress;
            useThis.orders[0].progress = tempProgress;
            break;

        case 1:
            //if there are no supply and progress
            if (useThis.orders[0].progress == 0 && business.workStations[useThis.extra[0]].orders[0].wants[1] == 0)
            {
                return;
            }

            //set the amount of focus that the player has in this station
            tempFocus = player.focus[place];

            //creates the amount of progress in the last update taking into account the focus multiplyer
            tempProgress = (tempFocus * player.playerEmployee.focusMultiplyer[place] * Time.deltaTime) / (useThis.timeMain / player.playerEmployee.timeMultiplyer[place]);
            //adds the progresses together to get the current progress

            tempProgress = tempProgress + useThis.orders[0].progress;

            //for orders if the taken value is false it means that the products for that order have not been removed
            if (useThis.orders[0].taken == false)
            {
                if (business.workStations[useThis.extra[0]].orders[0].wants[1] == 0)
                {
                    tempProgress = 0;
                }
                else
                {
                    business.workStations[useThis.extra[0]].orders[0].wants[1] = business.workStations[useThis.extra[0]].orders[0].wants[1] - 1;
                    useThis.orders[0].taken = true;
                }
            }

            //if the progress is greater than one
            if (tempProgress >= 1)
            {
                // makes a new number to be the amount of times the bar was filled
                tempNumber = (int)Mathf.Floor(tempProgress);

                //make new variable to hold the progress less than 1
                tempProgress = tempProgress - tempNumber;

                //this code is not very nice and i will redo it the future, basically if it went though more than once take for each time through
                useThis.orders[0].wants[1] = useThis.orders[0].wants[1] + 1;

                if (business.workStations[useThis.extra[0]].orders[0].wants[1] == 0)
                {
                    tempProgress            = 0;
                    useThis.orders[0].taken = false;
                }
                else
                {
                    business.workStations[useThis.extra[0]].orders[0].wants[1] = business.workStations[useThis.extra[0]].orders[0].wants[1] - 1;
                    useThis.orders[0].taken = true;
                }

                if (tempNumber == 2)
                {
                    if (business.workStations[useThis.extra[0]].orders[0].wants[1] == 0)
                    {
                        tempProgress            = 0;
                        useThis.orders[0].taken = false;
                    }
                    else
                    {
                        business.workStations[useThis.extra[0]].orders[0].wants[1] = business.workStations[useThis.extra[0]].orders[0].wants[1] - 1;
                        useThis.orders[0].wants[1] = useThis.orders[0].wants[1] + 1;
                    }
                }
            }
            useThis.slider.value       = tempProgress;
            useThis.orders[0].progress = tempProgress;
            upDateAmount(place);
            upDateAmount(useThis.extra[0]);
            break;

        case 2:
            //if there are no customers and progress
            if (useThis.orders.Count == 0)
            {
                return;
            }

            //if there are no supply and progress
            if (useThis.orders[0].progress == 0 && business.workStations[useThis.extra[0]].orders[0].wants[1] == 0)
            {
                return;
            }

            //set the amount of focus that the player has in this station
            tempFocus = player.focus[place];

            //creates the amount of progress in the last update taking into account the focus multiplyer
            tempProgress = (tempFocus * player.playerEmployee.focusMultiplyer[place] * Time.deltaTime) / (useThis.timeMain / player.playerEmployee.timeMultiplyer[place]);
            //adds the progresses together to get the current progress
            tempProgress = tempProgress + useThis.orders[0].progress;

            //take away one of the customers and used object since the bar has no progress
            if (useThis.orders[0].taken == false)
            {
                if (business.workStations[useThis.extra[0]].orders[0].wants[1] == 0)
                {
                    tempProgress = 0;
                }
                else
                {
                    business.workStations[useThis.extra[0]].orders[0].wants[1] = business.workStations[useThis.extra[0]].orders[0].wants[1] - 1;
                    useThis.orders[0].taken = true;
                }
            }

            //if the progress is greater than one
            if (tempProgress >= 1)
            {
                // makes a new number to be the amount of times the bar was filled
                tempNumber = (int)Mathf.Floor(tempProgress);

                //make new variable to hold the progress less than 1
                tempProgress = tempProgress - tempNumber;

                useThis.orders.RemoveAt(0);
                addToCustomers(1);

                //this code is not very nice and i will redo it the future, basically if it went though more than once take for each time through
                if (useThis.orders.Count == 0)
                {
                    tempProgress = 0;
                }
                else if (business.workStations[useThis.extra[0]].orders[0].wants[1] == 0)
                {
                    tempProgress            = 0;
                    useThis.orders[0].taken = false;
                }
                else
                {
                    business.workStations[useThis.extra[0]].orders[0].wants[1] = business.workStations[useThis.extra[0]].orders[0].wants[1] - 1;
                    useThis.orders[0].taken = true;
                }

                if (tempNumber == 2)
                {
                    if (useThis.orders.Count == 0)
                    {
                        tempProgress = 0;
                    }
                    else if (business.workStations[useThis.extra[0]].orders[0].wants[1] == 0)
                    {
                        tempProgress            = 0;
                        useThis.orders[0].taken = false;
                    }
                    else
                    {
                        business.workStations[useThis.extra[0]].orders[0].wants[1] = business.workStations[useThis.extra[0]].orders[0].wants[1] - 1;
                        useThis.orders.RemoveAt(0);
                        addToCustomers(1);
                    }
                }
            }
            useThis.slider.value = tempProgress;
            if (useThis.orders.Count > 0)
            {
                useThis.orders[0].progress = tempProgress;
            }
            upDateAmount(place);
            upDateAmount(useThis.extra[0]);
            break;

        case 3:
            /*
             * //if there are no customers and progress
             * if (useThis.progress == 0 && useThis.amountWaiting == 0)
             * {
             *  return;
             * }
             *
             * //add 10 to the focus amount if this workplace is being run
             * int tempFocus3 = useThis.focus;
             * if (business.isRunning == place)
             * {
             *  tempFocus3 = tempFocus3 + 10;
             * }
             *
             * //creates the amount of progress in the last update taking into account the focus multiplyer
             * float tempProgress3 = (tempFocus3 * player.focusMultiplyer[place] * Time.deltaTime) / (useThis.timeMain / player.timeMultiplyer[place]);
             * //adds the progresses together to get the current progress
             * tempProgress3 = tempProgress3 + useThis.progress;
             *
             * //take away one of the customers and used object since the bar has no progress
             * if (useThis.progress == 0)
             * {
             *  useThis.amountWaiting = useThis.amountWaiting - 1;
             * }
             *
             * //if the progress is greater than one
             * if (tempProgress3 >= 1)
             * {
             *  // makes a new number to be the amount of times the bar was filled
             *  int tempNumber3 = (int)Mathf.Floor(tempProgress3);
             *
             *  //make new variable to hold the progress less than 1
             *  tempProgress3 = tempProgress3 - tempNumber3;
             *  int amountToUse3;
             *  //if it went though more times then there are customers
             *  if (tempNumber3 > useThis.amountWaiting)
             *  {
             *      amountToUse3 = useThis.amountWaiting;
             *      addToCustomers(amountToUse3 + 1);
             *      tempProgress3 = 0;
             *  }
             *  //if the amount it went though was the correct amount
             *  else
             *  {
             *      amountToUse3 = tempNumber3;
             *      addToCustomers(tempNumber3);
             *  }
             *  useThis.amountWaiting = useThis.amountWaiting - amountToUse3;
             * }
             * useThis.slider.value = tempProgress3;
             * useThis.progress = tempProgress3;
             * upDateAmount(place);
             */
            break;

        case 4:
            //set the amount of focus that the player has
            tempFocus = player.focus[place];

            //creates the amount of progress in the last update taking into account the focus multiplyer
            tempProgress = (tempFocus * player.playerEmployee.focusMultiplyer[place] * Time.deltaTime) / (useThis.timeMain / player.playerEmployee.timeMultiplyer[place]);
            //adds the progresses together to get the current progress
            tempProgress = useThis.orders[0].progress - tempProgress;

            //the store is fully clean or maintained
            if (useThis.orders[0].progress == 0 && useThis.orders[0].wants[0] == 0)
            {
                return;
            }

            if (tempProgress < 0)
            {
                tempProgress = Mathf.Abs(tempProgress);
                // makes a new number to be the amount of times the bar was filled
                tempNumber = (int)Mathf.Floor(tempProgress) + 1;

                //make new variable to hold the progress less than 1
                tempProgress = tempProgress % 1;
                tempProgress = 1 - tempProgress;

                //if the amount is full stop at full
                if (useThis.orders[0].wants[0] == 0)
                {
                    tempProgress = 0;
                }
                else
                {
                    //subtract the amount and update happiness
                    useThis.orders[0].wants[0]        = useThis.orders[0].wants[0] - tempNumber;
                    business.negativeHappiness[place] = useThis.orders[0].wants[0];
                    if (business.negativeHappiness[place] < 0)
                    {
                        business.negativeHappiness[place] = 0;
                    }
                    updateHappiness();
                }
                upDateAmount(place);
            }
            useThis.slider.value       = tempProgress;
            useThis.orders[0].progress = tempProgress;
            break;

        case 5:
            /*
             * //calculate progress since last update and add to the exsisting progress
             * float tempProgress5 = (business.customerIncrease * Time.deltaTime) / (useThis.extra[0] / player.timeMultiplyer[place]);
             * tempProgress5 = useThis.progress - tempProgress5;
             * int tempNumber5 = 0;
             *
             * if (useThis.running == true)
             * {
             *  //add focuse if it is being run by player
             *  int tempFocus5 = useThis.focus;
             *  if (business.isRunning == place)
             *  {
             *      tempFocus5 = tempFocus5 + 10;
             *  }
             *
             *  //update the progress based on the amount of work that is being done
             *  tempProgress5 = tempProgress5 + ((tempFocus5 * player.focusMultiplyer[place] * Time.deltaTime) / (useThis.timeMain / player.timeMultiplyer[place]));
             * }
             *
             * //the store is fully stocked or maintained
             * if (useThis.progress == 1 && useThis.amountWaiting == 100 && tempProgress5 < 0)
             * {
             *  return;
             * }
             *
             * //the store is fully unstocked or unmaintained
             * if (useThis.progress == 0 && useThis.amountWaiting == 0 && tempProgress5 > 0)
             * {
             *  return;
             * }
             *
             * if (tempProgress5 >= 1)
             * {
             *  // makes a new number to be the amount of times the bar was filled
             *  tempNumber5 = (int)Mathf.Floor(tempProgress5);
             *
             *  //make new variable to hold the progress less than 1
             *  tempProgress5 = tempProgress5 - tempNumber5;
             *
             *  //if the amount is full stop at full
             *  if (useThis.amountWaiting == 100)
             *  {
             *      tempProgress5 = 1;
             *  }
             *  else
             *  {
             *      //add the amount and update happiness
             *      useThis.amountWaiting = useThis.amountWaiting + tempNumber5;
             *      business.negativeHappiness[place] = 100 - useThis.amountWaiting;
             *      if (business.negativeHappiness[place] < 0)
             *      {
             *          business.negativeHappiness[place] = 0;
             *      }
             *      updateHappiness();
             *  }
             *  upDateAmount(place);
             * }
             *
             * if (tempProgress5 < 0)
             * {
             *  tempProgress5 = Mathf.Abs(tempProgress5);
             *  // makes a new number to be the amount of times the bar was filled
             *  tempNumber5 = (int)Mathf.Floor(tempProgress5) + 1;
             *
             *  //make new variable to hold the progress less than 1
             *  tempProgress5 = tempProgress5 % 1;
             *  tempProgress5 = 1 - tempProgress5;
             *
             *  //if the amount if full stop at full
             *  if (useThis.amountWaiting == 0)
             *  {
             *      tempProgress5 = 0;
             *  }
             *  else
             *  {
             *      //subtract the amount and update happiness
             *      useThis.amountWaiting = useThis.amountWaiting - tempNumber5;
             *      business.negativeHappiness[place] = 100 - useThis.amountWaiting;
             *      if (business.negativeHappiness[place] > 50)
             *      {
             *          business.negativeHappiness[place] = 50;
             *      }
             *      updateHappiness();
             *  }
             *  upDateAmount(place);
             * }
             * useThis.slider.value = tempProgress5;
             * useThis.progress = tempProgress5;
             */
            break;

        case 6:
            /*
             * //if the store is fully supplied/maintained
             * if (useThis.progress == 1 && useThis.amountWaiting == 100)
             * {
             *  return;
             * }
             *
             * //if there are no goods waiting
             * if (useThis.extra[2] == 0 && business.workStations[useThis.extra[0]].amountWaiting == 0)
             * {
             *  return;
             * }
             *
             * //add 10 to the focus amount if this workplace is being run
             * int tempFocus6 = useThis.focus;
             * if (business.isRunning == place)
             * {
             *  tempFocus6 = tempFocus6 + 10;
             * }
             *
             * //creates the amount of progress in the last update taking into account the multiplyers
             * float thisProgress6 = (tempFocus6 * player.focusMultiplyer[place] * Time.deltaTime) / (useThis.timeMain / player.timeMultiplyer[place]);
             * //adds the progresses together to get the current progress
             * float tempProgress6 = thisProgress6 + useThis.progress;
             * int tempNumber6 = 0;
             *
             * if (thisProgress6 > (float)useThis.extra[2] / 1000000)
             * {
             *  tempProgress6 = thisProgress6 - ((float)useThis.extra[2] / 1000000);
             *  // makes a new number to be the amount of times the bar was filled
             *  tempNumber6 = (int)Mathf.Ceil(tempProgress6);
             *
             *  if (tempNumber6 > business.workStations[useThis.extra[0]].amountWaiting)
             *  {
             *      tempNumber6 = business.workStations[useThis.extra[0]].amountWaiting;
             *      useThis.extra[2] = useThis.extra[2] + (1000000 * tempNumber6);
             *      tempProgress6 = useThis.progress + ((float)useThis.extra[2] / 1000000F);
             *      useThis.extra[2] = 0;
             *  }
             *  else
             *  {
             *      business.workStations[useThis.extra[0]].amountWaiting = business.workStations[useThis.extra[0]].amountWaiting - tempNumber6;
             *      tempProgress6 = useThis.progress + thisProgress6;
             *      useThis.extra[2] = (useThis.extra[2] + (1000000 * tempNumber6)) - (int)(thisProgress6 * 1000000F);
             *  }
             * }
             * else
             * {
             *  useThis.extra[2] = useThis.extra[2] - (int)(thisProgress6 * 1000000);
             * }
             *
             * if (tempProgress6 >= 1)
             * {
             *  // makes a new number to be the amount of times the bar was filled
             *  tempNumber6 = (int)Mathf.Floor(tempProgress6);
             *
             *  //make new variable to hold the progress less than 1
             *  tempProgress6 = tempProgress6 - tempNumber6;
             *  useThis.amountWaiting = useThis.amountWaiting + tempNumber6;
             *  setHappinessForUses(useThis.amountWaiting);
             *  if (useThis.amountWaiting > 100)
             *  {
             *      useThis.extra[2] = useThis.extra[2] + (int)(tempProgress6 * 1000000F);
             *      tempProgress6 = 1;
             *      useThis.amountWaiting = 100;
             *  }
             * }
             * useThis.slider.value = tempProgress6;
             * useThis.progress = tempProgress6;
             * upDateAmount(place);
             * upDateAmount(useThis.extra[0]);
             */
            break;

        case 7:
            if (useThis.orders.Count == 0)
            {
                return;
            }

            //set the amount of focus that the player has in this station
            tempFocus = player.focus[place];

            //creates the amount of progress in the last update taking into account the focus multiplyer
            tempProgress = (tempFocus * player.playerEmployee.focusMultiplyer[place] * Time.deltaTime) / (useThis.orders[0].wants[1] / player.playerEmployee.timeMultiplyer[place]);
            //adds the progresses together to get the current progress
            tempProgress = tempProgress + useThis.orders[0].progress;

            //when the current training has been finished
            if (tempProgress > 1)
            {
                trainingCS.finishTraining();
                useThis.orders.RemoveAt(0);
                tempProgress = tempProgress - 1;
            }

            //if there is training add the progress to the next training
            if (useThis.orders.Count != 0)
            {
                useThis.slider.value       = tempProgress;
                useThis.orders[0].progress = tempProgress;
            }
            //if there is no more training
            else
            {
                useThis.slider.value = 0;
                selectionChange(player.playerEmployee.wasWorkingIn);
            }
            break;
        }
    }
Beispiel #5
0
    //run the work stations for each employee - needs work
    private void updateStations(int station, workStation useThis, employee employee, float decreaseAmount, int place)
    {
        int   tempFocus;
        int   tempNumber;
        float tempProgress;

        switch (useThis.type)
        {
        case 0:
            /*
             * //creates the amount of progress in the last update taking into account the focus multiplyer
             * float tempProgress0 = (focus * employee.focusMultiplyer[place] * Time.deltaTime * (player.skillPercent[0]/100F) * decreaseAmount) / (useThis.timeMain / employee.timeMultiplyer[place]);
             *
             * //adds the progresses together to get the current progress
             * tempProgress0 = tempProgress0 + employee.progress;
             *
             * if (tempProgress0 >= 1)
             * {
             *  // makes a new number to be the amount of times the bar was filled
             *  int tempNumber0 = (int)Mathf.Floor(tempProgress0);
             *
             *  //make new variable to hold the progress less than 1
             *  tempProgress0 = tempProgress0 - tempNumber0;
             *  useThis.amountWaiting = useThis.amountWaiting + tempNumber0;
             *  upDateAmount(place, employee);
             * }
             * employee.slider.value = tempProgress0;
             * employee.progress = tempProgress0;
             * break;
             * case 1:
             * //if there are no supply and progress
             * if (employee.progress == 0 && business.workStations[useThis.extra[0]].amountWaiting == 0)
             * {
             *  return;
             * }
             *
             * //creates the amount of progress in the last update taking into account the focus multiplyer
             * float tempProgress1 = (focus * employee.focusMultiplyer[place] * Time.deltaTime * (player.skillPercent[0] / 100F) * decreaseAmount) / (useThis.timeMain / employee.timeMultiplyer[place]);
             *
             * //adds the progresses together to get the current progress
             * tempProgress1 = tempProgress1 + employee.progress;
             *
             * //take away one used object since the bar has no progress
             * if (employee.progress == 0)
             * {
             *  business.workStations[useThis.extra[0]].amountWaiting = business.workStations[useThis.extra[0]].amountWaiting - 1;
             * }
             *
             * //if the progress is greater than one
             * if (tempProgress1 >= 1)
             * {
             *  // makes a new number to be the amount of times the bar was filled
             *  int tempNumber1 = (int)Mathf.Floor(tempProgress1);
             *
             *  //make new variable to hold the progress less than 1
             *  tempProgress1 = tempProgress1 - tempNumber1;
             *  int amountToUse1;
             *  //if it went though more times then there are used amount
             *  if (tempNumber1 > business.workStations[useThis.extra[0]].amountWaiting)
             *  {
             *      amountToUse1 = business.workStations[useThis.extra[0]].amountWaiting + 1;
             *      business.workStations[useThis.extra[0]].amountWaiting = business.workStations[useThis.extra[0]].amountWaiting - (amountToUse1 - 1);
             *      tempProgress1 = 0;
             *  }
             *  //if the amount it went though was the correct amount
             *  else
             *  {
             *      amountToUse1 = tempNumber1;
             *      business.workStations[useThis.extra[0]].amountWaiting = business.workStations[useThis.extra[0]].amountWaiting - amountToUse1;
             *  }
             *  useThis.amountWaiting = useThis.amountWaiting + amountToUse1;
             * }
             * employee.slider.value = tempProgress1;
             * employee.progress = tempProgress1;
             * upDateAmount(place,employee);
             * upDateAmount(useThis.extra[0],employee);
             */
            break;

        case 2:
            /*
             * //if there are no supply and progress
             * if (employee.progress == 0 && business.workStations[useThis.extra[0]].amountWaiting == 0)
             * {
             *  return;
             * }
             *
             * //if there are no customers and progress
             * if (employee.progress == 0 && useThis.amountWaiting == 0)
             * {
             *  return;
             * }
             *
             * //creates the amount of progress in the last update taking into account the focus multiplyer
             * float tempProgress2 = (focus * employee.focusMultiplyer[place] * Time.deltaTime * (player.skillPercent[0] / 100F) * decreaseAmount) / (useThis.timeMain / employee.timeMultiplyer[place]);
             *
             * //adds the progresses together to get the current progress
             * tempProgress2 = tempProgress2 + employee.progress;
             *
             * //take away one of the customers and used object since the bar has no progress
             * if (employee.progress == 0)
             * {
             *  business.workStations[useThis.extra[0]].amountWaiting = business.workStations[useThis.extra[0]].amountWaiting - 1;
             *  useThis.amountWaiting = useThis.amountWaiting - 1;
             * }
             *
             * //if the progress is greater than one
             * if (tempProgress2 >= 1)
             * {
             *  // makes a new number to be the amount of times the bar was filled
             *  int tempNumber2 = (int)Mathf.Floor(tempProgress2);
             *
             *  //make new variable to hold the progress less than 1
             *  tempProgress2 = tempProgress2 - tempNumber2;
             *  int amountToUse2;
             *  //if it went though more times then there are customers
             *  if (tempNumber2 > useThis.amountWaiting)
             *  {
             *      amountToUse2 = useThis.amountWaiting;
             *      addToCustomers(amountToUse2 + 1);
             *      tempProgress2 = 0;
             *  }
             *  //if it went though more times then there are used amount
             *  else if (tempNumber2 > business.workStations[useThis.extra[0]].amountWaiting)
             *  {
             *      amountToUse2 = business.workStations[useThis.extra[0]].amountWaiting;
             *      addToCustomers(amountToUse2 + 1);
             *      tempProgress2 = 0;
             *  }
             *  //if the amount it went though was the correct amount
             *  else
             *  {
             *      amountToUse2 = tempNumber2;
             *      addToCustomers(tempNumber2);
             *  }
             *  useThis.amountWaiting = useThis.amountWaiting - amountToUse2;
             *  business.workStations[useThis.extra[0]].amountWaiting = business.workStations[useThis.extra[0]].amountWaiting - amountToUse2;
             * }
             * employee.slider.value = tempProgress2;
             * employee.progress = tempProgress2;
             * upDateAmount(place,employee);
             * upDateAmount(useThis.extra[0],employee);
             */
            break;

        case 3:
            /*
             * //if there are no customers and progress
             * if (useThis.progress == 0 && useThis.amountWaiting == 0)
             * {
             *  return;
             * }
             *
             * //creates the amount of progress in the last update taking into account the focus multiplyer
             * float tempProgress3 = (focus * employee.focusMultiplyer[place] * Time.deltaTime * (player.skillPercent[0] / 100F) * decreaseAmount) / (useThis.timeMain / employee.timeMultiplyer[place]);
             *
             * //adds the progresses together to get the current progress
             * tempProgress3 = tempProgress3 + employee.progress;
             *
             * //take away one of the customers and used object since the bar has no progress
             * if (employee.progress == 0)
             * {
             *  useThis.amountWaiting = useThis.amountWaiting - 1;
             * }
             *
             * //if the progress is greater than one
             * if (tempProgress3 >= 1)
             * {
             *  // makes a new number to be the amount of times the bar was filled
             *  int tempNumber3 = (int)Mathf.Floor(tempProgress3);
             *
             *  //make new variable to hold the progress less than 1
             *  tempProgress3 = tempProgress3 - tempNumber3;
             *  int amountToUse3;
             *  //if it went though more times then there are customers
             *  if (tempNumber3 > useThis.amountWaiting)
             *  {
             *      amountToUse3 = useThis.amountWaiting;
             *      addToCustomers(amountToUse3 + 1);
             *      tempProgress3 = 0;
             *  }
             *  //if the amount it went though was the correct amount
             *  else
             *  {
             *      amountToUse3 = tempNumber3;
             *      addToCustomers(tempNumber3);
             *  }
             *  useThis.amountWaiting = useThis.amountWaiting - amountToUse3;
             * }
             * employee.slider.value = tempProgress3;
             * employee.progress = tempProgress3;
             * upDateAmount(place,employee);
             */
            break;

        case 4:
            if (employee.task == null)
            {
                employee.task = useThis.orders[0];
            }
            else if (employee.task.name != useThis.orders[0].name)
            {
                employee.task = useThis.orders[0];
            }

            //set the amount of focus that the employee has
            tempFocus = employee.focus;

            //creates the amount of progress in the last update taking into account the focus multiplyer
            tempProgress = ((tempFocus * employee.focusMultiplyer[station] * Time.deltaTime) / (useThis.timeMain / employee.timeMultiplyer[station])) * decreaseAmount * (player.skillPercent[0] / 100F);
            tempProgress = tempProgress * getWorkForHappiness(employee);
            if (player.playerEmployee.workingIn == station)
            {
                tempProgress = tempProgress * ((100 + player.percentEffect) / 100F);
            }
            //adds the progresses together to get the current progress
            tempProgress = useThis.orders[0].progress - tempProgress;

            //the store is fully clean or maintained
            if (useThis.orders[0].progress == 0 && useThis.orders[0].wants[0] == 0)
            {
                return;
            }

            if (tempProgress < 0)
            {
                tempProgress = Mathf.Abs(tempProgress);
                // makes a new number to be the amount of times the bar was filled
                tempNumber = (int)Mathf.Floor(tempProgress) + 1;

                //make new variable to hold the progress less than 1
                tempProgress = tempProgress % 1;
                tempProgress = 1 - tempProgress;

                //if the amount is full stop at full
                if (useThis.orders[0].wants[0] == 0)
                {
                    tempProgress = 0;
                }
                else
                {
                    //subtract the amount and update happiness
                    useThis.orders[0].wants[0]          = useThis.orders[0].wants[0] - tempNumber;
                    business.negativeHappiness[station] = useThis.orders[0].wants[0];
                    if (business.negativeHappiness[station] < 0)
                    {
                        business.negativeHappiness[station] = 0;
                    }
                    updateHappiness();
                }
            }
            employee.task.progress = tempProgress;
            break;

        case 5:
            /*
             * //calculate progress since last update and add to the exsisting progress
             * float tempProgress5 = (business.customerIncrease * Time.deltaTime) / (useThis.extra[0] / player.timeMultiplyer[place]);
             * tempProgress5 = useThis.progress - tempProgress5;
             * int tempNumber5 = 0;
             *
             * if (useThis.running == true)
             * {
             *  //add focuse if it is being run by player
             *  int tempFocus5 = useThis.focus;
             *  if (business.isRunning == place)
             *  {
             *      tempFocus5 = tempFocus5 + 10;
             *  }
             *
             *  //update the progress based on the amount of work that is being done
             *  tempProgress5 = tempProgress5 + ((tempFocus5 * player.focusMultiplyer[place] * Time.deltaTime) / (useThis.timeMain / player.timeMultiplyer[place]));
             * }
             *
             * //the store is fully stocked or maintained
             * if (useThis.progress == 1 && useThis.amountWaiting == 100 && tempProgress5 < 0)
             * {
             *  return;
             * }
             *
             * //the store is fully unstocked or unmaintained
             * if (useThis.progress == 0 && useThis.amountWaiting == 0 && tempProgress5 > 0)
             * {
             *  return;
             * }
             *
             * if (tempProgress5 >= 1)
             * {
             *  // makes a new number to be the amount of times the bar was filled
             *  tempNumber5 = (int)Mathf.Floor(tempProgress5);
             *
             *  //make new variable to hold the progress less than 1
             *  tempProgress5 = tempProgress5 - tempNumber5;
             *
             *  //if the amount is full stop at full
             *  if (useThis.amountWaiting == 100)
             *  {
             *      tempProgress5 = 1;
             *  }
             *  else
             *  {
             *      //add the amount and update happiness
             *      useThis.amountWaiting = useThis.amountWaiting + tempNumber5;
             *      business.negativeHappiness[place] = 100 - useThis.amountWaiting;
             *      if (business.negativeHappiness[place] < 0)
             *      {
             *          business.negativeHappiness[place] = 0;
             *      }
             *      updateHappiness();
             *  }
             *  upDateAmount(place);
             * }
             *
             * if (tempProgress5 < 0)
             * {
             *  tempProgress5 = Mathf.Abs(tempProgress5);
             *  // makes a new number to be the amount of times the bar was filled
             *  tempNumber5 = (int)Mathf.Floor(tempProgress5) + 1;
             *
             *  //make new variable to hold the progress less than 1
             *  tempProgress5 = tempProgress5 % 1;
             *  tempProgress5 = 1 - tempProgress5;
             *
             *  //if the amount if full stop at full
             *  if (useThis.amountWaiting == 0)
             *  {
             *      tempProgress5 = 0;
             *  }
             *  else
             *  {
             *      //subtract the amount and update happiness
             *      useThis.amountWaiting = useThis.amountWaiting - tempNumber5;
             *      business.negativeHappiness[place] = 100 - useThis.amountWaiting;
             *      if (business.negativeHappiness[place] > 50)
             *      {
             *          business.negativeHappiness[place] = 50;
             *      }
             *      updateHappiness();
             *  }
             *  upDateAmount(place);
             * }
             * useThis.slider.value = tempProgress5;
             * useThis.progress = tempProgress5;
             */
            break;

        case 6:
            /*
             * //if the store is fully supplied/maintained
             * if (useThis.progress == 1 && useThis.amountWaiting == 100)
             * {
             *  return;
             * }
             *
             * //if there are no goods waiting
             * if (useThis.extra[2] == 0 && business.workStations[useThis.extra[0]].amountWaiting == 0)
             * {
             *  return;
             * }
             *
             * //add 10 to the focus amount if this workplace is being run
             * int tempFocus6 = useThis.focus;
             * if (business.isRunning == place)
             * {
             *  tempFocus6 = tempFocus6 + 10;
             * }
             *
             * //creates the amount of progress in the last update taking into account the multiplyers
             * float thisProgress6 = (tempFocus6 * player.focusMultiplyer[place] * Time.deltaTime) / (useThis.timeMain / player.timeMultiplyer[place]);
             * //adds the progresses together to get the current progress
             * float tempProgress6 = thisProgress6 + useThis.progress;
             * int tempNumber6 = 0;
             *
             * if (thisProgress6 > (float)useThis.extra[2] / 1000000)
             * {
             *  tempProgress6 = thisProgress6 - ((float)useThis.extra[2] / 1000000);
             *  // makes a new number to be the amount of times the bar was filled
             *  tempNumber6 = (int)Mathf.Ceil(tempProgress6);
             *
             *  if (tempNumber6 > business.workStations[useThis.extra[0]].amountWaiting)
             *  {
             *      tempNumber6 = business.workStations[useThis.extra[0]].amountWaiting;
             *      useThis.extra[2] = useThis.extra[2] + (1000000 * tempNumber6);
             *      tempProgress6 = useThis.progress + ((float)useThis.extra[2] / 1000000F);
             *      useThis.extra[2] = 0;
             *  }
             *  else
             *  {
             *      business.workStations[useThis.extra[0]].amountWaiting = business.workStations[useThis.extra[0]].amountWaiting - tempNumber6;
             *      tempProgress6 = useThis.progress + thisProgress6;
             *      useThis.extra[2] = (useThis.extra[2] + (1000000 * tempNumber6)) - (int)(thisProgress6 * 1000000F);
             *  }
             * }
             * else
             * {
             *  useThis.extra[2] = useThis.extra[2] - (int)(thisProgress6 * 1000000);
             * }
             *
             * if (tempProgress6 >= 1)
             * {
             *  // makes a new number to be the amount of times the bar was filled
             *  tempNumber6 = (int)Mathf.Floor(tempProgress6);
             *
             *  //make new variable to hold the progress less than 1
             *  tempProgress6 = tempProgress6 - tempNumber6;
             *  useThis.amountWaiting = useThis.amountWaiting + tempNumber6;
             *  setHappinessForUses(useThis.amountWaiting);
             *  if (useThis.amountWaiting > 100)
             *  {
             *      useThis.extra[2] = useThis.extra[2] + (int)(tempProgress6 * 1000000F);
             *      tempProgress6 = 1;
             *      useThis.amountWaiting = 100;
             *  }
             * }
             * useThis.slider.value = tempProgress6;
             * useThis.progress = tempProgress6;
             * upDateAmount(place);
             * upDateAmount(useThis.extra[0]);
             */
            break;

        case 7:
            if (employee.trainingQ.Count == 0)
            {
                return;
            }

            //set the amount of focus that the employee has
            tempFocus = employee.focus;

            //creates the amount of progress in the last update taking into account the focus multiplyer
            tempProgress = ((tempFocus * employee.focusMultiplyer[station] * Time.deltaTime) / (employee.trainingQ[0].wants[1] / employee.timeMultiplyer[station])) * decreaseAmount * (player.skillPercent[0] / 100F);
            //adds the progresses together to get the current progress
            tempProgress = tempProgress * getWorkForHappiness(employee);
            if (player.playerEmployee.workingIn == station)
            {
                tempProgress = tempProgress * ((100 + player.percentEffect) / 100F);
            }
            tempProgress = tempProgress + employee.trainingQ[0].progress;

            if (tempProgress > 1)
            {
                int iteam = employee.trainingQ[0].wants[0];
                for (short x = 0; x < business.iteamList[iteam].affectAreas.Length; x++)
                {
                    int tempInt = business.iteamList[iteam].affectAreas[x];
                    employee.timeMultiplyer[tempInt] = employee.timeMultiplyer[tempInt] + (business.iteamList[iteam].affectAmount / 100F);
                }

                employee.trainingQ.RemoveAt(0);
                if (currentlySelected == -1)
                {
                    //do nothing
                }
                else if (business.employeesInfo[currentlySelected] == employee)
                {
                    trainingMenuEmployee.GetComponent <TrainingEmployee>().setUp(currentlySelected);
                }
                tempProgress = tempProgress - 1;
            }

            if (employee.trainingQ.Count != 0)
            {
                employee.slider.value          = tempProgress;
                employee.trainingQ[0].progress = tempProgress;
            }
            else
            {
                employee.slider.value = 0;
                if (business.workStations[employee.wasWorkingIn].EmployeeSpace != 0)
                {
                    changeEmployeeStation(place, employee.wasWorkingIn);
                    employee.workingIn = employee.wasWorkingIn;
                }
            }
            break;
        }
    }