THE LEVEL SELECTION MENU
========================

WHEN YOU START THE GAME, YOU WILL SEE THE LEVEL SELECTION MENU.

THERE ARE TWO MAIN PARTS. ON THE LEFT, THERE'S A LIST OF LEVELS AVAILABLE TO PLAY. A TICKED LEVEL MEANS THAT AT LEAST ONE OF THE PROGRAMS HAS PASSED THE TEST. TO SELECT A LEVEL, JUST CLICK IT.

ON THE RIGHT, THERE'S INFORMATION ABOUT THE SELECTED LEVEL. THE SECTION AT THE TOP SHOWS THE INSTRUCTIONS FOR THE LEVEL.

UNDER THAT, THERE ARE THREE COLUMNS. EACH COLUMN SHOWS INFORMATION ABOUT THE THREE POSSIBLE PROGRAMS YOU CAN WRITE FOR THE LEVEL.

THE HEADER OF THESE COLUMNS SHOWS THE 'EDIT' BUTTON (WHICH WILL TAKE YOU TO THE PROGRAM EDITING SCREEN), A CHECKBOX SHOWING IF THE PROGRAM HAS PASSED THE TEST, AND THE 'DEL' BUTTON (WHICH WILL SHOW THE CONFIRMATION BOX TO DELETE THE PROGRAM).

UNDER EACH HEADING, THERE'S A LONG COLUMN SHOWING THE CODE OF EACH PROGRAM.

THE PROGRAM EDITING MENU
========================

ON THE LEFT-HAND SIDE OF THE SCREEN THERE ARE THREE COLUMNS LABELLED 'INPUT', 'TARGET', AND 'OUTPUT'. THE GOAL OF THE GAME IS TO USE THE INPUT VALUES TO OUTPUT THE SAME VALUES AS THE ONES UNDER THE TARGET COLUMN. IF THE TARGET AND THE OUTPUT COLUMNS AREN'T EXACTLY THE SAME, THE PROGRAM WON'T BE CONSIDERED SUCCESSFUL.

THE CENTRE SECTION CONSTAINS THE LEVEL INSTRUCTIONS AT THE TOP, THE EVENTUAL ERROR MESSAGES AT THE BOTTOM, AND YOUR PROGRAM IN THE MIDDLE. THIS IS WHERE YOU'RE GOING TO WRITE YOUR PROGRAM.

THE RIGHT PART OF THE SCREEN SHOWS THE MEMORY SECTION (SEE THE 'MEMORY' SECTION) WITH THE VALUES FOR THE REGISTERS. UNDER THAT, THERE ARE THE CONTROL BUTTONS.

THE 'STEP' BUTTON WILL RUN THE PROGRAM LINE BY LINE. IF THE PROGRAM REACHES THE BOTTOM, IT WILL MOVE TO THE FIRST LINE.

THE 'RUN' BUTTON WILL CONTINUOUSLY RUN THE PROGRAM UNTIL THERE'S AN ERROR, THE LEVEL IS FINISHED, OR THE 'STOP' BUTTON IS PRESSED. IF THE PROGRAM REACHES THE BOTTOM, IT WILL MOVE TO THE FIRST LINE.

THE 'STOP' BUTTON WILL STOP AND RESET THE EXECUTION OF THE PROGRAM.

THE 'HELP' BUTTON WILL SHOW THIS.

THE 'MENU' BUTTON WILL TAKE YOU BACK TO THE LEVEL SELECTION MENU.

THE MEMORY
==========

THE MEMORY TABLE IS ON THE RIGHT-HAND SIDE OF THE PROGRAM EDITING SCREEN. THIS TABLE SHOWS ALL THE TEN REGISTERS AVAILABLE AND THEIR CURRENT VALUES.

ALL REGISTERS START WITH A VALUE OF 0, AND THEY ARE REFERRED TO BY THEIR LETTERS (A-F) IN THE PROGRAM.

REGISTER 'A' IS SPECIAL. IT'S CALLED THE 'ACCUMULATOR'. IT HOLDS THE RESULTS OF ALL OPERATIONS IN THE PROGRAMS. FOR EXAMPLE, WHEN USING THE 'ADD' INSTRUCTION, THE RESULT WILL BE STORED IN THE ACCUMULATOR.

THE Z-1 PROGRAMMING LANGUAGE
============================

THE Z-1 PROGRAMMING LANGUAGE IS A VERY SIMPLE, ASSEMBLY-LIKE LANGUAGE.

