Tick now.
TODO: figure out how destructed spirits should
behave while we loop through handlers
@param {gui.Tick} tick
767578
function(tick) {
			var list = this._tempname.handlers[tick.type];
			if (list) {
				list.slice().forEach(function(handler) {
					handler.ontick(tick);
				});
			}
		}
807151
func Tick() {
	now := time.Now()
	timerHeapLock.Lock()

	for {
		if timerHeap.Len() <= 0 {
			break
		}

		nextFireTime := timerHeap.timers[0].fireTime
		//fmt.Printf(">>> nextFireTime %s, now is %s\n", nextFireTime, now)
		if nextFireTime.After(now) {
			break
		}

		t := heap.Pop(&timerHeap).(*Timer)

		callback := t.callback
		if callback == nil {
			continue
		}

		if !t.repeat {
			t.callback = nil
		}
		// unlock the lock to run callback, because callback may add more callbacks / timers
		timerHeapLock.Unlock()
		runCallback(callback)
		timerHeapLock.Lock()

		if t.repeat {
			// add Timer back to heap
			t.fireTime = t.fireTime.Add(t.interval)
			if !t.fireTime.After(now) { // might happen when interval is very small
				t.fireTime = now.Add(t.interval)
			}
			t.addseq = nextAddSeq
			nextAddSeq += 1
			heap.Push(&timerHeap, t)
		}
	}
	timerHeapLock.Unlock()
}
783914
function tick (a) {
			if (isStopped) return

			let playedTime = context.currentTime - initTime;
			let playedCount = playedTime * sampleRate;

			//if offset has changed - notify processor to provide a new piece of data
			if (lastCount - playedCount < samplesPerFrame) {
				let buf = fetch(samplesPerFrame)

				//send queued data chunk to buffer
				util.copy(buf, buffer, lastCount % buffer.length)

				//increase rendered count
				lastCount += samplesPerFrame;

				//if there is a holding pressure control - release it
				consume(samplesPerFrame)

				//call tick extra-time in case if there is a room for buffer
				//it will plan timeout, if none
				tick()
			}
			//else plan tick for the expected time of starving
			else {
				//time of starving is when played time reaches (last count time) - half-duration
				let starvingTime = (lastCount - samplesPerFrame) / sampleRate;
				let remainingTime = starvingTime - playedTime;
				setTimeout(tick, remainingTime * 1000)
			}
		}
707244
function(spirit) {
		var all = this._spirits;
		var key = spirit.$instanceid;
		if (!all.outside[key]) {
			if (all.inside[key]) {
				delete all.inside[key];
				this._stoptracking(spirit);
			}
			all.outside[key] = spirit;
			gui.Tick.dispatch(gui.$TICK_OUTSIDE, 0, this.$contextid);
		}
	}
1040891
def execute_tick(timeout)
      if timeout == 0
        @internal.tick(0)
      else
        (timeout * 2).times do
          # We're going to Thread#sleep in Ruby to avoid a
          # pthread_cond_timedwait(3) inside of librdkafka
          events = @internal.tick(0)
          # If we find events, break out early
          break if events > 0
          sleep 0.5
        end
      end
    end
403931
function ( tick ) {
		this._super.ontick ( tick );
		if ( tick.type === "tick-prism" ) {
			this._hilite ();
			console.log ( this.dom.text ());
		}
	}
1316083
function(callback, duration){
        var that = this;
        var targetTime = new Date().getTime() + duration;
        var tickObj = {
            tick:function(){
                var nowTime = new Date().getTime();
                var dt = nowTime - targetTime;
                if(dt >= 0){
                    that.removeTick(tickObj);
                    callback();
                }
            }
        };
        that.addTick(tickObj);
        return tickObj;
    }
1353210
public boolean tick (Pathable pable, long tickstamp)
    {
        if (tickstamp >= _startStamp + _duration) {
            if (_source != null) {
                pable.setLocation(_source.x, _source.y);
            }
            pable.pathCompleted(tickstamp);
            return (_source != null);
        }

        // If necessary, move the sprite to the supplied location
        if (_source != null && (pable.getX() != _source.x ||
                                pable.getY() != _source.y)) {
            pable.setLocation(_source.x, _source.y);
            return true;
        }

        return false;
    }
