Commit: 19 - NeoFT.Workshop (svn)

FreeTrainの進化系を目指す

Commit MetaInfo

• Revision: 19 (tree)
• Time: 2014-04-02 00:32:38
• Author: c477

Log Message

Test and Debug for ConditionedResource and related classes.

Change Summary

• modified: trunk/NeoFT.suo
• modified: trunk/core/core/view/ConditionedResourceFactory.cs
• modified: trunk/core/core/view/ConditionedResource.cs
• modified: trunk/core/core/schedule/IClockEventQueue.cs
• modified: trunk/core/core/schedule/SimpleTimeTickConverter.cs
• modified: trunk/core/core/schedule/DateTime.cs
• modified: trunk/core/core/schedule/Time.cs
• modified: trunk/core/core/schedule/PrimitiveConditions.cs
• modified: trunk/core/core/schedule/ConditionValueExtracter.cs
• modified: trunk/core/core/schedule/Calendar.cs
• modified: trunk/TestLauncher/test/ClockTest.cs

Incremental Difference

--- trunk/core/core/view/ConditionedResourceFactory.cs	(revision 18)
+++ trunk/core/core/view/ConditionedResourceFactory.cs	(revision 19)
@@ -29,17 +29,18 @@
             T _default = callback(dnode.IsNull ? resource : dnode);
             ParamsReader conds = resource[CONDITION_NODE];
 #if DEBUG
-            debug_indent = "";
-            Debug.WriteLine("default value = " + _default);
+            //debug_indent = "";
+            //Debug.WriteLine("default value = " + _default);
 #endif
             if (conds.IsNull) {
-                Debug.WriteLine("NO condition");
-                return new ConditionedResource<T>(_default);
+                ConditionedResource<T> ret = new ConditionedResource<T>(_default);
+                //Debug.WriteLine("+condition:" + ret);
+                return ret;
             } else {
                 NestedConditionsResouceRoot<T> ret = new NestedConditionsResouceRoot<T>(_default);
-                Debug.WriteLine("+condition:"+ret);
+                //Debug.WriteLine("+condition:"+ret);
                 foreach (ParamsReader child in conds.Each) {
-                    ConditionedResource<T> temp = LoadChildConditions(child, callback);
+                    ConditionedResource<T> temp = LoadChildConditions(_default, child, callback);
                     ret.AddChild(temp);
                 }
                 return ApplyOptimization<T>(ret);
@@ -47,29 +48,32 @@
         }
 
         #region private functions
-        private static ConditionedResource<T> LoadChildConditions<T>(ParamsReader resource, ResourceParser<T> callback){
+        private static ConditionedResource<T> LoadChildConditions<T>(T val_defult, ParamsReader resource, ResourceParser<T> callback){
             ISceneCondition sc = GetConditionFor(resource);
-            ParamsReader dnode = resource[VALUE_NODE];
-            T _default = callback(dnode.IsNull ? resource : dnode);
 #if DEBUG
-            string indent_saved = debug_indent;
-            debug_indent += "  ";
-            Debug.WriteLine(debug_indent+"value=" + _default);
+            //string indent_saved = debug_indent;
+            //debug_indent += "  ";
 #endif
             ParamsReader conds = resource[CONDITION_NODE];
             if (conds.IsNull) {
-                return new SingleConditionResouce<T>(sc,_default);
+                ParamsReader dnode = resource[VALUE_NODE];
+                T _default = callback(dnode.IsNull ? resource : dnode);
+                //Debug.WriteLine(debug_indent + "value=" + _default);
+                SingleConditionResouce<T> ret = new SingleConditionResouce<T>(sc, _default);
+                //Debug.WriteLine(debug_indent + "+condition:" + ret);
+                return ret;
             } else {
+                ParamsReader dnode = resource[VALUE_NODE];
+                T _default = dnode.IsNull ? val_defult : callback(dnode);
+                //Debug.WriteLine(debug_indent + "value=" + _default);
                 NestedConditionsResouce<T> ret = new NestedConditionsResouce<T>(sc, _default);
-#if DEBUG
-                Debug.WriteLine(debug_indent + "+condition:" + ret);
-#endif
+                //Debug.WriteLine(debug_indent + "+condition:" + ret);
                 foreach (ParamsReader child in conds.Each) {
-                    ConditionedResource<T> temp = LoadChildConditions(child, callback);
+                    ConditionedResource<T> temp = LoadChildConditions(_default, child, callback);
                     ret.AddChild(temp);
                 }
 #if DEBUG
-                debug_indent = indent_saved;
+                //debug_indent = indent_saved;
 #endif
                 return ApplyOptimization<T>(ret);
             }

--- trunk/core/core/view/ConditionedResource.cs	(revision 18)
+++ trunk/core/core/view/ConditionedResource.cs	(revision 19)
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
+using System.Diagnostics;
 
 namespace nft.core.view
 {    
@@ -24,6 +25,10 @@
             res = Default;
             return true;
         }
+
+        public override string ToString() {
+            return GetType().Name;
+        }
     }
 
     internal class SingleConditionResouce<T> : ConditionedResource<T>
@@ -41,6 +46,10 @@
                 return false;
             }
         }
