You were on the right track-- "getKey" on its own returns a single keypress, but you can also use "getKey(n)" to check if key "n" is pressed (it returns 0 for not pressed, 1 for pressed).

So if you want to check for both Enter and the Down arrow, simultaneously:
If getKey(9)
//Enter is pressed
End

If getKey(1)
//Down is pressed
End

You can also do some useful arithmetic, like if you have (X,Y) coordinates, you might want:
X+getKey(3)-getKey(2)→X
Y+getKey(1)-getKey(4)→Y
And that has a bonus of letting the user press multiple arrow keys simultaneously

Hopefully that helps!

EDIT: Also, welcome to Omninaga, you should Introduce Yourself!

Necropost: this came up elsewhere and I made a python version if anybody is interested. I think it could be implemented really well with logic gates!
https://gist.github.com/Zeda/98aab98fd32a231b878772a435ffb306

#!/usr/bin/python3

# This is ported from:
#    https://www.omnimaga.org/asm-language/sine-approximation-(z80)/
# (Xeda112358  a.k.a.  Zeda  a.k.a.  ZedaZ80)
#

from math import sin

def sineb(x):
    """Approximates 128*sin(x*2*pi/256)"""

    a1 = int(x)
    a0 = a1 << 1
    a2 = a1 >> 1

    # iteration 1
    if a1 & 64:
        l = ~a0 & 127
    else:
        l =  a0 & 127

    # iteration 2
    if a1 & 32:
        l += ~a1 & 31
    else:
        l +=  a1 & 31

    # iteration 3
    if a1 & 16:
        l += ~a2 & 7
    else:
        l +=  a2 & 7

    # check if it needs to be negated
    if a1 & 128:
        return -l
    else:
        return l

# Plot a graph of the approximation vs the actual
for x in range(0, 256, 2):
    y = sineb(x)
    z = int(sin(x*3.1415926535/128)*128)

    # translate and scale for "graphing"
    y += 128
    z += 128
    y >>= 1
    z >>= 1

    # "graph"
    #    X - Approximation
    #    O - Actual
    #    8 - used when the graphs overlap
    if y == z:
        print(" "*y + "8")
    elif y > z:
        print(" "*z + "X" + " "*(y-z-1) + "O")
    else:
        print(" "*y + "O" + " "*(z-y-1) + "X")


The code is difficult to follow, but it looks like you are mixing 0-indexing and 1-indexing.
You loop J from 1 to Rooms, but then you are checking if J>0 in the same loop (which is always true).

J+(J*((J>0)*4))-4→Y
Simplifies to:
J+(J*(1*4))-4→Y
J+(J*4)-4→Y
J*5-4→Y

Maybe there is something there?

Could it be that I used WabbitSign?  Should I use something else to sign the app?

I haven't used wabbitsign in a long time and I'm not sure if that is the issue. I generally use spasm and I've got it configured to automatically sign apps.

I know Wabbitemu is very generous with loading apps (it bypasses the calc's security which is great for streamlining development, but it hides signing issues).

I'm not much help with this stuff these ays .__.

Holy heck that looks so good :O

Awww yiss, that looks pretty cool!
I definitely like the monochrome graphics (I also find that grayscale is just too rough to look at on actual hardware and with moving images).

That is absolutely amazing, and especially for having been done in TI-BASIC