17302
function(type, checks) {
			var handler = checks[0];
			var bglobal = checks[1];
			if (this._remove(type, [handler])) {
				if (bglobal) {
					gui.Tick.removeGlobal(type, handler);
				} else {
					gui.Tick.remove(type, handler, this.$contextid);
				}
			}
		}
335387
def update_rigid_body_tick(self, rigid_body_tick: RigidBodyTick):
        """"""
        rlbot_status = self.game.UpdateRigidBodyTick(rigid_body_tick)
        self.game_status(None, rlbot_status)
        return rigid_body_tick
21351
def tick(self, d):
        
        if self.test_blocks:
            if not (self.counter["blocks"] or 0) % self.test_blocks:
                self.test()
            self.counter["blocks"] += 1
733091
function tick(context, timer) {
    return tslib_1.__awaiter(this, void 0, void 0, function () {
        var urls, doneCount, callDone, _loop_1, _i, urls_1, x, timeStamp;
        return tslib_1.__generator(this, function (_a) {
            urls = [
                'https://told-azure-functions-server-test.azurewebsites.net/api/example-function?ping=true',
                'https://told-azure-functions-server-test.azurewebsites.net/api/example-function-get-blob?ping=true',
                'https://told-azure-functions-server-test.azurewebsites.net/api/resource?ping=true',
            ];
            doneCount = 0;
            callDone = function (url) {
                doneCount++;
                context.log('Keep Alive END: ', url);
                if (doneCount >= urls.length) {
                    context.done();
                }
            };
            _loop_1 = function (x) {
                context.log('Keep Alive START: ', x);
                var http_s = http;
                if (x.match(/^https/)) {
                    http_s = https;
                }
                http_s.get(x, function (res) {
                    console.log('statusCode:', res.statusCode);
                    callDone(x);
                });
            };
            for (_i = 0, urls_1 = urls; _i < urls_1.length; _i++) {
                x = urls_1[_i];
                _loop_1(x);
            }
            timeStamp = new Date().toISOString();
            if (timer.isPastDue) {
                context.log('Timer is Past Due');
            }
            context.log('Timer started!', timeStamp);
            return [2 /*return*/];
        });
    });
}
1102032
public function tick() {
        if ((microtime(true) - self::$lastTick) > self::$tickFreq) {
            self::$lastTick = microtime(true);
            $this->fire('tick');
        }
    }
334977
function(arg, handler) {
		handler = handler ? handler : this.spirit;
		gui.Array.make(arg).forEach(function(type) {
			if (this._removechecks(type, [handler])) {
				if (this._handlers[type]) { // weirdo Gecko condition...
					var index = this._handlers[type].indexOf(type);
					gui.Array.remove(this._handlers[type], index);
					if (this._handlers[type].length === 0) {
						delete this._handlers[type];
					}
				}
			}
		}, this);
		return this.spirit;
	}
179628
function(type, handler, one) {
			var sig = this.spirit.$contextid;
			if (one) {
				if (this._global) {
					gui.Tick.oneGlobal(type, handler);
				} else {
					gui.Tick.one(type, handler, sig);
				}
			} else {
				if (this._global) {
					gui.Tick.addGlobal(type, handler);
				} else {
					gui.Tick.add(type, handler, sig);
				}
			}
		}
609483
public function tick()
    {
        // Only invoke as many callbacks as were on the queue when tick() was called.
        $count = $this->queue->count();

        while ($count--) {
            \call_user_func(
                $this->queue->dequeue()
            );
        }
    }
1308519
function tick() {
  var moment = (new Date().getTime() - startDate)/1000;
  x = Math.round(150 * Math.sin(moment));
  y = Math.round(150 * Math.cos(moment));
  requestAnimationFrame(tick);
}