+
+        public override string ToString() {
+            return String.Format("{0}[when={1}]", GetType().Name, Condition);
+        }
     }
 
     internal class NestedConditionsResouceRoot<T> : ConditionedResource<T>
@@ -53,6 +62,7 @@
 
         internal protected override bool Choose(ISceneParams p, ref T res) {
             foreach (ConditionedResource<T> cc in children) {
+                //Debug.WriteLine("  enter "+ cc);
                 if (cc.Choose(p, ref res)) {
                     return true;
                 }
@@ -64,6 +74,10 @@
         public void AddChild(ConditionedResource<T> child) {
             children.Add(child);
         }
+
+        public override string ToString() {
+            return String.Format("{0}", GetType().Name);
+        }
     }
 
     internal class NestedConditionsResouce<T> : NestedConditionsResouceRoot<T>
@@ -81,5 +95,9 @@
                 return false;
             }
         }
+
+        public override string ToString() {
+            return String.Format("{0}[when={1}]", GetType().Name, Condition);
+        }
     }
 }

--- trunk/core/core/schedule/IClockEventQueue.cs	(revision 18)
+++ trunk/core/core/schedule/IClockEventQueue.cs	(revision 19)
@@ -32,7 +32,7 @@
 		/// <summary>
 		/// Dispatch events earlier than the specified Time 'To'
 		/// </summary>
-		/// <param name="to"></param>
+        /// <param name="clock"></param>
 		void Dispatch( Clock clock );
 
 	}

--- trunk/core/core/schedule/SimpleTimeTickConverter.cs	(revision 18)
+++ trunk/core/core/schedule/SimpleTimeTickConverter.cs	(revision 19)
@@ -65,14 +65,14 @@
         public Date ToDate(long ticks) {
             long d = ticks/TicksIn1Day;
             long y,m;
-            d = Math.DivRem(d, DaysIn1Month, out m);
-            m = Math.DivRem(m, MonthsIn1Year, out y);
+            m = Math.DivRem(d, DaysIn1Month, out d);
+            y = Math.DivRem(m, MonthsIn1Year, out m);
             return new Date((int)y, (int)m+1, (int)d+1);
         }
 
         public TimeOfDay ToTimeOfDay(long ticks) {
-            long m;
-            long s = Math.DivRem(ticks, TicksIn1Minute, out m);
+            long s;
+            long m = Math.DivRem(ticks, TicksIn1Minute, out s);
             s = 60 * s / TicksIn1Minute; // Normarize
             long h = Math.DivRem(m, MinutesIn1Hour, out m);
             h = h % HoursIn1Day;
@@ -102,8 +102,8 @@
         }
 
         public int GetMonth(long ticks) {
-            long m = ticks / TicksIn1Month;
-            return 1+(int)(m % MonthsIn1Year);
+            long m = ticks % TicksIn1Year;
+            return 1+(int)(m / TicksIn1Month);
         }
 
         public int GetYear(long ticks) {

--- trunk/core/core/schedule/DateTime.cs	(revision 18)
+++ trunk/core/core/schedule/DateTime.cs	(revision 19)
@@ -38,6 +38,10 @@
             }
         }
 
+        public override string ToString() {
+            return string.Format("Date:[{0}/{1}/{2}]", Year, Month, Day);
+        }
+
         #region IComparable メンバ
         public int CompareTo(Date other) {
             return Math.Sign(this.SerialValue - other.SerialValue);
@@ -122,6 +126,10 @@
                 return (Hour << 12) + (Minute << 6) + Second;
             }
         }
