AI 助理
备案控制台
开发者社区 人工智能 文章 正文

Unity 使用ScriptableObject创作问答系统数据配置

2022-09-06 157
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Unity 使用ScriptableObject创作问答系统数据配置

Unity中使用ScriptableObject允许我们创建配置文件并作为Unity中的Asset资产使用，无需像Json、XML等文件需要通过IO读取并反序列化成为我们需要的数据结构，其弊端是不可以像Json等配置文件可以在外部进行修改，在此不对其做详细介绍，下面使用ScriptableObject创作一个用于配置问答系统数据的资产，先看效果：

   image.gif

配置文件中包含五种题型：判断、单选、多选、填空、论述，选项可以删减并配置正确答案，首先定义一个描述题型的枚举QuestionType：

namespaceSK.Framework{
/// <summary>/// 题型/// </summary>publicenumQuestionType    {
/// <summary>/// 判断题/// </summary>JUDGE,
/// <summary>/// 单选题/// </summary>SINGLE_CHOICE,
/// <summary>/// 多选题/// </summary>MULTIPLE_CHOICE,
/// <summary>/// 填空题/// </summary>COMPLETION,
/// <summary>/// 论述题/// </summary>ESSAY,
    }
}

image.gif

创建基类QuestionBase，定义公共字段，包括题号、问题、题型、题解：

namespaceSK.Framework{
/// <summary>/// 问题基类/// </summary>publicclassQuestionBase    {
/// <summary>/// 题号/// </summary>publicintSequence;
/// <summary>/// 问题/// </summary>publicstringQuestion;
/// <summary>/// 题型/// </summary>publicQuestionTypeType;
/// <summary>/// 题解/// </summary>publicstringAnalysis;
    }
}

image.gif

选项因题型不同而异，判断题只包含两个选项：正确与错误，答案为一个bool类型字段。

usingSystem;
namespaceSK.Framework{
/// <summary>/// 判断题/// </summary>    [Serializable]
publicclassJudgeQuestion : QuestionBase    {
/// <summary>/// 积极选项/// </summary>publicstringPositive="正确";
/// <summary>/// 消极选项/// </summary>publicstringNegative="错误";
/// <summary>/// 答案/// </summary>publicboolAnswer;
    }
}

image.gif

填空题需要一个string类型的列表存储所有答案：

usingSystem;
usingSystem.Collections.Generic;
namespaceSK.Framework{
/// <summary>/// 填空题/// </summary>    [Serializable]
publicclassCompletionQuestion : QuestionBase    {
/// <summary>/// 答案/// </summary>publicList<string>Answers=newList<string>(0);
    }
}

image.gif

论述题只需要一个string类型字段描述答案：

usingSystem;
namespaceSK.Framework{
/// <summary>/// 论述题/// </summary>    [Serializable]
publicclassEssayQuestion : QuestionBase    {
/// <summary>/// 答案/// </summary>publicstringAnswer;
    }
}

image.gif

单选和多选题的选项分为三种不同类型：文字描述类型选项、图片类型选项、文字描述+图片类型选项，所以首先定义一个选项类型的枚举：

namespaceSK.Framework{
/// <summary>/// 选项类型/// </summary>publicenumChoiceType    {
/// <summary>/// 文本/// </summary>Text,
/// <summary>/// 图片/// </summary>Pic,
/// <summary>/// 文本+图片/// </summary>TextAndPic    }
}

image.gif

单选题答案为一个int类型字段：

usingSystem;
usingSystem.Collections.Generic;
namespaceSK.Framework{
/// <summary>/// 单项选择题/// </summary>    [Serializable]
publicclassSingleChoiceQuestion : QuestionBase    {
/// <summary>/// 选项类型/// </summary>publicChoiceTypechoiceType;
/// <summary>/// 选项/// </summary>publicList<QuestionChoice>Choices=newList<QuestionChoice>(0);
/// <summary>/// 答案/// </summary>publicintAnswer;
    }
}

image.gif

多选题答案为一个int类型列表：

usingSystem;
usingSystem.Collections.Generic;
namespaceSK.Framework{
/// <summary>/// 多项选择题/// </summary>    [Serializable]
publicclassMultipleChoiceQuestion : QuestionBase    {
/// <summary>/// 选项类型/// </summary>publicChoiceTypechoiceType;
/// <summary>/// 选项/// </summary>publicList<QuestionChoice>Choices=newList<QuestionChoice>(0);
/// <summary>/// 答案/// </summary>publicList<int>Answers=newList<int>(0);
    }
}

