Text mode graphics were a Big Deal with computers for the longest time. C’s stream I/O didn’t stop various computer games from being developed throughout the 1970s and 1980s. And this limitation isn’t going to stop me from animating a falling ball, er, asterisk.

In last week’s Lesson, I explored the exp() function, which is the mathematician’s equivalent of an ice cream sundae. While most of what it does or how it’s used is beyond me, the output is interesting enough that when applied graphically, it can be used to simulate how gravity affects a falling object.

The exponential function outputs results for a sequential series of numbers as small values that rapidly increase in size. This data can be used as the row value when positioning an object on the terminal (text) screen, which is how it makes the movement look natural. But before plotting, a few useful functions must be gathered to boost the C language’s lack of “fun” capabilities: clear(), putat(), and delay(). These functions are covered in previous Lessons, with the lot presented here.

The clear() function (macro) uses ANSI codes to clear the screen.

The putat() function uses ANSI codes to position the cursor and output a character.

The delay() function pauses program execution for a given number of milliseconds.

The setvbuf() function is also required. Its purpose is to remove line buffering for the standard output device. This modification allows the asterisks to be output without waiting for a newline or for the output buffer to fill.

Here is my code, which uses the exp() function’s output animate a falling asterisk:

2025_08_16-Lesson.c

#include <stdio.h>
#include <math.h>
#include <time.h>

#define clear() printf("\e[H\e[2J")

/* move the cursor to position x (columns)
   and y (rows) and set character c */
void putat(x,y,c)
{
    printf("\e[%d;%dH%c",y,x,c);
}

/* pause for m milliseconds */
void delay(int m)
{
    long pause;
    clock_t now,then;

    pause = m*(CLOCKS_PER_SEC/1000);
    now = then = clock();
    while( (now-then) < pause )
        now = clock();
}

int main()
{
    int x;
    double b;
    char buffer[BUFSIZ];

    /* initialization */
    setvbuf(stdout,buffer,_IONBF,BUFSIZ);
    clear();

    for( x=5; x<64; x++ )
    {
        b=exp( (double)x/20 );
        putat( 3, (int)b, '*' );
        delay(50);
        putat( 3, (int)b, ' ' );
    }
    putchar('\n');

    return 0;
}

Remember when building this code at the Linux command prompt to add the -lm (little L, little M) switch to link in the math library.

In the main() function, int variable x is the looping variable, ranging from 5 to 64. These values were used in last week’s Lesson as arguments for the exp() function — and they’re used here again. The results of exp( (double)x/20 ) range from 1.000000 through 23.336065. Each value generated is saved in double variable b.

Immediately, double variable b is typecast to an integer for use in the putat() function. The values, now ranging from 1 to 23, plot the asterisk’s location on the screen:

putat( 3, (int)b, '*' )

The program pauses for 50 milliseconds. Then the asterisk is “erased.” The loop repeats, plotting the asterisk’s position down the screen. Video of the output appears below:

Figure 1. Program output: the falling asterisk.
(Image repeats/cycles, but the program’s output does not.)

Remember that the for loop repeats 59 times. A lot of the initial action is the program overwriting the asterisk’s position with itself. Because the output from the exp() function changes little (especially when converted into an integer), the asterisk appears to hang for a while before dropping. This effect is what builds the animation.

In next week’s Lesson, I add code to bounce the asterisk across the terminal window.