balls

1. [ -n "$BASH_VERSINFO" ] && [ $BASH_VERSINFO -ge 4 ] ||
{ echo 'This script requires bash4'; exit 1; }
name=bouncingballs
created=2013-02-19T12:39:48
modified=2013-05-11T14:51:10
version=1.0
author='Chris F.A. Johnson'
copyright="${modified%%-*} $author"
license='GNU General Public License V3.'
####################################################
#$ Variables ###
##################################################
bnum=5
topline=1
leftcol=1
rightmargin=0
bottommargin=0
char=O
boldchar=0
revchar=0
ulchar=0
silent=0
status=0
delayprompt='Enter delay in milliseconds: '
charprompt='Enter character'
CSI=$'e['
clearwindow=$'e[He[2J'
clearline=$'e[J'
hidecursor=$'e[?25l'
showcursor=$'e[?12le[?25h'
position_cursor=$'e[%d;%dH'
bold_on=$'e[1m'
bold_off=$'e[22m'
reverse_on=$'e[7m'
reverse_off=$'e[27m'
underline_on=$'e[4m'
underline_off=$'e[24m'
attr_norm=0
attr_bold=1
attr_rev=7
attr_blink=6
attr_uline=4
ON=1
OFF=0
small_increment=1
large_increment=10
readonly progname=${0##*/}
opts=(
b #@ Use bold character
c: #@ String character
d: #@ Delay in milliseconds
l: #@ Length of string

2. r #@ Reverse character
q #@ Do not print introduction
h #@ Help
v #@ Verbose
)
description="
${progname%-sh} $version (${modified/T/, })
Author: $author
Copyright $copyright
Released under $license; see COPYING for details
${progname%-sh} sends a string of characters flying across the
terminal (or console) window, bouncing off the sides.
OPTIONS:
b #@ Use bold character
c: #@ String character
d: #@ Delay in milliseconds
l: #@ Length of string
r #@ reverse character
q #@ Do not print introduction
h #@ help (-vh for longer help)
v #@ Show status line:
length of delay between iterations
length of string,
string character
print position
"
controls=" CONTROLS:
PageUp - Faster by 1 millisec
PageDown - Slower by 1 millisec
Home - Faster by 10 millisecs
End - Slower by 10 millisecs
The length of the string can be adjusted while running:
INS - Add one character to string
DEL - Remove one character from string
UP, DOWN, LEFT, RIGHT - Change direction
SPACE - Pause; press any key to continue
Character attributes:
b - Toggle bold
r - Toggle reverse
u - Toggle underline
[1-8] - Foreground colour
Other keys:
c - Change character to next character entered
C - Clear screen
d - Prompt for new delay value in milliseconds
h - Show control keys
q - Quit
s - Toggle display of status bar

3. "
press_any_key=$' e[7m Press any key to continue e[0mnn'
verbose=0
IFS=
optstr="${opts[@]}"
IFS=$' tn'
args=( )
####################################################
#$ Functions ###
##################################################
intro()
{
export LESS=eamgRXFj1i
printf "$clearwindow"
printf " %sn" "$description" | ${PAGER:-less}
read -sn1 -ep "$press_any_key"
printf "$clearwindow"
printf "nn %sn" "$controls" | ${PAGER:-less}
read -sn1 -ep $' e[7m Press any key to continue e[0mnn'
[ "$REPLY" = q ] && exit
}
status()
{
local fmt="Delay: %3dms (%.3fs) Length: %3d Character: %ce[K Row: %2d
Column: %3d"
(( status )) || { topline=1; return; }
printat 1 1 $'e[40;37;1m'
printf " $fmt" "$millisecs_delay" "$delay" "$bnum" "$char" "$y" "$x"
printf 'e[0m'
}
set_length()
{
[ $len -ge 0 ] && printat "${y[len]}" "${x[len]}" "$sp"
while [ ${#x[@]} -lt $bnum ]
do
[ $len -lt 0 ] && len=0
x+=( "${x[len]:-1}" )
y+=( "${y[len]:-1}" )
len=$(( ${#x[@]} - 1 )) ## index of last element in arrays
done
while [ ${#x[@]} -gt $bnum ]
do
if [ $len -ge 0 ]
then
unset x[len]
unset y[len]
fi
x=( "${x[@]}" )
y=( "${y[@]}" )
bnum=${#x[@]} ## number of elements in array
len=$(( $bnum - 1 )) ## index of last element in arrays
done
bnum=${#x[@]} ## number of elements in array
len=$(( $bnum - 1 )) ## index of last element in arrays
}
set_delay()

4. {
local arg=$1 n=9
while :
do
case $arg in
"") arg=20; break ;;
-*) arg=0; break ;; ## if less than zero, use 0
.*) arg=${arg#.} ;; ## remove leading period
[!0-9]*) arg=${arg#?} ;;
0?*) arg=${arg#0} ;; ## remove leading zero
0|[1-9]*) break ;; ## clean; continue
esac
done
millisecs_delay=${arg:-20}
if [ $millisecs_delay -le 0 ]
then
millisecs_delay=0
delay=.0001
else
printf -v delay "%d.%03d" "$(( millisecs_delay / 1000 ))" "$
(( millisecs_delay % 1000 ))"
fi
}
get_key() #@ Return ASCII represenation of keypress in variable
{ #@ USAGE: get_key varname
local CR=$'r' LF=$'n' keyvar=${1:-_KEY} tmout=.0001 TMOUT
local ctrl=( '' {A..Z} ) _n
TMOUT=$delay
IFS= read -sn1 -rd '' _key
case $_key in
"") ;;
"$LF") _key=LF ;;
"$ESC")
TMOUT=.01
while read -d '' -sn1 _k
do
_key=$_key$_k
case $_k in
[A-Za-z^~]) TMOUT=0; break ;;
esac
done
TMOUT=$tmout
_esc2key "$_key" _key
;;
*)
if [[ $_key < $ESC ]] ## CTRL-KEY pressed
then
printf -v _n %d "'$_key" ## Convert CTRL-KEY to its ASCII value
_key=^${ctrl[_n]} ## Show ^[X] where X is the letter key
fi
;;
esac
printf -v "$keyvar" %s "$_key"
}
_esc2key()
{
local _ESC2KEY=$1 var=${2:-_ESC2KEY} CSI=$'e[' ESC=$'e'
case $_ESC2KEY in
## Cursor keys
"${CSI}A" | "${CSI}OA" ) _ESC2KEY=UP ;;

5. "${CSI}B" | "${CSI}0B" ) _ESC2KEY=DOWN ;;
"${CSI}C" | "${CSI}OC" ) _ESC2KEY=RIGHT ;;
"${CSI}D" | "${CSI}OD" ) _ESC2KEY=LEFT ;;
## Function keys (unshifted)
"${CSI}11~" | "${CSI}["A | "${ESC}OP" ) _ESC2KEY=F1 ;;
"${CSI}12~" | "${CSI}["B | "${ESC}OQ" ) _ESC2KEY=F2 ;;
"${CSI}13~" | "${CSI}["C | "${ESC}OR" ) _ESC2KEY=F3 ;;
"${CSI}14~" | "${CSI}["D | "${ESC}OS" ) _ESC2KEY=F4 ;;
"${CSI}15~" | "${CSI}["E ) _ESC2KEY=F5 ;;
"${CSI}17~" | "${CSI}["F ) _ESC2KEY=F6 ;;
"${CSI}18~" ) _ESC2KEY=F7 ;;
"${CSI}19~" ) _ESC2KEY=F8 ;;
"${CSI}20~" ) _ESC2KEY=F9 ;;
"${CSI}21~" ) _ESC2KEY=F10 ;;
"${CSI}23~" ) _ESC2KEY=F11 ;; # SF1
"${CSI}24~" ) _ESC2KEY=F12 ;; # SF2
## Function keys (shifted)
"${CSI}11;2~" ) _ESC2KEY=SF1 ;;
"${CSI}25~" ) _ESC2KEY=SF3 ;;
"${CSI}26~" ) _ESC2KEY=SF4 ;;
"${CSI}28~" ) _ESC2KEY=SF5 ;;
"${CSI}29~" ) _ESC2KEY=SF6 ;;
"${CSI}31~" ) _ESC2KEY=SF7 ;;
"${CSI}32~" ) _ESC2KEY=SF8 ;;
"${CSI}33~" ) _ESC2KEY=SF9 ;;
"${CSI}34~" ) _ESC2KEY=SF10 ;;
## Insert, Delete, Home, End, Page Up, Page Down
"${CSI}2~" ) _ESC2KEY=INS ;;
"${CSI}2^" ) _ESC2KEY=^INS ;;
"${CSI}3~" ) _ESC2KEY=DEL ;;
"${CSI}"[17]~ | "${CSI}H" ) _ESC2KEY=HOME ;;
"${CSI}"[28]~ | "${CSI}F" ) _ESC2KEY=END ;;
"${CSI}8^" ) _ESC2KEY=^END ;;
"${CSI}5~" ) _ESC2KEY=PGUP ;;
"${CSI}5^" ) _ESC2KEY=^PGUP ;;
"${CSI}6~" ) _ESC2KEY=PGDN ;;
"${CSI}6^" ) _ESC2KEY=^PGDN ;;
"${CSI}3^" ) _ESC2KEY=^DEL ;;
"${CSI}7^" ) _ESC2KEY=^HOME ;;
"${CSI}3$" ) _ESC2KEY=S-DEL ;;
"${CSI}7$" ) _ESC2KEY=S-HOME ;;
"$ESC" ) _ESC2KEY=ESC ;;
## Everything else; add other keys before this line
*) _ESC2KEY=UNKNOWN ;;
esac
printf -v "$var" "%s" "$_ESC2KEY"
}
shove() #@ Add element to beginning of array and remove last element
{ #@ USAGE: shove arrayname val
local arrayname=${1:?} val=$2 max=$3 array n
## Copy the array, $arrayname, to local array
eval "array=( "${$arrayname[@]}" )"
n=${#array[@]}
## Add $val to beginning of array
array=( "$val" "${array[@]}" )
## Remove last element of array
unset array[n]
## Copy array back to $arrayname

6. eval "$arrayname=( "${array[@]}" )"
}
printat() #@ Move cursor to row/col on screen; print any remaining args
{ #@ USAGE: printat row col [arg ...]
local cursorto='e[%d;%dH'
printf "$cursorto" ${1:-1} ${2:-1}
if [ $# -gt 2 ]
then
shift 2
printf "%s" "$*"
fi
}
die() #@ Print optional error message and exit with $result
{ #@ die errnum [message]
result=$1
shift
msg=$*
[ -n "$*" ] && printf "%sn" "$msg" >&2
exit "$result"
}
usage()
{
printf 'USAGE: %s %s %sn' "$progname" ["$optstr"] "${args[*]}"
}
cleanup()
{
printf "$showcursor$na$clearwindow"
stty echo
while read -t 0; do read -sn1; done
tput rmcup
}
####################################################
#$ Parse options ###
##################################################
while getopts "$optstr" opt
do
case $opt in
b) boldchar=$ON ;;
c) char=$OPTARG ;;
d) millisecs_delay=$OPTARG ;;
l) bnum=$OPTARG ;;
q) silent=$ON ;;
h) (( verbose )) && intro || { usage; exit; } ;;
v) verbose=$(( verbose + 1 )) ;;
esac
done
shift "$(( $OPTIND - 1 ))"
####################################################
#$ Main program ###
##################################################
trap cleanup EXIT
tput smcup
(( silent )) || intro
status=$verbose
(( status )) && topline=2

