Beispiel #1
0
    // MARK: Flush

    public void doFlush(Objectives.FlushRequest request)
    {
        const int FLUSH_COST = 100;

        LocalMoneyWorker.Instance.Buy(FLUSH_COST, delegate(int amount)
        {
            var response = new Objectives.FlushResponse();
            if (amount >= 0)
            {
                //since we are flushing, we should reset progress dans status
                for (int obj = 0; obj < numberOfObjectives; obj++)
                {
                    ObjectivesWorker.Update(obj, fetchedSet, 0);
                    ObjectivesWorker.UpdateStatus(obj, fetchedSet, false);
                }

                response.objectives = ObjectivesWorker.Flush(numberOfObjectives);

                //since we flushed data we fetch objectives again
                var fetchRequest = new Objectives.FetchRequest();
                fetchRequest.numberOfObjectives = numberOfObjectives;
                fetchRequest.set = fetchedSet;
                doFetch(fetchRequest);
            }
            else //Flush failed
            {
                response.objectives = new Objectives.ObjectivesModel[] { };
            }
            this.presenter.presentFlush(response);
        });
    }
Beispiel #2
0
    // MARK: Fetch

    public void fetchObjectives(Objectives.ObjectiveSet set, int numberOfObjectives = 3)
    {
        var request = new Objectives.FetchRequest();

        request.set = set;
        request.numberOfObjectives = numberOfObjectives;
        interactor.doFetch(request);
    }
Beispiel #3
0
    // MARK: Claim

    public void doClaim(Objectives.ClaimRequest request)
    {
        var response = new Objectives.ClaimResponse();

        //invalid index
        if (request.id >= this.fetchedObjectives.Length)
        {
            response.isRewardGranted = false;
            this.presenter.presentClaim(response);
            return;
        }
        //max step not reached
        if (this.fetchedObjectives[request.id].currentStep != this.fetchedObjectives[request.id].numberOfSteps)
        {
            response.isRewardGranted = false;
            this.presenter.presentClaim(response);
            return;
        }

        var reward = this.fetchedObjectives[request.id].reward;

        LocalMoneyWorker.Instance.Sell(reward, delegate(int amount) {
            //everything is fine, we can update claim status
            //fetchedObjectives[request.id].isRewardClaimed = true;
            ObjectivesWorker.UpdateStatus(request.id, fetchedSet, true);

            //since we flushed data we fetch objectives again
            var fetchRequest = new Objectives.FetchRequest();
            fetchRequest.numberOfObjectives = numberOfObjectives;
            fetchRequest.set = fetchedSet;
            doFetch(fetchRequest);

            //if all Game Objectives are complete and claimed, we should autoflush
            if (fetchedSet == Objectives.ObjectiveSet.Game)
            {
                bool shouldAutoFlush = true;
                foreach (var objective in fetchedObjectives)
                {
                    if (false == objective.isRewardClaimed)
                    {
                        shouldAutoFlush = false;
                    }
                }

                if (shouldAutoFlush)
                {
                    var flushRequest = new Objectives.FlushRequest();
                    doFlush(flushRequest);
                }
            }

            response.isRewardGranted = true;
            this.presenter.presentClaim(response);
        });
    }
    //--- WORLDS SET
    //TODO

    // MARK: - Private Methods

    private void buildFetchRequest(int number, Objectives.ObjectiveSet set)
    {
        var request = new Objectives.FetchRequest();

        request.numberOfObjectives = number;
        request.set = set;
        sut.doFetch(request);

        Assert.IsTrue(spy.presentFetchCalled);
        Assert.AreEqual(spy.lastFetchResponse.objectives.Length, request.numberOfObjectives);
    }
Beispiel #5
0
    // MARK: Fetch

    public void doFetch(Objectives.FetchRequest request)
    {
        var response = new Objectives.FetchResponse();

        numberOfObjectives = request.numberOfObjectives;
        fetchedSet         = request.set;

        this.fetchedObjectives = ObjectivesWorker.Read(numberOfObjectives, fetchedSet);
        response.objectives    = this.fetchedObjectives;
        response.currentIndex  = ObjectivesWorker.ReadIndex(fetchedSet);

        this.presenter.presentFetch(response);
    }
Beispiel #6
0
    // MARK: Reset

    public void doReset(Objectives.ResetRequest request)
    {
        ObjectivesWorker.Reset();

        //since we flushed data we fetch objectives again
        var fetchRequest = new Objectives.FetchRequest();

        fetchRequest.numberOfObjectives = numberOfObjectives;
        fetchRequest.set = fetchedSet;
        doFetch(fetchRequest);

        var response = new Objectives.ResetResponse();

        presenter.presentReset(response);
    }
Beispiel #7
0
    // MARK: Step

    public void doStep(Objectives.StepRequest request)
    {
        var response = new Objectives.StepResponse();

        if (fetchedObjectives[request.id].currentStep < fetchedObjectives[request.id].numberOfSteps)
        {
            fetchedObjectives[request.id].currentStep = fetchedObjectives[request.id].currentStep + 1;
        }

        ObjectivesWorker.Update(request.id, fetchedSet, fetchedObjectives[request.id].currentStep);

        response.objective = fetchedObjectives[request.id];

        //since we stepped data we fetch objectives again
        var fetchRequest = new Objectives.FetchRequest();

        fetchRequest.numberOfObjectives = numberOfObjectives;
        fetchRequest.set = fetchedSet;
        doFetch(fetchRequest);

        presenter.presentStep(response);
    }