THE INSTRUCTIONS AVAILABLE ARE: 'IN', 'OUT', 'NEG', 'LD', 'ADD', 'SAV', 'JP', 'JPZ', 'JPN', 'JPG', AND 'JPL'.

Z-1 ALSO SUPPORTS LABELS INDENTIFIED WITH A COLON AFTER THE LABEL NAME (E.G.: 'LOOP:'). LABELS NEED TO BE IN THEIR OWN LINE (A LINE SUCH AS 'LOOP: IN' WILL THROW A SYNTAX ERROR). LABELS ARE USED FOR JUMP INSTRUCTIONS.

IN
==

THE INSTRUCTION 'IN' WILL READ A VALUE FROM THE INPUT COLUMN AND STORE IT IN THE ACCUMULATOR (REGISTER 'A').

IF THERE ARE NO MORE INPUT VALUES TO READ, THE PROGRAM WILL THROW AN ERROR.


EXAMPLE PROGRAM:
----------------
[INPUT = 25]
  IN [A = 26]

OUT
===

THE INSTRUCTION 'OUT' WILL OUTPUT THE VALUE OF THE ACCUMULATOR (REGISTER 'A') TO THE OUTPUT COLUMN.

IF THE OUTPUT VALUE IS DIFFERENT FROM THE TARGET VALUE, IT WILL BE MARKED IN RED AND THE PROGRAM WILL BE CONSIDERED UNSUCCESSFUL.


EXAMPLE PROGRAM:
----------------
[INPUT = 12]
  IN [A = 12]
  OUT [OUTPUT = 12]

NEG
===

THE 'NEG' (NEGATE) INSTRUCTION WILL INVERT THE SIGN OF THE VALUE IN THE ACCUMULATOR, MAKING A NEGATIVE NUMBER POSITIVE, AND A POSITIVE NUMBER NEGATIVE.

THE NEGATED VALUE WILL BE STORED IN THE ACCUMULATOR.


EXAMPLE PROGRAM:
----------------
[INPUT = 45]
  IN [A = 45]
  NEG [A = -45]

[INPUT = -2]
  IN [A = -2]
  NEG [A = 2]
	
[INPUT = 0]
  IN [A = 0]
  NEG [A = 0]

LD
==

THE 'LD' (LOAD) WILL LOAD A NUMERIC VALUE TO THE ACCUMULATOR. THE VALUE MUST BE PASSED AS A PARAMETER.


EXAMPLE PROGRAM:
----------------
  LD 86 [A = 86]
	
  LD 0 [A = 0]
	
  LD -11 [A = -11]

SAV
===

THE 'SAV' (SAVE) INSTRUCTION WILL COPY THE ACCUMULATOR VALUE INTO A REGISTER THAT MUST BE PASSED AS A PARAMETER.


EXAMPLE PROGRAM:
----------------
[INPUT = 44]
  IN [A = 44]
  SAV B [B = 44]

ADD
===

  THE 'ADD' INSTRUCTION WILL ADD THE VALUE OF THE SPECIFIED REGISTER TO THE ACCUMULATOR. THE RESULT WILL BE STORED IN THE ACCUMULATOR.


EXAMPLE PROGRAM:
----------------
[INPUT = 7]
  IN [A = 7]
  SAV B [B = 7]
[INPUT = 2]
  IN [A = 2]
  ADD B [A = 9]

[INPUT = 32]
  IN [A = 32]
  ADD A [A = 64]
	
[INPUT = -7]
  IN [A = -7]
  SAV C [C = -7]
[INPUT = 1]
  IN [A = 1]
  ADD C [A = -6]

JP
==

THE 'JP' (JUMP) INSTRUCTION WILL MOVE THE PROGRAM EXECUTION TO THE NEXT LINE AFTER THE SPECIFIED LABEL. THIS IS AN UNCONDITIONAL JUMP.


EXAMPLE PROGRAM:
----------------
  LD -1 [A = -1]
  SAV B [B = -1]
  LOOP:
[INPUT = 10]
  IN [A = 10]
  ADD B [A = 9]
  OUT [OUTPUT = 9]
  JP LOOP [MOVE TO LINE AFTER 'LOOP:']

JPZ
===

THE 'JPZ' (JUMP IF ZERO) INSTRUCTION WILL MOVE THE PROGRAM EXECUTION TO THE NEXT LINE AFTER THE SPECIFIED LABEL IF THE ACCUMULATOR VALUE IS 0. IT WILL CONTINUE EXECUTION NORMALLY OTHERWISE. THIS IS A CONDITIONAL JUMP.


