//フォントを変更
        void FontChange(bool autoSave)
        {
            Font arialFont = Resources.GetBuiltinResource(typeof(Font), "Arial.ttf") as Font;

            if (this.UiFont == arialFont)
            {
                return;
            }
            if (this.UiFont == null)
            {
                return;
            }

            //シーンをセーブ
            if (autoSave)
            {
                WrapperUnityVersion.SaveScene();
            }
            else
            {
                if (!WrapperUnityVersion.SaveCurrentSceneIfUserWantsTo())
                {
                    return;
                }
            }

            Debug.Log("Font Change Arial to " + this.UiFont.name);
            AssetDatabase.Refresh();
            ReferenceAssetChanger.FindAndChangeAll(arialFont, UiFont, this.newProjectDir);
        }
Example #2
0
        /// <summary>
        /// 文字列で書かれた、スケール値を読みとる
        /// </summary>
        /// <param name="text">テキスト</param>
        /// <param name="defaultValue">デフォルト値</param>
        /// <returns>スケール値。文字列が設定されてなかったらデフォルト値を。解析できなかったら例外を投げる</returns>
        public static Vector3 ParseScale3DOptional(string text, Vector3 defaultValue)
        {
            //何も設定がなければデフォルト値を
            if (string.IsNullOrEmpty(text))
            {
                return(defaultValue);
            }

            Vector3 scale = defaultValue;

            //数字だけが書かれていた場合はx,yを同じ値として扱う
            float s;

            if (WrapperUnityVersion.TryParseFloatGlobal(text, out s))
            {
                return(Vector3.one * s);
            }

            if (ParserUtil.TryParseVector3Optional(text, scale, out scale))
            {
                return(scale);
            }
            else
            {
                throw new System.Exception("Parse Scale3D Error " + text);
            }
        }
Example #3
0
        //CharacterInfo(描画用の文字情報)の設定を試行
        public bool TrySetCharacterInfo(Font font)
        {
            if (IsNoFontData)
            {
                return(true);
            }

            if (!font.dynamic)
            {
                if (!font.GetCharacterInfo(charData.Char, out this.charInfo))
                {
                    return(false);
                }
            }
            else if (!font.GetCharacterInfo(charData.Char, out this.charInfo, FontSize, FontStyle))
            {
                return(false);
            }

            this.width  = WrapperUnityVersion.GetCharacterInfoWidth(ref charInfo);
            this.width *= BmpFontScale;
            //ダッシュ
            if (CustomInfo.IsDash)
            {
                width *= CustomInfo.DashSize;
            }
            return(true);
        }
Example #4
0
        float CalcSliderValue(Vector2 point)
        {
            float   t      = 0;
            float   min    = 0;
            float   max    = 0;
            Vector3 pos    = this.transform.position;
            Vector2 offset = WrapperUnityVersion.GetBoxCollider2DOffset(BoxCollider2D);

            switch (direction)
            {
            case Direction.Horizontal:
                min = (pos.x - offset.x) - BoxCollider2D.size.x / 2;
                max = (pos.x - offset.x) + BoxCollider2D.size.x / 2;
                t   = point.x;
                break;

            case Direction.Vertical:
            default:
                min = (pos.y - offset.y) - BoxCollider2D.size.y / 2;
                max = (pos.y - offset.y) + BoxCollider2D.size.y / 2;
                t   = point.y;
                break;
            }
            return(Mathf.InverseLerp(min, max, t));
        }
Example #5
0
        //クローンしたプレハブやScriptableObject内にテンプレートアセットへのリンクがあったら、クローンアセットのものに変える
        void ReplaceCloneInSelf(Dictionary <Object, Object> cloneAssetPair)
        {
            //Valuesはクローンしたアセット
            foreach (Object clone in cloneAssetPair.Values)
            {
                bool isReplaced = false;
                if (WrapperUnityVersion.CheckPrefabAsset(clone))
                {
                    //プレハブの場合
                    GameObject go = clone as GameObject;
                    if (go == null)
                    {
                        Debug.Log(clone.name);
                        continue;
                    }
                    foreach (Component component in go.GetComponentsInChildren <Component>(true))
                    {
                        isReplaced |= UtageEditorToolKit.ReplaceSerializedProperties(new SerializedObject(component), cloneAssetPair);
                    }
                }
                else if (UtageEditorToolKit.IsScriptableObject(clone))
                {
                    //ScriptableObjectの場合
                    isReplaced |= UtageEditorToolKit.ReplaceSerializedProperties(new SerializedObject(clone), cloneAssetPair);
                }

                if (isReplaced)
                {
                    EditorUtility.SetDirty(clone);
                }
            }
        }