image.gif

需要注意各个问题类都需要添加Serializable特性，以确保其可序列化。单选和多选题的答案均为int类型字段，为了使int值对应A、B、C......Z字符，定义一个Alphabet字母表类， 例如Alphabet.Values[0]返回的便是字符A

namespaceSK.Framework{
/// <summary>/// 英文字母表/// </summary>publicstaticclassAlphabet    {
publicstaticchar[] Values=newchar[26]
        {
'A','B','C','D','E','F','G','H','I','G','K','L','M',
'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
        };
    }
}

image.gif

有了上述类后，创建QuestionsProfile类，继承ScriptableObject，使用CreateAssetMenu为创建该类型资产提供了创建菜单，并创建QuestionsProfileInspector继承Editor类进行了编辑器拓展：

usingUnityEngine;
usingSystem.Collections.Generic;
#ifUNITY_EDITORusingUnityEditor;
#endifnamespaceSK.Framework{
    [CreateAssetMenu(fileName="New Questions Profile", menuName="Question Profile")]
publicsealedclassQuestionsProfile : ScriptableObject    {
/// <summary>/// 判断题列表/// </summary>publicList<JudgeQuestion>Judges=newList<JudgeQuestion>(0);
/// <summary>/// 单向选择题列表/// </summary>publicList<SingleChoiceQuestion>SingleChoices=newList<SingleChoiceQuestion>(0);
/// <summary>/// 多项选择题列表/// </summary>publicList<MultipleChoiceQuestion>MultipleChoices=newList<MultipleChoiceQuestion>(0);
/// <summary>/// 填空题列表/// </summary>publicList<CompletionQuestion>Completions=newList<CompletionQuestion>(0);
/// <summary>/// 论述题列表/// </summary>publicList<EssayQuestion>Essays=newList<EssayQuestion>();
publicTGet<T>(QuestionTypetype, intsequence) whereT : QuestionBase        {
switch (type)
            {
caseQuestionType.JUDGE: returnJudges.Find(m=>m.Sequence==sequence) asT;
caseQuestionType.SINGLE_CHOICE: returnSingleChoices.Find(m=>m.Sequence==sequence) asT;
caseQuestionType.MULTIPLE_CHOICE: returnMultipleChoices.Find(m=>m.Sequence==sequence) asT;
caseQuestionType.COMPLETION: returnCompletions.Find(m=>m.Sequence==sequence) asT;
caseQuestionType.ESSAY: returnEssays.Find(m=>m.Sequence==sequence) asT;
default: returnnull;
            }
        }
    }
