Example #1
0
    // Start is called before the first frame update
    void Start()
    {
        isConnecting = false;
        inExperiment = false;

        // init params with GlobalController
        sender = GlobalController.Instance.client;

        curRepeateTime = 0;
        curTrialIndex  = PublicLabFactors.trial_start_index;

        serverRefreshed    = false;
        haveObjectOnScreen = false;
        prevTrialPhase     = TrialPhase.block_end;
        curTrialPhase      = TrialPhase.a_trial_ready;

        curTrial = new Trial();
        GlobalController.Instance.curLab1Trial = new lab1Factors.Trial();
    }
Example #2
0
    // Start is called before the first frame update
    void Start()
    {
        isConnecting = false;
        inExperiment = false;

        //init params with GloabalController
        sender = GlobalController.Instance.server;
        totalTrialsPerRepeatition = GlobalController.Instance.curLabInfos.totalTrialCount;
        repeateTimes    = PublicLabFactors.Lab0_tap_55.repetitionCount;
        inProtraitBlock = (GlobalController.Instance.curLab0BlockCondition.getOrientation()
                           == PublicLabFactors.Lab0_tap_55.Orientation.protrait);
        blockPosture   = GlobalController.Instance.curLab0BlockCondition.getPosture();
        curRepeateTime = 0;
        curTrialIndex  = PublicLabFactors.trial_start_index;

        prevTrialPhase     = TrialPhase.block_end;
        curTrialPhase      = TrialPhase.block_start;
        clientSaidMoveon   = false;
        haveObjectOnScreen = false;

        trialSequences = new TrialSequence[repeateTimes + 1];
        curSequence    = new TrialSequence();
    }
