Merge dev into net5.0

.github/workflows/dotnet.yml

@@ -0,0 +1,28 @@
+name: .NET
+
+on:
+  push:
+    branches: [ dev, master ]
+  pull_request:
+    branches: [ dev, master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout repo and submodules
+      uses: actions/checkout@v2
+      with:
+        submodules: recursive
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v1
+      with:
+        dotnet-version: 3.1.x
+    - name: Restore dependencies
+      run: dotnet restore
+    - name: Build
+      run: dotnet build --no-restore
+    - name: Test
+      run: dotnet test --no-build --verbosity normal

Uchu.Core/Config/UchuConfiguration.cs

@@ -144,7 +144,7 @@ public class ServerDllSource
         /// <summary>
         /// The path to the Uchu.Instance DLL
         /// </summary>
-        [XmlElement] public string Instance { get; set; } = "Uchu.Instance.dll";
+        [XmlElement] public string Instance { get; set; } = "Enter path to Uchu.Instance.dll";
 
         /// <summary>
         /// The path to the script source DLLs

Uchu.Core/Database/UchuContext.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Threading.Tasks;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.ChangeTracking;
 using Uchu.Core.Providers;
 
 namespace Uchu.Core
@@ -60,6 +61,11 @@ public UchuContext()
             }
         }
 