#ifUNITY_EDITOR    [CustomEditor(typeof(QuestionsProfile))]
publicsealedclassQuestionsProfileInspector : Editor    {
privateQuestionsProfileprofile;
privateQuestionTypecurrentType;
privateColorbtnNormalColor=newColor(0.5f, 0.5f, 0.5f, 1f);
privatereadonlyGUIContentdeleteContent=newGUIContent("-", "delete");
privateVector2scroll=Vector2.zero;
privateDictionary<JudgeQuestion, bool>judgeFoldoutMap;
privateDictionary<SingleChoiceQuestion, bool>singleChoicesFoldoutMap;
privateDictionary<MultipleChoiceQuestion, bool>multipleChoicesFoldoutMap;
privateDictionary<CompletionQuestion, bool>completionFoldoutMap;
privateDictionary<EssayQuestion, bool>essayFoldoutMap;
privatevoidOnEnable()
        {
profile=targetasQuestionsProfile;
judgeFoldoutMap=newDictionary<JudgeQuestion, bool>();
singleChoicesFoldoutMap=newDictionary<SingleChoiceQuestion, bool>();
multipleChoicesFoldoutMap=newDictionary<MultipleChoiceQuestion, bool>();
completionFoldoutMap=newDictionary<CompletionQuestion, bool>();
essayFoldoutMap=newDictionary<EssayQuestion, bool>();
        }
publicoverridevoidOnInspectorGUI()
        {
OnTypeGUI();
OnMenuGUI();
OnDetailGUI();
if (GUI.changed)
            {
EditorUtility.SetDirty(profile);
serializedObject.ApplyModifiedProperties();
            }
        }
privatevoidOnTypeGUI()
        {
EditorGUILayout.BeginHorizontal();
            {
GUI.color=currentType==QuestionType.JUDGE?Color.white : btnNormalColor;
if (GUILayout.Button("判断题", EditorStyles.miniButtonLeft)) currentType=QuestionType.JUDGE;
GUI.color=currentType==QuestionType.SINGLE_CHOICE?Color.white : btnNormalColor;
if (GUILayout.Button("单选题", EditorStyles.miniButtonMid)) currentType=QuestionType.SINGLE_CHOICE;
GUI.color=currentType==QuestionType.MULTIPLE_CHOICE?Color.white : btnNormalColor;
if (GUILayout.Button("多选题", EditorStyles.miniButtonMid)) currentType=QuestionType.MULTIPLE_CHOICE;
GUI.color=currentType==QuestionType.COMPLETION?Color.white : btnNormalColor;
if (GUILayout.Button("填空题", EditorStyles.miniButtonMid)) currentType=QuestionType.COMPLETION;
GUI.color=currentType==QuestionType.ESSAY?Color.white : btnNormalColor;
if (GUILayout.Button("论述题", EditorStyles.miniButtonRight)) currentType=QuestionType.ESSAY;
GUI.color=Color.white;
            }
EditorGUILayout.EndHorizontal();
        }
privatevoidOnMenuGUI()
        {
GUILayout.BeginHorizontal();
if (GUILayout.Button("展开", EditorStyles.miniButtonLeft))
            {
switch (currentType)
                {
caseQuestionType.JUDGE: profile.Judges.ForEach(m=>judgeFoldoutMap[m] =true); break;
caseQuestionType.SINGLE_CHOICE: profile.SingleChoices.ForEach(m=>singleChoicesFoldoutMap[m] =true); break;
caseQuestionType.MULTIPLE_CHOICE: profile.MultipleChoices.ForEach(m=>multipleChoicesFoldoutMap[m] =true); break;
caseQuestionType.COMPLETION: profile.Completions.ForEach(m=>completionFoldoutMap[m] =true); break;
caseQuestionType.ESSAY: profile.Essays.ForEach(m=>essayFoldoutMap[m] =true); break;
default: break;
                }
            }
if (GUILayout.Button("收缩", EditorStyles.miniButtonMid))
            {
switch (currentType)
                {
caseQuestionType.JUDGE: profile.Judges.ForEach(m=>judgeFoldoutMap[m] =false); break;
caseQuestionType.SINGLE_CHOICE: profile.SingleChoices.ForEach(m=>singleChoicesFoldoutMap[m] =false); break;
caseQuestionType.MULTIPLE_CHOICE: profile.MultipleChoices.ForEach(m=>multipleChoicesFoldoutMap[m] =false); break;
caseQuestionType.COMPLETION: profile.Completions.ForEach(m=>completionFoldoutMap[m] =false); break;
caseQuestionType.ESSAY: profile.Essays.ForEach(m=>essayFoldoutMap[m] =false); break;
default: break;
                }
            }
if (GUILayout.Button("添加", EditorStyles.miniButtonMid))
            {
Undo.RecordObject(profile, "Add New");
switch (currentType)
                {
caseQuestionType.JUDGE: profile.Judges.Add(newJudgeQuestion()); break;
caseQuestionType.SINGLE_CHOICE: profile.SingleChoices.Add(newSingleChoiceQuestion()); break;
caseQuestionType.MULTIPLE_CHOICE: profile.MultipleChoices.Add(newMultipleChoiceQuestion()); break;
caseQuestionType.COMPLETION: profile.Completions.Add(newCompletionQuestion()); break;
caseQuestionType.ESSAY: profile.Essays.Add(newEssayQuestion()); break;
default: break;
                }
            }
if (GUILayout.Button("清空", EditorStyles.miniButtonRight))
            {
Undo.RecordObject(profile, "Clear");
if (EditorUtility.DisplayDialog("Prompt", "Are you sure clear the questions?", "Yes", "No"))
                {
switch (currentType)
                    {
caseQuestionType.JUDGE: profile.Judges.Clear(); judgeFoldoutMap.Clear(); break;
caseQuestionType.SINGLE_CHOICE: profile.SingleChoices.Clear(); singleChoicesFoldoutMap.Clear(); break;
caseQuestionType.MULTIPLE_CHOICE: profile.MultipleChoices.Clear(); multipleChoicesFoldoutMap.Clear(); break;
caseQuestionType.COMPLETION: profile.Completions.Clear(); completionFoldoutMap.Clear(); break;
caseQuestionType.ESSAY: profile.Essays.Clear(); essayFoldoutMap.Clear(); break;
default: break;
                    }
                }
            }
GUILayout.EndHorizontal();
        }
privatevoidOnDetailGUI()
        {
scroll=GUILayout.BeginScrollView(scroll);
switch (currentType)
            {
#region判断题caseQuestionType.JUDGE:
for (inti=0; i<profile.Judges.Count; i++)
                    {
varcurrent=profile.Judges[i];
if (!judgeFoldoutMap.ContainsKey(current)) judgeFoldoutMap.Add(current, true);
GUILayout.BeginHorizontal("IN Title");
judgeFoldoutMap[current] =EditorGUILayout.Foldout(judgeFoldoutMap[current], $"第 {current.Sequence} 题", true);
if (GUILayout.Button("×", GUILayout.Width(20f)))
                        {
profile.Judges.Remove(current);
judgeFoldoutMap.Remove(current);
break;
                        }
GUILayout.EndHorizontal();
if (judgeFoldoutMap[current])
                        {
GUILayout.BeginHorizontal();
GUILayout.Label("题号：", GUILayout.Width(40));
varnewValue=EditorGUILayout.IntField(current.Sequence, GUILayout.Width(30));
if (current.Sequence!=newValue)
                            {
Undo.RecordObject(profile, "Judge Sequence");
current.Sequence=newValue;
                            }
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("问题：", GUILayout.Width(40));
varnewQ=EditorGUILayout.TextArea(current.Question, newGUIStyle(GUI.skin.textArea) { stretchWidth=false }, GUILayout.ExpandWidth(true));
if (newQ!=current.Question)
                            {
Undo.RecordObject(profile, "Judge Question");
current.Question=newQ;
                            }
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("正确：", GUILayout.Width(40));
varnewP=EditorGUILayout.TextField(current.Positive);
if (newP!=current.Positive)
                            {
Undo.RecordObject(profile, "Positive");
current.Positive=newP;
                            }
varnewAnswer=EditorGUILayout.Toggle(current.Answer==true, GUILayout.Width(15));
if (newAnswer!= (current.Answer==true))
                            {
Undo.RecordObject(profile, "Judge Answer");
current.Answer=true;
                            }
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("错误：", GUILayout.Width(40));
varnewN=EditorGUILayout.TextField(current.Negative);
if (newN!=current.Positive)
                            {
Undo.RecordObject(profile, "Negative");
current.Negative=newN;
                            }
varnewAns=EditorGUILayout.Toggle(current.Answer==false, GUILayout.Width(15));
if (newAns!= (current.Answer==false))
                            {
Undo.RecordObject(profile, "Judge Answer");
current.Answer=false;
                            }
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("题解：", GUILayout.Width(40));
varnewA=EditorGUILayout.TextArea(current.Analysis, newGUIStyle(GUI.skin.textArea) { stretchWidth=false }, GUILayout.ExpandWidth(true));
if (newA!=current.Analysis)
                            {
Undo.RecordObject(profile, "Judge Analysis");
current.Analysis=newA;
                            }
GUILayout.EndHorizontal();
                        }
                    }
break;
#endregion#region单选题caseQuestionType.SINGLE_CHOICE:
for (inti=0; i<profile.SingleChoices.Count; i++)
                    {
varcurrent=profile.SingleChoices[i];
if (!singleChoicesFoldoutMap.ContainsKey(current)) singleChoicesFoldoutMap.Add(current, true);
GUILayout.BeginHorizontal("IN Title");
singleChoicesFoldoutMap[current] =EditorGUILayout.Foldout(singleChoicesFoldoutMap[current], $"第 {current.Sequence} 题", true);
if (GUILayout.Button("×", GUILayout.Width(20f)))
                        {
profile.SingleChoices.Remove(current);
singleChoicesFoldoutMap.Remove(current);
break;
                        }
GUILayout.EndHorizontal();
if (singleChoicesFoldoutMap[current])
                        {
GUILayout.BeginHorizontal();
GUILayout.Label("题号：", GUILayout.Width(40));
varnewS=EditorGUILayout.IntField(current.Sequence, GUILayout.Width(30));
if (current.Sequence!=newS)
                            {
Undo.RecordObject(profile, "SingleChoices Sequence");
current.Sequence=newS;
                            }
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("问题：", GUILayout.Width(40));
varnewQ=EditorGUILayout.TextArea(current.Question, newGUIStyle(GUI.skin.textArea) { stretchWidth=false }, GUILayout.ExpandWidth(true));
if (newQ!=current.Question)
                            {
Undo.RecordObject(profile, "SingleChoices Question");
current.Question=newQ;
                            }
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("选项：", GUILayout.Width(40));
GUILayout.BeginHorizontal();
if (GUILayout.Button("＋", GUILayout.Width(25)))
                            {
Undo.RecordObject(profile, "SingleChoices Add");
current.Choices.Add(newQuestionChoice("选项描述", null));
                            }
GUILayout.FlexibleSpace();
current.choiceType= (ChoiceType)EditorGUILayout.EnumPopup(current.choiceType, GUILayout.Width(80f));
GUILayout.Label("(类型)");
GUILayout.EndHorizontal();
GUILayout.EndHorizontal();
GUILayout.BeginVertical();
for (intk=0; k<current.Choices.Count; k++)
                            {
GUILayout.BeginHorizontal();
GUILayout.Space(50);
GUILayout.Label($"{Alphabet.Values[k]}.", GUILayout.Width(20));
switch (current.choiceType)
                                {
caseChoiceType.Text:
current.Choices[k].text=GUILayout.TextField(current.Choices[k].text);
break;
caseChoiceType.Pic:
current.Choices[k].pic=EditorGUILayout.ObjectField(current.Choices[k].pic, typeof(Sprite), false) asSprite;
break;
caseChoiceType.TextAndPic:
current.Choices[k].text=GUILayout.TextField(current.Choices[k].text);
current.Choices[k].pic=EditorGUILayout.ObjectField(current.Choices[k].pic, typeof(Sprite), false, GUILayout.Width(110f)) asSprite;
break;
                                }
varnewValue=EditorGUILayout.Toggle(current.Answer==k, GUILayout.Width(15));
if (newValue)
                                {
Undo.RecordObject(profile, "SingleChoices Answer");
current.Answer=k;
                                }
if (GUILayout.Button(deleteContent, "MiniButton", GUILayout.Width(18)))
                                {
Undo.RecordObject(profile, "Delete SingleChoice");
current.Choices.RemoveAt(k);
break;
                                }
GUILayout.EndHorizontal();
                            }
GUILayout.EndVertical();
GUILayout.BeginHorizontal();
GUILayout.Label("题解：", GUILayout.Width(40));
varnewA=EditorGUILayout.TextArea(current.Analysis, newGUIStyle(GUI.skin.textArea) { stretchWidth=false }, GUILayout.ExpandWidth(true));
if (newA!=current.Analysis)
                            {
Undo.RecordObject(profile, "SingleChoices Analysis");
current.Analysis=newA;
                            }
GUILayout.EndHorizontal();
                        }
                    }
break;
#endregion#region多选题caseQuestionType.MULTIPLE_CHOICE:
for (inti=0; i<profile.MultipleChoices.Count; i++)
                    {
varcurrent=profile.MultipleChoices[i];
if (!multipleChoicesFoldoutMap.ContainsKey(current)) multipleChoicesFoldoutMap.Add(current, true);
GUILayout.BeginHorizontal("IN Title");
multipleChoicesFoldoutMap[current] =EditorGUILayout.Foldout(multipleChoicesFoldoutMap[current], $"第 {current.Sequence} 题", true);
if (GUILayout.Button("×", GUILayout.Width(20f)))
                        {
profile.MultipleChoices.Remove(current);
multipleChoicesFoldoutMap.Remove(current);
break;
                        }
GUILayout.EndHorizontal();
if (multipleChoicesFoldoutMap[current])
                        {
GUILayout.BeginHorizontal();
GUILayout.Label("题号：", GUILayout.Width(40));
varnewS=EditorGUILayout.IntField(current.Sequence, GUILayout.Width(30));
if (newS!=current.Sequence)
                            {
Undo.RecordObject(profile, "MultipleChoices Sequence");
current.Sequence=newS;
                            }
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("问题：", GUILayout.Width(40));
varnewQ=EditorGUILayout.TextArea(current.Question, newGUIStyle(GUI.skin.textArea) { stretchWidth=false }, GUILayout.ExpandWidth(true));
if (newQ!=current.Question)
                            {
Undo.RecordObject(profile, "MultipleChoices Question");
current.Question=newQ;
                            }
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("选项：", GUILayout.Width(40));
GUILayout.BeginHorizontal();
if (GUILayout.Button("＋", GUILayout.Width(25)))
                            {
Undo.RecordObject(profile, "SingleChoices Add");
current.Choices.Add(newQuestionChoice("选项描述", null));
                            }
GUILayout.FlexibleSpace();
current.choiceType= (ChoiceType)EditorGUILayout.EnumPopup(current.choiceType, GUILayout.Width(80f));
GUILayout.Label("(类型)");
GUILayout.EndHorizontal();
GUILayout.EndHorizontal();
GUILayout.BeginVertical();
for (intk=0; k<current.Choices.Count; k++)
                            {
GUILayout.BeginHorizontal();
GUILayout.Space(50);
GUILayout.Label($"{Alphabet.Values[k]}.", GUILayout.Width(20));
switch (current.choiceType)
                                {
caseChoiceType.Text:
current.Choices[k].text=GUILayout.TextField(current.Choices[k].text);
break;
caseChoiceType.Pic:
current.Choices[k].pic=EditorGUILayout.ObjectField(current.Choices[k].pic, typeof(Sprite), false) asSprite;
break;
caseChoiceType.TextAndPic:
current.Choices[k].text=GUILayout.TextField(current.Choices[k].text);
current.Choices[k].pic=EditorGUILayout.ObjectField(current.Choices[k].pic, typeof(Sprite), false, GUILayout.Width(110f)) asSprite;
break;
                                }
varnewValue=EditorGUILayout.Toggle(current.Answers.Contains(k), GUILayout.Width(15));
if (newValue!=current.Answers.Contains(k))
                                {
Undo.RecordObject(profile, "MultipleChoices Answers");
if (newValue)
current.Answers.Add(k);
elsecurrent.Answers.Remove(k);
                                }
if (GUILayout.Button(deleteContent, "MiniButton", GUILayout.Width(18)))
                                {
Undo.RecordObject(profile, "Delete MultipleChoice");
current.Choices.RemoveAt(k);
break;
                                }
GUILayout.EndHorizontal();
                            }
GUILayout.EndVertical();
GUILayout.BeginHorizontal();
GUILayout.Label("题解：", GUILayout.Width(40));
varnewA=EditorGUILayout.TextArea(current.Analysis, newGUIStyle(GUI.skin.textArea) { stretchWidth=false }, GUILayout.ExpandWidth(true));
if (newA!=current.Analysis)
                            {
Undo.RecordObject(profile, "MultipleChoices Analysis");
current.Analysis=newA;
                            }
GUILayout.EndHorizontal();
                        }
                    }
break;
#endregion#region填空题caseQuestionType.COMPLETION:
for (inti=0; i<profile.Completions.Count; i++)
                    {
varcurrent=profile.Completions[i];
if (!completionFoldoutMap.ContainsKey(current)) completionFoldoutMap.Add(current, true);
GUILayout.BeginHorizontal("IN Title");
completionFoldoutMap[current] =EditorGUILayout.Foldout(completionFoldoutMap[current], $"第 {current.Sequence} 题", true);
if (GUILayout.Button("×", GUILayout.Width(20f)))
                        {
profile.Completions.Remove(current);
completionFoldoutMap.Remove(current);
break;
                        }
GUILayout.EndHorizontal();
if (completionFoldoutMap[current])
                        {
GUILayout.BeginHorizontal();
GUILayout.Label("题号：", GUILayout.Width(40));
varnewS=EditorGUILayout.IntField(current.Sequence, GUILayout.Width(30));
if (newS!=current.Sequence)
                            {
Undo.RecordObject(profile, "Completion Sequence");
current.Sequence=newS;
                            }
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("问题：", GUILayout.Width(40));
varnewQ=EditorGUILayout.TextArea(current.Question, newGUIStyle(GUI.skin.textArea) { stretchWidth=false }, GUILayout.ExpandWidth(true));
if (newQ!=current.Question)
                            {
Undo.RecordObject(profile, "Completion Question");
current.Question=newQ;
                            }
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("答案：", GUILayout.Width(40));
if (GUILayout.Button("＋", GUILayout.Width(25)))
                            {
Undo.RecordObject(profile, "CompletionAnswers Add");
current.Answers.Add(null);
                            }
GUILayout.EndHorizontal();
GUILayout.BeginVertical();
for (intn=0; n<current.Answers.Count; n++)
                            {
GUILayout.BeginHorizontal();
GUILayout.Space(50);
GUILayout.Label($"({n + 1}).", GUILayout.Width(30));
varnewC=EditorGUILayout.TextField(current.Answers[n]);
if (current.Answers[n] !=newC)
                                {
Undo.RecordObject(profile, "CompletionAnswer");
current.Answers[n] =newC;
                                }
if (GUILayout.Button(deleteContent, "MiniButton", GUILayout.Width(18)))
                                {
Undo.RecordObject(profile, "CompletionAnswers Remove");
current.Answers.RemoveAt(n);
break;
                                }
GUILayout.EndHorizontal();
                            }
GUILayout.EndVertical();
GUILayout.BeginHorizontal();
GUILayout.Label("题解：", GUILayout.Width(40));
varnewA=EditorGUILayout.TextArea(current.Analysis, newGUIStyle(GUI.skin.textArea) { stretchWidth=false }, GUILayout.ExpandWidth(true));
if (newA!=current.Analysis)
                            {
Undo.RecordObject(profile, "Completion Analysis");
current.Analysis=newA;
                            }
GUILayout.EndHorizontal();
                        }
                    }
break;
#endregion#region论述题caseQuestionType.ESSAY:
for (inti=0; i<profile.Essays.Count; i++)
                    {
varcurrent=profile.Essays[i];
if (!essayFoldoutMap.ContainsKey(current)) essayFoldoutMap.Add(current, true);
GUILayout.BeginHorizontal("IN Title");
essayFoldoutMap[current] =EditorGUILayout.Foldout(essayFoldoutMap[current], $"第 {current.Sequence} 题", true);
if (GUILayout.Button("×", GUILayout.Width(20f)))
                        {
profile.Essays.Remove(current);
essayFoldoutMap.Remove(current);
break;
                        }
GUILayout.EndHorizontal();
if (essayFoldoutMap[current])
                        {
GUILayout.BeginHorizontal();
GUILayout.Label("题号：", GUILayout.Width(40));
varnewS=EditorGUILayout.IntField(current.Sequence, GUILayout.Width(30));
if (newS!=current.Sequence)
                            {
Undo.RecordObject(profile, "Essay Sequence");
current.Sequence=newS;
                            }
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("问题：", GUILayout.Width(40));
varnewQ=EditorGUILayout.TextArea(current.Question, newGUIStyle(GUI.skin.textArea) { stretchWidth=false }, GUILayout.ExpandWidth(true));
if (newQ!=current.Question)
                            {
Undo.RecordObject(profile, "Essay Question");
current.Question=newQ;
                            }
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("答案：", GUILayout.Width(40));
varnewA=EditorGUILayout.TextArea(current.Answer, newGUIStyle(GUI.skin.textArea) { stretchWidth=false }, GUILayout.ExpandWidth(true));
if (newA!=current.Answer)
                            {
Undo.RecordObject(profile, "Essay Answer");
current.Answer=newA;
                            }
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("题解：", GUILayout.Width(40));
varnewV=EditorGUILayout.TextArea(current.Analysis, newGUIStyle(GUI.skin.textArea) { stretchWidth=false }, GUILayout.ExpandWidth(true));
if (newV!=current.Analysis)
                            {
Undo.RecordObject(profile, "Essay Analysis");
current.Analysis=newV;
                            }
GUILayout.EndHorizontal();
                        }
                    }
break;
#endregiondefault:
GUILayout.Label("Unknown Question Type.");
break;
            }
GUILayout.EndScrollView();
        }
    }
