Whack-a-Mole: Data Structures

typedef struct {
        wamDisplay_point_t origin;  // This is the origin of the hole for this mole.

        // A mole is active if either of the tick counts are non-zero. The mole is dormant otherwise.
        // During operation, non-zero tick counts are decremented at a regular rate by the control state machine.
        // The mole remains in his hole until ticksUntilAwake decrements to zero and then he pops out.
        // The mole remains popped out of his hole until ticksUntilDormant decrements to zero.
        // Once ticksUntilDormant goes to zero, the mole hides in his hole and remains dormant until activated again.
        wamDisplay_moleTickCount_t ticksUntilAwake;  // Moles wake up (pop out of hole) when this goes from 1 -> 0.
        wamDisplay_moleTickCount_t ticksUntilDormant; // Moles go dormant (back in hole) this goes 1 -> 0.
} wamDisplay_moleInfo_t;

// This will contain pointers to all of the mole info records.
// This will ultimately be treated as an array of pointers.
static wamDisplay_moleInfo_t** wamDisplay_moleInfo;

// Allocates the memory for wamDisplay_moleInfo_t records.
// Computes the origin for each mole assuming a simple row-column layout:
// 9 moles: 3 rows, 3 columns, 6 moles: 2 rows, 3 columns, 4 moles: 2 rows, 2 columns
// Also inits the tick counts for awake and dormant.
void wamDisplay_computeMoleInfo() {
    // Setup all of the moles, creates and inits mole info records.
    // Create the container array. It contains pointers to each of the mole-hole info records.
    //    wamDisplay_moleInfo =  // Need to uncomment this line and initialize this variable via malloc().
}

#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>

typedef struct {uint16_t x; uint16_t y;} myStruct;  // Simple struct as an example.

// Step 1: Define the variable that will contain the array of pointers.
static myStruct** arrayOfPointers = NULL;  // This is just a pointer, it doesn't point to anything yet.

#define NUMBER_OF_POINTERS 4

int main() {
 
    // Step 2: allocate enough memory to hold NUMBER_OF_POINTERS. I need enough storage for 4
    // pointers. sizeof(myStruct*) returns the number of bytes for a single pointer to a myStruct. 
    // Multiply that value by 4 to get enough memory for 4 pointers. 
    // malloc() returns a (void *) so you must cast it to match the type of arrayOfPointers.
    // Rule of thumb: the number of stars (*) must match on both sides of the equation.
    // arrayOfPointers is pointer-to-pointer (myStruct**) so you need two stars (*) for the cast.
    arrayOfPointers = (myStruct**) malloc(NUMBER_OF_POINTERS * sizeof(myStruct*));

    // Step 3: Allocate memory for each myStruct.
    // sizeof(myStruct) returns the number of bytes required by a single myStruct.
    // The for-loop iterates 4 times, during each iteration, it grabs enough memory
    // for a single myStruct and stores it address (the pointer value) in a location in arrayOfPointers.
    for (uint16_t i=0; i<NUMBER_OF_POINTERS; i++) {
        // Second, allocate an instance of myStruct and point to it.
        arrayOfPointers[i] = (myStruct*) malloc(sizeof(myStruct));
    }
    // Step 4: assign values to these structs.
    for (uint16_t j=0; j<NUMBER_OF_POINTERS; j++) {
        arrayOfPointers[j]->x = j;  // Just need a number.
        arrayOfPointers[j]->y = NUMBER_OF_POINTERS - j;  // Just need a number.
    }
    // Verify that the assignments worked.
    for (uint16_t k=0; k<NUMBER_OF_POINTERS; k++) {
        printf("Struct contents x:%d, y:%d\n", arrayOfPointers[k]->x, arrayOfPointers[k]->y);
    }
    // When you are done, you must return the memory to the system or you will create a memory leak.
    // First deallocate all of the structs.
    for (uint16_t l=0; l<NUMBER_OF_POINTERS; l++) {
        free(arrayOfPointers[l]);   // This deallocates the memory. 
        arrayOfPointers[l] = NULL;  // This step is not necessary but will keep you from reusing deallocated memory.
    }
    // Next, deallocate the array that contains the pointers to the structs.
    free(arrayOfPointers);   // Deallocates the container of arrays.
    arrayOfPointers = NULL;  // Also keeps you from reusing the deallocated memory.
}