Example #6
0
        /// <summary>
        /// 子オブジェクトを含めた全てのスプライトのBoundsでコライダーをリサイズ
        /// </summary>
        /// <param name="col">リサイズするコライダー</param>
        static public void ResizeCollider(BoxCollider2D col)
        {
            Bounds bounds = CalcSpritesBounds(col.gameObject);

            WrapperUnityVersion.SetBoxCollider2DOffset(col, bounds.center);
            col.size = bounds.size;
        }
Example #7
0
        /// <summary>
        /// ゲームのデータをセーブ
        /// </summary>
        /// <param name="engine">ADVエンジン</param>
        /// <param name="tex">セーブアイコン</param>
        public void UpdateAutoSaveData(AdvEngine engine, Texture2D tex, List <IBinaryIO> customSaveIoList, List <IBinaryIO> saveIoList)
        {
            Clear();
            //セーブ対象となる情報を設定
            List <IBinaryIO> ioList = new List <IBinaryIO>()
            {
                engine.ScenarioPlayer,
                engine.Param.DefaultData,
                engine.GraphicManager,
                engine.CameraManager,
                engine.SoundManager,
            };

            ioList.AddRange(customSaveIoList);
            ioList.AddRange(saveIoList);

            //バイナリデータを作成
            Profiler.BeginSample("MakeSaveDataBuffer");
            Buffer.MakeBuffer(ioList);
            Profiler.EndSample();

            Date    = WrapperUnityVersion.DateTimeNow();
            Texture = tex;
            Title   = engine.Page.SaveDataTitle;
        }
Example #8
0
        //キャラクターのパターン変更をキーフレームアニメーションから呼ぶためのメソッド
        public virtual void ChangePatternAnimation(string paraString)
        {
            if (LastResource == null)
            {
                Debug.LogError("ChangePatternAnimationError  LastResource is null");
                return;
            }
            AdvCharacterSettingData characterData = LastResource.SettingData as AdvCharacterSettingData;

            if (characterData == null)
            {
                Debug.LogError("ChangePatternAnimationError  characterData is null");
                return;
            }

            string[] after = paraString.Split(new char[] { ',' });
            float    fadeTime;

            if (after.Length <= 0)
            {
                Debug.LogError("ChangePatternAnimationError  argString = " + paraString);
                return;
            }
            else if (after.Length == 1)
            {
                fadeTime = 0;
            }
            else
            {
                if (!WrapperUnityVersion.TryParseFloatGlobal(after[1], out fadeTime))
                {
                    Debug.LogError("ChangePatternAnimationError  " + after[1] + " is not float string");
                    return;
                }
            }
            //0秒だと、DestroyImmediateが呼ばれてしまうが
            //AnimationClip中でそれが許可されていないため
            fadeTime = Mathf.Max(fadeTime, 0.001f);

            string pattern = after[0];
            AdvCharacterSettingData newPatternData = Engine.DataManager.SettingDataManager.CharacterSetting.GetCharacterData(characterData.Name, pattern);

            if (newPatternData == null)
            {
                Debug.LogError("ChangePatternAnimationError  pattern is not pattern name");
                return;
            }

            //Graphicのロードは考慮しない
            var graphic = newPatternData.Graphic.Main;

            //描画
            DrawSub(graphic, Engine.Page.ToSkippedTime(fadeTime));
            //モーション変更
            if (!string.IsNullOrEmpty(graphic.AnimationState))
            {
                TargetObject.ChangeAnimationState(graphic.AnimationState, fadeTime);
            }
        }
        //キャッシュファイル書き込み
        internal void WriteNewVersion(AssetFileUtage file)
        {
            if (AssetFileManager.DontUseCache)
            {
                return;
            }
            if (AssetFileManager.isOutPutDebugLog)
            {
                Debug.Log("WriteCacheFile:" + file.FileName + " ver:" + file.Version + " cache:" + file.CacheVersion);
            }

            //キャッシュファイル書き込み準備
            file.ReadyToWriteCache(IncCacheID(), CacheRootDir, AssetFileManager.isDebugCacheFileName);
            string cachePath = file.CachePath;

            //キャッシュ用のディレクトリがなければ作成
            FileIOManger.CreateDirectory(cachePath);

            //ファイル書き込み
            bool ret = false;

            if (file.EncodeType == AssetFileEncodeType.EncodeOnCache)
            {
                switch (file.FileType)
                {
                case AssetFileType.Sound:
                    ret = FileIOManger.WriteSound(cachePath, file.WriteCacheFileSound);
                    break;

                case AssetFileType.Texture:
                    ret = FileIOManger.WriteEncodeNoCompress(cachePath, file.CacheWriteBytes);
                    break;

                default:
                    ret = FileIOManger.WriteEncode(cachePath, file.CacheWriteBytes);
                    break;
                }
            }
            else
            {
                ret = FileIOManger.Write(cachePath, file.CacheWriteBytes);
            }

            WrapperUnityVersion.SetNoBackupFlag(cachePath);

            //キャッシュファイルテーブルを更新して上書き
            if (!ret)
            {
                if (AssetFileManager.isOutPutDebugLog)
                {
                    Debug.LogError("Write Failed :" + file.CachePath);
                }
            }
            else
            {
                WriteCacheTbl();
                file.DeleteOldCacheFile();
            }
        }