7. set_delay "$millisecs_delay"
echo $'e[?25l' ## "$delay"; sleep 3
stty -echo
if [ -z "$COLUMNS" ]; then ## Set COLUMNS and LINES
termsize=( $(stty size) )
LINES=${termsize[0]}
COLUMNS=${termsize[1]}
fi
shopt -s SIGWINCH
rightcol=$(( COLUMNS - ${rightmargin:-0} ))
bottomline=$(( LINES - ${bottommargin:-0} ))
shopt -s checkwinsize ## adjust COLUMNS and LINES if window resized
x=( $topline $topline $topline $topline $topline $topline ) ## adjust number of
elements to taste
y=( $leftcol $leftcol $leftcol $leftcol $leftcol $leftcol ) ## adjust number of
elements to taste
len=$(( ${#x[@]} - 1 )) ## index of last element in arrays
xdir=+ ## direction of horizontal movement
ydir=- ## direction of vertical movement
printf "$clearwindow" ## clear screen
exec 2>$HOME/bb.log
#set -x
while :
do
set_length "$bnum"
status
printat "$y" "$x"
(( boldchar )) && printf "$bold_on" || printf "$bold_off"
(( revchar )) && printf "$reverse_on" || printf "$reverse_off"
(( ulchar )) && printf "$underline_on" || printf "$underline_off"
printf "$colour"
printf %c "$char"
printat "${y[len]}" "${x[len]}" $'e[0m '
[ $x -le ${leftcol:-1} ] && xdir=+
[ $y -ge ${bottomline:-$LINES} ] && ydir=-
[ $x -ge ${rightcol:-$COLUMNS} ] && xdir=-
[ $y -le ${topline:-1} ] && ydir=+
shove x "$(( x $xdir 1 ))"
shove y "$(( y $ydir 1 ))"
TMOUT=$delay
get_key k
case $k in
q) break;;
[1-8]) colour=${CSI}3${k}m ;;
## Increase/decrease speed
PGUP) (( millisecs_delay -= small_increment )) ;;
PGDN) (( millisecs_delay += small_increment )) ;;
HOME) (( millisecs_delay -= large_increment )) ;;
END) (( millisecs_delay += large_increment )) ;;

