LONG WINDED POST WARNING!
1. To make a basic loop, you would use either jr or jp. jp is generally slightly faster, but takes up one byte more than jr. You use jr the same way you use djnz, that is you can jump forward 128 bytes or backwards 127. With jp, you will use the full exact address in memory you want to jump to, but keep in mind that it's Little Endian, ie the Least Significant Byte (LSB) is stored first, followed by the Most Significant Byte (MSB). In the value $8070, the MSB is $80 and the LSB is $70. So what does this mean? After the hex opcode for jp (whatever it is), instead of writing JP8070, you'll need to put the MSB first, like this: JP7080.
2. What do you mean, output? Drawing a sprite? I believe there is a B_CALL called _DisplaySprite, though i've never used it and it's probably awfully slow. Probably not a big deal for Pong, but for a game with more than 3 sprites... You'll eventually want to write your own, but doing that in hex is going to be a huge pain. Often times, what will happen is a routine will write to what's called the graphbuffer (or gbuf, or plotSScreen), which is a buffer in RAM that you write to before copying it to the screen. It's quicker to write/read RAM (the LCD is really slow), so that's why that's done. If trying to display something you find the screen doesn't change, you might need to output the contents of the gbuf to the LCD. There's a B_CALL to do that, something like _GrBufCpy, again it's really slow, but coding in hex i imagine it'd be a pain to code your own copy routine. If you can get a copy of Ion, MirageOS, DoorsCS, or some other shell on your calculator, you can use the routines provided by the shell, which will generally include sprite routines, a fastcopy (copy the gbuf to the LCD more quickly than the B_CALL) routine, and some other random stuff.
3. For ComParisons, you'll use 'cp'. There are other tricks you can use, too, but cp is the most straightforward. cp will compare an 8-bit register (a,b,c,d,e,h,l) or number (0-255) to a and set the flags based on the result of the comparison. You can think of cp as a subtraction that doesn't store the result.
The main flags are:
z: the two values are the same. With cp, this means a = whatever value you compared. z stands for zero, so if a = c, cp c means the result was 0
nz: the two values are different (the result was Not Zero)
c: carry. This means a is less than the value compared to it. If a = 10, cp 13 will set the c flag because 10-13 = -3, the result carried over. (Note that the value of a doesn't change with a cp instruction, you could use the 'sub' instruction to do the exact same thing, this time the value of a WOULD change. So 'cp 10' and 'sub 10' set the exact same flags, the only difference being that with cp, a doesn't change, whereas with 'sub 10', the value of a is ten less afterwards.
nc: this means there was no carry. If the two values are the same, NC will also be set. So if a = 30, comparing a value of 0-30 would return NC, whereas 31-255 would set the c flag.
The z, c, and nc flags can also be used in additions, when the result is >255 (for 8-bit numbers, >65535 for 16-bit numbers) it will set the c flag. When the result = 0, (ie 256 or 65536, since the numbers will wrap), the z and nc flags will be "set" (or rather, the c flag will be "reset"). And when the result doesn't carry over, the carry flag will be reset (ie nc).
Those are the main flags, there are a couple others that can't be used with jr (they can be used with jp, call, and ret):
p: positive. The result of the operation was a positive number
m: minus? (who knows why it isn't 'n') the result was a negative number
The last few you probably won't use, at least not for now:
pe/
po: parity even/odd: the number of bits set (number of ones in the binary version of the number) is even/odd.
overflow: uses the same flag bit as parity. Overflow is kinda like a signed carry, you can think of it as when there is a sign change (when the carry flag and bit 7 are different). pe means there was an overflow, po means no overflow.
And for these, i think the only instruction that makes use of them is 'daa' (other instructions obviously set/reset these flags, though):
h: half-carry. This is like the carry flag, but when there is a carry from bit 3 to bit 4 (the regular carry is from bit 7 to 8, bits start counting at 0 so bit 7 is actually the 8th bit
)
n: additioN (or perhaps subtractioN?): the last operation was either an addition or subtraction.
Whew. Sorry about the lack of formatting, if you have any questions or can't be bothered to read all that, i'd be glad to answer/try to be more concise. In the end, i think you're going to want to get a cable and move to assembly programming on the computer (or at least downloading an on-calc assembly editor like Mimas or ASMDREAM).