Example #10
0
 void Awake()
 {
     if (IsDeviceIndicator())
     {
         WrapperUnityVersion.SetActivityIndicatorStyle();
         icon.SetActive(false);
     }
 }
 private void Awake()
 {
     if (this.IsDeviceIndicator())
     {
         WrapperUnityVersion.SetActivityIndicatorStyle();
         this.icon.SetActive(false);
     }
 }
Example #12
0
        /// <summary>
        /// 文字列で書かれた、Vector3を読みとる
        /// </summary>
        public static bool TryParseVector3Optional(string text, Vector3 defaultValue, out Vector3 vec3)
        {
            vec3 = defaultValue;
            if (string.IsNullOrEmpty(text))
            {
                return(false);
            }

            bool ret = false;

            string[] strings;
            {
                char[] separator = { ' ' };
                strings = text.Split(separator, System.StringSplitOptions.RemoveEmptyEntries);
            }
            foreach (string str in strings)
            {
                char[]   separator = { '=' };
                string[] tags      = str.Split(separator, System.StringSplitOptions.RemoveEmptyEntries);
                if (tags.Length == 2)
                {
                    switch (tags[0])
                    {
                    case "x":
                        if (!WrapperUnityVersion.TryParseFloatGlobal(tags[1], out vec3.x))
                        {
                            return(false);
                        }
                        ret = true;
                        break;

                    case "y":
                        if (!WrapperUnityVersion.TryParseFloatGlobal(tags[1], out vec3.y))
                        {
                            return(false);
                        }
                        ret = true;
                        break;

                    case "z":
                        if (!WrapperUnityVersion.TryParseFloatGlobal(tags[1], out vec3.z))
                        {
                            return(false);
                        }
                        ret = true;
                        break;

                    default:
                        return(false);
                    }
                }
                else
                {
                    return(false);
                }
            }
            return(ret);
        }
Example #13
0
 public static void AddEventTriggerEntry(EventTrigger eventTrigger, UnityAction <UnityEngine.EventSystems.BaseEventData> action, EventTriggerType eventTriggerType)
 {
     EventTrigger.Entry        entry   = new EventTrigger.Entry();
     EventTrigger.TriggerEvent trigger = new EventTrigger.TriggerEvent();
     trigger.AddListener((eventData) => action(eventData));
     entry.callback = trigger;
     entry.eventID  = eventTriggerType;
     WrapperUnityVersion.AddEntryToEventTrigger(eventTrigger, entry);
 }
Example #14
0
 private void UpdateMemSize()
 {
     this.memSizeSystem       = SystemInfo.get_systemMemorySize();
     this.memSizeGraphic      = SystemInfo.get_graphicsMemorySize();
     this.memSizeGC           = ((1f * GC.GetTotalMemory(false)) / 1024f) / 1024f;
     this.memSizeUsedHeap     = WrapperUnityVersion.UsedHeapMegaSize();
     this.memSizeMonoHeap     = WrapperUnityVersion.MonoHeapMegaSize();
     this.memSizeMonoUsedHeap = WrapperUnityVersion.MonoUsedMegaSize();
 }
