Esempio n. 1
0
    // ------------- Override --------------------.

    /// <summary>
    /// Handles the opcode.
    /// </summary>
    public override void OnUpdate()
    {
        if (IsFinish())
        {
            return;
        }

        // Pomp Message to MessagingHandler.
        if (m_MessagePompToMsghandler)
        {
            if (m_MessagingHandler != null)
            {
                bool handled = m_MessagingHandler.HandleOpcode(this);
                m_MessagePompToMsghandler = !handled;
            }
            return;
        }

        m_CanTextProgress = false;
        switch (code[pc])
        {
        case Opcode.STRING:             pc = ByteCodeReader.readString(code, pc + 1);        m_TextBuilder.Append(loadedString);   break;

        case Opcode.TEXT:               pc = ReadText(pc);                                                                                                                                            break;

        case Opcode.VAR:                pc = ByteCodeReader.readVar(code, pc, ref paramHash, ref m_TextBuilder, stubIndent);       break;

        case Opcode.TABLE:              pc = ByteCodeReader.readTable(code, pc, ref paramHash);                                                                     break;

        case Opcode.ASSIGN_STRING:
//			Debug.Log("OPCODE>ASSIGN_STRING");
            pc        = ByteCodeReader.readString(code, pc + 2);
            leftHand  = loadedString;
            pc        = ByteCodeReader.readString(code, pc + 1);
            rightHand = loadedString;
//			Debug.Log(  "Opcode.ASSIGN key=" + leftHand + " value=\"" + rightHand + "\"" );

// Assign Value to Hashtable ?.
#if false
            symbolTable[leftHand] = rightHand;

// Assign Value to FlagTable.
#else
            ScenarioNode scenario = ScenarioNode.Instance;
            if (scenario != null && scenario.flagTable != null)
            {
                scenario.flagTable.SetStringValue(leftHand, rightHand);
            }
#endif
            leftHand  = "";
            rightHand = "";
            break;

        case Opcode.NULL:              pc++;                                                                                                                                                                           break;

        case Opcode.MESSAGING:
            pc = ByteCodeReader.readString(code, pc + 2);
            messagingTargetName       = loadedString;
            m_MessagePompToMsghandler = true;
            bool isIgnoreObj = loadedString.Equals("env");
            if (!isIgnoreObj)
            {
                if (tweenDataCached.tweenTarget != null)
                {
                    if (!tweenDataCached.tweenTarget.name.Equals(messagingTargetName))
                    {
                        tweenDataCached.tweenTarget = GameObject.Find(messagingTargetName);
                    }
                }
                else
                {
                    tweenDataCached.tweenTarget = GameObject.Find(messagingTargetName);
                }
            }
            tweenDataCached.paramTable = paramHash;
            break;

        case Opcode.NODE:
            m_PrevNodeName = m_CurrNodeName;
            pc             = ByteCodeReader.readString(code, pc + 2);
            ViNoDebugger.Log("NODE", loadedString);

            m_CurrNodeName            = loadedString;
            m_NodePcMap[loadedString] = pc;
            SetCurrentNodeToScriptEngine();

            // Callback to ScriptBinder.
            scriptBinder.OnEnterNode(this);
            break;

        case Opcode.LOAD_RESOURCE:
            m_LoadedResourcePath = VirtualMachine.loadedTextLiteralString;
            m_LoadedResource     = UnityWrapper.LoadResource(m_LoadedResourcePath);
            pc++;
            break;

// TODO : Need to Test .
        case Opcode.PLAY_AUDIO_FROM_RESOURCE:
            m_LoadedResourcePath = VirtualMachine.loadedTextLiteralString;
            ISoundPlayer.Instance.PlayAudioClip(m_LoadedResource as AudioClip, m_LoadedResourcePath, ViNoConfig.prefsBgmVolume, 0f);
            m_LoadedResource = null;
            Resources.UnloadUnusedAssets();

            pc++;
            break;

        case Opcode.INSTANTIATE_AS_GAMEOBJECT:
            if (m_LoadedResource != null)
            {
                string parentName = VirtualMachine.loadedTextLiteralString;

                UnityWrapper.InstantiateAsGameObject(m_LoadedResource, parentName);

                m_LoadedResource = null;
                Resources.UnloadUnusedAssets();
            }
            else
            {
                Debug.LogError("Resource not loaded.");
            }
            pc++;
            break;

        case Opcode.DESTROY_OBJECT:
            string     goName = VirtualMachine.loadedTextLiteralString;
            GameObject go     = GameObject.Find(goName);                                // TODO : GO.Find is Slow .
            GameObject.Destroy(go);
            pc++;
            break;

        case Opcode.JUMP:               // Jump to loadedString Node  .
            ByteCodeReader.readString(code, pc + 2);
            GoToLabel(loadedString);
            ViNoDebugger.Log("NODE", "jump to :" + loadedString);
            break;

        case Opcode.IF:
            pc = ByteCodeReader.readString(code, pc + 2);
            string flagName = VirtualMachine.loadedString;
            Debug.Log("flag name :" + flagName);

            bool isOnOrOff = (code[pc] == 1) ? true : false;
            pc++;

            pc = ByteCodeReader.readString(code, pc + 1);
            string ifTarget = VirtualMachine.loadedString;
            Debug.Log("IF =>" + ifTarget);
            pc = ByteCodeReader.readString(code, pc + 1);
            string elseTarget = VirtualMachine.loadedString;
            Debug.Log("ELSE =>" + elseTarget);

            bool isFlagOn = ScenarioNode.Instance.flagTable.CheckFlagBy(flagName);
            if (isFlagOn == isOnOrOff)
            {
                Debug.Log("IF");
                GoToLabel(ifTarget);
            }
            else
            {
                Debug.Log("ELSE");
                GoToLabel(elseTarget);
            }
            break;

            // ----- Layer -----.
#if false
        case Opcode.LAYOPT:                             GOOptionNode.Do(paramHash);           pc++;   break;
#endif
        case Opcode.BEGIN_TRANSITION:   UnityWrapper.BeginTransition();         pc++;   break;

        case Opcode.END_TRANSITION:             UnityWrapper.EndTransition();           pc++;   break;

        case Opcode.SCENE_NODE:
            SceneData.SceneNodeData data = SceneCreator.CreateNodeData(paramHash);
            SceneCreator.Create(data);
            pc++;
            break;

        case Opcode.LOAD_SCENE:
//			bool destroy = ( code[ pc + 1 ] == 0 ) ? true : false ;
//			UnityWrapper.LoadScene( m_LoadedResource , destroy );
            LoadSceneNode.Do(m_LoadedResource, paramHash);
            m_LoadedResource = null;
            Resources.UnloadUnusedAssets();
            pc++;
            break;

        case Opcode.CLEAR_SCENE:
            GameObject advSceneRoot     = ViNoSceneManager.Instance.theSavedPanel;
            bool       immediateDestroy = false;
            SceneCreator.DestroyScene(advSceneRoot, immediateDestroy);
            pc++;
            break;

/*		case Opcode.PLAY_ANIMATION:
 *                      byte animationID = code[ pc + 1 ];
 *                      ViNoAnimationManager.Instance.PlayAnimation( (int)animationID );
 *                      pc+= 2;
 *                      break;
 * //*/

        // ----- Message -----.
        case Opcode.BR:
//			m_TextBuilder.Append( "\n" );
            pc++;           break;            //scriptBinder.BR( this );	pc++;		break;

        case Opcode.CM:         ClearMessage();                         pc++;           break;

        case Opcode.ER:
            AddToBacklog();
            ClearTextBuilder();
            if (m_MsgTargetTextBox != null)
            {
                m_MsgTargetTextBox.ClearMessage();
            }
            else
            {
                Debug.LogWarning("Current Message Target Not Set.");
            }
            pc++;
            break;

        case Opcode.PRINT:              scriptBinder.PRINT(this);                     pc++;           break;

        case Opcode.CURRENT:
            TriggerMessageEvent("OnMessageTargetChanged", code[pc + 1], "", true);
            break;

        case Opcode.SET_TEXT:
            TriggerMessageEvent("OnSetText", code[pc + 1], VirtualMachine.loadedTextLiteralString, true);
            m_CurrentText = m_MessageEventData.message;
            break;

        case Opcode.HIDE_MESSAGE:
            TriggerMessageEvent("OnHideMessage", code[pc + 1], "", false);
            break;

        // ------ System Opcode -----.
        case Opcode.START_WAIT:
            m_ElapsedSec = 0f;
            if (!string.IsNullOrEmpty(loadedTextLiteralString))
            {
                m_WaitSec = float.Parse(loadedTextLiteralString);
            }
            else
            {
                m_WaitSec = kWaitSec;
            }
            pc++;
            break;

        case Opcode.UPDATE_WAIT:
//			ViNoDebugger.Log( "VM" , "waiting ...");
            m_ElapsedSec += Time.deltaTime;
            if (m_ElapsedSec > m_WaitSec)
            {
                pc++;
            }
            break;

        case Opcode.STOP:
            // Wait Until Player choosing from options . or reached to the end of a leaf node .
            // Nothing to do...

            break;

        case Opcode.END:
            ViNoEventManager.Instance.TriggerEvent("OnFinishScenario");
            update = false;
            break;

        case Opcode.PLAY_SCENARIO:
            pc = ByteCodeReader.readString(code, pc + 2);
            string     scenarioName = loadedString;
            GameObject scenarioObj  = GOCache.SetActive(scenarioName, true);
            if (scenarioObj != null)
            {
                ScenarioNode s = scenarioObj.GetComponent <ScenarioNode>();
                s.Play();
            }
            break;

        case Opcode.FLAG_ON:
            if (ScenarioNode.Instance != null && ScenarioNode.Instance.flagTable != null)
            {
                ScenarioNode.Instance.flagTable.SetFlagBy(VirtualMachine.loadedTextLiteralString, true);
            }
            pc++;
            break;

        case Opcode.FLAG_OFF:
            if (ScenarioNode.Instance != null && ScenarioNode.Instance.flagTable != null)
            {
                ScenarioNode.Instance.flagTable.SetFlagBy(VirtualMachine.loadedTextLiteralString, false);
            }
            pc++;
            break;

        case Opcode.SELECTIONS:
            ISelectionsCtrl selCtrl = ISelectionsCtrl.Instance;
            if (selCtrl != null)
            {
                if (!selCtrl.IsActive())
                {
                    string title = VirtualMachine.loadedTextLiteralString;
                    selCtrl.SetTitle(title);
                    ISelectionsCtrl.Instance.ChangeActive(true);
                }
            }
            else
            {
                Debug.LogError("ISelectionsCtrl instance not found.");
            }
            pc++;
            break;

        case Opcode.LINK:               ISelectionsCtrl.Instance.AddSelection(ref paramHash); pc++;   break;

        case Opcode.WAIT_TOUCH:
            if (IScriptEngine.skip)
            {
                if (IScriptEngine.skipAlreadyPass && !VirtualMachine._ALREADY_PASS_THE_NODE)
                {
                    return;
                }

                _SkipText( );

                ISoundPlayer pl = ISoundPlayer.Instance;
                if (pl != null)
                {
                    if (pl.IsPlayingVoice())
                    {
                        pl.StopVoice();
                    }
                }
                m_CanTextProgress = true;
                return;
            }

            if (autoMode)
            {
                float dt = Time.deltaTime;
                m_TimeElapsed += dt;
                if (m_TimeElapsed > _AUTO_MODE_WAIT_TIME)
                {
                    m_TimeElapsed = 0f;
                    _SkipText();
                }
                return;
            }
            m_CanTextProgress = true;
            break;

//		case Opcode.PLAY_BGM:
//			break;

        // -----Audio -----.
        case Opcode.PLAY_SOUND:
            byte soundCategory = code[pc + 1];                  // 0: BGM 1:SE 2: VOICE.
            byte soundID       = code[pc + 2];

            UnityWrapper.PlaySound(soundCategory, soundID);
            if (soundCategory == 2)
            {
                SET_CURRENT_VOICE_ID(true, soundID);
            }
            pc += 3;
            break;

        case Opcode.STOP_SOUND:
            //TODO :

            pc++;
            break;

        case Opcode.STOP_VOICE:
            SET_CURRENT_VOICE_ID(false, 0);
            if (ISoundPlayer.Instance != null)
            {
                ISoundPlayer.Instance.StopVoice();
            }
            pc++;
            break;

        default:
            ViNoDebugger.LogError("VM", "PC : " + pc);
            break;
        }
    }
