Complex cloack idea (too complex for now :):):))

Hello,

Here is a complex cloack idea:

The idea is to assign a code to each possible instructions.

There are like 16 instructions or so or whatever.

Each instruction has it's own code.

Only problem is with modifiers and operators.

So that would make the different ammount of instructions huge.

Maybe warriors could be limited to a certain range of instruction
combinations.

Then the instruction code itself gets loaded into p-space as well.

Now the idea is to use a little pointer which gets loaded from p-space which
makes it point to the correct instruction, then load the parameters from
p-space into that location and then execute the instruction... then clear it
again and load next instruction... like sorta a mini cpu.

This to prevent too many instructions from showing.

It sounds complex but maybe it's not so complex at least not the decoding:

InstructionTable
instruction
instruction
instruction


Now decode:

LoadInstructionCode from p-space into pointer
LoadInstructionParameterA to pointer instruction
LoadInstructionParameterB to pointer instruction
ExecuteInstructionPointer

only problem is with last statement... that's nasty.
and ofcourse other nasty problems with jumps and such.

Oh well, way too complex, I'll forget about this idea for now

Bye,
Skybuck.

On Jan 26, 5:27 am, "Skybuck Flying" <s....RemoveThis@hotmail.com> wrote:
> Hello,
>
> Here is a complex cloack idea:
>
> The idea is to assign a code to each possible instructions.
>
> There are like 16 instructions or so or whatever.

This isn't going to work in coresize 8000, but maybe on one of the
Large hills where you have more room. You could limit the instruction
set to just those combinations you need, no one uses all the opcode/
modifier/indirect/value combinations. Then pre-compress the program
into an array of values and a small decoder. In the first round move
the array into p-space. After that, just boot the decoder somewhere
into core and you are all set.

P. Kline