EXAMPLE PROGRAM:
----------------
[INPUT = 10]
  ZERO:
  IN [A = 10]
  JPZ ZERO ['A' ISN'T 0, SO JUMP WON'T HAPPEN]
	
[INPUT = 0]
  ZERO:
  IN [A = 0]
  JPZ ZERO ['A' IS 0, SO JUMP WILL HAPPEN]

JPN
===

THE 'JPN' (JUMP IF NOT ZERO) INSTRUCTION WILL MOVE THE PROGRAM EXECUTION TO THE NEXT LINE AFTER THE SPECIFIED LABEL IF THE ACCUMULATOR VALUE ISN'T 0. IT WILL CONTINUE EXECUTION NORMALLY OTHERWISE. THIS IS A CONDITIONAL JUMP.


EXAMPLE PROGRAM:
----------------
[INPUT = 10]
  NOTZERO:
  IN [A = 10]
  JPN NOTZERO ['A' ISN'T 0, SO JUMP WILL HAPPEN]
	
[INPUT = 0]
  NOTZERO:
  IN [A = 0]
  JPN NOTZERO ['A' IS 0, SO JUMP WON'T HAPPEN]

JPG
===

THE 'JPG' (JUMP IF GREATER THAN ZERO) INSTRUCTION WILL MOVE THE PROGRAM EXECUTION TO THE NEXT LINE AFTER THE SPECIFIED LABEL IF THE ACCUMULATOR VALUE IS GREATER THAN 0. IT WILL CONTINUE EXECUTION NORMALLY OTHERWISE. THIS IS A CONDITIONAL JUMP.


EXAMPLE PROGRAM:
----------------
[INPUT = 10]
  GTZ:
  IN [A = 10]
  JPG GTZ ['A' IS GREATER THAN 0, SO JUMP WILL HAPPEN]
	
[INPUT = 0]
  GTZ:
  IN [A = 0]
  JPG GTZ ['A' ISN'T GREATER THAN 0, SO JUMP WON'T HAPPEN]
	
[INPUT = -3]
  GTZ:
  IN [A = -3]
  JPG GTZ ['A' ISN'T GREATER THAN 0, SO JUMP WON'T HAPPEN]

JPL
===

THE 'JPL' (JUMP IF LESS THAN ZERO) INSTRUCTION WILL MOVE THE PROGRAM EXECUTION TO THE NEXT LINE AFTER THE SPECIFIED LABEL IF THE ACCUMULATOR VALUE IS LESS THAN 0. IT WILL CONTINUE EXECUTION NORMALLY OTHERWISE. THIS IS A CONDITIONAL JUMP.


EXAMPLE PROGRAM:
----------------
[INPUT = 10]
  LTZ:
  IN [A = 10]
  JPG LTZ ['A' ISN'T LESS THAN 0, SO JUMP WON'T HAPPEN]
	
[INPUT = 0]
  LTZ:
  IN [A = 0]
  JPG LTZ ['A' ISN'T LESS THAN 0, SO JUMP WON'T HAPPEN]

[INPUT = -3]
  LTZ:
  IN [A = -3]
  JPG LTZ ['A' IS LESS THAN 0, SO JUMP WILL HAPPEN]

EXAMPLE CODE: DOUBLE
=======================

TO DOUBLE A VALUE, ADD THE ACCUMULATOR VALUE TO ITSELF.

THIS CODE OUTPUTS THE INPUT VALUE DOUBLED:
  IN
  ADD A
  OUT

EXAMPLE CODE: SUBTRACTION
=========================

Z-1 DOESN'T HAVE A SUBTRACT INSTRUCTION. SO, TO SUBTRACT A VALUE, SAVE A NEGATE VALUE AND THEN ADD IT TO THE ACCUMULATOR.

THIS CODE OUTPUTS THE INPUT VALUE MINUS 7:
  LD -7
  SAV B
  IN
  ADD B

EXAMPLE CODE: LOOP
==================

YOU WILL NEED A CONDITIONAL JUMP TO CREATE A LOOP.

THIS CODE OUTPUTS ALL THE NUMBERS FROM THE INPUT VALUE DOWN TO ZERO:
  LD -1
  SAV B
  START:
  IN
  LOOP:
  OUT
  ADD B
  JPL START
  JP LOOP

EXAMPLE CODE: LOAD VALUE FROM REGISTER
======================================

TO GET THE VALUE OF A REGISTER INTO THE ACCUMULATOR, YOU'LL HAVE TO USE THE 'ADD' INSTRUCTION.

THIS CODE RECOVERS THE VALUE OF REGISTER 'B' TO THE ACCUMULATOR:
  LD 0
  ADD B