Thread: Reaction Game: How to create randomize algorithm which gets exponentially faster

Functions to suspend program execution (i.e. to pause) are not part of the C standard. You need to look up a relevant function for your system. Under most unix, there are functions like sleep() and usleep(), which sleep for specified intervals (in seconds and microseconds) respectively. They are often declared in a header like <unistd.h>. Under windows, there is a Sleep() function (note uppercase first letter) in the win32 API.

As to " if trigger move onto next random pin or no trigger go to lose function" - that is excruciatingly unclear. I assume you mean wait for a specified period and, if pin hasn't gone high, lose.

Assuming the pin stays high until you reset it low, that might be done with some logic like this (note: not real code)

Code:

sleep(allowed_trigger_time);
if (input(PIN_B0) == 1)    /*   I assume this is your test for triggered high */
{
      /*  check next pin */
}
else
{
      /* lose */
}

[crosspost]
c - Reaction game, unaware of how to write function - Stack Overflow

"PIN_B0" -> Would you be using the CCS compiler, by chance?

If so, have a look at the generate tone here CCS :: View topic - 4" 7-segment LED display in 3-digit with 2x7W amplifier

Also, the CCS compiler has a delay function CCS :: View topic - How to generate delay in ms

Okay so...

Lasers and LED strips - What are you using to drive that sort of current?

In microcontroller world, getting random numbers is hard. However, because you have a system running and waiting for input at any time, you can use that to create a random number.

You can have an integer being incremented until input is found. Having random input from a user is gold when it comes to creating a random number. However, if you are finding that the numbers generated this way are not random enough, you can use something like an Xorshift - Xorshift - Wikipedia, the free encyclopedia - I'd probably start with the Xorshift function, because you may find that the reaction time could be close to constant, and this might be a visible pattern that the users could get used to. (And having the subroutine written and tested for other projects is also good to have).

The easiest way to reduce the time exponentially is to continuously reduce the time by a percentage (i.e. loopTime -= (loopTime*0.05)). The 0.05 corresponds to 5%, but I'm sure that you can find a nice percentage experimentally.

Keep us updated on how you go

It is not possible to speed up instructions. It is only possible to add delays between operations of interest.

"rand()" might work if you make sure you can vary the seed for the start of each turn

i.e.

Code:

#include ...
#include <stdlib.h>

#use blah... blah...


void playGame(void)
{
    int randomNumber;

    // You must have a starting point for your
    // Pseudo random number generator
    srand(get_rtcc()); 
    
    randomNumber = rand();
    /* Do something */

    randomNumber = rand();
    /* Do something */

    randomNumber = rand();
    /* Do something */

    ...
}

/* It's "void main()" or just "main()" for CCS */
void main()
{
    setup();

    for(;;)
    {
        if( startButton == PRESSED)
        {
            playGame();
        }
    }
}

ok so how do you make the delay time exponentially less then the previous?

As I said earlier, it goes down at a constant percentage

i.e.

Code:

unsigned int16 delayTime;

for(delayTime = 60000; ; delayTime -= (delayTime * 0.05))
{
    output_toggle(LED);
    delay_ms(delayTime);
}