Example #3
0
    // Update is called once per frame
    void Update()
    {
        if (isConnecting & inExperiment)
        {
            if (prevTrialPhase != curTrialPhase)
            {
                Debug.Log("TrialPhase: " + prevTrialPhase + "->" + curTrialPhase);
                prevTrialPhase = curTrialPhase;
                GlobalController.Instance.curLab0TrialPhase = curTrialPhase;
            }

            if (curTrialPhase == TrialPhase.block_start)
            {
                curTrialPhase = TrialPhase.repeatition_start;
            }
            else if (curTrialPhase == TrialPhase.repeatition_start)
            {
                if (curRepeateTime < repeateTimes)
                {
                    curRepeateTime++;
                    GlobalController.Instance.curLab0Repeateid = curRepeateTime;
                    curTrialPhase = TrialPhase.repeatition_scheduling;
                }
                else
                {
                    curTrialPhase = TrialPhase.block_end;
                }
            }
            else if (curTrialPhase == TrialPhase.repeatition_scheduling)
            {
                target1Controller.resetAllTargets1();

                int    bid    = GlobalController.Instance.curBlockid;
                int    rid    = curRepeateTime;
                string prefix = string.Format("B{0:D2}-R{1:D2}", bid, rid);

                curSequence.setTrialLength(GlobalController.Instance.curLabInfos.totalTrialCount);
                curSequence.setPrefix(prefix);
                curSequence.setAllQuence(blockPosture);
                trialSequences[curRepeateTime] = curSequence;
                GlobalController.Instance.curLab0TrialSequence = curSequence;
                GlobalController.Instance.writeCurrentRepeatIndexTrialSequenceToFile();

                curTrialIndex = PublicLabFactors.trial_start_index - 1;
                curTrialPhase = TrialPhase.a_trial_set_params;
            }
            else if (curTrialPhase == TrialPhase.a_trial_set_params)
            {
                // trial index
                curTrialIndex++;
                GlobalController.Instance.curLab0Trialid = curTrialIndex;

                // set trial
                curTrial.setParams(curTrialIndex,
                                   curSequence.seqTarget1[curTrialIndex - 1],
                                   curSequence.seqTarget2[curTrialIndex - 1]);
                curTrial.printParams();
                GlobalController.Instance.curLab0Trial = curTrial;

                // set trial data
                GlobalController.Instance.curLab0TrialData = new TrialDataWithLocalTime();
                GlobalController.Instance.curLab0TrialData.init(curTrial.index, curTrial.firstid, curTrial.secondid);
                int    bid    = GlobalController.Instance.curBlockid;
                int    rid    = curRepeateTime;
                int    tid    = curTrialIndex;
                string prefix = string.Format("B{0:D2}-R{1:D2}-T{2:D2}", bid, rid, tid);
                GlobalController.Instance.curLab0TrialData.setPrefix(prefix);

                // test mode show params
                uiController.setTrialInfo(prefix, curTrial.firstid, curTrial.secondid);

                // move to next phase
                curTrialPhase = TrialPhase.a_trial_ready;
            }
            else if (curTrialPhase == TrialPhase.a_trial_ready)
            {
                if (!haveObjectOnScreen)
                {
                    target1Controller.updateTarget1OnScreen(curTrial.firstid);
                    GlobalController.Instance.curLab0TrialData.localTime.t1ShowupStamp = CurrentTimeMillis();
                    haveObjectOnScreen = true;
                }
#if UNITY_ANDROID && UNITY_EDITOR
                if (Input.GetMouseButtonUp(0))
                {
                    GlobalController.Instance.curLab0TrialData.tp1Count++;
                    bool touchSuccess = process1Touch4Target1(Input.mousePosition, curTrial.firstid);
                    if (touchSuccess)
                    {
                        GlobalController.Instance.curLab0TrialData.localTime.tp1SuccessStamp = CurrentTimeMillis();
                        GlobalController.Instance.curLab0TrialData.tp1SuccessPosition        = Input.mousePosition;
                        target1Controller.updateTarget1TouchedStatus(curTrial.firstid);
                        haveObjectOnScreen = false;
                        curTrialPhase      = TrialPhase.a_trial_ongoing_p1;
                    }
                    else
                    {
                        GlobalController.Instance.curLab0TrialData.tp1FailPositions.Add(Input.mousePosition);
                    }
                }
#elif UNITY_IOS || UNITY_ANDROID
                if (Input.touchCount == 1)
                {
                    Touch touch = Input.GetTouch(0);
                    if (touch.phase == TouchPhase.Ended)
                    {
                        GlobalController.Instance.curLab0TrialData.tp1Count++;
                        bool touchSuccess = process1Touch4Target1(touch.position, curTrial.firstid);
                        if (touchSuccess)
                        {
                            GlobalController.Instance.curLab0TrialData.localTime.tp1SuccessStamp = CurrentTimeMillis();
                            GlobalController.Instance.curLab0TrialData.tp1SuccessPosition        = touch.position;
                            target1Controller.updateTarget1TouchedStatus(curTrial.firstid);
                            haveObjectOnScreen = false;
                            curTrialPhase      = TrialPhase.a_trial_ongoing_p1;
                        }
                        else
                        {
                            GlobalController.Instance.curLab0TrialData.tp1FailPositions.Add(touch.position);
                        }
                    }
                }
#endif
            }
            else if (curTrialPhase == TrialPhase.a_trial_ongoing_p1)
            {
                // send command to client to display target-2
                GlobalController.Instance.curLab0TrialData.localTime.serverSendDataStamp = CurrentTimeMillis();
                sender.prepareNewMessage4Client(PublicLabFactors.MessageType.Trial);
                curTrialPhase = TrialPhase.a_trial_ongoing_p2;
            }
            else if (curTrialPhase == TrialPhase.a_trial_ongoing_p2)
            {
                clientSaidMoveon = GlobalController.Instance.clientRefreshedTrialData;
                if (isConnecting && clientSaidMoveon)
                {
                    //GlobalController.Instance.curLab0TrialData.localTime.serverReceiveDataStamp = CurrentTimeMillis();
                    clientSaidMoveon = false;
                    GlobalController.Instance.clientRefreshedTrialData = false;
                    curTrialPhase = TrialPhase.a_trial_ongoing_p3;
                }
            }
            else if (curTrialPhase == TrialPhase.a_trial_ongoing_p3)
            {
                curTrialPhase = TrialPhase.a_trial_output_data;
            }
            else if (curTrialPhase == TrialPhase.a_trial_output_data)
            {
                bool writeFinished = false;
                GlobalController.Instance.writeCurrentTrialDataToFile(out writeFinished);
                if (writeFinished)
                {
                    curTrialPhase = TrialPhase.a_trial_end;
                }
            }
            else if (curTrialPhase == TrialPhase.a_trial_end)
            {
                if (curTrialIndex == totalTrialsPerRepeatition)
                {
                    curTrialPhase = TrialPhase.repeatition_start;
                }
                else
                {
                    curTrialPhase = TrialPhase.a_trial_set_params;
                }
            }
            else if (curTrialPhase == TrialPhase.block_end)
            {
                sender.prepareNewMessage4Client(PublicLabFactors.MessageType.Trial);
                phaseController.moveToPhase(Lab0Phase.end_experiment);
            }
            else
            {
                Debug.LogError("Something bad happened.");
            }
        }
    }
