protected TimeOfDayChangedAction(SerializationInfo info, StreamingContext context)
     : base(info, context)
 {
     v3dLayer = EditorManager.Project.Scene.MainLayer as V3DLayer;
       oldConfig = (TimeOfDay)info.GetValue("oldConfig", typeof(TimeOfDay));
       newConfig = (TimeOfDay)info.GetValue("newConfig", typeof(TimeOfDay));
 }

        public static string GetOrderList(List<int> listDishes, TimeOfDay tod)
        {
            var output = string.Empty;
            listDishes = listDishes.OrderBy(x => x).ToList();
            var last = -1;

            foreach (var dishType in listDishes)
            {
                if (dishType == last)
                    continue;
                last = dishType;

                Dish dish = rest.FindDish(tod, (DishType)dishType);
                if (dish == null)
                {
                    output += "error,";
                    continue;
                }

                var quantity = GetValidQuantity(listDishes, dish);
                if (quantity == -1)
                {
                    Console.WriteLine("Invalid quantity.");
                    break;
                }

                // Concatenating the output and adding the quantity if necessary
                output += quantity > 1 ? rest.FindFood(dish.FoodID).Name + "(x" + quantity + ")," : rest.FindFood(dish.FoodID).Name + ",";
            }

            return output;
        }

 public Filter(bool exclude, FieldIndex fieldIndex, TimeOfDay value, FilterTest test)
 {
     Exclude_ = exclude;
     FieldIndex_ = fieldIndex;
     Value_ = value.DayMinutes;
     Test_ = test;
 }

        public static TimeSpan GetTimeBetween(TimeOfDay first, TimeOfDay next)
        {
            var times = new Dictionary<TimeOfDay, DateTime>
            {
                [TimeOfDay.Breakfast] = new DateTime(2015, 2, 1, MedicineWithDoses.BreakfastHour, 0, 0),
                [TimeOfDay.Lunch] = new DateTime(2015, 2, 1, MedicineWithDoses.LunchHour, 0, 0),
                [TimeOfDay.Dinner] = new DateTime(2015, 2, 1, MedicineWithDoses.DinnerHour, 0, 0)
            };

            var firstIdx = (int)first;
            var nextIdx = (int)next;

            if (firstIdx < nextIdx)
            {
                return times[next] - times[first];
            }
            else if (firstIdx > nextIdx)
            {
                return times[next] - times[first].DayBefore();
            }
            else
            {
                return TimeSpan.FromDays(1).Subtract(TimeSpan.FromSeconds(1));
            }



        }

 public void CanConstructTimeOfDayFrom12HoursAndMinutes()
 {
     TimeOfDay time = new TimeOfDay(11, 59, Meridiem.PM);
     const long expected = 23 * TimeSpan.TicksPerHour +
                           59 * TimeSpan.TicksPerMinute;
     Assert.Equal(expected, time.Ticks);
 }

    // Update is called once per frame
    void Update()
    {
        sunMoonTransform[0].Rotate(new Vector3(_degreeRotation, 0, 0) * Time.deltaTime);
        //		if (moon_light.transform.position.y < 0) {
        //			moon_light.enabled = false;
        //			moon_spot_light.enabled = false;
        //		} else {
        //			moon_light.enabled = true;
        //			moon_spot_light.enabled = true;
        //		}
        //		if (sun_light.transform.position.y < 0) {
        //			sun_light.enabled = false;
        //			sun_spot_light.enabled = false;
        //		} else {
        //			sun_light.enabled = true;
        //			sun_spot_light.enabled = true;
        //		}

        _timeOfDay += Time.deltaTime;

        if (_timeOfDay > _dayCycleInSeconds) _timeOfDay -= _dayCycleInSeconds;

        if (_timeOfDay > sunRise &&
            _timeOfDay < sunSet &&
            RenderSettings.skybox.GetColor("_Tint")[3] < 1) {
            _tod = GameTime.TimeOfDay.SunRise;
            updateSkyBox();
        } else if (_timeOfDay > sunSet && RenderSettings.skybox.GetColor("_Tint")[3] > 0) {
            _tod = GameTime.TimeOfDay.SunSet;
            updateSkyBox();
        } else {
            _tod = GameTime.TimeOfDay.Idle;
        }
    }

 public Dish(int dishID, int foodID, DishType dishType, TimeOfDay timeOfDay)
 {
     DishID = dishID;
     FoodID = foodID;
     DishType = dishType;
     TimeOfDay = timeOfDay;
 }

        public void MultipleTypeCustomInstanceAnnotationsOnErrorShouldRoundtrip()
        {
            var originalInt = new KeyValuePair<string, ODataValue>("int.error", new ODataPrimitiveValue(1));
            var originalDouble = new KeyValuePair<string, ODataValue>("double.error", new ODataPrimitiveValue(double.NaN));
            DateTimeOffset dateTimeOffset = new DateTimeOffset(2012, 10, 10, 12, 12, 59, new TimeSpan());
            var originalDateTimeOffset = new KeyValuePair<string, ODataValue>("DateTimeOffset.error", new ODataPrimitiveValue(dateTimeOffset));
            Date date = new Date(2014, 12, 12);
            var originalDate = new KeyValuePair<string, ODataValue>("Date.error", new ODataPrimitiveValue(date));
            TimeOfDay time = new TimeOfDay(10, 12, 3, 9);
            var originaltime = new KeyValuePair<string, ODataValue>("TimeOfDay.error", new ODataPrimitiveValue(time));
            TimeSpan timeSpan = new TimeSpan(12345);
            var originalTimeSpan = new KeyValuePair<string, ODataValue>("TimeSpan.error", new ODataPrimitiveValue(timeSpan));
            GeographyPoint geographyPoint = GeographyPoint.Create(32.0, -100.0);
            var originalGeography = new KeyValuePair<string, ODataValue>("Geography.error", new ODataPrimitiveValue(geographyPoint));
            var originalNull = new KeyValuePair<string, ODataValue>("null.error", new ODataNullValue());

            var complexValue = new ODataComplexValue
            {
                TypeName = "ns.ErrorDetails",
                Properties = new[] { new ODataProperty { Name = "ErrorDetailName", Value = "inner property value" } }
            };
            var originalComplex = new KeyValuePair<string, ODataValue>("sample.error", complexValue);

            var error = this.WriteThenReadErrorWithInstanceAnnotation(originalInt, originalDouble, originalDate, originalDateTimeOffset, originaltime, originalTimeSpan, originalGeography, originalNull, originalComplex);

            var annotation = RunBasicVerificationAndGetAnnotationValue("int.error", error);
            annotation.Should().BeOfType<ODataPrimitiveValue>();
            annotation.As<ODataPrimitiveValue>().Value.Should().Be(1);

            annotation = RunBasicVerificationAndGetAnnotationValue("double.error", error);
            annotation.Should().BeOfType<ODataPrimitiveValue>();
            annotation.As<ODataPrimitiveValue>().Value.Should().Be(double.NaN);

            annotation = RunBasicVerificationAndGetAnnotationValue("Date.error", error);
            annotation.Should().BeOfType<ODataPrimitiveValue>();
            annotation.As<ODataPrimitiveValue>().Value.Should().Be(date);

            annotation = RunBasicVerificationAndGetAnnotationValue("DateTimeOffset.error", error);
            annotation.Should().BeOfType<ODataPrimitiveValue>();
            annotation.As<ODataPrimitiveValue>().Value.Should().Be(dateTimeOffset);

            annotation = RunBasicVerificationAndGetAnnotationValue("TimeOfDay.error", error);
            annotation.Should().BeOfType<ODataPrimitiveValue>();
            annotation.As<ODataPrimitiveValue>().Value.Should().Be(time);

            annotation = RunBasicVerificationAndGetAnnotationValue("TimeSpan.error", error);
            annotation.Should().BeOfType<ODataPrimitiveValue>();
            annotation.As<ODataPrimitiveValue>().Value.Should().Be(timeSpan);

            annotation = RunBasicVerificationAndGetAnnotationValue("Geography.error", error);
            annotation.Should().BeOfType<ODataPrimitiveValue>();
            annotation.As<ODataPrimitiveValue>().Value.Should().Be(geographyPoint);

            annotation = RunBasicVerificationAndGetAnnotationValue("null.error", error);
            annotation.Should().BeOfType<ODataNullValue>();

            annotation = RunBasicVerificationAndGetAnnotationValue("sample.error", error);
            annotation.Should().BeOfType<ODataComplexValue>();
            annotation.As<ODataComplexValue>().Properties.First().Value.Should().Be("inner property value");
        }

 public void CanConstructTimeOfDayFrom24HoursAndMinutesAndSeconds()
 {
     TimeOfDay time = new TimeOfDay(23, 59, 59);
     const long expected = 23 * TimeSpan.TicksPerHour +
                           59 * TimeSpan.TicksPerMinute +
                           59 * TimeSpan.TicksPerSecond;
     Assert.Equal(expected, time.Ticks);
 }

        /// <summary>
        /// Looks at a supplied time of day and figures out what TimeOfDayState needs to be returned that matches the time of day.
        /// </summary>
        /// <param name="currentTime">The current time.</param>
        /// <returns>
        /// Returns an instance of ITimeOfDayState that represents the current time of day in the game.
        /// </returns>
        internal TimeOfDayState GetTimeOfDayState(DateTime? currentTime = null)
        {
            TimeOfDay time = new TimeOfDay();
            time.Hour = currentTime.Value.Hour;
            time.Minute = currentTime.Value.Minute;

            return this.GetTimeOfDayState(time);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Session" /> class.
        /// </summary>
        /// <param name="timeOfDay">The time of day.</param>
        public Session(TimeOfDay timeOfDay)
        {
            this._talks = new List<Talk>();
            this._timeOfDay = timeOfDay;

            // Total possible duration can be 3 hrs if it is a morning session; 4 hrs otherwise
            this.totalPossibleDuration = timeOfDay == TimeOfDay.Morning ? 60 * 3 : 60 * 4;
        }

        public void CanAddPositiveTime()
        {
            TimeOfDay startTime = new TimeOfDay(12, 0);
            TimeOfDay actual = startTime.AddHours(13);
            TimeOfDay expected = new TimeOfDay(1, 0);

            Assert.Equal(expected, actual);
        }

        public void CanCalculateDuration_OverMidnight()
        {
            TimeOfDay startTime = new TimeOfDay(23, 0);
            TimeOfDay endTime = new TimeOfDay(1, 0);

            TimeSpan duration = TimeOfDay.CalculateDuration(startTime, endTime);
            Assert.Equal(TimeSpan.FromHours(2), duration);
        }

        public Dish FindDish(TimeOfDay timeOfDay, DishType dishType)
        {
            foreach (var dish in dishList)
                if (dish.TimeOfDay == timeOfDay && dish.DishType == dishType)
                    return dish;

            return null;
        }

        public void CanCalculateDuration_Normal()
        {
            TimeOfDay startTime = new TimeOfDay(10, 0);
            TimeOfDay endTime = new TimeOfDay(12, 0);

            TimeSpan duration = endTime - startTime;
            Assert.Equal(TimeSpan.FromHours(2), duration);
        }

 // Handle switching for the time of day
 void TimeChanged(TimeOfDay newTime)
 {
     Flip ();
     if (newTime == ForceRightWhen) {
         forceVec= force;
     } else {
         forceVec= -force;
     }
 }

        public void CanCompareTimes_Object_Equal()
        {
            var t1 = new TimeOfDay(0, 0);
            var t2 = new TimeOfDay(0, 0);

            var c = t1.CompareTo((object)t2);

            Assert.Equal(0, c);
        }

        public void CanCompareTimes_Static_After()
        {
            var t1 = new TimeOfDay(0, 1);
            var t2 = new TimeOfDay(0, 0);

            var c = TimeOfDay.Compare(t1, t2);

            Assert.Equal(1, c);
        }

        public void CanGetDateTimeFromTimeOnDate()
        {
            Date date = new Date(2000, 12, 31);
            TimeOfDay time = new TimeOfDay(23, 59, 59);
            DateTime dt = time.On(date);

            DateTime expected = new DateTime(2000, 12, 31, 23, 59, 59);
            Assert.Equal(expected, dt);
        }

 public void Schedule(string jobName, IJob job, TimeSpan interval, TimeOfDay startTime, IDictionary<string, string> jobData)
 {
     lock (_lock)
     {
         var schedule = new Schedule(Instance, jobName, job, interval, startTime, jobData);
         _schedules.Add(jobName, schedule);
         schedule.Start();
     }
 }