Example #1
0
        /// <summary>
        /// Load game from "save/game" directory
        /// GuiManager must started first
        /// </summary>
        public static void LoadGame(bool isInitlizeGame)
        {
            if (isInitlizeGame)
            {
                //Clear
                ScriptManager.Clear();
                ScriptExecuter.Init();
                MagicManager.Clear();
                NpcManager.ClearAllNpc();
                ObjManager.ClearAllObjAndFileName();
                Globals.TheMap.Free();
                GuiManager.CloseTimeLimit();
                GuiManager.EndDialog();
                BackgroundMusic.Stop();
                Globals.IsInputDisabled = false;
            }

            LoadGameFile();
            LoadMagicGoodMemoList();
            LoadPlayer();
            //Apply xiulian magic to player
            Globals.ThePlayer.XiuLianMagic = MagicListManager.GetItemInfo(
                MagicListManager.XiuLianIndex);

            LoadPartner();
            LoadTraps();
            LoadTrapIgnoreList();

            Globals.TheCarmera.CenterPlayerInCamera();

            GameState.State = GameState.StateType.Playing;
            Globals.TheGame.IsGamePlayPaused = false;
            GuiManager.ShowAllPanels(false);
        }
Example #2
0
        public static void Update(GameTime gameTime)
        {
            //To avoid Sleep() script function end early, update ScriptExecuter first.
            ScriptExecuter.Update(gameTime);

            for (var node = _list.First; node != null;)
            {
                var script = node.Value;
                if (script.FilePath != _lastFilePath)
                {
                    Globals.TheMessageSender.SendFunctionCallMessage(Environment.NewLine +
                                                                     "【" +
                                                                     script.FilePath + "】" +
                                                                     (script.IsOk ? "" : "  读取失败"));
                    Globals.TheMessageSender.SendScriptFileChangeMessage(script.FilePath);
                }
                _lastFilePath = script.FilePath;

                if (!script.Continue())
                {
                    //Remove current
                    _list.Remove(node);
                    //Get next
                    node = _list.First;
                }
                else
                {
                    //Can't run multiple script at same time
                    break;
                }
            }
        }
Example #3
0
        private static void ShowSaveLoad(bool isShow, bool canSave)
        {
            SaveLoadInterface.IsShow  = isShow;
            SaveLoadInterface.CanSave = canSave;
            if (isShow && canSave)
            {
                var show = IsShow;
                //Hide GUI when take snapshot
                IsShow = false;
                SaveLoadInterface.Snapshot = Globals.TheGame.TakeSnapShot();
                //Restore
                IsShow = show;
            }

            if (!isShow)
            {
                switch (GameState.State)
                {
                case GameState.StateType.Title:
                    ScriptExecuter.ReturnToTitle();
                    break;

                case GameState.StateType.Playing:
                    break;
                }
            }
        }
        private void PlayButtonClicked(object sender, EventArgs e)
        {
            // Run script and handle exceptions.
            ScriptExecuter.Execute(
                Editor.Text.Split('\n').ToList(),
                (ScriptExecuter.ScriptErrorType type, string message) => {
                // On exception, show toast message and log it.
                switch (type)
                {
                case ScriptExecuter.ScriptErrorType.SYNTAX_ERROR:
                    ToastProvider.ShowToast("Syntax error in script. See logfile for details.");
                    LoggerPage.instance.LogMessage("Syntax error in script: \n" + message, LoggerPage.MessageType.ERROR);
                    break;

                case ScriptExecuter.ScriptErrorType.RUNTIME_ERROR:
                    ToastProvider.ShowToast("Error while executing script. See logfile for details.");
                    LoggerPage.instance.LogMessage("Error while executing script: \n" + message, LoggerPage.MessageType.ERROR);
                    break;

                case ScriptExecuter.ScriptErrorType.INTERNAL_ERROR:
                    ToastProvider.ShowToast("Internal error in scripting engine. See logfile for details.");
                    LoggerPage.instance.LogMessage("Internal error while executing script: \n" + message, LoggerPage.MessageType.ERROR);
                    break;

                case ScriptExecuter.ScriptErrorType.CONNECTION_ERROR:
                    ToastProvider.ShowToast("No connection to Arduino. See logfile for details.");
                    LoggerPage.instance.LogMessage("Script execution was stopped because there was no Arduino connection: \n" + message, LoggerPage.MessageType.WARNING);
                    break;
                }

                LoggerPage.instance.LogMessage("While executing script " + title + ".lua");
            }
                );
        }
Example #5
0
 /// <summary>
 /// Draw map npc obj magic etc.
 /// </summary>
 /// <param name="gameTime">Provides a snapshot of timing values.</param>
 private void DrawGamePlay(GameTime gameTime)
 {
     if (Globals.IsWaterEffectEnabled)
     {
         WaterEffectBegin();
     }
     //Map npcs objs magic sprite
     MapBase.Instance.Draw(_spriteBatch);
     //Player
     Globals.ThePlayer.Draw(_spriteBatch);
     //Weather
     WeatherManager.Draw(_spriteBatch);
     //Super magic
     if (Globals.IsInSuperMagicMode)
     {
         Globals.SuperModeMagicSprite.Draw(_spriteBatch);
     }
     if (Globals.IsWaterEffectEnabled)
     {
         WaterEffectEnd(gameTime);
     }
     //Fade in, fade out
     if (ScriptExecuter.IsInFadeIn || ScriptExecuter.IsInFadeOut)
     {
         ScriptExecuter.DrawFade(_spriteBatch);
     }
 }