+
+        public override string ToString() {
+            return string.Format("TimeOfDay:[{0,2:d}:{1,2:d}:{2,2:d}]",Hour,Minute,Second);
+        }
         
         #region IComparable メンバ
         public int CompareTo(TimeOfDay other) {

--- trunk/core/core/schedule/Time.cs	(revision 18)
+++ trunk/core/core/schedule/Time.cs	(revision 19)
@@ -128,6 +128,7 @@
 
         public Date ToDate() {
             return Converter.ToDate(ticks);
+            //return new Date(Year,Month,Day);
         }
 
         /// <summary>

--- trunk/core/core/schedule/PrimitiveConditions.cs	(revision 18)
+++ trunk/core/core/schedule/PrimitiveConditions.cs	(revision 19)
@@ -249,6 +249,9 @@
 
         protected abstract bool IsMatchCore(ISceneParams p);
 
+        public override string ToString() {
+            return String.Format("{0}:({1}/{2}/{3})", GetType().Name, ConditionType, GroupName, ConditionName); 
+        }
     }
 
     public abstract class ComparebleSceneCondition : CacheableSceneCondition {

--- trunk/core/core/schedule/ConditionValueExtracter.cs	(revision 18)
+++ trunk/core/core/schedule/ConditionValueExtracter.cs	(revision 19)
@@ -49,7 +49,7 @@
         }
 
         public override IComparable GetTestValue(ISceneParams p) {
-            return p.Time.Month;
+            return (long)p.Time.Month;
         }
     }
 
@@ -90,11 +90,10 @@
         }
     }
 