Example #15
0
 void UpdateMemSize()
 {
     memSizeSystem       = SystemInfo.systemMemorySize;
     memSizeGraphic      = SystemInfo.graphicsMemorySize;
     memSizeGC           = 1.0f * System.GC.GetTotalMemory(false) / 1024 / 1024;
     memSizeUsedHeap     = WrapperUnityVersion.UsedHeapMegaSize();
     memSizeMonoHeap     = WrapperUnityVersion.MonoHeapMegaSize();
     memSizeMonoUsedHeap = WrapperUnityVersion.MonoUsedMegaSize();
 }
Example #16
0
 /// <summary>
 /// オートセーブデータからセーブデータを作成
 /// </summary>
 /// <param name="autoSave">オートセーブデータ</param>
 /// <param name="tex">セーブアイコン</param>
 public void SaveGameData(AdvSaveData autoSave, AdvEngine engine, Texture2D tex)
 {
     Clear();
     Buffer      = autoSave.Buffer.Clone <BinaryBuffer>();
     Date        = WrapperUnityVersion.DateTimeNow();
     Texture     = tex;
     FileVersion = autoSave.FileVersion;
     Title       = autoSave.Title;
 }
Example #17
0
        /// <summary>
        /// itweenの引数の値を文字列から解析
        /// </summary>
        /// <param name="type">itweenのタイプ</param>
        /// <param name="name">引数の名前</param>
        /// <param name="valueString">値の文字列</param>
        /// <returns>値</returns>
        static object ParseValue(iTweenType type, string name, string valueString, ref bool isDynamic)
        {
            object paramValue = null;

            if (CallbackGetValue != null)
            {
                paramValue = CallbackGetValue(valueString);
                isDynamic  = true;
            }
            if (CheckArg(type, name))
            {
                switch (name)
                {
                case Time:
                case Delay:
                case Speed:
                case Alpha:
                case R:
                case G:
                case B:
                case A:
                case X:
                case Y:
                case Z:
                    if (paramValue != null)
                    {
                        return((float)paramValue);
                    }
                    else
                    {
                        return(WrapperUnityVersion.ParseFloatGlobal(valueString));
                    }

                case Islocal:
                    if (paramValue != null)
                    {
                        return((bool)paramValue);
                    }
                    else
                    {
                        return(bool.Parse(valueString));
                    }

                case Color:
                    return(ColorUtil.ParseColor(valueString));

                default:
                    return(null);
                }
            }
            else
            {
                return(null);
            }
        }
        //新たなプロジェクトを作成
        void Create()
        {
            switch (createType)
            {
            case Type.CreateNewAdvScene:
                if (!WrapperUnityVersion.SaveCurrentSceneIfUserWantsTo())
                {
                    return;
                }
                break;

            default:
                break;
            }

            newProjectDir = ToProjectDir(newProjectName);

            Profiler.BeginSample("CopyTemplate");
            //テンプレートをコピー
            CopyTemplate();
            Profiler.EndSample();

            //プロジェクトファイルを作成
            string path = FileUtil.GetProjectRelativePath(newProjectDir + newProjectName + ".project.asset");
            AdvScenarioDataProject ProjectData = UtageEditorToolKit.CreateNewUniqueAsset <AdvScenarioDataProject>(path);

            //プロジェクトにエクセルファイルを設定
            ProjectData.InitDefault(GetExcelRelativePath());
            //プロジェクトにカスタムインポートフォルダを設定
            ProjectData.AddCustomImportAudioFolders(LoadAudioFolders());
            ProjectData.AddCustomImportSpriteFolders(LoadSpriteFolders());
            ProjectData.AddCustomImportMovieFolders(LoadMovieFolders());
            //プロジェクトファイルを設定してインポート
            AdvScenarioDataBuilderWindow.ProjectData = ProjectData;
            AdvScenarioDataBuilderWindow.Import();

            Profiler.BeginSample("SceneEdting");
            switch (createType)
            {
            case Type.CreateNewAdvScene:
                //ADV用新規シーンを作成
                CreateNewAdvScene();
                break;

            case Type.AddToCurrentScene:
                //テンプレートシーンをコピー
                AddToCurrentScene();
                break;

            case Type.CreateScenarioAssetOnly:
                AssetDatabase.DeleteAsset(GetSceneRelativePath());
                break;
            }
            Profiler.EndSample();
        }