8. ## Change length of string
INS) (( bnum++ ))
set_length
;;
DEL) (( bnum-- ))
printat "${y[len]}" "${x[len]}" ' '
set_length
;;
## Change direction
UP) ydir=- ;;
DOWN) ydir=+ ;;
LEFT) xdir=- ;;
RIGHT) xdir=+ ;;
## Character attributes: bold, reverse and underline
b) (( boldchar = boldchar==ON?OFF:ON )) ;;
r) (( revchar = revchar==ON?OFF:ON )) ;;
u) (( ulchar = ulchar==ON?OFF:ON )) ;;
c) printat "$topline" 2 $'e[0m'"$charprompt"
TMOUT=0 read -sn1 char
printf 'r%s ' "${charprompt//?/ }"
;;
C) printf %s "$clearwindow" ;;
d) printat "$topline" 2
stty echo
TMOUT=0 read -ep "$delayprompt" millisecs_delay
printf 'e[A%s ' "${delayprompt//?/ }"
stty -echo
;;
h) printf %s "$clearwindow"
printat 3 1 "$controls"
TMOUT=0 read -sn1
printf %s "$clearwindow"
;;
' ') TMOUT=0 read -sn1 ;;
s) if (( status ))
then
status=0
topline=1
printf 'e[He[K'
else
status=1
topline=2
fi
;;
$'e') printf 'a' ;;
?*) printat 1 1 "$k " ;;
*) ;;
esac
set_delay "$millisecs_delay"
# read -sn1 -t "$delay" && break
done
echo $'e[?12le[?25h'
stty echo