Timers

Timers

Timers in SplashKit can be used to track the passing of time.

Functions

Create Timer  {</>}

Create and return a new Timer. The timer will not be started, and will have an initial ‘ticks’ of 0.

Parameters:

Name	Type	Description
name	String	The name of the timer for resource tracking

Return Type: Timer

Returns: A new timer.

Signatures:

C++

timer create_timer(string name)

C#

public static Timer SplashKit.CreateTimer(string name);
public Timer(string name);

Python

def create_timer(name):

Pascal

function CreateTimer(name: String): Timer

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Modify PWM through button presses

API Documentation Code Examples:

• Point In Rectangle: Splashkit Function: PointInRectangle
• Rectangle Around: Splashkit Function: RectangleAround
• Resume Timer: Resuming a Paused Timer
• Timer Started: Start-Stop Stopwatch

See Code Examples

Example 1: Creating and Running a Simple Timer

C++

#include "splashkit.h"
#include <string>

int main()
{
    open_window("Simple Timer Display", 800, 600);

    timer example_timer = create_timer("Example Timer");
    start_timer(example_timer);

    while (!quit_requested())
    {
        process_events();

        double elapsed_seconds = timer_ticks(example_timer) / 1000.0;

        clear_screen(COLOR_WHITE);

        draw_text("Timer created and running", COLOR_BLACK, 20, 20);
        draw_text(
            "Elapsed time: " + std::to_string(elapsed_seconds) + " seconds",
            COLOR_BLACK,
            20,
            60
        );
        draw_text("Close the window to finish.", COLOR_BLACK, 20, 100);

        refresh_screen(60);
    }

    free_timer(example_timer);

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

OpenWindow("Simple Timer Display", 800, 600);

Timer timer = CreateTimer("Example Timer");
StartTimer(timer);

while (!QuitRequested())
{
    ProcessEvents();

    double elapsedSeconds = TimerTicks(timer) / 1000.0;

    ClearScreen(ColorWhite());

    DrawText("Timer created and running", ColorBlack(), 20, 20);
    DrawText("Elapsed time: " + elapsedSeconds.ToString("0.0") + " seconds", ColorBlack(), 20, 60);
    DrawText("Close the window to finish.", ColorBlack(), 20, 100);

    RefreshScreen(60);
}

FreeTimer(timer);

Object-Oriented

using SplashKitSDK;

namespace CreateTimerExample
{
    public class Program
    {
        public static void Main()
        {
            SplashKit.OpenWindow("Simple Timer Display", 800, 600);

            SplashKitSDK.Timer timer = SplashKit.CreateTimer("Example Timer");
            SplashKit.StartTimer(timer);

            while (!SplashKit.QuitRequested())
            {
                SplashKit.ProcessEvents();

                double elapsedSeconds = SplashKit.TimerTicks(timer) / 1000.0;

                SplashKit.ClearScreen(Color.White);

                SplashKit.DrawText("Timer created and running", Color.Black, 20, 20);
                SplashKit.DrawText("Elapsed time: " + elapsedSeconds.ToString("0.0") + " seconds", Color.Black, 20, 60);
                SplashKit.DrawText("Close the window to finish.", Color.Black, 20, 100);

                SplashKit.RefreshScreen(60);
            }

            SplashKit.FreeTimer(timer);
        }
    }
}

Python

from splashkit import *

open_window("Simple Timer Display", 800, 600)

timer = create_timer("Example Timer")
start_timer(timer)

while not quit_requested():
    process_events()

    elapsed_seconds = timer_ticks(timer) / 1000.0

    clear_screen(color_white())

    draw_text_no_font_no_size("Timer created and running", color_black(), 20, 20)
    draw_text_no_font_no_size(
        "Elapsed time: " + format(elapsed_seconds, ".1f") + " seconds",
        color_black(),
        20,
        60
    )
    draw_text_no_font_no_size(
        "Close the window to finish.",
        color_black(),
        20,
        100
    )

    refresh_screen_with_target_fps(60)

free_timer(timer)

Output:

---

Free All Timers  {</>}

Free all of timers that have been created.

Signatures:

C++

void free_all_timers()

C#

public static void SplashKit.FreeAllTimers();

Python

def free_all_timers():

Pascal

procedure FreeAllTimers()

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Modify PWM through button presses

---

Free Timer  {</>}

Free the memory used to store this timer.

Parameters:

Name	Type	Description
to_free	Timer	The time to be released.

Signatures:

C++

void free_timer(timer to_free)

C#

public void Timer.Free();
public static void SplashKit.FreeTimer(Timer toFree);

Python

def free_timer(to_free):

Pascal

procedure FreeTimer(toFree: Timer)

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Create Timer: Creating and Running a Simple Timer
• Resume Timer: Resuming a Paused Timer

---

Has Timer

Checks if SplashKit has a timer with the indicated name.

Parameters:

Name	Type	Description
name	String	The name of the timer

Return Type: Boolean

Returns: True if SplashKit has created a timer with that name.

Signatures:

C++

bool has_timer(string name)

C#

public static bool SplashKit.HasTimer(string name);

Python

def has_timer_named(name):

Pascal

function HasTimer(name: String): Boolean

---

Pause Timer  {</>}

Note

This function is overloaded. The following versions exist:

• Pause Timer (name: string)
• Pause Timer (to_pause: timer)  {</>}

Pause Timer

Pause the timer, getting ticks from a paused timer will continue to return the same time.

Parameters:

Name	Type	Description
name	String	The name of the timer

Signatures:

C++

void pause_timer(string name)

C#

public static void SplashKit.PauseTimer(string name);

Python

def pause_timer_named(name):

Pascal

procedure PauseTimer(name: String)

---

Pause Timer  {</>}

Pause the timer, getting ticks from a paused timer will continue to return the same time.

Parameters:

Name	Type	Description
to_pause	Timer	The timer

Signatures:

C++

void pause_timer(timer to_pause)

C#

public void Timer.Pause();
public static void SplashKit.PauseTimer(Timer toPause);

Python

def pause_timer(to_pause):

Pascal

procedure PauseTimer(toPause: Timer)

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Resume Timer: Resuming a Paused Timer

---

Reset Timer  {</>}

Note

This function is overloaded. The following versions exist:

• Reset Timer (name: string)
• Reset Timer (tmr: timer)  {</>}

Reset Timer

Resets the named timer

Parameters:

Name	Type	Description
name	String	The name of the timer

Signatures:

C++

void reset_timer(string name)

C#

public static void SplashKit.ResetTimer(string name);

Python

def reset_timer_named(name):

Pascal

procedure ResetTimer(name: String)

---

Reset Timer  {</>}

Resets the time of a given timer

Parameters:

Name	Type	Description
tmr	Timer	The timer

Signatures:

C++

void reset_timer(timer tmr)

C#

public void Timer.Reset();
public static void SplashKit.ResetTimer(Timer tmr);

Python

def reset_timer(tmr):

Pascal

procedure ResetTimer(tmr: Timer)

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Point In Rectangle: Splashkit Function: PointInRectangle
• Rectangle Around: Splashkit Function: RectangleAround
• Close Window: Starts a countdown to close the window at the push of a button.

---

Resume Timer  {</>}

Note

This function is overloaded. The following versions exist:

• Resume Timer (name: string)
• Resume Timer (to_resume: timer)  {</>}

Resume Timer

Resumes the named timer.

Parameters:

Name	Type	Description
name	String	The name of the timer

Signatures:

C++

void resume_timer(string name)

C#

public static void SplashKit.ResumeTimer(string name);

Python

def resume_timer_named(name):

Pascal

procedure ResumeTimer(name: String)

---

Resume Timer  {</>}

Resumes a paused timer.

Parameters:

Name	Type	Description
to_resume	Timer	The timer

Signatures:

C++

void resume_timer(timer to_resume)

C#

public void Timer.Resume();
public static void SplashKit.ResumeTimer(Timer toResume);

Python

def resume_timer(to_resume):

Pascal

procedure ResumeTimer(toResume: Timer)

Usage:  {</>}

See Code Examples

Example 1: Resuming a Paused Timer

C++

#include "splashkit.h"

int main()
{
    // Create and start a timer
    timer my_timer = create_timer("my_timer");
    start_timer(my_timer);
    write_line("Timer started!");

    // Wait 1 second
    delay(1000);
    write_line("After 1 second: " + to_string((int)timer_ticks(my_timer)) + " ms");

    // Pause the timer
    pause_timer(my_timer);
    write_line("Timer paused!");

    // Wait 1 second while paused - timer should NOT increase
    delay(1000);
    write_line("After pause delay, still at: " + to_string((int)timer_ticks(my_timer)) + " ms");

    // Resume the timer
    resume_timer(my_timer);
    write_line("Timer resumed!");

    // Wait 1 more second - timer continues from where it left off
    delay(1000);
    write_line("After resume: " + to_string((int)timer_ticks(my_timer)) + " ms");

    free_timer(my_timer);
    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

// Create and start a timer
SplashKitSDK.Timer myTimer = CreateTimer("my_timer");
StartTimer(myTimer);
WriteLine("Timer started!");

// Wait 1 second
Delay(1000);
WriteLine("After 1 second: " + TimerTicks(myTimer) + " ms");

// Pause the timer
PauseTimer(myTimer);
WriteLine("Timer paused!");

// Wait 1 second while paused - timer should NOT increase
Delay(1000);
WriteLine("After pause delay, still at: " + TimerTicks(myTimer) + " ms");

// Resume the timer
ResumeTimer(myTimer);
WriteLine("Timer resumed!");

// Wait 1 more second - timer continues from where it left off
Delay(1000);
WriteLine("After resume: " + TimerTicks(myTimer) + " ms");

FreeTimer(myTimer);

Object-Oriented

using SplashKitSDK;

class Program
{
    static void Main(string[] args)
    {
        // Create and start a timer
        SplashKitSDK.Timer myTimer = SplashKit.CreateTimer("my_timer");
        SplashKit.StartTimer(myTimer);
        SplashKit.WriteLine("Timer started!");

        // Wait 1 second
        SplashKit.Delay(1000);
        SplashKit.WriteLine("After 1 second: " + SplashKit.TimerTicks(myTimer) + " ms");

        // Pause the timer
        SplashKit.PauseTimer(myTimer);
        SplashKit.WriteLine("Timer paused!");

        // Wait 1 second while paused - timer should NOT increase
        SplashKit.Delay(1000);
        SplashKit.WriteLine("After pause delay, still at: " + SplashKit.TimerTicks(myTimer) + " ms");

        // Resume the timer
        SplashKit.ResumeTimer(myTimer);
        SplashKit.WriteLine("Timer resumed!");

        // Wait 1 more second - timer continues from where it left off
        SplashKit.Delay(1000);
        SplashKit.WriteLine("After resume: " + SplashKit.TimerTicks(myTimer) + " ms");

        SplashKit.FreeTimer(myTimer);
    }
}

Python

from splashkit import *

# Create and start a timer
my_timer = create_timer("my_timer")
start_timer(my_timer)
write_line("Timer started!")

# Wait 1 second
delay(1000)
write_line("After 1 second: " + str(timer_ticks(my_timer)) + " ms")

# Pause the timer
pause_timer(my_timer)
write_line("Timer paused!")

# Wait 1 second while paused - timer should NOT increase
delay(1000)
write_line("After pause delay, still at: " + str(timer_ticks(my_timer)) + " ms")

# Resume the timer
resume_timer(my_timer)
write_line("Timer resumed!")

# Wait 1 more second - timer continues from where it left off
delay(1000)
write_line("After resume: " + str(timer_ticks(my_timer)) + " ms")

free_timer(my_timer)

Output:

---

Start Timer  {</>}

Note

This function is overloaded. The following versions exist:

• Start Timer (name: string)
• Start Timer (to_start: timer)  {</>}

Start Timer

Start a timer. The timer will then start recording the time that has passed. You can check how long has past since the timer was started using the Timer Ticks function.

Parameters:

Name	Type	Description
name	String	The name of the timer

Signatures:

C++

void start_timer(string name)

C#

public static void SplashKit.StartTimer(string name);

Python

def start_timer_named(name):

Pascal

procedure StartTimer(name: String)

---

Start Timer  {</>}

Start a timer. The timer will then start recording the time that has passed. You can check how long has past since the timer was started using the Timer Ticks function.

Parameters:

Name	Type	Description
to_start	Timer	The timer

Signatures:

C++

void start_timer(timer to_start)

C#

public void Timer.Start();
public static void SplashKit.StartTimer(Timer toStart);

Python

def start_timer(to_start):

Pascal

procedure StartTimer(toStart: Timer)

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Modify PWM through button presses

API Documentation Code Examples:

• Point In Rectangle: Splashkit Function: PointInRectangle
• Rectangle Around: Splashkit Function: RectangleAround
• Create Timer: Creating and Running a Simple Timer
• Resume Timer: Resuming a Paused Timer

---

Stop Timer  {</>}

Note

This function is overloaded. The following versions exist:

• Stop Timer (name: string)
• Stop Timer (to_stop: timer)  {</>}

Stop Timer

Stop the timer. The time is reset to 0 and you must recall start to begin the timer ticking again.

Parameters:

Name	Type	Description
name	String	The name of the timer

Signatures:

C++

void stop_timer(string name)

C#

public static void SplashKit.StopTimer(string name);

Python

def stop_timer_named(name):

Pascal

procedure StopTimer(name: String)

---

Stop Timer  {</>}

Stop the timer. The time is reset to 0 and you must recall start to begin the timer ticking again.

Parameters:

Name	Type	Description
to_stop	Timer	The timer

Signatures:

C++

void stop_timer(timer to_stop)

C#

public void Timer.Stop();
public static void SplashKit.StopTimer(Timer toStop);

Python

def stop_timer(to_stop):

Pascal

procedure StopTimer(toStop: Timer)

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Modify PWM through button presses

API Documentation Code Examples:

• Timer Started: Start-Stop Stopwatch

---

Timer Named

Get the timer created with the indicated name.

Parameters:

Name	Type	Description
name	String	The name of the timer to fetch

Return Type: Timer

Returns: Returns the timer fetched from SplashKit

Signatures:

C++

timer timer_named(string name)

C#

public static Timer SplashKit.TimerNamed(string name);

Python

def timer_named(name):

Pascal

function TimerNamed(name: String): Timer

---

Timer Paused

Note

This function is overloaded. The following versions exist:

• Timer Paused (name: string)
• Timer Paused (to_get: timer)

Timer Paused

Indicates if the timer is paused.

Parameters:

Name	Type	Description
name	String	The name of the timer

Return Type: Boolean

Returns: True if the timer is paused

Signatures:

C++

bool timer_paused(string name)

C#

public static bool SplashKit.TimerPaused(string name);

Python

def timer_paused_named(name):

Pascal

function TimerPaused(name: String): Boolean

---

Timer Paused

Indicates if the timer is paused.

Parameters:

Name	Type	Description
to_get	Timer	The timer

Return Type: Boolean

Returns: True if the timer is paused

Signatures:

C++

bool timer_paused(timer to_get)

C#

public bool Timer.IsPaused { get }
public static bool SplashKit.TimerPaused(Timer toGet);

Python

def timer_paused(to_get):

Pascal

function TimerPaused(toGet: Timer): Boolean

---

Timer Started  {</>}

Note

This function is overloaded. The following versions exist:

• Timer Started (name: string)
• Timer Started (to_get: timer)  {</>}

Timer Started

Indicates if the timer is started.

Parameters:

Name	Type	Description
name	String	The name of the timer

Return Type: Boolean

Returns: True if the timer has been started

Signatures:

C++

bool timer_started(string name)

C#

public static bool SplashKit.TimerStarted(string name);

Python

def timer_started_named(name):

Pascal

function TimerStarted(name: String): Boolean

---

Timer Started  {</>}

Indicates if the timer is started.

Parameters:

Name	Type	Description
to_get	Timer	The timer

Return Type: Boolean

Returns: True if the timer has been started

Signatures:

C++

bool timer_started(timer to_get)

C#

public bool Timer.IsStarted { get }
public static bool SplashKit.TimerStarted(Timer toGet);

Python

def timer_started(to_get):

Pascal

function TimerStarted(toGet: Timer): Boolean

Usage:  {</>}

See Code Examples

Example 1: Start-Stop Stopwatch

C++

#include "splashkit.h"
#include <string>

int main()
{
    open_window("Start-Stop Stopwatch", 600, 300);

    // Create a named timer - it is not started until start_timer is called
    timer game_timer = create_timer("game_timer");

    while (!quit_requested())
    {
        process_events();

        // Start the timer when SPACE is pressed
        if (key_typed(SPACE_KEY))
            start_timer(game_timer);

        // Stop the timer when S is pressed
        if (key_typed(S_KEY))
            stop_timer(game_timer);

        clear_screen(COLOR_WHITE);

        // Use timer_started to check whether the timer is currently running
        bool is_running = timer_started(game_timer);

        // Display the timer status
        if (is_running)
        {
            draw_text("Status: Running", COLOR_GREEN, "Arial", 28, 170, 80);
        }
        else
        {
            draw_text("Status: Stopped", COLOR_RED, "Arial", 28, 170, 80);
        }

        // Display elapsed milliseconds - std::to_string converts a number to a string
        draw_text("Elapsed: " + std::to_string(timer_ticks(game_timer)) + " ms",
                  COLOR_BLACK, "Arial", 20, 185, 140);

        draw_text("[SPACE] Start   [S] Stop", COLOR_GRAY, "Arial", 16, 165, 220);

        refresh_screen(60);
    }

    close_all_windows();
    return 0;
}

C#

Top-level Statements

// using static allows calling SplashKit methods directly (e.g. TimerStarted, StartTimer)
// using SplashKitSDK is required for Timer and KeyCode types
using static SplashKitSDK.SplashKit;
using SplashKitSDK;

OpenWindow("Start-Stop Stopwatch", 600, 300);

// SplashKitSDK.Timer needed to distinguish from System.Threading.Timer
// Create a named timer - it is not started until StartTimer is called
SplashKitSDK.Timer gameTimer = new SplashKitSDK.Timer("game_timer");

while (!QuitRequested())
{
    ProcessEvents();

    // Start the timer when SPACE is pressed
    if (KeyTyped(KeyCode.SpaceKey))
        StartTimer(gameTimer);

    // Stop the timer when S is pressed
    if (KeyTyped(KeyCode.SKey))
        StopTimer(gameTimer);

    ClearScreen(ColorWhite());

    // Use TimerStarted to check whether the timer is currently running
    bool isRunning = TimerStarted(gameTimer);

    // Display the timer status
    if (isRunning)
    {
        DrawText("Status: Running", ColorGreen(), "Arial", 28, 170, 80);
    }
    else
    {
        DrawText("Status: Stopped", ColorRed(), "Arial", 28, 170, 80);
    }

    // Display elapsed milliseconds
    DrawText("Elapsed: " + TimerTicks(gameTimer) + " ms",
             ColorBlack(), "Arial", 20, 185, 140);

    DrawText("[SPACE] Start   [S] Stop", ColorGray(), "Arial", 16, 165, 220);

    RefreshScreen(60);
}

CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace TimerStarted
{
    public class Program
    {
        public static void Main()
        {
            SplashKit.OpenWindow("Start-Stop Stopwatch", 600, 300);

            // SplashKitSDK.Timer needed to distinguish from System.Threading.Timer
            // Create a named timer - it is not started until StartTimer is called
            SplashKitSDK.Timer gameTimer = new SplashKitSDK.Timer("game_timer");

            while (!SplashKit.QuitRequested())
            {
                SplashKit.ProcessEvents();

                // Start the timer when SPACE is pressed
                if (SplashKit.KeyTyped(KeyCode.SpaceKey))
                    SplashKit.StartTimer(gameTimer);

                // Stop the timer when S is pressed
                if (SplashKit.KeyTyped(KeyCode.SKey))
                    SplashKit.StopTimer(gameTimer);

                SplashKit.ClearScreen(Color.White);

                // Use TimerStarted to check whether the timer is currently running
                bool isRunning = SplashKit.TimerStarted(gameTimer);

                // Display the timer status
                if (isRunning)
                {
                    SplashKit.DrawText("Status: Running", Color.Green, "Arial", 28, 170, 80);
                }
                else
                {
                    SplashKit.DrawText("Status: Stopped", Color.Red, "Arial", 28, 170, 80);
                }

                // Display elapsed milliseconds
                SplashKit.DrawText("Elapsed: " + SplashKit.TimerTicks(gameTimer) + " ms",
                                   Color.Black, "Arial", 20, 185, 140);

                SplashKit.DrawText("[SPACE] Start   [S] Stop", Color.Gray, "Arial", 16, 165, 220);

                SplashKit.RefreshScreen(60);
            }

            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

open_window("Start-Stop Stopwatch", 600, 300)

# Create a named timer - it is not started until start_timer is called
game_timer = create_timer("game_timer")

while not quit_requested():
    process_events()

    # Start the timer when SPACE is pressed
    if key_typed(KeyCode.space_key):
        start_timer(game_timer)

    # Stop the timer when S is pressed
    if key_typed(KeyCode.s_key):
        stop_timer(game_timer)

    clear_screen(color_white())

    # Use timer_started to check whether the timer is currently running
    is_running = timer_started(game_timer)

    # Display the timer status
    if is_running:
        draw_text_font_as_string("Status: Running", color_green(), "Arial", 28, 170, 80)
    else:
        draw_text_font_as_string("Status: Stopped", color_red(), "Arial", 28, 170, 80)

    # Display elapsed milliseconds
    draw_text_font_as_string("Elapsed: " + str(timer_ticks(game_timer)) + " ms",
                             color_black(), "Arial", 20, 185, 140)

    draw_text_font_as_string("[SPACE] Start   [S] Stop", color_gray(), "Arial", 16, 165, 220)

    refresh_screen_with_target_fps(60)

close_all_windows()

Output:

---

Timer Ticks  {</>}

Note

This function is overloaded. The following versions exist:

• Timer Ticks (name: string)
• Timer Ticks (to_get: timer)  {</>}

Timer Ticks

Gets the number of ticks (milliseconds) that have passed since the timer was started/reset. When paused the timer’s ticks will not advance until the timer is once again resumed.

Parameters:

Name	Type	Description
name	String	The name of the Timer

Return Type: Unsigned Integer

Signatures:

C++

unsigned int timer_ticks(string name)

C#

public static uint SplashKit.TimerTicks(string name);

Python

def timer_ticks_named(name):

Pascal

function TimerTicks(name: String): Cardinal

---

Timer Ticks  {</>}

Gets the number of ticks (milliseconds) that have passed since the timer was started/reset. When paused the timer’s ticks will not advance until the timer is once again resumed.

Parameters:

Name	Type	Description
to_get	Timer	The timer

Return Type: Unsigned Integer

Signatures:

C++

unsigned int timer_ticks(timer to_get)

C#

public uint Timer.Ticks { get }
public static uint SplashKit.TimerTicks(Timer toGet);

Python

def timer_ticks(to_get):

Pascal

function TimerTicks(toGet: Timer): Cardinal

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Modify PWM through button presses

API Documentation Code Examples:

• Point In Rectangle: Splashkit Function: PointInRectangle
• Rectangle Around: Splashkit Function: RectangleAround
• Create Timer: Creating and Running a Simple Timer
• Resume Timer: Resuming a Paused Timer

---

Types

Timer

Timers in SplashKit can be used to track the passing of time. In general you will create a timer, start it, then use it to track time by asking for the timer’s ticks (milliseconds).

---