Bash - Using a "static" variable (aka Command line Russian Roulette) [duplicate] - bash

Question

This question already has answers here:
Variable in Bash Script that keeps it value from the last time running
(3 answers)
Closed 7 years ago.
TL;DR: How do you set up a variable upon first run of a bash script and modify it upon further runs (something like a static variable in a function in C)?
Background info:
The following line in Bash is for playing "Command line Russian Roulette" (a much safer version of https://stackoverflow.com/a/575464/3696619):
[ $[ $RANDOM % 6 ] == 0 ] && echo *Boom* || echo *Click*
However, it doesn't really work like normal Russian Roulette (for which, within the first 6 tries, you are guaranteed to have a bullet in one of them).
Is there any way to make sure that this occurs (i.e. a *Boom* is guaranteed within the first 6 tries). The code should be repeatable (i.e. exact same code should be able to be copy pasted again and again, not parts of it) and it should work properly.
My idea is: Set up a variable that is set to $[$RANDOM % 6] initially and then decremented each time the code is run. If the variable reaches 0, the gun goes *Boom*, otherwise, it *Click*s. However, I am unable to figure out how to set up the variable only upon first run, and not on further runs.
Warning: Execute the code from https://stackoverflow.com/a/575464/3696619 only at your own risk.

Answer 1

Short answer: No, bash doesn't have "static" variables.
Longer: When your "C" program finishes its run, the "static" variable is lost. The same is applied for the bash script. So, you must decide what you want:
run the script once, simulate the revolver (and you can use global variable to hold the revolver status)
want preserve the revolver's cylinder status between each script run, so you need use some external storage to preserve the data. (for example file).
From you question i guessed the second version, so you must use file to hold the revolver status. For the game, you should divide the problem to different parts:
roll - (roll the revolver's cylinder (random bullet position))
shoot - (move the cylinder by one position and check the bullet)
I would do this as the following:
define the revolver for example as /tmp/revolver.
It will have 6 lines, in each line could be 2 values: 0 - no bullet, 1 - bullet
the hammer is in the 1st line - so, if the bullet is in the first line (e.g. the 1st line has value 1) the bullet will fire.
each "roll" ensures than exactly ONE bullet is in the cylinder
when shooting - once the bullet is fired, will not fire again, so any number of subsequent shots will not fire again
the roll "command". Defined as an bash function and saved as ./roll command.
revolver="/tmp/revolver"
roll() {
cyl=(0 0 0 0 0 0) # empty cylinder
cyl[$(($RANDOM % 6))]=1 # one bullet at random position
printf "%d\n" "${cyl[#]}" >"$revolver" # save
}
roll #do the roll
now, you can do bash roll (or after the chmod 755 roll) simply ./roll and your revolver is loaded with one bullet. Run the ./roll few times and after each ./roll check the bullet position with cat /tmp/revolver.
the shoot command should:
rotate the lines by one position (as in the real revolver)
and cock the hammer - e.g. check the value of the 1st line
revolver="/tmp/revolver"
rollone() {
at_hammer=$1 # store what is under the hammer
shift # shift the rest by one position
printf "%d\n" "$#" 0 > "$revolver" # save new cylinder the status
# note, we adding to the last position 0,
# because when the bullet is fired it will not fire again
# out digital revolver is not jamming
echo $at_hammer # return the bullet yes/no
}
shoot() {
cyl=($(<"$revolver")) #load the revolver status
return $(rollone "${cyl[#]}") #make the shoot, roll the cylinder and return the status
}
boom() { echo "Boom"; } #the "boom" action
click() { echo "Click"; } #the "click" action
shoot && click || boom #the actual shot
Now you can play the game:
a. ./roll - load the revolver with one bullet and roll the cylinder
b. ./shoot - any number of times
The whole game as script.
Variant A - roll once and shooting multiple times i
./roll
while :
do
./shoot
done
this will output something like:
Click
Click
Boom
Click
Click
... and forever ...
Click
Variant B - roll (e.g. reload with 1 bullet) between each shot
while :
do
./roll
./shoot
done
this will prints e.g.:
Click
Click
Boom
Boom
Click
Click
Click
Boom
Click
Click
Click
Click
Click
Click
Click
Click
Click
Boom
Click
... etc ...
Also, you could extend/modify the scripts with one more command: load and redefine your revolver as:
load - will load one (or more) bullet(s) into the cylinder
roll - will rotate the cylinder by the random number of positions (but NOT reloads the bullet) - e.g. after the fired bullet the roll will rotate only empty cylinder
shoot - fire the gun (no modification needed).

Answer 2

I don't think there's a different way for persisting the value without using a file. So, if you're going to use a file you could have the command below:
f=/tmp/a; test -f $f || echo $(($RANDOM%6))>$f; test $(<$f) == "0" && echo *Boom* && rm $f; test -f $f && echo *Click* && echo $(($(<$f)-1))>$f
What actually happens is:
Declare a variable $f where to store the name of the file that we use to store the variable.
f=/tmp/a;
Generate a random number between 0 and 5 and store it in the file:
test -f $f || echo $(($RANDOM%6))>$f;
If what we have in the file is 0 then print Boom and remove the file:
test $(<$f) == "0" && echo *Boom* && rm $f;
If the file is still there, print Click and decrement the value by 1:
test -f $f && echo *Click* && echo $(($(<$f)-1))>$f