+        public EntityEntry Entry(object entry)
+        {
+            return ContextBase.Entry(entry);
+        }
+
         public async Task EnsureUpdatedAsync()
         {
             await ContextBase.EnsureUpdatedAsync().ConfigureAwait(false);

Uchu.Master/MasterServer.cs

@@ -218,6 +218,8 @@ private static async Task ConfigureAsync()
             {
                 LogQueue.Config = Config = new UchuConfiguration();
 
+                Config.DllSource.ScriptDllSource.Add("Enter path to Uchu.StandardScripts.dll");
+
                 var backup = File.CreateText("config.default.xml");
 
                 serializer.Serialize(backup, Config);
@@ -265,10 +267,24 @@ private static async Task ConfigureAsync()
 
             if (!File.Exists(DllLocation))
             {
-                Logger.Error("Could not find file specified in DllSource -> Instance in config.xml.");
-                throw new FileNotFoundException("Could not find Instance file.");
+                throw new FileNotFoundException("Could not find file specified in <Instance> under <DllSource> in config.xml.");
             }
 
+            var validScriptPackExists = Config.DllSource.ScriptDllSource.Exists(scriptPackPath =>
+            {
+                if (File.Exists(scriptPackPath))
+                    return true;
+
+                Logger.Warning($"Could not find script pack at {scriptPackPath}");
+                return false;
+            });
+
+            if (!validScriptPackExists)
+            {
+                throw new FileNotFoundException("No valid <ScriptDllSource> specified under <DllSource> in config.xml.\n"
+                                                + "Without Uchu.StandardScripts.dll, Uchu cannot function correctly.");
+            }
+
             foreach (var scriptPackPath in Config.DllSource.ScriptDllSource)
             {
                 if (!File.Exists(scriptPackPath))

Uchu.World/Objects/Components/Player/MissionInventoryComponent.cs

@@ -317,7 +317,7 @@ private async Task<MissionInstance> AddMissionAsync(int missionId, GameObject ga
         /// <param name="mission"></param>
         /// <returns><c>true</c> if the player can accept this mission, <c>false</c> otherwise</returns>
         public bool CanAccept(MissionInstance mission) => 
-            (mission.Repeatable || !HasMission(mission.MissionId)) 
+            (mission.CanRepeat || !HasMission(mission.MissionId)) 
             && MissionParser.CheckPrerequiredMissions(mission.PrerequisiteMissions, AllMissions);
 
         /// <summary>
@@ -373,6 +373,13 @@ private async Task RespondToMissionAsync(int missionId, GameObject missionGiver,
                 return;
             }
 
+            // Repeat the mission if it is repeatable, such as a daily mission.
+            if (mission.CanRepeat)
+            {
+                await mission.RestartAsync();
+                return;
+            }
+
             // Player is responding to an active mission.
             if (!mission.Completed)
             {

Uchu.World/Objects/Components/Server/MissionGiverComponent.cs

@@ -3,9 +3,7 @@
 using System.Linq;
 using Uchu.Core;
 using Uchu.Core.Client;
-using Uchu.Core.Resources;
 using Uchu.World.Client;
-using Uchu.World.Systems.Missions;
 
 namespace Uchu.World
 {
@@ -94,7 +92,7 @@ public void HandleInteraction(Player player)
                     var playerMission = missionInventory.GetMission(questId);
 
                     // If the player is ready to hand this mission in, allow them to complete the mission
-                    if (playerMission != default && (component.AcceptsMission ?? false) && playerMission.State == MissionState.ReadyToComplete)
+                    if (playerMission != default && (component.AcceptsMission ?? false) && (playerMission.State == MissionState.ReadyToComplete || playerMission.State == MissionState.CompletedReadyToComplete))
                     {
                             missionInventory.MessageOfferMission(questId, GameObject);
                             return;
@@ -118,17 +116,15 @@ public void HandleInteraction(Player player)
                                 return;
                             case MissionState.CompletedActive:
                                 // If this is an active mission show the offer popup again for information
-                                player.GetComponent<MissionInventoryComponent>().MessageOfferMission(
-                                    playerMission.MissionId,
-                                    GameObject
-                                );
-                                continue;
+                                missionInventory.MessageOfferMission(playerMission.MissionId, GameObject);
+                                return;
                             case MissionState.ReadyToComplete:
+                            case MissionState.CompletedReadyToComplete:
                             case MissionState.Unavailable:
                             case MissionState.Completed:
-                            case MissionState.CompletedReadyToComplete:
-                                // Any other missions are skipped
-                                continue;
+                                // Allow the mission if it is repeatable and the cooldown period has passed.
+                                if (!playerMission.CanRepeat) continue;
+                                break;
                             default:
                                 throw new ArgumentOutOfRangeException(
                                     nameof(playerMission.State), $"{playerMission.State} is not a valid {nameof(MissionState)}"
@@ -143,6 +139,7 @@ public void HandleInteraction(Player player)
 
                     // Set the mission as the mission to offer.
                     // The mission is not offered directly in cases where an Available mission comes up before a ReadyToComplete mission.
+                    if (questIdToOffer != default) continue;
                     questIdToOffer = questId;
                 }
 

Uchu.World/Systems/Missions/MissionInstance.cs

@@ -181,6 +181,16 @@ public class MissionInstance
         public int RewardItem4RepeatableCount { get; private set; }
         #endregion template
 
+        /// <summary>
+        /// Whether the mission is part of mission of the day
+        /// </summary>
+        public bool InMissionOfTheDay { get; private set; }
+
+        /// <summary>
+        /// Cooldown time for repeating the mission.
+        /// </summary>
+        public long CooldownTime { get; private set; }
+
         #region instance
         /// <summary>
         /// The player that started this mission
@@ -229,6 +239,12 @@ public class MissionInstance
         /// <returns><c>true</c> if completed, <c>false</c> otherwise</returns>
         public bool Completed => Tasks.All(t => t.Completed);
 
+        /// <summary>
+        /// Checks if this mission is can be repeated and the cooldown time is satisfied.
+        /// </summary>
+        /// <returns><c>true</c> if can be repeated right now, <c>false</c> otherwise</returns>
+        public bool CanRepeat => IsMission && State == MissionState.Completed && (Repeatable || InMissionOfTheDay) && (LastCompletion == default || LastCompletion + (CooldownTime * 60) <= DateTimeOffset.Now.ToUnixTimeSeconds());
+
         #endregion properties
         static MissionInstance()
         {
@@ -291,6 +307,14 @@ private async Task LoadTemplateAsync()
             RewardCurrency = mission.Rewardcurrency ?? 0;
             RewardCurrencyRepeatable = mission.Rewardcurrencyrepeatable ?? 0;
             RewardScore = mission.LegoScore ?? 0;
+            Repeatable = mission.Repeatable ?? false;
+            InMissionOfTheDay = mission.InMOTD ?? false;
+            CooldownTime = mission.CooldownTime ?? 0;
+            if (InMissionOfTheDay && CooldownTime == 0)
+            {
+                // Prevents infinite loop of getting and completing daily quest. ~22 hour timer is used by other daily quests.
+                CooldownTime = 1300;
+            }
 
             // Emotes
             RewardEmote1 = mission.Rewardemote ?? -1;
@@ -396,6 +420,28 @@ public async Task StartAsync()
 
             State = MissionState.Active;
 
+            await NotifyClientStartAsync();
+        }
+
+        /// <summary>
+        /// Restarts this mission instance and notifies the client
+        /// </summary>
+        public async Task RestartAsync()
+        {
+            State = MissionState.CompletedActive;
+            foreach (var missionTask in Tasks)
+            {
+                missionTask.Restart();
+            }
+
+            await NotifyClientStartAsync();
+        }
+
+        /// <summary>
+        /// Notifies the client of starting the mission
+        /// </summary>
+        private async Task NotifyClientStartAsync()
+        {
             MessageNotifyMission();
             MessageMissionTypeState(MissionLockState.New);
 
@@ -582,7 +628,9 @@ public async Task SoftCompleteAsync()
         {
             if (IsMission)
             {
-                UpdateMissionState(MissionState.ReadyToComplete);
+                UpdateMissionState(State == MissionState.CompletedActive
+                    ? MissionState.CompletedReadyToComplete
+                    : MissionState.ReadyToComplete);
                 return;
             }
 

Uchu.World/Systems/Missions/MissionTaskInstance.cs

@@ -212,5 +212,13 @@ protected async Task CheckMissionCompletedAsync()
             if (Mission.Completed)
                 await Mission.SoftCompleteAsync();
         }
+
+        /// <summary>
+        /// Restarts the task status.
+        /// </summary>
+        public void Restart()
+        {
+            this.Progress = new List<float>();
+        }
     }
 }