//Always fill all slots in the final round
    public RoundDefinition GenerateFinalRound(int numberOfAvailableSlots)
    {
        RoundDefinition result = new RoundDefinition();

        result.duration     = roundDuration;
        result.isFinalRound = true;

        result.orderedSlotDefinitions = new List <RoundDefinition.SlotDefinition>();

        for (int i = 0; i < numberOfAvailableSlots; i++)
        {
            RoundDefinition.SlotDefinition slotDefinition = slotDefinitionGenerator.GenerateSlotDefinition(targetTypeCollection, weightSum);
            result.orderedSlotDefinitions.Add(slotDefinition);
        }

        return(result);
    }
    public RoundDefinition GenerateRound(int roundNumber, int numberOfAvailableSlots)
    {
        RoundDefinition result = new RoundDefinition();

        result.duration     = roundDuration;
        result.isFinalRound = false;

        result.orderedSlotDefinitions = new List <RoundDefinition.SlotDefinition>(numberOfAvailableSlots);

        int numberOfSlotsToUse = Random.Range(1, numberOfAvailableSlots + 1);

        int[] indices = new int[numberOfAvailableSlots];
        for (int i = 0; i < numberOfAvailableSlots; i++)
        {
            indices[i] = i;
        }

        SelectIndicesToUse(ref indices, numberOfSlotsToUse, numberOfAvailableSlots);

        for (int k = 0; k < numberOfAvailableSlots; k++)
        {
            bool useSlot = false;

            for (int l = 0; l < numberOfAvailableSlots; l++)
            {
                if (indices[l] == k)
                {
                    useSlot = l < numberOfSlotsToUse;
                    break;
                }
            }

            if (useSlot)
            {
                RoundDefinition.SlotDefinition slotDefinition = slotDefinitionGenerator.GenerateSlotDefinition(targetTypeCollection, weightSum);
                result.orderedSlotDefinitions.Add(slotDefinition);
            }
            else
            {
                result.orderedSlotDefinitions.Add(null);
            }
        }

        return(result);
    }
Example #3
0
    private void LoadTargets(List <RoundDefinition.SlotDefinition> slotDefinitions)
    {
        for (int i = 0; i < presenters.Count; i++)
        {
            presenters[i].ClearTarget();

            RoundDefinition.SlotDefinition slotDefinition = slotDefinitions[i];
            if (slotDefinition == null)
            {
                continue;
            }

            WhackTarget targetPrefab = targetTypeCollection.targetTypes[slotDefinition.targetTypeIndex];
            WhackTarget newTarget    = GameObject.Instantiate <WhackTarget>(targetPrefab, presenters[i].transform);
            newTarget.transform.eulerAngles = Vector3.zero;

            presenters[i].SetTarget(newTarget);
            newTarget.Init(presenters[i], playModel);
        }
    }
    public RoundDefinition.SlotDefinition GenerateSlotDefinition(TargetTypeCollection targetTypeCollection, float weightSum)
    {
        RoundDefinition.SlotDefinition slotDefinition = new RoundDefinition.SlotDefinition();

        //use the weights to select the targetType
        float weightSelection = Random.Range(0, weightSum);
        float localSum        = 0;

        for (int i = 0; i < targetTypeCollection.targetTypes.Count; i++)
        {
            localSum += targetTypeCollection.targetTypes[i].Weight;
            if (weightSelection < localSum)
            {
                slotDefinition.targetTypeIndex = i;
                break;
            }
        }

        slotDefinition.timeBeforePresent = 0;
        return(slotDefinition);
    }