├── .gitattributes
├── .github
    └── ISSUE_TEMPLATE
    │   ├── bug_report.md
    │   └── feature_request.md
├── .gitignore
├── LICENSE
├── README.md
├── RPG Databases.csproj
├── RPG Databases.csproj.old
├── RPG Databases.sln
├── addons
    ├── rpg_database
    │   ├── Scenes
    │   │   └── Base.tscn
    │   ├── Scripts
    │   │   ├── Armor.cs
    │   │   ├── Base.cs
    │   │   ├── Character.cs
    │   │   ├── Class.cs
    │   │   ├── Effects.cs
    │   │   ├── Enemy.cs
    │   │   ├── Item.cs
    │   │   ├── Skill.cs
    │   │   ├── States.cs
    │   │   ├── SystemScript.cs
    │   │   └── Weapon.cs
    │   ├── database.cs
    │   └── plugin.cfg
    └── rpg_databases_gd
    │   ├── Scenes
    │       └── Base.tscn
    │   ├── Scripts
    │       ├── armor.gd
    │       ├── base.gd
    │       ├── character.gd
    │       ├── class.gd
    │       ├── effects.gd
    │       ├── enemy.gd
    │       ├── item.gd
    │       ├── skill.gd
    │       ├── states.gd
    │       ├── system.gd
    │       └── weapon.gd
    │   ├── database.gd
    │   └── plugin.cfg
├── databases
    ├── Armor.json
    ├── Character.json
    ├── Class.json
    ├── Effect.json
    ├── Enemy.json
    ├── Item.json
    ├── Skill.json
    ├── State.json
    ├── System.json
    └── Weapon.json
├── default_env.tres
├── icon.png
├── icon.png.import
├── project.godot
└── screenshots
    ├── armor.png
    ├── armor.png.import
    ├── character.png
    ├── character.png.import
    ├── class.png
    ├── class.png.import
    ├── item.png
    ├── item.png.import
    ├── skill.png
    ├── skill.png.import
    ├── weapon.png
    └── weapon.png.import


/.gitattributes:
--------------------------------------------------------------------------------
1 | *.gd linguist-language=GDScript


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/bug_report.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Bug report
 3 | about: Create a report to help us improve
 4 | title: ''
 5 | labels: ''
 6 | assignees: ''
 7 | 
 8 | ---
 9 | 
10 | **Describe the bug**
11 | A clear and concise description of what the bug is.
12 | 
13 | **To Reproduce**
14 | Steps to reproduce the behavior:
15 | 1. Go to '...'
16 | 2. Click on '....'
17 | 3. Scroll down to '....'
18 | 4. See error
19 | 
20 | **Expected behavior**
21 | A clear and concise description of what you expected to happen.
22 | 
23 | **Screenshots**
24 | If applicable, add screenshots to help explain your problem.
25 | 
26 | Please complete the following information:
27 |  - OS: [e.g. iOS]
28 |  - Browser [e.g. chrome, safari]
29 |  - Version [e.g. 22]
30 | 
31 | **Additional context**
32 | Add any other context about the problem here.
33 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/feature_request.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Feature request
 3 | about: Suggest an idea for this project
 4 | title: ''
 5 | labels: ''
 6 | assignees: ''
 7 | 
 8 | ---
 9 | 
10 | **Is your feature request related to a problem? Please describe.**
11 | A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
12 | 
13 | **Describe the solution you'd like**
14 | A clear and concise description of what you want to happen.
15 | 
16 | **Describe alternatives you've considered**
17 | A clear and concise description of any alternative solutions or features you've considered.
18 | 
19 | **Additional context**
20 | Add any other context or screenshots about the feature request here.
21 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | 
 2 | # Godot-specific ignores
 3 | .import/
 4 | export.cfg
 5 | export_presets.cfg
 6 | assets/
 7 | # Mono-specific ignores
 8 | .mono/
 9 | data_*/
10 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 sdtv9507
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # RPG Database
 2 | 
 3 | RPG database for [Godot Engine](https://godotengine.org) inspired on RPG Maker's database editor made in C#
 4 | 
 5 | ## How to use
 6 | 
 7 | - Copy the folder rpg_database from the project in "res://addons/".
 8 | - Create a new folder in the root of your project called "databases" (without the quotes).
 9 | - If you are using the C# version, build the project.
10 | - Go to your project's Settings and enable the plugin.
11 | - A button should show above the inspector. Press it to open the database
12 | 
13 | Feel free to open an issue if you find bugs or have a feature request
14 | 
15 | # Version 1.1.1
16 | - Fixed bugs on Character's tab regarding adding Effect Types.
17 | - Fixed bugs on State's tab regarding saving and adding effects.
18 | - Fixed bugs on all tabs regarding change member button not clearing past data.
19 | - Added sample database.
20 | 
21 | You can also find the project at [itch.io](https://sdtv9507.itch.io/godot-rpg-database-manager)
22 | 


--------------------------------------------------------------------------------
/RPG Databases.csproj:
--------------------------------------------------------------------------------
1 | <Project Sdk="Godot.NET.Sdk/3.3.0">
2 |   <PropertyGroup>
3 |     <TargetFramework>net472</TargetFramework>
4 |     <RootNamespace>RPGDatabases</RootNamespace>
5 |   </PropertyGroup>
6 | </Project>


--------------------------------------------------------------------------------
/RPG Databases.csproj.old:
--------------------------------------------------------------------------------
1 | <Project Sdk="Godot.NET.Sdk/3.2.3">
2 |   <PropertyGroup>
3 |     <TargetFramework>net472</TargetFramework>
4 |     <RootNamespace>RPGDatabases</RootNamespace>
5 |   </PropertyGroup>
6 | </Project>


--------------------------------------------------------------------------------
/RPG Databases.sln:
--------------------------------------------------------------------------------
 1 | Microsoft Visual Studio Solution File, Format Version 12.00
 2 | # Visual Studio 2012
 3 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RPG Databases", "RPG Databases.csproj", "{CA9380EC-F8E6-4857-98C7-9B9641726EE3}"
 4 | EndProject
 5 | Global
 6 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 7 | 	Debug|Any CPU = Debug|Any CPU
 8 | 	ExportDebug|Any CPU = ExportDebug|Any CPU
 9 | 	ExportRelease|Any CPU = ExportRelease|Any CPU
10 | 	EndGlobalSection
11 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
12 | 		{CA9380EC-F8E6-4857-98C7-9B9641726EE3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
13 | 		{CA9380EC-F8E6-4857-98C7-9B9641726EE3}.Debug|Any CPU.Build.0 = Debug|Any CPU
14 | 		{CA9380EC-F8E6-4857-98C7-9B9641726EE3}.ExportDebug|Any CPU.ActiveCfg = ExportDebug|Any CPU
15 | 		{CA9380EC-F8E6-4857-98C7-9B9641726EE3}.ExportDebug|Any CPU.Build.0 = ExportDebug|Any CPU
16 | 		{CA9380EC-F8E6-4857-98C7-9B9641726EE3}.ExportRelease|Any CPU.ActiveCfg = ExportRelease|Any CPU
17 | 		{CA9380EC-F8E6-4857-98C7-9B9641726EE3}.ExportRelease|Any CPU.Build.0 = ExportRelease|Any CPU
18 | 	EndGlobalSection
19 | EndGlobal
20 | 


--------------------------------------------------------------------------------
/addons/rpg_database/Scripts/Armor.cs:
--------------------------------------------------------------------------------
  1 | using Godot;
  2 | using System;
  3 | 
  4 | [Tool]
  5 | public class Armor : Control
  6 | {
  7 |     // Declare member variables here. Examples:
  8 |     // private int a = 2;
  9 |     // private string b = "text";
 10 | 
 11 |     string iconPath = "";
 12 |     int armorSelected = 0;
 13 |     int statEdit = -1;
 14 |     // Called when the node enters the scene tree for the first time.
 15 |     public void Start()
 16 |     {
 17 |         Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "Armor") as Godot.Collections.Dictionary;
 18 |         GetNode<OptionButton>("ArmorButton").Clear();
 19 |         for (int i = 0; i < jsonDictionary.Count; i++)
 20 |         {
 21 |             Godot.Collections.Dictionary armorData = jsonDictionary["armor" + i] as Godot.Collections.Dictionary;
 22 |             if (i > GetNode<OptionButton>("ArmorButton").GetItemCount() - 1)
 23 |             {
 24 |                 GetNode<OptionButton>("ArmorButton").AddItem(armorData["name"] as string);
 25 |             }
 26 |             else
 27 |             {
 28 |                 GetNode<OptionButton>("ArmorButton").SetItemText(i, armorData["name"] as string);
 29 |             }
 30 |         }
 31 | 
 32 |         jsonDictionary = this.GetParent().GetParent().Call("ReadData", "System") as Godot.Collections.Dictionary;
 33 |         
 34 |         Godot.Collections.Dictionary systemData = jsonDictionary["armors"] as Godot.Collections.Dictionary;
 35 |         for (int i = 0; i < systemData.Count; i++)
 36 |         {
 37 |             if (i > GetNode<OptionButton>("ATypeLabel/ATypeButton").GetItemCount() - 1)
 38 |             {
 39 |                 GetNode<OptionButton>("ATypeLabel/ATypeButton").AddItem(systemData[i.ToString()] as string);
 40 |             }
 41 |             else
 42 |             {
 43 |                 GetNode<OptionButton>("ATypeLabel/ATypeButton").SetItemText(i, systemData[i.ToString()] as string);
 44 |             }
 45 |         }
 46 |         
 47 |         systemData = jsonDictionary["slots"] as Godot.Collections.Dictionary;
 48 |         int final_id = 0;
 49 |         foreach (String str in systemData.Keys)
 50 |         {
 51 |             if (str[0] == 'a')
 52 |             {
 53 |                 int id = Convert.ToInt32(str.Remove(0, 1)) - final_id;
 54 |                 if (id > GetNode<OptionButton>("SlotLabel/SlotButton").GetItemCount() - 1)
 55 |                 {
 56 |                     GetNode<OptionButton>("SlotLabel/SlotButton").AddItem(systemData[str] as string);
 57 |                 }
 58 |                 else
 59 |                 {
 60 |                     GetNode<OptionButton>("SlotLabel/SlotButton").SetItemText(id, systemData[str] as string);
 61 |                 }
 62 |             }
 63 |             else
 64 |             {
 65 |                 final_id += 1;
 66 |             }
 67 |         }
 68 |         RefreshData(armorSelected);
 69 |     }
 70 | 
 71 |     private void RefreshData(int id)
 72 |     {
 73 |         Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "Armor") as Godot.Collections.Dictionary;
 74 |         Godot.Collections.Dictionary armorData = jsonDictionary["armor" + id] as Godot.Collections.Dictionary;
 75 | 
 76 |         jsonDictionary = this.GetParent().GetParent().Call("ReadData", "System") as Godot.Collections.Dictionary;
 77 |         Godot.Collections.Dictionary systemData = jsonDictionary["stats"] as Godot.Collections.Dictionary;
 78 | 
 79 |         GetNode<LineEdit>("NameLabel/NameText").Text = armorData["name"] as string;
 80 |         string icon = armorData["icon"] as string;
 81 |         if (icon != "")
 82 |         {
 83 |             iconPath = icon;
 84 |             GetNode<Sprite>("IconLabel/IconSprite").Texture = GD.Load(armorData["icon"] as string) as Godot.Texture;
 85 |         }
 86 |         GetNode<TextEdit>("DescLabel/DescText").Text = armorData["description"] as string;
 87 |         GetNode<OptionButton>("ATypeLabel/ATypeButton").Selected = Convert.ToInt32(armorData["armor_type"]);
 88 |         GetNode<OptionButton>("SlotLabel/SlotButton").Selected = Convert.ToInt32(armorData["slot_type"]);
 89 |         GetNode<SpinBox>("PriceLabel/PriceSpin").Value = Convert.ToInt32(armorData["price"]);
 90 | 
 91 |         GetNode<ItemList>("StatsLabel/StatsContainer/DataContainer/StatNameCont/StatNameList").Clear();
 92 |         GetNode<ItemList>("StatsLabel/StatsContainer/DataContainer/StatValueCont/StatValueList").Clear();
 93 |         for (int i = 0; i < systemData.Count; i++)
 94 |         {
 95 |             string statName = systemData[i.ToString()] as string;
 96 |             Godot.Collections.Dictionary armorStatFormula = armorData["stat_list"] as Godot.Collections.Dictionary;
 97 |             string statFormula = "";
 98 |             if (armorStatFormula.Contains(statName))
 99 |             {
100 |                 statFormula = armorStatFormula[statName as string] as string;
101 |             }
102 |             else
103 |             {
104 |                 statFormula = "0";
105 |             }
106 |             GetNode<ItemList>("StatsLabel/StatsContainer/DataContainer/StatNameCont/StatNameList").AddItem(statName);
107 |             GetNode<ItemList>("StatsLabel/StatsContainer/DataContainer/StatValueCont/StatValueList").AddItem(statFormula);
108 |         }
109 |         if (armorData.Contains("effects") == true)
110 |         {
111 |             this.ClearEffectList();
112 |             Godot.Collections.Array effectList = armorData["effects"] as Godot.Collections.Array;
113 |             foreach (Godot.Collections.Dictionary effect in effectList)
114 |             {
115 |                 this.AddEffectList(effect["name"].ToString(), Convert.ToInt32(effect["data_id"]), effect["value1"].ToString(), effect["value2"].ToString());
116 |             }
117 |         }
118 | 
119 |     }
120 | 
121 |     private void _on_AddArmorButton_pressed()
122 |     {
123 |         GetNode<OptionButton>("ArmorButton").AddItem("NewArmor");
124 |         int id = GetNode<OptionButton>("ArmorButton").GetItemCount() - 1;
125 |         Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "Armor") as Godot.Collections.Dictionary;
126 |         Godot.Collections.Dictionary armorData = new Godot.Collections.Dictionary();
127 |         Godot.Collections.Dictionary armorStats = new Godot.Collections.Dictionary();
128 |         armorData.Add("name", "NewArmor");
129 |         armorData.Add("icon", "");
130 |         armorData.Add("description", "New created armor");
131 |         armorData.Add("armor_type", 0);
132 |         armorData.Add("slot_type", 0);
133 |         armorData.Add("price", 50);
134 |         armorStats.Add("hp", "0");
135 |         armorStats.Add("mp", "0");
136 |         armorStats.Add("atk", "0");
137 |         armorStats.Add("def", "0");
138 |         armorStats.Add("int", "0");
139 |         armorStats.Add("res", "0");
140 |         armorStats.Add("spd", "0");
141 |         armorStats.Add("luk", "0");
142 |         armorData.Add("stat_list", armorStats);
143 |         jsonDictionary.Add("armor" + id, armorData);
144 |         this.GetParent().GetParent().Call("StoreData", "Armor", jsonDictionary);
145 |     }
146 | 
147 |     private void _on_RemoveArmor_pressed()
148 |     {
149 |         Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "Armor") as Godot.Collections.Dictionary;
150 |         if (jsonDictionary.Keys.Count > 1)
151 |         {
152 |             int armorId = armorSelected;
153 |             while (armorId < jsonDictionary.Keys.Count - 1)
154 |             {
155 |                 jsonDictionary["armor" + armorId] = jsonDictionary["armor" + (armorId + 1)];
156 |                 armorId += 1;
157 |             }
158 |             jsonDictionary.Remove("armor" + armorId);
159 |             this.GetParent().GetParent().Call("StoreData", "Armor", jsonDictionary);
160 |             GetNode<OptionButton>("ArmorButton").RemoveItem(armorSelected);
161 |             if (armorSelected == 0)
162 |             {
163 |                 GetNode<OptionButton>("ArmorButton").Select(armorSelected + 1);
164 |                 armorSelected += 1;
165 |             }
166 |             else
167 |             {
168 |                 GetNode<OptionButton>("ArmorButton").Select(armorSelected - 1);
169 |                 armorSelected -= 1;
170 |             }
171 |             GetNode<OptionButton>("ArmorButton").Select(armorSelected);
172 |             RefreshData(armorSelected);
173 |         }
174 |     }
175 | 
176 |     private void _on_ArmorSaveButton_pressed()
177 |     {
178 |         SaveArmorData();
179 |         RefreshData(armorSelected);
180 |     }
181 | 
182 |     private void _on_Search_pressed()
183 |     {
184 |         GetNode<FileDialog>("IconLabel/IconSearch").PopupCentered();
185 |     }
186 | 
187 |     private void _on_IconSearch_file_selected(string path)
188 |     {
189 |         iconPath = path;
190 |         GetNode<Sprite>("IconLabel/IconSprite").Texture = GD.Load(path) as Godot.Texture;
191 |     }
192 | 
193 |     private void _on_ArmorButton_item_selected(int id)
194 |     {
195 |         armorSelected = id;
196 |         RefreshData(id);
197 |     }
198 | 
199 |     private void SaveArmorData()
200 |     {
201 | 		Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "Armor") as Godot.Collections.Dictionary;
202 |         Godot.Collections.Dictionary armorData = jsonDictionary["armor"+armorSelected] as Godot.Collections.Dictionary;
203 |         Godot.Collections.Dictionary armorStatFormula = armorData["stat_list"] as Godot.Collections.Dictionary;
204 | 		Godot.Collections.Array effectList = new Godot.Collections.Array();
205 | 
206 |         armorData["name"] = GetNode<LineEdit>("NameLabel/NameText").Text;
207 | 		GetNode<OptionButton>("ArmorButton").SetItemText(armorSelected, GetNode<LineEdit>("NameLabel/NameText").Text);
208 | 		armorData["icon"] = iconPath;
209 | 		armorData["description"] = GetNode<TextEdit>("DescLabel/DescText").Text;
210 |         armorData["armor_type"] = GetNode<OptionButton>("ATypeLabel/ATypeButton").Selected;
211 |         armorData["slot_type"] = GetNode<OptionButton>("SlotLabel/SlotButton").Selected;
212 | 		armorData["price"] = GetNode<SpinBox>("PriceLabel/PriceSpin").Value;
213 |         int items = GetNode<ItemList>("StatsLabel/StatsContainer/DataContainer/StatNameCont/StatNameList").GetItemCount();
214 |         for (int i = 0; i < items; i++)
215 |         {
216 |             string stat = GetNode<ItemList>("StatsLabel/StatsContainer/DataContainer/StatNameCont/StatNameList").GetItemText(i);
217 |             string formula = GetNode<ItemList>("StatsLabel/StatsContainer/DataContainer/StatValueCont/StatValueList").GetItemText(i);
218 |             armorStatFormula[stat] = formula;
219 |         }
220 |         int effectSize = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").GetItemCount();
221 |         for (int i = 0; i < effectSize; i++)
222 |         {
223 |             Godot.Collections.Dictionary effectData = new Godot.Collections.Dictionary();
224 |             effectData["name"] = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").GetItemText(i);
225 |             effectData["data_id"] = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType").GetItemText(i);
226 |             effectData["value1"] = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1").GetItemText(i);
227 |             effectData["value2"] = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2").GetItemText(i);
228 |             effectList.Add(effectData);
229 |         }
230 |         armorData["effects"] = effectList;
231 |         this.GetParent().GetParent().Call("StoreData", "Armor", jsonDictionary);
232 |     }
233 | 
234 |     private void _on_StatValueList_item_activated(int index)
235 |     {
236 |         string statName = GetNode<ItemList>("StatsLabel/StatsContainer/DataContainer/StatNameCont/StatNameList").GetItemText(index);
237 |         string statFormula = GetNode<ItemList>("StatsLabel/StatsContainer/DataContainer/StatValueCont/StatValueList").GetItemText(index);
238 |         GetNode<Label>("StatEditor/StatLabel").Text = statName;
239 |         GetNode<LineEdit>("StatEditor/StatEdit").Text = statFormula;
240 |         statEdit = index;
241 |         GetNode<WindowDialog>("StatEditor").Show();
242 |     }
243 | 
244 |     private void _on_OkButton_pressed()
245 |     {
246 |         string statFormula = GetNode<LineEdit>("StatEditor/StatEdit").Text;
247 |         GetNode<ItemList>("StatsLabel/StatsContainer/DataContainer/StatValueCont/StatValueList").SetItemText(statEdit, statFormula);
248 |         SaveArmorData();
249 |         statEdit = -1;
250 |         GetNode<WindowDialog>("StatEditor").Hide();
251 |     }
252 | 
253 |     private void _on_CancelButton_pressed()
254 |     {
255 |         statEdit = -1;
256 |         GetNode<WindowDialog>("StatEditor").Hide();
257 |     }
258 |     private void _on_AddArmorEffect_pressed()
259 |     {
260 |         this.GetParent().GetParent().Call("OpenEffectManager", "Armor");
261 |     }
262 | 
263 |     private void _on_RemoveArmorEffect_pressed()
264 |     {
265 |         int id = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").GetSelectedItems()[0];
266 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").RemoveItem(id);
267 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType").RemoveItem(id);
268 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1").RemoveItem(id);
269 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2").RemoveItem(id);
270 |     }
271 |     public void AddEffectList(String name, int dataId, String value1, String value2)
272 |     {
273 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").AddItem(name);
274 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType").AddItem(dataId.ToString());
275 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1").AddItem(value1);
276 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2").AddItem(value2);
277 |     }
278 | 
279 |     public void ClearEffectList()
280 |     {
281 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").Clear();
282 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType").Clear();
283 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1").Clear();
284 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2").Clear();
285 |     }
286 | //  // Called every frame. 'delta' is the elapsed time since the previous frame.
287 | //  public override void _Process(float delta)
288 | //  {
289 | //      
290 | //  }
291 | }
292 | 