#endif}

image.gif

image.gif

文章标签：
图形学
数据格式
存储
JSON
XML
关键词：
unity配置
unity数据
CoderZ1010
目录
相关文章
星河造梦坊丨程序开发
|
2月前
|
API 开发工具 vr&ar
PicoVR Unity SDK⭐️一、SDK下载、项目设置与程序初始配置
PicoVR Unity SDK⭐️一、SDK下载、项目设置与程序初始配置
星河造梦坊丨程序开发
32 1
土木林森
|
1月前
|
vr&ar 图形学 API
Unity与VR控制器交互全解：从基础配置到力反馈应用，多角度提升虚拟现实游戏的真实感与沉浸体验大揭秘
【8月更文挑战第31天】虚拟现实（VR）技术迅猛发展，Unity作为主流游戏开发引擎，支持多种VR硬件并提供丰富的API，尤其在VR控制器交互设计上具备高度灵活性。本文详细介绍了如何在Unity中配置VR支持、设置控制器、实现按钮交互及力反馈，结合碰撞检测和物理引擎提升真实感，助力开发者创造沉浸式体验。
土木林森
71 0
向宇it
|
4月前
|
存储 JSON 关系型数据库
【unity实战】制作unity数据保存和加载系统——大型游戏存储的最优解
【unity实战】制作unity数据保存和加载系统——大型游戏存储的最优解
向宇it
91 2
向宇it
|
4月前
|
存储 JSON 图形学
【unity实战】制作unity数据保存和加载系统——小型游戏存储的最优解
【unity实战】制作unity数据保存和加载系统——小型游戏存储的最优解
向宇it
118 0
向宇it
|
4月前
|
图形学
【unity小技巧】unity读excel配置表操作，excel转txt文本，并读取txt文本内容，实例说明
【unity小技巧】unity读excel配置表操作，excel转txt文本，并读取txt文本内容，实例说明
向宇it
79 0
游戏开发小Y
|
5月前
|
JSON Java 数据处理
Unity 数据读取|（二）多种方式读取文本文件
Unity 数据读取|（二）多种方式读取文本文件
游戏开发小Y
243 0
音视频牛哥
|
5月前
|
数据采集 编解码 图形学
Android平台Unity下如何通过WebCamTexture采集摄像头数据并推送至RTMP服务器或轻量级RTSP服务
Android平台Unity下如何通过WebCamTexture采集摄像头数据并推送至RTMP服务器或轻量级RTSP服务
音视频牛哥
267 0
游戏开发小Y
|
5月前
|
存储 安全 API
Unity 数据读取|（六）PlayerPrefs解析
Unity 数据读取|（六）PlayerPrefs解析
游戏开发小Y
107 0
游戏开发小Y
|
5月前
|
XML 存储 安全
Unity 数据读取|（五）XML文件解析（XmlDocument，XmlTextReader）
Unity 数据读取|（五）XML文件解析（XmlDocument，XmlTextReader）
游戏开发小Y
101 0
游戏开发小Y
|
5月前
|
存储 JSON C#
Unity 数据读取|（四）Json文件解析（Newtonsoft.Json ，Litjson，JsonUtility，SimpleJSON）
Unity 数据读取|（四）Json文件解析（Newtonsoft.Json ，Litjson，JsonUtility，SimpleJSON）
游戏开发小Y
285 0