Example #19
0
        //キャッシュファイルテーブルを保存
        void WriteCacheTbl()
        {
#if !(UNITY_WEBPLAYER || UNITY_WEBGL)
            //キャッシュ用のディレクトリがなければ作成
            string path = GetCacheTblPath();
            FileIOManger.CreateDirectory(path);
            FileIOManger.WriteBinaryEncode(path, fileInfoTbl.Write);

            WrapperUnityVersion.SetNoBackupFlag(path);
#endif
        }
Example #20
0
 //ストリーミングタイプのサウンドだった場合、利用可能になったか
 bool CheckSoundStreamReady(WWW www)
 {
     if (null == sound)
     {
         return(false);
     }
     else
     {
         return(WrapperUnityVersion.IsReadyPlayAudioClip(sound));
     }
 }
 /// <summary>
 /// 再生
 /// </summary>
 public void Play()
 {
     if (!WrapperUnityVersion.IsReadyPlayAudioClip(clip))
     {
         Debug.LogError(LanguageErrorMsg.LocalizeTextFormat(ErrorMsg.SoundNotReadyToPlay, clip.name));
     }
     audioSource.clip   = clip;
     audioSource.loop   = IsLoop;
     audioSource.volume = requestVolume * callbackMasterVolume();
     audioSource.Play();
     status = SoundStreamStatus.Play;
 }
Example #22
0
 static void DeleteCacheFilesAndAssetBundles()
 {
     if (EditorUtility.DisplayDialog(
             LanguageSystemText.LocalizeText(SystemText.DeleteAllCacheFilesTitle),
             LanguageSystemText.LocalizeText(SystemText.DeleteAllCacheFilesMessage),
             LanguageSystemText.LocalizeText(SystemText.Ok),
             LanguageSystemText.LocalizeText(SystemText.Cancel)
             ))
     {
         DeleteFolder(FileIOManager.SdkTemporaryCachePath);
         WrapperUnityVersion.CleanCache();
     }
 }
Example #23
0
        //Audioファイルのインポート設定
        void OnPreprocessAudio()
        {
            //インポート時のAudioファイルを設定するクラス
            AudioImporter importer = assetImporter as AudioImporter;

            //宴のリソースかチェック
            if (!IsCustomImportAudio(importer))
            {
                return;
            }
            //各設定
            WrapperUnityVersion.SetAudioImporterThreeD(importer, false);
        }