Example #6
0
        private void btTest_Click(object sender, EventArgs e)
        {
            ScriptExecuter.init();
            Dictionary <String, String> rec = new Dictionary <string, string>();

            rec.Add("Customer_Text", "北京车到网络科技有限公司");
            rec.Add("Product_Code", "95#");
            rec.Add("Product_Price", "4.5");
            rec.Add("Amount", "300");
            rec.Add("Product_Number", "30");
            ScriptExecuter.readScript("tmp_" + ScriptExecuter.default_script_fn);
            int res = ScriptExecuter.execute(rec);

            if (res != 0)
            {
                Trace.WriteLine(String.Format("Execute res {0:d}", res));
                MessageBox.Show("执行失败,请联系技术支持");
            }
            else
            {
                if (MessageBox.Show(this, "脚本执行完成,请检查发票信息是否成功注入,如没有,请联系技术支持", "确认", MessageBoxButtons.YesNo) == DialogResult.Yes)
                {
                    this.DialogResult = DialogResult.OK;
                    File.Copy("tmp_" + ScriptExecuter.default_script_fn, ScriptExecuter.default_script_fn);
                    this.Close();
                }
            }
        }
Example #7
0
        private static void SaveGameFile()
        {
            var data = new IniData();

            //State
            data.Sections.AddSection("State");
            var state = data["State"];

            state.AddKey("Map", Globals.TheMap.MapFileNameWithoutExtension + ".map");
            state.AddKey("Npc", NpcManager.FileName);
            state.AddKey("Obj", ObjManager.FileName);
            state.AddKey("Bgm", BackgroundMusic.FileName);
            state.AddKey("Chr", Globals.PlayerIndex.ToString());
            state.AddKey("Time", string.Format(
                             "{0:yyyy} 年{0:MM} 月{0:dd} 日 {0:HH} 时{0:mm} 分{0:ss} 秒",
                             DateTime.Now));

            //Save npc obj
            NpcManager.SaveNpc();
            ObjManager.Save();

            //Option
            data.Sections.AddSection("Option");
            var option = data["Option"];

            option.AddKey("MapTime", Map.MapTime.ToString());
            option.AddKey("SnowShow", (WeatherManager.IsSnowing ? 1 : 0).ToString());
            option.AddKey("RainFile", WeatherManager.IsRaining ? WeatherManager.RainFileName : "");
            option.AddKey("Water", Globals.IsWaterEffectEnabled ? "1" : "0");
            option.AddKey("MpcStyle", StorageBase.GetStringFromColor(Map.DrawColor));
            option.AddKey("AsfStyle", StorageBase.GetStringFromColor(Sprite.DrawColor));

            //Timer
            data.Sections.AddSection("Timer");
            var timer = data["Timer"];

            timer.AddKey("IsOn", GuiManager.IsTimerStarted() ? "1" : "0");
            if (GuiManager.IsTimerStarted())
            {
                timer.AddKey("TotalSecond", GuiManager.GetTimerCurrentSeconds().ToString());
                timer.AddKey("IsTimerWindowShow", GuiManager.IsTimerWindowHided() ? "0" : "1");
                timer.AddKey("IsScriptSet", ScriptExecuter.IsTimeScriptSet ? "1" : "0");
                timer.AddKey("TimerScript", ScriptExecuter.TimeScriptFileName);
                timer.AddKey("TriggerTime", ScriptExecuter.TimeScriptSeconds.ToString());
            }

            //Variables
            data.Sections.AddSection("Var");
            ScriptExecuter.SaveVariables(data["Var"]);

            //Wirte to file
            File.WriteAllText(StorageBase.GameIniFilePath, data.ToString(), Globals.LocalEncoding);
        }
Example #8
0
 public static int init()
 {
     ScriptExecuter.init();
     status = -1;
     if (ScriptExecuter.readScript("chedaoshuikong_cfg.txt") != true)
     {
         return(-1);
     }
     status = 0;
     ScriptExecuter.debug_level = Program.trace_sw.Level;
     return(0);
 }