热门文章

最新文章

  • 1
    Unity3D之Mecanim动画系统学习笔记（五）：Animator Controller
  • 2
    《Unity虚拟现实开发实战》——第1章，第1.5节本书涵盖的内容
  • 3
    Microsoft实现的IOC DI之 Unity 、Service Locator、MEF
  • 4
    Unity与 DLL文件 ☀️| 怎样使用 C# 类库 生成一个DLL文件 并 调用！
  • 5
    Unity 离线建造系统
  • 6
    Unity 4.6 GUI
  • 7
    Unity代码里的Position和界面上的Position
  • 8
    unity 多线程
  • 9
    Unity优化
  • 10
    [Unity] 文件夹图像资源的读取
  • 1
    Unity优化——加速物理引擎1
    126
  • 2
    Unity优化——批处理的优势
    143
  • 3
    Unity优化——脚本优化策略4
    98
  • 4
    Unity优化——脚本优化策略3
    74
  • 5
    Unity优化——脚本优化策略2
    69
  • 6
    Unity优化——脚本优化策略1
    85
  • 7
    Unity和C#游戏编程入门：创建迷宫小球游戏示例
    137
  • 8
    Android平台Unity下如何通过WebCamTexture采集摄像头数据并推送至RTMP服务器或轻量级RTSP服务
    267
  • 9
    如何绕过某讯手游保护系统并从内存中获取Unity3D引擎的Dll文件
    78
  • 10
    Unity3D 导出的apk进行混淆加固、保护与优化原理（防止反编译）
    70

    • 相关课程

    更多
  • 趣味视觉AI应用入门与实战
  • 人人都能学｜AI大模型应用搭建
  • AI情绪鼓励师模型微调实操教学
  • AI人像动漫画实操教学
  • 基于通义灵码实现高效 AI 编码
  • 跨越N次元 一键变身AI漫画人

    • 相关电子书

    更多
  • 阿里云视觉计算开发者系列手册-目标检测入门必读指南
  • 人物写真开源&商业
  • 《视觉计算开发者系列手册》

    • 相关实验场景

    更多
  • SAE 极速部署专属 AI 证件照神器
  • AI克隆声音，基于函数计算部署GPT-Sovits语音生成模型
  • 奥运时刻！零代码生成奥运风格AI写真。
  • 【图生图】一键部署3D卡通风格模型
  • 【AI破次元壁合照】少年白马醉春风，函数计算一键部署AI绘画平台
  • 【自由换模型】基于函数计算一键部署 Stable Diffusion
    • 下一篇
    无影云桌面