Esempio n. 2
0
/*
 *      public void HandleAOpcode( VM vm , byte op ){
 *              vm.code = new byte[ 1 ];
 *              vm.code[ 0 ] = op;
 *              HandleOpcode( vm );
 *      }
 * //*/
    /// <summary>
    /// Handles the opcode.
    /// </summary>
    /// <returns>
    /// The opcode.
    /// </returns>
    /// <param name='vm'>
    /// If set to <c>true</c> vm.
    /// </param>
    public override bool HandleOpcode(VirtualMachine vm)
    {
        m_Vm = vm;
        switch (vm.code[vm.pc])
        {
        case OpcodeMessaging.PUNCH_POSITION:    vm.scriptBinder.PUNCH_POSITION(vm);   break;

        case OpcodeMessaging.SIZE:                              vm.scriptBinder.SIZE(vm);                                            break;

        case OpcodeMessaging.LOAD_IMAGE:                vm.scriptBinder.LOAD_IMAGE(vm.tweenDataCached);                       break;

        case OpcodeMessaging.CHANGE_IMAGE:              vm.scriptBinder.CHANGE_IMAGE(vm.tweenDataCached);             break;

        case OpcodeMessaging.MSG_TARGET:
            GameObject obj = vm.tweenDataCached.tweenTarget;
            vm.scriptBinder.MSG_TARGET(obj);
            break;

        case OpcodeMessaging.SET_TEXT:                                          vm.scriptBinder.SET_TEXT(vm);                                                                                 break;

        case OpcodeMessaging.SET_RESOURCE_AS_TEXTURE:
            Texture2D    image = vm.loadedResource as Texture2D;
            MeshRenderer ren   = vm.tweenDataCached.tweenTarget.GetComponent <MeshRenderer>();
            if (ren != null)
            {
                ren.sharedMaterial.mainTexture = image;
                ren.transform.localScale       = new Vector3(image.width, image.height, 1f);

                // VinoSceneNode component is needed.
                vm.tweenDataCached.tweenTarget.SendMessage("OnChangeTexture", vm.loadedResourcePath, SendMessageOptions.DontRequireReceiver);
            }
            else
            {
                Debug.LogError("MeshRenderer not Found.");
            }
            break;

        case OpcodeMessaging.SET_RESOURCE_AS_TRANSITION_TEXTURE1:
            image = vm.loadedResource as Texture2D;
            ren   = vm.tweenDataCached.tweenTarget.GetComponent <MeshRenderer>();
            if (ren != null)
            {
                ren.sharedMaterial.SetTexture("_tex0", image);
            }
            else
            {
                Debug.LogError("MeshRenderer not Found.");
            }
            break;

        case OpcodeMessaging.SET_RESOURCE_AS_TRANSITION_TEXTURE2:
            image = vm.loadedResource as Texture2D;
            ren   = vm.tweenDataCached.tweenTarget.GetComponent <MeshRenderer>();
            if (ren != null)
            {
                ren.sharedMaterial.SetTexture("_tex1", image);
            }
            else
            {
                Debug.LogError("MeshRenderer not Found.");
            }
            break;

        case OpcodeMessaging.FADE_PANEL:                        vm.update = false;              vm.scriptBinder.FADE_PANEL(vm.tweenDataCached);       break;

        case OpcodeMessaging.CROSS_FADE:                        vm.update = false;              vm.scriptBinder.CROSS_FADE(vm.tweenDataCached);       break;

        case OpcodeMessaging.TWEEN:                                     vm.update = false;              vm.scriptBinder.TWEEN(vm.tweenDataCached);                    break;

        case OpcodeMessaging.DESTROY:                           GameObject.Destroy(vm.tweenDataCached.tweenTarget);           break;

        case OpcodeMessaging.DESTROY_CHILDREN:          ViNoGOExtensions.FindAndDestroyChildren(vm.messagingTargetName);                                      break;

        case OpcodeMessaging.TARGET:                            vm.m_CurrTarget = GameObject.Find(VM.loadedTextLiteralString);                                break;

        case OpcodeMessaging.LOAD_LEVEL:                        Application.LoadLevel(VM.loadedTextLiteralString);                    break;

        case OpcodeMessaging.LOAD_SCENE_XML:            vm.scriptBinder.LOAD_SCENE_XML(vm);                                           break;

        case OpcodeMessaging.PLAY_SOUND:
            if (ISoundPlayer.Instance == null)
            {
                vm.ProgressProgramCounter(1);
                ViNoDebugger.LogError("VM", "PLAY_SOUND : ISoundPlayer.Instance NOT FOUND.");
                return(false);
            }
            string soundName = vm.paramHash["name"] as string;
            string soundCat  = vm.paramHash["category"] as string;
            string delayStr  = vm.paramHash["delay"] as string;
            float  delay     = float.Parse(delayStr);

            if (ISoundPlayer.Instance != null)
            {
                ISoundPlayer.Instance.PlaySoundCallback(soundName, soundCat, 1f, delay);
            }
            break;

        case OpcodeMessaging.STOP_SOUND:
            if (ISoundPlayer.Instance == null)
            {
                vm.ProgressProgramCounter(1);
                ViNoDebugger.LogWarning("ISoundPlayer.Instance NOT FOUND.");
                return(false);
            }
            soundName = vm.paramHash["name"] as string;
            soundCat  = vm.paramHash["category"] as string;
            string fadeStr        = vm.paramHash["fadeOutSeconds"] as string;
            float  fadeOutSeconds = float.Parse(fadeStr);

            if (ISoundPlayer.Instance != null)
            {
                ISoundPlayer.Instance.StopSoundCallback(soundName, soundCat, fadeOutSeconds);
            }
            break;

// TODO:
#if false
        case OpcodeMessaging.SET_ACTIVE:                // OBSOLETE. ===> OPCODE.LAYOPT.
            GOOptionNode.Do(vm.paramHash);
            break;
#endif

        case OpcodeMessaging.SET_POS_3D:
            Vector3 pos = ViNoStringExtensions.ParseVector3(VM.loadedTextLiteralString);
            if (vm.tweenDataCached.tweenTarget != null)
            {
                vm.tweenDataCached.tweenTarget.transform.localPosition = pos;
            }
            break;

        case OpcodeMessaging.SET_SCALE_3D:
            Vector3 scale = ViNoStringExtensions.ParseVector3(VM.loadedTextLiteralString);
            if (vm.tweenDataCached.tweenTarget != null)
            {
                vm.tweenDataCached.tweenTarget.transform.localScale = scale;
            }
            break;

        case OpcodeMessaging.TRANSLATE:
            if (!string.IsNullOrEmpty(VM.loadedTextLiteralString))
            {
                string[] strs = VM.loadedTextLiteralString.Split(',');
                if (strs.Length > 0)
                {
                    if (strs.Length == 3)
                    {
                        GameObject target = vm.tweenDataCached.tweenTarget;
                        if (target != null)
                        {
                            Vector3 tra  = ViNoStringExtensions.ParseVector3(VM.loadedTextLiteralString);
                            Vector3 temp = target.transform.localPosition;
                            temp += tra;
                            target.transform.localPosition = temp;
                        }
                    }
                }
            }
            break;

        case OpcodeMessaging.TRIGGER_EVENT:
            ViNoEventManager em = ViNoEventManager.Instance;
            if (!string.IsNullOrEmpty(VM.loadedTextLiteralString) && em != null)
            {
                em.TriggerEvent(VM.loadedTextLiteralString);
            }
            break;

        case OpcodeMessaging.TRIGGER_EVENT_WITH_ARGS:
            em = ViNoEventManager.Instance;
            if (em != null && vm.tweenDataCached.paramTable.ContainsKey("eventType"))
            {
                string evtType = vm.tweenDataCached.paramTable["eventType"] as string;
                em.TriggerEvent(evtType, vm.tweenDataCached.paramTable);
            }
            break;

        default:
            ViNoDebugger.LogError("PC : " + vm.pc);
            break;
        }

        // Progress Counter.
        vm.ProgressProgramCounter(1);

        return(true);
    }