--------------------------------------------------------------------------------
/addons/rpg_database/Scripts/Effects.cs:
--------------------------------------------------------------------------------
  1 | using Godot;
  2 | using System;
  3 | 
  4 | [Tool]
  5 | public class Effects : Container
  6 | {
  7 |     // Declare member variables here. Examples:
  8 |     // private int a = 2;
  9 |     // private string b = "text";
 10 | 
 11 |     bool addNewEffect = true;
 12 |     bool databaseLoaded = false;
 13 |     // Called when the node enters the scene tree for the first time.
 14 |     public void Start()
 15 |     {
 16 |         if (databaseLoaded == false)
 17 |         {
 18 |             Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "Effect") as Godot.Collections.Dictionary;
 19 |             for (int i = 0; i < jsonDictionary.Count; i++)
 20 |             {
 21 |                 Godot.Collections.Dictionary effectData = jsonDictionary["effect" + i] as Godot.Collections.Dictionary;
 22 |                 Godot.Collections.Dictionary showList = effectData["data_type"] as Godot.Collections.Dictionary;
 23 |                 Godot.Collections.Dictionary value2 = effectData["value2"] as Godot.Collections.Dictionary;
 24 | 
 25 |                 GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectNames").AddItem(effectData["name"].ToString());
 26 |                 if (showList["show"] as bool? == true)
 27 |                 {
 28 |                     GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/DataTypes").AddItem(showList["data"].ToString());
 29 |                 }
 30 |                 else
 31 |                 {
 32 |                     GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/DataTypes").AddItem("Disabled");
 33 |                 }
 34 | 
 35 |                 GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue1").AddItem(effectData["value1"].ToString());
 36 |                 if (value2["show"] as bool? == true)
 37 |                 {
 38 |                     GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue2").AddItem(value2["data"].ToString());
 39 |                 }
 40 |                 else
 41 |                 {
 42 |                     GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue2").AddItem("-1");
 43 |                 }
 44 |             }
 45 |             databaseLoaded = true;
 46 |         }
 47 | 
 48 |     }
 49 | 
 50 |     private void _on_AddEffect_pressed()
 51 |     {
 52 |         addNewEffect = true;
 53 |         GetNode<WindowDialog>("AddEffect").PopupCentered();
 54 |     }
 55 | 
 56 |     private void _on_EditEffect_pressed()
 57 |     {
 58 |         if (GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectNames").GetSelectedItems()[0] > -1)
 59 |         {
 60 |             addNewEffect = false;
 61 |             int id = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectNames").GetSelectedItems()[0];
 62 | 
 63 |             String name = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectNames").GetItemText(id);
 64 |             String dataTypes = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/DataTypes").GetItemText(id);
 65 |             int value1 = Convert.ToInt32(GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue1").GetItemText(id));
 66 |             int value2 = Convert.ToInt32(GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue2").GetItemText(id));
 67 | 
 68 |             GetNode<LineEdit>("AddEffect/VBoxContainer/Name/LineEdit").Text = name;
 69 |             if (dataTypes == "Disabled")
 70 |             {
 71 |                 GetNode<CheckButton>("AddEffect/VBoxContainer/ShowList/CheckButton").Pressed = false;
 72 |                 GetNode<OptionButton>("AddEffect/VBoxContainer/ShowList/OptionButton").Disabled = true;
 73 |             }
 74 |             else
 75 |             {
 76 |                 GetNode<CheckButton>("AddEffect/VBoxContainer/ShowList/CheckButton").Pressed = true;
 77 |                 GetNode<OptionButton>("AddEffect/VBoxContainer/ShowList/OptionButton").Disabled = false;
 78 |                 switch (dataTypes)
 79 |                 {
 80 |                     case "States":
 81 |                         GetNode<OptionButton>("AddEffect/VBoxContainer/ShowList/OptionButton").Select(0);
 82 |                         break;
 83 |                     case "Stats":
 84 |                         GetNode<OptionButton>("AddEffect/VBoxContainer/ShowList/OptionButton").Select(1);
 85 |                         break;
 86 |                     case "Weapon Types":
 87 |                         GetNode<OptionButton>("AddEffect/VBoxContainer/ShowList/OptionButton").Select(2);
 88 |                         break;
 89 |                     case "Armor Types":
 90 |                         GetNode<OptionButton>("AddEffect/VBoxContainer/ShowList/OptionButton").Select(3);
 91 |                         break;
 92 |                     case "Elements":
 93 |                         GetNode<OptionButton>("AddEffect/VBoxContainer/ShowList/OptionButton").Select(4);
 94 |                         break;
 95 |                     case "Skill Types":
 96 |                         GetNode<OptionButton>("AddEffect/VBoxContainer/ShowList/OptionButton").Select(5);
 97 |                         break;
 98 |                 }
 99 |             }
100 | 
101 |             GetNode<OptionButton>("AddEffect/VBoxContainer/Value1/OptionButton").Select(value1);
102 |             if (value2 == -1)
103 |             {
104 |                 GetNode<CheckButton>("AddEffect/VBoxContainer/Value2/CheckButton").Pressed = false;
105 |                 GetNode<OptionButton>("AddEffect/VBoxContainer/Value2/OptionButton").Disabled = true;
106 |             }
107 |             else
108 |             {
109 |                 GetNode<CheckButton>("AddEffect/VBoxContainer/Value2/CheckButton").Pressed = true;
110 |                 GetNode<OptionButton>("AddEffect/VBoxContainer/Value2/OptionButton").Disabled = false;
111 |                 GetNode<OptionButton>("AddEffect/VBoxContainer/Value2/OptionButton").Select(value2);
112 |             }
113 |             GetNode<WindowDialog>("AddEffect").PopupCentered();
114 |         }
115 |     }
116 | 
117 |     private void _on_RemoveEffect_pressed()
118 |     {
119 |         int selectedEffect = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectNames").GetSelectedItems()[0];
120 |         if (selectedEffect > -1)
121 |         {
122 |             GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectNames").RemoveItem(selectedEffect);
123 |             GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/DataTypes").RemoveItem(selectedEffect);
124 |             GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue1").RemoveItem(selectedEffect);
125 |             GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue2").RemoveItem(selectedEffect);
126 |         }
127 |     }
128 | 
129 |     private void _on_ClearEffects_pressed()
130 |     {
131 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectNames").Clear();
132 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/DataTypes").Clear();
133 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue1").Clear();
134 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue2").Clear();
135 |     }
136 | 
137 |     private void _on_ShowListCheckButton_pressed()
138 |     {
139 |         if (GetNode<CheckButton>("AddEffect/VBoxContainer/ShowList/CheckButton").Pressed == true)
140 |         {
141 |             GetNode<OptionButton>("AddEffect/VBoxContainer/ShowList/OptionButton").Disabled = false;
142 |         }
143 |         else
144 |         {
145 |             GetNode<OptionButton>("AddEffect/VBoxContainer/ShowList/OptionButton").Disabled = true;
146 |         }
147 |     }
148 | 
149 |     private void _on_Value2CheckButton_pressed()
150 |     {
151 |         if (GetNode<CheckButton>("AddEffect/VBoxContainer/Value2/CheckButton").Pressed == true)
152 |         {
153 |             GetNode<OptionButton>("AddEffect/VBoxContainer/Value2/OptionButton").Disabled = false;
154 |         }
155 |         else
156 |         {
157 |             GetNode<OptionButton>("AddEffect/VBoxContainer/Value2/OptionButton").Disabled = true;
158 |         }
159 |     }
160 | 
161 |     private void _on_AddEffectConfirm_pressed()
162 |     {
163 |         String name = GetNode<LineEdit>("AddEffect/VBoxContainer/Name/LineEdit").Text;
164 |         int selected = 0;
165 |         String dataType = "Disabled";
166 |         if (GetNode<CheckButton>("AddEffect/VBoxContainer/ShowList/CheckButton").Pressed == true)
167 |         {
168 |             selected = GetNode<OptionButton>("AddEffect/VBoxContainer/ShowList/OptionButton").Selected;
169 |             dataType = GetNode<OptionButton>("AddEffect/VBoxContainer/ShowList/OptionButton").GetItemText(selected);
170 |         }
171 |         int value1 = GetNode<OptionButton>("AddEffect/VBoxContainer/Value1/OptionButton").Selected;
172 |         int value2 = -1;
173 |         if (GetNode<CheckButton>("AddEffect/VBoxContainer/Value2/CheckButton").Pressed == true)
174 |         {
175 |             value2 = GetNode<OptionButton>("AddEffect/VBoxContainer/Value2/OptionButton").Selected;
176 |         }
177 |         if (addNewEffect == false)
178 |         {
179 |             int id = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectNames").GetSelectedItems()[0];
180 |             GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectNames").SetItemText(id, name);
181 |             GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/DataTypes").SetItemText(id, dataType);
182 |             GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue1").SetItemText(id, value1.ToString());
183 |             GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue2").SetItemText(id, value2.ToString());
184 |         }
185 |         else
186 |         {
187 |             GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectNames").AddItem(name);
188 |             GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/DataTypes").AddItem(dataType);
189 |             GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue1").AddItem(value1.ToString());
190 |             GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue2").AddItem(value2.ToString());
191 |         }
192 | 
193 |         GetNode<WindowDialog>("AddEffect").Hide();
194 |     }
195 | 
196 |     private void _on_AddEffectCancel_pressed()
197 |     {
198 |         GetNode<WindowDialog>("AddEffect").Hide();
199 |     }
200 | 
201 |     private void _on_SaveEffects_pressed()
202 |     {
203 |         int size = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectNames").GetItemCount();
204 |         Godot.Collections.Dictionary effectList = new Godot.Collections.Dictionary();
205 |         for (int i = 0; i < size; i++)
206 |         {
207 |             Godot.Collections.Dictionary effectData = new Godot.Collections.Dictionary();
208 |             Godot.Collections.Dictionary showList = new Godot.Collections.Dictionary();
209 |             Godot.Collections.Dictionary value2 = new Godot.Collections.Dictionary();
210 |             effectData["name"] = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectNames").GetItemText(i);
211 |             String dataType = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/DataTypes").GetItemText(i);
212 |             if (dataType == "Disabled")
213 |             {
214 |                 showList["show"] = false;
215 |                 showList["data"] = "";
216 |             }
217 |             else
218 |             {
219 |                 showList["show"] = true;
220 |                 showList["data"] = dataType;
221 |             }
222 |             effectData["data_type"] = showList;
223 |             effectData["value1"] = Convert.ToInt32(GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue1").GetItemText(i));
224 |             int value2Val = Convert.ToInt32(GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue2").GetItemText(i));
225 |             if (value2Val == -1)
226 |             {
227 |                 value2["show"] = false;
228 |                 value2["data"] = "";
229 |             }
230 |             else
231 |             {
232 |                 value2["show"] = true;
233 |                 value2["data"] = value2Val;
234 |             }
235 |             effectData["value2"] = value2;
236 |             effectList["effect" + i] = effectData;
237 |         }
238 | 
239 |         this.GetParent().GetParent().Call("StoreData", "Effect", effectList);
240 |     }
241 |     //  // Called every frame. 'delta' is the elapsed time since the previous frame.
242 |     //  public override void _Process(float delta)
243 |     //  {
244 |     //      
245 |     //  }
246 | }
247 | 


--------------------------------------------------------------------------------
/addons/rpg_database/Scripts/Item.cs:
--------------------------------------------------------------------------------
  1 | using Godot;
  2 | using System;
  3 | 
  4 | [Tool]
  5 | public class Item : Control
  6 | {
  7 |     // Declare member variables here. Examples:
  8 |     // private int a = 2;
  9 |     // private string b = "text";
 10 |     string iconPath = "";
 11 |     int itemSelected = 0;
 12 |     // Called when the node enters the scene tree for the first time.
 13 |     public void Start()
 14 |     {
 15 |         Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "Item") as Godot.Collections.Dictionary;
 16 |         GetNode<OptionButton>("ItemButton").Clear();
 17 |         for (int i = 0; i < jsonDictionary.Count; i++)
 18 |         {
 19 |             Godot.Collections.Dictionary itemData = jsonDictionary["item"+i] as Godot.Collections.Dictionary;
 20 |             if (i > GetNode<OptionButton>("ItemButton").GetItemCount() - 1)
 21 |             {
 22 |                 GetNode<OptionButton>("ItemButton").AddItem(itemData["name"] as string);
 23 |             }else{
 24 |                 GetNode<OptionButton>("ItemButton").SetItemText(i, itemData["name"] as string);
 25 |             }
 26 |         }
 27 |         
 28 | 		jsonDictionary = this.GetParent().GetParent().Call("ReadData", "System") as Godot.Collections.Dictionary;
 29 |         
 30 |         Godot.Collections.Dictionary systemData = jsonDictionary["elements"] as Godot.Collections.Dictionary;
 31 |         for (int i = 0; i < systemData.Count; i++)
 32 |         {
 33 |             if (i > GetNode<OptionButton>("DamageLabel/ElementLabel/ElementButton").GetItemCount() - 1)
 34 |             {
 35 |                 GetNode<OptionButton>("DamageLabel/ElementLabel/ElementButton").AddItem(systemData[i.ToString()] as string);
 36 |             }else{
 37 |                 GetNode<OptionButton>("DamageLabel/ElementLabel/ElementButton").SetItemText(i, systemData[i.ToString()] as string);
 38 |             }
 39 |         }
 40 |         RefreshData(itemSelected);
 41 |     }
 42 | 
 43 |     private void RefreshData(int id)
 44 |     {
 45 |         Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "Item") as Godot.Collections.Dictionary;
 46 |         Godot.Collections.Dictionary itemData = jsonDictionary["item"+id] as Godot.Collections.Dictionary;
 47 |         GetNode<LineEdit>("NameLabel/NameText").Text = itemData["name"] as string;
 48 |         string icon = itemData["icon"] as string;
 49 |         if (icon != "")
 50 |         {
 51 |             iconPath = icon;
 52 |             GetNode<Sprite>("IconLabel/IconSprite").Texture = GD.Load(itemData["icon"] as string) as Godot.Texture;
 53 |         }
 54 |         GetNode<TextEdit>("DescLabel/DescText").Text = itemData["description"] as string;
 55 |         GetNode<OptionButton>("ItemTypeLabel/ItemTypeButton").Selected = Convert.ToInt32(itemData["item_type"]);
 56 |         GetNode<SpinBox>("PriceLabel/PriceBox").Value = Convert.ToInt32(itemData["price"]);
 57 |         GetNode<OptionButton>("ConsumableLabel/ConsumableButton").Selected = Convert.ToInt32(itemData["consumable"]);
 58 |         GetNode<OptionButton>("TargetLabel/TargetButton").Selected = Convert.ToInt32(itemData["target"]);
 59 |         GetNode<OptionButton>("UsableLabel/UsableButton").Selected = Convert.ToInt32(itemData["usable"]);
 60 |         GetNode<SpinBox>("HitLabel/HitBox").Value = Convert.ToInt32(itemData["success"]);
 61 |         GetNode<OptionButton>("TypeLabel/TypeButton").Selected = Convert.ToInt32(itemData["hit_type"]);
 62 |         GetNode<OptionButton>("DamageLabel/DTypeLabel/DTypeButton").Selected = Convert.ToInt32(itemData["damage_type"]);
 63 |         GetNode<OptionButton>("DamageLabel/ElementLabel/ElementButton").Selected = Convert.ToInt32(itemData["element"]);
 64 |         GetNode<LineEdit>("DamageLabel/DFormulaLabel/FormulaText").Text = itemData["formula"] as string;
 65 |         if (itemData.Contains("effects") == true)
 66 |         {
 67 |             this.ClearEffectList();
 68 |             Godot.Collections.Array effectList = itemData["effects"] as Godot.Collections.Array;
 69 |             foreach (Godot.Collections.Dictionary effect in effectList)
 70 |             {
 71 |                 this.AddEffectList(effect["name"].ToString(), Convert.ToInt32(effect["data_id"]), effect["value1"].ToString(), effect["value2"].ToString());
 72 |             }
 73 |         }
 74 |     }
 75 |     
 76 |     private void _on_Search_pressed()
 77 |     {
 78 |         GetNode<FileDialog>("IconLabel/IconSearch").PopupCentered();
 79 |     }
 80 | 
 81 |     private void _on_IconSearch_file_selected(string path)
 82 |     {
 83 |         iconPath = path;
 84 |         GetNode<Sprite>("IconLabel/IconSprite").Texture = GD.Load(path) as Godot.Texture;
 85 |     }
 86 |     private void _on_AddItem_pressed()
 87 |     {
 88 |         GetNode<OptionButton>("ItemButton").AddItem("NewItem");
 89 |         int id = GetNode<OptionButton>("ItemButton").GetItemCount() - 1;
 90 |         Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "Item") as Godot.Collections.Dictionary;
 91 |         Godot.Collections.Dictionary itemData = new Godot.Collections.Dictionary();
 92 | 		itemData.Add("name", "NewItem");
 93 | 		itemData.Add("icon", "");
 94 | 		itemData.Add("description", "New created item");
 95 | 		itemData.Add("item_type", 0);
 96 | 		itemData.Add("price", 10);
 97 | 		itemData.Add("consumable", 0);
 98 | 		itemData.Add("target", 3);
 99 | 		itemData.Add("usable", 0);
100 | 		itemData.Add("success", 95);
101 | 		itemData.Add("hit_type", 1);
102 | 		itemData.Add("damage_type", 1);
103 | 		itemData.Add("element", 0);
104 | 		itemData.Add("formula", "10");
105 | 		jsonDictionary.Add("item" + id, itemData);
106 |         this.GetParent().GetParent().Call("StoreData", "Item", jsonDictionary);
107 |     }
108 | 
109 |     private void _on_RemoveItem_pressed()
110 |     {
111 |         Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "Item") as Godot.Collections.Dictionary;
112 |         if (jsonDictionary.Keys.Count > 1)
113 |         {
114 |             int itemId = itemSelected;
115 |             while (itemId < jsonDictionary.Keys.Count - 1)
116 |             {
117 |                 jsonDictionary["item" + itemId] = jsonDictionary["item" + (itemId + 1)];
118 |                 itemId += 1;
119 |             }
120 |             jsonDictionary.Remove("item" + itemId);
121 |             this.GetParent().GetParent().Call("StoreData", "Item", jsonDictionary);
122 |             GetNode<OptionButton>("ItemButton").RemoveItem(itemSelected);
123 |             if (itemSelected == 0)
124 |             {
125 |                 GetNode<OptionButton>("ItemButton").Select(itemSelected + 1);
126 |                 itemSelected += 1;
127 |             }
128 |             else
129 |             {
130 |                 GetNode<OptionButton>("ItemButton").Select(itemSelected - 1);
131 |                 itemSelected -= 1;
132 |             }
133 |             GetNode<OptionButton>("ItemButton").Select(itemSelected);
134 |             RefreshData(itemSelected);
135 |         }
136 |     }
137 | 
138 |     private void _on_ItemSaveButton_pressed()
139 |     {
140 |         SaveItemData();
141 |         RefreshData(itemSelected);
142 |     }
143 |     private void SaveItemData()
144 |     {
145 | 		Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "Item") as Godot.Collections.Dictionary;
146 |         Godot.Collections.Dictionary itemData = jsonDictionary["item"+itemSelected] as Godot.Collections.Dictionary;
147 | 		Godot.Collections.Array effectList = new Godot.Collections.Array();
148 | 
149 |         itemData["name"] = GetNode<LineEdit>("NameLabel/NameText").Text;
150 | 		GetNode<OptionButton>("ItemButton").SetItemText(itemSelected, GetNode<LineEdit>("NameLabel/NameText").Text);
151 | 		itemData["icon"] = iconPath;
152 | 		itemData["description"] = GetNode<TextEdit>("DescLabel/DescText").Text;
153 |         itemData["item_type"] = GetNode<OptionButton>("ItemTypeLabel/ItemTypeButton").Selected;
154 | 		itemData["price"] = GetNode<SpinBox>("PriceLabel/PriceBox").Value;
155 | 		itemData["consumable"] = GetNode<OptionButton>("ConsumableLabel/ConsumableButton").Selected;
156 | 		itemData["target"] = GetNode<OptionButton>("TargetLabel/TargetButton").Selected;
157 | 		itemData["usable"] = GetNode<OptionButton>("UsableLabel/UsableButton").Selected;
158 | 		itemData["success"] = GetNode<SpinBox>("HitLabel/HitBox").Value;
159 | 		itemData["hit_type"] = GetNode<OptionButton>("TypeLabel/TypeButton").Selected;
160 | 		itemData["damage_type"] = GetNode<OptionButton>("DamageLabel/DTypeLabel/DTypeButton").Selected;
161 | 		itemData["element"] = GetNode<OptionButton>("DamageLabel/ElementLabel/ElementButton").Selected;
162 | 		itemData["formula"] = GetNode<LineEdit>("DamageLabel/DFormulaLabel/FormulaText").Text;
163 |         int effectSize = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").GetItemCount();
164 |         for (int i = 0; i < effectSize; i++)
165 |         {
166 |             Godot.Collections.Dictionary effectData = new Godot.Collections.Dictionary();
167 |             effectData["name"] = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").GetItemText(i);
168 |             effectData["data_id"] = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType").GetItemText(i);
169 |             effectData["value1"] = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1").GetItemText(i);
170 |             effectData["value2"] = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2").GetItemText(i);
171 |             effectList.Add(effectData);
172 |         }
173 |         itemData["effects"] = effectList;
174 |         this.GetParent().GetParent().Call("StoreData", "Item", jsonDictionary);
175 |     }
176 | 
177 |     private void _on_ItemButton_item_selected(int id)
178 |     {
179 |         itemSelected = id;
180 |         RefreshData(id);
181 |     }
182 |     private void _on_AddItemEffect_pressed()
183 |     {
184 |         this.GetParent().GetParent().Call("OpenEffectManager", "Item");
185 |     }
186 | 
187 |     private void _on_RemoveItemEffect_pressed()
188 |     {
189 |         int id = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").GetSelectedItems()[0];
190 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").RemoveItem(id);
191 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType").RemoveItem(id);
192 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1").RemoveItem(id);
193 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2").RemoveItem(id);
194 |     }
195 |     public void AddEffectList(String name, int dataId, String value1, String value2)
196 |     {
197 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").AddItem(name);
198 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType").AddItem(dataId.ToString());
199 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1").AddItem(value1);
200 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2").AddItem(value2);
201 |     }
202 | 
203 |     public void ClearEffectList()
204 |     {
205 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").Clear();
206 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType").Clear();
207 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1").Clear();
208 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2").Clear();
209 |     }
210 | //  // Called every frame. 'delta' is the elapsed time since the previous frame.
211 | //  public override void _Process(float delta)
212 | //  {
213 | //      
214 | //  }
215 | }
216 | 


--------------------------------------------------------------------------------
/addons/rpg_database/Scripts/Skill.cs:
--------------------------------------------------------------------------------
  1 | using Godot;
  2 | using System;
  3 | 
  4 | [Tool]
  5 | public class Skill : Control
  6 | {
  7 |     // Declare member variables here. Examples:
  8 |     // private int a = 2;
  9 |     // private string b = "text";
 10 |     string iconPath = "";
 11 |     int skillSelected = 0;
 12 |     // Called when the node enters the scene tree for the first time.
 13 |     public void Start()
 14 |     {
 15 |         Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "Skill") as Godot.Collections.Dictionary;
 16 |         Godot.Collections.Dictionary systemDictionary = this.GetParent().GetParent().Call("ReadData", "System") as Godot.Collections.Dictionary;
 17 |         GetNode<OptionButton>("SkillButton").Clear();
 18 |         for (int i = 0; i < jsonDictionary.Count; i++)
 19 |         {
 20 |             Godot.Collections.Dictionary skillData = jsonDictionary["skill" + i] as Godot.Collections.Dictionary;
 21 |             if (i > GetNode<OptionButton>("SkillButton").GetItemCount() - 1)
 22 |             {
 23 |                 GetNode<OptionButton>("SkillButton").AddItem(skillData["name"] as string);
 24 |             }
 25 |             else
 26 |             {
 27 |                 GetNode<OptionButton>("SkillButton").SetItemText(i, skillData["name"] as string);
 28 |             }
 29 |         }
 30 | 
 31 |         Godot.Collections.Dictionary systemData = systemDictionary["elements"] as Godot.Collections.Dictionary;
 32 |         for (int i = 0; i < systemData.Count; i++)
 33 |         {
 34 |             if (i > GetNode<OptionButton>("DamageLabel/ElementLabel/ElementButton").GetItemCount() - 1)
 35 |             {
 36 |                 GetNode<OptionButton>("DamageLabel/ElementLabel/ElementButton").AddItem(systemData[i.ToString()] as string);
 37 |             }
 38 |             else
 39 |             {
 40 |                 GetNode<OptionButton>("DamageLabel/ElementLabel/ElementButton").SetItemText(i, systemData[i.ToString()] as string);
 41 |             }
 42 |         }
 43 | 
 44 |         systemData = systemDictionary["skills"] as Godot.Collections.Dictionary;
 45 |         for (int i = 0; i < systemData.Count; i++)
 46 |         {
 47 |             if (i > GetNode<OptionButton>("SkillTypeLabel/SkillTypeButton").GetItemCount() - 1)
 48 |             {
 49 |                 GetNode<OptionButton>("SkillTypeLabel/SkillTypeButton").AddItem(systemData[i.ToString()] as string);
 50 |             }
 51 |             else
 52 |             {
 53 |                 GetNode<OptionButton>("SkillTypeLabel/SkillTypeButton").SetItemText(i, systemData[i.ToString()] as string);
 54 |             }
 55 |         }
 56 |         RefreshData(skillSelected);
 57 |     }
 58 | 
 59 |     private void RefreshData(int id)
 60 |     {
 61 |         Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "Skill") as Godot.Collections.Dictionary;
 62 |         Godot.Collections.Dictionary skillData = jsonDictionary["skill" + id] as Godot.Collections.Dictionary;
 63 |         GetNode<LineEdit>("NameLabel/NameText").Text = skillData["name"] as string;
 64 |         string icon = skillData["icon"] as string;
 65 |         if (icon != "")
 66 |         {
 67 |             iconPath = icon;
 68 |             GetNode<Sprite>("IconLabel/IconSprite").Texture = GD.Load(skillData["icon"] as string) as Godot.Texture;
 69 |         }
 70 |         GetNode<TextEdit>("DescLabel/DescText").Text = skillData["description"] as string;
 71 |         GetNode<OptionButton>("SkillTypeLabel/SkillTypeButton").Selected = Convert.ToInt32(skillData["skill_type"]);
 72 |         GetNode<SpinBox>("MPCostLabel/MPCostBox").Value = Convert.ToInt32(skillData["mp_cost"]);
 73 |         GetNode<SpinBox>("TPCostLabel/TPCostBox").Value = Convert.ToInt32(skillData["tp_cost"]);
 74 |         GetNode<OptionButton>("TargetLabel/TargetButton").Selected = Convert.ToInt32(skillData["target"]);
 75 |         GetNode<OptionButton>("UsableLabel/UsableButton").Selected = Convert.ToInt32(skillData["usable"]);
 76 |         GetNode<SpinBox>("HitLabel/HitBox").Value = Convert.ToInt32(skillData["success"]);
 77 |         GetNode<OptionButton>("TypeLabel/TypeButton").Selected = Convert.ToInt32(skillData["hit_type"]);
 78 |         GetNode<OptionButton>("DamageLabel/DTypeLabel/DTypeButton").Selected = Convert.ToInt32(skillData["damage_type"]);
 79 |         GetNode<OptionButton>("DamageLabel/ElementLabel/ElementButton").Selected = Convert.ToInt32(skillData["element"]);
 80 |         GetNode<LineEdit>("DamageLabel/DFormulaLabel/FormulaText").Text = skillData["formula"] as string;
 81 |         if (skillData.Contains("effects") == true)
 82 |         {
 83 |             this.ClearEffectList();
 84 |             Godot.Collections.Array effectList = skillData["effects"] as Godot.Collections.Array;
 85 |             foreach (Godot.Collections.Dictionary effect in effectList)
 86 |             {
 87 |                 this.AddEffectList(effect["name"].ToString(), Convert.ToInt32(effect["data_id"]), effect["value1"].ToString(), effect["value2"].ToString());
 88 |             }
 89 |         }
 90 |     }
 91 | 
 92 |     private void _on_Search_pressed()
 93 |     {
 94 |         GetNode<FileDialog>("IconLabel/IconSearch").PopupCentered();
 95 |     }
 96 | 
 97 |     private void _on_IconSearch_file_selected(string path)
 98 |     {
 99 |         iconPath = path;
100 |         GetNode<Sprite>("IconLabel/IconSprite").Texture = GD.Load(path) as Godot.Texture;
101 |     }
102 | 
103 |     private void _on_AddSkill_pressed()
104 |     {
105 |         GetNode<OptionButton>("SkillButton").AddItem("NewSkill");
106 |         int id = GetNode<OptionButton>("SkillButton").GetItemCount() - 1;
107 |         Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "Skill") as Godot.Collections.Dictionary;
108 |         Godot.Collections.Dictionary skillData = new Godot.Collections.Dictionary();
109 |         skillData.Add("name", "NewSkill");
110 |         skillData.Add("icon", "");
111 |         skillData.Add("description", "New created skill");
112 |         skillData.Add("skill_type", 0);
113 |         skillData.Add("mp_cost", 0);
114 |         skillData.Add("tp_cost", 0);
115 |         skillData.Add("target", 1);
116 |         skillData.Add("usable", 1);
117 |         skillData.Add("success", 95);
118 |         skillData.Add("hit_type", 1);
119 |         skillData.Add("damage_type", 1);
120 |         skillData.Add("element", 0);
121 |         skillData.Add("formula", "atk * 4 - def * 2");
122 |         jsonDictionary.Add("skill" + id, skillData);
123 |         this.GetParent().GetParent().Call("StoreData", "Skill", jsonDictionary);
124 |     }
125 | 
126 |     private void _on_RemoveSkill_pressed()
127 |     {
128 |         Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "Skill") as Godot.Collections.Dictionary;
129 |         if (jsonDictionary.Keys.Count > 1)
130 |         {
131 |             int skillId = skillSelected;
132 |             while (skillId < jsonDictionary.Keys.Count - 1)
133 |             {
134 |                 jsonDictionary["skill" + skillId] = jsonDictionary["skill" + (skillId + 1)];
135 |                 skillId += 1;
136 |             }
137 |             jsonDictionary.Remove("skill" + skillId);
138 |             this.GetParent().GetParent().Call("StoreData", "Skill", jsonDictionary);
139 |             GetNode<OptionButton>("SkillButton").RemoveItem(skillSelected);
140 |             if (skillSelected == 0)
141 |             {
142 |                 GetNode<OptionButton>("SkillButton").Select(skillSelected + 1);
143 |                 skillSelected += 1;
144 |             }
145 |             else
146 |             {
147 |                 GetNode<OptionButton>("SkillButton").Select(skillSelected - 1);
148 |                 skillSelected -= 1;
149 |             }
150 |             GetNode<OptionButton>("SkillButton").Select(skillSelected);
151 |             RefreshData(skillSelected);
152 |         }
153 |     }
154 | 
155 |     private void _on_SkillSaveButton_pressed()
156 |     {
157 |         SaveSkillData();
158 |         RefreshData(skillSelected);
159 |     }
160 |     private void SaveSkillData()
161 |     {
162 |         Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "Skill") as Godot.Collections.Dictionary;
163 |         Godot.Collections.Dictionary skillData = jsonDictionary["skill" + skillSelected] as Godot.Collections.Dictionary;
164 |         Godot.Collections.Array effectList = new Godot.Collections.Array();
165 |         
166 |         skillData["name"] = GetNode<LineEdit>("NameLabel/NameText").Text;
167 |         GetNode<OptionButton>("SkillButton").SetItemText(skillSelected, GetNode<LineEdit>("NameLabel/NameText").Text);
168 |         skillData["icon"] = iconPath;
169 |         skillData["description"] = GetNode<TextEdit>("DescLabel/DescText").Text;
170 |         skillData["skill_type"] = GetNode<OptionButton>("SkillTypeLabel/SkillTypeButton").Selected;
171 |         skillData["mp_cost"] = GetNode<SpinBox>("MPCostLabel/MPCostBox").Value;
172 |         skillData["tp_cost"] = GetNode<SpinBox>("TPCostLabel/TPCostBox").Value;
173 |         skillData["target"] = GetNode<OptionButton>("TargetLabel/TargetButton").Selected;
174 |         skillData["usable"] = GetNode<OptionButton>("UsableLabel/UsableButton").Selected;
175 |         skillData["success"] = GetNode<SpinBox>("HitLabel/HitBox").Value;
176 |         skillData["hit_type"] = GetNode<OptionButton>("TypeLabel/TypeButton").Selected;
177 |         skillData["damage_type"] = GetNode<OptionButton>("DamageLabel/DTypeLabel/DTypeButton").Selected;
178 |         skillData["element"] = GetNode<OptionButton>("DamageLabel/ElementLabel/ElementButton").Selected;
179 |         skillData["formula"] = GetNode<LineEdit>("DamageLabel/DFormulaLabel/FormulaText").Text;
180 |         int effectSize = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").GetItemCount();
181 |         for (int i = 0; i < effectSize; i++)
182 |         {
183 |             Godot.Collections.Dictionary effectData = new Godot.Collections.Dictionary();
184 |             effectData["name"] = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").GetItemText(i);
185 |             effectData["data_id"] = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType").GetItemText(i);
186 |             effectData["value1"] = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1").GetItemText(i);
187 |             effectData["value2"] = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2").GetItemText(i);
188 |             effectList.Add(effectData);
189 |         }
190 |         skillData["effects"] = effectList;
191 |         this.GetParent().GetParent().Call("StoreData", "Skill", jsonDictionary);
192 |     }
193 | 
194 |     private void _on_SkillButton_item_selected(int id)
195 |     {
196 |         skillSelected = id;
197 |         RefreshData(id);
198 |     }
199 | 
200 |     private void _on_AddSkillEffect_pressed()
201 |     {
202 |         this.GetParent().GetParent().Call("OpenEffectManager", "Skill");
203 |     }
204 | 
205 |     private void _on_RemoveSkillEffect_pressed()
206 |     {
207 |         int id = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").GetSelectedItems()[0];
208 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").RemoveItem(id);
209 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType").RemoveItem(id);
210 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1").RemoveItem(id);
211 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2").RemoveItem(id);
212 |     }
213 |     public void AddEffectList(String name, int dataId, String value1, String value2)
214 |     {
215 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").AddItem(name);
216 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType").AddItem(dataId.ToString());
217 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1").AddItem(value1);
218 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2").AddItem(value2);
219 |     }
220 | 
221 |     public void ClearEffectList()
222 |     {
223 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").Clear();
224 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType").Clear();
225 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1").Clear();
226 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2").Clear();
227 |     }
228 |     //  // Called every frame. 'delta' is the elapsed time since the previous frame.
229 |     //  public override void _Process(float delta)
230 |     //  {
231 |     //      
232 |     //  }
233 | }
234 | 


