To awnser the first part of your question:

Asm(HEX): Native assembly code written in hexadecimal is inserted at the current position.

Shifting left always inserts zeros, while rotating left inserts the same bit that was removed on the other side.

-.- Yes, and this removed bit goes in the carry flag.

Quote from: Matrefeytontias on January 22, 2014, 01:17:14 pm

I can't see any point to using rotation instructions since you don't have control on the carry flag anyway.

Aren't you thinking of RR/RL? Those instructions are a 9-bit shift/rotate, the 9th bit being the carry flag.
The instruction mentioned in the OP is RLC, which while it does do stuff with the carry flag, it does not by any means use it for anything. It is an 8-bit rotation and the bit that leaves appears immediately on the other side.

Now, extending this idea into 16 bits is a bit ... trickier, but can be accomplished with a short ASM routine, none of which ever leaves the routine, so the whole issue about carry is moot.

;Left rotate HL circular, cheap method
 ld a,L
 add hl,hl
 rla
 ld L,a

;Right rotate HL circular

 ld a,h
 rr h
 rr L
 rra
 ld h,a
It's up to you to convert that to hex, tho.

EDIT: Problem with the first routine after the next post was posted. It should've been an RLA.

EDIT: Mat isn't here to edit his post. There was a problem in what I posted before and the converted first routine should have actually used RLA instead of RRA. The corrected routine is thus: Asm(7D29176F)

Many apologies

If individually, the answer becomes fairly trivial. That would be an RLC/RRC ... something on each byte. As a combined unit, you'll have to have a loop of RL/RR's traversing the area that needs to be rotated with the very first byte of it being saved someplace so when the loop ends, you can rotate the trailing bit into that and reload that as the first bit to simulate a complete rotation.

Thanks for the input guys. @calc84maniac Sorry for not being clear, I would like to rotate each byte left and then add them together. So for example, using 1011011010010110, I'd like to rotate 0000000010010110 (255 and 1011011010010110), then rotate 1011011000000000 (65280 and 1011011010010110) and then add them together.

Is Asm(7D291F6F) still the correct routine for a left rotation?

Since I haven't learnt about asm yet (I'm planning to), what would I input to the routine and how?

Thanks!

By "add them together", do you mean the arithmetic operation "add" or the combining of the two binary strings (concatenate) ? From what you're saying, you want each to be rotated individually in the absence of each other? If that's the case, then you'll want something completely different than what we've supplied.

What is it that you're trying to accomplish?

Yes, that's what I would like to do I'd like to rotate the first 8 bits of the two byte number by 1 bit and then rotate the last 8 bits of the two byte number (adding zeros for the first 8 bits) and then add (+) the two rotations together.

What I'm doing is making a remake of an old game from the 80's. This game used procedural generation to generate 8 galaxies and it got the generations seeds for each one by rotating each starting seed by one bit, on the 8th rotation it would return to the fist seed, hence sending you back t the first galaxy.
For clarification, the first value of 1 of the 3 seeds is 231114 and the first rotation will set it to 46228.

I have some axe code that works on my calculator (below), but it doesn't function the same in SC3 on Cemetech.net

.A
23114->A. Seed 1
584->B.Seed 2
46931->C.Seed 3

For(E,0,8)
ClrHome
A->D
sub(ROT).D is input, W is output
W->A
B->D
sub(ROT)
W->B
C->D
sub(ROT)
W->C
Disp A>Dec,[i],B>Dec,[i],C>Dec
Pause 10400
End
Return

Lbl ROT
(D and 255)->U.Getting the first 8 bits
(D and 65280)->V.Getting the last 8 bits
(2*U) or (U/e^(7))->W
(2*V) or (V/e^(15))+W->W
Return