-    public class ScaleConditionValueExtracter : LongConditionValueExtracter {
-        public ScaleConditionValueExtracter()
-            : base(ConditionTypes.Scale) {
+    public class ScaleConditionValueExtracter : IConditionValueExtracter {
+        public ScaleConditionValueExtracter(){            
         }
-        public override IComparable GetTestValue(ISceneParams p) {
+        public IComparable GetTestValue(ISceneParams p) {
             return p.Scaler.Value;
         }
 

--- trunk/core/core/schedule/Calendar.cs	(revision 18)
+++ trunk/core/core/schedule/Calendar.cs	(revision 19)
@@ -68,8 +68,8 @@
                 ParamsReader match = r2["match"];
                 if(match.IsNull){
                     string v_from = r2["from"].InnerText;
-                    string v_to = r2["to"].InnerText;
-                    PrimitiveConditions.CreateSceneConditionFromDateFormat(grp_name, cname, ctype, format, v_from, v_to );
+                    string v_until = r2["until"].InnerText;
+                    PrimitiveConditions.CreateSceneConditionFromDateFormat(grp_name, cname, ctype, format, v_from, v_until );
                 } else {
                     string v_match = match.InnerText;
                     PrimitiveConditions.CreateSceneConditionFromDateFormat(grp_name, cname, ctype, format, v_match);

--- trunk/TestLauncher/test/ClockTest.cs	(revision 18)
+++ trunk/TestLauncher/test/ClockTest.cs	(revision 19)
@@ -7,19 +7,83 @@
 using nft.util;
 using System.Diagnostics;
 using nft.core.schedule;
+using System.IO;
+using nft.framework.loader;
+using nft.core.view;
+using nft.framework.drawing;
 
 namespace nft.test.test {
-    class ClockTest {
+    class ClockTest {        
         [TestEntry]
-        public static void InitCalender() {
-            try {
-                GlobalModules.Initialize();
-            }catch(Exception ex){
-                Debug.WriteLine(ex.Message);
-                Debug.WriteLine(ex.StackTrace);
+        public static void InitCalendar() {
+            if (Calendar.ActiveCalendar != null) {
+                Debug.WriteLine("The calendar is already initialized.");
+                return;
             }
+            XmlDocument doc = XmlUtil.LoadFile(Path.Combine(Directories.AppBaseDir, "core_modules.xml"));
+            ParamsReader reader = new ParamsReader(doc.BaseURI, new XmlParamParser(doc));
+            ParamsReader root = reader["modules"];
+            foreach (ParamsReader cn in root.EnumChildren("module")) {
+                if (cn["name"].InnerText.Equals("Game Time Calendar")) {
+                    Debug.WriteLine("Initialize the calendar.");
+                    new Calendar(cn);
+                }
+            }
         }
 
+        [TestEntry(new object[]{new int[]{0,3,13,31}})]
+        public static void TestDateConversion(int[] years) {
+            ITimeTickConverter ttc = Calendar.ActiveCalendar.TimeTickConverter;
+            long day = ttc.DailyTicks;
+            long yer = ttc.YearlyTicksAve;
+            long mnt = ttc.MonthlyTicksAve;
+            int mcnt = (int)Math.Ceiling(yer / (double)mnt);
+            int dcnt = (int)Math.Ceiling(mnt / (double)day);
+            int erros = 0;
+            Debug.WriteLine(String.Format("{0} months per year, {1} days per month.", mcnt, dcnt));
+            for (int i = 0; i < years.Length; i++) {
+                Debug.WriteLine(String.Format("## Start loop for the {0}th year ##", years[i]));
+                for (int m = 1; m <= mcnt; m++) {
+                    for (int d = 1; d <= dcnt; d++) {
+                        Date date = new Date(years[i], m, d);
+                        Time time = Time.Create(date, ttc);
+                        Date dat2 = time.ToDate();
+                        if (!date.Equals(dat2)) {
+                            erros++;
+                            Debug.WriteLine(String.Format("Conversion Error: {0} -> {1}", date, dat2));
+                        }
+                    }
+                }
+            }
+            if(erros>0) throw new Exception(String.Format("Detect {0} conversion errors!",erros));
+        }
+
+        [TestEntry(new object[] { new int[] { 0, 31, 977, 4073 } })]
+        public static void TestTimeOfDayConversion(int[] days) {
+            ITimeTickConverter ttc = Calendar.ActiveCalendar.TimeTickConverter;
+            long day = ttc.DailyTicks;
+            long secs = ttc.MinutelyTicks;
+            int erros = 0;
+            for (int i = 0; i < days.Length; i++) {
+                Date offset = TimeLength.FromDays(ttc, days[i]).ToDate();
+                Debug.WriteLine(String.Format("## Start 24H loop for the {0} ##", offset));
+                for (int h = 0; h < 24; h++) {
+                    for (int m = 0; m < 60; m++) {
+                        for (int s = 0; s < secs; s++) {
+                            TimeOfDay tod = new TimeOfDay(h, m, s);
+                            Time time = Time.Create(offset, tod, ttc);
+                            TimeOfDay tod2 = time.GetTimeOfTheDay();
+                            if (!tod.Equals(tod2)) {
+                                erros++;
+                                Debug.WriteLine(String.Format("Conversion Error: {0} -> {1}", tod, tod2));
+                            }
+                        }
+                    }
+                }
+            }
+            if (erros > 0) throw new Exception(String.Format("Detect {0} conversion errors!", erros));
+        }
+
         [TestEntry]
         public static void TestClock() {
             Clock clock = Calendar.ActiveCalendar.CreateNewClock(new Date());
@@ -39,6 +103,44 @@
 
         }
 
+        [TestEntry]
+        public static void TestConditionedResource() {
+            XmlDocument doc = new XmlDocument();
+            doc.LoadXml(@"<root>
+<default>Apple</default>
+<condition when='winter'><value>Banana</value>
+  <condition when='night'>Orange</condition>
+</condition>
+<condition when='night'>
+  <condition when='summer'>Pinapple</condition>
+</condition>
+</root>");
+            ParamsReader reader = new ParamsReader("test", new XmlParamParser(doc.FirstChild));
+            ConditionedResource<String> res = ConditionedResourceFactory.LoadAsConditiondResources<String>(reader, ParseString );
+            ITimeTickConverter ttc = Calendar.ActiveCalendar.TimeTickConverter;
+            Date spring = new Date(1, 4, 6);
+            Date summer = new Date(1, 7, 10);
+            Date winter = new Date(1, 1, 5);
+            TimeOfDay night = new TimeOfDay(0, 0);
+            TimeOfDay day = new TimeOfDay(13, 30);
+            Debug.WriteLine("Spring,Day="+res[new TestParams(Time.Create(spring, day))]);
+            PrimitiveConditions.InvalidateCachedConditions();
+            Debug.WriteLine("Spring,Night=" + res[new TestParams(Time.Create(spring, night))]);
+            PrimitiveConditions.InvalidateCachedConditions();
+            Debug.WriteLine("Summer,Day=" + res[new TestParams(Time.Create(summer, day))]);
+            PrimitiveConditions.InvalidateCachedConditions();
+            Debug.WriteLine("Summer,Night=" + res[new TestParams(Time.Create(summer, night))]);
+            PrimitiveConditions.InvalidateCachedConditions();
+            Debug.WriteLine("Winter,Day=" + res[new TestParams(Time.Create(winter, day))]);
+            PrimitiveConditions.InvalidateCachedConditions();
+            Debug.WriteLine("Winter,Night=" + res[new TestParams(Time.Create(winter, night))]);
+
+        }
+
+        static private String ParseString(ParamsReader r) {
+            return r.InnerText;
+        }
+
         class ClockEventCallback {
             String msg;
             int n;
@@ -54,5 +156,19 @@
                 return n < 10;
             }
         }
+
+        class TestParams : ISceneParams {
+            private Time time;
+            public TestParams(Time t) {
+                time = t;
+                Debug.WriteLine("Time="+time);
+            }
+
+            public Time Time { get{ return time; }}
+
+            public object Weather { get { return null; }}
+
+            public Scaler Scaler { get {return Scaler.Default; }}
+        }
     }
 }