Example #24
0
        //シーン内の全てのテンプレートアセットをクローンアセットに置き換える
        void ReplaceAssetsFromTemplateToCloneInSecne()
        {
//			Debug.Log(System.DateTime.Now + " プレハブインスタンスを検索");
            //プレハブインスタンスを検索
            List <GameObject> prefabInstanceList = new List <GameObject>();

            foreach (GameObject go in UtageEditorToolKit.GetAllObjectsInScene())
            {
                if (WrapperUnityVersion.CheckPrefabInstance(go))
                {
                    GameObject prefabInstance = WrapperUnityVersion.GetOutermostPrefabInstanceRoot(go);
                    if (!prefabInstanceList.Contains(prefabInstance))
                    {
                        prefabInstanceList.Add(prefabInstance);
                    }
                }
            }

            //			Debug.Log(System.DateTime.Now + " prefabInstanceList");
            //プレハブインスタンスはいったん削除して、クローンプレハブからインスタンスを作って置き換える
            foreach (GameObject go in prefabInstanceList)
            {
                //プレハブの元となるアセットを取得
                GameObject prefabAsset = WrapperUnityVersion.GetPrefabParent(go);
                if (prefabAsset == null)
                {
                    Debug.LogError(go.name + " Not fount parent Prefab.");
                }

                //プレハブをクローンしたものと入れ替えるために、クローンプレハブでアセットを作り直す
                Object clonePrefabAsset;
                if (CloneAssetPair.TryGetValue(prefabAsset, out clonePrefabAsset))
                {
                    GameObject cloneInstance = PrefabUtility.InstantiatePrefab(clonePrefabAsset) as GameObject;
                    cloneInstance.transform.SetParent(go.transform.parent);
                    cloneInstance.transform.localPosition = prefabAsset.transform.localPosition;
                    cloneInstance.transform.localRotation = prefabAsset.transform.localRotation;
                    cloneInstance.transform.localScale    = prefabAsset.transform.localScale;
                    GameObject.DestroyImmediate(go);
                }
                else
                {
                    Debug.LogError(go.name + " Not Find Clone Prefab.");
                }
            }

//			Debug.Log(System.DateTime.Now + "ReplaceSerializedProperties");
            //オブジェクト内のコンポーネントからのリンクを全て、テンプレートからクローンに置き換える
            UtageEditorToolKit.ReplaceSerializedPropertiesAllComponentsInScene(CloneAssetPair);
//			Debug.Log(System.DateTime.Now);
        }
        void AddToCurrentScene()
        {
            //すでにカメラがある場合は、宴関係のレイヤー設定を無効化する
            ChangeCameraMaskInScene();

            //すでにイベントシステムがある場合は、新しいほうを削除するために
            UnityEngine.EventSystems.EventSystem eventSystem = UtageEditorToolKit.FindComponentAllInTheScene <UnityEngine.EventSystems.EventSystem>();

            //シーンを開く
            string scenePath = GetSceneRelativePath();

            WrapperUnityVersion.OpenSceneAdditive(scenePath);


            //余分なオブジェクトを削除
            UtageUguiTitle title = UtageEditorToolKit.FindComponentAllInTheScene <UtageUguiTitle>();

            GameObject.DestroyImmediate(title.transform.root.gameObject);
            SystemUi systemUi = UtageEditorToolKit.FindComponentAllInTheScene <SystemUi>();

            GameObject.DestroyImmediate(systemUi.gameObject);

            //シーンのアセットを削除
            AssetDatabase.DeleteAsset(scenePath);

            //「宴」エンジンの初期化
            InitUtageEngine();

            //エンジン休止状態に
            AdvEngine engine = GameObject.FindObjectOfType <AdvEngine>();

            engine.gameObject.SetActive(false);

            ChangeLayerInCurrentScene();

            //すでにイベントシステムがある場合は、新しいほうを削除する
            if (eventSystem != null)
            {
                UnityEngine.EventSystems.EventSystem[] eventSystems = UtageEditorToolKit.FindComponentsAllInTheScene <UnityEngine.EventSystems.EventSystem>();
                foreach (var item in eventSystems)
                {
                    if (item != eventSystem)
                    {
                        GameObject.DestroyImmediate(item.gameObject);
                        break;
                    }
                }
            }
            Selection.activeObject = AssetDatabase.LoadAssetAtPath(scenePath, typeof(Object));
            FontChange(false);
        }
        //ADV用新規シーンを作成
        void CreateNewAdvScene()
        {
            //シーンを開く
            string scenePath = GetSceneRelativePath();

            WrapperUnityVersion.OpenScene(scenePath);
            WrapperUnityVersion.SaveScene();

            //「宴」エンジンの初期化
            InitUtageEngine();
            FontChange(true);
            WrapperUnityVersion.SaveScene();
            Selection.activeObject = AssetDatabase.LoadAssetAtPath(scenePath, typeof(Object));
        }
Example #27
0
        /// <summary>
        /// コンストラクタ
        /// </summary>
        /// <param name="c">文字</param>
        /// <param name="info">文字情報</param>
        /// <param name="sprite">描画スプライト</param>
        /// <param name="offsetY">フォントに設定されているオフセット値Y</param>
        public FontRenderInfo(char c, CharacterInfo info, Sprite sprite, float offsetY, float fontSize)
        {
            this.c        = c;
            this.charInfo = info;
            this.sprite   = sprite;

            //中心を原点とした場合の、表示位置
            WrapperUnityVersion.SetFontRenderInfo(c, ref info, offsetY, fontSize, out offset, out width, out kerningWidth);
            if (kerningWidth == 0)
            {
                kerningWidth = width;
            }
            kerningOffsetX = kerningWidth / 2;
        }