Example #9
0
        /// <summary>
        /// This is called when the game should draw itself.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Draw(GameTime gameTime)
        {
            //Update fps measurer
            Fps.Update(gameTime);

            GraphicsDevice.Clear(BackgroundColor);
            _spriteBatch.Begin(SpriteSortMode.Deferred, null);
            if (ScriptExecuter.IsInPlayingMovie)//Movie
            {
                ScriptExecuter.DrawVideo(_spriteBatch);
            }
            else
            {
                switch (GameState.State)
                {
                case GameState.StateType.Start:
                    break;

                case GameState.StateType.Title:
                    break;

                case GameState.StateType.Playing:
                    DrawGamePlay(gameTime);
                    if (Globals.ShowMapPos || Globals.ScriptShowMapPos)
                    {
                        DrawMapPos(_spriteBatch);
                    }
                    break;

                case GameState.StateType.EndAds:
                    DrawAds(gameTime);
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
                //GUI
                GuiManager.Draw(_spriteBatch);
            }

            if (IsInEditMode)
            {
                DrawGameInfo(_spriteBatch);
            }

            _spriteBatch.End();

            base.Draw(gameTime);
        }
Example #10
0
        public static int SendRecipt(CheRequest req)
        {
            if (status != 0)
            {
                return(-1);
            }
            Dictionary <String, String> rec = new Dictionary <string, string>();

            rec.Add("Customer_Text", req.Customer_Text);
            rec.Add("Product_Code", req.Product_Code);
            rec.Add("Product_Price", req.Product_Price);
            rec.Add("Amount", req.Amount);
            rec.Add("Product_Number", req.Product_Number);
            rec.Add("Product_Type", req.Product_Type);
            rec.Add("Pump_Number", req.Pump_Number);
            return(ScriptExecuter.execute(rec));
        }
Example #11
0
        private static void ShowSaveLoad(bool isShow, bool canSave)
        {
            SaveLoadInterface.IsShow  = isShow;
            SaveLoadInterface.CanSave = canSave;

            if (!isShow)
            {
                switch (GameState.State)
                {
                case GameState.StateType.Title:
                    ScriptExecuter.ReturnToTitle();
                    break;

                case GameState.StateType.Playing:
                    break;
                }
            }
        }
Example #12
0
        private void btTest_Click(object sender, EventArgs e)
        {
            ScriptExecuter.init();
            Dictionary <String, String> rec = new Dictionary <string, string>();

            rec.Add("Customer_Text", "北京车到网络科技有限公司");
            rec.Add("Product_Code", "95#");
            rec.Add("Product_Price", "4.5");
            rec.Add("Amount", "300");
            rec.Add("Product_Number", "30");
            ScriptExecuter.readScript("chedaoshuikong_cfg.txt");
            int res = ScriptExecuter.execute(rec);

            if (res != 0)
            {
                Trace.WriteLine(String.Format("Execute res {0:d}", res));
            }
        }
Example #13
0
        /// <summary>
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input, and playing audio.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Update(GameTime gameTime)
        {
            //Update mouse scroll state.
            MouseScrollHandler.Update();

            UpdateGameActiveState(gameTime);

            if (IsPaused || IsFocusLost)
            {
                base.Update(gameTime);
                SuppressDraw();
                return;
            }

            var mouseState    = Mouse.GetState();
            var keyboardState = Keyboard.GetState();

            //Fullscreen toggle
            if (!IsInEditMode &&
                (keyboardState.IsKeyDown(Keys.LeftAlt) || keyboardState.IsKeyDown(Keys.RightAlt)))
            {
                if (keyboardState.IsKeyDown(Keys.Enter) &&
                    LastKeyboardState.IsKeyUp(Keys.Enter))
                {
                    _graphics.ToggleFullScreen();
                    Globals.IsFullScreen = !Globals.IsFullScreen;
                }
            }

            //Map layer draw toggle
            if (IsInEditMode)
            {
                if (keyboardState.IsKeyDown(Keys.D1) && LastKeyboardState.IsKeyUp(Keys.D1))
                {
                    MapBase.SwitchLayerDraw(0);
                }
                if (keyboardState.IsKeyDown(Keys.D2) && LastKeyboardState.IsKeyUp(Keys.D2))
                {
                    MapBase.SwitchLayerDraw(1);
                }
                if (keyboardState.IsKeyDown(Keys.D3) && LastKeyboardState.IsKeyUp(Keys.D3))
                {
                    MapBase.SwitchLayerDraw(2);
                }
                if (keyboardState.IsKeyDown(Keys.D4) && LastKeyboardState.IsKeyUp(Keys.D4))
                {
                    MapBase.SwitchLayerDraw(3);
                }
                if (keyboardState.IsKeyDown(Keys.D5) && LastKeyboardState.IsKeyUp(Keys.D5))
                {
                    MapBase.SwitchLayerDraw(4);
                }
            }

            if (ScriptExecuter.IsInPlayingMovie)
            {
                //Stop movie when Esc key pressed
                if (keyboardState.IsKeyDown(Keys.Escape) &&
                    LastKeyboardState.IsKeyUp(Keys.Escape))
                {
                    ScriptExecuter.StopMovie();
                }
            }
            else
            {
                //Update GUI first, GUI will decide whether user input be intercepted or pass through
                GuiManager.Update(gameTime);

                switch (GameState.State)
                {
                case GameState.StateType.Start:
                    ScriptManager.RunScript(Utils.GetScriptParser("title.txt"));
                    GameState.State = GameState.StateType.Title;
                    break;

                case GameState.StateType.Title:
                    break;

                case GameState.StateType.Playing:
                    if (IsGamePlayPaused)
                    {
                        break;
                    }
                    UpdatePlaying(gameTime);
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
            }

            //Update script after GuiManager, because script executing rely GUI state.
            ScriptManager.Update(gameTime);

            LastKeyboardState = Keyboard.GetState();
            LastMouseState    = mouseState;

            base.Update(gameTime);
        }
Example #14
0
 public static void NewGame()
 {
     ScriptExecuter.RunScript("NewGame.txt");
 }
Example #15
0
        public static void Update(GameTime gameTime)
        {
            //To avoid Sleep() script function end early, update ScriptExecuter first.
            ScriptExecuter.Update(gameTime);

            for (var node = _list.First; node != null;)
            {
                var runner = node.Value;
                LogScriptFilePath(runner);

                if (!runner.Continue())
                {
                    //Remove current
                    _list.Remove(node);
                    //Get next
                    node = _list.First;
                }
                else
                {
                    //Can't run multiple script at same time
                    break;
                }
            }

            //New item may added when script run, count items added before this frame.
            var itemSum = _parallelListDelayed.Count;
            var count   = 0;

            for (var node = _parallelListDelayed.First; node != null && count < itemSum; count++)
            {
                var item = node.Value;
                if (item.WaitMilliseconds > 0)
                {
                    item.WaitMilliseconds -= (float)gameTime.ElapsedGameTime.TotalMilliseconds;
                }

                if (item.WaitMilliseconds <= 0)
                {
                    item.CheckCreateScriptRunner();
                }

                if (item.ScriptInRun != null)
                {
                    LogScriptFilePath(item.ScriptInRun);
                    if (!item.ScriptInRun.Continue())
                    {
                        _parallelListDelayed.Remove(node);
                    }
                }

                node = node.Next;
            }

            for (var node = _parallelListImmediately.First; node != null;)
            {
                var item = node.Value;
                item.CheckCreateScriptRunner();

                LogScriptFilePath(item.ScriptInRun);
                var continueRun = item.ScriptInRun.Continue();
                var next        = node.Next; //Get next here, new item may added after script run.
                if (!continueRun)
                {
                    _parallelListImmediately.Remove(node);
                }
                node = next;
            }
        }
Example #16
0
 private void enableNpcAIToolStripMenuItem_Click(object sender, EventArgs e)
 {
     ScriptExecuter.EnableNpcAI();
 }
Example #17
0
        /// <summary>
        /// RunCode
        /// </summary>
        /// <param name="code">Code to run</param>
        /// <param name="gotoPosition"></param>
        /// <param name="scriptEnd">Script is returned if true</param>
        /// <returns>True if code runed, false if code is running</returns>
        private bool RunCode(int lineIndex, out string gotoPosition, out bool scriptEnd)
        {
            gotoPosition = null;
            scriptEnd    = false;

            var code = _targetScript.GetCode(lineIndex);

            if (code == null ||
                code.IsGoto ||
                string.IsNullOrEmpty(code.Name))
            {
                return(true);
            }

            var isEnd = true;

            try
            {
                if (_currentCode != null)
                {
                    switch (_currentCode.Name)
                    {
                    case "Say":
                        isEnd = ScriptExecuter.IsSayEnd();
                        break;

                    case "FadeOut":
                        isEnd = ScriptExecuter.IsFadeOutEnd();
                        break;

                    case "FadeIn":
                        isEnd = ScriptExecuter.IsFadeInEnd();
                        break;

                    case "Talk":
                        isEnd = !ScriptExecuter.IsInTalk;
                        break;

                    case "Choose":
                    case "Select":
                        isEnd = ScriptExecuter.IsChooseEnd(_currentCode.Parameters);
                        break;

                    case "ChooseEx":
                        isEnd = ScriptExecuter.IsChooseExEnd(_currentCode.Parameters);
                        break;

                    case "PlayMovie":
                        isEnd = !ScriptExecuter.IsInPlayingMovie;
                        break;

                    case "PlayerGoto":
                        isEnd = ScriptExecuter.IsPlayerGotoEnd();
                        break;

                    case "PlayerGotoDir":
                        isEnd = ScriptExecuter.IsPlayerGotoDirEnd();
                        break;

                    case "PlayerJumpTo":
                        isEnd = ScriptExecuter.IsPlayerJumpToEnd();
                        break;

                    case "PlayerRunTo":
                        isEnd = ScriptExecuter.IsPlayerRunToEnd();
                        break;

                    case "NpcGoto":
                        isEnd = ScriptExecuter.IsNpcGotoEnd(_currentCode.Parameters,
                                                            BelongObject);
                        break;

                    case "NpcGotoDir":
                        isEnd = ScriptExecuter.IsNpcGotoDirEnd(_currentCode.Parameters,
                                                               BelongObject);
                        break;

                    case "MoveScreen":
                        isEnd = ScriptExecuter.IsMoveScreenEnd();
                        break;

                    case "MoveScreenEx":
                        isEnd = ScriptExecuter.IsMoveScreenExEnd();
                        break;

                    case "SellGoods":
                    case "BuyGoods":
                    case "BuyGoodsOnly":
                        isEnd = ScriptExecuter.IsBuyGoodsEnd();
                        break;

                    case "NpcSpecialActionEx":
                        isEnd = ScriptExecuter.IsNpcSpecialActionExEnd(_currentCode.Parameters, BelongObject);
                        break;

                    case "Sleep":
                        isEnd = ScriptExecuter.IsSleepEnd();
                        break;
                    }
                }
                else
                {
                    _currentCode = code;
                    var parameters = _currentCode.Parameters;

                    //Send message to register
                    Globals.TheMessageSender.SendFunctionCallMessage(ToMessageString(_currentCode));

                    switch (_currentCode.Name)
                    {
                    case "Say":
                        ScriptExecuter.Say(parameters);
                        isEnd = ScriptExecuter.IsSayEnd();
                        break;

                    case "If":
                        if (ScriptExecuter.If(parameters))
                        {
                            if (_currentCode.Result == "Return")
                            {
                                scriptEnd = true;
                            }
                            else
                            {
                                gotoPosition = _currentCode.Result;
                            }
                        }
                        break;

                    case "Return":
                        scriptEnd = true;
                        break;

                    case "Goto":
                        gotoPosition = _currentCode.Parameters.Count != 0
                                ? _currentCode.Parameters[0]
                                : _currentCode.Result;
                        break;

                    case "Add":
                        ScriptExecuter.Add(parameters);
                        break;

                    case "Assign":
                        ScriptExecuter.Assign(parameters);
                        break;

                    case "FadeOut":
                        ScriptExecuter.FadeOut();
                        isEnd = ScriptExecuter.IsFadeOutEnd();
                        break;

                    case "FadeIn":
                        ScriptExecuter.FadeIn();
                        isEnd = ScriptExecuter.IsFadeInEnd();
                        break;

                    case "DelNpc":
                        ScriptExecuter.DelNpc(parameters);
                        break;

                    case "ClearBody":
                        ScriptExecuter.ClearBody();
                        break;

                    case "StopMusic":
                        ScriptExecuter.StopMusic();
                        break;

                    case "PlayMusic":
                        ScriptExecuter.PlayMusic(parameters);
                        break;

                    case "PlaySound":
                        ScriptExecuter.PlaySound(parameters, BelongObject);
                        break;

                    case "OpenBox":
                        ScriptExecuter.OpenBox(parameters, BelongObject);
                        break;

                    case "CloseBox":
                        ScriptExecuter.CloseBox(parameters, BelongObject);
                        break;

                    case "OpenObj":
                        ScriptExecuter.OpenBox(parameters, BelongObject);
                        break;

                    case "SetObjScript":
                        ScriptExecuter.SetObjScript(parameters, BelongObject);
                        break;

                    case "SetNpcScript":
                        ScriptExecuter.SetNpcScript(parameters, BelongObject);
                        break;

                    case "SetNpcDeathScript":
                        ScriptExecuter.SetNpcDeathScript(parameters, BelongObject);
                        break;

                    case "SetNpcLevel":
                        ScriptExecuter.SetNpcLevel(parameters, BelongObject);
                        break;

                    case "SetLevelFile":
                        ScriptExecuter.SetLevelFile(parameters, BelongObject);
                        break;

                    case "AddRandMoney":
                        ScriptExecuter.AddRandMoney(parameters);
                        break;

                    case "AddLife":
                        ScriptExecuter.AddLife(parameters);
                        break;

                    case "AddThew":
                        ScriptExecuter.AddThew(parameters);
                        break;

                    case "AddMana":
                        ScriptExecuter.AddMana(parameters);
                        break;

                    case "AddExp":
                        ScriptExecuter.AddExp(parameters);
                        break;

                    case "SetPlayerPos":
                        ScriptExecuter.SetPlayerPos(parameters);
                        break;

                    case "SetPlayerDir":
                        ScriptExecuter.SetPlayerDir(parameters);
                        break;

                    case "LoadMap":
                        ScriptExecuter.LoadMap(parameters);
                        break;

                    case "LoadNpc":
                        ScriptExecuter.LoadNpc(parameters);
                        break;

                    case "MergeNpc":
                        ScriptExecuter.MergeNpc(parameters);
                        break;

                    case "LoadObj":
                        ScriptExecuter.LoadObj(parameters);
                        break;

                    case "AddNpc":
                        ScriptExecuter.AddNpc(parameters);
                        break;

                    case "AddObj":
                        ScriptExecuter.AddObj(parameters);
                        break;

                    case "AddGoods":
                        ScriptExecuter.AddGoods(parameters);
                        break;

                    case "AddRandGoods":
                        ScriptExecuter.AddRandGoods(parameters);
                        break;

                    case "AddMagic":
                        ScriptExecuter.AddMagic(parameters);
                        break;

                    case "AddMoney":
                        ScriptExecuter.AddMoney(parameters);
                        break;

                    case "Talk":
                        ScriptExecuter.Talk(parameters);
                        isEnd = !ScriptExecuter.IsInTalk;
                        break;

                    case "Memo":
                        ScriptExecuter.Memo(parameters);
                        break;

                    case "AddToMemo":
                        ScriptExecuter.AddToMemo(parameters);
                        break;

                    case "DelGoods":
                        ScriptExecuter.DelGoods(parameters, BelongObject);
                        break;

                    case "DelCurObj":
                        ScriptExecuter.DelCurObj(BelongObject);
                        break;

                    case "DelObj":
                        ScriptExecuter.DelObj(parameters, BelongObject);
                        break;

                    case "FreeMap":
                        ScriptExecuter.FreeMap();
                        break;

                    case "SetTrap":
                        ScriptExecuter.SetTrap(parameters);
                        break;

                    case "SetMapTrap":
                        ScriptExecuter.SetMapTrap(parameters);
                        break;

                    case "SetMapTime":
                        MapBase.MapTime = int.Parse(parameters[0]);
                        break;

                    case "FullLife":
                        ScriptExecuter.FullLife();
                        break;

                    case "FullMana":
                        ScriptExecuter.FullMana();
                        break;

                    case "FullThew":
                        ScriptExecuter.FullThew();
                        break;

                    case "ShowNpc":
                        ScriptExecuter.ShowNpc(parameters);
                        break;

                    case "Sleep":
                        ScriptExecuter.Sleep(parameters);
                        isEnd = ScriptExecuter.IsSleepEnd();
                        break;

                    case "ShowMessage":
                        ScriptExecuter.ShowMessage(parameters);
                        break;

                    case "DisplayMessage":
                        ScriptExecuter.DisplayMessage(parameters);
                        break;

                    case "SetMagicLevel":
                        ScriptExecuter.SetMagicLevel(parameters);
                        break;

                    case "ShowSnow":
                        ScriptExecuter.ShowSnow(parameters);
                        break;

                    case "BeginRain":
                        ScriptExecuter.BeginRain(parameters);
                        break;

                    case "EndRain":
                        ScriptExecuter.EndRain();
                        break;

                    case "ChangeMapColor":
                        ScriptExecuter.ChangeMapColor(parameters);
                        break;

                    case "ChangeAsfColor":
                        ScriptExecuter.ChangeAsfColor(parameters);
                        break;

                    case "Choose":
                        ScriptExecuter.Choose(parameters);
                        isEnd = false;
                        break;

                    case "Select":
                        ScriptExecuter.Select(parameters);
                        isEnd = false;
                        break;

                    case "ChooseEx":
                        ScriptExecuter.ChooseEx(parameters);
                        isEnd = false;
                        break;

                    case "RunScript":
                        ScriptExecuter.RunScript(parameters, BelongObject);
                        break;

                    case "RunParallelScript":
                        ScriptExecuter.RunParallelScript(parameters, BelongObject);
                        break;

                    case "PlayMovie":
                        ScriptExecuter.PlayMovie(parameters);
                        isEnd = !ScriptExecuter.IsInPlayingMovie;
                        break;

                    case "SaveMapTrap":
                        ScriptExecuter.SaveMapTrap();
                        break;

                    case "SaveNpc":
                        ScriptExecuter.SaveNpc(parameters);
                        break;

                    case "SaveObj":
                        ScriptExecuter.SaveObj(parameters);
                        break;

                    case "GetRandNum":
                        ScriptExecuter.GetRandNum(parameters);
                        break;

                    case "SetNpcDir":
                        ScriptExecuter.SetNpcDir(parameters, BelongObject);
                        break;

                    case "SetNpcKind":
                        ScriptExecuter.SetNpcKind(parameters, BelongObject);
                        break;

                    case "SetNpcMagicFile":
                        ScriptExecuter.SetNpcMagicFile(parameters, BelongObject);
                        break;

                    case "SetNpcPos":
                        ScriptExecuter.SetNpcPos(parameters, BelongObject);
                        break;

                    case "SetNpcRelation":
                        ScriptExecuter.SetNpcRelation(parameters, BelongObject);
                        break;

                    case "SetNpcRes":
                        ScriptExecuter.SetNpcRes(parameters, BelongObject);
                        break;

                    case "SetNpcAction":
                        ScriptExecuter.SetNpcAction(parameters);
                        break;

                    case "SetNpcActionFile":
                        ScriptExecuter.SetNpcActionFile(parameters);
                        break;

                    case "SetNpcActionType":
                        ScriptExecuter.SetNpcActionType(parameters, BelongObject);
                        break;

                    case "Watch":
                        ScriptExecuter.Watch(parameters);
                        break;

                    case "SetObjOfs":
                        ScriptExecuter.SetObjOfs(parameters, BelongObject);
                        break;

                    case "DisableFight":
                        ScriptExecuter.DisableFight();
                        break;

                    case "EnableFight":
                        ScriptExecuter.EnableFight();
                        break;

                    case "DisableInput":
                        ScriptExecuter.DisableInput();
                        break;

                    case "EnableInput":
                        ScriptExecuter.EnableInput();
                        break;

                    case "DisableJump":
                        ScriptExecuter.DisableJump();
                        break;

                    case "EnableJump":
                        ScriptExecuter.EnableJump();
                        break;

                    case "DisableNpcAI":
                        ScriptExecuter.DisableNpcAI();
                        break;

                    case "EnableNpcAI":
                        ScriptExecuter.EnableNpcAI();
                        break;

                    case "DisableRun":
                        ScriptExecuter.DisableRun();
                        break;

                    case "EnableRun":
                        ScriptExecuter.EnableRun();
                        break;

                    case "SetPlayerState":
                        ScriptExecuter.SetPlayerState(parameters);
                        break;

                    case "OpenWaterEffect":
                        ScriptExecuter.OpenWaterEffect();
                        break;

                    case "CloseWaterEffect":
                        ScriptExecuter.CloseWaterEffect();
                        break;

                    case "PlayerGoto":
                        ScriptExecuter.PlayerGoto(parameters);
                        isEnd = ScriptExecuter.IsPlayerGotoEnd();
                        break;

                    case "PlayerGotoDir":
                        ScriptExecuter.PlayerGotoDir(parameters);
                        isEnd = ScriptExecuter.IsPlayerGotoDirEnd();
                        break;

                    case "PlayerGotoEx":
                        ScriptExecuter.PlayerGotoEx(parameters);
                        break;

                    case "PlayerJumpTo":
                        ScriptExecuter.PlayerJumpTo(parameters);
                        isEnd = ScriptExecuter.IsPlayerJumpToEnd();
                        break;

                    case "PlayerRunTo":
                        ScriptExecuter.PlayerRunTo(parameters);
                        isEnd = ScriptExecuter.IsPlayerRunToEnd();
                        break;

                    case "PlayerRunToEx":
                        ScriptExecuter.PlayerRunToEx(parameters);
                        break;

                    case "NpcGoto":
                        ScriptExecuter.NpcGoto(parameters, BelongObject);
                        isEnd = ScriptExecuter.IsNpcGotoEnd(parameters, BelongObject);
                        break;

                    case "NpcGotoDir":
                        ScriptExecuter.NpcGotoDir(parameters, BelongObject);
                        isEnd = ScriptExecuter.IsNpcGotoDirEnd(parameters, BelongObject);
                        break;

                    case "NpcGotoEx":
                        ScriptExecuter.NpcGotoEx(parameters, BelongObject);
                        break;

                    case "SetMoneyNum":
                        ScriptExecuter.SetMoneyNum(parameters);
                        break;

                    case "GetMoneyNum":
                        ScriptExecuter.GetMoneyNum(parameters);
                        break;

                    case "SetPlayerScn":
                        ScriptExecuter.SetPlayerScn();
                        break;

                    case "MoveScreen":
                        ScriptExecuter.MoveScreen(parameters);
                        isEnd = ScriptExecuter.IsMoveScreenEnd();
                        break;

                    case "MoveScreenEx":
                        ScriptExecuter.MoveScreenEx(parameters);
                        isEnd = ScriptExecuter.IsMoveScreenExEnd();
                        break;

                    case "SetMapPos":
                        ScriptExecuter.SetMapPos(parameters);
                        break;

                    case "EquipGoods":
                        ScriptExecuter.EquipGoods(parameters);
                        break;

                    case "SellGoods":
                    case "BuyGoods":
                        ScriptExecuter.BuyGoods(parameters, true, BelongObject);
                        isEnd = ScriptExecuter.IsBuyGoodsEnd();
                        break;

                    case "BuyGoodsOnly":
                        ScriptExecuter.BuyGoods(parameters, false, BelongObject);
                        isEnd = ScriptExecuter.IsBuyGoodsEnd();
                        break;

                    case "OpenTimeLimit":
                        ScriptExecuter.OpenTimeLimit(parameters);
                        break;

                    case "CloseTimeLimit":
                        ScriptExecuter.CloseTimeLimit();
                        break;

                    case "HideTimerWnd":
                        ScriptExecuter.HideTimerWnd();
                        break;

                    case "SetTimeScript":
                        ScriptExecuter.SetTimeScript(parameters);
                        break;

                    case "GetGoodsNum":
                        ScriptExecuter.GetGoodsNum(parameters);
                        break;

                    case "GetNpcCount":
                        ScriptExecuter.GetNpcCount(parameters);
                        break;

                    case "LimitMana":
                        ScriptExecuter.LimitMana(parameters);
                        break;

                    case "NpcAttack":
                        ScriptExecuter.NpcAttack(parameters, BelongObject);
                        break;

                    case "FollowNpc":
                        ScriptExecuter.FollowNpc(parameters, BelongObject);
                        break;

                    case "NpcSpecialAction":
                        ScriptExecuter.NpcSpecialAction(parameters, BelongObject);
                        break;

                    case "NpcSpecialActionEx":
                        ScriptExecuter.NpcSpecialActionEx(parameters, BelongObject);
                        isEnd = ScriptExecuter.IsNpcSpecialActionExEnd(parameters, BelongObject);
                        break;

                    case "LoadGame":
                        ScriptExecuter.LoadGame(parameters);
                        break;

                    case "PlayerChange":
                        ScriptExecuter.PlayerChange(parameters);
                        break;

                    case "ReturnToTitle":
                        ScriptExecuter.ReturnToTitle();
                        break;

                    case "GetPartnerIdx":
                        ScriptExecuter.GetPartnerIdx(parameters);
                        break;

                    case "GetExp":
                        ScriptExecuter.GetPlayerExp(parameters);
                        break;

                    case "ClearAllVar":
                        ScriptExecuter.ClearAllVar(parameters);
                        break;

                    case "SetDropIni":
                        ScriptExecuter.SetDropIni(parameters);
                        break;

                    case "ClearAllSave":
                        ScriptExecuter.ClearAllSave(parameters);
                        break;

                    case "EnableSave":
                        ScriptExecuter.EnableSave(parameters);
                        break;

                    case "DisableSave":
                        ScriptExecuter.DisableSave(parameters);
                        break;

                    case "CheckFreeGoodsSpace":
                        ScriptExecuter.CheckFreeGoodsSpace(parameters);
                        break;

                    case "CheckFreeMagicSpace":
                        ScriptExecuter.CheckFreeMagicSpace(parameters);
                        break;

                    case "GetPlayerState":
                        ScriptExecuter.GetPlayerState(parameters);
                        break;

                    case "GetPlayerMagicLevel":
                        ScriptExecuter.GetPlayerMagicLevel(parameters);
                        break;

                    case "EnabelDrop":
                        ScriptExecuter.EnabelDrop(parameters);
                        break;

                    case "DisableDrop":
                        ScriptExecuter.DisableDrop(parameters);
                        break;

                    case "ClearGoods":
                        ScriptExecuter.ClearGoods(parameters);
                        break;

                    case "ClearMagic":
                        ScriptExecuter.ClearMagic(parameters);
                        break;

                    case "AddMoveSpeedPercent":
                        ScriptExecuter.AddMoveSpeedPercent(parameters);
                        break;

                    case "UseMagic":
                        ScriptExecuter.UseMagic(parameters);
                        break;

                    case "IsEquipWeapon":
                        ScriptExecuter.IsEquipWeapon(parameters);
                        break;

                    case "AddAttack":
                        ScriptExecuter.AddAttack(parameters);
                        break;

                    case "AddDefend":
                        ScriptExecuter.AddDefend(parameters);
                        break;

                    case "AddEvade":
                        ScriptExecuter.AddEvade(parameters);
                        break;

                    case "AddLifeMax":
                        ScriptExecuter.AddLifeMax(parameters);
                        break;

                    case "AddManaMax":
                        ScriptExecuter.AddManaMax(parameters);
                        break;

                    case "AddThewMax":
                        ScriptExecuter.AddThewMax(parameters);
                        break;

                    case "DelMagic":
                        ScriptExecuter.DelMagic(parameters);
                        break;

                    default:
                        throw new Exception("无此函数");
                    }
                }
            }
            catch (Exception exception)
            {
                string fullPath;
                try
                {
                    fullPath = Path.GetFullPath(_targetScript.FilePath);
                }
                catch (Exception)
                {
                    fullPath = _targetScript.FilePath;
                }
                var message = "Script error! File: " + fullPath + ".";
                if (_currentCode != null)
                {
                    message += ("\nCode: " + _currentCode.Literal);
                }
                message += "\n" + exception.Message + "\n" + Log.GetLastLine(exception);
                Log.LogMessage(message);
                if (Globals.TheGame.IsInEditMode)
                {
                    MessageBox.Show(message);
                }
            }

            if (isEnd)
            {
                _currentCode = null;
            }
            return(isEnd);
        }
Example #18
0
 public static string getLastError()
 {
     return(ScriptExecuter.getLastError());
 }
Example #19
0
        private static void LoadGameFile()
        {
            try
            {
                var parser = new FileIniDataParser();
                var data   = parser.ReadFile(StorageBase.GameIniFilePath);

                //state
                var state = data["State"];
                MapBase.OpenMap(state["Map"]);
                NpcManager.Load(state["Npc"]);
                ObjManager.Load(state["Obj"]);
                BackgroundMusic.Play(state["Bgm"]);
                Globals.PlayerIndex = int.Parse(state["Chr"]);

                //option
                var option = data["Option"];
                MapBase.MapTime = int.Parse(option["MapTime"]);
                WeatherManager.ShowSnow(int.Parse(option["SnowShow"]) != 0);
                if (!string.IsNullOrEmpty(option["RainFile"]))
                {
                    WeatherManager.BeginRain(option["RainFile"]);
                }
                if (string.IsNullOrEmpty(option["Water"]))
                {
                    Globals.IsWaterEffectEnabled = false;
                }
                else
                {
                    Globals.IsWaterEffectEnabled = int.Parse(option["Water"]) != 0;
                }
                if (string.IsNullOrEmpty(option["MpcStyle"]))
                {
                    MapBase.DrawColor = Color.White;
                }
                else
                {
                    MapBase.DrawColor = StorageBase.GetColorFromString(option["MpcStyle"]);
                }
                if (string.IsNullOrEmpty(option["AsfStyle"]))
                {
                    Sprite.DrawColor = Color.White;
                }
                else
                {
                    Sprite.DrawColor = StorageBase.GetColorFromString(option["AsfStyle"]);
                }
                if (string.IsNullOrEmpty(option["SaveDisabled"]))
                {
                    Globals.IsSaveDisabled = false;
                }
                else
                {
                    Globals.IsSaveDisabled = int.Parse(option["SaveDisabled"]) > 0;
                }
                if (string.IsNullOrEmpty(option["IsDropGoodWhenDefeatEnemyDisabled"]))
                {
                    Globals.IsDropGoodWhenDefeatEnemyDisabled = false;
                }
                else
                {
                    Globals.IsDropGoodWhenDefeatEnemyDisabled = int.Parse(option["IsDropGoodWhenDefeatEnemyDisabled"]) > 0;
                }
                //Timer
                var timer = data["Timer"];
                if (timer != null)
                {
                    var isOn = timer["IsOn"] != "0";
                    if (isOn)
                    {
                        ScriptExecuter.OpenTimeLimit(int.Parse(timer["TotalSecond"]));
                        var isHide = timer["IsTimerWindowShow"] != "1";
                        if (isHide)
                        {
                            ScriptExecuter.HideTimerWnd();
                        }
                        if (timer["IsScriptSet"] != "0")
                        {
                            ScriptExecuter.SetTimeScript(int.Parse(timer["TriggerTime"]),
                                                         timer["TimerScript"]);
                        }
                    }
                }

                //Variables
                ScriptExecuter.LoadVariables(data["Var"]);

                //ParallelScript
                ScriptManager.LoadParallelScript(data["ParallelScript"]);
            }
            catch (Exception exception)
            {
                Log.LogFileLoadError("Game.ini", StorageBase.GameIniFilePath, exception);
            }
        }