├── .editorconfig
├── .gitattributes
├── .gitignore
├── DotnetQuestSystemAddon.csproj
├── DotnetQuestSystemAddon.sln
├── LICENSE
├── README.md
├── addons
    └── dotnetquestsystem
    │   ├── MainPage.cs
    │   ├── MainPage.tscn
    │   ├── Plugin.cs
    │   ├── RewardOption.cs
    │   ├── api
    │       ├── Quest.cs
    │       ├── QuestController.cs
    │       ├── QuestDatabase.cs
    │       ├── QuestManager.cs
    │       ├── QuestStatus.cs
    │       ├── QuestSystemAPI.csproj
    │       ├── Reward
    │       │   ├── ExperienceReward.cs
    │       │   ├── IReward.cs
    │       │   └── ItemReward.cs
    │       └── Save
    │       │   ├── ISaveSystemStrategy.cs
    │       │   ├── QuestDatabaseSave.cs
    │       │   └── QuestLocalSave.cs
    │   ├── assets
    │       ├── dotnetquestsystem_node.svg
    │       └── godot_asset_icon.png
    │   └── plugin.cfg
├── docs
    ├── api
    │   ├── quest.md
    │   ├── quest_controller.md
    │   ├── quest_database.md
    │   ├── quest_manager.md
    │   ├── quest_status.md
    │   ├── reward.md
    │   └── save_system.md
    ├── contributing.md
    └── getting_started.md
├── project.godot
└── test
    └── QuestSystemAPITest
        ├── QuestControllerTest.cs
        ├── QuestControllerTest.cs.uid
        ├── QuestDatabaseTest.cs
        ├── QuestDatabaseTest.cs.uid
        ├── QuestManagerTest.cs
        ├── QuestManagerTest.cs.uid
        ├── QuestSystemAPITest.csproj
        ├── QuestTest.cs
        └── QuestTest.cs.uid


/.editorconfig:
--------------------------------------------------------------------------------
1 | root = true
2 | 
3 | [*]
4 | charset = utf-8
5 | 


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
1 | # Normalize EOL for all files that Git considers text files.
2 | * text=auto eol=lf
3 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Godot 4+ specific ignores
 2 | .godot/
 3 | /android/
 4 | .import/
 5 | .mono/
 6 | 
 7 | # Ignore standard build folders created during project compilation
 8 | bin/
 9 | obj/
10 | Debug/
11 | Release/
12 | 
13 | # Ignore Visual Studio Code settings and configurations
14 | .vscode/
15 | 
16 | # Ignore temporary files that may be created during development
17 | tmp/
18 | *.tmp
19 | *.temp


--------------------------------------------------------------------------------
/DotnetQuestSystemAddon.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Godot.NET.Sdk/4.4.1">
 2 |   <PropertyGroup>
 3 |     <TargetFramework>net9.0</TargetFramework>
 4 |     <EnableDynamicLoading>true</EnableDynamicLoading>
 5 |     <Nullable>enable</Nullable>
 6 |   </PropertyGroup>
 7 | 
 8 |   <!-- Ignore the test source files -->
 9 |   <PropertyGroup>
10 |     <DefaultItemExcludes>
11 |       $(DefaultItemExcludes);test\**\*
12 |     </DefaultItemExcludes>
13 |   </PropertyGroup>
14 | </Project>


--------------------------------------------------------------------------------
/DotnetQuestSystemAddon.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio Version 17
 4 | VisualStudioVersion = 17.13.35913.81 d17.13
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DotnetQuestSystemAddon", "DotnetQuestSystemAddon.csproj", "{37491199-0456-4B57-9CD5-DE2BBC4CAD5C}"
 7 | EndProject
 8 | Global
 9 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | 		Debug|Any CPU = Debug|Any CPU