Example #28
0
 /// <summary>
 /// 文字列を値に変換
 /// </summary>
 /// <typeparam name="T">値の型</typeparam>
 /// <param name="str">文字列</param>
 /// <param name="val">値</param>
 /// <returns>変換に成功したらtrue、書式違いなどで変換できなかったらfalse</returns>
 public static bool TryParse <T>(string str, out T val)
 {
     try
     {
         System.Type type = typeof(T);
         if (type == typeof(string))
         {
             val = (T)(object)str;
         }
         else if (type.IsEnum)
         {
             val = (T)System.Enum.Parse(typeof(T), str);
         }
         else if (type == typeof(Color))
         {
             Color color = Color.white;
             bool  ret   = ColorUtil.TryParseColor(str, ref color);
             val = ret ? (T)(object)color : default(T);
             return(ret);
         }
         else if (type == typeof(int))
         {
             val = (T)(object)int.Parse(str);
         }
         else if (type == typeof(float))
         {
             val = (T)(object)WrapperUnityVersion.ParseFloatGlobal(str);
         }
         else if (type == typeof(double))
         {
             val = (T)(object)WrapperUnityVersion.ParseDoubleGlobal(str);
         }
         else if (type == typeof(bool))
         {
             val = (T)(object)bool.Parse(str);
         }
         else
         {
             System.ComponentModel.TypeConverter converter = System.ComponentModel.TypeDescriptor.GetConverter(type);
             val = (T)converter.ConvertFromString(str);
         }
         return(true);
     }
     catch
     {
         val = default(T);
         return(false);
     }
 }
Example #29
0
        //キャッシュファイル書き込み
        void WriteNewVersion(AssetFileWork file)
        {
            //キャッシュファイル書き込み準備
            file.FileInfo.ReadyToWriteCache(fileInfoTbl.IncCacheID(), GetCacheRootDir(), isDebugCacheFileName);
            string cachePath = file.FileInfo.CachePath;

            //キャッシュ用のディレクトリがなければ作成
            FileIOManger.CreateDirectory(cachePath);

            //ファイル書き込み
            bool ret = false;

            if (file.FileInfo.IsCrypt && !file.FileInfo.IsAlreadyEncoded)
            {
                switch (file.FileInfo.FileType)
                {
                case AssetFileType.Sound:
                    ret = FileIOManger.WriteSound(cachePath, file.WriteCacheFileSound);
                    break;

                case AssetFileType.Texture:
                    ret = FileIOManger.WriteEncodeNoCompress(cachePath, file.CacheWriteBytes);
                    break;

                default:
                    ret = FileIOManger.WriteEncode(cachePath, file.CacheWriteBytes);
                    break;
                }
            }
            else
            {
                ret = FileIOManger.Write(cachePath, file.CacheWriteBytes);
            }

            WrapperUnityVersion.SetNoBackupFlag(cachePath);

            //キャッシュファイルテーブルを更新して上書き
            if (!ret)
            {
                DebugLogError("Write Failed :" + file.FileInfo.CachePath);
            }
            else
            {
                WriteCacheTbl();
                file.FileInfo.DeleteOldCacheFile();
            }
        }
Example #30
0
        //名前からトークン作成
        static public ExpressionToken CreateToken(string name)
        {
            if (name.Length == 0)
            {
                Debug.LogError(" Token is enmpty");
            }

            int i;

            if (int.TryParse(name, out i))
            {
                //intとして追加
                return(new ExpressionToken(name, false, ExpressionToken.TokenType.Number, 0, i));
            }
            float f;

            if (WrapperUnityVersion.TryParseFloatGlobal(name, out f))
            {
                //floatとして追加
                return(new ExpressionToken(name, false, ExpressionToken.TokenType.Number, 0, f));
            }
            bool b;

            if (bool.TryParse(name, out b))
            {
                //boolとして追加
                return(new ExpressionToken(name, false, ExpressionToken.TokenType.Number, 0, b));
            }
            string str;

            if (TryParseString(name, out str))
            {
                //stringとして追加
                return(new ExpressionToken(name, false, ExpressionToken.TokenType.Number, 0, str));
            }

            ExpressionToken token;

            if (TryParseFunction(name, out token))
            {
                //関数として追加
                return(token);
            }

            //変数として追加
            return(new ExpressionToken(name, false, ExpressionToken.TokenType.Value, 0));
        }