// AI begins here

do not include class Letter.

!include once #1002637 // substring

!include once #1000810 // join

!include once #1007089 // lastIndexOf

!include once #1003421 // padLeft

!include once #1002071 // trim

// copied from main.java in preliminary IDEA project

// from "static class Smarty" to

// "JavaX standard functions & classes"

concept Smarty {

    int IntensityRange;

    String[] Sense = new[10+1];

    boolean Processing50;

    int MaxBodies;

    transient TheWorld World;

    new Bodies bodies;

    static class TheWorld {

        public String LookUnder() {

            return "";

        }

        public void MoveWest() {

        }

        public void MoveSouth() {

        }

        public void MoveEast() {

        }

        public void MoveNorth() {

        }

        public void PointUnder() {

        }

        public void PointNorth() {

        }

        public void PointSouth() {

        }

        public void PointWest() {

        }

        public void PointEast() {

        }

        public void DisplayStimuliAndResponse(int[][][] sensorValues, char resp) {

        }

        public int RangeSouth() {

            return 0;

        }

        public int RangeNorth() {

            return 0;

        }

        public int RangeEast() {

            return 0;

        }

        public int RangeWest() {

            return 0;

        }

        public S LookSouth() {

            return "";

        }

        public S LookNorth() {

            return "";

        }

        public S LookEast() {

            return "";

        }

        public S LookWest() {

            return "";

        }

        public void Update_View() {}

        public void setBinonDisplayObjList(S text) {}

        public void setBinonDisplayChngResults(S text) {}

        public void appendBinonDisplayChngResults(S text) {}

        public void showSensorValues(S text) {}

        public void showDeviceValues(S text) {}

    } // end of TheWorld

    String VB_Name = "Adaptron";

    // Originally was a TEST VERSION WHICH PRODUCES RANDOM INPUT AND

    //CHECKS MEMORY TO SEE IF IT CONTAINS THE SAME STUFF

    //Obviously must have spun it off of Think 5

    // Adaptron/Cognitron Algorithm - Program  - Feb. 2003 test

    // (C) Copyright 2007, Adaptron Inc.

    //

    //THINK3 IS NOT HANDLING CONSCIOUS HABITS PROPERLY

    //THINK4 IS EXPERIMENT IN EXPECTATIONS BEING SAVED

    //THINK5 DOES A PROPER JOB OF HANDLING R-HABITS

    //11 July 2002 - attempting to get the 2 bugs out of pattern matching

    //13th July 2002 - put back the stimulus matching mem location use for

    // habit continuation checking in the right order - resulting stimulus

    // first then is it an expected trigger.

    //pattern4 - July 28, format display better

    //pattern5 - July 29 week - trace display improvements -got out bug in

    //           habit collapsing

    //pattern6 - Aug 3 - test some more

    //pattern7 - Aug 9 - more tests with manual input, THEN AUTOMATED AGAIN

    //pattern8 - Aug 13 - I did top and bottom expected stimuli in habit in

    //           previous version - now I need to introduce expected stimuli

    //           in the habit stack fixed up Context saving too - but I think

    //           some context could be put in LTM for pattern matching on

    //           context so it doesn't get too long or do pattern matching on

    //           context while in STM.

    //Pattern9 - incorporate thinking changes from Think8 and turn on responses

    //Went back to the THINK versions and incorporated results from Pattern9

    //THINK7 DOES A PROPER JOB OF HANDLING R-HABITS

    //THINK8 Well documented version

    // Fixed up some stuff and comments and made it into ACTIONS8.BAS Aug 16th 2002

    //ACTIONS8 - Work on comments and then responses -Then went back to Pattern

    //versions and worked on Pattern0 -Active Habits that fail attract attention

    //and then incorporated these results into Actions8.

    //Actions9   - Started to investigate response habits - fixed up

    //             NOADDSHABITS and removed NOADDHABITS.

    //ACTION10   - Make no distinction between doing nothing and doing something

    //             until the last minute when go to do it.

    //           - Refine priority of what attracts attention especially for

    //             familiar input.

    //EXPLORE1   - Test it out

    //EXPLORE2   - Improve context saving. Use 16 bit memory locations.

    //           - HAVING PROBLEM WITH HABIT MATCHING - CREATE NEW VERSION

    //EXPLORE3   - Change habit stack so current one is on top and any ADDSHABITS

    //             are below it. Stopped it using context in habits being done.

    //EXPLORE4   - Removed code for context saving.

    //Explore5   - Visual Basic 6 Version with different windows for LTM, STM etc.

    //             Boredom turned on for current stimulus and result

    //             habitualized and this habit has a familiar or novel result

    //             based on InterestLevel. Old Boredom code commented out.

    //Explore6   13th July 2003 Try to make feelings of novel, familiar etc.

    //             into a new stimulus type which result in information about

    //             success or failure.

    //           12th Aug 2003 Decided not to do this. Instead am

    //             going to add R-Habits. Decided R-Habits already taken care

    //             of. Added continuous stimuli from both senses. Investigate

    //             looping behaviour and subconscious habit execution. Haven't

    //             done looping but it seems pretty stable.

    //Explore7   11th Sept 2003 Now work on subconscious habit execution.

    //             Add loop execution in subconscious habits

    //           24th Sept Allow multiple stimuli on S-List - 1 external &

    //             1 internal stimulus. Then fix bugs / features

    //Explore8   1st Oct 2003 Now work on R-habits and their execution.

    //Explore9   6th Nov 2003 Major change required in how memory stored and

    //           used - less emphasis on efficiency and episodic accuracy.

    //           Added multiple S-habit recognition and context of S-habit

    //           Added conscious looping of permanent S-habits

    //Happy1     25th Nov 2003 Add in pain and pleasure. 11th Dec Added

    //           expectation of Novel as Interesting - exploration is better.

    //Happy2     17th Dec 2003 First attempt at adding thinking

    //           7th Jan 2004 small changes

    //Happy3     10th Jan 2004 turn off separate Trigger and Result stimuli,

    //           add control flags for it and DoingReflex.

    //Happy4     13th Jan,Seperate permanence property from feeling for stimuli

    //           Add Response Habits containing Response-Stimulus-Response

    //           Get looping (repeating same stimulus) working properly

    //Happy5     20th Jan, getting permanent working, remove stimulus roles

    //Happy6     21st Jan, handle dynamic environments

    //Happy7     23rd Jan, Try handling S-Habits as R-Habits-no go.

    //Happy8     27th Jan, Try to get R-habits as R-S-R working. Feb 12th. Add

    //           subconscious processes.

    //Happy9     23rd Feb, Novel stimulus becomes interesting, then familiar

    //           Enhance thinking, strategies for handling Interesting

    //Works1     6th Mar, 2004, Attend to stimuli

    //Works2     30th March, Expectation processing

    //Works3     31st March, Stimulus context in LTM for S-Habits too.

    //Works4     8th Apr, Recognize loops in R-Habits, Good/Bad testing

    //Works5     15th Apr, turn on Kinesthetics, do subconscious habits

    //Works6     work on repetition / loops

    //Works7     18th July 2004, new learning strategy, Test Cases

    //Works8     29th July, Good and Bad processing

    //Works9     7th Sept, Generalization & Discrimination - 2 or more senses

    //           and subconscious habit processing

    //Learn1     18th Sept, Conscious versus subconscious behaviour, added

    //           levels and context at end of LTM

    //Learn2     3rd Nov, Kinesthetic stimuli, loops, action habits

    //Learn3     23rd Nov, Rename things, subconscious A-Habits, A-sequences

    //Learn4     6th Dec, Chained A-Habits, Concentration, A-Sequences

    //Learn5     6th Jan, 2005, A&B sequence, thinking refined, kinesthtics,

    //           order of For's, Separate world

    //Learn6     World front-end, ABC repeating pattern & permanent S-Habits

    //Learn7     Body info, still working on S-Habits, R-Habits, separate body

    //Learn8     11 May 05, separate body & Test Cases, R-Habits, P-Stimuli,

    //           Difference in R-Habits

    //Learn9     21 June 05, 31st Dec 05, removed linked habits, novelty/familarity

    //           stored as feeling, work on 2nd sense and R-Habits

    //Habit1     3rd March 06, New attention algorithm, only collapse permanent

    //           triggers of S-Habits, practice non-permanent S-Habits

    //Habit2     March - Interestlevel based on A & S-Habit feelings

    //Habit3     March - Good & Bad, Reward & Punishment, Feelings

    //Habit4     Jan 2007 reworking interest levels

    //Habit5     29th Jan 07, S-habits collapse when both stimuli are permanent

    //           A-habits interest propagate back to trigger, S-Habits interest

    //           propagates up the heirarchy.

    //Habit6     16th Feb 07, Rearrange attention algorithm

    //Habit7     14th March 07, Add graduated stimuli

    //Habit8     25th March 07, New attention algorithm

    //Habit9     3rd April 07, Sort out permanent stimuli, attention algorithm

    //Cogni1     18th April 07, Work on thinking part, replace feature with sensor

    //           Recog1, Recog2 Recognition of objects from graduated senses.

    //           Add discrete Sensor Array, discrete and graduated sensors

    //Cogni2     New interest derivation for experiences, new expected interest

    //Cogni3     27th July 07, Each Habit has its own expected interest

    //In here I worked on lines

    //Cogni5     Sept 07, Reworking multiple sensors with graduated values

    //Cogni6     Oct 12, 07,  New S-Habit matching and find difference, multi-sensors

    //Cogni7     Oct 28, 07, Multi-sensors

    //Cogni8     Nov 16, 07, Use recency to solve which S-Habit to attend to. Change

    //           action selection strategy, use FindInstead, not FindDifference

    //Cogni9     Nov 25, 07, Bucket stimuli readings, Change as a stimulus

    //Grad1      Dec 14, 07, Graduated sensors, S-Habits use LTM pointers

    //Grad2      Feb 4, 2008,  sequences of graduated stimuli - C-Habits, generalization

    //Grad3      Feb 14, 2008, Change as stimulus, new S-Habit structure

    //Grad4      Feb 26, 2008, new S-Habit structure

    //Grad5      Mar 9, 2008,  new S-Habit structure

    //Grad6      April 2008, Remove Change as a stimulus - objects represent the changes experienced

    //In here I worked on lines and developed course 447

    //Grad7      Jan 2009, Subconscious action habits, Interest levels

    //Grad8      Feb 2009, new S-Habit structure changes

    //Grad9      Mar 20, 2009, Overlapping parts of S-habits, add line recognition from Sense1

    //Ideas1     April 18, 2009, Add change objects, get thinking working and upto testcase #25

    //Ideas2     May 19, 2009, Use tree of sense stimuli and P-habits - not on S-List

    //Ideas3     June 17, 2009, Finish conversion of S-List, Conscious Habit rework, attention alg.

    //Ideas4     July 8, P-Habits

    //Ideas5     July 10, Remove context processing, ignore repeating S-Habits,

    //Ideas6     Aug 2, Incorporate new line recognition, Where and Order processing

    //Ideas7     Sept 1st, Partial trigger matching - generalization

    //Ideas8     Sept 15th, Graduated readings, 8th Dec new recognition routines, Change Reading Object

    //Ideas9     Dec 15th, Separation object

    //Change1    Dec 31st, Save Change objects in LTM, Add STM for sequences

    //Change2    Jan 10th, 2010 create SepRdgObj, remove LTM Separs(), move STM process

    //Change3    Feb 2nd, STM processing, new line recognition, sequence recognition

    //Change4    May 2nd, New LTM episodic memory representation, new STM

    //Change5    May 26th, Sequence and Action LTM separated

    //Change6    Jun 13th, new Where obj, STM per Sense & Sensor if independent

    //Change7    Jun 23rd, Interest on sequences in STM, T-List

    //Change8    Jul 4th, P-Habits in STM, Body and World changes

    //Change9    Jul 20th, A_Sequences implemented, Fix STM S-habit recognition / distraction

    //Active1    Jul 31st, Boredom and sub-conscious A-Habits

    //Active2    Aug 12th, Conscious STM and/or A-Habits

    //Active3    Sept 21st, New Sequence recognition, Conscious STM

    //Active4    Oct 7th, Action Habits(practicing & doing), remove partial sequential match,

    //                    Convert interest into a property of all binons

    //Active5    Nov 4th, New binon structure, thinking

    //Active6    Dec 7th, Another new binon structure, fix partial match, remove reset interest

    //Active7    Dec 17th, Separate Change and Interest, reduce interest upon repetition, no concentration

    //Active8    Jan 22nd, 2011 remove permanent, remove current habit, separate S-habit and A-Habits

    //Active9    Feb 12th, New binon structure, P-habits before Sequences, better attention

    //Expect1    Mar 6th,  Expect Interesting, new A-Habit structure, remove dependence concept

    //Expect2    Mar 23rd, Changed DoIt structure, Experiences in STM, Conscious Seq's in STM

    //Expect3    Apr 9th,  New Acton structure, sequential trigger and goal recognition, removed

    //                     Novel and Fresh concepts

    //Expect4    May 3rd,  Add device stimuli, Unexpected, New Acton structure

    //Expect5    Aug 2nd,  Action habits, STM changes

    //Expect6    Sept 4th, STM just recognizes (no expectations), remove orient actons, directed

    //                     attention on expected goal

    //Expect7    Sept 20th,Added UnInteresting

    //Expect8    Oct 4th, New acton structure

    //Expect9    Oct 16th, P-Habits, kinesthetic sense fixed, formation of combo by A-Habit?

    //Practic1   Nov 7th, Sequences and Action Habits

    //Practic2   Nov 15th, STM processing and Permanent

    //Practic3   Dec 12th, Before and after conscious STMs, S-Level 1 stimuli familiar

    //Practic4   Jan 10th, STMs do not create A-Habits, Practice mode - redo-interest

    //Practic5   Jan 31st, Practice and Goal Actons, STM processing conscious sequences

    //Practic6   Feb 15th, P-Habit processing, Directed Attention, sequences of permanent stimuli

    //Practic7   Mar 14th, brought in new pattern recognition

    //Practic8   Apr 7th, new novel/familiar combinations and STM processing, P-Habits working

    //Practic9   Apr 24th, generalization for 2 senses

    //General1   May 23rd, Incorporate new Object Recognition (twice)

    //General2   July 1st, Practice and Thinking, Redo versus goal interest, Random next responses

    //General3   July 11th, A-habits at lowest level first, Unexpected sequential interest

    //General4   July 23rd, Expectation inhibits familiar from attention, should binons come with

    //                       habituation of a repeat sequence built in?

    //General5   12th Jan 2017 - started to document it - going to insert PerceptionAction from Act2

    //15th Jan 2017  'Inserted PerceptionAction() and got Inpu_KeyPress(0 and TestCases working with no babbling output.

    //22nd Jan   'adding motor babbling when known action habits are familiar

    //23rd Jan   'thinking and bodies starting to work

    //24th Jan   'adding body #6 with two senses - vision and motion

    //28th Jan   'Got Thinking Approach #1 working

    //29th Jan   'Make Binon type one of the Binon properties

    //30th Jan   'Create P-Habit combinations for any number of senses = properties

    //2018 Aug 29th  'Clean up code before sending to Jianyong

    //31st Aug   'Renamed it Smarty. Continue to clean up the code

    //25th August 2019

    //           'renaming percpts, actions etc. to conform with the perception-action hierarchy paper

    //DefInt A - Z; //16 bits / 2 bytes

    int JND; //set to 20%

    final static String Smarty = "J"; // J = wingdings happy face

    final static String LeftArrow = chr(239); // "<"

    final static String RightArrow = chr(240); // ">"

    final static String UpArrow = chr(241); // "^"

    final static String DownArrow = chr(242); // "v"

    String FourWay; // "+" - unused

    String Smarty0; // "Smarty0" The initial / default Body name

    String[] BodySetting = new[22]; //Contains the current body being used

    //Bodysetting$(0) contains the number of settings in use

    String BodyConfig; //The values in the configure forms when go to Design or Select

    //For determining if a change has been made.

    String[] BodyValue; //Contain the values read and written to the .BDY file

    //The values on the body configuration forms

    int BodyPointing; //direction body is pointing, 0=East, 1=South, 2=West, 3=North

    //direction body is pointing, 0=East, 1=South, 2=West, 3=North

    transient final int North = 3;

    transient final int East = 0;

    transient final int South = 1;

    transient final int West = 2; //direction body is pointing, 0=East, 1=South, 2=West, 3=North

// --------------------------  Senses and Sensors --------------------------

    int NumSenses; //The number of physical senses, Max of 10, dynamically set in SetUpSense()

    //Currently equals the NumProperties since each sense currently = 1 property type

    int MaxSenses; //Maximum number of senses = max 10 physical senses

    int IsSense; //1, Flag for Senses versus Devices

    //unused String StringSense; //Names of senses, up to 10 physical senses - assigned in SetupSense()

    int[][] Senses = new int[10 + 1][8 + 1]; //Properties of the different senses

    //1st index = Sense number

    //2nd index = Sense property

    String[] SensorStimuli = new String[10 + 1]; //A string of the possible symbolic stimuli for the sensor

    //---- Senses() - 2nd index values - Sense Properties - same used for Devices below

    int PropertyBinonType; //1, Stimulus property binon type e.g. 1 = TextBin or 2 = ContBin

    int SymbolicOrMagnitude; //2, Symbolic or Magnitude indicator

    int LowerRangeLimit; //3, Lower limit of range of values, zero is minimum (65 = "A")

    int UpperRangeLimit; //4, Upper limit of range of values, 255 is maximum (90 ="Z")

    int LinearOrCircular; //5, Linear list or Ring/Circular of values for Magnitude sense, Distance is Linear, Compass degrees are Circular (0 to 360)

    int IntegersOrLogs; //6, Integer Values or Log Values, Temperatures are Integers while Decibels are Logs

    int NumberOfSensors; //7 Number of sensors in sensor array

    int SensorsDependentOrIndependent; //8 are sensors adjacent (dependent) or independent

    int Symbolic; //1, Indicates that the values from this sense are symbolic, range A -> Z

    int Magnitude; //2, Indicates that the values from this sense are numeric, integers, range 0 -> Limit

    int Linear; //1, Indicates that the values go from the lower limit to upper limit

    int Circular; //2, Indicates that the values rap around from the upper limit to 0

    int IntegerValues; //1, Indicates that the values are integer readings

    int LogValues; //2, Indicates that the values are already logs - orders of magnitude

    int Dependent; //1, Sensors in array are beside each other (adjacent)

    int Independent; //2, Sensors are not associated with each other

    //--------------------  Values of stimuli from senses / sensors ------------------------------

    int[][][] SensorValues = new int[10 + 1][2 + 1][1+1]; //Stimulus values from senses/sensors

    //1st index is sense number, currently = property /sense binon type

    //2nd index is what type of information is in the SensorValues(), XQCnt or Valu

    //3rd index is Fired for the most recent stimulus value and Current for the previous

    //---- SensorValues 2nd index values - type of information in SensorValues()

    int Valu; //=1, the value for the stimulus, if symbolic then value = Asc(Symbol$)

    int XQCnt; //=2, the count of times the value has repeated, also used below

    String NoName; //"_", The character used when no letter provided for the IDL value of a TextBin binon

    String Motion; //World.MoveDown() etc set this to indicate the direction the robot moved

    String NoMove; //"-" to indicate there was no motion in the Motion$ stimulus value

    String WheelMovement; //"-flrb..." 'will contains the possible wheel motions

    //WheelMovement$ = "-flrb" & TurnRght$ & TurnLft$ & TurnArnd$ ' rotate right, left and around 180 degrees

    String ABlock;

    static final String Wall = chr(219); //a block, Chr$(219) is a black square in Terminal font

    static final String EmptySquare = chr(177); //Chr$(177) is a fuzzy square in Terminal font

    //---- SensorValues 3rd index values - which past stimulus it is - also used below

    int Fired; //=0 'stimulus put in this level upon firing before being processed

    int Current; //=1 'The Fired one becomes the Current one after processing

    //--------------------  Devices ------------------------------------------------

    int NumDevices; //Number of output devices - max 4 - dynamically set in SetupDevice()

    int MaxDevices; //Maximum number of devices = max 4 devices

    String[] Device = new String[4 + 1]; //Names of device, up to 4 devices - assigned in SetupDevice()

    int IsDevice; //2, Flag for Devices versus Senses

    int[][] Devices = new int[4 + 1][6 + 1]; //Properties of the output / response devices

    //1st index = Device number

    //2nd index = Device property

    String[] DeviceResponses = new String[4 + 1]; //A string of the possible symbolic responses for the device

    //---- Devices() - 2nd index values - Device Properties - DEFINED ABOVE

//  Public PropertyBinonType      '1, Response property binon type e.g. 1 = LetrBin

//  Public SymbolicOrMagnitude    '2, Symbolic or Magnitude indicator

//  Public LowerRangeLimit        '3, Lower limit of range of response values, zero is minimum (97 = "a")

//  Public UpperRangeLimit        '4, Upper limit of range of response values, 255 is maximum (122 = "z")

//  Public LinearOrCircular       '5, Linear list or Ring/Circular of values for Magnitude sense, Distance is Linear, Motor rotations are Circular (0 to 360)

//  Public IntegersOrLogs         '6, Integer Values or Log Values, Temperatures are Integers while Decibels are Logs

//  Public Symbolic               '1, Indicates that the values for this device are symbolic, Range a -> z

//  Public Magnitude              '2, Indicates that the values for this device are numeric, integers, range 0 -> limit

//  Public Linear                 '1, Indicates that the values go from the lower limit to upper limit

//  Public Circular               '2, Indicates that the values rap around from the upper limit to 0

//  Public IntegerValues          '1, Indicates that the values are integer readings

//  Public LogValues              '2, Indicates that the values are already logs - orders of magnitude

    //--------------------  Values of responses to devices ------------------------------

    int[][] DeviceValues = new int[4 + 1][2 + 1]; //Response values for devices

    //1st index is device number, currently = response property binon type

    //2nd index is what type of information is in the DeviceValues(), XQCnt or Valu

    //---- DeviceValues 2nd index values - type of information in DeviceValues() - DEFINED ABOVE

//  Public Valu                   '=1, the value for the response, if symbolic then Symbol$ = Chr$(value)

//  Public XQCnt                  '=2, the count of times the value needs repeating, also used below

    transient final char NoResp = '-'; //"-", The character representing no response for a LetrBin binon

    //c  Public Relax$                 '"-", used for a Relaxing response - currently the same as NoResp$

    //and it is used as the stimulus input of the Motion sense

    boolean WheelsTurn; //If it is false then Smarty displays as an O else it displays as ^><v

    //  Relax$ = NoResp$         '"-", used for Relaxing response - currently the same as NoResp$

    transient final char MoveForward = 'f';

    transient final char MoveToLeft = 'l';

    transient final char MoveToRight = 'r';

    transient final char MoveBackward = 'b'; // f, l, r, b

    static final char TurnRght = 187; //right angle in Terminal font

    static final char TurnLft = 188; //left angle

    static final char TurnArnd = 18; //double arrow

    String NoMoveOrTurn; //"z" indicates Smarty does not have this move ability

// ---------------------------Primitive responses  --------------------------------------

    //unused String[][] Acts = new String[100 + 1][2]; //Primitive responses per device per device type

    int NumActs; //The number of Acts entries in use

    //unused Public MaxActs; //Max is 100

    //Acts properties

    //unused Public DvcType; //0 = The device type number for this device

    //unused Public DvcID; //1 = The device number for this device of the device type

    //unused Public Respns; //2 = The response for this device

    //static Public NullAct; //-1 Used only for Act2 - Indicates that Act1 points to a primitive Acts()

    //unused Public RelaxAct; //1, The 1st act = 1st response in 1st device of 1st device type = a relax

    boolean RotateActs; //Set true if GetNxtResponse rotates through all acts

    //--------------------  The Stimulus Objects (Binons)  -------------------------

    //This is a tree of all stimulus and response representations - Parallel ones from multiple sensors and devices.

    //A binon is made up of 2 source binons (left and right) at the next level down.

    //A binon has many right target and left target binons.

    //For parallel recognition it stimulates both targets when it fires (recognizes its source combination)

    //For sequential performance it is activated by its left target, waits to be triggered by its left source,

    //then activates/does its right source and fires its right target.

    int NumBinons; //Number of objects so far in Binons(), incremented before its use

    //to determine the place where the next new binon will be placed in Binons()

    int MaxBinons; //5000, Max number of binons per type

    boolean OverLimit; //Global flag set when over Binon or Path limit

    int[][] Binons = new int[5000 + 1][14 + 1]; //Objects, parts, percepts, stimuli, responses

    //1st index = binon number

    //2nd index = binon property

    //---- Binon Properties - 2nd index values

    int BType; //1, The type of binon

    int O1; //2, Left source binon pointer

    int TQ; //3, the count of times the trigger has fired

    int O2; //4, Right source binon pointer

    int GQ; //5, the number of times the goal has fired

    int IDL; //6, The ratio value of the binon

    int IntVl; //7, Interest Value (NOVEL, INTERESTING, or Familiar)

    int OLv; //8, Level of object = number of lowest level parts involved

    int SP; //9, Sequential or Parallel property

    int TriggerList; //10, points to the linked list of target binons [Targets()]

    //   for which this binon is the left source binon (not the right source binon).

    int TriggerCount; //11, Count of its sequential right targets, >1 means it has more than one goal

    //    Used for prediction reliability, may be set >1 if needs to be combined with previous

    int GoalList; //12, points to the linked list of target binons [Targets()]

    //   for which this binon is the right source binon (not the left source binon)

    int GoalCount; //13, Count of its sequential left targets, >1 means can not predict its trigger

    //    Used for reliability of determining the cause, may be set >1 if needs to be combined with next

    int AE; //14, Action (Percept - Act) or Attention (Act - Percept) level 1 Sequential binon

    int NullObject; //-1, Indicates the O1 or O2 pointer is not pointing to another binon

    //---- Interest values for Binons(x, IntVl) - must be numeric for comparison purposes

// New - 1st time experienced - attention paid to it

    //---- Interest values for Binons(x, IntVl) - must be numeric for comparison purposes

    final int NOVEL = 3; //3 New - 1st time experienced - attention paid to it

    // To indicate it has been experienced for the second time

    final int INTERESTING = 2; //2 To indicate it has been experienced for the second time

    // Neutral, experienced 2 or 3 or more times

    final int FAMILIAR = 1; //1 Neutral, experienced 2 or 3 or more times

    int NoInterest; //-1 Interest not known yet

    int InterestLevels; //2 or 3 - number of interest levels, 2= Novel and Familiar, 3= Novel, Interesting, and Familiar

    //---- Sequential or Parallel property values for Binons(x, SP)

    int Sequential; //-1

    int Parallel; //+1

    //---- Action or Attention property values for Binons(x, AE) - value = 0 for Parallel Percepts

    int Action; //1

    int Attention; //2

    //---- BinonType property values for Binons(x, BType)

    int MaxBinonTypes; //with 2 senses and 1 device this is =6, 4 senses & 4 devices = 33

    int NumBinonTypes; //= 2^N+1, number of property binons, Percept combination binon types, Action type and

    //the D-Habit response types - set dynamically based on SetupSense() and SetupDevice()

    String[][] BinonTypeName = new String[68 + 1][2 + 1]; //The names and abbreviations for the various binon types

    //---- BinonTypeName$() 2nd index values

    int BinName; //1

    int BinAbbreviation; //2

    //The source types of property binons are 1=TextBin, 2=ContBin. There are N of these

    //and all other Percept combinations such as Name&Cont.

    //There are 2^N-1 Property plus Percept types

    //There is just the one Action type - a sequential combination of the

    //Property binons, Percept binons, response D-Habit binons and/or Action binons.

    int[][] BinonTypes = new int[68 + 1][1 + 2]; //The binon types for stimuli (Percepts 15), ActBin (1) and responses (D-Habits 15)

    //1st index = the type of binon (dimension = NumBinonTypes)

    //2nd index = binon type property

    //---- BinonTypes() - 1st Index values - stimulus and response binon types

    int ActBin; //Binon type for Actions, Expectations, percepts, and action binons = NumPercepts + 1. Dynamically set

    int NumProperties; //N=4, The number of stimulus property binon types - currently one property per sense

    final int NullType = 0; //0, Indicates the type not set, binon will be NullObject

    //---- BinonTypes() 2nd index values

    int SensOrDevNum; //1, Pointer points back to sense or device

//  Public SymbolicOrMagnitude    '2, Symbolic or Magnitude indicator - defined above

    //--------------------  Percept Stimuli Perceived ---------------------------------------

    int[] SensedBinons = new int[1 + 10]; //the source binons for the Percepts() tree (only uses = Numsenses=NumProperties)

    int NumPercepts; //N=63, The number of property binons and Percept combinations of them 2^NumProperties-1

    int MaxPercepts; //=63 currently = (2^6)-1 would need to be (2^10) if 10 sensors

    int[][][] Percepts = new int[1 + 63][1 + 2][2]; //Current and Fired Property binon and Percept IDs and XQ count

    //1st index is the property / Percept binon type (dimension = NumPercepts)

    //2nd index is what type of information is in the Percepts()

    //3rd index is Fired=0 or Current=1

    //---- Percepts 2nd index values - type of information in Percepts()

    int BinId; //=1, the 2nd index value for the binon ID - defined / used below

    //Public XQCnt                  '=2, the count of times the fired binon has been recognized / fired - DEFINED ABOVE

    int[][] PerceptSources = new int[1 + 63][1 + 3]; //pointers to the lower level Percepts that are used in forming this Percept

    //---- PerceptSources() 2nd index values

    int FirstSource; //=1, the first / left source Percept binon

    int SecondSource; //=2, the second / right source Percept binon

    int PerceptLevel; //=3, The level in the Percept tree

    //--------------------  Left and Right Targets ---------------------------------------

    //---  Linked List of Target Binons - for all binons -------------

    int NumTargets; //The number of Target binon entries created so far

    int MaxTargets; //10000 = the max number of Target binon entries possible

    int[][] Targets = new int[1 + 10000][1 + 2]; //pointed to by Binons(ID, TriggerList) or by Binons(ID, GoalList)

    //---- Targets' 2nd index property values

    int NLnk; //1 = The pointer to the next Targets() entry in this linked list,

    //    may be a NullTarget at end of linked list

    int TargetBinon; //2 = a left or right Target binon

    int NullTarget; //=0, an NLnk pointer at end of linked list

    //--------------------  D-Habit Response Produced ---------------------------------------

    //unused int[] RespondedBinons = new int[1 + 2]; //the response binons for the DHabits() tree (only uses = NumDevices=NumResponses)

    int NumDHabits; //N=15, The number of response binons and D-Habit combinations of them 2^NumDevices-1

    //unused int MaxDHabits; //=15 currently = (2^4)-1

    //unused int[][][] DHabits = new int[1 + 15][1 + 2][1 + 1]; //Current and Fired Property binon and Percept IDs and XQ count

    //1st index is the property / Percept binon type (dimension = NumPercepts)

    //2nd index is what type of information is in the Percepts()

    //3rd index is Fired=0 or Current=1

    //---- Percepts 2nd index values - type of information in Percepts()

    //Public BinId                  '=1, the 2nd index value for the binon ID - defined above

    //Public XQCnt                  '=2, the count of times the fired binon has been recognized / fired - DEFINED ABOVE

    //--------------------  Action Stimuli Perceived ---------------------------------------

    int TopLevel; //The highest level with any binons in it in STM

    int HighestPerceptLvl; //The highest STM() entry produced / fired per cycle

    int MaxLevels; //=25, The highest level of complexity to which the tree can grow

    int[][][] STM = new int[25+1][3+1][25+1]; //STM current history of Patterns - a tree with parts at level 1

    //1st index is the stimulus object level

    //2nd index  =1 for binon type, =2 for binon ID, =3 for XQCnt, =4 for TQCnt

    //3rd index  = Fired = 0 for the just fired stimulus

    // = Current = 1 for the Current perceived stimuli

    //They can all be expecting a repeat or a changed / different value

    // = Last one whose position is the last STM entry that has something in it

    //---- STM 2nd index values - type of information in STM()

    //Public BinId                '=1, the binon ID      - DEFINED ABOVE

    //Public XQCnt                '=2, the count of times the fired binon has been recognized / fired / repeated - Defined above

    int TQCnt; //=3, the count of times its trigger fired for repeat size comparison

    //---- STM 3rd index values - which past stimulus is it   - DEFINED ABOVE

//  Public Fired                  '=0   'stimulus put in this level upon firing before being processed

//  Public Current                '=1   'The fired one becomes the current one after processing

    int MoveAmount; //Move right amount to eliminate previous pattern - set in ProcessSTMLevel()

    //--------------------- Conscious Binons -----------------------------------------

    int PerceivedBinon; //predicting/expecting the next binon as the goal. May have 0, 1 or more associating binons.

//--------------------  Long Term Memory (LTM) - Monitoring Info. -------------------------

    //For Display purposes only by Adapt.DUMPLTM in Adapt.LTMem

    //Long term memory contains a list of the stimuli that have been paid attention to.

    //It stores Perceptual sequences as a pair of sequential memory locations.

    int[][] LTMEMORY = new int[2000+1][8+1];

    //1st index is StoreAt cycle number

    //2nd index is what type of information is in the LTM

    //---- LTMEMORY() 2nd index values - type of information in LTMEMORY()

    int LtmPerceptTyp; //1 Percept binon type

    int LtmPerceptBin; //2 Percept binon

    int LtmESType; //3 Type of ES Binon - may be an S

    int LtmESActBin; //4 ES Actbin

    int LtmARType; //5 Type of AR Binon - may be an R

    int LtmARActBin; //6 AR ActBin

    int LtmActionTyp; //7 Action binon type

    int LtmActionBin; //8 Action binon

    int StoreAt; //LTM POSITION OF LAST STIMULUS - location in LTMEMORY() - incremented by PerceptionAction()

    int MaxMemory; //2000

    //----------------------Input/Output History  ----------------------------------------

    //For display by Adapt.HISTORYDISPLAY in Adapt.IO

    String[][] INPUTS = new String[2000][10+1]; //INPUT history - List of sense stimuli for each sense (1 to 10)

    String[][] OUTPUTS = new String[2000][4+1]; //OUTPUT history - List of Responses for each device (1 to 4)

    //--------------------  Other Variables ------------------------------------------

    double SizeBase; //1.2 for a 20% just noticeable difference

    double IntensityBase; //If it is 2.0 then that is a 100% just noticeable difference

    //--------------------  Operational Values - Adaptron --------------------

    String ASpace;

    //char SequentialSign = first(unicode_rightPointingTriangle()); //Chr$(16) ">"

    transient char SequentialSign = '>';

    String ParallelSign; // "+" was Chr$(186) two vertical lines was "/"

    boolean CreateAll; //True if create all combinations

    //False if use only familiar parts

    // *********  Counters, Temporary values, Flags and Pointers  ******

    //---------------------- Operational Values -------------------------------

    int Normal;

    int Happy;

    int Unhappy;

    int PartMatch; //Used as ActTypes for body display

    //unused boolean PracticeMode; //Practicing the PracticeActon. Still performing it.

    //When finished in PracticeMode then we switch to GoalMode.

    //unused Public PracticeActon; //The acton that is being practiced

    //static Public ActiveActon; //The highest level active acton being done subconsciously

    //If set then this is being done subconsciously (not being practiced)

    //static Public DoingAct1; //The Act is being done even though it is not being practiced

    //This does not include the do Relax act

    //unused Public GoalExpected; //Goal expected by Action started - to measure success or failure

    //= 0 if no expectation because doing reflexive response

    //unused Public GoalSoFar; //Keeps track of the part of the expected goal obtained so far

    //unused boolean GoalMode; //Concentrating on the goal of the action being practiced.

    //We have finished the acton execution.

    //If set it will cause directed attention to the GoalExpected

    //unused Public ExpectedGoal; //Goal expected for thinking about

    //unused Public TraceGoal; //Used for Trace - The goal we are either trying to achieve or avoid

    //unused Public MATCHUSE; //Trigger match Action in Actons() that is interesting to do

    //unused Public ActionDesire; //Interest in the MATCHUSE entry for AttendTo

    //unused Public PartialMATCHUSE; //same as MATCHUSE but for partial matches

    //unused Public PartialActionDesire;

    //unused Public PartialTrigger; //set to the partial trigger object if partial trigger true

    //unused boolean ThoughtUsed;

    boolean DoingReaction; //set true if last response was reactive / reflex

    boolean DoingRepeat; //set true if repeating a known response as a reflexive reaction

    int LastAct; //Last reflexive response used from Acts list

    //unused Public NextAct; //The next output act for reflexive response from Acts()

    //unused Public ResponseOutput; //The one output in this cycle for storing in LTM trace

    //unused Public Recency;

    //unused boolean PracticeIt; //Global because used in Trace()

    //unused boolean DoIt; //Global because used in Trace()

    //unused boolean React; //Global because used in Trace()

    int LIN; //Count of how many stimuli have been input/output in INPUTS$() and OUTPUTS$()

    //unused boolean FreezeSList; //When true don't do the DUMPSTIMS any more

    int COUNTIN; //Count of inputs for display of history

    String[] RecentWorld = new String[4]; //The list of recent .WLD files created - kept in RecentWldList.TXT

    String[] RecentBody = new String[4]; //The list of recent .BDY files created - kept in RecentBdyList.TXT

    int OperatingMode; //Either, Running World or just Started

    int Running;

    int Started;

    // *********  Counters, Temporary values, Flags and Pointers  ******

    //unused Public I, J, T, M, H, N, K, P, F, S, Hab;

    //unused Public ThoughtDesire;

    char vbDblQuote;

    //  --------------- Colours --------------

    int Black;

    int White;

    int LightBlue;

    int DarkBlue;

    //                                           End of  (Declarations)

    public void Initialize_Adaptron() {

        //Called only once from World form when it loads, World.Form_Load()

        //Initialize all values that don't change

        FourWay = chr(170);

        Smarty0 = "Smarty0"; //The initial / default Body name

        InitBodySettingsToSmarty0(); //sets the inital values in BodySetting$()

        // --------------------------  Senses and Sensors --------------------------

        MaxSenses = 10; //max no. of physical senses possible in Values$ arrays

        IsSense = 1; // Flag for Senses versus Devices

        //---- Senses() and Devices() - 2nd index values - Sense and device Properties

        PropertyBinonType = 1; // Stimulus property binon type e.g. 1 = TextBin or 2 = ContBin

        SymbolicOrMagnitude = 2; // Symbolic or Magnitude indicator

        LowerRangeLimit = 3; // Lower limit of range of values, zero is minimum (65 = "A")

        UpperRangeLimit = 4; // Upper limit of range of values, 255 is maximum (90 ="Z")

        LinearOrCircular = 5; // Linear list or Ring/Circular of values for Magnitude sense, Distance is Linear, Compass degrees are Circular (0 to 360)

        IntegersOrLogs = 6; // Integer Values or Log Values, Temperatures are Integers while Decibels are Logs

        NumberOfSensors = 7; // Number of sensors in sensor array

        SensorsDependentOrIndependent = 8; // Are sensors adjacent (dependent) or independent

        Symbolic = 1; // Indicates that the values from this sense are symbolic, range A -> Z

        Magnitude = 2; // Indicates that the values from this sense are numeric, integers, range 0 -> Limit

        Linear = 1; // Indicates that the values go from the lower limit to upper limit

        Circular = 2; // Indicates that the values rap around from the upper limit to 0

        IntegerValues = 1; // Indicates that the values are integer readings

        LogValues = 2; // Indicates that the values are already logs - orders of magnitude

        Dependent = 1; // Sensors in array are beside each other (adjacent)

        Independent = 2; // Sensors are not associated with each other

        //--------------------  Values of stimuli from senses / sensors ------------------------------

        //---- SensorValues 2nd index values - type of information in SensorValues()

        Valu = 1; // the value for the stimulus, if symbolic then value = Asc(Symbol$)

        XQCnt = 2; // the count of times the value has repeated, also used below

        NoName = "_"; // The character used when no letter provided for the IDL value of a TextBin binon

        ABlock = "#"; //a # for internal use to indicate a block at the location

        //---- SensorValues 3rd index values - which past stimulus it is - also used below

        Fired = 0; //stimulus put in this level upon firing before being processed

        Current = 1; //The Fired one becomes the Current one after processing

        //--------------------  Devices ------------------------------------------------

        MaxDevices = 4; //Maximum number of devices = max 4 devices

        IsDevice = 2; // Flag for Devices versus Senses

        NoMoveOrTurn = "z"; //"z" indicates Smarty does not have this move ability

        WheelMovement = "-flrb" + TurnRght + TurnLft + TurnArnd; // rotate right, left and around 180 degrees

        NoMove = WheelMovement.substring(0, 1); //"-" to indicate there was no motion in the Motion$ stimulus value

        //--------------------  The Stimulus Objects (Binons)  -------------------------

        MaxBinons = 5000; // Max number of binons per type

        MaxBinonTypes = 68; //with 2 senses and 1 device this is =5

        //---- BinonTypeName$() 2nd index values

        BinName = 1;

        BinAbbreviation = 2;

        //---- BinonTypes() 2nd index values

        SensOrDevNum = 1; // Pointer points back to sense or device

//  SymbolicOrMagnitude = 2  ' Symbolic or Magnitude indicator - initialized above

        //--------------------  Percept Stimuli Perceived ---------------------------------------

        MaxPercepts = 63; // currently based on maxsenses=5 senses=number of property types

        //---- Percepts() 2nd index values - type of information in Percepts()

        BinId = 1; // the 2nd index value for the binon ID - defined / used below

        //XQCnt = 2                ' the count of times the fired binon has been recognized / fired - DEFINED ABOVE

        //---- PerceptSources() 2nd index values

        FirstSource = 1; // the first / left source Percept binon

        SecondSource = 2; // the second / right source Percept binon

        PerceptLevel = 3; // The level in the Percept tree

        //---- Binons() Properties - 2nd index values

        BType = 1; // The type of binon

        O1 = 2; // Left source binon pointer

        TQ = 3; // the count of times the trigger has fired

        O2 = 4; // Right source binon pointer

        GQ = 5; // the number of times the goal has fired

        IDL = 6; // The ratio value of the binon

        IntVl = 7; // Interest Value (NOVEL, INTERESTING, or Familiar)

        OLv = 8; // Level of object = number of lowest level parts involved

        SP = 9; // Sequential or Parallel property

        TriggerList = 10; // points to the linked list of right target binons [Targets()]

        TriggerCount = 11; // Count of its sequential right targets, >1 means it has more than one goal

        GoalList = 12; // points to the linked list of left target binons [Targets()]

        GoalCount = 13; // Count of its sequential left targets, >1 means can not predict its trigger

        AE = 14; // Action (Stimulus - Response) or Attention (Response - Stimulus) level 1 Sequential binon

        NullObject = -1; // Indicates the O1 or O2 pointer is not pointing to another binon

        NoInterest = -1; // Interest not known yet

        InterestLevels = 2; //2 or 3 - number of interest levels, 2= Novel and Familiar, 3= Novel, Interesting, and Familiar

        //---- Sequential or Parallel property values for Binons(x, SP)

        Sequential = -1;

        Parallel = 1;

        //---- Action or Attention property values for Binons(x, AE)

        Action = 1;

        Attention = 2;

        //---  Linked List of Target Binons - for Percepts and Actions -------------

        MaxTargets = 10000; // = the max number of Target binon entries possible

        //---- Targets' 2nd index property values

        NLnk = 1; // = The pointer to the next Targets() entry in this linked list,

        TargetBinon = 2; // = a left or right Target binon

        NullTarget = 0; // an NLnk pointer at end of linked list

        //--------------------  Stimuli Perceived STM() ---------------------------------------

        MaxLevels = 25; // The highest level of complexity to which the tree can grow

        //---- STM 2nd index values - type of information in STM()

        //BinId = 1          ' the binon ID - initialized above

        //XQCnt = 2          ' the count of times the fired binon has been recognized / fired / repeated - initialized above

        TQCnt = 3; // the count of times its trigger fired for repeat size comparison

        //--------------------  Long Term Memory (LTM) - Monitoring Info. -------------------------

        LtmPerceptTyp = 1;

        LtmPerceptBin = 2;

        LtmESType = 3;

        LtmESActBin = 4;

        LtmARType = 5;

        LtmARActBin = 6;

        LtmActionTyp = 7;

        LtmActionBin = 8;

        MaxMemory = 2000;

        //---------------------- Operational Values -------------------------------

        ASpace = " ";

        ParallelSign = "+"; //Was Chr$(186), 'was "/"

        Normal = 0; //Used as ActTypes for body display

        Happy = 1;

        PartMatch = 2;

        Unhappy = 3;

        vbDblQuote = (char) 34; // = "

        Running = 2;

        Started = 1;

        OperatingMode = Started; //Just started so WorldHelp is displayed

        Black = 0x0;

        White = 0xFFFFFF;

        LightBlue = 0xFF8080;

        DarkBlue = 0xC00000;

        change(); // persist changes

    }

    private static String chr(int c) {

        return String.valueOf((char) c);

    }

    public final void GetTypeInfo(int BinTyp, ISetter<String> BinonTyp, ISetter<String> Rdgs) {

        //Returns the names of the BinonTyp$ and Rdg$ for the given BinTyp

//  Public BinonTypeName$(1 To 5, 1 To 2) 'The names and abbreviations for the various binon types

//                '---- BinonTypeName$() 2nd index values

//  Public BinName                '1

//  Public BinAbbreviation        '2

        Rdgs.set("");

        BinonTyp.set("");

        if (BinTyp == NullType) {

            BinonTyp.set("Null");

            Rdgs.set("~  = ");

        } else {

            BinonTyp.set(BinonTypeName[BinTyp][BinName]);

            Rdgs.set(BinonTypeName[BinTyp][BinAbbreviation] + "= ");

        }

    } //End of GetTypeInfo()

    public final int BinonTypeOf(int TheBinon) {

        int tempBinonTypeOf;

        if (TheBinon == NullObject) {

            tempBinonTypeOf = NullType;

        } else {

            tempBinonTypeOf = Binons[TheBinon][BType];

        }

        return tempBinonTypeOf;

    } //End of BinonTypeOf()

    public final void GetValue(int OOO, Var<String> v) {

        //Returns the value for the object based on its Type

        int Readng;

        int TheBinon;

        int LeftBinon;

        //Recursive routine to add values to V$ for any binon/object

        if (OOO == NullObject) {

            return;

        }

//VB TO JAVA CONVERTER NOTE: The following VB 'Select Case' included either a non-ordinal switch expression or non-ordinal, range-type, or non-constant 'Case' expressions and was converted to Java 'if-else' logic:

//  Select Case BinonTypeOf(OOO)

        var tempVar = BinonTypeOf(OOO);

//ORIGINAL LINE: Case ActBin //Public ActBin = sequential - action = NumPercepts+1

        if (tempVar == ActBin) //Public ActBin = sequential - action = NumPercepts+1

        {

            TheBinon = OOO;

            while ping (BinonTypeOf(TheBinon) == ActBin) //While we have an Action

            {

                LeftBinon = TheBinon;

                //Go down the left side to the bottom Property or Percept binon

                while ping (BinonTypeOf(LeftBinon) == ActBin) //While we have an Action

                {

                    LeftBinon = Binons[LeftBinon][O1]; //Get the left source part

                }

                GetValue(LeftBinon, v); //get the property and/or Percept binon

                v.set(v.get() + SequentialSign);

                //Go to the right side and repeat going down its left side

                TheBinon = Binons[TheBinon][O2];

            }

            GetValue(TheBinon, v); //get the last Property or Percept binon on the right side

        }

//ORIGINAL LINE: Case 1 To NumProperties //Senses / property binon

        else if (tempVar >= 1 && tempVar <= NumProperties) //Senses / property binon

        {

            Readng = Binons[OOO][IDL]; //The binons value

            if (BinonTypes[BinonTypeOf(OOO)][SymbolicOrMagnitude] == Symbolic) {

                if (Readng < 32) {

                    v.set(v.get() + "~");

                } else {

                    v.set(v.get() + chr(Readng)); //text

                }

            } else //Else the property is Magnitude

            {

                v.set(v.get() + vbToStr(Readng)); //a number

            }

        }

//ORIGINAL LINE: Case NumProperties + 1 To NumPercepts //Percept binons

        else if (tempVar >= NumProperties + 1 && tempVar <= NumPercepts) //Percept binons

        {

            TheBinon = OOO;

            while ping (BinonTypeOf(TheBinon) > NumProperties) //While we have a Percept

            {

                LeftBinon = TheBinon;

                //Go down the left side to the bottom property binon

                while ping (BinonTypeOf(LeftBinon) > NumProperties) //While we have a Percept

                {

                    LeftBinon = Binons[LeftBinon][O1]; //Get the left source part

                }

                GetValue(LeftBinon, v); //get the property binon

                v.set(v.get() + ParallelSign);

                //Go to the right side and repeat going down its left side

                TheBinon = Binons[TheBinon][O2];

            }

            GetValue(TheBinon, v); //get the last Property binon on the right side

        }

//ORIGINAL LINE: Case ActBin + 1 To NumBinonTypes //A response / device binon

        else if (tempVar >= ActBin + 1 && tempVar <= NumBinonTypes) //A response / device binon

        {

            Readng = Binons[OOO][IDL];

            if (Readng < 32) {

                v.set(v.get() + "~");

            } else {

                v.set(v.get() + chr(Readng)); //symbolic

            }

        }

    } //End of GetValue()

    public final void RememberResponse(int RespBin, int StoreAtPlace) {

        //Save the last response for LTM display

//  Public LTMEMORY&(1 To 2000, 1 To 6) -- comment stefan: not really - it's going to 8

//                                '1st index is StoreAt cycle number

//                                '2nd index is what type of information is in the LTM

//

//                '---- LTMEMORY() 2nd index values - type of information in LTMEMORY()

//  Public LtmPerceptTyp           '1 Percept binon type

//  Public LtmPerceptBin           '2 Percept binon

//  Public LtmESType              '3 Type of ES Binon - may be an S

//  Public LtmESActBin            '4 ES Actbin

//  Public LtmARType              '5 Type of AR Binon - may be an R

//  Public LtmARActBin            '6 AR ActBin

//  Public LtmActionTyp           '7 Action binon type

//  Public LtmActionBin           '8 Action binon

        LTMEMORY[StoreAtPlace][LtmActionTyp] = BinonTypeOf(RespBin);

        LTMEMORY[StoreAtPlace][LtmActionBin] = RespBin;

    } //End of RememberResponse()

    public final void RememberStimulus(int TrigObj, int StoreAtPlace) {

        //Save the given relationship / association in LTM for display

//  Public LTMEMORY&(1 To 2000, 1 To 6)

//                                '1st index is StoreAt cycle number

//                                '2nd index is what type of information is in the LTM

//

//                '---- LTMEMORY() 2nd index values - type of information in LTMEMORY()

//  Public LtmPerceptTyp           '1 Percept binon type

//  Public LtmPerceptBin           '2 Percept binon

//  Public LtmESType              '3 Type of ES Binon - may be an S

//  Public LtmESActBin            '4 ES Actbin

//  Public LtmARType              '5 Type of AR Binon - may be an R

//  Public LtmARActBin            '6 AR ActBin

//  Public LtmActionTyp           '7 Action binon type

//  Public LtmActionBin           '8 Action binon

        LTMEMORY[StoreAtPlace][LtmPerceptTyp] = BinonTypeOf(TrigObj);

        LTMEMORY[StoreAtPlace][LtmPerceptBin] = TrigObj;

    } //End of RememberStimulus()

    public final void SetupSense(int SenseNum, String Sense_Name, String BinonName, String BinonAbbrev, int MagnOrSymb, int LowerLimit, int UpperLimit, String Stimuli, int LinOrCirc, int IntOrLog, int NumSensrs, int SensorDependency) {

        printVars_str SetupSense(+SenseNum, +Sense_Name, +NumSensrs);

        //If the SenseNum passed in is zero this routine returns the Sense number (SenseNum)

        //for the given Sense, else it modifies the given SenseNum

        //The range or number of sensors is NumSensrs - max 256

        //IntensityRange:  is the range or number of intensity values for the sensors

        //Stimuli$:        is a string of possible stimuli for this sensor - saved in SensorStimuli$()

        //Sense_Name$:     is the name of the sense

        //MagnOrSymb:  = Magnitude if each sensor measures a Magnitude range of intensity

        //             = Symbolic if each sensor provides readings that are symbolic.

        //LinOrCirc:   = Linear

        //             = Circular

        //unused String Ssr = null;

        int UseSense;

        //unused String SG = null;

        int Sns;

        var BinTypNum = new Var<>(0);

        String DisplayStimuli;

//  Public NumSenses              'The number of physical senses, Max of 8

//                                'Currently equals the NumProperties since each sense currently = 1 property type

//  Public MaxSenses              'Maximum number of senses = max 8 physical senses

//  Public Sense$(1 To 8)         'Names of senses, up to 8 physical senses

//

//  Public Senses[1 To 8][1 To 6] 'Properties of the different senses

//                                '1st index = Sense number

//                                '2nd index = Sense property

//  Public SensorStimuli$(1 To 10)  'A string of the possible symbolic stimuli for the sensor

//

//                '---- Senses() - 2nd index values - Sense Properties

//  Public PropertyBinonType      '1, Stimulus property binon type e.g. 1 = TextBin or 2 = ContBin

//  Public SymbolicOrMagnitude    '2, Symbolic or Magnitude indicator

//  Public LowerRangeLimit        '3, Lower limit of range of values, zero is minimum (65 = "A")

//  Public UpperRangeLimit        '4, Upper limit of range of values, 255 is maximum (90 ="Z")

//  Public LinearOrCircular       '5, Linear list or Ring/Circular of values for Magnitude sense, Distance is Linear, Compass degrees are Circular (0 to 360)

//  Public IntegersOrLogs         '6, Integer Values or Log Values, Temperatures are Integers while Decibels are Logs

//  Public NumberOfSensors        '7  Number of sensors in sensor array

//  Public SensorsDependentOrIndependent '8 are sensors adjacent (dependent) or independent

//

//  Public Symbolic               '1, Indicates that the values from this sense are symbolic, range A -> Z

//  Public Magnitude              '2, Indicates that the values from this sense are numeric, integers, range 0 -> Limit

//

//  Public Linear                 '1, Indicates that the values go from the lower limit to upper limit

//  Public Circular               '2, Indicates that the values rap around from the upper limit to 0

//

//  Public IntegerValues          '1, Indicates that the values are integer readings

//  Public LogValues              '2, Indicates that the values are already logs - orders of magnitude

//

        if (NumSenses == MaxSenses) //Can't assign another new sense number

        {

            Stop();

        }

        //There are only so many senses in SensorValues array

        //currently set to 8 in Adaptron.Initialize_Adaptron()

        if (SenseNum == 0) //don't have a sense number yet so assign and return it

        {

            NumSenses = NumSenses + 1; //The new sense number for this sense

            SenseNum = NumSenses; //The returned sense number

        } else if (SenseNum > MaxSenses) //else it is more than allowed

        {

            Stop();

        } else if (SenseNum > NumSenses + 1) //else is it higher than the next one available

        {

            Stop();

        } else if (SenseNum <= NumSenses) //else use the one passed in - overriding an existing sense

        {

        } else if (SenseNum == NumSenses + 1) //else is it equal to the next one available

        {

            NumSenses = SenseNum; //which equals NumSenses + 1

        }

        UseSense = SenseNum;

        if (NumSensrs > 8) //only 8 sensors allowed per sense for now - maybe only

        {

            Stop();

        }

        //need this limit if independent sensors

        if (IntensityRange > 256) //only 256 values allowed for intensity

        {

            Stop();

        }

        Sense[UseSense] = Sense_Name;

        Senses[UseSense][SymbolicOrMagnitude] = MagnOrSymb;

        Senses[UseSense][LowerRangeLimit] = LowerLimit;

        Senses[UseSense][UpperRangeLimit] = UpperLimit;

        SensorStimuli[UseSense] = Stimuli; //If not "" these take preference over the upper and lower limit

        if (Senses[UseSense][SymbolicOrMagnitude] == Magnitude) //Magnitude READINGS

        {

            Senses[UseSense][LinearOrCircular] = LinOrCirc; //can be circular or linear

            SensorStimuli[UseSense] = ""; //can not have symbolic list

        } else //Symbolic readings can not be circular

        {

            Senses[UseSense][LinearOrCircular] = Linear; //non circular

        }

        Senses[UseSense][IntegersOrLogs] = IntOrLog;

        Senses[UseSense][NumberOfSensors] = NumSensrs;

        Senses[UseSense][SensorsDependentOrIndependent] = SensorDependency;

        //SetupBinonTypes(SenseOrDeviceNum, BinNam$, BinAbb$, IsASense, BinonTypReturned)

        SetupBinonTypes(UseSense, BinonName, BinonAbbrev, IsSense, BinTypNum);

        Senses[UseSense][PropertyBinonType] = BinTypNum.get(); //Currently BinonType = Sense = property binon

        //and fill in sense info on world page

        new StringBuilder sensorInfo;

        for ping (Sns = 1; Sns <= NumSenses; Sns++) {

            if (Senses[Sns][SymbolicOrMagnitude] == Magnitude) {

                DisplayStimuli = StringHelper.trim(String.valueOf(Senses[Sns][LowerRangeLimit]), ' ') + " to" + Senses[Sns][UpperRangeLimit];

            } else //symbolic values

            {

                if (SensorStimuli[Sns].equals("")) //If no symbolic list then use upper and lower limit

                {

                    DisplayStimuli = chr(Senses[Sns][LowerRangeLimit]) + " to " + chr(Senses[Sns][UpperRangeLimit]);

                } else {

                    DisplayStimuli = SensorStimuli[Sns];

                    DisplayStimuli = replace(DisplayStimuli, NoMoveOrTurn, ASpace);

                }

            }

            sensorInfo.append(takeFirst(8, Sense[Sns] + ":        ")

              + " " + DisplayStimuli + "  " + SymbOrMagn(IsSense, Sns) + "\r\n");

        }

        World.showSensorValues(str(sensorInfo));

    } //End of SetupSense()

    private static void Stop(S msg default "STOP") {

        throw new RuntimeException(msg);

    }

    public final void SetupVision() //Called from DesignBody.UseThisBody_Click()

    {

        int VisionSense;

        int MS = 0;

        int ll = 0; // renamed because of clash with JavaX's LL

        int UL = 0;

//    BodySetting$(7) = VisionConfig.VisionDown

//    BodySetting$(8) = VisionConfig.VisionLeft

//    BodySetting$(9) = VisionConfig.VisionRight

//    BodySetting$(10) = VisionConfig.VisionInFront

//    BodySetting$(11) = VisionConfig.VisionBehind

//    BodySetting$(12) = VisionConfig.VisionSymbolicOrMagnitude(0)

//    BodySetting$(13) = VisionConfig.VisionSymbolicOrMagnitude(1)

//    BodySetting$(21) = VisionConfig.VisionSymbolicOrMagnitude(2)

        VisionSense = 0; //so a new sense number assigned automatically by SetupSense()

//    Body 1              'Sense #1 looks down at square, Device #1 moves Left, Right, Up, Down

//            'set up Sense #1, 1 sensor

//          'SetupSense(SenseNum, Sense_Name$, BinonName$, BinonAbbrev$, MagnOrSymb, LowerLimit, UpperLimit, _

//                          LinOrCirc, IntOrLog, NumSensrs, SensorDependency)

//      Call SetupSense(InputSense, "Input", "Text", "Tx", Symbolic, 65, 122, Linear, IntegerValues, 1, Independent)

//

//          'SetupDevice(DeviceNum, DName$, BinonName$, BinonAbbrev$, MagnOrSymb, LowerLimit, UpperLimit, _

//                       Responses$, LinOrCirc, IntOrLog)

//      Call SetupDevice(DevNum, "Output", "Letter", "Lt", Symbolic, 97, 100, "", Linear, IntegerValues)

//

//    Body 2              'Looks forward at next cell, Turns left, right & moves forward

//            'set up Sense #1, 1 Sensor

//      Call SetupSense(InputSense, "Input", "Text", "Tx", Symbolic, 65, 113, Linear, IntegerValues, 1, Independent)

//      Call SetupDevice(DevNum, "Output", "Letter", "Lt", Symbolic, 97, 99, "", Linear, IntegerValues)

        if (isTrue(BodySetting[12])) //radio button VisionSymbolicOrMagnitude(0) selected

        {

            MS = Symbolic;

            ll = 65; //"A" 1st cell location

            UL = 122; //"z" last possible cell location - actually if 8 x 8 then it is Chr$(129)

        }

        if (isTrue(BodySetting[13])) //radio button VisionSymbolicOrMagnitude(1) selected

        {

            MS = Magnitude;

            ll = 1;

            UL = 8; //max 8 cells in any direction

        }

        if (isTrue(BodySetting[21])) //radio button VisionSymbolicOrMagnitude(2) selected

        {

            MS = Symbolic;

            ll = asc(Wall); //Wall$ = Chr$(20) Terminal font

            UL = asc(EmptySquare); //empty square beside it

        }

        if (eq(BodySetting[7], "1")) //Looking down box is checked

        {

            //SetupSense(SenseNum, Sense_Name$, BinonName$, BinonAbbrev$, MagnOrSymb, LowerLimit, UpperLimit, _

            //Stimuli, LinOrCirc, IntOrLog, NumSensrs, SensorDependency);

            SetupSense(VisionSense, "VisionD", "VisionD", "VD", MS, ll, UL, "", Linear, IntegerValues, 1, Independent);

        }

        VisionSense = 0;

        if (eq(BodySetting[8], "1")) //Looking left box is checked

        {

            SetupSense(VisionSense, "VisionL", "VisionL", "Vl", MS, ll, UL, "", Linear, IntegerValues, 1, Independent);

        }

        VisionSense = 0;

        if (eq(BodySetting[9], "1")) //Looking right box is checked

        {

            SetupSense(VisionSense, "VisionR", "VisionR", "Vr", MS, ll, UL, "", Linear, IntegerValues, 1, Independent);

        }

        VisionSense = 0;

        if (eq(BodySetting[10], "1")) //Looking InFront box is checked

        {

            SetupSense(VisionSense, "VisionF", "VisionF", "Vf", MS, ll, UL, "", Linear, IntegerValues, 1, Independent);

        }

        VisionSense = 0;

        if (eq(BodySetting[11], "1")) //Looking Behind box is checked

        {

            SetupSense(VisionSense, "VisionB", "VisionB", "Vb", MS, ll, UL, "", Linear, IntegerValues, 1, Independent);

        }

    } //End of SetupVision()

    private int asc(String s) {

        return empty(s) ? 0 : s.charAt(0);

    }

    private boolean isTrue(String s) {

        return "True".equals(s);

    }

    public final void SetupTouch() {