--------------------------------------------------------------------------------
/addons/rpg_database/Scripts/States.cs:
--------------------------------------------------------------------------------
  1 | using Godot;
  2 | using System;
  3 | 
  4 | [Tool]
  5 | public class States : Container
  6 | {
  7 |     // Declare member variables here. Examples:
  8 |     // private int a = 2;
  9 |     // private string b = "text";
 10 | 
 11 |     string iconPath = "";
 12 |     int stateSelected = 0;
 13 |     int add_string = -1;
 14 |     // Called when the node enters the scene tree for the first time.
 15 |     public void Start()
 16 |     {
 17 |         Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "State") as Godot.Collections.Dictionary;
 18 |         GetNode<OptionButton>("StateButton").Clear();
 19 |         for (int i = 0; i < jsonDictionary.Count; i++)
 20 |         {
 21 |             Godot.Collections.Dictionary stateData = jsonDictionary["state" + i] as Godot.Collections.Dictionary;
 22 |             if (i > GetNode<OptionButton>("StateButton").GetItemCount() - 1)
 23 |             {
 24 |                 GetNode<OptionButton>("StateButton").AddItem(stateData["name"] as string);
 25 |             }
 26 |             else
 27 |             {
 28 |                 GetNode<OptionButton>("StateButton").SetItemText(i, stateData["name"] as string);
 29 |             }
 30 |         }
 31 |         RefreshData(stateSelected);
 32 |     }
 33 | 
 34 |     public void RefreshData(int id)
 35 |     {
 36 |         Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "State") as Godot.Collections.Dictionary;
 37 |         Godot.Collections.Dictionary stateData = jsonDictionary["state" + id] as Godot.Collections.Dictionary;
 38 |         Godot.Collections.Dictionary eraseConditions = stateData["erase_conditions"] as Godot.Collections.Dictionary;
 39 |         Godot.Collections.Dictionary messages = stateData["messages"] as Godot.Collections.Dictionary;
 40 |         Godot.Collections.Dictionary customEraseConditions = stateData["custom_erase_conditions"] as Godot.Collections.Dictionary;
 41 |         GetNode<LineEdit>("NameLabel/NameLine").Text = stateData["name"] as string;
 42 |         string icon = stateData["icon"] as string;
 43 |         if (icon != "")
 44 |         {
 45 |             iconPath = stateData["icon"].ToString();
 46 |             GetNode<Sprite>("IconLabel/Sprite").Texture = GD.Load(stateData["icon"] as string) as Godot.Texture;
 47 |         }
 48 |         GetNode<OptionButton>("RestrictionLabel/RestrictionOption").Selected = Convert.ToInt32(stateData["restriction"]);
 49 |         GetNode<SpinBox>("PriorityLabel/PriorityValue").Value = Convert.ToInt32(stateData["priority"]);
 50 |         GetNode<SpinBox>("EraseLabel/TurnsLabel/MinTurns").Value = Convert.ToInt32(eraseConditions["turns_min"]);
 51 |         GetNode<SpinBox>("EraseLabel/TurnsLabel/MaxTurns").Value = Convert.ToInt32(eraseConditions["turns_max"]);
 52 |         GetNode<SpinBox>("EraseLabel/DamageLabel/Damage").Value = Convert.ToInt32(eraseConditions["erase_damage"]);
 53 |         GetNode<SpinBox>("EraseLabel/SetpsLabel/SpinBox").Value = Convert.ToInt32(eraseConditions["erase_setps"]);
 54 |         GetNode<ItemList>("MessagesLabel/PanelContainer/VBoxContainer/MessageList").Clear();
 55 |         foreach (String message in messages.Values)
 56 |         {
 57 |             GetNode<ItemList>("MessagesLabel/PanelContainer/VBoxContainer/MessageList").AddItem(message);
 58 |         }
 59 |         GetNode<ItemList>("CustomEraseLabel/PanelContainer/VBoxContainer/EraseConditions").Clear();
 60 |         foreach (String condition in customEraseConditions.Values)
 61 |         {
 62 |             GetNode<ItemList>("CustomEraseLabel/PanelContainer/VBoxContainer/EraseConditions").AddItem(condition);
 63 |         }
 64 |         if (stateData.Contains("effects") == true)
 65 |         {
 66 |             this.ClearEffectList();
 67 |             Godot.Collections.Array effectList = stateData["effects"] as Godot.Collections.Array;
 68 |             foreach (Godot.Collections.Dictionary effect in effectList)
 69 |             {
 70 |                 this.AddEffectList(effect["name"].ToString(), Convert.ToInt32(effect["data_id"]), effect["value1"].ToString(), effect["value2"].ToString());
 71 |             }
 72 |         }
 73 |     }
 74 | 
 75 |     private void _on_SearchState_pressed()
 76 |     {
 77 |         GetNode<FileDialog>("IconLabel/SearchDialog").PopupCentered();
 78 |     }
 79 | 
 80 |     private void _on_SearchStateIconDialog_file_selected(String path)
 81 |     {
 82 |         iconPath = path;
 83 |         GetNode<Sprite>("IconLabel/Sprite").Texture = GD.Load(path) as Godot.Texture;
 84 |     }
 85 | 
 86 |     private void _on_AddCustomStateCondition_pressed()
 87 |     {
 88 |         add_string = 0;
 89 |         GetNode<WindowDialog>("AddString").WindowTitle = "Custom State Erase Formula";
 90 |         GetNode<WindowDialog>("AddString").PopupCentered();
 91 |     }
 92 | 
 93 |     private void _on_RemoveCustomStateCondition_pressed()
 94 |     {
 95 |         int selected = GetNode<ItemList>("CustomEraseLabel/PanelContainer/VBoxContainer/EraseConditions").GetSelectedItems()[0];
 96 |         if (selected > -1)
 97 |         {
 98 |             GetNode<ItemList>("CustomEraseLabel/PanelContainer/VBoxContainer/EraseConditions").RemoveItem(selected);
 99 |         }
100 |     }
101 | 
102 |     private void _on_AddStateMessage_pressed()
103 |     {
104 |         add_string = 1;
105 |         GetNode<WindowDialog>("AddString").WindowTitle = "State Message";
106 |         GetNode<WindowDialog>("AddString").PopupCentered();
107 |     }
108 | 
109 |     private void _on_RemoveStateMessage_pressed()
110 |     {
111 |         int selected = GetNode<ItemList>("MessagesLabel/PanelContainer/VBoxContainer/MessageList").GetSelectedItems()[0];
112 |         if (selected > -1)
113 |         {
114 |             GetNode<ItemList>("MessagesLabel/PanelContainer/VBoxContainer/MessageList").RemoveItem(selected);
115 |         }
116 |     }
117 | 
118 |     private void _on_ConfirmAddString_pressed()
119 |     {
120 |         String text = GetNode<LineEdit>("AddString/LineEdit").Text;
121 |         if (add_string == 0)
122 |         {
123 |             GetNode<ItemList>("CustomEraseLabel/PanelContainer/VBoxContainer/EraseConditions").AddItem(text);
124 |         }
125 |         else if (add_string == 1)
126 |         {
127 |             GetNode<ItemList>("MessagesLabel/PanelContainer/VBoxContainer/MessageList").AddItem(text);
128 |         }
129 |         add_string = -1;
130 |         GetNode<WindowDialog>("AddString").Hide();
131 |     }
132 | 
133 |     private void _on_CancelAddString_pressed()
134 |     {
135 |         add_string = -1;
136 |         GetNode<WindowDialog>("AddString").Hide();
137 |     }
138 | 
139 |     private void _on_StateButton_item_selected(int id)
140 |     {
141 |         stateSelected = id;
142 |         RefreshData(id);
143 |     }
144 | 
145 |     private void _on_AddState_pressed()
146 |     {
147 |         GetNode<OptionButton>("StateButton").AddItem("NewState");
148 |         int id = GetNode<OptionButton>("StateButton").GetItemCount() - 1;
149 |         Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "State") as Godot.Collections.Dictionary;
150 | 
151 |         Godot.Collections.Dictionary stateData = new Godot.Collections.Dictionary();
152 |         Godot.Collections.Dictionary eraseCondition = new Godot.Collections.Dictionary();
153 |         Godot.Collections.Dictionary messages = new Godot.Collections.Dictionary();
154 |         Godot.Collections.Dictionary customEraseConditions = new Godot.Collections.Dictionary();
155 |         stateData.Add("name", "NewState");
156 |         stateData.Add("icon", "");
157 |         stateData.Add("restriction", 4);
158 |         stateData.Add("priority", 100);
159 |         eraseCondition.Add("turns_min", 0);
160 |         eraseCondition.Add("turns_max", 0);
161 |         eraseCondition.Add("erase_damage", 0);
162 |         eraseCondition.Add("erase_setps", 0);
163 |         stateData.Add("erase_conditions", eraseCondition);
164 |         messages.Add("0", "Insert a custom message");
165 |         stateData.Add("messages", messages);
166 |         customEraseConditions.Add("0", "Insert a custom condition");
167 |         stateData.Add("custom_erase_conditions", customEraseConditions);
168 | 
169 |         jsonDictionary.Add("state" + id, stateData);
170 |         this.GetParent().GetParent().Call("StoreData", "State", jsonDictionary);
171 |     }
172 | 
173 |     private void _on_RemoveState_pressed()
174 |     {
175 |         Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "State") as Godot.Collections.Dictionary;
176 |         if (jsonDictionary.Keys.Count > 1)
177 |         {
178 |             int stateId = stateSelected;
179 |             while (stateId < jsonDictionary.Keys.Count - 1)
180 |             {
181 |                 jsonDictionary["state" + stateId] = jsonDictionary["state" + (stateId + 1)];
182 |                 stateId += 1;
183 |             }
184 |             jsonDictionary.Remove("state" + stateId);
185 |             this.GetParent().GetParent().Call("StoreData", "State", jsonDictionary);
186 |             GetNode<OptionButton>("StateButton").RemoveItem(stateSelected);
187 |             if (stateSelected == 0)
188 |             {
189 |                 GetNode<OptionButton>("StateButton").Select(stateSelected + 1);
190 |                 stateSelected += 1;
191 |             }
192 |             else
193 |             {
194 |                 GetNode<OptionButton>("StateButton").Select(stateSelected - 1);
195 |                 stateSelected -= 1;
196 |             }
197 |             GetNode<OptionButton>("StateButton").Select(stateSelected);
198 |             RefreshData(stateSelected);
199 |         }
200 |     }
201 | 
202 |     private void _on_SaveStates_pressed()
203 |     {
204 |         Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "State") as Godot.Collections.Dictionary;
205 |         Godot.Collections.Dictionary stateData = jsonDictionary["state" + stateSelected] as Godot.Collections.Dictionary;
206 |         Godot.Collections.Dictionary eraseCondition = stateData["erase_conditions"] as Godot.Collections.Dictionary;
207 |         Godot.Collections.Dictionary messages = stateData["messages"] as Godot.Collections.Dictionary;
208 |         Godot.Collections.Dictionary customEraseConditions = stateData["custom_erase_conditions"] as Godot.Collections.Dictionary;
209 |         Godot.Collections.Array effectList = new Godot.Collections.Array();
210 | 
211 |         stateData["name"] = GetNode<LineEdit>("NameLabel/NameLine").Text;
212 |         stateData["icon"] = iconPath;
213 |         stateData["restriction"] = GetNode<OptionButton>("RestrictionLabel/RestrictionOption").Selected;
214 |         stateData["priority"] = GetNode<SpinBox>("PriorityLabel/PriorityValue").Value;
215 |         eraseCondition["turns_min"] = GetNode<SpinBox>("EraseLabel/TurnsLabel/MinTurns").Value;
216 |         eraseCondition["turns_max"] = GetNode<SpinBox>("EraseLabel/TurnsLabel/MaxTurns").Value;
217 |         eraseCondition["erase_damage"] = GetNode<SpinBox>("EraseLabel/DamageLabel/Damage").Value;
218 |         eraseCondition["erase_setps"] = GetNode<SpinBox>("EraseLabel/SetpsLabel/SpinBox").Value;
219 |         int items = GetNode<ItemList>("MessagesLabel/PanelContainer/VBoxContainer/MessageList").GetItemCount();
220 |         for (int i = 0; i < items; i++)
221 |         {
222 |             messages[i.ToString()] = GetNode<ItemList>("MessagesLabel/PanelContainer/VBoxContainer/MessageList").GetItemText(i);
223 |         }
224 |         items = GetNode<ItemList>("CustomEraseLabel/PanelContainer/VBoxContainer/EraseConditions").GetItemCount();
225 |         for (int i = 0; i < items; i++)
226 |         {
227 |             customEraseConditions[i.ToString()] = GetNode<ItemList>("CustomEraseLabel/PanelContainer/VBoxContainer/EraseConditions").GetItemText(i);
228 |         }
229 | 
230 |         int effectSize = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").GetItemCount();
231 |         for (int i = 0; i < effectSize; i++)
232 |         {
233 |             Godot.Collections.Dictionary effectData = new Godot.Collections.Dictionary();
234 |             effectData["name"] = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").GetItemText(i);
235 |             effectData["data_id"] = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType").GetItemText(i);
236 |             effectData["value1"] = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1").GetItemText(i);
237 |             effectData["value2"] = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2").GetItemText(i);
238 |             effectList.Add(effectData);
239 |         }
240 |         stateData["effects"] = effectList;
241 |         this.GetParent().GetParent().Call("StoreData", "State", jsonDictionary);
242 |         RefreshData(stateSelected);
243 |     }
244 |     private void _on_AddStateEffect_pressed()
245 |     {
246 |         this.GetParent().GetParent().Call("OpenEffectManager", "States");
247 |     }
248 | 
249 |     private void _on_RemoveStateEffect_pressed()
250 |     {
251 |         int id = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").GetSelectedItems()[0];
252 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").RemoveItem(id);
253 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType").RemoveItem(id);
254 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1").RemoveItem(id);
255 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2").RemoveItem(id);
256 |     }
257 |     public void AddEffectList(String name, int dataId, String value1, String value2)
258 |     {
259 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").AddItem(name);
260 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType").AddItem(dataId.ToString());
261 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1").AddItem(value1);
262 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2").AddItem(value2);
263 |     }
264 | 
265 |     public void ClearEffectList()
266 |     {
267 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").Clear();
268 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType").Clear();
269 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1").Clear();
270 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2").Clear();
271 |     }
272 |     //  // Called every frame. 'delta' is the elapsed time since the previous frame.
273 |     //  public override void _Process(float delta)
274 |     //  {
275 |     //      
276 |     //  }
277 | }
278 | 


--------------------------------------------------------------------------------
/addons/rpg_database/Scripts/Weapon.cs:
--------------------------------------------------------------------------------
  1 | using Godot;
  2 | using System;
  3 | 
  4 | [Tool]
  5 | public class Weapon : Control
  6 | {
  7 |     // Declare member variables here. Examples:
  8 |     // private int a = 2;
  9 |     // private string b = "text";
 10 | 
 11 |     string iconPath = "";
 12 |     int weaponSelected = 0;
 13 |     int statEdit = -1;
 14 |     // Called when the node enters the scene tree for the first time.
 15 |     public void Start()
 16 |     {
 17 |         Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "Weapon") as Godot.Collections.Dictionary;
 18 |         GetNode<OptionButton>("WeaponButton").Clear();
 19 |         for (int i = 0; i < jsonDictionary.Count; i++)
 20 |         {
 21 |             Godot.Collections.Dictionary weaponData = jsonDictionary["weapon" + i] as Godot.Collections.Dictionary;
 22 |             if (i > GetNode<OptionButton>("WeaponButton").GetItemCount() - 1)
 23 |             {
 24 |                 GetNode<OptionButton>("WeaponButton").AddItem(weaponData["name"] as string);
 25 |             }
 26 |             else
 27 |             {
 28 |                 GetNode<OptionButton>("WeaponButton").SetItemText(i, weaponData["name"] as string);
 29 |             }
 30 |         }
 31 | 
 32 |         jsonDictionary = this.GetParent().GetParent().Call("ReadData", "System") as Godot.Collections.Dictionary;
 33 |         
 34 |         Godot.Collections.Dictionary systemData = jsonDictionary["elements"] as Godot.Collections.Dictionary;
 35 |         for (int i = 0; i < systemData.Count; i++)
 36 |         {
 37 |             if (i > GetNode<OptionButton>("ElementLabel/ElementButton").GetItemCount() - 1)
 38 |             {
 39 |                 GetNode<OptionButton>("ElementLabel/ElementButton").AddItem(systemData[i.ToString()] as string);
 40 |             }
 41 |             else
 42 |             {
 43 |                 GetNode<OptionButton>("ElementLabel/ElementButton").SetItemText(i, systemData[i.ToString()] as string);
 44 |             }
 45 |         }
 46 | 
 47 |         systemData = jsonDictionary["weapons"] as Godot.Collections.Dictionary;
 48 |         for (int i = 0; i < systemData.Count; i++)
 49 |         {
 50 |             if (i > GetNode<OptionButton>("WTypeLabel/WTypeButton").GetItemCount() - 1)
 51 |             {
 52 |                 GetNode<OptionButton>("WTypeLabel/WTypeButton").AddItem(systemData[i.ToString()] as string);
 53 |             }
 54 |             else
 55 |             {
 56 |                 GetNode<OptionButton>("WTypeLabel/WTypeButton").SetItemText(i, systemData[i.ToString()] as string);
 57 |             }
 58 |         }
 59 | 
 60 |         systemData = jsonDictionary["slots"] as Godot.Collections.Dictionary;
 61 |         int final_id = 0;
 62 |         foreach (String str in systemData.Keys)
 63 |         {
 64 |             if (str[0] == 'w')
 65 |             {
 66 |                 int id = Convert.ToInt32(str.Remove(0, 1)) - final_id;
 67 |                 if (id > GetNode<OptionButton>("SlotLabel/SlotButton").GetItemCount() - 1)
 68 |                 {
 69 |                     GetNode<OptionButton>("SlotLabel/SlotButton").AddItem(systemData[str] as string);
 70 |                 }
 71 |                 else
 72 |                 {
 73 |                     GetNode<OptionButton>("SlotLabel/SlotButton").SetItemText(id, systemData[str] as string);
 74 |                 }
 75 |             }
 76 |             else
 77 |             {
 78 |                 final_id += 1;
 79 |             }
 80 |         }
 81 |         RefreshData(weaponSelected);
 82 |     }
 83 | 
 84 |     private void RefreshData(int id)
 85 |     {
 86 |         Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "Weapon") as Godot.Collections.Dictionary;
 87 |         Godot.Collections.Dictionary weaponData = jsonDictionary["weapon" + id] as Godot.Collections.Dictionary;
 88 | 
 89 |         jsonDictionary = this.GetParent().GetParent().Call("ReadData", "System") as Godot.Collections.Dictionary;
 90 |         Godot.Collections.Dictionary systemData = jsonDictionary["stats"] as Godot.Collections.Dictionary;
 91 | 
 92 |         GetNode<LineEdit>("NameLabel/NameText").Text = weaponData["name"] as string;
 93 |         string icon = weaponData["icon"] as string;
 94 |         if (icon != "")
 95 |         {
 96 |             iconPath = icon;
 97 |             GetNode<Sprite>("IconLabel/IconSprite").Texture = GD.Load(weaponData["icon"] as string) as Godot.Texture;
 98 |         }
 99 |         GetNode<TextEdit>("DescLabel/DescText").Text = weaponData["description"] as string;
100 |         GetNode<OptionButton>("WTypeLabel/WTypeButton").Selected = Convert.ToInt32(weaponData["weapon_type"]);
101 |         GetNode<OptionButton>("SlotLabel/SlotButton").Selected = Convert.ToInt32(weaponData["slot_type"]);
102 |         GetNode<SpinBox>("PriceLabel/PriceSpin").Value = Convert.ToInt32(weaponData["price"]);
103 |         GetNode<OptionButton>("ElementLabel/ElementButton").Selected = Convert.ToInt32(weaponData["element"]);
104 | 
105 |         GetNode<ItemList>("StatsLabel/StatsContainer/DataContainer/StatNameCont/StatNameList").Clear();
106 |         GetNode<ItemList>("StatsLabel/StatsContainer/DataContainer/StatValueCont/StatValueList").Clear();
107 |         for (int i = 0; i < systemData.Count; i++)
108 |         {
109 |             string statName = systemData[i.ToString()] as string;
110 |             Godot.Collections.Dictionary weaponStatFormula = weaponData["stat_list"] as Godot.Collections.Dictionary;
111 |             string statFormula = "";
112 |             if (weaponStatFormula.Contains(statName))
113 |             {
114 |                 statFormula = weaponStatFormula[statName as string] as string;
115 |             }
116 |             else
117 |             {
118 |                 statFormula = "0";
119 |             }
120 |             GetNode<ItemList>("StatsLabel/StatsContainer/DataContainer/StatNameCont/StatNameList").AddItem(statName);
121 |             GetNode<ItemList>("StatsLabel/StatsContainer/DataContainer/StatValueCont/StatValueList").AddItem(statFormula);
122 |         }
123 |         if (weaponData.Contains("effects") == true)
124 |         {
125 |             this.ClearEffectList();
126 |             Godot.Collections.Array effectList = weaponData["effects"] as Godot.Collections.Array;
127 |             foreach (Godot.Collections.Dictionary effect in effectList)
128 |             {
129 |                 this.AddEffectList(effect["name"].ToString(), Convert.ToInt32(effect["data_id"]), effect["value1"].ToString(), effect["value2"].ToString());
130 |             }
131 |         }
132 | 
133 |     }
134 | 
135 |     private void _on_AddWeaponButton_pressed()
136 |     {
137 |         GetNode<OptionButton>("WeaponButton").AddItem("NewWeapon");
138 |         int id = GetNode<OptionButton>("WeaponButton").GetItemCount() - 1;
139 |         Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "Weapon") as Godot.Collections.Dictionary;
140 |         Godot.Collections.Dictionary weaponData = new Godot.Collections.Dictionary();
141 |         Godot.Collections.Dictionary weaponStats = new Godot.Collections.Dictionary();
142 |         weaponData.Add("name", "NewWeapon");
143 |         weaponData.Add("icon", "");
144 |         weaponData.Add("description", "New created weapon");
145 |         weaponData.Add("weapon_type", 0);
146 |         weaponData.Add("slot_type", 0);
147 |         weaponData.Add("price", 50);
148 |         weaponData.Add("element", 0);
149 |         weaponStats.Add("hp", "0");
150 |         weaponStats.Add("mp", "0");
151 |         weaponStats.Add("atk", "0");
152 |         weaponStats.Add("def", "0");
153 |         weaponStats.Add("int", "0");
154 |         weaponStats.Add("res", "0");
155 |         weaponStats.Add("spd", "0");
156 |         weaponStats.Add("luk", "0");
157 |         weaponData.Add("stat_list", weaponStats);
158 |         jsonDictionary.Add("weapon" + id, weaponData);
159 |         this.GetParent().GetParent().Call("StoreData", "Weapon", jsonDictionary);
160 |     }
161 | 
162 |     private void _on_RemoveWeapon_pressed()
163 |     {
164 |         Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "Weapon") as Godot.Collections.Dictionary;
165 |         if (jsonDictionary.Keys.Count > 1)
166 |         {
167 |             int weaponId = weaponSelected;
168 |             while (weaponId < jsonDictionary.Keys.Count - 1)
169 |             {
170 |                 jsonDictionary["weapon" + weaponId] = jsonDictionary["weapon" + (weaponId + 1)];
171 |                 weaponId += 1;
172 |             }
173 |             jsonDictionary.Remove("weapon" + weaponId);
174 |             this.GetParent().GetParent().Call("StoreData", "Weapon", jsonDictionary);
175 |             GetNode<OptionButton>("WeaponButton").RemoveItem(weaponSelected);
176 |             if (weaponSelected == 0)
177 |             {
178 |                 GetNode<OptionButton>("WeaponButton").Select(weaponSelected + 1);
179 |                 weaponSelected += 1;
180 |             }
181 |             else
182 |             {
183 |                 GetNode<OptionButton>("WeaponButton").Select(weaponSelected - 1);
184 |                 weaponSelected -= 1;
185 |             }
186 |             GetNode<OptionButton>("WeaponButton").Select(weaponSelected);
187 |             RefreshData(weaponSelected);
188 |         }
189 |     }
190 | 
191 |     private void _on_WeaponSaveButton_pressed()
192 |     {
193 |         SaveWeaponData();
194 |         RefreshData(weaponSelected);
195 |     }
196 | 
197 |     private void _on_Search_pressed()
198 |     {
199 |         GetNode<FileDialog>("IconLabel/IconSearch").PopupCentered();
200 |     }
201 | 
202 |     private void _on_IconSearch_file_selected(string path)
203 |     {
204 |         iconPath = path;
205 |         GetNode<Sprite>("IconLabel/IconSprite").Texture = GD.Load(path) as Godot.Texture;
206 |     }
207 | 
208 |     private void _on_WeaponButton_item_selected(int id)
209 |     {
210 |         weaponSelected = id;
211 |         RefreshData(id);
212 |     }
213 | 
214 |     private void SaveWeaponData()
215 |     {
216 |         Godot.Collections.Dictionary jsonDictionary = this.GetParent().GetParent().Call("ReadData", "Weapon") as Godot.Collections.Dictionary;
217 |         Godot.Collections.Dictionary weaponData = jsonDictionary["weapon" + weaponSelected] as Godot.Collections.Dictionary;
218 |         Godot.Collections.Dictionary weaponStatFormula = weaponData["stat_list"] as Godot.Collections.Dictionary;
219 |         Godot.Collections.Array effectList = new Godot.Collections.Array();
220 | 
221 |         weaponData["name"] = GetNode<LineEdit>("NameLabel/NameText").Text;
222 |         GetNode<OptionButton>("WeaponButton").SetItemText(weaponSelected, GetNode<LineEdit>("NameLabel/NameText").Text);
223 |         weaponData["icon"] = iconPath;
224 |         weaponData["description"] = GetNode<TextEdit>("DescLabel/DescText").Text;
225 |         weaponData["weapon_type"] = GetNode<OptionButton>("WTypeLabel/WTypeButton").Selected;
226 |         weaponData["slot_type"] = GetNode<OptionButton>("SlotLabel/SlotButton").Selected;
227 |         weaponData["price"] = GetNode<SpinBox>("PriceLabel/PriceSpin").Value;
228 |         weaponData["element"] = GetNode<OptionButton>("ElementLabel/ElementButton").Selected;
229 |         int items = GetNode<ItemList>("StatsLabel/StatsContainer/DataContainer/StatNameCont/StatNameList").GetItemCount();
230 |         for (int i = 0; i < items; i++)
231 |         {
232 |             string stat = GetNode<ItemList>("StatsLabel/StatsContainer/DataContainer/StatNameCont/StatNameList").GetItemText(i);
233 |             string formula = GetNode<ItemList>("StatsLabel/StatsContainer/DataContainer/StatValueCont/StatValueList").GetItemText(i);
234 |             weaponStatFormula[stat] = formula;
235 |         }
236 |         int effectSize = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").GetItemCount();
237 |         for (int i = 0; i < effectSize; i++)
238 |         {
239 |             Godot.Collections.Dictionary effectData = new Godot.Collections.Dictionary();
240 |             effectData["name"] = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").GetItemText(i);
241 |             effectData["data_id"] = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType").GetItemText(i);
242 |             effectData["value1"] = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1").GetItemText(i);
243 |             effectData["value2"] = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2").GetItemText(i);
244 |             effectList.Add(effectData);
245 |         }
246 |         weaponData["effects"] = effectList;
247 |         this.GetParent().GetParent().Call("StoreData", "Weapon", jsonDictionary);
248 |     }
249 | 
250 |     private void _on_StatValueList_item_activated(int index)
251 |     {
252 |         string stat_name = GetNode<ItemList>("StatsLabel/StatsContainer/DataContainer/StatNameCont/StatNameList").GetItemText(index);
253 |         string stat_formula = GetNode<ItemList>("StatsLabel/StatsContainer/DataContainer/StatValueCont/StatValueList").GetItemText(index);
254 |         GetNode<Label>("StatEditor/StatLabel").Text = stat_name;
255 |         GetNode<LineEdit>("StatEditor/StatEdit").Text = stat_formula;
256 |         statEdit = index;
257 |         GetNode<WindowDialog>("StatEditor").Show();
258 |     }
259 | 
260 |     private void _on_OkButton_pressed()
261 |     {
262 |         string stat_formula = GetNode<LineEdit>("StatEditor/StatEdit").Text;
263 |         GetNode<ItemList>("StatsLabel/StatsContainer/DataContainer/StatValueCont/StatValueList").SetItemText(statEdit, stat_formula);
264 |         SaveWeaponData();
265 |         statEdit = -1;
266 |         GetNode<WindowDialog>("StatEditor").Hide();
267 |     }
268 | 
269 |     private void _on_CancelButton_pressed()
270 |     {
271 |         statEdit = -1;
272 |         GetNode<WindowDialog>("StatEditor").Hide();
273 |     }
274 |     
275 |     private void _on_AddWeaponEffect_pressed()
276 |     {
277 |         this.GetParent().GetParent().Call("OpenEffectManager", "Weapon");
278 |     }
279 | 
280 |     private void _on_RemoveWeaponEffect_pressed()
281 |     {
282 |         int id = GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").GetSelectedItems()[0];
283 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").RemoveItem(id);
284 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType").RemoveItem(id);
285 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1").RemoveItem(id);
286 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2").RemoveItem(id);
287 |     }
288 |     public void AddEffectList(String name, int dataId, String value1, String value2)
289 |     {
290 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").AddItem(name);
291 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType").AddItem(dataId.ToString());
292 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1").AddItem(value1);
293 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2").AddItem(value2);
294 |     }
295 | 
296 |     public void ClearEffectList()
297 |     {
298 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames").Clear();
299 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType").Clear();
300 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1").Clear();
301 |         GetNode<ItemList>("EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2").Clear();
302 |     }
303 |     //  // Called every frame. 'delta' is the elapsed time since the previous frame.
304 |     //  public override void _Process(float delta)
305 |     //  {
306 |     //      
307 |     //  }
308 | }
309 | 


--------------------------------------------------------------------------------
/addons/rpg_database/database.cs:
--------------------------------------------------------------------------------
 1 | #if TOOLS
 2 | using Godot;
 3 | using System;
 4 | 
 5 | [Tool]
 6 | public class database : EditorPlugin
 7 | {
 8 |     PackedScene MainPanel = (PackedScene)ResourceLoader.Load("res://addons/rpg_database/Scenes/Base.tscn");
 9 |     Control instanced_scene;
10 |     Button button = new Button();
11 |     public override void _Ready()
12 |     {
13 |     }
14 | 
15 |     public override void _EnterTree()
16 |     {   
17 |         instanced_scene = (Control)MainPanel.Instance();
18 |         button.Text = "Database";
19 |         button.Connect("pressed",this,"_on_button_pressed");
20 |         AddControlToContainer(0, button);
21 |         AddChild(instanced_scene);
22 |     }
23 |     public override void _ExitTree()
24 |     {
25 |         RemoveChild(instanced_scene);
26 |         RemoveControlFromContainer(0, button);
27 |         if (instanced_scene != null) {
28 |             instanced_scene.QueueFree();
29 |         }
30 |     }
31 | 
32 |     public void _on_button_pressed()
33 |     {
34 |         if (instanced_scene.Visible == false)
35 |         {
36 |             Vector2 pos = new Vector2(150, 150);
37 |             instanced_scene.SetPosition(pos);
38 |             instanced_scene.Show();
39 |         }
40 |         else
41 |         {
42 |             instanced_scene.Hide();
43 |         }
44 |     }
45 | }
46 | #endif


--------------------------------------------------------------------------------
/addons/rpg_database/plugin.cfg:
--------------------------------------------------------------------------------
1 | [plugin]
2 | 
3 | name="RPG Databases"
4 | description=""
5 | author="sdtv9507"
6 | version="1.1.1"
7 | script="database.cs"
8 | 


