public static HRTimer create(TimerType type)
        {

            HRTimer timer = null;

            switch (type)
            {

                case TimerType.DEFAULT:
                    {
                        timer = new DefaultTimer();
                        break;
                    }
                case TimerType.MULTI_MEDIA:
                    {

                        timer = new MultiMediaTimer();
                        break;
                    }
                case TimerType.TIMER_QUEUE:
                    {
                        timer = new TimerQueueTimer();
                        break;
                    }

            }

            return (timer);
        }

        public async Task<IHttpActionResult> PutTimerType(int id, TimerType timerType)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            if (id != timerType.TimerTypeID)
            {
                return BadRequest();
            }

            db.Entry(timerType).State = EntityState.Modified;

            try
            {
                await db.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!TimerTypeExists(id))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }

            return StatusCode(HttpStatusCode.NoContent);
        }

 public Timer CreateTimer(float duration, TimerType type = TimerType.Once, int times = -1)
 {
     ++timerid;
     Timer t = new Timer(duration, timerid, type, times);
     timers.Add(timerid, t);
     return t;
 }

		public Timer(float time, float time2)
		{
			Time1 = time;
			Time2 = time2;
			MyType = TimerType.RANDOM_TWO_CONSTANTS;
			Reset();
		}

 public static Timer Add(TimerType timerType, TimerCycles timerCycles, double timerLength)
 {
     string timerID = Guid.NewGuid().ToString();
     Timer timer = Add(timerID, timerType, timerCycles, timerLength);
     timer.TimerID = timerID;
     return timer;
 }

 public Event(object actor, int delay, TimerType type, string method, object[] arguments)
 {
     Actor = actor;
     Delay = delay;
     Type = type;
     Method = method;
     Arguments = arguments;
 }

 internal Timer(TimerType timerType, TimerCycles timerCycles, long startTick, double len)
 {
     Type = timerType;
     Cycles = timerCycles;
     StartTick = startTick;
     LastEventTick = startTick;
     Length = (long)(len * (double)HighResTimer.TicksPerSecond);
     Paused = false;
 }

 public Timer(float duration, int timerId, TimerType type = TimerType.Once, int times = -1)
 {
     countDown = 0.0f;
     this.duration = duration;
     this.timerId = timerId;
     this.type = type;
     state = Phase.NeverStart;
     this.times = times;
 }

 public static ITimer GetTimer(TimerType timerType)
 {
     switch (timerType)
     {
         case TimerType.Inverted:
             return new FwTimer(1, TimerType.Inverted);
         default:
             return new FwTimer(1, TimerType.Normal);
     }
 }

 public Timer(double duration, TimerType timerType, string parameter, bool failContract)
     : base("")
 {
     this.duration = duration;
     this.timerType = timerType;
     this.parameter = parameter;
     this.fakeFailures = !failContract;
     
     disableOnStateChange = false;
 }

	public TimerElement (string text, float duration, TimerType type, System.Action onEnd=null) {
		Text = text;
		this.duration = duration
		#if FAST_TIME
		* 0.1f
		#endif
		;
		this.type = type;
		this.onEnd = onEnd;
		Reset ();
	}

 public FwTimer()
 {
     // to be sure everything is initialized
     _running = false;
     _interval = DEFAULT_INTERVAL;
     _timer = new Timer {AutoReset = false};
     _timer.Elapsed += OnElapse;
     _status = TimerLogStatus.Disabled;
     _type = TimerType.Inverted;
     _startTime = DateTime.Now;
     _endTime = _startTime.AddSeconds(_interval);
 }

        public async Task<IHttpActionResult> PostTimerType(TimerType timerType)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            db.TimerTypes.Add(timerType);
            await db.SaveChangesAsync();

            return CreatedAtRoute("DefaultApi", new { id = timerType.TimerTypeID }, timerType);
        }

        public void SetAffect(string name, Mob afflicted, Mob owner, TimerType durationType, int duration, bool tickmethod, bool endmethod)
        {
            Name = name;
            HandlingName = name.ToLower().Trim();
            Duration = duration;
            DurationType = durationType;
            Owner = owner;
            Afflicted = afflicted;
            Level = Owner.Level;

            CanHasTickMethod = tickmethod;
            CanHasEndMethod = endmethod;
        }

		static public void StartTimer (TimerType which)
		{
			timer_start [(int) which] = DateTime.Now;
		}

		public void Stop (TimerType type)
		{
			if (timers != null) {
				timers[(int) type].Stop ();
			}
		}

		public void Start (TimerType type)
		{
			if (timers != null) {
				var sw = new Stopwatch ();
				timers[(int) type] = sw;
				sw.Start ();
			}
		}

		private void SetRepeatThumbAreaTimer ()
		{
			timer.Enabled = false;
			timer.Interval = 50;
			timer_type = TimerType.RepeatThumbArea;
			timer.Enabled = true;
		}

		private void SetHoldThumbAreaTimer ()
		{
			timer.Enabled = false;
			timer.Interval = 200;
			timer_type = TimerType.HoldThumbArea;
			timer.Enabled = true;
		}

		private void SetRepeatButtonTimer ()
		{
			timer.Enabled = false;
			timer.Interval = 50;
			timer_type = TimerType.RepeatButton;
			timer.Enabled = true;
		}