11 | 		ExportDebug|Any CPU = ExportDebug|Any CPU
12 | 		ExportRelease|Any CPU = ExportRelease|Any CPU
13 | 	EndGlobalSection
14 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
15 | 		{37491199-0456-4B57-9CD5-DE2BBC4CAD5C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
16 | 		{37491199-0456-4B57-9CD5-DE2BBC4CAD5C}.Debug|Any CPU.Build.0 = Debug|Any CPU
17 | 		{37491199-0456-4B57-9CD5-DE2BBC4CAD5C}.ExportDebug|Any CPU.ActiveCfg = ExportDebug|Any CPU
18 | 		{37491199-0456-4B57-9CD5-DE2BBC4CAD5C}.ExportDebug|Any CPU.Build.0 = ExportDebug|Any CPU
19 | 		{37491199-0456-4B57-9CD5-DE2BBC4CAD5C}.ExportRelease|Any CPU.ActiveCfg = ExportRelease|Any CPU
20 | 		{37491199-0456-4B57-9CD5-DE2BBC4CAD5C}.ExportRelease|Any CPU.Build.0 = ExportRelease|Any CPU
21 | 	EndGlobalSection
22 | 	GlobalSection(SolutionProperties) = preSolution
23 | 		HideSolutionNode = FALSE
24 | 	EndGlobalSection
25 | 	GlobalSection(ExtensibilityGlobals) = postSolution
26 | 		SolutionGuid = {8D3A86B4-78EB-495D-A152-9246578A1F87}
27 | 	EndGlobalSection
28 | EndGlobal
29 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2025 TRUINGLol
 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 | <h1  align="center">DOTNET QUEST SYSTEM</h1>
 2 | 
 3 | [![GodotEngine](https://img.shields.io/badge/-Godot%204-250a78?style=flat&logo=godotengine&logoColor=white&labelColor=250a78)](https://godotengine.org/)
 4 | [![Awesome](https://awesome.re/badge.svg)](https://github.com/godotengine/awesome-godot)
 5 | ![Version](https://img.shields.io/badge/version-1.1.0-brightgreen.svg)
 6 | 
 7 | # Simple quest system for Godot
 8 | DotnetQuestSystem - is a simple and powerful [Godot](https://godotengine.org/) add-on that greatly speeds up the process of creating a quest system. Its clean API, written in C#, allows you to quickly integrate quest mechanics into your games.
 9 | 
10 | ## Features
11 | 
12 | * 🌈 Easy to use API
13 | * 🧩 Support for custom quests
14 | * 📋 Tested API with [Xunit](https://xunit.net/)
15 | * 📚  Detailed documentation to help you get started quickly.
16 | * 🔍  C# Based API
17 | 
18 | ## Installing
19 | 
20 | 1. Download a copy of the `addons` folder
21 | 2. Copy the `addons` folder from the downloaded file to your project directory
22 | 3. Activate the addon in the editor `Project -> Project Settings -> Plugins`
23 | 
24 | ## Documentation
25 | 
26 | More detailed API documentation can be found in the `docs` folder.
27 | 
28 | ## Support and Contributions
29 | 
30 | If you think you have found a bug or have a feature request, create new issue. Try to be as detailed as possible in your issue reports.
31 | 
32 | If you are interested in contributing fixes or features, please read [contributors](docs/contributing.md) guide first.
33 | 


--------------------------------------------------------------------------------
/addons/dotnetquestsystem/MainPage.cs:
--------------------------------------------------------------------------------
  1 | using Godot;
  2 | using System;
  3 | using dotnetquestsystem;
  4 | using System.Collections.Generic;
  5 | using System.Linq;
  6 | 
  7 | [Tool]
  8 | public partial class MainPage : Control
  9 | {
 10 | 	[Export]
 11 | 	private NodePath QuestListPath = null!;
 12 | 
 13 | 	[Export]
 14 | 	private NodePath PanelViewPath = null!;
 15 | 
 16 | 	[Export]
 17 | 	private NodePath NamePath = null!;
 18 | 
 19 | 	[Export]
 20 | 	private NodePath DescriptionPath = null!;
 21 | 
 22 | 	[Export]
 23 | 	private NodePath ObjectivePath = null!;
 24 | 
 25 | 	[Export]
 26 | 	private NodePath RewardPath = null!;
 27 | 
 28 | 	[Export]
 29 | 	private NodePath DeleteQuestPath = null!;
 30 | 
 31 | 	[Export]
 32 | 	private NodePath FileDialogPath = null!;
 33 | 
 34 | 	private ItemList _questList = null!;
 35 | 	private Panel _panelView = null!;
 36 | 	private LineEdit _nameQuest = null!;
 37 | 	private TextEdit _descriptionQuest = null!;
 38 | 	private TextEdit _objectiveQuest = null!;
 39 | 	private RewardOption _reward = null!;
 40 | 	private Button _deleteQuest = null!;
 41 | 	private FileDialog _fileDialog = null!;
 42 | 
 43 | 	private string? _saveQuestsPath = null;
 44 | 	private Quest _currentQuest = null!;
 45 | 	private ConfigFile configFile = new ConfigFile();
 46 | 
 47 | 	public override void _Ready()
 48 | 	{
 49 | 		InitFields();
 50 | 		
 51 | 		// We do it once plugin activate
 52 | 		try
 53 | 		{
 54 | 			if(_saveQuestsPath != null){
 55 | 				QuestManager.instance.questDatabase.LoadQuests(_saveQuestsPath);
 56 | 			}
 57 | 			else{
 58 | 				QuestManager.instance.questDatabase.LoadQuests();
 59 | 			}
 60 | 		}
 61 | 		catch (System.IO.FileNotFoundException)
 62 | 		{  
 63 | 			GD.Print("Quests json file not found");
 64 | 		}
 65 | 
 66 | 		foreach (var quest in QuestManager.instance.questDatabase.Quests)
 67 | 		{
 68 | 			_questList.AddItem(quest.Name);
 69 | 		}
 70 | 	}
 71 | 
 72 | 	public void OnCreateNewQuestButtonPressed(){
 73 | 		Quest newQuest = QuestManager.instance.questController
 74 | 			.CreateQuest("New Quest", "New Description", "New Objective");
 75 | 
 76 | 		int indexNewQuest = _questList.AddItem(newQuest.Name);
 77 | 
 78 | 		// Since Select() does not trigger the item selection signal we emmit it directly
 79 | 		_questList.Select(indexNewQuest);
 80 | 		OnQuestItemSelect(indexNewQuest);
 81 | 	}
 82 | 
 83 | 	public void OnQuestItemSelect(int index){
 84 | 		if(index < 0 || index >= QuestManager.instance.questDatabase.Quests.Count){
 85 | 			GD.PushError("Quest index out of bounds, objects on scene created manually?");
 86 | 			return;
 87 | 		}
 88 | 
 89 | 		_deleteQuest.Visible = true;
 90 | 		
 91 | 		_currentQuest = QuestManager.instance.questDatabase.Quests[index];
 92 | 
 93 | 		_nameQuest.Text = _currentQuest.Name;
 94 | 		_descriptionQuest.Text = _currentQuest.Description;
 95 | 		_objectiveQuest.Text = _currentQuest.Objective;
 96 | 		if(_currentQuest.Reward != null){
 97 | 			SelectRewardByText(_currentQuest.Reward.GetType().Name.ToString()!.ToLower().Replace("reward", ""));
 98 | 			SetRewardParamsValue(_currentQuest);
 99 | 			_reward.attributeContainer.Visible = true;
100 | 		}
101 | 		else{
102 | 			_reward.optionRewards.Select(-1);
103 | 			_reward.attributeContainer.Visible = false;
104 | 		}
105 | 
106 | 		_panelView.Visible = true;
107 | 	}
108 | 
109 | 	public void OnSaveQuestButtonPressed(){
110 | 		if(_currentQuest == null){
111 | 			GD.PushError("Selected quest is null");
112 | 			return;
113 | 		}
114 | 
115 | 		string newName = _nameQuest.Text.Trim();
116 | 		if(string.IsNullOrEmpty(newName)){
117 | 			GD.PushWarning("Quest name cannot be empty");
118 | 			return;
119 | 		}
120 | 
121 | 		Quest? existsngQuest = QuestManager.instance.questDatabase.Quests.Find((q)=>q.Name == newName && q != _currentQuest);
122 | 		if(existsngQuest != null){
123 | 			GD.PushWarning("A quest with this name already exists");
124 | 			return;
125 | 		}
126 | 
127 | 		int selectedRewardId = _reward.optionRewards.Selected;
128 | 		IReward? newReward = null;
129 | 
130 | 		QuestManager.instance.questController.DeleteQuest(_currentQuest);
131 | 
132 | 		if(selectedRewardId>=0){
133 | 			object[]? rewardParams = GetRewardParamsValue();
134 | 
135 | 			newReward = Activator.CreateInstance(_reward.RewardableClass[selectedRewardId], rewardParams) as IReward;
136 | 		}
137 | 
138 | 		if(newReward != null){
139 | 			_currentQuest = QuestManager.instance.questController.CreateQuest(
140 | 				name: newName,
141 | 				description: _descriptionQuest.Text,
142 | 				objective: _objectiveQuest.Text,
143 | 				reward: newReward
144 | 			);
145 | 		}
146 | 		else{
147 | 			_currentQuest = QuestManager.instance.questController.CreateQuest(
148 | 				name: newName,
149 | 				description: _descriptionQuest.Text,
150 | 				objective: _objectiveQuest.Text
151 | 			);
152 | 		}
153 | 		
154 | 		int selectedIndex = -1;
155 | 		int[] selectedItems = _questList.GetSelectedItems();
156 | 
157 | 		if(selectedItems.Length > 0){
158 | 			selectedIndex = selectedItems[0];
159 | 		}
160 | 		if(selectedIndex >= 0){
161 | 			_questList.SetItemText(selectedIndex, newName);
162 | 		}
163 | 		
164 | 		GD.Print("Quest saved!");
165 | 	}
166 | 
167 | 	public void OnDeleteQuestButtonPressed(){
168 | 		int[] selectedItems = _questList.GetSelectedItems();
169 | 		int selectedIndex = -1;
170 | 
171 | 		if(selectedItems.Length > 0){
172 | 			selectedIndex = selectedItems[0];
173 | 		}
174 | 		if(selectedIndex >= 0){
175 | 			_questList.RemoveItem(selectedIndex);
176 | 		}
177 | 
178 | 		QuestManager.instance.questController.DeleteQuest(_currentQuest);
179 | 
180 | 		_deleteQuest.Visible = false;
181 | 		_panelView.Visible = false;
182 | 
183 | 		GD.Print("Quest delete!");
184 | 	}
185 | 
186 | 	public void OnSelectQuestPathButtonPressed(){
187 | 		_fileDialog.Visible = true;
188 | 	}
189 | 
190 | 	public void OnQuestPathSelect(){
191 | 		_fileDialog.Visible = false;
192 | 		_saveQuestsPath = _fileDialog.CurrentPath + "Quests.json";
193 | 		GD.Print("Save quest path change to: "+ _saveQuestsPath);
194 | 	}
195 | 
196 | 	private void SelectRewardByText(string text){
197 | 		int itemCount = _reward.optionRewards.ItemCount;
198 | 
199 | 		for (int i = 0; i < itemCount; i++){
200 | 			if(_reward.optionRewards.GetItemText(i) == text){
201 | 				_reward.optionRewards.Select(i);
202 | 
203 | 				// Select() method did not emmit OnSelect signal
204 | 				_reward.OnRewardTypeSelect(i);
205 | 				return;
206 | 			}
207 | 		}
208 | 
209 | 	}
210 | 
211 | 	private object[]? GetRewardParamsValue(){
212 | 		List<object> paramsValue = new List<object>();
213 | 		var allChild = _reward.attributeContainer.GetChildren();
214 | 
215 | 		foreach (var child in allChild){
216 | 			if(child is Label label){
217 | 				int index = allChild.IndexOf(label) + 1;
218 | 
219 | 				if(index < allChild.Count && allChild[index] is Control inputField){
220 | 
221 | 					if(inputField is SpinBox spinBox){
222 | 						if(spinBox.MinValue >= int.MinValue && spinBox.MaxValue <= int.MaxValue){
223 | 							paramsValue.Add((int)spinBox.Value);
224 | 						}
225 | 						else{
226 | 							paramsValue.Add((float)spinBox.Value);
227 | 						}
228 | 					}
229 | 					else if(inputField is LineEdit lineEdit){
230 | 						paramsValue.Add(lineEdit.Text);
231 | 					}
232 | 
233 | 				} 
234 | 			}
235 | 		}
236 | 
237 | 		return paramsValue.Count > 0 ? paramsValue.ToArray() : null;
238 | 	}
239 | 
240 | 	private void SetRewardParamsValue(Quest questWithReward){
241 | 		if(questWithReward.Reward is null) return;
242 | 
243 | 		var allChild = _reward.attributeContainer.GetChildren();
244 | 		var rewardProperties = questWithReward.Reward.GetType().GetProperties();
245 | 
246 | 		int valueIndex = 0;
247 | 
248 | 		foreach (var child in allChild){
249 | 			if(child is Label label){
250 | 				int index = allChild.IndexOf(label)+1;
251 | 
252 | 				if(index < allChild.Count && allChild[index] is Control inputField){
253 | 					if(valueIndex >= rewardProperties.Count()){
254 | 						GD.PushWarning("Reward count is out of bounds");
255 | 					}
256 | 
257 | 					if(inputField is SpinBox spinBox){
258 | 						if (rewardProperties[valueIndex].GetValue(questWithReward.Reward) is int intValue &&
259 | 						 spinBox.MinValue >= int.MinValue && spinBox.MaxValue <= int.MaxValue){
260 | 							spinBox.Value = intValue;
261 | 						}
262 | 						else if (rewardProperties[valueIndex].GetValue(questWithReward.Reward) is float floatValue){
263 | 							spinBox.Value = floatValue;
264 | 						}
265 | 					}
266 | 					else if (inputField is LineEdit lineEdit){
267 | 						if (rewardProperties[valueIndex].GetValue(questWithReward.Reward) is string stringValue){
268 | 							lineEdit.Text = stringValue;
269 | 						}
270 | 			   		}
271 | 
272 | 					valueIndex++;
273 | 
274 | 				}
275 | 			}
276 | 		}
277 | 	}
278 | 
279 | 	private void InitFields(){
280 | 		var err = configFile.Load("res://quest.cfg");
281 | 		if(err == Error.Ok){
282 | 			_saveQuestsPath = (string?)configFile.GetValue("settings","save_quest_path");
283 | 		}
284 | 
285 | 		_questList = GetNode<ItemList>(QuestListPath);
286 | 		_panelView = GetNode<Panel>(PanelViewPath);
287 | 		_descriptionQuest = GetNode<TextEdit>(DescriptionPath);
288 | 		_nameQuest = GetNode<LineEdit>(NamePath);
289 | 		_objectiveQuest = GetNode<TextEdit>(ObjectivePath);
290 | 		_reward = GetNode<RewardOption>(RewardPath);
291 | 		_deleteQuest = GetNode<Button>(DeleteQuestPath);
292 | 		_fileDialog = GetNode<FileDialog>(FileDialogPath);
293 | 	}
294 | 
295 | 	protected override void Dispose(bool disposing)
296 | 	{
297 | 		if(disposing){
298 | 			QuestListPath.Dispose();
299 | 			PanelViewPath.Dispose();
300 | 			RewardPath.Dispose();
301 | 			NamePath.Dispose();
302 | 			DescriptionPath.Dispose();
303 | 			ObjectivePath.Dispose();
304 | 			DeleteQuestPath.Dispose();
305 | 			FileDialogPath.Dispose();
306 | 		}
307 | 	}
308 | 
309 | 	public override void _ExitTree()
310 | 	{
311 | 		if(_saveQuestsPath != null){
312 | 			QuestManager.instance.questDatabase.SaveQuests(_saveQuestsPath);
313 | 			configFile.SetValue("settings","save_quest_path", _saveQuestsPath);
314 | 			configFile.Save("res://quest.cfg");
315 | 		}
316 | 		else{
317 | 			// Use defualt value
318 | 			QuestManager.instance.questDatabase.SaveQuests();
319 | 		}
320 | 	}
321 | }
322 | 


--------------------------------------------------------------------------------
/addons/dotnetquestsystem/MainPage.tscn:
--------------------------------------------------------------------------------
  1 | [gd_scene load_steps=3 format=3 uid="uid://ghs7qtultde6"]
  2 | 
  3 | [ext_resource type="Script" uid="uid://m8efb203ij2s" path="res://addons/dotnetquestsystem/RewardOption.cs" id="1_pi4nx"]
  4 | [ext_resource type="Script" uid="uid://ludjahesqwf8" path="res://addons/dotnetquestsystem/MainPage.cs" id="1_pwxvg"]
  5 | 
  6 | [node name="MainPage" type="Control"]
  7 | layout_mode = 3
  8 | anchors_preset = 15
  9 | anchor_right = 1.0
 10 | anchor_bottom = 1.0
 11 | grow_horizontal = 2
 12 | grow_vertical = 2
 13 | size_flags_horizontal = 3
 14 | size_flags_vertical = 3
 15 | script = ExtResource("1_pwxvg")
 16 | QuestListPath = NodePath("HBoxContainer/QuestList/ItemList")
 17 | PanelViewPath = NodePath("HBoxContainer/QuestProperties/View")
 18 | NamePath = NodePath("HBoxContainer/QuestProperties/View/VBoxContainer/Name/LineEdit")
 19 | DescriptionPath = NodePath("HBoxContainer/QuestProperties/View/VBoxContainer/Description/TextEdit")
 20 | ObjectivePath = NodePath("HBoxContainer/QuestProperties/View/VBoxContainer/Objective/TextEdit")
 21 | RewardPath = NodePath("HBoxContainer/QuestProperties/View/VBoxContainer/Reward/OptionButton")
 22 | DeleteQuestPath = NodePath("HBoxContainer/QuestList/HBoxContainer/Delete quest")
 23 | FileDialogPath = NodePath("HBoxContainer/QuestList/ItemList/HBoxContainer/FileDialog")
 24 | 
 25 | [node name="HBoxContainer" type="HBoxContainer" parent="."]
 26 | layout_mode = 1
 27 | anchors_preset = 15
 28 | anchor_right = 1.0
 29 | anchor_bottom = 1.0
 30 | grow_horizontal = 2
 31 | grow_vertical = 2
 32 | 
 33 | [node name="QuestList" type="VBoxContainer" parent="HBoxContainer"]
 34 | layout_mode = 2
 35 | size_flags_horizontal = 3
 36 | 
 37 | [node name="HBoxContainer2" type="HBoxContainer" parent="HBoxContainer/QuestList"]
 38 | layout_mode = 2
 39 | theme_override_constants/separation = 20
 40 | 
 41 | [node name="Label" type="Label" parent="HBoxContainer/QuestList/HBoxContainer2"]
 42 | layout_mode = 2
 43 | size_flags_horizontal = 3
 44 | text = "Quests"
 45 | horizontal_alignment = 1
 46 | 
 47 | [node name="ItemList" type="ItemList" parent="HBoxContainer/QuestList"]
 48 | layout_mode = 2
 49 | size_flags_vertical = 3
 50 | allow_reselect = true
 51 | same_column_width = true
 52 | 
 53 | [node name="HBoxContainer" type="HBoxContainer" parent="HBoxContainer/QuestList/ItemList"]
 54 | custom_minimum_size = Vector2(0, 25)
 55 | layout_mode = 1
 56 | anchors_preset = 12
 57 | anchor_top = 1.0
 58 | anchor_right = 1.0
 59 | anchor_bottom = 1.0
 60 | grow_horizontal = 2
 61 | grow_vertical = 0
 62 | 
 63 | [node name="Button" type="Button" parent="HBoxContainer/QuestList/ItemList/HBoxContainer"]
 64 | layout_mode = 2
 65 | size_flags_horizontal = 3
 66 | text = "Select save quest path"
 67 | 
 68 | [node name="FileDialog" type="FileDialog" parent="HBoxContainer/QuestList/ItemList/HBoxContainer"]
 69 | title = "Open a Directory"
 70 | ok_button_text = "Select Current Folder"
 71 | file_mode = 2
 72 | access = 2
 73 | 
 74 | [node name="HBoxContainer" type="HBoxContainer" parent="HBoxContainer/QuestList"]
 75 | layout_mode = 2
 76 | 
 77 | [node name="New quest" type="Button" parent="HBoxContainer/QuestList/HBoxContainer"]
 78 | layout_mode = 2
 79 | size_flags_horizontal = 3
 80 | text = "Add new quest"
 81 | 
 82 | [node name="Delete quest" type="Button" parent="HBoxContainer/QuestList/HBoxContainer"]
 83 | visible = false
 84 | layout_mode = 2
 85 | size_flags_horizontal = 3
 86 | text = "Delete quest"
 87 | 
 88 | [node name="QuestProperties" type="VBoxContainer" parent="HBoxContainer"]
 89 | layout_mode = 2
 90 | size_flags_horizontal = 3
 91 | size_flags_stretch_ratio = 2.0
 92 | 
 93 | [node name="View" type="Panel" parent="HBoxContainer/QuestProperties"]
 94 | visible = false
 95 | layout_mode = 2
 96 | size_flags_horizontal = 3
 97 | size_flags_vertical = 3
 98 | 
 99 | [node name="VBoxContainer" type="VBoxContainer" parent="HBoxContainer/QuestProperties/View"]
100 | layout_mode = 1
101 | anchors_preset = 15
102 | anchor_right = 1.0
103 | anchor_bottom = 1.0
104 | grow_horizontal = 2
105 | grow_vertical = 2
106 | theme_override_constants/separation = 20
107 | 
108 | [node name="Name" type="HBoxContainer" parent="HBoxContainer/QuestProperties/View/VBoxContainer"]
109 | layout_mode = 2
110 | 
111 | [node name="QuestName" type="Label" parent="HBoxContainer/QuestProperties/View/VBoxContainer/Name"]
112 | layout_mode = 2
113 | text = "Quest name"
114 | 
115 | [node name="LineEdit" type="LineEdit" parent="HBoxContainer/QuestProperties/View/VBoxContainer/Name"]
116 | layout_mode = 2
117 | size_flags_horizontal = 3
118 | 
119 | [node name="Description" type="HBoxContainer" parent="HBoxContainer/QuestProperties/View/VBoxContainer"]
120 | layout_mode = 2
121 | 
122 | [node name="QuestDescription" type="Label" parent="HBoxContainer/QuestProperties/View/VBoxContainer/Description"]
123 | layout_mode = 2
124 | size_flags_vertical = 1
125 | text = "Quest description"
126 | 
127 | [node name="TextEdit" type="TextEdit" parent="HBoxContainer/QuestProperties/View/VBoxContainer/Description"]
128 | custom_minimum_size = Vector2(0, 150)
129 | layout_mode = 2
130 | size_flags_horizontal = 3
131 | wrap_mode = 1
132 | 
133 | [node name="Objective" type="HBoxContainer" parent="HBoxContainer/QuestProperties/View/VBoxContainer"]
134 | layout_mode = 2
135 | 
136 | [node name="Label" type="Label" parent="HBoxContainer/QuestProperties/View/VBoxContainer/Objective"]
137 | layout_mode = 2
138 | size_flags_vertical = 1
139 | text = "Objective"
140 | 
141 | [node name="TextEdit" type="TextEdit" parent="HBoxContainer/QuestProperties/View/VBoxContainer/Objective"]
142 | custom_minimum_size = Vector2(0, 100)
143 | layout_mode = 2
144 | size_flags_horizontal = 3
145 | wrap_mode = 1
146 | 
147 | [node name="Reward" type="HBoxContainer" parent="HBoxContainer/QuestProperties/View/VBoxContainer"]
148 | layout_mode = 2
149 | 
150 | [node name="Label" type="Label" parent="HBoxContainer/QuestProperties/View/VBoxContainer/Reward"]
151 | layout_mode = 2
152 | text = "Reward"
153 | 
154 | [node name="OptionButton" type="OptionButton" parent="HBoxContainer/QuestProperties/View/VBoxContainer/Reward"]
155 | layout_mode = 2
156 | size_flags_horizontal = 3
157 | allow_reselect = true
158 | script = ExtResource("1_pi4nx")
159 | ButtonPath = NodePath(".")
160 | AttributeContainerPath = NodePath("../../RewardAttribute")
161 | 
162 | [node name="RewardAttribute" type="HBoxContainer" parent="HBoxContainer/QuestProperties/View/VBoxContainer"]
163 | visible = false
164 | layout_mode = 2
165 | 
166 | [node name="Label" type="Label" parent="HBoxContainer/QuestProperties/View/VBoxContainer/RewardAttribute"]
167 | layout_mode = 2
168 | size_flags_vertical = 1
169 | text = "Attribute"
170 | 
171 | [node name="Constructor" type="HBoxContainer" parent="HBoxContainer/QuestProperties/View/VBoxContainer/RewardAttribute"]
172 | layout_mode = 2
173 | size_flags_horizontal = 3
174 | 
175 | [node name="SaveQuest" type="Button" parent="HBoxContainer/QuestProperties/View/VBoxContainer"]
176 | layout_mode = 2
177 | size_flags_vertical = 10
178 | text = "Save Quest"
179 | 
180 | [connection signal="item_selected" from="HBoxContainer/QuestList/ItemList" to="." method="OnQuestItemSelect"]
181 | [connection signal="pressed" from="HBoxContainer/QuestList/ItemList/HBoxContainer/Button" to="." method="OnSelectQuestPathButtonPressed"]
182 | [connection signal="confirmed" from="HBoxContainer/QuestList/ItemList/HBoxContainer/FileDialog" to="." method="OnQuestPathSelect"]
183 | [connection signal="pressed" from="HBoxContainer/QuestList/HBoxContainer/New quest" to="." method="OnCreateNewQuestButtonPressed"]
184 | [connection signal="pressed" from="HBoxContainer/QuestList/HBoxContainer/Delete quest" to="." method="OnDeleteQuestButtonPressed"]
185 | [connection signal="item_selected" from="HBoxContainer/QuestProperties/View/VBoxContainer/Reward/OptionButton" to="HBoxContainer/QuestProperties/View/VBoxContainer/Reward/OptionButton" method="OnRewardTypeSelect"]
186 | [connection signal="pressed" from="HBoxContainer/QuestProperties/View/VBoxContainer/SaveQuest" to="." method="OnSaveQuestButtonPressed"]
187 | 


--------------------------------------------------------------------------------
/addons/dotnetquestsystem/Plugin.cs:
--------------------------------------------------------------------------------
 1 | #if TOOLS
 2 | using Godot;
 3 | using System;
 4 | 
 5 | [Tool]
 6 | public partial class Plugin : EditorPlugin
 7 | {
 8 | 	private Control _mainSceneInstance = null!;
 9 | 	private PackedScene _mainScenePKJ = ResourceLoader.Load<PackedScene>("res://addons/dotnetquestsystem/MainPage.tscn");
10 | 	public override void _EnterTree()
11 | 	{
12 | 		_mainSceneInstance = (Control)_mainScenePKJ.Instantiate();
13 | 		EditorInterface.Singleton.GetEditorMainScreen().AddChild(_mainSceneInstance);
14 | 		_MakeVisible(false);
15 | 	}
16 | 
17 | 	public override void _ExitTree()
18 | 	{
19 | 		if(_mainSceneInstance != null){
20 | 			_mainSceneInstance.QueueFree();
21 | 		}
22 | 	}
23 | 
24 | 	public override bool _HasMainScreen()
25 | 	{
26 | 		return true;
27 | 	}
28 | 
29 | 	public override string _GetPluginName()
30 | 	{
31 | 		return "Quest System";
32 | 	}
33 | 
34 | 	public override void _MakeVisible(bool visible)
35 | 	{
36 | 		if(_mainSceneInstance != null){
37 | 			_mainSceneInstance.Visible = visible;
38 | 		}
39 | 	}
40 | 
41 | 	public override Texture2D _GetPluginIcon()
42 | 	{
43 | 		return (Texture2D)ResourceLoader.Load("res://addons/dotnetquestsystem/assets/dotnetquestsystem_node.svg");
44 | 	}
45 | }
46 | #endif
47 | 


--------------------------------------------------------------------------------
/addons/dotnetquestsystem/RewardOption.cs:
--------------------------------------------------------------------------------
 1 | using Godot;
 2 | using System;
 3 | using System.Linq;
 4 | using System.Reflection;
 5 | using dotnetquestsystem;
 6 | 
 7 | [Tool]
 8 | public partial class RewardOption : OptionButton
 9 | {
10 | 	[Export]
11 | 	public NodePath ButtonPath = null!;
12 | 
13 | 	[Export]
14 | 	public NodePath AttributeContainerPath = null!;
15 | 
16 | 	public Type[] RewardableClass {get;set;} = null!;
17 | 
18 | 	public OptionButton optionRewards = null!;
19 | 	public HBoxContainer attributeContainer = null!;
20 | 
21 | 	public override void _Ready()
22 | 	{
23 | 		optionRewards = GetNode<OptionButton>(ButtonPath);
24 | 		attributeContainer = GetNode<HBoxContainer>(AttributeContainerPath);
25 | 
26 | 		RewardableClass = Assembly.GetExecutingAssembly().GetTypes()
27 | 		.Where((t)=>typeof(IReward).IsAssignableFrom(t) && !t.IsAbstract && !t.IsInterface && !t.ContainsGenericParameters)
28 | 		.ToArray();
29 | 	
30 | 		if(RewardableClass.Length > 0){
31 | 			foreach (Type item in RewardableClass)
32 | 			{
33 | 				optionRewards.AddItem(item.Name.ToLower().Replace("reward", ""));
34 | 			}
35 | 		}
36 | 
37 | 		optionRewards.Select(-1);
38 | 	}
39 | 
40 | 	public void OnRewardTypeSelect(int selectedId){
41 | 		RemoveAllChild();
42 | 		attributeContainer.Visible = true;
43 | 
44 | 		var selectedReward = RewardableClass[selectedId];
45 | 		var rewardConstructor = selectedReward.GetConstructors().OrderByDescending(c=>c.GetParameters().Length).FirstOrDefault();
46 | 	
47 | 		if(rewardConstructor != null){
48 | 			var constructorParams = rewardConstructor.GetParameters();
49 | 
50 | 			foreach (var param in constructorParams)
51 | 			{
52 | 				Control input_field;
53 | 
54 | 				if(param.ParameterType == typeof(int)){
55 | 					input_field = new SpinBox();
56 | 					((SpinBox)input_field).MinValue = int.MinValue;
57 | 					((SpinBox)input_field).MaxValue = int.MaxValue;
58 | 				}
59 | 				else if(param.ParameterType == typeof(float)){ 
60 | 					input_field = new SpinBox();
61 | 					((SpinBox)input_field).MinValue = float.MinValue;
62 | 					((SpinBox)input_field).MaxValue = float.MaxValue;
63 | 				}
64 | 				else if(param.ParameterType == typeof(string)){
65 | 					input_field = new LineEdit();
66 | 				}
67 | 				else{
68 | 					GD.PushWarning($"Сonstructor parameter type '{param.ParameterType}' is not supported for UI view, try creating object directly via API");
69 | 					continue;
70 | 				}
71 | 
72 | 				input_field.Name = param.Name!;
73 | 				Label labelField = new Label{ Text = param.Name };
74 | 
75 | 				attributeContainer.AddChild(labelField);
76 | 				attributeContainer.AddChild(input_field);
77 | 			}
78 | 		}
79 | 	}
80 | 
81 | 	private void RemoveAllChild(){
82 | 		var allChild = attributeContainer.GetChildren();
83 | 		foreach (var child in allChild){
84 | 			child.Free();
85 | 		}
86 | 	}
87 | 
88 | 	protected override void Dispose(bool disposing)
89 | 	{
90 | 		if(disposing){
91 | 			AttributeContainerPath.Dispose();
92 | 			ButtonPath.Dispose();
93 | 		}
94 | 	}
95 | }
96 | 


--------------------------------------------------------------------------------
/addons/dotnetquestsystem/api/Quest.cs:
--------------------------------------------------------------------------------
 1 | namespace dotnetquestsystem;
 2 | 
 3 | using System.Text.Json.Serialization;
 4 | 
 5 | /// <summary>
 6 | /// Represents a quest.
 7 | /// </summary>
 8 | public class Quest{
 9 |     /// <summary>
10 |     /// Name of the quest.
11 |     /// </summary>
12 |     public string Name {get;}
13 | 
14 |     /// <summary>
15 |     /// Description of the quest.
16 |     /// </summary>
17 |     public string Description {get;}
18 | 
19 |     /// <summary>
20 |     /// Current status of the quest.
21 |     /// </summary>
22 |     public QuestStatus Status {get; private set;}
23 | 
24 |     /// <summary>
25 |     /// Reward associated with the quest, if any;
26 |     /// Null by defualt
27 |     /// </summary>
28 |     public IReward? Reward {get;} = null;
29 | 
30 |     public string Objective {get;}
31 | 
32 |      /// <summary>
33 |     /// Initializes a new instance of the <see cref="Quest"/> class with a specified name, description, and reward.
34 |     /// </summary>
35 |     /// <param name="name">The name of the quest.</param>
36 |     /// <param name="description">The description of the quest.</param>
37 |     /// <param name="reward">The reward associated with the quest.</param>
38 |     [JsonConstructor]
39 |     public Quest(string name, string description, string objective, IReward reward){
40 |         Name = name;
41 |         Description = description;
42 |         Objective = objective;
43 |         Status = QuestStatus.New;
44 |         Reward = reward;
45 |     }
46 | 
47 |     /// <summary>
48 |     /// Initializes a new instance of the <see cref="Quest"/> class with a specified name and description.
49 |     /// </summary>
50 |     /// <param name="name">The name of the quest.</param>
51 |     /// <param name="description">The description of the quest.</param>
52 |     public Quest(string name, string description, string objective){
53 |         Name = name;
54 |         Description = description;
55 |         Objective = objective;
56 |         Status = QuestStatus.New;
57 |     }
58 | 
59 |     /// <summary>
60 |     /// Changes the status of the quest to a new specified status.
61 |     /// </summary>
62 |     /// <param name="newStatus">The new status to set for the quest.</param>
63 |     public void ChangeQuestStatus(QuestStatus newStatus){
64 |         Status = newStatus;
65 |         QuestManager.instance.InvokeQuestStatusChanged(this);
66 |     }
67 | }


--------------------------------------------------------------------------------
/addons/dotnetquestsystem/api/QuestController.cs:
--------------------------------------------------------------------------------
 1 | namespace dotnetquestsystem;
 2 | 
 3 | using System;
 4 | using System.Collections.Generic;
 5 | 
 6 | /// <summary>
 7 | /// Provides methods to create, delete, and retrieve quests in the quest management system.
 8 | /// </summary>
 9 | public sealed class QuestController{
10 |     /// <summary>
11 |     /// Creates a new quest with the specified name and description.
12 |     /// </summary>
13 |     /// <param name="name">The name of the quest.</param>
14 |     /// <param name="description">The description of the quest.</param>
15 |     /// <returns>The newly created <see cref="Quest"/> object.</returns>
16 |     public Quest CreateQuest(string name, string description, string objective){
17 |         Quest quest = new Quest(name,description,objective);
18 |         QuestManager.instance.questDatabase.Quests.Add(quest);
19 |         return quest;
20 |     }
21 | 
22 |     /// <summary>
23 |     /// Creates a new quest with the specified name, description, and reward.
24 |     /// </summary>
25 |     /// <param name="name">The name of the quest.</param>
26 |     /// <param name="description">The description of the quest.</param>
27 |     /// <param name="reward">The reward associated with the quest.</param>
28 |     /// <returns>The newly created <see cref="Quest"/> object.</returns>
29 |     public Quest CreateQuest(string name, string description, string objective, IReward reward){
30 |         Quest quest = new Quest(name,description,objective,reward);
31 |         QuestManager.instance.questDatabase.Quests.Add(quest);
32 |         return quest;
33 |     }
34 | 
35 |     /// <summary>
36 |     /// Deletes a specified quest from the quest database.
37 |     /// </summary>
38 |     /// <param name="questToDelete">The <see cref="Quest"/> object to be deleted.</param>
39 |     public void DeleteQuest(Quest questToDelete){
40 |         QuestManager.instance.questDatabase.Quests.Remove(questToDelete);
41 |     }
42 | 
43 |     /// <summary>
44 |     /// Retrieves a quest by its name.
45 |     /// </summary>
46 |     /// <param name="name">The name of the quest to retrieve.</param>
47 |     /// <returns>The matching <see cref="Quest"/> object if found; otherwise, null.</returns>
48 |     public Quest? GetQuestByName(string name){
49 |         Predicate<Quest> matchByName = (quest) => quest.Name.Equals(name,StringComparison.OrdinalIgnoreCase);
50 |         return QuestManager.instance.questDatabase.Quests.Find(matchByName);
51 |     }
52 | 
53 |     /// <summary>
54 |     /// Retrieves all quests in the quest database.
55 |     /// </summary>
56 |     /// <returns>A list of all available <see cref="Quest"/> objects.</returns>
57 |     public List<Quest> GetAllQuests(){
58 |         return QuestManager.instance.questDatabase.Quests;
59 |     }
60 | }


--------------------------------------------------------------------------------
/addons/dotnetquestsystem/api/QuestDatabase.cs:
--------------------------------------------------------------------------------
 1 | namespace dotnetquestsystem;
 2 | 
 3 | using System.Collections.Generic;
 4 | using System.Text.Json;
 5 | using System.Threading.Tasks;
 6 | 
 7 | /// <summary>
 8 | /// Represents a database for storing quests, providing methods to save and load quests.
 9 | /// </summary>
10 | public sealed class QuestDatabase{
11 |     /// <summary>
12 |     /// List of quests in the database.
13 |     /// </summary>
14 |     public List<Quest> Quests {get;set;} = new List<Quest>();
15 | 
16 |     private ISaveSystemStrategy _saveStrategy = new QuestLocalSave();
17 | 
18 |     /// <summary>
19 |     /// Sets the save strategy to be used for saving and loading quests.
20 |     /// </summary>
21 |     /// <param name="saveType">The <see cref="ISaveSystemStrategy"/> implementation to use for saving and loading quests.</param>
22 |     public void SetSaveType(ISaveSystemStrategy saveType){
23 |         _saveStrategy = saveType;
24 |     }
25 | 
26 |     /// <summary>
27 |     /// Saves the current list of quests to a specified file path.
28 |     /// </summary>
29 |     /// <param name="pathToSave">The file path where the quests will be saved..</param>
30 |     public void SaveQuests(string pathToSave = "./database/Quests.json"){
31 |         _saveStrategy.Save(Quests, pathToSave);
32 |     }
33 | 
34 |     /// <summary>
35 |     /// Loads quests from a specified file path into the database.
36 |     /// </summary>
37 |     /// <param name="pathToData">The file path from which to load the quests.</param>
38 |     public void LoadQuests(string pathToData = "./database/Quests.json"){
39 |         Quests = _saveStrategy.Load(pathToData);
40 |     }
41 | }


--------------------------------------------------------------------------------
/addons/dotnetquestsystem/api/QuestManager.cs:
--------------------------------------------------------------------------------
 1 | namespace dotnetquestsystem;
 2 | 
 3 | using System;
 4 | 
 5 | /// <summary>
 6 | /// Manages the quest system, providing methods to start, finish, and cancel quests.
 7 | /// Implements the singleton design pattern to ensure a single instance of the manager.
 8 | /// </summary>
 9 | public class QuestManager{
10 |     private static readonly Lazy<QuestManager> _Singleton = new Lazy<QuestManager>(()=>new QuestManager());
11 |     public static QuestManager instance => _Singleton.Value;
12 | 
13 |     /// <summary>
14 |     /// The controller responsible for managing quest operations.
15 |     /// </summary>
16 |     public QuestController questController = new QuestController();
17 | 
18 |     /// <summary>
19 |     /// The database that stores all quests.
20 |     /// </summary>
21 |     public QuestDatabase questDatabase = new QuestDatabase();
22 | 
23 |     private QuestManager(){}
24 |     static QuestManager(){}
25 | 
26 |     /// <summary>
27 |     /// Starts a specified quest by changing its status to 'Current'.
28 |     /// </summary>
29 |     /// <param name="quest">The <see cref="Quest"/> object to be started.</param>
30 |     public void StartQuest(Quest quest){
31 |         quest.ChangeQuestStatus(QuestStatus.Current);
32 |     }
33 | 
34 |     /// <summary>
35 |     /// Finishes a specified quest by changing its status to 'Complete'.
36 |     /// Invokes the completion event and returns the reward associated with the quest.
37 |     /// </summary>
38 |     /// <param name="quest">The <see cref="Quest"/> object to be finished.</param>
39 |     /// <returns>The reward associated with the completed quest, or null if no reward exists.</returns>
40 |     public IReward? FinishQuest(Quest quest){
41 |         quest.ChangeQuestStatus(QuestStatus.Complete);
42 |         OnQuestCompleate?.Invoke(quest);
43 |         return quest.Reward;
44 |     }
45 | 
46 |     /// <summary>
47 |     /// Cancels a specified quest by changing its status to 'Canceled'.
48 |     /// </summary>
49 |     /// <param name="quest">The <see cref="Quest"/> object to be canceled.</param>
50 |     public void CancelQuest(Quest quest){
51 |         quest.ChangeQuestStatus(QuestStatus.Canceled);
52 |     }
53 |     
54 |     /// <summary>
55 |     /// Invokes the event that notifies subscribers about changes in a quest's status.
56 |     /// </summary>
57 |     /// <param name="quest">The <see cref="Quest"/> object whose status has changed.</param>
58 |     public void InvokeQuestStatusChanged(Quest quest){
59 |         OnQuestStatusChanged?.Invoke(quest);
60 |     }
61 |     
62 |     /// <summary>
63 |     /// Event triggered when a quest is completed.
64 |     /// </summary>
65 |     public event Action<Quest>? OnQuestCompleate;
66 | 
67 |     /// <summary>
68 |     /// Event triggered when a quest's status changes.
69 |     /// </summary>
70 |     public event Action<Quest>? OnQuestStatusChanged;
71 | }


--------------------------------------------------------------------------------
/addons/dotnetquestsystem/api/QuestStatus.cs:
--------------------------------------------------------------------------------
 1 | namespace dotnetquestsystem;
 2 | 
 3 | 
 4 | /// <summary>
 5 | /// Enumeration representing the possible statuses of a quest.
 6 | /// </summary>
 7 | public enum QuestStatus{
 8 |     /// <summary>
 9 |     /// The quest has just been created and has not yet started.
10 |     /// </summary>
11 |     New,
12 | 
13 |     /// <summary>
14 |     /// The quest is currently in progress.
15 |     /// </summary>
16 |     Current,
17 | 
18 |     /// <summary>
19 |     /// The quest has been successfully completed.
20 |     /// </summary>
21 |     Complete,
22 | 
23 |     /// <summary>
24 |     /// The quest has been canceled and will not be completed.
25 |     /// </summary>
26 |     Canceled
27 | }


--------------------------------------------------------------------------------
/addons/dotnetquestsystem/api/QuestSystemAPI.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 
 3 |   <PropertyGroup>
 4 |     <TargetFramework>net9.0</TargetFramework> 
 5 |     <RootNamespace>dotnetquestsystem</RootNamespace>
 6 |     <AssemblyName>dotnetquestsystem</AssemblyName>
 7 |     <Nullable>enable</Nullable>
 8 |   </PropertyGroup>
 9 | 
10 | </Project>


--------------------------------------------------------------------------------
/addons/dotnetquestsystem/api/Reward/ExperienceReward.cs:
--------------------------------------------------------------------------------
 1 | using System.Text.Json.Serialization;
 2 | 
 3 | namespace dotnetquestsystem;
 4 | 
 5 | /// <summary>
 6 | /// Represents a reward that grants experience points to the player.
 7 | /// </summary>
 8 | public class ExperienceReward : IReward{
 9 | 
10 |     /// <summary>
11 |     ///  Amount of experience points granted by this reward.
12 |     /// </summary>
13 |     public int Amount {get; private set;}
14 | 
15 |     /// <summary>
16 |     /// Initializes a new instance of the <see cref="ExperienceReward"/> class with a specified amount of experience.
17 |     /// </summary>
18 |     /// <param name="expAmount">The amount of experience points to be awarded.</param>
19 |     public ExperienceReward(int amount){
20 |         Amount = amount;
21 |     }
22 | 
23 |     public string GetDescription(){
24 |         return "This reward grants experience points to the player.";
25 |     }
26 | }


--------------------------------------------------------------------------------
/addons/dotnetquestsystem/api/Reward/IReward.cs:
--------------------------------------------------------------------------------
 1 | namespace dotnetquestsystem;
 2 | 
 3 | using System.Text.Json.Serialization;
 4 | 
 5 | /// <summary>
 6 | /// Interface representing rewards in the quest system.
 7 | /// </summary>
 8 | [JsonPolymorphic]
 9 | [JsonDerivedType(typeof(ExperienceReward),"ExperienceReward")]
10 | [JsonDerivedType(typeof(ItemReward<string>), "ItemReward")]
11 | public interface IReward{
12 | 
13 |     /// <summary>
14 |     /// Gets the description of the reward.
15 |     /// </summary>
16 |     /// <returns>A string containing the description of the reward.</returns>
17 |     string GetDescription(); 
18 | }


--------------------------------------------------------------------------------
/addons/dotnetquestsystem/api/Reward/ItemReward.cs:
--------------------------------------------------------------------------------
 1 | namespace dotnetquestsystem;
 2 | 
 3 | /// <summary>
 4 | /// Represents a reward in the form of an item with the possibility of gaining experience.
 5 | /// </summary>
 6 | /// <typeparam name="TItem">The type of the item that will be the reward.</typeparam>
 7 | public class ItemReward<TItem> : IReward{
 8 |     /// <summary>
 9 |     /// Item that is part of the reward.
10 |     /// </summary>
11 |     public TItem Item {get;private set;}
12 | 
13 |     /// <summary>
14 |     /// Gets the experience associated with the reward, if any. 
15 |     /// If there is no experience, this value is null.
16 |     /// </summary>
17 |     public ExperienceReward? Exp {get;private set;} = null;
18 | 
19 |     /// <summary>
20 |     /// Initializes a new instance of the <see cref="ItemReward{TItem}"/> class with the specified item.
21 |     /// </summary>
22 |     /// <param name="item">The item that will be part of the reward.</param>
23 |     public ItemReward(TItem item){
24 |         Item = item;
25 |     }
26 | 
27 |     /// <summary>
28 |     /// Initializes a new instance of the <see cref="ItemReward{TItem}"/> class with the specified item and experience.
29 |     /// </summary>
30 |     /// <param name="item">The item that will be part of the reward.</param>
31 |     /// <param name="exp">The experience associated with the reward.</param>
32 |     public ItemReward(TItem item, ExperienceReward exp){
33 |         Item = item;
34 |         Exp = exp;
35 |     }
36 | 
37 |     public string GetDescription(){
38 |         string description = $"This reward includes an item: {Item}.";
39 | 
40 |         if (Exp != null)
41 |         {
42 |             description += $" Additionally, it grants {Exp.Amount} experience points.";
43 |         }
44 | 
45 |         return description;
46 |     }
47 | }


--------------------------------------------------------------------------------
/addons/dotnetquestsystem/api/Save/ISaveSystemStrategy.cs:
--------------------------------------------------------------------------------
 1 | namespace dotnetquestsystem;
 2 | 
 3 | using System.Collections.Generic; 
 4 | 
 5 | public interface ISaveSystemStrategy{
 6 |     /// <summary>
 7 |     /// Saves a list of quests to a specified file path.
 8 |     /// </summary>
 9 |     /// <param name="quests">The list of quests to be saved.</param>
10 |     /// <param name="pathToSave">The file path where the quests will be saved.</param>
11 |     void Save(List<Quest> quests, string pathToSave);
12 | 
13 |     /// <summary>
14 |     /// Loads a list of quests from a specified file path.
15 |     /// </summary>
16 |     /// <param name="pathToData">The file path from which the quests will be loaded.</param>
17 |     /// <returns>A list of quests loaded from the specified file.</returns>
18 |     List<Quest> Load(string pathToData);
19 | }


--------------------------------------------------------------------------------
/addons/dotnetquestsystem/api/Save/QuestDatabaseSave.cs:
--------------------------------------------------------------------------------
 1 | namespace dotnetquestsystem;
 2 | 
 3 | using System.Collections.Generic;
 4 | 
 5 | /// <summary>
 6 | /// Provides a database implementation of the <see cref="ISaveSystemStrategy"/> interface for saving and loading quests.
 7 | /// </summary>
 8 | ///TODO
 9 | public class QuestDatabaseSave : ISaveSystemStrategy{
10 |     public void Save(List<Quest> quests, string pathToSave){}
11 | 
12 |     public List<Quest> Load(string pathToData){
13 |         return new List<Quest>();
14 |     }
15 | }


--------------------------------------------------------------------------------
/addons/dotnetquestsystem/api/Save/QuestLocalSave.cs:
--------------------------------------------------------------------------------
 1 | namespace dotnetquestsystem;
 2 | 
 3 | using System.Collections.Generic;
 4 | using System.Text.Json;
 5 | using System.IO;
 6 | 
 7 | /// <summary>
 8 | /// Provides a json local file-based implementation of the <see cref="ISaveSystemStrategy"/> interface for saving and loading quests.
 9 | /// </summary>
10 | public class QuestLocalSave : ISaveSystemStrategy{
11 |     public void Save(List<Quest> quests, string pathToSave){
12 |         var option = new JsonSerializerOptions {WriteIndented = true};
13 |         string questsJson = JsonSerializer.Serialize(quests, option);
14 | 
15 |         string? directoryPath = Path.GetDirectoryName(pathToSave);
16 | 
17 |         if(!string.IsNullOrEmpty(directoryPath) && !Directory.Exists(directoryPath)){
18 |             Directory.CreateDirectory(directoryPath);
19 |         }
20 |         
21 |         File.WriteAllText(pathToSave, questsJson);
22 |     }
23 | 
24 |     public List<Quest> Load(string pathToData){
25 | 
26 |         if(!File.Exists(pathToData)){
27 |             throw new FileNotFoundException("Quests file not found", pathToData);
28 |         }
29 | 
30 |         string json = File.ReadAllText(pathToData);
31 | 
32 |         List<Quest>? quests = JsonSerializer.Deserialize<List<Quest>>(json);
33 | 
34 |         return quests?? new List<Quest>();
35 |     }
36 | }


--------------------------------------------------------------------------------
/addons/dotnetquestsystem/assets/dotnetquestsystem_node.svg:
--------------------------------------------------------------------------------
 1 | <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
 2 | <path d="M14.5 11H2.5C1.94772 11 1.5 11.4477 1.5 12V14C1.5 14.5523 1.94772 15 2.5 15H14.5" stroke="white" stroke-linecap="round" stroke-linejoin="round"/>
 3 | <path d="M2 0.5H14C14.2761 0.5 14.5 0.723858 14.5 1V10C14.5 10.2761 14.2761 10.5 14 10.5H2C1.72386 10.5 1.5 10.2761 1.5 10V1C1.5 0.723858 1.72386 0.5 2 0.5Z" stroke="white" stroke-linejoin="round"/>
 4 | <line x1="1.5" y1="10" x2="1.5" y2="12" stroke="white"/>
 5 | <line x1="14.5" y1="9" x2="14.5" y2="11" stroke="white"/>
 6 | <path d="M13 11L12.4472 12.1056C12.1657 12.6686 12.1657 13.3314 12.4472 13.8944L13 15" stroke="white" stroke-linecap="round"/>
 7 | <path d="M4 2.5H12" stroke="white" stroke-linecap="round"/>
 8 | <path d="M4 7H10" stroke="white" stroke-linecap="round"/>
 9 | <path d="M4 5H8" stroke="white" stroke-linecap="round"/>
10 | <line x1="2" y1="11.9" x2="13" y2="11.9" stroke="white" stroke-width="0.2"/>
11 | <line x1="2" y1="12.9" x2="12" y2="12.9" stroke="white" stroke-width="0.2"/>
12 | <line x1="2" y1="13.9" x2="12" y2="13.9" stroke="white" stroke-width="0.2"/>
13 | </svg>
14 | 


--------------------------------------------------------------------------------
/addons/dotnetquestsystem/assets/godot_asset_icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TRUINGLol/DotnetQuestSystem/928b1dc03a8eabb4767888e3e6244beb4153b4bc/addons/dotnetquestsystem/assets/godot_asset_icon.png


--------------------------------------------------------------------------------
/addons/dotnetquestsystem/plugin.cfg:
--------------------------------------------------------------------------------
1 | [plugin]
2 | 
3 | name="DotnetQuestSystem"
4 | description="Simple quest system"
5 | author="Sergei Naibauer"
6 | version="1.0.0"
7 | script="Plugin.cs"
8 | 


--------------------------------------------------------------------------------
/docs/api/quest.md:
--------------------------------------------------------------------------------
 1 | ## `Quest`
 2 | 
 3 | ### Description
 4 | 
 5 | The `Quest` class represents a basic structure for quests in a game. It contains information about the quest's title, description, status, and objective, as well as any potential rewards for its completion. The class provides methods for changing the quest's status and initializing its properties.
 6 | 
 7 | ### Properties
 8 | 
 9 | | Name           | Type        | Description |
10 | | ---------------| ------------| ------------|
11 | | `Name`         | [string](https://docs.microsoft.com/en-us/dotnet/api/system.string) | The title of the quest. |
12 | | `Description`  | [string](https://docs.microsoft.com/en-us/dotnet/api/system.string) | A description of the quest. |
13 | | `Status`       | [QuestStatus](#queststatus) | The current status of the quest. |
14 | | `Reward`       | [IReward?](#ireward) | The reward associated with the quest, if any; defaults to null. |
15 | | `Objective`    | [string](https://docs.microsoft.com/en-us/dotnet/api/system.string) | The objective of the quest. |
16 | 
17 | ### Constructors
18 | 
19 | #### _Quest(string name, string description, string objective, IReward reward)_
20 | > Initializes a new instance of the `Quest` class with the specified title, description, objective and reward.
21 | 
22 | - **Parameters:**
23 |   - `name`: The title of the quest.
24 |   - `description`: A description of the quest.
25 |   - `objective`: The objective of the quest.
26 |   - `reward`: The reward associated with the quest.
27 | 
28 | #### _Quest(string name, string description, string objective)_
29 | > Initializes a new instance of the `Quest` class with the specified title, objective and description.
30 | 
31 | - **Parameters:**
32 |   - `name`: The title of the quest.
33 |   - `description`: A description of the quest.
34 |   - `objective`: The objective of the quest.
35 | 
36 | ### Methods
37 | 
38 | | Name | Return Type |
39 | | ---- | ----------- |
40 | | [**ChangeQuestStatus**](#void-changequeststatusqueststatus-newstatus)**(QuestStatus newStatus)** | **void** |
41 | 
42 | #### _void ChangeQuestStatus(QuestStatus newStatus)_
43 | > Changes the status of the quest to the specified new status.
44 | 
45 | - **Parameters:**
46 |   - `newStatus`: The new status to set for the quest.
47 | 
48 | ### Summary
49 | 
50 | The `Quest` class provides essential properties and methods for managing the state and information about quests in a game. It allows setting titles and descriptions for quests, as well as managing their statuses and rewards. The method `ChangeQuestStatus` allows changing a quest's status and notifying the quest management system about changes through a call to this method in an instance of the `QuestManager`.


--------------------------------------------------------------------------------
/docs/api/quest_controller.md:
--------------------------------------------------------------------------------
 1 | ## `QuestController`
 2 | **Description:** Provides methods to create, delete, and retrieve quests in the quest management system.
 3 | 
 4 | ### Methods
 5 | 
 6 | | Name                                   | Return Type                     |
 7 | | -------------------------------------- | ------------------------------- |
 8 | | [**CreateQuest**](#quest-createqueststring-string-string)**(string name, string description, string objective)** | **Quest**                       |
 9 | | [**CreateQuest**](#quest-createqueststring-string-string-ireward)**(string name, string description, string objective, IReward reward)** | **Quest**                       |
10 | | [**DeleteQuest**](#void-deletequestquest)**(Quest questToDelete)** | **void**                        |
11 | | [**GetQuestByName**](#quest-getquestbynamestring)**(string name)** | **Quest?**                     |
12 | | [**GetAllQuests**](#listquest-getallquests)**()** | **List <Quest**                |
13 | 
14 | #### _Quest CreateQuest(string name, string description, string objective)_
15 | > Creates a new quest with the specified name, objective and description. And adds it to `QuestDatabase`. 
16 | 
17 | - **Parameters:**
18 |   - `name`: The name of the quest.
19 |   - `description`: The description of the quest.
20 |   - `objective`: The objective of the quest.
21 | - **Returns:** The newly created [`Quest`](#quest) object.
22 | 
23 | #### _Quest CreateQuest(string name, string description, string objective, IReward reward)_
24 | > Creates a new quest with the specified name, description, objective and reward. And adds it to `QuestDatabase`.
25 | 
26 | - **Parameters:**
27 |   - `name`: The name of the quest.
28 |   - `description`: The description of the quest.
29 |   - `objective`: The objective of the quest.
30 |   - `reward`: The reward associated with the quest.
31 | - **Returns:** The newly created [`Quest`](#quest) object.
32 | 
33 | #### _void DeleteQuest(Quest questToDelete)_
34 | > Deletes a specified quest from the quest database.
35 | 
36 | - **Parameters:**
37 |   - `questToDelete`: The [`Quest`](#quest) object to be deleted.
38 | 
39 | #### _Quest? GetQuestByName(string name)_
40 | > Retrieves a quest by its name.
41 | 
42 | - **Parameters:**
43 |   - `name`: The name of the quest to retrieve.
44 | - **Returns:** The matching [`Quest`](#quest) object if found; otherwise, null.
45 | 
46 | #### _List<Quest> GetAllQuests()_
47 | > Retrieves all quests in the quest database.
48 | 
49 | - **Returns:** A list of all available [`Quest`](#quest) objects.
50 | 
51 | ### Summary
52 | 
53 | The `QuestController` class is responsible for managing quests within a game. It provides functionality to create new quests (with or without rewards), delete existing quests from the database, and retrieve quests either by their names or as a complete list. This class acts as an interface between the user and the underlying data structure that holds all quests.


--------------------------------------------------------------------------------
/docs/api/quest_database.md:
--------------------------------------------------------------------------------
 1 | ## `QuestDatabase`
 2 | **Description:** Represents a database for storing quests, providing methods to save and load quests.
 3 | 
 4 | ### Properties
 5 | 
 6 | | Name      | Type                     | Description |
 7 | | --------- | ------------------------ | ----------- |
 8 | | `Quests`  | List<Quest>             | List of quests in the database. |
 9 | 
10 | ### Methods
11 | 
12 | | Name                                   | Return Type                     |
13 | | -------------------------------------- | ------------------------------- |
14 | | [**SetSaveType**](#void-setsavetypeisavesystemstrategy)**(ISaveSystemStrategy saveType)** | **void**                        |
15 | | [**SaveQuests**](#void-savequestsstring)**(string pathToSave)** | **void**                        |
16 | | [**LoadQuests**](#void-loadquestsstring)**(string pathToData)** | **void**                        |
17 | 
18 | #### _void SetSaveType(ISaveSystemStrategy saveType)_
19 | > Sets the save strategy to be used for saving and loading quests. By default, the `QuestLocalSave` type is set
20 | 
21 | - **Parameters:**
22 |   - `saveType`: The [`ISaveSystemStrategy`](#isavesystemstrategy) implementation to use for saving and loading quests.
23 | 
24 | #### _void SaveQuests(string pathToSave = "./database/Quests.json")_
25 | > Saves the current list of quests to a specified file path.
26 | 
27 | - **Parameters:**
28 |   - `pathToSave`: The file path where the quests will be saved (default is `"./database/Quests.json"`).
29 | 
30 | #### _void LoadQuests(string pathToData = "./database/Quests.json")_
31 | > Loads quests from a specified file path into the database.
32 | 
33 | - **Parameters:**
34 |   - `pathToData`: The file path from which to load the quests (default is `"./database/Quests.json"`).
35 | 
36 | ### Summary
37 | 
38 | The `QuestDatabase` class serves as a storage system for managing quests within a game. It provides functionality to save and load quests using a specified saving strategy, allowing for flexibility in how quest data is handled. The class maintains a list of quests and offers methods to set the saving strategy, save the current list of quests to a file, and load quests from a file into the database.
39 | 
40 | >You can also create your own quest saving strategy by creating a class that implements the `ISaveSystemStrategy` interface.


--------------------------------------------------------------------------------
/docs/api/quest_manager.md:
--------------------------------------------------------------------------------
 1 | ## `QuestManager`
 2 | 
 3 | **Description:** Manages the quest system, providing methods to start, finish, and cancel quests. Implements the singleton design pattern to ensure a single instance of the manager.
 4 | 
 5 | ### Properties
 6 | 
 7 | | Name                | Type                     | Description |
 8 | | ------------------- | ------------------------ | ----------- |
 9 | | `instance`          | [QuestManager](#questmanager) | The singleton instance of the `QuestManager`. |
10 | | `questController`   | [QuestController](#questcontroller) | The controller responsible for managing quest operations. |
11 | | `questDatabase`     | [QuestDatabase](#questdatabase) | The database that stores all quests. |
12 | 
13 | ### Constructors
14 | 
15 | #### _QuestManager()_
16 | > Initializes a new instance of the `QuestManager`. This constructor is private to enforce the singleton pattern.
17 | 
18 | ### Methods
19 | 
20 | | Name                                   | Return Type                     |
21 | | -------------------------------------- | ------------------------------- |
22 | | [**StartQuest**](#void-startquestquest)**(Quest quest)** | **void**                        |
23 | | [**FinishQuest**](#ireward-finishquestquest)**(Quest quest)** | **IReward?**                   |
24 | | [**CancelQuest**](#void-cancelquestquest)**(Quest quest)** | **void**                        |
25 | | [**InvokeQuestStatusChanged**](#void-invokequeststatuschangedquest)**(Quest quest)** | **void**                        |
26 | 
27 | #### _void StartQuest(Quest quest)_
28 | > Starts a specified quest by changing its status to 'Current'.
29 | 
30 | - **Parameters:**
31 |   - `quest`: The [`Quest`](#quest) object to be started.
32 | 
33 | #### _IReward? FinishQuest(Quest quest)_
34 | > Finishes a specified quest by changing its status to 'Complete'. Invokes the completion event and returns the reward associated with the quest.
35 | 
36 | - **Parameters:**
37 |   - `quest`: The [`Quest`](#quest) object to be finished.
38 | - **Returns:** The reward associated with the completed quest, or null if no reward exists.
39 | 
40 | #### _void CancelQuest(Quest quest)_
41 | > Cancels a specified quest by changing its status to 'Canceled'.
42 | 
43 | - **Parameters:**
44 |   - `quest`: The [`Quest`](#quest) object to be canceled.
45 | 
46 | #### _void InvokeQuestStatusChanged(Quest quest)_
47 | > Invokes the event that notifies subscribers about changes in a quest's status.
48 | 
49 | - **Parameters:**
50 |   - `quest`: The [`Quest`](#quest) object whose status has changed.
51 | 
52 | ### Events
53 | 
54 | | Name                          | Description |
55 | | ----------------------------- | ----------- |
56 | | `OnQuestCompleate`           | Event triggered when a quest is completed. |
57 | | `OnQuestStatusChanged`       | Event triggered when a quest's status changes. |
58 | 
59 | ### Summary
60 | 
61 | The `QuestManager` class serves as a central hub for managing quests within a game. It allows for starting, finishing, and canceling quests while ensuring that only one instance of the manager exists through the singleton design pattern. Additionally, it provides events for notifying subscribers about changes in quest statuses and completions.`.


--------------------------------------------------------------------------------
/docs/api/quest_status.md:
--------------------------------------------------------------------------------
 1 | ## `QuestStatus`
 2 | 
 3 | **Description:** Enumeration representing the possible statuses of a quest.
 4 | 
 5 | ### Enumeration Members
 6 | 
 7 | | Name      | Description |
 8 | | --------- | ----------- |
 9 | | `New`     | The quest has just been created and has not yet started. |
10 | | `Current` | The quest is currently in progress. |
11 | | `Complete`| The quest has been successfully completed. |
12 | | `Canceled`| The quest has been canceled and will not be completed. |
13 | 
14 | ### Summary
15 | 
16 | The `QuestStatus` enumeration defines the various states a quest can be in during its lifecycle. It includes statuses for newly created quests, quests that are currently active, completed quests, and quests that have been canceled. This enumeration helps in managing and tracking the progress of quests within a game.


--------------------------------------------------------------------------------
/docs/api/reward.md:
--------------------------------------------------------------------------------
 1 | ## Reward
 2 | 
 3 | As you can see, the `Quest` class allows you to store a `Reward` property that will be returned when the quest is completed via the `FinishQuest()` method of the `QuestManager` instance. The `Reward` property is of type `IReward`, which means you can create your own reward types.
 4 | 
 5 | For example, two types of rewards have already been created: `ExperienceReward` and `ItemReward`
 6 | 
 7 | To create your own reward type, you need to implement the `IReward` interface.
 8 | **Please note** that for the `QuestLocalSave` strategy to work correctly, you will need to add the `JsonDerivedType` attribute for the `IReward` interface, this is due to the polymorphic serialization of `System.Text.Json` used in the `QuestLocalSave` strategy.
 9 | For an example, you can go to the source code of already created rewards.
10 | 
11 | > **_Note_** New reward types will only display correctly in godot editor if they follow the type class name: `NewReward` and are not a generic type.


--------------------------------------------------------------------------------
/docs/api/save_system.md:
--------------------------------------------------------------------------------
1 | ## Save system
2 | 
3 | You can use your own quest data saving strategies different from the existing ones.
4 | 
5 | To do this, you need to implement the `ISaveSystemStrategy` interface and specify this type in the `SetSaveType()` method of the `QuestDatabase` class
6 | 
7 | Please refer to the source code for an example implementation


--------------------------------------------------------------------------------
/docs/contributing.md:
--------------------------------------------------------------------------------
 1 | # Contributing to DotnetQuestSystem
 2 | 
 3 | Thank you for considering contributing to this project! Contributions from everyone are welcome. 
 4 | 
 5 | Please follow the guidelines below to help maintain the high quality of the project!
 6 | 
 7 | ## Quick Guidelines
 8 | 
 9 | Here are a few simple rules and suggestions to remember when contributing to MonoGame.
10 | 
11 | * :bangbang: **NEVER** commit code that you did not personally write.
12 | * :bangbang:  **NEVER**  use decompiler tools to steal code and submit it as your own work.
13 | * :bangbang:  **NEVER**  decompile Godot assemblies or other libraries and steal copyrighted code.
14 | * **PLEASE** try to keep your PRs focused on a single topic and of a reasonable size.
15 | * **PLEASE** be sure to write simple and descriptive commit messages.
16 | * **DO** try to microsoft [coding style](https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/coding-style/coding-conventions) for new code.
17 | * **DO** give priority to the existing style of the file you are changing.
18 | * **DO** try to add [unit tests](test) when adding new features or fixing bugs in the API.
19 | * **PLEASE** keep a civil and respectful tone when discussing and reviewing contributions.
20 | 
21 | ## Issues and Feedback
22 | If you find any issues or have suggestions for improvements, please open an issue in the repository.
23 | Thank you for contributing!♥️


--------------------------------------------------------------------------------
/docs/getting_started.md:
--------------------------------------------------------------------------------
 1 | # Getting started with DotnetQuestSystem
 2 | 
 3 | This quick guide will help you get started with installing and using the addon in your Godot projects.
 4 | 
 5 | ## Prerequisites
 6 | 
 7 | Before you begin, ensure you have the following:
 8 | - Godot.NET.Sdk (version 4.0.0 or higher)
 9 | - .NET SDK (version 8.0 or higher)
10 | - Basic knowledge of C# programming
11 | 
12 | ## Installation
13 | 1. Download a copy of the `addons` folder
14 | 2. Copy the `addons` folder from the downloaded file to your project directory
15 | 3. Activate the addon in the editor `Project -> Project Settings -> Plugins`
16 | 
17 | ##  Working with quest via code
18 | 
19 | Here is a simple example of creating and completing a quest state through code
20 | 
21 | ```
22 | using dotnetquestsystem;
23 | using System;
24 | 
25 | public partial class PlayersHouse : Control{
26 | 	
27 | 	public Quest newQuest;
28 | 	
29 | 	public  override  void  _Ready(){
30 | 		newQuest = QuestManager.instance.questController.CreateQuest(
31 | 		    "The Secret of the Attic", // Quest name
32 | 		    "Locals claim that ancient artifacts and secrets of your family are hidden in the attic.", // Quest description
33 | 		    "Solve the riddles" // Quest objective
34 | 		);
35 | 		
36 | 		GD.Print("Quest status: "+ newQuest.Status); // Quest status: New
37 | 		
38 | 		QuestManager.instance.StartQuest(newQuest);
39 | 
40 | 		GD.Print("Quest status: "+ newQuest.Status); // Quest status: Current
41 | 	}
42 | 
43 | 	public void OnSolveRiddles(){
44 | 		QuestManager.instance.FinishQuest(newQuest);
45 | 		GD.Print("Quest status: "+ newQuest.Status); // Quest status: Complete
46 | 	}
47 | }
48 | ```
49 | 
50 | All work with the quest management system API is carried out through the singleton `QuestManager`, which simplifies interaction and management of quest status.
51 | 
52 | To create a `Quest` object, the `CreateQuest()` method of the `questController` property is used here. Nothing stops you from creating a `Quest` manually via the constructor, but note that in this case the `Quest` object will not be added to the `QuestDatabase` quest store.
53 | 
54 | After creating a quest, we can start the quest by making its state `Current` using the `StartQuest()` method of the `QuestManager` instance.
55 | 
56 | To complete a quest and change its status to `Complete`, use the `FinishQuest()` method of the `QuestManager` instance.
57 | 
58 | > **_NOTE:_** It is worth considering that this addon was created as a library and is aimed at use through code.
59 | 
60 | ## Working with quests via godot editor
61 | 
62 | After activating the addon, you are provided with an interface in the editor for managing quests. Please note that this interface does not provide the ability to change the status of the quest and is used only for working with the quest database.


--------------------------------------------------------------------------------
/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=5
10 | 
11 | [application]
12 | 
13 | config/name="DotnetQuestSystem"
14 | config/features=PackedStringArray("4.4", "C#", "Forward Plus")
15 | config/icon="res://icon.svg"
16 | 
17 | [dotnet]
18 | 
19 | project/assembly_name="DotnetQuestSystemAddon"
20 | 
21 | [editor_plugins]
22 | 
23 | enabled=PackedStringArray("res://addons/dotnetquestsystem/plugin.cfg")
24 | 


--------------------------------------------------------------------------------
/test/QuestSystemAPITest/QuestControllerTest.cs:
--------------------------------------------------------------------------------
 1 | namespace QuestSystemAPITest;
 2 | 
 3 | using dotnetquestsystem;
 4 | using System.Collections.Generic;
 5 | 
 6 | public class QuestControllerTest{
 7 | 
 8 |     public QuestControllerTest(){
 9 |         QuestManager.instance.questDatabase.Quests.Clear();
10 |     }
11 |     
12 |     [Fact]
13 |     public void CreateQuest_WithNameDescription_ReturnQuestAddedToDatabase(){
14 |         // Arrange
15 |         QuestManager instance = QuestManager.instance;
16 |         string expectedName = "TestNameWithDescriptionQuest";
17 |         string expectedDescription = "TestDescriptionWithNameQuest";
18 |         string expectedObjective = "TestObjective";
19 | 
20 |         // Act
21 |         Quest quest = instance.questController.CreateQuest(expectedName, expectedDescription, expectedObjective);
22 | 
23 |         // Assert
24 |         Assert.Equal(expectedName, quest.Name);
25 |         Assert.Equal(expectedDescription, quest.Description);
26 |         Assert.Contains(instance.questDatabase.Quests, q => q.Name == expectedName &&
27 |             q.Description == expectedDescription && q.Reward == null && q.Objective == expectedObjective);
28 |     }
29 | 
30 |     [Fact]
31 |     public void CreateQuest_WithNameDescriptionReward_ReturnQuestAddedToDatabase(){
32 |         // Arrange
33 |         QuestManager instance = QuestManager.instance;
34 |         string expectedName = "TestNameWithDescriptionRewardQuest";
35 |         string expectedDescription = "TestDescriptionWithNameRewardQuest";
36 |         string expectedObjective = "TestObjective";
37 |         IReward expectedReward = new ExperienceReward(0);
38 | 
39 |         // Act
40 |         Quest quest = instance.questController.CreateQuest(expectedName, expectedDescription, expectedObjective, expectedReward);
41 | 
42 |         // Assert
43 |         Assert.Equal(expectedName, quest.Name);
44 |         Assert.Equal(expectedDescription, quest.Description);
45 |         Assert.Equal(expectedReward, quest.Reward);
46 |         Assert.Contains(instance.questDatabase.Quests, q => q.Name == expectedName && 
47 |             q.Description == expectedDescription && q.Reward == expectedReward && q.Objective == expectedObjective);
48 |     }
49 | 
50 |     [Fact]
51 |     public void DeleteQuest_WithCreatedQuest_ReturnRemoveFromDatabase(){
52 |         // Arrange
53 |         QuestManager instance = QuestManager.instance;
54 |         string expectedName = "TestName";
55 |         string expectedDescription = "TestDescription";
56 |         string expectedObjective = "TestObjective";
57 |         Quest quest = instance.questController.CreateQuest(expectedName, expectedDescription, expectedObjective);
58 | 
59 |         // Act
60 |         instance.questController.DeleteQuest(quest);
61 | 
62 |         // Assert
63 |         Assert.DoesNotContain(instance.questDatabase.Quests, q => q.Name == expectedName && 
64 |             q.Description == expectedDescription && q.Reward == null && q.Objective == expectedObjective);
65 |     }
66 | 
67 |     [Fact]
68 |     public void GetQuestByName_WithTestName_ReturnQuestByTestNameFromDatabase(){
69 |         // Arrange
70 |         QuestManager instance = QuestManager.instance;
71 |         string expectedName = "TestName";
72 |         Quest expectedQuest = instance.questController.CreateQuest(expectedName, "TestDescription", "TestObjective");
73 | 
74 |         // Act
75 |         Quest? questFromDB = instance.questController.GetQuestByName(expectedName);
76 | 
77 |         // Assert
78 |         Assert.Equal(expectedQuest, questFromDB);
79 | 
80 |     }
81 | 
82 |     [Fact]
83 |     public void GetAllQuests_WithCreatedQuests_ReturnQuestsListFromDatabaseWithCreatedQuests(){
84 |         // Arrange
85 |         QuestManager instance = QuestManager.instance;
86 |         string expectedName = "TestNameQuest";
87 |         string expectedDescription = "TestDescriptionQuest";
88 |         string expectedObjective = "TestObjective";
89 |         Quest expectedQuest = instance.questController.CreateQuest(expectedName, expectedDescription, expectedObjective);
90 | 
91 |         // Act
92 |         List<Quest> questsFromDatabase = instance.questController.GetAllQuests();
93 | 
94 |         // Assert
95 |         Assert.Contains(questsFromDatabase, q => q.Name == expectedName &&
96 |             q.Description == expectedDescription && q.Reward == null && q.Objective == expectedObjective);
97 |     }
98 | }


--------------------------------------------------------------------------------
/test/QuestSystemAPITest/QuestControllerTest.cs.uid:
--------------------------------------------------------------------------------
1 | uid://dtcesfa5n03i4
2 | 


--------------------------------------------------------------------------------
/test/QuestSystemAPITest/QuestDatabaseTest.cs:
--------------------------------------------------------------------------------
 1 | namespace QuestSystemAPITest;
 2 | 
 3 | using dotnetquestsystem;
 4 | using System.Collections.Generic;
 5 | using System.IO;
 6 | 
 7 | public class QuestDatabseTest{
 8 | 
 9 |     [Fact]
10 |     public void SaveQuests_LocalSaveCreatedQuests_ReturnCreateNewJsonFile(){
11 |         // Arrange
12 |         QuestDatabase instance = new QuestDatabase();
13 |         Quest quest = new Quest("TestName", "TestDescription", "TestObjective");
14 | 
15 |         instance.SetSaveType(new QuestLocalSave());
16 |         string expectedJsonPath = "../Quest.json";
17 | 
18 |         // Act
19 |         instance.Quests.Add(quest);
20 |         instance.SaveQuests(expectedJsonPath);
21 | 
22 |         // Assert
23 |         Assert.True(File.Exists(expectedJsonPath), "Json file was not created!");
24 |     }
25 | 
26 |     [Fact]
27 |     public void LoadQuests_LocalLoadSavedQuests_ReturnQuestListData(){
28 |         // Arrange
29 |         QuestDatabase instance = new QuestDatabase();
30 |         string expectedName = "TestName";
31 |         string expectedDescription = "TestDescription";
32 |         string expectedObjective = "TestObjective";
33 |         Quest quest = new Quest(expectedName, expectedDescription, expectedObjective);
34 | 
35 |         instance.SetSaveType(new QuestLocalSave());
36 |         string expectedJsonPath = "../Quest.json";
37 | 
38 |         // Act
39 |         instance.Quests.Add(quest);
40 |         instance.SaveQuests(expectedJsonPath);
41 |         instance.LoadQuests(expectedJsonPath);
42 | 
43 |         // Assert
44 |         Assert.Contains(instance.Quests, q=> q.Name==expectedName && 
45 |             q.Description==expectedDescription && q.Objective == expectedObjective);
46 |     }
47 | }


--------------------------------------------------------------------------------
/test/QuestSystemAPITest/QuestDatabaseTest.cs.uid:
--------------------------------------------------------------------------------
1 | uid://b7gynte0auat3
2 | 


--------------------------------------------------------------------------------
/test/QuestSystemAPITest/QuestManagerTest.cs:
--------------------------------------------------------------------------------
 1 | namespace QuestSystemAPITest;
 2 | 
 3 | using dotnetquestsystem;
 4 | using System.IO;
 5 | 
 6 | public class QuestManagerTest{
 7 | 
 8 |     [Fact]
 9 |     public void OnQuestCompleate_QuestStatusComplete_ReturnInvokeEvent(){
10 |         // Arrange
11 |         QuestManager instance = QuestManager.instance;
12 |         Quest quest = new Quest("testName", "testDescription", "testObjective");
13 | 
14 |         bool eventInvoked = false;
15 |         instance.OnQuestCompleate += (q)=>eventInvoked = true;
16 | 
17 |         // Act
18 |         instance.FinishQuest(quest);
19 | 
20 |         // Assert
21 |         Assert.True(eventInvoked);
22 |     }
23 | 
24 |     [Fact]
25 |     public void OnQuestStatusChanged_CreatedQuestStatusChanged_ReturnInvokeEvent(){
26 |         // Arrange
27 |         QuestManager instance = QuestManager.instance;
28 |         Quest quest = new Quest("testName", "testDescription", "testObjective");
29 | 
30 |         bool eventInvoked = false;
31 |         instance.OnQuestStatusChanged += (q)=>eventInvoked = true;
32 | 
33 |         // Act
34 |         quest.ChangeQuestStatus(QuestStatus.Complete);
35 | 
36 |         // Assert
37 |         Assert.True(eventInvoked);
38 |     }
39 | }


--------------------------------------------------------------------------------
/test/QuestSystemAPITest/QuestManagerTest.cs.uid:
--------------------------------------------------------------------------------
1 | uid://bdpmqqudx7tp3
2 | 


--------------------------------------------------------------------------------
/test/QuestSystemAPITest/QuestSystemAPITest.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 
 3 |   <PropertyGroup>
 4 |     <TargetFramework>net9.0</TargetFramework>
 5 |     <ImplicitUsings>enable</ImplicitUsings>
 6 |     <Nullable>enable</Nullable>
 7 |     <IsPackable>false</IsPackable>
 8 |   </PropertyGroup>
 9 | 
10 |   <ItemGroup>
11 |     <PackageReference Include="coverlet.collector" Version="6.0.2" />
12 |     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
13 |     <PackageReference Include="xunit" Version="2.9.2" />
14 |     <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2" />
15 |   </ItemGroup>
16 | 
17 |   <ItemGroup>
18 |     <Using Include="Xunit" />
19 |   </ItemGroup>
20 | 
21 |   <ItemGroup>
22 |     <ProjectReference Include="../../addons/dotnetquestsystem/api/QuestSystemAPI.csproj" />
23 |   </ItemGroup>
24 | 
25 | </Project>
26 | 


--------------------------------------------------------------------------------
/test/QuestSystemAPITest/QuestTest.cs:
--------------------------------------------------------------------------------
 1 | namespace QuestSystemAPITest;
 2 | 
 3 | using dotnetquestsystem;
 4 | 
 5 | public class QuestTest
 6 | {
 7 |     [Fact]
 8 |     public void ChangeQuestStatus_NewToComplete_ReturnComplete()
 9 |     {
10 |         // Arrange
11 |         Quest quest = new Quest("TestName", "TestDescription", "TestObjective");
12 | 
13 |         // Act
14 |         quest.ChangeQuestStatus(QuestStatus.Complete);
15 | 
16 |         // Assert
17 |         Assert.Equal(QuestStatus.Complete,quest.Status);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/test/QuestSystemAPITest/QuestTest.cs.uid:
--------------------------------------------------------------------------------
1 | uid://frtnnln1jnqi
2 | 


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