--------------------------------------------------------------------------------
/addons/rpg_databases_gd/Scripts/armor.gd:
--------------------------------------------------------------------------------
  1 | extends Container
  2 | tool
  3 | 
  4 | # Declare member variables here. Examples:
  5 | # var a = 2
  6 | # var b = "text"
  7 | 
  8 | var icon_path: String = ""
  9 | var armor_selected: int = 0
 10 | var stat_edit: int = -1
 11 | # Called when the node enters the scene tree for the first time.
 12 | func _ready():
 13 | 	pass # Replace with function body.
 14 | 
 15 | func start() -> void:
 16 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Armor")
 17 | 	$ArmorButton.clear()
 18 | 	for i in range(json_dictionary.size()):
 19 | 		var armor_data: Dictionary = json_dictionary["armor"+String(i)]
 20 | 		if i > $ArmorButton.get_item_count() - 1:
 21 | 			$ArmorButton.add_item(armor_data["name"])
 22 | 		else:
 23 | 			$ArmorButton.set_item_text(i, armor_data["name"])
 24 | 	json_dictionary = get_parent().get_parent().call("read_data", "System")
 25 | 	var system_data: Dictionary = json_dictionary["armors"]
 26 | 	for i in range(system_data.size()):
 27 | 		if i > $ATypeLabel/ATypeButton.get_item_count() - 1:
 28 | 			$ATypeLabel/ATypeButton.add_item(system_data[String(i)])
 29 | 		else:
 30 | 			$ATypeLabel/ATypeButton.set_item_text(i, system_data[String(i)])
 31 | 	system_data = json_dictionary["slots"]
 32 | 	var final_id: int = 0
 33 | 	for string in system_data.keys():
 34 | 		if string[0] == "w":
 35 | 			var id = string
 36 | 			id.erase(0, 1)
 37 | 			if int(id) > $SlotLabel/SlotButton.get_item_count() - 1:
 38 | 				$SlotLabel/SlotButton.add_item(system_data[string])
 39 | 			else:
 40 | 				$SlotLabel/SlotButton.set_item_text(int(id), system_data[string])
 41 | 		else:
 42 | 			final_id += 1
 43 | 	refresh_data(armor_selected)
 44 | 
 45 | func refresh_data(id: int) -> void:
 46 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Armor")
 47 | 	var armor_data: Dictionary = json_dictionary["armor" + String(id)]
 48 | 	json_dictionary = get_parent().get_parent().call("read_data", "System")
 49 | 	var system_data: Dictionary = json_dictionary["stats"]
 50 | 	$NameLabel/NameText.text = armor_data["name"]
 51 | 	var icon: String = armor_data["icon"]
 52 | 	if icon != "":
 53 | 		icon_path = icon
 54 | 		$IconLabel/IconSprite.texture = load(icon)
 55 | 	$DescLabel/DescText.text = armor_data["description"]
 56 | 	$ATypeLabel/ATypeButton.selected = int(armor_data["armor_type"])
 57 | 	$SlotLabel/SlotButton.selected = int(armor_data["slot_type"])
 58 | 	$PriceLabel/PriceSpin.value = int(armor_data["price"])
 59 | 	
 60 | 	$StatsLabel/StatsContainer/DataContainer/StatNameCont/StatNameList.clear()
 61 | 	$StatsLabel/StatsContainer/DataContainer/StatValueCont/StatValueList.clear()
 62 | 	for i in range(system_data.size()):
 63 | 		var stat_name: String = system_data[String(i)]
 64 | 		var armor_stat_formula: Dictionary = armor_data["stat_list"]
 65 | 		var stat_formula: String = ""
 66 | 		if armor_stat_formula.has(stat_name):
 67 | 			stat_formula = armor_stat_formula[stat_name]
 68 | 		else:
 69 | 			stat_formula = "0"
 70 | 		$StatsLabel/StatsContainer/DataContainer/StatNameCont/StatNameList.add_item(stat_name)
 71 | 		$StatsLabel/StatsContainer/DataContainer/StatValueCont/StatValueList.add_item(stat_formula)
 72 | 	if armor_data.has("effects") == true:
 73 | 		clear_effect_list()
 74 | 		var effect_list: Array = armor_data["effects"]
 75 | 		for effect in effect_list:
 76 | 			add_effect_list(effect["name"], int(effect["data_id"]), String(effect["value1"]), String(effect["value2"]))
 77 | 
 78 | func _on_AddArmorButton_pressed() -> void:
 79 | 	$ArmorButton.add_item("NewArmor")
 80 | 	var id: int = $ArmorButton.get_item_count() - 1
 81 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Armor")
 82 | 	var armor_data: Dictionary
 83 | 	var armor_stats: Dictionary
 84 | 	armor_data["name"] = "NewArmor"
 85 | 	armor_data["icon"] = ""
 86 | 	armor_data["description"] = "New created armor"
 87 | 	armor_data["armor_type"] = 0
 88 | 	armor_data["slot_type"] = 0
 89 | 	armor_data["price"] = 50
 90 | 	armor_stats["hp"] = "0"
 91 | 	armor_stats["mp"] = "0"
 92 | 	armor_stats["atk"] = "0"
 93 | 	armor_stats["def"] = "0"
 94 | 	armor_stats["int"] = "0"
 95 | 	armor_stats["res"] = "0"
 96 | 	armor_stats["spd"] = "0"
 97 | 	armor_stats["luk"] = "0"
 98 | 	armor_data["stat_list"] = armor_stats
 99 | 	json_dictionary["armor" + String(id)] = armor_data