Example #4
0
    // Update is called once per frame
    void Update()
    {
        serverRefreshed = GlobalController.Instance.serverRefreshTrialData;
        if (isConnecting & inExperiment)
        {
            if (prevTrialPhase != curTrialPhase)
            {
                Debug.Log("TrialPhase: " + prevTrialPhase + "->" + curTrialPhase);
                prevTrialPhase = curTrialPhase;
                GlobalController.Instance.curLab1TrialPhase = curTrialPhase;
            }

            if (serverRefreshed)
            {
                curTrialPhase = GlobalController.Instance.curLab1TrialPhase;
                if (curTrialPhase == TrialPhase.a_trial_ongoing_p1)
                {
                    long tmpTime = CurrentTimeMillis();
                    curRepeateTime = GlobalController.Instance.curLab1Repeateid;
                    curTrialIndex  = GlobalController.Instance.curLab1Trialid;
                    curTrial       = GlobalController.Instance.curLab1Trial;
                    trialData      = new TrialDataWithLocalTime();
                    trialData.init(curTrial.index, curTrial.secondid);
                    trialData.localTime.clientReceiveDataStamp = tmpTime;
                }
                else if (curTrialPhase == TrialPhase.block_end)
                {
                    // wait
                }
                GlobalController.Instance.serverRefreshTrialData = false;
            }

            if (curTrialPhase == TrialPhase.a_trial_ready)
            {
            }
            else if (curTrialPhase == TrialPhase.a_trial_ongoing_p1)
            {
                if (!haveObjectOnScreen)
                {
                    target2Controller.updateTarget2OnScreen(curTrial.secondid);
                    trialData.localTime.t2ShowupStamp = CurrentTimeMillis();
                    haveObjectOnScreen = true;
                }
#if UNITY_ANDROID && UNITY_EDITOR
                if (Input.GetMouseButtonUp(0))
                {
                    trialData.tp2Count++;
                    bool touchSuccess = process1Touch4Target2(Input.mousePosition, curTrial.secondid);
                    if (touchSuccess)
                    {
                        trialData.localTime.tp2SuccessStamp = CurrentTimeMillis();
                        trialData.tp2SuccessPosition        = Input.mousePosition;
                        target2Controller.updateTarget2TouchedStatus(curTrial.secondid);
                        haveObjectOnScreen = false;
                        curTrialPhase      = TrialPhase.a_trial_ongoing_p2;
                    }
                    else
                    {
                        trialData.tp2FailPositions.Add(Input.mousePosition);
                    }
                }
#elif UNITY_IOS || UNITY_ANDROID
                if (Input.touchCount == 1)
                {
                    Touch touch = Input.GetTouch(0);
                    if (touch.phase == TouchPhase.Ended)
                    {
                        trialData.tp2Count++;
                        bool touchSuccess = process1Touch4Target2(touch.position, curTrial.secondid);
                        if (touchSuccess)
                        {
                            trialData.localTime.tp2SuccessStamp = CurrentTimeMillis();
                            trialData.tp2SuccessPosition        = touch.position;
                            target2Controller.updateTarget2TouchedStatus(curTrial.secondid);
                            haveObjectOnScreen = false;
                            curTrialPhase      = TrialPhase.a_trial_ongoing_p2;
                        }
                        else
                        {
                            trialData.tp2FailPositions.Add(touch.position);
                        }
                    }
                }
#endif
            }
            else if (curTrialPhase == TrialPhase.a_trial_ongoing_p2)
            {
                trialData.localTime.clientSendDataStamp    = CurrentTimeMillis();
                GlobalController.Instance.curLab1TrialData = trialData;
                sender.prepareNewMessage4Server(PublicLabFactors.MessageType.Trial);
                curTrialPhase = TrialPhase.a_trial_ongoing_p3;
            }
            else if (curTrialPhase == TrialPhase.a_trial_ongoing_p3 ||
                     curTrialPhase == TrialPhase.a_trial_output_data)
            {
                // server is rensponsible for this phase
                // client just go on
            }
            else if (curTrialPhase == TrialPhase.block_end)
            {
                phaseController.moveToPhase(Lab1Phase.end_experiment);
            }
            else
            {
                Debug.LogError("Something bad happened: ");
            }
        }
    }