100 | 	get_parent().get_parent().call("store_data", "Armor", json_dictionary)
101 | 
102 | func _on_RemoveArmor_pressed() -> void:
103 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Armor")
104 | 	if json_dictionary.keys().size() > 1:
105 | 		var armor_id: int = armor_selected
106 | 		while armor_id < (json_dictionary.keys().size() - 1):
107 | 			json_dictionary["armor"+String(armor_id)] = json_dictionary["armor"+String(armor_id+1)]
108 | 			armor_id += 1
109 | 		json_dictionary.erase("armor"+String(armor_id))
110 | 		get_parent().get_parent().call("store_data", "Armor", json_dictionary)
111 | 		$ArmorButton.remove_item(armor_selected)
112 | 		if armor_selected == 0:
113 | 			$ArmorButton.select(armor_selected + 1)
114 | 			armor_selected += 1
115 | 		else:
116 | 			$ArmorButton.select(armor_selected + 1)
117 | 			armor_selected -= 1
118 | 		$ArmorButton.select(armor_selected)
119 | 		refresh_data(armor_selected)
120 | 
121 | func _on_ArmorSaveButton_pressed() -> void:
122 | 	save_armor_data()
123 | 	refresh_data(armor_selected)
124 | 
125 | func _on_Search_pressed() -> void:
126 | 	$IconLabel/IconSearch.popup_centered()
127 | 
128 | func _on_IconSearch_file_selected(path: String) -> void:
129 | 	icon_path = path
130 | 	$IconLabel/IconSprite.texture = load(path)
131 | 
132 | func _on_ArmorButton_item_selected(id: int) -> void:
133 | 	armor_selected = id
134 | 	refresh_data(id)
135 | 
136 | func save_armor_data() -> void:
137 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Armor")
138 | 	var armor_data: Dictionary = json_dictionary["armor"+String(armor_selected)]
139 | 	var armor_stat_formula: Dictionary = armor_data["stat_list"]
140 | 	var effect_list: Array
141 | 	armor_data["name"] = $NameLabel/NameText.text
142 | 	$ArmorButton.set_item_text(armor_selected, $NameLabel/NameText.text)
143 | 	armor_data["icon"] = icon_path
144 | 	armor_data["description"] = $DescLabel/DescText.text
145 | 	armor_data["armor_type"] = $ATypeLabel/ATypeButton.selected
146 | 	armor_data["slot_type"] = $SlotLabel/SlotButton.selected
147 | 	armor_data["price"] = $PriceLabel/PriceSpin.value
148 | 	var items: int = $StatsLabel/StatsContainer/DataContainer/StatNameCont/StatNameList.get_item_count()
149 | 	for i in range(items):
150 | 		var stat: String = $StatsLabel/StatsContainer/DataContainer/StatNameCont/StatNameList.get_item_text(i)
151 | 		var formula: String = $StatsLabel/StatsContainer/DataContainer/StatValueCont/StatValueList.get_item_text(i)
152 | 		armor_stat_formula[stat] = formula
153 | 	var effect_size: int = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.get_item_count()
154 | 	for i in effect_size:
155 | 		var effect_data: Dictionary
156 | 		effect_data["name"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.get_item_text(i)
157 | 		effect_data["data_id"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.get_item_text(i)
158 | 		effect_data["value1"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.get_item_text(i)
159 | 		effect_data["value2"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.get_item_text(i)
160 | 		effect_list.append(effect_data)
161 | 	armor_data["effects"] = effect_list
162 | 	get_parent().get_parent().call("store_data", "Armor", json_dictionary)
163 | 
164 | func _on_StatValueList_item_activated(index: int) -> void:
165 | 	var stat_name: String = $StatsLabel/StatsContainer/DataContainer/StatNameCont/StatNameList.get_item_text(index)
166 | 	var stat_formula: String = $StatsLabel/StatsContainer/DataContainer/StatValueCont/StatValueList.get_item_text(index)
167 | 	$StatEditor/StatLabel.text = stat_name
168 | 	$StatEditor/StatEdit.text = stat_formula
169 | 	stat_edit = index
170 | 	$StatEditor.show()
171 | 
172 | func _on_OkButton_pressed() -> void:
173 | 	var stat_formula: String = $StatEditor/StatEdit.text
174 | 	$StatsLabel/StatsContainer/DataContainer/StatValueCont/StatValueList.set_item_text(stat_edit, stat_formula)
175 | 	save_armor_data()
176 | 	stat_edit = -1
177 | 	$StatEditor.hide()
178 | 
179 | func _on_CancelButton_pressed() -> void:
180 | 	stat_edit = -1
181 | 	$StatEditor.hide()
182 | 
183 | func  _on_AddArmorEffect_pressed() -> void:
184 | 	get_parent().get_parent().call("open_effect_manager", "Armor")
185 | 
186 | func _on_RemoveArmorEffect_pressed() -> void:
187 | 	var id: int = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.get_selected_items()[0]
188 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.remove_item(id)
189 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.remove_item(id)
190 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.remove_item(id)
191 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.remove_item(id)
192 | 
193 | func add_effect_list(name: String, data_id: int, value1: String, value2: String) -> void:
194 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.add_item(name)
195 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.add_item(String(data_id))
196 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.add_item(value1)
197 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.add_item(value2)
198 | 
199 | func clear_effect_list() -> void:
200 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.clear()
201 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.clear()
202 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.clear()
203 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.clear()
204 | 
205 | # Called every frame. 'delta' is the elapsed time since the previous frame.
206 | #func _process(delta):
207 | #	pass
208 | 


--------------------------------------------------------------------------------
/addons/rpg_databases_gd/Scripts/character.gd:
--------------------------------------------------------------------------------
  1 | extends Container
  2 | tool
  3 | 
  4 | # Declare member variables here. Examples:
  5 | # var a = 2
  6 | # var b = "text"
  7 | var face_path: String = ""
  8 | var chara_path: String = ""
  9 | var character_selected: int = 0
 10 | var initial_equip_edit: int = -1
 11 | var equip_id_array: Array
 12 | var equip_edit_array: Array
 13 | var initial_equip_id_array: Array
 14 | onready var character_button = get_node("VBoxContainer/CharacterList/CharacterList/CharacterButton")
 15 | onready var name_text = get_node("VBoxContainer/Body/Data/Top/Top/Name/CenterContainer/NameText")
 16 | onready var description_text = get_node("VBoxContainer/Body/Data/Top/Top/Description/CenterContainer/DescText")
 17 | onready var face_sprite = get_node("VBoxContainer/Body/Data/Top/Top/Face/FaceSprite")
 18 | onready var class_text = get_node("VBoxContainer/Body/Data/Middle/Middle/Class/ClassText")
 19 | onready var ilevel_text = get_node("VBoxContainer/Body/Data/Middle/Middle/iLevel/InitLevelText")
 20 | onready var mlevel_text = get_node("VBoxContainer/Body/Data/Middle/Middle/mLevel/MaxLevelText")
 21 | onready var equip_list = get_node("VBoxContainer/Body/Data/Bottom/Bottom/Equip/EquipContainer/EquipContainer/EquipList")
 22 | onready var etype_list = get_node("VBoxContainer/Body/Data/Bottom/Bottom/Iequip/PanelContainer/TypeContainer/TypeList")
 23 | onready var iequip_list = get_node("VBoxContainer/Body/Data/Bottom/Bottom/Iequip/PanelContainer/TypeContainer/EquipList")
 24 | # Effects
 25 | onready var effect_names = get_node("VBoxContainer/Body/Effects/PanelContainer/VBoxContainer/HBoxContainer/EffectNames")
 26 | onready var data_type = get_node("VBoxContainer/Body/Effects/PanelContainer/VBoxContainer/HBoxContainer/DataType")
 27 | onready var effect_value1 = get_node("VBoxContainer/Body/Effects/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1")
 28 | onready var effect_value2 = get_node("VBoxContainer/Body/Effects/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2")
 29 | 
 30 | 
 31 | # Called when the node enters the scene tree for the first time.
 32 | func _ready():
 33 | 	pass # Replace with function body.
 34 | 
 35 | func start():
 36 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Character")
 37 | 	character_button.clear()
 38 | 	for i in range(json_dictionary.size()):
 39 | 		var chara_data = json_dictionary["chara"+String(i)]
 40 | 		if i > character_button.get_item_count() - 1:
 41 | 			character_button.add_item(chara_data["name"])
 42 | 		else:
 43 | 			character_button.set_item_text(i, chara_data["name"])
 44 | 	refresh_data(character_selected)
 45 | 
 46 | func refresh_data(id: int):
 47 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Character")
 48 | 	var chara_data: Dictionary = json_dictionary["chara"+String(id)]
 49 | 	character_button.set_item_text(id, chara_data["name"])
 50 | 	name_text.text = chara_data["name"]
 51 | 	var face: String = chara_data["faceImage"]
 52 | 	if face != "":
 53 | 		face_path = face
 54 | 		face_sprite.texture = load(face)
 55 | 	if chara_data.has("description"):
 56 | 		description_text.text = chara_data["description"]
 57 | 	else:
 58 | 		description_text.text = ""
 59 | 	ilevel_text.value = chara_data["initialLevel"]
 60 | 	mlevel_text.value = chara_data["maxLevel"]
 61 | 	
 62 | 	json_dictionary = get_parent().get_parent().call("read_data", "System")
 63 | 	var w_type_dictionary: Dictionary = json_dictionary["weapons"]
 64 | 	var a_type_dictionary: Dictionary = json_dictionary["armors"]
 65 | 	var equip_slots_dictionary: Dictionary = json_dictionary["slots"]
 66 | 	
 67 | 	var e_type_dictionary: Dictionary = chara_data["equip_types"]
 68 | 	equip_list.clear()
 69 | 	equip_id_array.clear()
 70 | 	var equip_name: String
 71 | 	for equip in e_type_dictionary.keys():
 72 | 		var kind: String = equip[0]
 73 | 		var type_id: String = String(e_type_dictionary[equip])
 74 | 		equip_id_array.append(e_type_dictionary[equip])
 75 | 		match kind:
 76 | 			"w":
 77 | 				var w_id = String(equip).erase(0, 1)
 78 | 				equip_name = "W: " + w_type_dictionary[type_id]
 79 | 				equip_list.add_item(equip_name)
 80 | 			"a":
 81 | 				var a_id = String(equip).erase(0, 1)
 82 | 				equip_name = "A: " + a_type_dictionary[type_id]
 83 | 				equip_list.add_item(equip_name)
 84 | 	var weapon_list: Dictionary = get_parent().get_parent().call("read_data", "Weapon")
 85 | 	var armor_list: Dictionary = get_parent().get_parent().call("read_data", "Armor")
 86 | 	etype_list.clear()
 87 | 	iequip_list.clear()
 88 | 	var initial_equip_data: Dictionary = chara_data["initial_equip"]
 89 | 	initial_equip_id_array.clear()
 90 | 	for equip in equip_slots_dictionary.keys():
 91 | 		etype_list.add_item(equip_slots_dictionary[equip])
 92 | 		var kind: String = equip[0]
 93 | 		var kind_id = String(equip)
 94 | 		kind_id.erase(0, 1)
 95 | 		match kind:
 96 | 			"w":
 97 | 				var w_id: int = -1
 98 | 				if int(kind_id) < initial_equip_data.keys().size():
 99 | 					w_id = int(initial_equip_data[kind_id])
100 | 				initial_equip_id_array.append(w_id)
101 | 				if w_id >= 0:
102 | 					var weapon_data: Dictionary = weapon_list["weapon"+String(w_id)]
103 | 					iequip_list.add_item(weapon_data["name"])
104 | 				else:
105 | 					iequip_list.add_item("None")
106 | 			"a":
107 | 				var a_id: int = -1
108 | 				if int(kind_id) < initial_equip_data.keys().size():
109 | 					a_id = int(initial_equip_data[kind_id])
110 | 				initial_equip_id_array.append(a_id)
111 | 				if a_id >= 0:
112 | 					var armor_data: Dictionary = armor_list["armor"+String(a_id)]
113 | 					iequip_list.add_item(armor_data["name"])
114 | 				else:
115 | 					iequip_list.add_item("None")
116 | 	json_dictionary = get_parent().get_parent().call("read_data", "Class")
117 | 	class_text.clear()
118 | 	for i in range(json_dictionary.size()):
119 | 		var class_data: Dictionary = json_dictionary["class"+String(i)]
120 | 		class_text.add_item(class_data["name"])
121 | 	
122 | 	if chara_data.has("effects"):
123 | 		clear_effect_list()
124 | 		var effect_list: Array = chara_data["effects"]
125 | 		for effect in effect_list:
126 | 			add_effect_list(effect["name"], int(effect["data_id"]), String(effect["value1"]), String(effect["value2"]))
127 | 
128 | func _on_CharaSaveButton_pressed() -> void:
129 | 	save_character_data();
130 | 	refresh_data(character_selected)
131 | 
132 | func _on_AddButton_pressed() -> void:
133 | 	character_button.add_item("NewCharacter")
134 | 	var id: int = character_button.get_item_count() - 1
135 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Character")
136 | 	var character_data: Dictionary
137 | 	var e_type_data: Dictionary
138 | 	var e_init_data: Dictionary
139 | 	character_data["faceImage"] = ""
140 | 	character_data["charaImage"] = ""
141 | 	character_data["name"] = "NewCharacter"
142 | 	character_data["class"] = 0
143 | 	character_data["description"] = ""
144 | 	character_data["initialLevel"] = 1
145 | 	character_data["maxLevel"] = 99
146 | 	e_type_data["w0"] = 0
147 | 	e_type_data["w1"] = 1
148 | 	e_type_data["a2"] = 0
149 | 	e_type_data["a3"] = 3
150 | 	e_init_data["0"] = -1
151 | 	e_init_data["1"] = -1
152 | 	e_init_data["2"] = -1
153 | 	e_init_data["3"] = -1
154 | 	character_data["initial_equip"] = e_init_data
155 | 	character_data["equip_types"] = e_type_data
156 | 	json_dictionary["chara"+String(id)] = character_data
157 | 	get_parent().get_parent().call("store_data", "Character", json_dictionary)
158 | 
159 | func _on_RemoveCharacterButton_pressed():
160 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Character")
161 | 	if json_dictionary.keys().size() > 1:
162 | 		var chara: int = character_selected
163 | 		while chara < (json_dictionary.keys().size() - 1):
164 | 			json_dictionary["chara"+String(chara)] = json_dictionary["chara"+String(chara+1)]
165 | 			chara += 1
166 | 		json_dictionary.erase("chara"+String(chara))
167 | 		get_parent().get_parent().call("store_data", "Character", json_dictionary)
168 | 		character_button.remove_item(character_selected)
169 | 		if character_selected == 0:
170 | 			character_button.select(character_selected + 1)
171 | 			character_selected += 1
172 | 		else:
173 | 			character_button.select(character_selected + 1)
174 | 			character_selected -= 1
175 | 		character_button.select(character_selected)
176 | 		refresh_data(character_selected)
177 | 
178 | func _on_Search_pressed() -> void:
179 | 	$FaceSearch.popup_centered()
180 | 
181 | func _on_FaceSearch_file_selected(file: String) -> void:
182 | 	face_path = file
183 | 	set_face_image(file)
184 | 
185 | func set_face_image(path: String) -> void:
186 | 	$FaceSprite.texture = load(path)
187 | 
188 | func save_character_data() -> void:
189 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Character")
190 | 	var chara_data: Dictionary = json_dictionary["chara"+String(character_selected)]
191 | 	var equip_type_data: Dictionary = chara_data["equip_types"]
192 | 	var initial_equip_data: Dictionary = chara_data["initial_equip"]
193 | 	var effect_list: Array
194 | 	chara_data["faceImage"] = face_path
195 | 	chara_data["charaImage"] = ""
196 | 	chara_data["name"] = name_text.text
197 | 	character_button.set_item_text(character_selected, name_text.text)
198 | 	chara_data["class"] = class_text.selected
199 | 	chara_data["description"] = description_text.text
200 | 	chara_data["initialLevel"] = ilevel_text.value
201 | 	chara_data["maxLevel"] = mlevel_text.value
202 | 	equip_type_data.clear()
203 | 	var equip_items: int = equip_list.get_item_count()
204 | 	for i in range(equip_items):
205 | 		var kind: String = equip_list.get_item_text(i)[0]
206 | 		match kind:
207 | 			"W":
208 | 				equip_type_data["w"+String(i)] = equip_id_array[i]
209 | 			"A":
210 | 				equip_type_data["a"+String(i)] = equip_id_array[i]
211 | 	chara_data["equip_types"] = equip_type_data
212 | 	var slot_items: int = iequip_list.get_item_count()
213 | 	for i in range(slot_items):
214 | 		var data = initial_equip_id_array[i]
215 | 		initial_equip_data[String(i)] = data
216 | 	chara_data["initial_equip"] = initial_equip_data
217 | 	var effect_size: int = effect_names.get_item_count()
218 | 	for i in range(effect_size):
219 | 		var effect_data: Dictionary
220 | 		effect_data["name"] = effect_names.get_item_text(i)
221 | 		effect_data["data_id"] = data_type.get_item_text(i)
222 | 		effect_data["value1"] = effect_value1.get_item_text(i)
223 | 		effect_data["value2"] = effect_value2.get_item_text(i)
224 | 		effect_list.append(effect_data)
225 | 	chara_data["effects"] = effect_list
226 | 	get_parent().get_parent().call("store_data", "Character", json_dictionary)
227 | 
228 | func _on_CharacterButton_item_selected(id: int) -> void:
229 | 	character_selected = id
230 | 	refresh_data(id)
231 | 
232 | func _on_CancelButton_pressed() -> void:
233 | 	$AddEquip.hide()
234 | 
235 | func _on_AddEquipTypeButton_pressed() -> void:
236 | 	$AddEquip.popup_centered()
237 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "System")
238 | 	var w_type_data: Dictionary = json_dictionary["weapons"]
239 | 	for i in w_type_data.size():
240 | 		if i > $AddEquip/EquipLabel/EquipButton.get_item_count() - 1:
241 | 			$AddEquip/EquipLabel/EquipButton.add_item(w_type_data[String(i)])
242 | 		else:
243 | 			$AddEquip/EquipLabel/EquipButton.set_item_text(i, w_type_data[String(i)])
244 | 
245 | func _on_RemoveEquipTypeButton_pressed() -> void:
246 | 	var selected: int = equip_list.get_selected_items()[0]
247 | 	equip_id_array.remove(selected)
248 | 	equip_list.remove_item(selected)
249 | 
250 | func _on_OkButton_pressed() -> void:
251 | 	var kind: int = $AddEquip/TypeLabel/TypeButton.selected
252 | 	var item: int = $AddEquip/EquipLabel/EquipButton.selected
253 | 	equip_id_array.append(int(item))
254 | 	var item_text: String = $AddEquip/EquipLabel/EquipButton.text
255 | 	match kind:
256 | 		0:
257 | 			equip_list.add_item("W: "+item_text)
258 | 		1:
259 | 			equip_list.add_item("A: "+item_text)
260 | 	$AddEquip.hide()
261 | 
262 | func _on_TypeButton_item_selected(index: int) -> void:
263 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "System")
264 | 	$AddEquip/EquipLabel/EquipButton.clear()
265 | 	match index:
266 | 		0:
267 | 			var w_type_data: Dictionary = json_dictionary["weapons"]
268 | 			for i in range(w_type_data.size()):
269 | 				if i > $AddEquip/EquipLabel/EquipButton.get_item_count() - 1:
270 | 					$AddEquip/EquipLabel/EquipButton.add_item(w_type_data[String(i)])
271 | 				else:
272 | 					$AddEquip/EquipLabel/EquipButton.set_item_text(i, w_type_data[String(i)])
273 | 		1:
274 | 			var a_type_data: Dictionary = json_dictionary["armors"]
275 | 			for i in range(a_type_data.size()):
276 | 				if i > $AddEquip/EquipLabel/EquipButton.get_item_count() - 1:
277 | 					$AddEquip/EquipLabel/EquipButton.add_item(a_type_data[String(i)])
278 | 				else:
279 | 					$AddEquip/EquipLabel/EquipButton.set_item_text(i, a_type_data[String(i)])
280 | 
281 | func _on_EquipList_item_activated(index: int) -> void:
282 | 	initial_equip_edit = index
283 | 	equip_edit_array.append("-1")
284 | 	$InitialEquipChange/Label.text = etype_list.get_item_text(index)
285 | 	$InitialEquipChange/Label/OptionButton.clear()
286 | 	$InitialEquipChange/Label/OptionButton.add_item("None")
287 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Character")
288 | 	var chara_data: Dictionary = json_dictionary["chara"+String(character_selected)]
289 | 	json_dictionary = get_parent().get_parent().call("read_data", "System")
290 | 	var slots_data: Dictionary = json_dictionary["slots"]
291 | 	var equip_types_data: Dictionary = chara_data["equip_types"]
292 | 	if slots_data.has("w"+String(index)):
293 | 		var weapon_list: Dictionary = get_parent().get_parent().call("read_data", "Weapon")
294 | 		var weapon_array: Array
295 | 		for key in equip_types_data.keys():
296 | 			var kind: String = key[0]
297 | 			if kind == "w":
298 | 				weapon_array.append(int(equip_types_data[key]))
299 | 		for weapon in weapon_list.keys():
300 | 			var weapon_data: Dictionary = weapon_list[weapon]
301 | 			if weapon_data["weapon_type"] in weapon_array:
302 | 				var weapon_name = String(weapon)
303 | 				weapon_name.erase(0, 6)
304 | 				equip_edit_array.append(weapon_name)
305 | 				$InitialEquipChange/Label/OptionButton.add_item(weapon_data["name"])
306 | 	elif slots_data.has("a"+String(index)):
307 | 		var armor_list: Dictionary = get_parent().get_parent().call("read_data", "Armor")
308 | 		var armor_array: Array
309 | 		for key in equip_types_data.keys():
310 | 			var kind: String = key[0]
311 | 			if kind == "a":
312 | 				armor_array.append(int(equip_types_data[key]))
313 | 		for armor in armor_list.keys():
314 | 			var armor_data: Dictionary = armor_list[armor]
315 | 			if armor_data["armor_type"] in armor_array:
316 | 				var armor_name = String(armor)
317 | 				armor_name.erase(0, 5)
318 | 				equip_edit_array.append(armor_name)
319 | 				$InitialEquipChange/Label/OptionButton.add_item(armor_data["name"])
320 | 	$InitialEquipChange.popup_centered()
321 | 
322 | func _on_CancelInitialEquipButton_pressed() -> void:
323 | 	initial_equip_edit = -1
324 | 	equip_edit_array.clear()
325 | 	$InitialEquipChange.hide()
326 | 
327 | func _on_OkInitialEquipButton_pressed() -> void:
328 | 	var text: String = $InitialEquipChange/Label/OptionButton.text
329 | 	var selected: int = $InitialEquipChange/Label/OptionButton.selected
330 | 	iequip_list.set_item_text(initial_equip_edit, text)
331 | 	initial_equip_id_array[initial_equip_edit] = equip_edit_array[selected]
332 | 	initial_equip_edit = -1
333 | 	equip_edit_array.clear()
334 | 	$InitialEquipChange.hide()
335 | 
336 | func _on_CharacterAddEffectButton_pressed() -> void:
337 | 	get_parent().get_parent().call("open_effect_manager", "Character")
338 | 
339 | func _on_CharacterRemoveEffectButton_pressed() -> void:
340 | 	var id: int = effect_names.get_selected_items()[0]
341 | 	effect_names.remove_item(id)
342 | 	data_type.remove_item(id)
343 | 	effect_value1.remove_item(id)
344 | 	effect_value2.remove_item(id)
345 | 
346 | func add_effect_list(name: String, data_id: int, value1: String, value2: String) -> void:
347 | 	effect_names.add_item(name)
348 | 	data_type.add_item(String(data_id))
349 | 	effect_value1.add_item(value1)
350 | 	effect_value2.add_item(value2)
351 | 
352 | func clear_effect_list() -> void:
353 | 	effect_names.clear()
354 | 	data_type.clear()
355 | 	effect_value1.clear()
356 | 	effect_value2.clear()
357 | 
358 | # Called every frame. 'delta' is the elapsed time since the previous frame.
359 | #func _process(delta):
360 | #	pass
361 | 


--------------------------------------------------------------------------------
/addons/rpg_databases_gd/Scripts/class.gd:
--------------------------------------------------------------------------------
  1 | extends Container
  2 | tool
  3 | 
  4 | # Declare member variables here. Examples:
  5 | # var a = 2
  6 | # var b = "text"
  7 | 
  8 | var icon_path: String = ""
  9 | var class_selected: int = 0
 10 | var stat_edit: int = 0
 11 | var skill_list_array: Array
 12 | # Called when the node enters the scene tree for the first time.
 13 | func _ready():
 14 | 	pass # Replace with function body.
 15 | 
 16 | func start() -> void:
 17 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Class")
 18 | 	$ClassButton.clear()
 19 | 	for i in range(json_dictionary.size()):
 20 | 		var class_data: Dictionary = json_dictionary["class"+String(i)]
 21 | 		if i > $ClassButton.get_item_count() - 1:
 22 | 			$ClassButton.add_item(class_data["name"])
 23 | 		else:
 24 | 			$ClassButton.set_item_text(i, class_data["name"])
 25 | 	refresh_data(class_selected)
 26 | 
 27 | func refresh_data(id: int) -> void:
 28 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Class")
 29 | 	var class_data: Dictionary = json_dictionary["class"+String(id)]
 30 | 	var class_skill_list: Dictionary = class_data["skill_list"]
 31 | 	json_dictionary = get_parent().get_parent().call("read_data", "System")
 32 | 	var system_stats_data: Dictionary = json_dictionary["stats"]
 33 | 	json_dictionary = get_parent().get_parent().call("read_data", "Skill")
 34 | 	$NameLabel/NameText.text = class_data["name"]
 35 | 	var icon: String = class_data["icon"]
 36 | 	if icon != "":
 37 | 		$IconLabel/IconSprite.texture = load(icon)
 38 | 	$ExpLabel/ExpText.text = class_data["experience"]
 39 | 	$StatsLabel/StatsContainer/DataContainer/StatsListContainer/StatsList.clear()
 40 | 	$StatsLabel/StatsContainer/DataContainer/FormulaListContainer/FormulaList.clear()
 41 | 	for i in range(system_stats_data.size()):
 42 | 		var stat_name: String = system_stats_data[String(i)]
 43 | 		var class_stat_formula = class_data["stat_list"]
 44 | 		var stat_formula: String = ""
 45 | 		if class_stat_formula.has(stat_name):
 46 | 			stat_formula = class_stat_formula[stat_name]
 47 | 		else:
 48 | 			stat_formula = "level * 5"
 49 | 		$StatsLabel/StatsContainer/DataContainer/StatsListContainer/StatsList.add_item(stat_name)
 50 | 		$StatsLabel/StatsContainer/DataContainer/FormulaListContainer/FormulaList.add_item(stat_formula)
 51 | 	$SkillLabel/SkillContainer/HBoxContainer/SkillListContainer/SkillList.clear()
 52 | 	$SkillLabel/SkillContainer/HBoxContainer/SkillLevelContainer/SkillLevelList.clear()
 53 | 	for element in class_skill_list.keys():
 54 | 		skill_list_array.append(element)
 55 | 		var skill_data: Dictionary = json_dictionary["skill"+String(element)]
 56 | 		var skill_name: String = skill_data["name"]
 57 | 		$SkillLabel/SkillContainer/HBoxContainer/SkillListContainer/SkillList.add_item(skill_name)
 58 | 		var level: String = String(class_skill_list[String(element)])
 59 | 		$SkillLabel/SkillContainer/HBoxContainer/SkillLevelContainer/SkillLevelList.add_item(level)
 60 | 	$SkillLabel/AddSkill/SkillLabel/OptionButton.clear()
 61 | 	for element in json_dictionary.keys():
 62 | 		var skill_data: Dictionary = json_dictionary[element]
 63 | 		var name: String = String(skill_data["name"])
 64 | 		$SkillLabel/AddSkill/SkillLabel/OptionButton.add_item(name)
 65 | 		$SkillLabel/AddSkill/SkillLabel/OptionButton.select(0)
 66 | 	if class_data.has("effects") == true:
 67 | 		clear_effect_list()
 68 | 		var effect_list: Array = class_data["effects"]
 69 | 		for effect in effect_list:
 70 | 			add_effect_list(effect["name"], int(effect["data_id"]), String(effect["value1"]), String(effect["value2"]))
 71 | 
 72 | func _on_Search_pressed() -> void:
 73 | 	$IconLabel/IconSearch.popup_centered()
 74 | 
 75 | func _on_IconSearch_file_selected(path: String) -> void:
 76 | 	icon_path = path
 77 | 	$IconLabel/IconSprite.texture = load(path)
 78 | 
 79 | func _on_ClassSaveButton_pressed() -> void:
 80 | 	save_class_data()
 81 | 	refresh_data(class_selected)
 82 | 
 83 | func save_class_data() -> void:
 84 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Class")
 85 | 	var class_data: Dictionary = json_dictionary["class"+String(class_selected)]
 86 | 	var class_stat_formula: Dictionary = class_data["stat_list"]
 87 | 	var class_skill_list: Dictionary = class_data["skill_list"]
 88 | 	var effect_list: Array
 89 | 	class_skill_list.clear()
 90 | 	
 91 | 	class_data["name"] = $NameLabel/NameText.text
 92 | 	$ClassButton.set_item_text(class_selected, $NameLabel/NameText.text)
 93 | 	class_data["icon"] = icon_path
 94 | 	class_data["experience"] = $ExpLabel/ExpText.text
 95 | 	var items: int = $StatsLabel/StatsContainer/DataContainer/StatsListContainer/StatsList.get_item_count()
 96 | 	for i in range(items):
 97 | 		var stat: String = $StatsLabel/StatsContainer/DataContainer/StatsListContainer/StatsList.get_item_text(i)
 98 | 		var formula: String = $StatsLabel/StatsContainer/DataContainer/FormulaListContainer/FormulaList.get_item_text(i)
 99 | 		class_stat_formula[stat] = formula
100 | 	var skills_count = $SkillLabel/SkillContainer/HBoxContainer/SkillLevelContainer/SkillLevelList.get_item_count()
101 | 	for i in range(skills_count):
102 | 		var skill: String = String(skill_list_array[i])
103 | 		var level: int = int($SkillLabel/SkillContainer/HBoxContainer/SkillLevelContainer/SkillLevelList.get_item_text(i))
104 | 		class_skill_list[skill] = level
105 | 	class_data["stat_list"] = class_stat_formula
106 | 	class_data["skill_list"] = class_skill_list
107 | 	var effect_size: int = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.get_item_count()
108 | 	for i in range(effect_size):
109 | 		var effect_data: Dictionary
110 | 		effect_data["name"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.get_item_text(i)
111 | 		effect_data["data_id"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.get_item_text(i)
112 | 		effect_data["value1"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.get_item_text(i)
113 | 		effect_data["value2"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.get_item_text(i)
114 | 		effect_list.append(effect_data)
115 | 	class_data["effects"] = effect_list
116 | 	get_parent().get_parent().call("store_data", "Class", json_dictionary)
117 | 
118 | func _on_AddClass_pressed() -> void:
119 | 	$ClassButton.add_item("NewClass")
120 | 	var id: int = $ClassButton.get_item_count() - 1
121 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Class")
122 | 	var class_data: Dictionary
123 | 	var stat_data: Dictionary
124 | 	var skill_data: Dictionary
125 | 	class_data["name"] = "NewClass"
126 | 	class_data["icon"] = ""
127 | 	class_data["experience"] = "level * 30"
128 | 	stat_data["hp"] = "level * 25 + 10"
129 | 	stat_data["mp"] = "level * 15 + 5"
130 | 	stat_data["atk"] = "level * 5 + 3"
131 | 	stat_data["def"] = "level * 5 + 3"
132 | 	stat_data["int"] = "level * 5 + 3"
133 | 	stat_data["res"] = "level * 5 + 3"
134 | 	stat_data["spd"] = "level * 5 + 3"
135 | 	stat_data["luk"] = "level * 5 + 3"
136 | 	class_data["stat_list"] = stat_data
137 | 	skill_data[0] =  5
138 | 	class_data["skill_list"] = skill_data
139 | 	json_dictionary["class" + String(id)] = class_data
140 | 	get_parent().get_parent().call("store_data", "Class", json_dictionary)
141 | 
142 | func _on_RemoveClass_pressed() -> void:
143 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Class")
144 | 	if (json_dictionary.keys().size() > 1):
145 | 		var class_id: int = class_selected
146 | 		while class_id < (json_dictionary.keys().size() - 1):
147 | 			json_dictionary["class"+String(class_id)] = json_dictionary["class"+String(class_id+1)]
148 | 			class_id += 1
149 | 		json_dictionary.erase("class"+String(class_id))
150 | 		get_parent().get_parent().call("store_data", "Class", json_dictionary)
151 | 		$ClassButton.remove_item(class_selected)
152 | 		if class_selected == 0:
153 | 			$ClassButton.select(class_selected + 1)
154 | 			class_selected += 1
155 | 		else:
156 | 			$ClassButton.select(class_selected + 1)
157 | 			class_selected -= 1
158 | 		$ClassButton.select(class_selected)
159 | 		refresh_data(class_selected)
160 | 
161 | func _on_ClassButton_item_selected(id: int) -> void:
162 | 	class_selected = id
163 | 	refresh_data(id)
164 | 
165 | func _on_AddSkillButton_pressed() -> void:
166 | 	$SkillLabel/AddSkill.popup_centered()
167 | 
168 | func _on_RemoveButton_pressed() -> void:
169 | 	var selected: int = $SkillLabel/SkillContainer/HBoxContainer/SkillListContainer/SkillList.get_selected_items()[0]
170 | 	$SkillLabel/SkillContainer/HBoxContainer/SkillListContainer/SkillList.remove_item(selected)
171 | 	$SkillLabel/SkillContainer/HBoxContainer/SkillLevelContainer/SkillLevelList.remove_item(selected)
172 | 	skill_list_array.remove(selected)
173 | 
174 | func _on_OkButton_pressed() -> void:
175 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Skill")
176 | 	var skill: int = $SkillLabel/AddSkill/SkillLabel/OptionButton.get_selected_id()
177 | 	var level: int = int($SkillLabel/AddSkill/LevelLabel/LevelSpin.value)
178 | 	skill_list_array.append(String(skill))
179 | 	var skill_data: Dictionary = json_dictionary["skill"+String(skill)]
180 | 	var skill_name: String = skill_data["name"]
181 | 	$SkillLabel/SkillContainer/HBoxContainer/SkillListContainer/SkillList.add_item(skill_name)
182 | 	$SkillLabel/SkillContainer/HBoxContainer/SkillLevelContainer/SkillLevelList.add_item(String(level))
183 | 	$SkillLabel/AddSkill.hide()
184 | 
185 | func _on_CancelButton_pressed() -> void:
186 | 	$SkillLabel/AddSkill.hide()
187 | 
188 | func _on_StatsList_item_selected(index: int) -> void:
189 | 	$StatsLabel/StatsContainer/DataContainer/FormulaListContainer/FormulaList.select(index)
190 | 
191 | func _on_FormulaList_item_selected(index: int) -> void:
192 | 	$StatsLabel/StatsContainer/DataContainer/StatsListContainer/StatsList.select(index)
193 | 
194 | func _on_SkillList_item_selected(index: int) -> void:
195 | 	$SkillLabel/SkillContainer/HBoxContainer/SkillLevelContainer/SkillLevelList.select(index)
196 | 
197 | func _on_SkillLevelList_item_selected(index: int) -> void:
198 | 	$SkillLabel/SkillContainer/HBoxContainer/SkillListContainer/SkillList.select(index)
199 | 
200 | func _on_FormulaList_item_activated(index: int) -> void:
201 | 	var stat_name: String = $StatsLabel/StatsContainer/DataContainer/StatsListContainer/StatsList.get_item_text(index)
202 | 	var stat_formula: String = $StatsLabel/StatsContainer/DataContainer/FormulaListContainer/FormulaList.get_item_text(index)
203 | 	$StatEditor/StatLabel.text = stat_name
204 | 	$StatEditor/StatEdit.text = stat_formula
205 | 	stat_edit = index
206 | 	$StatEditor.show()
207 | 
208 | func _on_OkStatButton_pressed() -> void:
209 | 	var stat_formula: String = $StatEditor/StatEdit.text
210 | 	$StatsLabel/StatsContainer/DataContainer/FormulaListContainer/FormulaList.set_item_text(stat_edit, stat_formula)
211 | 	save_class_data()
212 | 	stat_edit = -1
213 | 	$StatEditor.hide()
214 | 
215 | func _on_CancelStatButton_pressed() -> void:
216 | 	stat_edit = -1
217 | 	$StatEditor.hide()
218 | 
219 | func _on_AddClassEffect_pressed() -> void:
220 | 	get_parent().get_parent().call("open_effect_manager", "Class")
221 | 
222 | func _on_RemoveClassEffect_pressed() -> void:
223 | 	var id: int = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.get_selected_items()[0]
224 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.remove_item(id)
225 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.remove_item(id)
226 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.remove_item(id)
227 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.remove_item(id)
228 | 
229 | func add_effect_list(name: String, data_id: int, value1: String, value2: String) -> void:
230 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.add_item(name)
231 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.add_item(String(data_id))
232 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.add_item(value1)
233 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.add_item(value2)
234 | 
235 | func clear_effect_list() -> void:
236 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.clear()
237 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.clear()
238 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.clear()
239 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.clear()
240 | 
241 | # Called every frame. 'delta' is the elapsed time since the previous frame.
242 | #func _process(delta):
243 | #	pass
244 | 


--------------------------------------------------------------------------------
/addons/rpg_databases_gd/Scripts/effects.gd:
--------------------------------------------------------------------------------
  1 | extends Container
  2 | tool
  3 | 
  4 | # Declare member variables here. Examples:
  5 | # var a = 2
  6 | # var b = "text"
  7 | 
  8 | var add_new_effect = true;
  9 | var database_loaded = false;
 10 | # Called when the node enters the scene tree for the first time.
 11 | func _ready():
 12 | 	pass # Replace with function body.
 13 | 
 14 | func start():
 15 | 	if (database_loaded == false):
 16 | 		var jsonDictionary = get_parent().get_parent().call("read_data", "Effect")
 17 | 		for i in range(jsonDictionary.size()):
 18 | 			var effect_data = jsonDictionary["effect" + String(i)]
 19 | 			var show_list = effect_data["data_type"]
 20 | 			var value2 = effect_data["value2"]
 21 | 
 22 | 			$EffectLabel/PanelContainer/VBoxContainer/Effects/EffectNames.add_item(effect_data["name"])
 23 | 			if (show_list["show"] == true):
 24 | 				$EffectLabel/PanelContainer/VBoxContainer/Effects/DataTypes.add_item(show_list["data"])
 25 | 			else:
 26 | 				$EffectLabel/PanelContainer/VBoxContainer/Effects/DataTypes.add_item("disabled")
 27 | 			$EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue1.add_item(String(effect_data["value1"]))
 28 | 			if (value2["show"] == true):
 29 | 				$EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue2.add_item(String(value2["data"]))
 30 | 			else:
 31 | 				$EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue2.add_item("-1")
 32 | 		database_loaded = true
 33 | 
 34 | func _on_AddEffect_pressed():
 35 | 	add_new_effect = true;
 36 | 	$AddEffect.popup_centered()
 37 | 
 38 | func _on_EditEffect_pressed():
 39 | 	if ($EffectLabel/PanelContainer/VBoxContainer/Effects/EffectNames.get_selected_items()[0] > -1):
 40 | 		add_new_effect = false;
 41 | 		var id = $EffectLabel/PanelContainer/VBoxContainer/Effects/EffectNames.get_selected_items()[0]
 42 | 		var name = $EffectLabel/PanelContainer/VBoxContainer/Effects/EffectNames.get_item_text(id)
 43 | 		var data_types = $EffectLabel/PanelContainer/VBoxContainer/Effects/DataTypes.get_item_text(id)
 44 | 		var value1 = int($EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue1.get_item_text(id))
 45 | 		var value2 = int($EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue2.get_item_text(id))
 46 | 
 47 | 		$AddEffect/VBoxContainer/Name/LineEdit.text = name
 48 | 		if (data_types == "disabled"):
 49 | 			$AddEffect/VBoxContainer/ShowList/CheckButton.pressed = false
 50 | 			$AddEffect/VBoxContainer/ShowList/OptionButton.disabled = true
 51 | 		else:
 52 | 			$AddEffect/VBoxContainer/ShowList/CheckButton.pressed = true
 53 | 			$AddEffect/VBoxContainer/ShowList/OptionButton.disabled = false
 54 | 			match (data_types):
 55 | 				"States":
 56 | 					$AddEffect/VBoxContainer/ShowList/OptionButton.select(0)
 57 | 				"Stats":
 58 | 					$AddEffect/VBoxContainer/ShowList/OptionButton.select(1)
 59 | 				"Weapon Types":
 60 | 					$AddEffect/VBoxContainer/ShowList/OptionButton.select(2)
 61 | 				"Armor Types":
 62 | 					$AddEffect/VBoxContainer/ShowList/OptionButton.select(3)
 63 | 				"Elements":
 64 | 					$AddEffect/VBoxContainer/ShowList/OptionButton.select(4)
 65 | 				"Skill Types":
 66 | 					$AddEffect/VBoxContainer/ShowList/OptionButton.select(5)
 67 | 		$AddEffect/VBoxContainer/Value1/OptionButton.select(value1)
 68 | 		if (value2 == -1):
 69 | 			$AddEffect/VBoxContainer/Value2/CheckButton.pressed = false
 70 | 			$AddEffect/VBoxContainer/Value2/OptionButton.disabled = true
 71 | 		else:
 72 | 			$AddEffect/VBoxContainer/Value2/CheckButton.pressed = true
 73 | 			$AddEffect/VBoxContainer/Value2/OptionButton.disabled = false
 74 | 			$AddEffect/VBoxContainer/Value2/OptionButton.select(value2)
 75 | 		$AddEffect.popup_centered()
 76 | 
 77 | func _on_RemoveEffect_pressed():
 78 | 	var selected_effect = $EffectLabel/PanelContainer/VBoxContainer/Effects/EffectNames.get_selected_items()[0];
 79 | 	if (selected_effect > -1):
 80 | 		$EffectLabel/PanelContainer/VBoxContainer/Effects/EffectNames.RemoveItem(selected_effect)
 81 | 		$EffectLabel/PanelContainer/VBoxContainer/Effects/DataTypes.RemoveItem(selected_effect)
 82 | 		$EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue1.RemoveItem(selected_effect)
 83 | 		$EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue2.RemoveItem(selected_effect)
 84 | 
 85 | func _on_clearEffects_pressed():
 86 | 	$EffectLabel/PanelContainer/VBoxContainer/Effects/EffectNames.clear()
 87 | 	$EffectLabel/PanelContainer/VBoxContainer/Effects/DataTypes.clear()
 88 | 	$EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue1.clear()
 89 | 	$EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue2.clear()
 90 | 
 91 | func _on_CheckButton_toggled(button_pressed):
 92 | 	if (button_pressed == true):
 93 | 		$AddEffect/VBoxContainer/ShowList/OptionButton.disabled = false
 94 | 	else:
 95 | 		$AddEffect/VBoxContainer/ShowList/OptionButton.disabled = true
 96 | 
 97 | func _on_Value2CheckButton_pressed():
 98 | 	if ($AddEffect/VBoxContainer/Value2/CheckButton.pressed == true):
 99 | 		$AddEffect/VBoxContainer/Value2/OptionButton.disabled = false
100 | 	else:
101 | 		$AddEffect/VBoxContainer/Value2/OptionButton.disabled = true
102 | 
103 | func _on_AddEffectConfirm_pressed():
104 | 	var name = $AddEffect/VBoxContainer/Name/LineEdit.text
105 | 	var selected = 0
106 | 	var data_type = "disabled"
107 | 	if ($AddEffect/VBoxContainer/ShowList/CheckButton.pressed == true):
108 | 		selected = $AddEffect/VBoxContainer/ShowList/OptionButton.selected
109 | 		data_type = $AddEffect/VBoxContainer/ShowList/OptionButton.get_item_text(selected)
110 | 	var value1 = $AddEffect/VBoxContainer/Value1/OptionButton.selected
111 | 	var value2 = -1
112 | 	if ($AddEffect/VBoxContainer/Value2/CheckButton.pressed == true):
113 | 		value2 = $AddEffect/VBoxContainer/Value2/OptionButton.selected
114 | 	if (add_new_effect == false):
115 | 		var id = $EffectLabel/PanelContainer/VBoxContainer/Effects/EffectNames.get_selected_items()[0];
116 | 		$EffectLabel/PanelContainer/VBoxContainer/Effects/EffectNames.SetItemtext(id, name)
117 | 		$EffectLabel/PanelContainer/VBoxContainer/Effects/DataTypes.SetItemtext(id, data_type)
118 | 		$EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue1.SetItemtext(id, String(value1))
119 | 		$EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue2.SetItemtext(id, String(value2))
120 | 	else:
121 | 		$EffectLabel/PanelContainer/VBoxContainer/Effects/EffectNames.add_item(name)
122 | 		$EffectLabel/PanelContainer/VBoxContainer/Effects/DataTypes.add_item(data_type)
123 | 		$EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue1.add_item(String(value1))
124 | 		$EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue2.add_item(String(value2))
125 | 	$AddEffect.hide()
126 | 
127 | func _on_AddEffectCancel_pressed():
128 | 	$AddEffect.hide()
129 | 
130 | func _on_SaveEffects_pressed():
131 | 	var size = $EffectLabel/PanelContainer/VBoxContainer/Effects/EffectNames.get_item_count()
132 | 	var effect_list: Dictionary
133 | 	for i in range(size):
134 | 		var effect_data: Dictionary
135 | 		var show_list: Dictionary
136 | 		var value2: Dictionary
137 | 		effect_data["name"] = $EffectLabel/PanelContainer/VBoxContainer/Effects/EffectNames.get_item_text(i)
138 | 		var data_type = $EffectLabel/PanelContainer/VBoxContainer/Effects/DataTypes.get_item_text(i)
139 | 		if (data_type == "disabled"):
140 | 			show_list["show"] = false
141 | 			show_list["data"] = ""
142 | 		else:
143 | 			show_list["show"] = true
144 | 			show_list["data"] = data_type
145 | 		effect_data["data_type"] = show_list
146 | 		effect_data["value1"] = int($EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue1.get_item_text(i))
147 | 		var value2Val = int($EffectLabel/PanelContainer/VBoxContainer/Effects/EffectValue2.get_item_text(i))
148 | 		if (value2Val == -1):
149 | 			value2["show"] = false
150 | 			value2["data"] = ""
151 | 		else:
152 | 			value2["show"] = true
153 | 			value2["data"] = value2Val
154 | 		effect_data["value2"] = value2
155 | 		effect_list["effect" + String(i)] = effect_data
156 | 	get_parent().get_parent().call("store_data", "Effect", effect_list)
157 | 
158 | # Called every frame. 'delta' is the elapsed time since the previous frame.
159 | #func _process(delta):
160 | #	pass
161 | 


--------------------------------------------------------------------------------
/addons/rpg_databases_gd/Scripts/enemy.gd:
--------------------------------------------------------------------------------
  1 | extends Container
  2 | tool
  3 | 
  4 | # Declare member variables here. Examples:
  5 | # var a = 2
  6 | # var b = "text"
  7 | 
  8 | var graphics_path = ""
  9 | var enemy_selected = 0
 10 | var statEdit = -1
 11 | var drop_id_array: Array
 12 | # Called when the node enters the scene tree for the first time.
 13 | func _ready():
 14 | 	pass # Replace with function body.
 15 | 
 16 | func start():
 17 | 	var json_dictionary = get_parent().get_parent().call("read_data", "Enemy")
 18 | 	$EnemyButton.clear()
 19 | 	for i in range(json_dictionary.size()):
 20 | 		var enemy_data = json_dictionary["enemy" + String(i)]
 21 | 		if (i > $EnemyButton.get_item_count() - 1):
 22 | 			$EnemyButton.add_item(enemy_data["name"])
 23 | 		else:
 24 | 			$EnemyButton.set_item_text(i, enemy_data["name"])
 25 | 	refresh_data(enemy_selected)
 26 | 
 27 | func refresh_data(id):
 28 | 	var json_dictionary = get_parent().get_parent().call("read_data", "Enemy")
 29 | 	var enemy_data = json_dictionary["enemy" + String(id)]
 30 | 	json_dictionary = get_parent().get_parent().call("read_data", "System")
 31 | 	var system_stats_data = json_dictionary["stats"]
 32 | 	var item_list = get_parent().get_parent().call("read_data", "Item")
 33 | 	var weapon_list = get_parent().get_parent().call("read_data", "Weapon")
 34 | 	var armor_list = get_parent().get_parent().call("read_data", "Armor")
 35 | 
 36 | 	$NameLabel/NameLine.text = enemy_data["name"]
 37 | 	var graphic = enemy_data["graphicImage"]
 38 | 	if (graphic != ""):
 39 | 		graphics_path = enemy_data["graphicImage"]
 40 | 		$GraphicLabel/Graphic.texture = load(enemy_data["graphicImage"])
 41 | 	$StatsLabel/StatsContainer/DataContainer/StatList.clear()
 42 | 	$StatsLabel/StatsContainer/DataContainer/FormulaList.clear()
 43 | 	for i in range(system_stats_data.size()):
 44 | 		var stat_name = system_stats_data[String(i)]
 45 | 		var enemy_stat_formula = enemy_data["stat_list"]
 46 | 		var stat_formula = "";
 47 | 		if (enemy_stat_formula.has(stat_name)):
 48 | 			stat_formula = enemy_stat_formula[stat_name]
 49 | 		else:
 50 | 			stat_formula = "level * 5"
 51 | 		$StatsLabel/StatsContainer/DataContainer/StatList.add_item(stat_name)
 52 | 		$StatsLabel/StatsContainer/DataContainer/FormulaList.add_item(stat_formula)
 53 | 	var drop_list = enemy_data["drop_list"]
 54 | 	$DropsLabel/DropsContainer/VBoxContainer/HBoxContainer/DropsList.clear()
 55 | 	$DropsLabel/DropsContainer/VBoxContainer/HBoxContainer/ChanceList.clear()
 56 | 	drop_id_array.clear()
 57 | 	for drop in drop_list.keys():
 58 | 		var kind = drop[0]
 59 | 		var kind_id: String = drop
 60 | 		kind_id.erase(0,1)
 61 | 		match kind:
 62 | 			"i":
 63 | 				drop_id_array.append(drop)
 64 | 				var item_data: Dictionary = item_list["item" + kind_id]
 65 | 				$DropsLabel/DropsContainer/VBoxContainer/HBoxContainer/DropsList.add_item(item_data["name"])
 66 | 			"w":
 67 | 				drop_id_array.append(drop)
 68 | 				var weapon_data = weapon_list["weapon" + kind_id]
 69 | 				$DropsLabel/DropsContainer/VBoxContainer/HBoxContainer/DropsList.add_item(weapon_data["name"])
 70 | 			"a":
 71 | 				drop_id_array.append(drop)
 72 | 				var armor_data = armor_list["armor" + kind_id]
 73 | 				$DropsLabel/DropsContainer/VBoxContainer/HBoxContainer/DropsList.add_item(armor_data["name"])
 74 | 		$DropsLabel/DropsContainer/VBoxContainer/HBoxContainer/ChanceList.add_item(String(drop_list[drop]))
 75 | 	$ExpLabel/ExpSpin.value = int(enemy_data["experience"])
 76 | 	$GoldLabel/GoldSpin.value = int(enemy_data["money"])
 77 | 	
 78 | 	if (enemy_data.has("effects") == true):
 79 | 		clear_effect_list()
 80 | 		var effect_list: Array = enemy_data["effects"]
 81 | 		for effect in effect_list:
 82 | 			add_effect_list(effect["name"], int(effect["data_id"]), String(effect["value1"]), String(effect["value2"]))
 83 | 
 84 | func _on_AddEnemy_pressed():
 85 | 	$EnemyButton.add_item("NewEnemy")
 86 | 	var id = $EnemyButton.get_item_count() - 1;
 87 | 	var json_dictionary = get_parent().get_parent().call("read_data", "Enemy")
 88 | 	var enemy_data: Dictionary
 89 | 	var stats_data: Dictionary
 90 | 	var drop_data: Dictionary
 91 | 	enemy_data["name"] = "Slime"
 92 | 	enemy_data["graphicImage"] = ""
 93 | 	stats_data["hp"] = "150"
 94 | 	stats_data["mp"] = "50"
 95 | 	stats_data["atk"] = "18"
 96 | 	stats_data["def"] = "16"
 97 | 	stats_data["int"] = "8"
 98 | 	stats_data["res"] = "4"
 99 | 	stats_data["spd"] = "12"
100 | 	stats_data["luk"] = "10"
101 | 	drop_data["i0"] = 80
102 | 	enemy_data["experience"] = 6
103 | 	enemy_data["money"] = 50
104 | 	enemy_data["stat_list"] = stats_data
105 | 	enemy_data["drop_list"] = drop_data
106 | 	json_dictionary["enemy" + String(id)] = enemy_data
107 | 	get_parent().get_parent().call("store_data", "Enemy", json_dictionary)
108 | 
109 | func _on_eraseEnemy_pressed():
110 | 	var json_dictionary = get_parent().get_parent().call("read_data", "Enemy")
111 | 	if (json_dictionary.keys().size() > 1):
112 | 		var enemyId = enemy_selected
113 | 		while (enemyId < json_dictionary.keys().size() - 1):
114 | 			json_dictionary["Enemy" + enemyId] = json_dictionary["Enemy" + (enemyId + 1)]
115 | 			enemyId += 1;
116 | 		json_dictionary.erase("Enemy" + enemyId)
117 | 		get_parent().get_parent().call("store_data", "Enemy", json_dictionary)
118 | 		$EnemyButton.remove_item(enemy_selected)
119 | 		if (enemy_selected == 0):
120 | 			$EnemyButton.select(enemy_selected + 1)
121 | 			enemy_selected += 1
122 | 		else:
123 | 			$EnemyButton.select(enemy_selected - 1)
124 | 			enemy_selected -= 1
125 | 		$EnemyButton.select(enemy_selected)
126 | 		refresh_data(enemy_selected)
127 | 
128 | func _on_SearchGraphic_pressed():
129 | 	$EnemyGraphic.popup_centered()
130 | 
131 | func _on_EnemyGraphic_file_selected(path):
132 | 	graphics_path = path;
133 | 	$GraphicLabel/Graphic.texture = load(path)
134 | 
135 | func _on_FormulaList_item_activated(var index):
136 | 	var stat_name = $StatsLabel/StatsContainer/DataContainer/StatList.get_item_text(index)
137 | 	var stat_formula = $StatsLabel/StatsContainer/DataContainer/FormulaList.get_item_text(index)
138 | 	$StatsEdit/Stat.text = stat_name
139 | 	$StatsEdit/Formula.text = stat_formula
140 | 	statEdit = index
141 | 	$StatsEdit.popup_centered()
142 | 
143 | func _on_EnemyStatEditorOkButton_pressed():
144 | 	var stat_formula = $StatsEdit/Formula.text;
145 | 	$StatsLabel/StatsContainer/DataContainer/FormulaList.set_item_text(statEdit, stat_formula)
146 | 	save_enemy_data()
147 | 	statEdit = -1
148 | 	$StatsEdit.hide()
149 | 
150 | func _on_EnemyStatEditorCancelButton_pressed():
151 | 	statEdit = -1;
152 | 	$StatsEdit.hide()
153 | 
154 | func _on_AddDrop_pressed():
155 | 	$DropEdit/Type/OptionButton.select(0)
156 | 	var item_data = get_parent().get_parent().call("read_data", "Item")
157 | 	for i in range(item_data.size()):
158 | 		var itemName = item_data["item" + String(i)]
159 | 		if (i > $DropEdit/Drop/OptionButton.get_item_count() - 1):
160 | 			$DropEdit/Drop/OptionButton.add_item(itemName["name"])
161 | 		else:
162 | 			$DropEdit/Drop/OptionButton.set_item_text(i, itemName["name"])
163 | 	$DropEdit.popup_centered()
164 | 
165 | func _on_eraseDrop_pressed():
166 | 	var id = $DropsLabel/DropsContainer/VBoxContainer/HBoxContainer/DropsList.get_selected_items()[0];
167 | 	$DropsLabel/DropsContainer/VBoxContainer/HBoxContainer/DropsList.remove_item(id)
168 | 	$DropsLabel/DropsContainer/VBoxContainer/HBoxContainer/ChanceList.remove_item(id)
169 | 
170 | func _on_DropType_item_selected(index):
171 | 	var item_data = get_parent().get_parent().call("read_data", "Item")
172 | 	var weapon_data = get_parent().get_parent().call("read_data", "Weapon")
173 | 	var armor_data = get_parent().get_parent().call("read_data", "Armor")
174 | 	$DropEdit/Drop/OptionButton.clear()
175 | 	match index:
176 | 		0:
177 | 			for i in range(item_data.size()):
178 | 				var itemName = item_data["item" + String(i)]
179 | 				if (i > $DropEdit/Drop/OptionButton.get_item_count() - 1):
180 | 					$DropEdit/Drop/OptionButton.add_item(itemName["name"])
181 | 				else:
182 | 					$DropEdit/Drop/OptionButton.set_item_text(i, itemName["name"])
183 | 		1:
184 | 			for i in range(weapon_data.size()):
185 | 				var weaponName = weapon_data["weapon" + String(i)]
186 | 				if (i > $DropEdit/Drop/OptionButton.get_item_count() - 1):
187 | 					$DropEdit/Drop/OptionButton.add_item(weaponName["name"])
188 | 				else:
189 | 					$DropEdit/Drop/OptionButton.set_item_text(i, weaponName["name"])
190 | 		2:
191 | 			for i in range(armor_data.size()):
192 | 				var armorName = armor_data["armor" + String(i)]
193 | 				if (i > $DropEdit/Drop/OptionButton.get_item_count() - 1):
194 | 					$DropEdit/Drop/OptionButton.add_item(armorName["name"])
195 | 				else:
196 | 					$DropEdit/Drop/OptionButton.set_item_text(i, armorName["name"])
197 | 
198 | func _on_DropEditOkButton_pressed():
199 | 	var item_list = get_parent().get_parent().call("read_data", "Item")
200 | 	var weapon_list = get_parent().get_parent().call("read_data", "Weapon")
201 | 	var armor_list = get_parent().get_parent().call("read_data", "Armor")
202 | 	var id = $DropEdit/Type/OptionButton.get_selected_id()
203 | 	var selected_id = $DropEdit/Drop/OptionButton.get_selected_id()
204 | 	var chance = int($DropEdit/Chance/SpinBox.value)
205 | 	match id:
206 | 		0:
207 | 			drop_id_array.append("i" + String(selected_id))
208 | 			var item_data = item_list["item" + String(selected_id)]
209 | 			$DropsLabel/DropsContainer/VBoxContainer/HBoxContainer/DropsList.add_item(item_data["name"])
210 | 		1:
211 | 			drop_id_array.append("w" + String(selected_id))
212 | 			var weapon_data = weapon_list["weapon" + String(selected_id)]
213 | 			$DropsLabel/DropsContainer/VBoxContainer/HBoxContainer/DropsList.add_item(weapon_data["name"])
214 | 		2:
215 | 			drop_id_array.append("a" + String(selected_id))
216 | 			var armor_data = armor_list["armor" + String(selected_id)]
217 | 			$DropsLabel/DropsContainer/VBoxContainer/HBoxContainer/DropsList.add_item(armor_data["name"])
218 | 	$DropsLabel/DropsContainer/VBoxContainer/HBoxContainer/ChanceList.add_item(String(chance))
219 | 	$DropEdit.hide()
220 | 
221 | func _on_DropEditCancelButton_pressed():
222 | 	$DropEdit.hide()
223 | 
224 | func _on_EnemySaveButton_pressed():
225 | 	save_enemy_data()
226 | 	refresh_data(enemy_selected)
227 | 
228 | func save_enemy_data():
229 | 	var json_dictionary = get_parent().get_parent().call("read_data", "Enemy")
230 | 	var enemy_data = json_dictionary["enemy" + String(enemy_selected)]
231 | 	var stats_data = enemy_data["stat_list"]
232 | 	var drops_data = enemy_data["drop_list"]
233 | 	var effect_list: Array
234 | 	enemy_data["name"] = $NameLabel/NameLine.text;
235 | 	enemy_data["graphicImage"] = graphics_path;
236 | 	var items = $StatsLabel/StatsContainer/DataContainer/StatList.get_item_count()
237 | 	for i in range(items):
238 | 		var stat = $StatsLabel/StatsContainer/DataContainer/StatList.get_item_text(i)
239 | 		var formula = $StatsLabel/StatsContainer/DataContainer/FormulaList.get_item_text(i)
240 | 		stats_data[stat] = formula
241 | 	items = $DropsLabel/DropsContainer/VBoxContainer/HBoxContainer/DropsList.get_item_count()
242 | 	for i in range(items):
243 | 		var id = drop_id_array[i]
244 | 		var chance = $DropsLabel/DropsContainer/VBoxContainer/HBoxContainer/ChanceList.get_item_text(i)
245 | 		drops_data[id] = chance
246 | 	var effect_size = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.get_item_count()
247 | 	for i in range(effect_size):
248 | 		var effect_data: Dictionary
249 | 		effect_data["name"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.get_item_text(i)
250 | 		effect_data["data_id"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.get_item_text(i)
251 | 		effect_data["value1"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.get_item_text(i)
252 | 		effect_data["value2"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.get_item_text(i)
253 | 		effect_list.append(effect_data)
254 | 	enemy_data["effects"] = effect_list;
255 | 	enemy_data["experience"] = $ExpLabel/ExpSpin.value;
256 | 	enemy_data["money"] = $GoldLabel/GoldSpin.value;
257 | 	enemy_data["stat_list"] = stats_data;
258 | 	enemy_data["drop_list"] = drops_data;
259 | 	get_parent().get_parent().call("store_data", "Enemy", json_dictionary)
260 | 
261 | func _on_AddEnemyEffect_pressed() -> void:
262 | 	get_parent().get_parent().call("open_effect_manager", "Enemy")
263 | 
264 | func _on_eraseEnemyEffect_pressed() -> void:
265 | 	var id = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.get_selected_items()[0]
266 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.remove_item(id)
267 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.remove_item(id)
268 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.remove_item(id)
269 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.remove_item(id)
270 | 
271 | func add_effect_list(name: String, data_id: int, value1: String, value2: String) -> void:
272 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.add_item(name)
273 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.add_item(String(data_id))
274 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.add_item(value1)
275 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.add_item(value2)
276 | 
277 | func clear_effect_list() -> void:
278 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.clear()
279 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.clear()
280 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.clear()
281 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.clear()
282 | 
283 | # Called every frame. 'delta' is the elapsed time since the previous frame.
284 | #func _process(delta):
285 | #	pass
286 | 
287 | func _on_EnemyButton_item_selected(index):
288 | 	enemy_selected = index
289 | 	refresh_data(index)
290 | 


--------------------------------------------------------------------------------
/addons/rpg_databases_gd/Scripts/item.gd:
--------------------------------------------------------------------------------
  1 | extends Container
  2 | tool
  3 | 
  4 | # Declare member variables here. Examples:
  5 | # var a = 2
  6 | # var b = "text"
  7 | 
  8 | var icon_path: String = ""
  9 | var item_selected: int = 0
 10 | # Called when the node enters the scene tree for the first time.
 11 | func _ready():
 12 | 	pass # Replace with function body.
 13 | 
 14 | func start() -> void:
 15 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Item")
 16 | 	$ItemButton.clear()
 17 | 	for i in range(json_dictionary.size()):
 18 | 		var item_data: Dictionary = json_dictionary["item"+String(i)]
 19 | 		if i > $ItemButton.get_item_count() - 1:
 20 | 			$ItemButton.add_item(item_data["name"])
 21 | 		else:
 22 | 			$ItemButton.set_item_text(i, item_data["name"])
 23 | 	json_dictionary = get_parent().get_parent().call("read_data", "System")
 24 | 	var system_data: Dictionary = json_dictionary["elements"]
 25 | 	for i in range(system_data.size()):
 26 | 		if i >$DamageLabel/ElementLabel/ElementButton.get_item_count() - 1:
 27 | 			$DamageLabel/ElementLabel/ElementButton.add_item(system_data[String(i)])
 28 | 		else:
 29 | 			$DamageLabel/ElementLabel/ElementButton.set_item_text(i, system_data[String(i)])
 30 | 	refresh_data(item_selected)
 31 | 
 32 | func refresh_data(id: int) -> void:
 33 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Item")
 34 | 	var item_data: Dictionary = json_dictionary["item"+String(id)]
 35 | 	$NameLabel/NameText.text = item_data["name"]
 36 | 	var icon: String = item_data["icon"]
 37 | 	if icon != "":
 38 | 		icon_path = icon
 39 | 		$IconLabel/IconSprite.texture = load(item_data["icon"])
 40 | 	$DescLabel/DescText.text = item_data["description"]
 41 | 	$ItemTypeLabel/ItemTypeButton.selected = item_data["item_type"]
 42 | 	$PriceLabel/PriceBox.value = item_data["price"]
 43 | 	$ConsumableLabel/ConsumableButton.selected = item_data["consumable"]
 44 | 	$TargetLabel/TargetButton.selected = item_data["target"]
 45 | 	$UsableLabel/UsableButton.selected = item_data["usable"]
 46 | 	$HitLabel/HitBox.value = item_data["success"]
 47 | 	$TypeLabel/TypeButton.selected = item_data["hit_type"]
 48 | 	$DamageLabel/DTypeLabel/DTypeButton.selected = item_data["damage_type"]
 49 | 	$DamageLabel/ElementLabel/ElementButton.selected = item_data["element"]
 50 | 	$DamageLabel/DFormulaLabel/FormulaText.text = item_data["formula"]
 51 | 	if item_data.has("effects"):
 52 | 		clear_effect_list()
 53 | 		var effect_list: Array = item_data["effects"]
 54 | 		for effect in effect_list:
 55 | 			add_effect_list(effect["name"], int(effect["data_id"]), String(effect["value1"]), String(effect["value2"]))
 56 | 
 57 | func _on_Search_pressed() -> void:
 58 | 	$IconLabel/IconSearch.popup_centered()
 59 | 
 60 | func _on_IconSearch_file_selected(path: String) -> void:
 61 | 	icon_path = path
 62 | 	$IconLabel/IconSprite.texture = load(path)
 63 | 
 64 | func _on_AddItem_pressed() -> void:
 65 | 	$ItemButton.add_item("NewItem")
 66 | 	var id: int = $ItemButton.get_item_count() - 1
 67 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Item")
 68 | 	var item_data: Dictionary
 69 | 	item_data["name"] = "NewItem"
 70 | 	item_data["icon"] = ""
 71 | 	item_data["description"] = "New created item"
 72 | 	item_data["item_type"] = 0
 73 | 	item_data["price"] = 10
 74 | 	item_data["consumable"] = 0
 75 | 	item_data["target"] = 3
 76 | 	item_data["usable"] = 0
 77 | 	item_data["success"] = 95
 78 | 	item_data["hit_type"] = 1
 79 | 	item_data["damage_type"] = 1
 80 | 	item_data["element"] = 0
 81 | 	item_data["formula"] = "10"
 82 | 	json_dictionary["item" + String(id)] = item_data
 83 | 	get_parent().get_parent().call("store_data", "Item", json_dictionary)
 84 | 
 85 | func _on_RemoveItem_pressed():
 86 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Item")
 87 | 	if json_dictionary.keys().size() > 1:
 88 | 		var item_id: int = item_selected
 89 | 		while item_id < (json_dictionary.keys().size() - 1):
 90 | 			json_dictionary["item"+String(item_id)] = json_dictionary["item"+String(item_id+1)]
 91 | 			item_id += 1
 92 | 		json_dictionary.erase("item"+String(item_id))
 93 | 		get_parent().get_parent().call("store_data", "Item", json_dictionary)
 94 | 		$ItemButton.remove_item(item_selected)
 95 | 		if item_selected == 0:
 96 | 			$ItemButton.select(item_selected + 1)
 97 | 			item_selected += 1
 98 | 		else:
 99 | 			$ItemButton.select(item_selected + 1)
100 | 			item_selected -= 1
101 | 		$ItemButton.select(item_selected)
102 | 		refresh_data(item_selected)
103 | 
104 | func _on_ItemSaveButton_pressed() -> void:
105 | 	save_item_data()
106 | 	refresh_data(item_selected)
107 | 
108 | func save_item_data() -> void:
109 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Item")
110 | 	var item_data: Dictionary = json_dictionary["item"+String(item_selected)]
111 | 	var effect_list: Array
112 | 	item_data["name"] = $NameLabel/NameText.text
113 | 	$ItemButton.set_item_text(item_selected, $NameLabel/NameText.text)
114 | 	item_data["icon"] = icon_path
115 | 	item_data["description"] = $DescLabel/DescText.text
116 | 	item_data["item_type"] = $ItemTypeLabel/ItemTypeButton.selected
117 | 	item_data["price"] = $PriceLabel/PriceBox.value
118 | 	item_data["consumable"] = $ConsumableLabel/ConsumableButton.selected
119 | 	item_data["target"] = $TargetLabel/TargetButton.selected
120 | 	item_data["usable"] = $UsableLabel/UsableButton.selected
121 | 	item_data["success"] = $HitLabel/HitBox.value
122 | 	item_data["hit_type"] = $TypeLabel/TypeButton.selected
123 | 	item_data["damage_type"] = $DamageLabel/DTypeLabel/DTypeButton.selected
124 | 	item_data["element"] = $DamageLabel/ElementLabel/ElementButton.selected
125 | 	item_data["formula"] = $DamageLabel/DFormulaLabel/FormulaText.text
126 | 	var effect_size: int = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.get_item_count()
127 | 	for i in effect_size:
128 | 		var effect_data: Dictionary
129 | 		effect_data["name"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.get_item_text(i)
130 | 		effect_data["data_id"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.get_item_text(i)
131 | 		effect_data["value1"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.get_item_text(i)
132 | 		effect_data["value2"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.get_item_text(i)
133 | 		effect_list.append(effect_data)
134 | 	item_data["effects"] = effect_list
135 | 	get_parent().get_parent().call("store_data", "Item", json_dictionary)
136 | 
137 | func _on_ItemButton_item_selected(id: int) -> void:
138 | 	item_selected = id
139 | 	refresh_data(id)
140 | 
141 | func _on_AddItemEffect_pressed() -> void:
142 | 	get_parent().get_parent().call("open_effect_manager", "Item")
143 | 
144 | func _on_RemoveItemEffect_pressed() -> void:
145 | 	var id: int = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.get_selected_items()[0]
146 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.remove_item(id)
147 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.remove_item(id)
148 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.remove_item(id)
149 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.remove_item(id)
150 | 
151 | func add_effect_list(name: String, data_id: int, value1: String, value2: String) -> void:
152 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.add_item(name)
153 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.add_item(String(data_id))
154 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.add_item(value1)
155 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.add_item(value2)
156 | 
157 | func clear_effect_list() -> void:
158 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.clear()
159 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.clear()
160 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.clear()
161 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.clear()
162 | 
163 | # Called every frame. 'delta' is the elapsed time since the previous frame.
164 | #func _process(delta):
165 | #	pass
166 | 


--------------------------------------------------------------------------------
/addons/rpg_databases_gd/Scripts/skill.gd:
--------------------------------------------------------------------------------
  1 | extends Container
  2 | tool
  3 | 
  4 | # Declare member variables here. Examples:
  5 | # var a = 2
  6 | # var b = "text"
  7 | 
  8 | var icon_path: String = ""
  9 | var skill_selected: int = 0
 10 | # Called when the node enters the scene tree for the first time.
 11 | func _ready():
 12 | 	pass # Replace with function body.
 13 | 
 14 | func start() -> void:
 15 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Skill")
 16 | 	var system_dictionary: Dictionary = get_parent().get_parent().call("read_data", "System")
 17 | 	$SkillButton.clear()
 18 | 	for i in range(json_dictionary.size()):
 19 | 		var skill_data: Dictionary = json_dictionary["skill"+String(i)]
 20 | 		if i > $SkillButton.get_item_count() - 1:
 21 | 			$SkillButton.add_item(skill_data["name"])
 22 | 		else:
 23 | 			$SkillButton.set_item_text(i, skill_data["name"])
 24 | 	var system_data: Dictionary = system_dictionary["elements"]
 25 | 	for i in range(system_data.size()):
 26 | 		if i >$DamageLabel/ElementLabel/ElementButton.get_item_count() - 1:
 27 | 			$DamageLabel/ElementLabel/ElementButton.add_item(system_data[String(i)])
 28 | 		else:
 29 | 			$DamageLabel/ElementLabel/ElementButton.set_item_text(i, system_data[String(i)])
 30 | 	system_data = system_dictionary["skills"]
 31 | 	for i in range(system_data.size()):
 32 | 		if i >$SkillTypeLabel/SkillTypeButton.get_item_count() - 1:
 33 | 			$SkillTypeLabel/SkillTypeButton.add_item(system_data[String(i)])
 34 | 		else:
 35 | 			$SkillTypeLabel/SkillTypeButton.set_item_text(i, system_data[String(i)])
 36 | 	refresh_data(skill_selected)
 37 | 
 38 | func refresh_data(id: int) -> void:
 39 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Skill")
 40 | 	var skill_data: Dictionary = json_dictionary["skill"+String(id)]
 41 | 	$NameLabel/NameText.text = skill_data["name"]
 42 | 	var icon: String = skill_data["icon"]
 43 | 	if icon != "":
 44 | 		icon_path = icon
 45 | 		$IconLabel/IconSprite.texture = load(skill_data["icon"])
 46 | 	$DescLabel/DescText.text = skill_data["description"]
 47 | 	$SkillTypeLabel/SkillTypeButton.selected = skill_data["skill_type"]
 48 | 	$MPCostLabel/MPCostBox.value = skill_data["mp_cost"]
 49 | 	$TPCostLabel/TPCostBox.value = skill_data["tp_cost"]
 50 | 	$TargetLabel/TargetButton.selected = skill_data["target"]
 51 | 	$UsableLabel/UsableButton.selected = skill_data["usable"]
 52 | 	$HitLabel/HitBox.value = skill_data["success"]
 53 | 	$TypeLabel/TypeButton.selected = skill_data["hit_type"]
 54 | 	$DamageLabel/DTypeLabel/DTypeButton.selected = skill_data["damage_type"]
 55 | 	$DamageLabel/ElementLabel/ElementButton.selected = skill_data["element"]
 56 | 	$DamageLabel/DFormulaLabel/FormulaText.text = skill_data["formula"]
 57 | 	if skill_data.has("effects"):
 58 | 		clear_effect_list()
 59 | 		var effect_list: Array = skill_data["effects"]
 60 | 		for effect in effect_list:
 61 | 			add_effect_list(effect["name"], int(effect["data_id"]), String(effect["value1"]), String(effect["value2"]))
 62 | 
 63 | func _on_Search_pressed() -> void:
 64 | 	$IconLabel/IconSearch.popup_centered()
 65 | 
 66 | func _on_IconSearch_file_selected(path: String) -> void:
 67 | 	icon_path = path
 68 | 	$IconLabel/IconSprite.texture = load(path)
 69 | 
 70 | func _on_AddSkill_pressed() -> void:
 71 | 	$SkillButton.add_item("NewSkill")
 72 | 	var id: int = $SkillButton.get_item_count() - 1
 73 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Skill")
 74 | 	var skill_data: Dictionary
 75 | 	skill_data["name"] = "NewSkill"
 76 | 	skill_data["icon"] = ""
 77 | 	skill_data["description"] = "New created skill"
 78 | 	skill_data["skill_type"] = 0
 79 | 	skill_data["mp_cost"] = 0
 80 | 	skill_data["tp_cost"] = 0
 81 | 	skill_data["target"] = 1
 82 | 	skill_data["usable"] = 1
 83 | 	skill_data["success"] = 95
 84 | 	skill_data["hit_type"] = 1
 85 | 	skill_data["damage_type"] = 1
 86 | 	skill_data["element"] = 0
 87 | 	skill_data["formula"] = "atk * 4 - def * 2"
 88 | 	json_dictionary["skill" + String(id)] = skill_data
 89 | 	get_parent().get_parent().call("store_data", "Skill", json_dictionary)
 90 | 
 91 | func _on_RemoveSkill_pressed():
 92 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Skill")
 93 | 	if json_dictionary.keys().size() > 1:
 94 | 		var skill_id: int = skill_selected
 95 | 		while skill_id < (json_dictionary.keys().size() - 1):
 96 | 			json_dictionary["skill"+String(skill_id)] = json_dictionary["skill"+String(skill_id+1)]
 97 | 			skill_id += 1
 98 | 		json_dictionary.erase("skill"+String(skill_id))
 99 | 		get_parent().get_parent().call("store_data", "Skill", json_dictionary)
100 | 		$SkillButton.remove_item(skill_selected)
101 | 		if skill_selected == 0:
102 | 			$SkillButton.select(skill_selected + 1)
103 | 			skill_selected += 1
104 | 		else:
105 | 			$SkillButton.select(skill_selected + 1)
106 | 			skill_selected -= 1
107 | 		$SkillButton.select(skill_selected)
108 | 		refresh_data(skill_selected)
109 | 
110 | func _on_SkillSaveButton_pressed() -> void:
111 | 	save_skill_data()
112 | 	refresh_data(skill_selected)
113 | 
114 | func save_skill_data() -> void:
115 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Skill")
116 | 	var skill_data: Dictionary = json_dictionary["skill"+String(skill_selected)]
117 | 	var effect_list: Array
118 | 	skill_data["name"] = $NameLabel/NameText.text
119 | 	$SkillButton.set_item_text(skill_selected, $NameLabel/NameText.text)
120 | 	skill_data["icon"] = icon_path
121 | 	skill_data["description"] = $DescLabel/DescText.text
122 | 	skill_data["skill_type"] = $SkillTypeLabel/SkillTypeButton.selected
123 | 	skill_data["mp_cost"] = $MPCostLabel/MPCostBox.value
124 | 	skill_data["tp_cost"] = $TPCostLabel/TPCostBox.value
125 | 	skill_data["target"] = $TargetLabel/TargetButton.selected
126 | 	skill_data["usable"] = $UsableLabel/UsableButton.selected
127 | 	skill_data["success"] = $HitLabel/HitBox.value
128 | 	skill_data["hit_type"] = $TypeLabel/TypeButton.selected
129 | 	skill_data["damage_type"] = $DamageLabel/DTypeLabel/DTypeButton.selected
130 | 	skill_data["element"] = $DamageLabel/ElementLabel/ElementButton.selected
131 | 	skill_data["formula"] = $DamageLabel/DFormulaLabel/FormulaText.text
132 | 	var effect_size: int = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.get_item_count()
133 | 	for i in effect_size:
134 | 		var effect_data: Dictionary
135 | 		effect_data["name"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.get_item_text(i)
136 | 		effect_data["data_id"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.get_item_text(i)
137 | 		effect_data["value1"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.get_item_text(i)
138 | 		effect_data["value2"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.get_item_text(i)
139 | 		effect_list.append(effect_data)
140 | 	skill_data["effects"] = effect_list
141 | 	get_parent().get_parent().call("store_data", "Skill", json_dictionary)
142 | 
143 | func _on_SkillButton_item_selected(id: int) -> void:
144 | 	skill_selected = id
145 | 	refresh_data(id)
146 | 
147 | func _on_AddSkillEffect_pressed() -> void:
148 | 	get_parent().get_parent().call("open_effect_manager", "Skill")
149 | 
150 | func _on_RemoveSkillEffect_pressed() -> void:
151 | 	var id: int = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.get_selected_items()[0]
152 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.remove_item(id)
153 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.remove_item(id)
154 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.remove_item(id)
155 | 
156 | func _on_CharacterAddEffectButton_pressed() -> void:
157 | 	get_parent().get_parent().call("open_effect_manager", "Character")
158 | 
159 | func _on_CharacterRemoveEffectButton_pressed() -> void:
160 | 	var id: int = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.get_selected_items()[0]
161 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.remove_item(id)
162 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.remove_item(id)
163 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.remove_item(id)
164 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.remove_item(id)
165 | 
166 | func add_effect_list(name: String, data_id: int, value1: String, value2: String) -> void:
167 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.add_item(name)
168 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.add_item(String(data_id))
169 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.add_item(value1)
170 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.add_item(value2)
171 | 
172 | func clear_effect_list() -> void:
173 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.clear()
174 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.clear()
175 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.clear()
176 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.clear()
177 | 
178 | # Called every frame. 'delta' is the elapsed time since the previous frame.
179 | #func _process(delta):
180 | #	pass
181 | 


--------------------------------------------------------------------------------
/addons/rpg_databases_gd/Scripts/states.gd:
--------------------------------------------------------------------------------
  1 | extends Container
  2 | tool
  3 | 
  4 | # Declare member variables here. Examples:
  5 | # var a = 2
  6 | # var b = "text"
  7 | 
  8 | var iconPath = ""
  9 | var state_selected = 0
 10 | var add_string = -1
 11 | # Called when the node enters the scene tree for the first time.
 12 | func _ready():
 13 | 	pass # Replace with function body.
 14 | 
 15 | func start():
 16 | 	var json_dictionary = get_parent().get_parent().call("read_data", "State")
 17 | 	$StateButton.clear()
 18 | 	for i in range(json_dictionary.size()):
 19 | 		var state_data = json_dictionary["state" + String(i)]
 20 | 		if i > $StateButton.get_item_count() - 1:
 21 | 			$StateButton.add_item(state_data["name"])
 22 | 		else:
 23 | 			$StateButton.set_item_text(i, state_data["name"])
 24 | 	refresh_data(state_selected)
 25 | 
 26 | func refresh_data(id):
 27 | 	var json_dictionary = get_parent().get_parent().call("read_data", "State")
 28 | 	var state_data = json_dictionary["state" + String(id)]
 29 | 	var erase_conditions = state_data["erase_conditions"]
 30 | 	var messages = state_data["messages"]
 31 | 	var custom_erase_conditions = state_data["custom_erase_conditions"]
 32 | 	$NameLabel/NameLine.text = state_data["name"]
 33 | 	var icon = state_data["icon"]
 34 | 	if icon != "":
 35 | 		iconPath = String(state_data["icon"])
 36 | 		$IconLabel/Sprite.texture = load(state_data["icon"])
 37 | 	$RestrictionLabel/RestrictionOption.selected = int(state_data["restriction"])
 38 | 	$PriorityLabel/PriorityValue.value = int(state_data["priority"])
 39 | 	$EraseLabel/TurnsLabel/MinTurns.value = int(erase_conditions["turns_min"])
 40 | 	$EraseLabel/TurnsLabel/MaxTurns.value = int(erase_conditions["turns_max"])
 41 | 	$EraseLabel/DamageLabel/Damage.value = int(erase_conditions["erase_damage"])
 42 | 	$EraseLabel/SetpsLabel/SpinBox.value = int(erase_conditions["erase_setps"])
 43 | 	$MessagesLabel/PanelContainer/VBoxContainer/MessageList.clear()
 44 | 	for message in messages.keys():
 45 | 		$MessagesLabel/PanelContainer/VBoxContainer/MessageList.add_item(message)
 46 | 	$CustomEraseLabel/PanelContainer/VBoxContainer/EraseConditions.clear()
 47 | 	for condition in custom_erase_conditions.keys():
 48 | 		$CustomEraseLabel/PanelContainer/VBoxContainer/EraseConditions.add_item(condition)
 49 | 	if (state_data.has("effects") == true):
 50 | 		clear_effect_list()
 51 | 		var effect_list: Array = state_data["effects"]
 52 | 		for effect in effect_list:
 53 | 			add_effect_list(effect["name"], int(effect["data_id"]), String(effect["value1"]), String(effect["value2"]))
 54 | 
 55 | func _on_SearchState_pressed():
 56 | 	$IconLabel/SearchDialog.popup_centered()
 57 | 
 58 | func _on_SearchStateIconDialog_file_selected(path):
 59 | 	iconPath = path
 60 | 	$IconLabel/Sprite.texture = load(path)
 61 | 
 62 | func _on_AddCustomStateCondition_pressed():
 63 | 	add_string = 0
 64 | 	$AddString.window_title = "Custom State Erase Formula"
 65 | 	$AddString.popup_centered()
 66 | 
 67 | func _on_RemoveCustomStateCondition_pressed():
 68 | 	var selected = $CustomEraseLabel/PanelContainer/VBoxContainer/EraseConditions.GetselectedItems()[0]
 69 | 	if (selected > -1):
 70 | 		$CustomEraseLabel/PanelContainer/VBoxContainer/EraseConditions.remove_item(selected)
 71 | 
 72 | func _on_AddStateMessage_pressed():
 73 | 	add_string = 1
 74 | 	$AddString.window_title = "State Message"
 75 | 	$AddString.popup_centered()
 76 | 
 77 | func _on_RemoveStateMessage_pressed():
 78 | 	var selected = $MessagesLabel/PanelContainer/VBoxContainer/MessageList.GetselectedItems()[0]
 79 | 	if (selected > -1):
 80 | 		$MessagesLabel/PanelContainer/VBoxContainer/MessageList.remove_item(selected)
 81 | 
 82 | func _on_ConfirmAddString_pressed():
 83 | 	var text = $AddString/LineEdit.text
 84 | 	if (add_string == 0):
 85 | 		$CustomEraseLabel/PanelContainer/VBoxContainer/EraseConditions.add_item(text)
 86 | 	elif (add_string == 1):
 87 | 		$MessagesLabel/PanelContainer/VBoxContainer/MessageList.add_item(text)
 88 | 	add_string = -1
 89 | 	$AddString.hide()
 90 | 
 91 | func _on_CancelAddString_pressed():
 92 | 	add_string = -1
 93 | 	$AddString.hide()
 94 | 
 95 | func _on_StateButton_item_selected(id):
 96 | 	state_selected = id
 97 | 	refresh_data(id)
 98 | 
 99 | func _on_AddState_pressed():
100 | 	$StateButton.add_item("NewState")
101 | 	var id = $StateButton.get_item_count() - 1
102 | 	var json_dictionary = get_parent().get_parent().call("read_data", "State")
103 | 	var state_data:Dictionary
104 | 	var erase_condition:Dictionary
105 | 	var messages:Dictionary
106 | 	var custom_erase_conditions:Dictionary
107 | 	state_data["name"] = "NewState"
108 | 	state_data["icon"] = ""
109 | 	state_data["restriction"] = 4
110 | 	state_data["priority"] = 100
111 | 	erase_condition["turns_min"] = 0
112 | 	erase_condition["turns_max"] = 0
113 | 	erase_condition["erase_damage"] = 0
114 | 	erase_condition["erase_setps"] = 0
115 | 	state_data["erase_conditions"] = erase_condition
116 | 	messages["0"] = "Insert a custom message"
117 | 	state_data["messages"] = messages
118 | 	custom_erase_conditions["0"] = "Insert a custom condition"
119 | 	state_data["custom_erase_conditions"] = custom_erase_conditions
120 | 	json_dictionary["state" + String(id)] = state_data
121 | 	get_parent().get_parent().call("store_data", "State", json_dictionary)
122 | 
123 | func _on_RemoveState_pressed():
124 | 	var json_dictionary = get_parent().get_parent().call("read_data", "State")
125 | 	if (json_dictionary.keys().size() > 1):
126 | 		var state_id = state_selected
127 | 		while (state_id < json_dictionary.keys().size() - 1):
128 | 			json_dictionary["state" + String(state_id)] = json_dictionary["state" + String(state_id + 1)]
129 | 			state_id += 1
130 | 		json_dictionary.erase("state" + String(state_id))
131 | 		get_parent().get_parent().call("store_data", "State", json_dictionary)
132 | 		$StateButton.remove_item(state_selected)
133 | 		if (state_selected == 0):
134 | 			$StateButton.select(state_selected + 1)
135 | 			state_selected += 1
136 | 		else:
137 | 			$StateButton.select(state_selected - 1)
138 | 			state_selected -= 1
139 | 		$StateButton.select(state_selected)
140 | 		refresh_data(state_selected)
141 | 
142 | func _on_SaveStates_pressed():
143 | 	var json_dictionary = get_parent().get_parent().call("read_data", "State")
144 | 	var state_data = json_dictionary["state" + String(state_selected)]
145 | 	var erase_condition = state_data["erase_conditions"]
146 | 	var messages = state_data["messages"]
147 | 	var custom_erase_conditions = state_data["custom_erase_conditions"]
148 | 	var effect_list: Array
149 | 
150 | 	state_data["name"] = $NameLabel/NameLine.text
151 | 	state_data["icon"] = iconPath
152 | 	state_data["restriction"] = $RestrictionLabel/RestrictionOption.selected
153 | 	state_data["priority"] = $PriorityLabel/PriorityValue.value
154 | 	erase_condition["turns_min"] = $EraseLabel/TurnsLabel/MinTurns.value
155 | 	erase_condition["turns_max"] = $EraseLabel/TurnsLabel/MaxTurns.value
156 | 	erase_condition["erase_damage"] = $EraseLabel/DamageLabel/Damage.value
157 | 	erase_condition["erase_setps"] = $EraseLabel/SetpsLabel/SpinBox.value
158 | 	var items = $MessagesLabel/PanelContainer/VBoxContainer/MessageList.get_item_count()
159 | 	for i in range(items):
160 | 		messages[String(i)] = $MessagesLabel/PanelContainer/VBoxContainer/MessageList.get_item_text(i)
161 | 	items = $CustomEraseLabel/PanelContainer/VBoxContainer/EraseConditions.get_item_count()
162 | 	for i in range(items):
163 | 		custom_erase_conditions[String(i)] = $CustomEraseLabel/PanelContainer/VBoxContainer/EraseConditions.get_item_text(i)
164 | 	var effect_size = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.get_item_count()
165 | 	for i in range(effect_size):
166 | 		var effect_data: Dictionary
167 | 		effect_data["name"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.get_item_text(i)
168 | 		effect_data["data_id"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.get_item_text(i)
169 | 		effect_data["value1"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.get_item_text(i)
170 | 		effect_data["value2"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.get_item_text(i)
171 | 		effect_list.append(effect_data)
172 | 	state_data["effects"] = effect_list
173 | 	get_parent().get_parent().call("store_data", "State", json_dictionary)
174 | 	refresh_data(state_selected)
175 | 
176 | func _on_AddStateEffect_pressed() -> void:
177 | 	get_parent().get_parent().call("open_effect_manager", "States")
178 | 
179 | func _on_RemoveStateEffect_pressed() -> void:
180 | 	var id = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.get_selected_items()[0]
181 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.remove_item(id)
182 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.remove_item(id)
183 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.remove_item(id)
184 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.remove_item(id)
185 | 
186 | func add_effect_list(name: String, data_id: int, value1: String, value2: String) -> void:
187 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.add_item(name)
188 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.add_item(String(data_id))
189 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.add_item(value1)
190 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.add_item(value2)
191 | 
192 | func clear_effect_list() -> void:
193 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.clear()
194 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.clear()
195 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.clear()
196 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.clear()
197 | 
198 | # Called every frame. 'delta' is the elapsed time since the previous frame.
199 | #func _process(delta):
200 | #	pass
201 | 


--------------------------------------------------------------------------------
/addons/rpg_databases_gd/Scripts/system.gd:
--------------------------------------------------------------------------------
  1 | extends Container
  2 | tool
  3 | 
  4 | # Declare member variables here. Examples:
  5 | # var a = 2
  6 | # var b = "text"
  7 | 
  8 | var edited_field: int = -1
  9 | # Called when the node enters the scene tree for the first time.
 10 | func _ready():
 11 | 	pass # Replace with function body.
 12 | 
 13 | func start() -> void:
 14 | 	var json_dictionary = get_parent().get_parent().call("read_data", "System")
 15 | 	var stats_data = json_dictionary["stats"]
 16 | 	var weapons_data = json_dictionary["weapons"]
 17 | 	var armors_data = json_dictionary["armors"]
 18 | 	var elements_data = json_dictionary["elements"]
 19 | 	var slots_data = json_dictionary["slots"]
 20 | 	var skills_data
 21 | 	if json_dictionary.has("skills"):
 22 | 		skills_data = json_dictionary["skills"]
 23 | 	else:
 24 | 		skills_data["0"] = "Skills"
 25 | 		skills_data["1"] = "Magic"
 26 | 		json_dictionary["skills"] = skills_data
 27 | 		get_parent().get_parent().call("store_data", "System", json_dictionary)
 28 | 	$StatsLabel/StatsContainer/StatsBoxContainer/StatsList.clear()
 29 | 	$WeaponTypesLabel/WeaponTypesContainer/WpBoxContainer/WeaponList.clear()
 30 | 	$ArmorTypesLabel/ArmorTypesContainer/ArBoxContainer/ArmorList.clear()
 31 | 	$ElementLabel/ElementContainer/EleBoxContainer/ElementList.clear()
 32 | 	$EquipmentLabel/EquipContainer/SetContainer/SetDivisor/KindList.clear()
 33 | 	$EquipmentLabel/EquipContainer/SetContainer/SetDivisor/TypeList.clear()
 34 | 	$SkillTypesLabel/SkillTypeContainer/VBoxContainer/SkillTypeList.clear()
 35 | 	for i in range(stats_data.size()):
 36 | 		var item = $StatsLabel/StatsContainer/StatsBoxContainer/StatsList
 37 | 		item.add_item(stats_data[String(i)])
 38 | 	for i in range(weapons_data.size()):
 39 | 		var item = $WeaponTypesLabel/WeaponTypesContainer/WpBoxContainer/WeaponList
 40 | 		item.add_item(weapons_data[String(i)])
 41 | 	for i in range(armors_data.size()):
 42 | 		var item = $ArmorTypesLabel/ArmorTypesContainer/ArBoxContainer/ArmorList
 43 | 		item.add_item(armors_data[String(i)])
 44 | 	for i in range(elements_data.size()):
 45 | 		var item = $ElementLabel/ElementContainer/EleBoxContainer/ElementList
 46 | 		item.add_item(elements_data[String(i)])
 47 | 	for i in range(skills_data.size()):
 48 | 		var item = $SkillTypesLabel/SkillTypeContainer/VBoxContainer/SkillTypeList
 49 | 		item.add_item(skills_data[String(i)])
 50 | 	for id in slots_data.keys():
 51 | 		var kind = $EquipmentLabel/EquipContainer/SetContainer/SetDivisor/KindList
 52 | 		var kindId: String = String(id[0])
 53 | 		var type = $EquipmentLabel/EquipContainer/SetContainer/SetDivisor/TypeList
 54 | 		match (kindId):
 55 | 			"w":
 56 | 				kind.add_item("Weapon")
 57 | 				type.add_item(slots_data[id])
 58 | 			"a":
 59 | 				kind.add_item("Armor")
 60 | 				type.add_item(slots_data[id])
 61 | 
 62 | func save_data():
 63 | 	save_stats()
 64 | 	save_weapons()
 65 | 	save_armors()
 66 | 	save_elements()
 67 | 	save_slots()
 68 | 	save_skills()
 69 | 
 70 | func save_stats():
 71 | 	var json_dictionary = get_parent().get_parent().call("read_data", "System")
 72 | 	var stats_data: Dictionary
 73 | 	var stat_size = $StatsLabel/StatsContainer/StatsBoxContainer/StatsList.get_item_count()
 74 | 	for i in range(stat_size):
 75 | 		var text = $StatsLabel/StatsContainer/StatsBoxContainer/StatsList.get_item_text(i)
 76 | 		stats_data[String(i)] = text
 77 | 	json_dictionary["stats"] = stats_data
 78 | 	get_parent().get_parent().call("store_data", "System", json_dictionary)
 79 | 
 80 | func save_weapons():
 81 | 	var json_dictionary = get_parent().get_parent().call("read_data", "System")
 82 | 	var weapons_data: Dictionary
 83 | 	var weapon_size = $WeaponTypesLabel/WeaponTypesContainer/WpBoxContainer/WeaponList.get_item_count()
 84 | 	for i in range(weapon_size):
 85 | 		var text = $WeaponTypesLabel/WeaponTypesContainer/WpBoxContainer/WeaponList.get_item_text(i)
 86 | 		weapons_data[String(i)] = text
 87 | 	json_dictionary["weapons"] = weapons_data
 88 | 	get_parent().get_parent().call("store_data", "System", json_dictionary)
 89 | 
 90 | func save_armors():
 91 | 	var json_dictionary = get_parent().get_parent().call("read_data", "System")
 92 | 	var armors_data: Dictionary
 93 | 	var armor_size = $ArmorTypesLabel/ArmorTypesContainer/ArBoxContainer/ArmorList.get_item_count()
 94 | 	for i in range(armor_size):
 95 | 		var text = $ArmorTypesLabel/ArmorTypesContainer/ArBoxContainer/ArmorList.get_item_text(i)
 96 | 		armors_data[String(i)] = text
 97 | 	json_dictionary["armors"] = armors_data
 98 | 	get_parent().get_parent().call("store_data", "System", json_dictionary)
 99 | 
100 | func save_elements():
101 | 	var json_dictionary = get_parent().get_parent().call("read_data", "System")
102 | 	var elements_data: Dictionary
103 | 	var element_size = $ElementLabel/ElementContainer/EleBoxContainer/ElementList.get_item_count()
104 | 	for i in range(element_size):
105 | 		var text = $ElementLabel/ElementContainer/EleBoxContainer/ElementList.get_item_text(i)
106 | 		elements_data[String(i)] = text
107 | 	json_dictionary["elements"] = elements_data
108 | 	get_parent().get_parent().call("store_data", "System", json_dictionary)
109 | 
110 | func save_skills():
111 | 	var json_dictionary = get_parent().get_parent().call("read_data", "System")
112 | 	var skills_data: Dictionary
113 | 	var skill_size = $SkillTypesLabel/SkillTypeContainer/VBoxContainer/SkillTypeList.get_item_count()
114 | 	for i in range(skill_size):
115 | 		var text = $SkillTypesLabel/SkillTypeContainer/VBoxContainer/SkillTypeList.get_item_text(i)
116 | 		skills_data[String(i)] = text
117 | 	json_dictionary["skills"] = skills_data
118 | 	get_parent().get_parent().call("store_data", "System", json_dictionary)
119 | 
120 | func save_slots():
121 | 	var json_dictionary = get_parent().get_parent().call("read_data", "System")
122 | 	var slots_data: Dictionary
123 | 	var slot_size = $EquipmentLabel/EquipContainer/SetContainer/SetDivisor/KindList.get_item_count()
124 | 	for i in range(slot_size):
125 | 		var kind = $EquipmentLabel/EquipContainer/SetContainer/SetDivisor/KindList.get_item_text(i)
126 | 		var id = ""
127 | 		match (kind):
128 | 			"Weapon":
129 | 				id = "w"
130 | 			"Armor":
131 | 				id = "a"
132 | 		var text = $EquipmentLabel/EquipContainer/SetContainer/SetDivisor/TypeList.get_item_text(i)
133 | 		id += String(i)
134 | 		slots_data[String(id)] = text
135 | 	json_dictionary["slots"] = slots_data
136 | 	get_parent().get_parent().call("store_data", "System", json_dictionary)
137 | 
138 | func _on_OKButton_pressed():
139 | 	var name = $EditField/FieldName.text
140 | 	if (name != ""):
141 | 		if (edited_field == 0):
142 | 			$StatsLabel/StatsContainer/StatsBoxContainer/StatsList.add_item(name)
143 | 		elif (edited_field == 1):
144 | 			$WeaponTypesLabel/WeaponTypesContainer/WpBoxContainer/WeaponList.add_item(name)
145 | 		elif (edited_field == 2):
146 | 			$ArmorTypesLabel/ArmorTypesContainer/ArBoxContainer/ArmorList.add_item(name)
147 | 		elif (edited_field == 3):
148 | 			$ElementLabel/ElementContainer/EleBoxContainer/ElementList.add_item(name)
149 | 		elif (edited_field == 4):
150 | 			$SkillTypesLabel/SkillTypeContainer/VBoxContainer/SkillTypeList.add_item(name)
151 | 		save_data()
152 | 	$EditField.hide()
153 | 	edited_field = -1
154 | 
155 | func _on_CancelButton_pressed():
156 | 	edited_field = -1
157 | 	$EditField.hide()
158 | 
159 | func _on_EditField_popup_hide():
160 | 	edited_field = -1
161 | 	$EditField.hide()
162 | 
163 | func _on_AddStat_pressed():
164 | 	edited_field = 0
165 | 	$EditField.window_title = "Add Stat"
166 | 	$EditField.popup_centered(Vector2(392, 95))
167 | 
168 | func _on_RemoveStat_pressed():
169 | 	var index = $StatsLabel/StatsContainer/StatsBoxContainer/StatsList.get_selected_items()[0]
170 | 	if (index > -1):
171 | 		$StatsLabel/StatsContainer/StatsBoxContainer/StatsList.remove_item(index)
172 | 		save_data()
173 | 
174 | func _on_AddWeapon_pressed():
175 | 	edited_field = 1
176 | 	$EditField.window_title = "Add Weapon"
177 | 	$EditField.popup_centered(Vector2(392, 95))
178 | 
179 | func _on_RemoveWeapon_pressed():
180 | 	var index = $WeaponTypesLabel/WeaponTypesContainer/WpBoxContainer/WeaponList.get_selected_items()[0]
181 | 	if (index > -1):
182 | 		$WeaponTypesLabel/WeaponTypesContainer/WpBoxContainer/WeaponList.remove_item(index)
183 | 		save_data()
184 | 
185 | func _on_AddArmor_pressed():
186 | 	edited_field = 2
187 | 	$EditField.window_title = "Add Armor"
188 | 	$EditField.popup_centered(Vector2(392, 95))
189 | 
190 | func _on_RemoveArmor_pressed():
191 | 	var index = $ArmorTypesLabel/ArmorTypesContainer/ArBoxContainer/ArmorList.get_selected_items()[0]
192 | 	if (index > -1):
193 | 		$ArmorTypesLabel/ArmorTypesContainer/ArBoxContainer/ArmorList.remove_item(index)
194 | 		save_data()
195 | 
196 | func _on_AddElement_pressed():
197 | 	edited_field = 3
198 | 	$EditField.window_title = "Add Element"
199 | 	$EditField.popup_centered(Vector2(392, 95))
200 | 
201 | func _on_RemoveElement_pressed():
202 | 	var index = $ElementLabel/ElementContainer/EleBoxContainer/ElementList.get_selected_items()[0]
203 | 	if (index > -1):
204 | 		$ElementLabel/ElementContainer/EleBoxContainer/ElementList.remove_item(index)
205 | 		save_data()
206 | 
207 | func _on_AddSkillType_pressed():
208 | 	edited_field = 4
209 | 	$EditField.window_title = "Add Skill Type"
210 | 	$EditField.popup_centered(Vector2(392, 95))
211 | 
212 | func _on_RemoveSKillType_pressed():
213 | 	var index = $SkillTypesLabel/SkillTypeContainer/VBoxContainer/SkillTypeList.get_selected_items()[0]
214 | 	if (index > -1):
215 | 		$SkillTypesLabel/SkillTypeContainer/VBoxContainer/SkillTypeList.remove_item(index)
216 | 		save_data()
217 | 
218 | func _on_AddSet_pressed():
219 | 	$AddSlot.popup_centered()
220 | 
221 | func _on_RemoveSet_pressed():
222 | 	var index = $EquipmentLabel/EquipContainer/SetContainer/SetDivisor/TypeList.get_selected_items()[0]
223 | 	if (index > -1):
224 | 		$EquipmentLabel/EquipContainer/SetContainer/SetDivisor/KindList.remove_item(index)
225 | 		$EquipmentLabel/EquipContainer/SetContainer/SetDivisor/TypeList.remove_item(index)
226 | 		save_data()
227 | 
228 | func _on_AddSlotCancelButton_pressed():
229 | 	$AddSlot.hide()
230 | 
231 | func _on_AddSlotOkButton_pressed():
232 | 	var kind = $AddSlot/TypeLabel/TypeButton.selected
233 | 	match (kind):
234 | 		0:
235 | 			$EquipmentLabel/EquipContainer/SetContainer/SetDivisor/KindList.add_item("Weapon")
236 | 		1:
237 | 			$EquipmentLabel/EquipContainer/SetContainer/SetDivisor/KindList.add_item("Armor")
238 | 	var name = $AddSlot/NameLabel/NameEdit.text
239 | 	$EquipmentLabel/EquipContainer/SetContainer/SetDivisor/TypeList.add_item(name)
240 | 	save_data()
241 | 	$AddSlot.hide()
242 | # Called every frame. 'delta' is the elapsed time since the previous frame.
243 | #func _process(delta):
244 | #	pass
245 | 


--------------------------------------------------------------------------------
/addons/rpg_databases_gd/Scripts/weapon.gd:
--------------------------------------------------------------------------------
  1 | extends Container
  2 | tool
  3 | 
  4 | # Declare member variables here. Examples:
  5 | # var a = 2
  6 | # var b = "text"
  7 | 
  8 | var icon_path: String = ""
  9 | var weapon_selected: int = 0
 10 | var stat_edit: int = -1
 11 | # Called when the node enters the scene tree for the first time.
 12 | func _ready():
 13 | 	pass # Replace with function body.
 14 | 
 15 | func start() -> void:
 16 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Weapon")
 17 | 	$WeaponButton.clear()
 18 | 	for i in range(json_dictionary.size()):
 19 | 		var weapon_data: Dictionary = json_dictionary["weapon"+String(i)]
 20 | 		if i > $WeaponButton.get_item_count() - 1:
 21 | 			$WeaponButton.add_item(weapon_data["name"])
 22 | 		else:
 23 | 			$WeaponButton.set_item_text(i, weapon_data["name"])
 24 | 	json_dictionary = get_parent().get_parent().call("read_data", "System")
 25 | 	var system_data: Dictionary = json_dictionary["elements"]
 26 | 	for i in range(system_data.size()):
 27 | 		if i > $ElementLabel/ElementButton.get_item_count() - 1:
 28 | 			$ElementLabel/ElementButton.add_item(system_data[String(i)])
 29 | 		else:
 30 | 			$ElementLabel/ElementButton.set_item_text(i, system_data[String(i)])
 31 | 	system_data = json_dictionary["weapons"]
 32 | 	for i in range(system_data.size()):
 33 | 		if i > $WTypeLabel/WTypeButton.get_item_count() - 1:
 34 | 			$WTypeLabel/WTypeButton.add_item(system_data[String(i)])
 35 | 		else:
 36 | 			$WTypeLabel/WTypeButton.set_item_text(i, system_data[String(i)])
 37 | 	system_data = json_dictionary["slots"]
 38 | 	var final_id: int = 0
 39 | 	for string in system_data.keys():
 40 | 		if string[0] == "w":
 41 | 			var id = string
 42 | 			id.erase(0, 1)
 43 | 			if int(id) > $SlotLabel/SlotButton.get_item_count() - 1:
 44 | 				$SlotLabel/SlotButton.add_item(system_data[string])
 45 | 			else:
 46 | 				$SlotLabel/SlotButton.set_item_text(int(id), system_data[string])
 47 | 		else:
 48 | 			final_id += 1
 49 | 	refresh_data(weapon_selected)
 50 | 
 51 | func refresh_data(id: int) -> void:
 52 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Weapon")
 53 | 	var weapon_data: Dictionary = json_dictionary["weapon" + String(id)]
 54 | 	json_dictionary = get_parent().get_parent().call("read_data", "System")
 55 | 	var system_data: Dictionary = json_dictionary["stats"]
 56 | 	$NameLabel/NameText.text = weapon_data["name"]
 57 | 	var icon: String = weapon_data["icon"]
 58 | 	if icon != "":
 59 | 		icon_path = icon
 60 | 		$IconLabel/IconSprite.texture = load(icon)
 61 | 	$DescLabel/DescText.text = weapon_data["description"]
 62 | 	$WTypeLabel/WTypeButton.selected = int(weapon_data["weapon_type"])
 63 | 	$SlotLabel/SlotButton.selected = int(weapon_data["slot_type"])
 64 | 	$PriceLabel/PriceSpin.value = int(weapon_data["price"])
 65 | 	$ElementLabel/ElementButton.selected = int(weapon_data["element"])
 66 | 	$StatsLabel/StatsContainer/DataContainer/StatNameCont/StatNameList.clear()
 67 | 	$StatsLabel/StatsContainer/DataContainer/StatValueCont/StatValueList.clear()
 68 | 	for i in range(system_data.size()):
 69 | 		var stat_name: String = system_data[String(i)]
 70 | 		var weapon_stat_formula: Dictionary = weapon_data["stat_list"]
 71 | 		var stat_formula: String = ""
 72 | 		if weapon_stat_formula.has(stat_name):
 73 | 			stat_formula = weapon_stat_formula[stat_name]
 74 | 		else:
 75 | 			stat_formula = "0"
 76 | 		$StatsLabel/StatsContainer/DataContainer/StatNameCont/StatNameList.add_item(stat_name)
 77 | 		$StatsLabel/StatsContainer/DataContainer/StatValueCont/StatValueList.add_item(stat_formula)
 78 | 	if weapon_data.has("effects") == true:
 79 | 		clear_effect_list()
 80 | 		var effect_list: Array = weapon_data["effects"]
 81 | 		for effect in effect_list:
 82 | 			add_effect_list(effect["name"], int(effect["data_id"]), String(effect["value1"]), String(effect["value2"]))
 83 | 
 84 | func _on_AddWeaponButton_pressed() -> void:
 85 | 	$WeaponButton.add_item("NewWeapon")
 86 | 	var id: int = $WeaponButton.get_item_count() - 1
 87 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Weapon")
 88 | 	var weapon_data: Dictionary
 89 | 	var weapon_stats: Dictionary
 90 | 	weapon_data["name"] = "NewWeapon"
 91 | 	weapon_data["icon"] = ""
 92 | 	weapon_data["description"] = "New created weapon"
 93 | 	weapon_data["weapon_type"] = 0
 94 | 	weapon_data["slot_type"] = 0
 95 | 	weapon_data["price"] = 50
 96 | 	weapon_data["element"] = 0
 97 | 	weapon_stats["hp"] = "0"
 98 | 	weapon_stats["mp"] = "0"
 99 | 	weapon_stats["atk"] = "0"
100 | 	weapon_stats["def"] = "0"
101 | 	weapon_stats["int"] = "0"
102 | 	weapon_stats["res"] = "0"
103 | 	weapon_stats["spd"] = "0"
104 | 	weapon_stats["luk"] = "0"
105 | 	weapon_data["stat_list"] = weapon_stats
106 | 	json_dictionary["weapon" + String(id)] = weapon_data
107 | 	get_parent().get_parent().call("store_data", "Weapon", json_dictionary)
108 | 
109 | func _on_RemoveWeapon_pressed() -> void:
110 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Weapon")
111 | 	if json_dictionary.keys().size() > 1:
112 | 		var weapon_id: int = weapon_selected
113 | 		while weapon_id < (json_dictionary.keys().size() - 1):
114 | 			json_dictionary["weapon"+String(weapon_id)] = json_dictionary["weapon"+String(weapon_id+1)]
115 | 			weapon_id += 1
116 | 		json_dictionary.erase("weapon"+String(weapon_id))
117 | 		get_parent().get_parent().call("store_data", "Weapon", json_dictionary)
118 | 		$WeaponButton.remove_item(weapon_selected)
119 | 		if weapon_selected == 0:
120 | 			$WeaponButton.select(weapon_selected + 1)
121 | 			weapon_selected += 1
122 | 		else:
123 | 			$WeaponButton.select(weapon_selected + 1)
124 | 			weapon_selected -= 1
125 | 		$WeaponButton.select(weapon_selected)
126 | 		refresh_data(weapon_selected)
127 | 
128 | func _on_WeaponSaveButton_pressed() -> void:
129 | 	save_weapon_data()
130 | 	refresh_data(weapon_selected)
131 | 
132 | func _on_Search_pressed() -> void:
133 | 	$IconLabel/IconSearch.popup_centered()
134 | 
135 | func _on_IconSearch_file_selected(path: String) -> void:
136 | 	icon_path = path
137 | 	$IconLabel/IconSprite.texture = load(path)
138 | 
139 | func _on_WeaponButton_item_selected(id: int) -> void:
140 | 	weapon_selected = id
141 | 	refresh_data(id)
142 | 
143 | func save_weapon_data() -> void:
144 | 	var json_dictionary: Dictionary = get_parent().get_parent().call("read_data", "Weapon")
145 | 	var weapon_data: Dictionary = json_dictionary["weapon"+String(weapon_selected)]
146 | 	var weapon_stat_formula: Dictionary = weapon_data["stat_list"]
147 | 	var effect_list: Array
148 | 	weapon_data["name"] = $NameLabel/NameText.text
149 | 	$WeaponButton.set_item_text(weapon_selected, $NameLabel/NameText.text)
150 | 	weapon_data["icon"] = icon_path
151 | 	weapon_data["description"] = $DescLabel/DescText.text
152 | 	weapon_data["weapon_type"] = $WTypeLabel/WTypeButton.selected
153 | 	weapon_data["slot_type"] = $SlotLabel/SlotButton.selected
154 | 	weapon_data["price"] = $PriceLabel/PriceSpin.value
155 | 	weapon_data["element"] = $ElementLabel/ElementButton.selected
156 | 	var items: int = $StatsLabel/StatsContainer/DataContainer/StatNameCont/StatNameList.get_item_count()
157 | 	for i in range(items):
158 | 		var stat: String = $StatsLabel/StatsContainer/DataContainer/StatNameCont/StatNameList.get_item_text(i)
159 | 		var formula: String = $StatsLabel/StatsContainer/DataContainer/StatValueCont/StatValueList.get_item_text(i)
160 | 		weapon_stat_formula[stat] = formula
161 | 	var effect_size: int = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.get_item_count()
162 | 	for i in effect_size:
163 | 		var effect_data: Dictionary
164 | 		effect_data["name"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.get_item_text(i)
165 | 		effect_data["data_id"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.get_item_text(i)
166 | 		effect_data["value1"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.get_item_text(i)
167 | 		effect_data["value2"] = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.get_item_text(i)
168 | 		effect_list.append(effect_data)
169 | 	weapon_data["effects"] = effect_list
170 | 	get_parent().get_parent().call("store_data", "Weapon", json_dictionary)
171 | 
172 | func _on_StatValueList_item_activated(index: int) -> void:
173 | 	var stat_name: String = $StatsLabel/StatsContainer/DataContainer/StatNameCont/StatNameList.get_item_text(index)
174 | 	var stat_formula: String = $StatsLabel/StatsContainer/DataContainer/StatValueCont/StatValueList.get_item_text(index)
175 | 	$StatEditor/StatLabel.text = stat_name
176 | 	$StatEditor/StatEdit.text = stat_formula
177 | 	stat_edit = index
178 | 	$StatEditor.show()
179 | 
180 | func _on_OkButton_pressed() -> void:
181 | 	var stat_formula: String = $StatEditor/StatEdit.text
182 | 	$StatsLabel/StatsContainer/DataContainer/StatValueCont/StatValueList.set_item_text(stat_edit, stat_formula)
183 | 	save_weapon_data()
184 | 	stat_edit = -1
185 | 	$StatEditor.hide()
186 | 
187 | func _on_CancelButton_pressed() -> void:
188 | 	stat_edit = -1
189 | 	$StatEditor.hide()
190 | 
191 | func  _on_AddWeaponEffect_pressed() -> void:
192 | 	get_parent().get_parent().call("open_effect_manager", "Weapon")
193 | 
194 | func _on_RemoveWeaponEffect_pressed() -> void:
195 | 	var id: int = $EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.get_selected_items()[0]
196 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.remove_item(id)
197 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.remove_item(id)
198 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.remove_item(id)
199 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.remove_item(id)
200 | 
201 | func add_effect_list(name: String, data_id: int, value1: String, value2: String) -> void:
202 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.add_item(name)
203 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.add_item(String(data_id))
204 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.add_item(value1)
205 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.add_item(value2)
206 | 
207 | func clear_effect_list() -> void:
208 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectNames.clear()
209 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/DataType.clear()
210 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue1.clear()
211 | 	$EffectLabel/PanelContainer/VBoxContainer/HBoxContainer/EffectValue2.clear()
212 | 
213 | # Called every frame. 'delta' is the elapsed time since the previous frame.
214 | #func _process(delta):
215 | #	pass
216 | 


--------------------------------------------------------------------------------
/addons/rpg_databases_gd/database.gd:
--------------------------------------------------------------------------------
 1 | tool
 2 | extends EditorPlugin
 3 | 
 4 | var instanced_scene: Control = null
 5 | var button: Button = Button.new()
 6 | 
 7 | func _enter_tree() -> void:
 8 | 	instanced_scene = load("res://addons/rpg_databases_gd/Scenes/Base.tscn").instance()
 9 | 	button.text = "Database"
10 | 	button.connect("pressed", self, "_on_button_pressed")
11 | 	add_control_to_container(EditorPlugin.CONTAINER_TOOLBAR, button)
12 | 	add_child(instanced_scene)
13 | 
14 | 
15 | func _exit_tree() -> void:
16 | 	remove_child(instanced_scene)
17 | 	remove_control_from_container(EditorPlugin.CONTAINER_TOOLBAR, button)
18 | 	button.queue_free()
19 | 	instanced_scene.queue_free()
20 | 
21 | func _on_button_pressed() -> void:
22 | 	if (instanced_scene.visible == false):
23 | 		var pos: Vector2 = Vector2(150, 150)
24 | 		instanced_scene.set_position(pos)
25 | 		instanced_scene.show()
26 | 	else:
27 | 		instanced_scene.hide()
28 | 


--------------------------------------------------------------------------------
/addons/rpg_databases_gd/plugin.cfg:
--------------------------------------------------------------------------------
1 | [plugin]
2 | 
3 | name="RPG Databases (gdscript)"
4 | description=""
5 | author="sdtv9507"
6 | version="1.1.1"
7 | script="database.gd"
8 | 


--------------------------------------------------------------------------------
/databases/Armor.json:
--------------------------------------------------------------------------------
1 | {"armor0":{"name":"Armor","icon":"","description":"Light Clothes","armor_type":0,"slot_type":1,"price":50,"stat_list":{"hp":"0","mp":"0","atk":"0","def":"5","int":"0","res":"0","spd":"0","luk":"0"},"effects":[]},"armor1":{"name":"Robe","icon":"","description":"New created armor","armor_type":1,"slot_type":1,"price":50,"stat_list":{"hp":"0","mp":"0","atk":"0","def":"3","int":"0","res":"3","spd":"0","luk":"0"},"effects":[]},"armor2":{"name":"Shield","icon":"","description":"New created armor","armor_type":2,"slot_type":3,"price":50,"stat_list":{"hp":"0","mp":"0","atk":"0","def":"2","int":"0","res":"0","spd":"-1","luk":"0"},"effects":[]},"armor3":{"name":"Hat","icon":"","description":"New created armor","armor_type":3,"slot_type":0,"price":50,"stat_list":{"hp":"0","mp":"0","atk":"0","def":"0","int":"0","res":"4","spd":"0","luk":"0"},"effects":[]},"armor4":{"name":"Helmet","icon":"","description":"New created armor","armor_type":5,"slot_type":0,"price":50,"stat_list":{"hp":"0","mp":"0","atk":"0","def":"0","int":"0","res":"3","spd":"0","luk":"0"},"effects":[]}}


--------------------------------------------------------------------------------
/databases/Character.json:
--------------------------------------------------------------------------------
1 | {"chara0":{"faceImage":"","charaImage":"","name":"Kate","class":0,"description":"","initialLevel":1,"maxLevel":99,"initial_equip":{"0":0,"1":4,"2":0,"3":-1,"4":2},"equip_types":{"w0":0,"w1":1,"a2":0,"a3":5,"a4":2},"effects":[]},"chara1":{"faceImage":"res://","charaImage":"","name":"Maria","class":0,"description":"","initialLevel":1,"maxLevel":99,"initial_equip":{"0":3,"1":3,"2":1,"3":-1,"4":-1},"equip_types":{"w0":3,"a1":1,"a2":3},"effects":[]},"chara2":{"faceImage":"res://","charaImage":"","name":"Reyson","class":2,"description":"","initialLevel":1,"maxLevel":99,"initial_equip":{"0":3,"1":3,"2":1,"3":-1,"4":-1},"equip_types":{"w0":3,"a1":3,"a2":1},"effects":[]}}


--------------------------------------------------------------------------------
/databases/Class.json:
--------------------------------------------------------------------------------
1 | {"class0":{"name":"Warrior","icon":"","experience":"level * 30","skill_list":{"1":5,"2":8,"3":12},"stat_list":{"hp":"level * 25 + 20","mp":"level * 15 + 5","atk":"level * 5 + 6","def":"level * 5 + 5","int":"level * 5 + 3","res":"level * 5 + 3","spd":"level * 5 + 3","luk":"level * 5 + 3"},"effects":[{"name":"Element Attack","data_id":"0","value1":"10","value2":"0"}]},"class1":{"name":"Mage","icon":"","experience":"level * 30","stat_list":{"hp":"level * 22 + 5","mp":"level * 15 + 5","atk":"level * 4 + 3","def":"level * 5 + 3","int":"level * 7 + 3","res":"level * 6 + 3","spd":"level * 5 + 3","luk":"level * 5 + 3"},"skill_list":{"4":6,"5":7,"6":8},"effects":[{"name":"Add Skill Type","data_id":"1","value1":"1","value2":"0"},{"name":"Element Attack","data_id":"1","value1":"15","value2":"0"},{"name":"Element Attack","data_id":"2","value1":"15","value2":"0"},{"name":"Element Attack","data_id":"2","value1":"15","value2":"0"}]},"class2":{"name":"Priest","icon":"","experience":"level * 30","stat_list":{"hp":"level * 20 + 10","mp":"level * 20 + 5","atk":"level * 2 + 3","def":"level * 3 + 3","int":"level * 5 + 3","res":"level * 7 + 3","spd":"level * 5 + 3","luk":"level * 5 + 3"},"skill_list":{"0":5},"effects":[{"name":"Element Defense","data_id":"1","value1":"15","value2":"0"},{"name":"Element Defense","data_id":"2","value1":"15","value2":"0"},{"name":"Element Defense","data_id":"3","value1":"15","value2":"0"}]}}


--------------------------------------------------------------------------------
/databases/Effect.json:
--------------------------------------------------------------------------------
1 | {"effect0":{"name":"HP Recovery","data_type":{"show":false,"data":""},"value1":1,"value2":{"show":true,"data":2}},"effect1":{"name":"MP Recovery","data_type":{"show":false,"data":""},"value1":1,"value2":{"show":true,"data":2}},"effect2":{"name":"Add State","data_type":{"show":true,"data":"States"},"value1":1,"value2":{"show":false,"data":""}},"effect3":{"name":"Remove State","data_type":{"show":true,"data":"States"},"value1":1,"value2":{"show":false,"data":""}},"effect4":{"name":"Increase Stat","data_type":{"show":true,"data":"Stats"},"value1":1,"value2":{"show":false,"data":""}},"effect5":{"name":"Decrease Stat","data_type":{"show":true,"data":"Stats"},"value1":1,"value2":{"show":false,"data":""}},"effect6":{"name":"Add Weapon Type","data_type":{"show":true,"data":"Weapon Types"},"value1":1,"value2":{"show":false,"data":""}},"effect7":{"name":"Add Armor Type","data_type":{"show":true,"data":"Armor Types"},"value1":1,"value2":{"show":false,"data":""}},"effect8":{"name":"Element Attack","data_type":{"show":true,"data":"Elements"},"value1":1,"value2":{"show":false,"data":""}},"effect9":{"name":"Element Defense","data_type":{"show":true,"data":"Elements"},"value1":1,"value2":{"show":false,"data":""}},"effect10":{"name":"Add Skill Type","data_type":{"show":true,"data":"Skill Types"},"value1":1,"value2":{"show":false,"data":""}},"effect11":{"name":"Remove Skill Type","data_type":{"show":true,"data":"Skill Types"},"value1":1,"value2":{"show":false,"data":""}}}


--------------------------------------------------------------------------------
/databases/Enemy.json:
--------------------------------------------------------------------------------
1 | {"enemy0":{"name":"Slime","graphicImage":"","experience":6,"money":50,"stat_list":{"hp":"150","mp":"50","atk":"18","def":"16","int":"8","res":"4","spd":"12","luk":"10"},"drop_list":{"i0":80}}}
2 | 


--------------------------------------------------------------------------------
/databases/Item.json:
--------------------------------------------------------------------------------
1 | {"item0":{"name":"Potion","icon":"","description":"Heals 50HP to one ally","item_type":0,"price":50,"consumable":0,"target":7,"usable":0,"success":100,"hit_type":0,"damage_type":3,"element":0,"formula":"50"}}
2 | 


--------------------------------------------------------------------------------
/databases/Skill.json:
--------------------------------------------------------------------------------
1 | {"skill0":{"name":"Attack","icon":"","description":"Basic Attack Command","skill_type":0,"mp_cost":0,"tp_cost":0,"target":1,"usable":1,"success":95,"hit_type":1,"damage_type":1,"element":0,"formula":"a.atk * 4 - b.def * 2","effects":[]},"skill1":{"name":"Cleave","icon":"","description":"Light physical Attack to one enemy","skill_type":0,"mp_cost":3,"tp_cost":0,"target":1,"usable":1,"success":95,"hit_type":1,"damage_type":1,"element":0,"formula":"(a.atk * 4 - b.def * 2) * 1.08","effects":[]},"skill2":{"name":"Shout","icon":"","description":"Increases user's atk","skill_type":0,"mp_cost":2,"tp_cost":0,"target":11,"usable":1,"success":100,"hit_type":0,"damage_type":0,"element":0,"formula":"","effects":[{"name":"Increase Stat","data_id":"2","value1":"8","value2":""}]},"skill3":{"name":"Blazing Blade","icon":"","description":"Fire attack to all enemies","skill_type":0,"mp_cost":6,"tp_cost":0,"target":2,"usable":1,"success":90,"hit_type":1,"damage_type":1,"element":1,"formula":"(a.atk * 4 - b.def * 2) * 1.06","effects":[]},"skill4":{"name":"Fire","icon":"","description":"Fire attack to one enemy","skill_type":1,"mp_cost":3,"tp_cost":0,"target":1,"usable":1,"success":95,"hit_type":2,"damage_type":1,"element":1,"formula":"(a.int * 4 - a.res * 2) * 1.05","effects":[]},"skill5":{"name":"Ice","icon":"","description":"Ice attack to one enemy","skill_type":1,"mp_cost":3,"tp_cost":0,"target":1,"usable":1,"success":95,"hit_type":2,"damage_type":1,"element":2,"formula":"(a.int * 4 - a.res * 2) * 1.05","effects":[]},"skill6":{"name":"Wind","icon":"","description":"Wind attack to one enemy","skill_type":1,"mp_cost":3,"tp_cost":0,"target":1,"usable":1,"success":95,"hit_type":2,"damage_type":1,"element":3,"formula":"(a.int * 4 - a.res * 2) * 1.05","effects":[]},"skill7":{"name":"Cure","icon":"","description":"Heals one ally for 30% of their max HP","skill_type":1,"mp_cost":2,"tp_cost":0,"target":7,"usable":0,"success":100,"hit_type":0,"damage_type":3,"element":0,"formula":"b.mhp * 0.3","effects":[]},"skill8":{"name":"Revive","icon":"","description":"Revives an ally and heals them for 10% of their\nmax HP","skill_type":1,"mp_cost":15,"tp_cost":0,"target":9,"usable":0,"success":100,"hit_type":0,"damage_type":3,"element":0,"formula":"b.mhp * 0.1","effects":[{"name":"Remove State","data_id":"0","value1":"100","value2":"0"}]}}


--------------------------------------------------------------------------------
/databases/State.json:
--------------------------------------------------------------------------------
1 | {"state0":{"name":"Death","icon":"","restriction":4,"priority":100,"erase_conditions":{"turns_min":0,"turns_max":0,"erase_damage":0,"erase_setps":0},"messages":{"0":"Insert a custom formula for erase state"},"custom_erase_conditions":{"0":"Insert a custom formula for erase state"},"effects":[]},"state1":{"name":"Poison","icon":"","restriction":0,"priority":100,"erase_conditions":{"turns_min":2,"turns_max":6,"erase_damage":0,"erase_setps":0},"messages":{"0":"{character} is poisoned!"},"custom_erase_conditions":{"0":"Insert a custom condition"},"effects":[{"name":"Decrease Stat","data_id":"0","value1":"10","value2":"0"}]},"state2":{"name":"Sleep","icon":"","restriction":4,"priority":90,"erase_conditions":{"turns_min":3,"turns_max":6,"erase_damage":50,"erase_setps":0},"messages":{"0":"{character} is sleeping!"},"custom_erase_conditions":{"0":"Insert a custom condition"},"effects":[{"name":"Decrease Stat","data_id":"3","value1":"20","value2":"0"}]}}


--------------------------------------------------------------------------------
/databases/System.json:
--------------------------------------------------------------------------------
1 | {"stats":{"0":"hp","1":"mp","2":"atk","3":"def","4":"int","5":"res","6":"spd","7":"luk"},"weapons":{"0":"Sword","1":"Spear","2":"Axe","3":"Staff"},"armors":{"0":"Armor","1":"Robe","2":"Shield","3":"Hat","4":"Accessory","5":"Helmet"},"elements":{"0":"Physical","1":"Fire","2":"Ice","3":"Wind","4":"Light","5":"Dark"},"slots":{"w0":"Weapon","a1":"Head","a2":"Body","a3":"Accessory","a4":"Shield"},"skills":{"0":"Skills","1":"Magic"}}


--------------------------------------------------------------------------------
/databases/Weapon.json:
--------------------------------------------------------------------------------
1 | {"weapon0":{"name":"Broad Sword","icon":"","description":"A light and easy to use sword","weapon_type":0,"slot_type":0,"price":50,"element":0,"stat_list":{"hp":"0","mp":"0","atk":"10","def":"2","int":"2","res":"1","spd":"0","luk":"0"}},"weapon1":{"name":"Spear","icon":"","description":"New created weapon","weapon_type":1,"slot_type":0,"price":55,"element":0,"stat_list":{"hp":"0","mp":"0","atk":"15","def":"1","int":"0","res":"0","spd":"0","luk":"0"},"effects":[]},"weapon2":{"name":"Axe","icon":"","description":"New created weapon","weapon_type":2,"slot_type":0,"price":65,"element":0,"stat_list":{"hp":"0","mp":"0","atk":"18","def":"0","int":"0","res":"0","spd":"-4","luk":"0"},"effects":[]},"weapon3":{"name":"Staff","icon":"","description":"New created weapon","weapon_type":3,"slot_type":0,"price":50,"element":1,"stat_list":{"hp":"0","mp":"0","atk":"1","def":"0","int":"14","res":"0","spd":"0","luk":"0"},"effects":[]}}


--------------------------------------------------------------------------------
/default_env.tres:
--------------------------------------------------------------------------------
1 | [gd_resource type="Environment" load_steps=2 format=2]
2 | 
3 | [sub_resource type="ProceduralSky" id=1]
4 | 
5 | [resource]
6 | background_mode = 2
7 | background_sky = SubResource( 1 )
8 | 


--------------------------------------------------------------------------------
/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sdtv9507/RPG-Databases/8eda7b9312c69e5b220a612966edbba158ff5411/icon.png


--------------------------------------------------------------------------------
/icon.png.import:
--------------------------------------------------------------------------------
 1 | [remap]
 2 | 
 3 | importer="texture"
 4 | type="StreamTexture"
 5 | path="res://.import/icon.png-487276ed1e3a0c39cad0279d744ee560.stex"
 6 | metadata={
 7 | "vram_texture": false
 8 | }
 9 | 
10 | [deps]
11 | 
12 | source_file="res://icon.png"
13 | dest_files=[ "res://.import/icon.png-487276ed1e3a0c39cad0279d744ee560.stex" ]
14 | 
15 | [params]
16 | 
17 | compress/mode=0
18 | compress/lossy_quality=0.7
19 | compress/hdr_mode=0
20 | compress/bptc_ldr=0
21 | compress/normal_map=0
22 | flags/repeat=0
23 | flags/filter=true
24 | flags/mipmaps=false
25 | flags/anisotropic=false
26 | flags/srgb=2
27 | process/fix_alpha_border=true
28 | process/premult_alpha=false
29 | process/HDR_as_SRGB=false
30 | process/invert_color=false
31 | stream=false
32 | size_limit=0
33 | detect_3d=true
34 | svg/scale=1.0
35 | 


--------------------------------------------------------------------------------
/project.godot:
--------------------------------------------------------------------------------
 1 | ; Engine configuration file.
 2 | ; It's best edited using the editor UI and not directly,
 3 | ; since the parameters that go here are not all obvious.
 4 | ;
 5 | ; Format:
 6 | ;   [section] ; section goes between []
 7 | ;   param=value ; assign values to parameters
 8 | 
 9 | config_version=4
10 | 
11 | [application]
12 | 
13 | config/name="RPG Databases"
14 | config/icon="res://icon.png"
15 | 
16 | [display]
17 | 
18 | window/size/width=960
19 | window/size/height=540
20 | 
21 | [editor_plugins]
22 | 
23 | enabled=PoolStringArray( "res://addons/rpg_databases_gd/plugin.cfg" )
24 | 
25 | [locale]
26 | 
27 | locale_filter=[ 1, [  ] ]
28 | translations=PoolStringArray(  )
29 | translation_remaps={
30 | }
31 | 
32 | [rendering]
33 | 
34 | quality/driver/driver_name="GLES2"
35 | vram_compression/import_etc=true
36 | vram_compression/import_etc2=false
37 | environment/default_environment="res://default_env.tres"
38 | 


--------------------------------------------------------------------------------
/screenshots/armor.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sdtv9507/RPG-Databases/8eda7b9312c69e5b220a612966edbba158ff5411/screenshots/armor.png


--------------------------------------------------------------------------------
/screenshots/armor.png.import:
--------------------------------------------------------------------------------
 1 | [remap]
 2 | 
 3 | importer="texture"
 4 | type="StreamTexture"
 5 | path="res://.import/armor.png-81a8951b01a45c325c1c382b41e43890.stex"
 6 | metadata={
 7 | "vram_texture": false
 8 | }
 9 | 
10 | [deps]
11 | 
12 | source_file="res://screenshots/armor.png"
13 | dest_files=[ "res://.import/armor.png-81a8951b01a45c325c1c382b41e43890.stex" ]
14 | 
15 | [params]
16 | 
17 | compress/mode=0
18 | compress/lossy_quality=0.7
19 | compress/hdr_mode=0
20 | compress/bptc_ldr=0
21 | compress/normal_map=0
22 | flags/repeat=0
23 | flags/filter=true
24 | flags/mipmaps=false
25 | flags/anisotropic=false
26 | flags/srgb=2
27 | process/fix_alpha_border=true
28 | process/premult_alpha=false
29 | process/HDR_as_SRGB=false
30 | process/invert_color=false
31 | stream=false
32 | size_limit=0
33 | detect_3d=true
34 | svg/scale=1.0
35 | 


--------------------------------------------------------------------------------
/screenshots/character.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sdtv9507/RPG-Databases/8eda7b9312c69e5b220a612966edbba158ff5411/screenshots/character.png


--------------------------------------------------------------------------------
/screenshots/character.png.import:
--------------------------------------------------------------------------------
 1 | [remap]
 2 | 
 3 | importer="texture"
 4 | type="StreamTexture"
 5 | path="res://.import/character.png-b1a4785a4e741ebd52889798c355e362.stex"
 6 | metadata={
 7 | "vram_texture": false
 8 | }
 9 | 
10 | [deps]
11 | 
12 | source_file="res://screenshots/character.png"
13 | dest_files=[ "res://.import/character.png-b1a4785a4e741ebd52889798c355e362.stex" ]
14 | 
15 | [params]
16 | 
17 | compress/mode=0
18 | compress/lossy_quality=0.7
19 | compress/hdr_mode=0
20 | compress/bptc_ldr=0
21 | compress/normal_map=0
22 | flags/repeat=0
23 | flags/filter=true
24 | flags/mipmaps=false
25 | flags/anisotropic=false
26 | flags/srgb=2
27 | process/fix_alpha_border=true
28 | process/premult_alpha=false
29 | process/HDR_as_SRGB=false
30 | process/invert_color=false
31 | stream=false
32 | size_limit=0
33 | detect_3d=true
34 | svg/scale=1.0
35 | 


--------------------------------------------------------------------------------
/screenshots/class.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sdtv9507/RPG-Databases/8eda7b9312c69e5b220a612966edbba158ff5411/screenshots/class.png


--------------------------------------------------------------------------------
/screenshots/class.png.import:
--------------------------------------------------------------------------------
 1 | [remap]
 2 | 
 3 | importer="texture"
 4 | type="StreamTexture"
 5 | path="res://.import/class.png-1868f6e717325a5b9aa70c2a7afbb43a.stex"
 6 | metadata={
 7 | "vram_texture": false
 8 | }
 9 | 
10 | [deps]
11 | 
12 | source_file="res://screenshots/class.png"
13 | dest_files=[ "res://.import/class.png-1868f6e717325a5b9aa70c2a7afbb43a.stex" ]
14 | 
15 | [params]
16 | 
17 | compress/mode=0
18 | compress/lossy_quality=0.7
19 | compress/hdr_mode=0
20 | compress/bptc_ldr=0
21 | compress/normal_map=0
22 | flags/repeat=0
23 | flags/filter=true
24 | flags/mipmaps=false
25 | flags/anisotropic=false
26 | flags/srgb=2
27 | process/fix_alpha_border=true
28 | process/premult_alpha=false
29 | process/HDR_as_SRGB=false
30 | process/invert_color=false
31 | stream=false
32 | size_limit=0
33 | detect_3d=true
34 | svg/scale=1.0
35 | 


--------------------------------------------------------------------------------
/screenshots/item.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sdtv9507/RPG-Databases/8eda7b9312c69e5b220a612966edbba158ff5411/screenshots/item.png


--------------------------------------------------------------------------------
/screenshots/item.png.import:
--------------------------------------------------------------------------------
 1 | [remap]
 2 | 
 3 | importer="texture"
 4 | type="StreamTexture"
 5 | path="res://.import/item.png-7df056025fda0a1aeb7cc1c1010e52aa.stex"
 6 | metadata={
 7 | "vram_texture": false
 8 | }
 9 | 
10 | [deps]
11 | 
12 | source_file="res://screenshots/item.png"
13 | dest_files=[ "res://.import/item.png-7df056025fda0a1aeb7cc1c1010e52aa.stex" ]
14 | 
15 | [params]
16 | 
17 | compress/mode=0
18 | compress/lossy_quality=0.7
19 | compress/hdr_mode=0
20 | compress/bptc_ldr=0
21 | compress/normal_map=0
22 | flags/repeat=0
23 | flags/filter=true
24 | flags/mipmaps=false
25 | flags/anisotropic=false
26 | flags/srgb=2
27 | process/fix_alpha_border=true
28 | process/premult_alpha=false
29 | process/HDR_as_SRGB=false
30 | process/invert_color=false
31 | stream=false
32 | size_limit=0
33 | detect_3d=true
34 | svg/scale=1.0
35 | 


--------------------------------------------------------------------------------
/screenshots/skill.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sdtv9507/RPG-Databases/8eda7b9312c69e5b220a612966edbba158ff5411/screenshots/skill.png


--------------------------------------------------------------------------------
/screenshots/skill.png.import:
--------------------------------------------------------------------------------
 1 | [remap]
 2 | 
 3 | importer="texture"
 4 | type="StreamTexture"
 5 | path="res://.import/skill.png-5f2b64435094cb62eb54c2197652515c.stex"
 6 | metadata={
 7 | "vram_texture": false
 8 | }
 9 | 
10 | [deps]
11 | 
12 | source_file="res://screenshots/skill.png"
13 | dest_files=[ "res://.import/skill.png-5f2b64435094cb62eb54c2197652515c.stex" ]
14 | 
15 | [params]
16 | 
17 | compress/mode=0
18 | compress/lossy_quality=0.7
19 | compress/hdr_mode=0
20 | compress/bptc_ldr=0
21 | compress/normal_map=0
22 | flags/repeat=0
23 | flags/filter=true
24 | flags/mipmaps=false
25 | flags/anisotropic=false
26 | flags/srgb=2
27 | process/fix_alpha_border=true
28 | process/premult_alpha=false
29 | process/HDR_as_SRGB=false
30 | process/invert_color=false
31 | stream=false
32 | size_limit=0
33 | detect_3d=true
34 | svg/scale=1.0
35 | 


--------------------------------------------------------------------------------
/screenshots/weapon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sdtv9507/RPG-Databases/8eda7b9312c69e5b220a612966edbba158ff5411/screenshots/weapon.png


--------------------------------------------------------------------------------
/screenshots/weapon.png.import:
--------------------------------------------------------------------------------
 1 | [remap]
 2 | 
 3 | importer="texture"
 4 | type="StreamTexture"
 5 | path="res://.import/weapon.png-1fd18b58d09befbe29a47f0b8aec3cd5.stex"
 6 | metadata={
 7 | "vram_texture": false
 8 | }
 9 | 
10 | [deps]
11 | 
12 | source_file="res://screenshots/weapon.png"
13 | dest_files=[ "res://.import/weapon.png-1fd18b58d09befbe29a47f0b8aec3cd5.stex" ]
14 | 
15 | [params]
16 | 
17 | compress/mode=0
18 | compress/lossy_quality=0.7
19 | compress/hdr_mode=0
20 | compress/bptc_ldr=0
21 | compress/normal_map=0
22 | flags/repeat=0
23 | flags/filter=true
24 | flags/mipmaps=false
25 | flags/anisotropic=false
26 | flags/srgb=2
27 | process/fix_alpha_border=true
28 | process/premult_alpha=false
29 | process/HDR_as_SRGB=false
30 | process/invert_color=false
31 | stream=false
32 | size_limit=0
33 | detect_3d=true
34 | svg/scale=1.0
35 | 


--------------------------------------------------------------------------------