Author Topic: WIP: Isometric Demo re-revisited v2.90 (multi-simultaneous angles!) (Read 3348 times)

madscijr · « **on:** December 09, 2021, 12:59:16 pm »

Another update, this one displays 4x split screen, each from a different angle!

https://www.qb64.org/forum/index.php?topic=4456.0

Quote from: bplus on December 04, 2021, 12:44:17 pm

@madscijr
You should post in Programs in one thread as a work in progress. That way if amounts to something, and it should with continued progress, librarians have a single thread to reference. MasterGy is doing good job of that with "car simulator".
I wonder if you can make a Christmas tree of cubes or even a whole xmas scene?

Here is the latest, posted here in Programs per @bplus 's suggestion.

This is based on the Isometric Mapping Demo code from
https://www.qb64.org/forum/index.php?topic=1903.30

This version now lets you rotate the viewing angle
using the Insert/Delete keys (demo 3 from the menu).
* Maybe "rotate" isn't accurate, you can view from 6 different directions, though viewing from top/bottom angles are kind of screwy as the transparency for tiles that the player is hidden behind is messed up. I'll have to give that a look.
Also the viewing angle code isn't the most "optimized", I just do it the cheap & easy way by creating a copy of the array, but it works!

A future update will change the key mapping as you change the viewing angle, to be more intuitive. So the arrow keys would move the player on screen relative to the front viewing angle.
(Maybe I'll add an option to rotate the 2-D map accordingly when the viewing angle changes.)
For now, if you change the viewing angle, and find moving around to be confusing, just use the 2-D map as your reference to keep track of your movement.

I started a bigger overhaul to move to split screen for 1-4 players,
and added arrays and variables for that, but the demo isn't really using the mutiplayer
or split screen yet.

Finally @bplus , I'm working on some kind of Christmas-themed version. Stay tuned!

Hopefully someone will find this useful. Comments welcome!

Code: QB64: [Select]

' ################################################################################################################################################################
' Isomatric mapping demo re-revisited
' Version 2.90 by madscijr
 
' Based on Isometric Mapping Demo
' by SMcNeill, bplus, and others at
' https://www.qb64.org/forum/index.php?topic=1903.30
 
' This crude version uses a 3-dimensional array (32x32x32)
' to store cubes of different colors,
' and draws them to the screen in 2.5D "isometric".
 
' -----------------------------------------------------------------------------
' DONE:
' * Render cubes that block the view of the player as transparent.
' * 2-D top down "map" view of the player's current Z slice.
' * variable grid size
' * change arrMap to global shared variable (for simpler code) & rename m_arrMap
' * allow player to rotate their view
' * preliminary multiplayer changes
'   - move player info into array (upto 4 players)
'   - key mapping variables
' * fixed some keyboard input (repeating keys, continuous motion)
' * fixed right point of view bug where x & y coordinates were reversed
' * preliminary multiplayer changes
'   - split screen display (4, 6, or 8?)
'     + for now display player 1's world rotated in each window (for editor)
'       * x4: c_iDir_Left, c_iDir_Right, c_iDir_Back, c_iDir_Forward
'       * x6: c_iDir_Down, c_iDir_Up, c_iDir_Left, c_iDir_Right, c_iDir_Back, c_iDir_Forward
'       * x8: c_iDir_Down, c_iDir_Up, c_iDir_Left, c_iDir_Right, c_iDir_Back, c_iDir_Forward, (none), (none)
'     + will eventually be one per player
' * 2D minimap background = cKhaki&
' * , and . change minimap size
 
' -----------------------------------------------------------------------------
' TO DO:
' * editor v1 = simple drawing program
'   - add type RecordType to hold recording steps
'   - add array m_arrRecord of RecordType to hold recording
'   - display available tiles/colors/etc. at bottom of screen
'     + 40 colors including empty
'     + 07 tiles (empty, floor, wall)
'   - cursor places tiles (ENTER = add/delete at current space)
'   - 0-9 keys cycle through tiles/colors
'   - save screens to file (stored as editable text)
'     + FORMAT: [tile=t][color@x,y,z][color@x,y,z][color@x,y,z]...
'   - load screens into array m_arrRecord
'     + PARSER:
'       1. replace all ][ with [
'       2. split by "[" into simple 1D array
'       3. each element is either "tile=t" or "plot=color@x,y,z"
'       4. parse data into array to playback recording
'          [n][0] = command
'                   -1 = select tile "tile=t"
'                   0+ = color to plot "color@x,y,z"
'          [n][1] = parameter #1 = tile
'          [n][2] = parameter #2 = x
'          [n][3] = parameter #3 = y
'          [n][3] = parameter #4 = z
'   - run commands in m_arrRecord to plot tiles and display
' * rotating view changes orientation of keys (get it working)
 
' -----------------------------------------------------------------------------
' * add parameters to tiles
' * - color scheme (for cycle colors)
 
' * add tiles
'   - transparent lights (blinking / cycle colors)
'   - gravity tiles (fall if no tiles underneath)
 
' * editor v2 = simple animation program
'   - records cursor movements and adding/deleting tiles
'   - press key to record a "frame"
'     + flash screen + play a sound
'   - can change animation speed
'   - realtime=on command enables redrawing screen every step (until realtime=off command encountered)
'   - playback mode recreates editing actions
'   - playback updates screen every "update"
'   - tweak save format (still editable text)
'     + FORMAT: [cls][rotate=d][speed=n][tile=t][color@x,y,z][tile=t][color@x,y,z][update][tile=t][color@x,y,z][realtime=on][tile=t][color@x,y,z]...
'     + PARSER:
'       1. replace all ][ with [
'       2. split by "[" into simple 1D array
'       3. each element is either "color@x,y,z", "tile=t", "cls", "update", "speed=s", "realtime=on", "realtime=off", "rotate=d"
'       4. parse array into array of LONG for playback
'          [n].Command
'                   -7 = rotate point of view (up, down, left, right, back, forward) "rotate=d"
'                   -6 = disable screen update every step "realtime=off"
'                   -5 = enable screen update every step "realtime=on"
'                   -4 = set speed "speed=s"
'                   -3 = update screen "update"
'                   -2 = clear screen "cls"
'                   -1 = select tile "tile=t"
'                   0+ = color to plot "color@x,y,z"
'          [n].Param1 = parameter #1 = tile, speed, direction
'          [n].Param2 = parameter #2 = x
'          [n].Param3 = parameter #3 = y
'          [n].Param4 = parameter #4 = z
'   - effects of gravity (from bottom up, ie z=0 to z=max)
 
' -----------------------------------------------------------------------------
' * expand world to bigger than screen (2.5d scrolling view)
 
' * editor v3 = mouse
'   - mouse movement controls cursor x,y position
'   - mouse wheel controls z position
'   - left click draws a tile
'   - right click erases a tile
'   - ENTER records a frame
'   - Add animation playback command:
'          [n][0] = command
'                   -8 = enable user to rotate image in realtime with mouse? "mouse=on"
 
' -----------------------------------------------------------------------------
' TO DO (LATER):
' * local multiplayer (2-4 players)
'   - split screen (x2 or x4)
 
' * fix/control screen placement/rendering/scroll boundaries for grid sizes 
'   (to not overwrite other players, go off screen, etc., when grid size changes)
 
' * auto-rotate view depending on direction player is facing
 
' * control the x/y/z slice axis, for a cutaway view
 
' * gravity (players stay on ground, can fall)
' * player can climb up to next level if it is 1 tile higher
' * add ability to jump over 1 space
 
' * option to remap keys
' * support game controllers
' * game controller calibration/mapping function
 
' * option to hide objects out of player's line-of-sight
 
' * show player as a stick figure (like "Realm of Impossibility")
' * walking movement
 
' * add tiles (water, ladders, steps, ropes, windows, doors, etc.)
' * add toggle tiles - door "opens" when triggered
' * triggers
' * add tiles
'   - Water = transparent blue)
'   - Window = more transparent cyan)
 
' * add directional tiles (can be rotated?)
'   - ladder
'   - bridge
'   - hand-over-hand bars?
'   - Slope45 = 45° slope <- 4 or 6 directions?
'   - InvSlope45 = 45° inverted slope <- 4 or 6 directions?
'   - Pyramid45 = 45° pyramid "cap stone" <- 4 or 6 directions?
'   - ramp (player can walk up/down slope45)
 
' * add ability to climb ladders + climbing animation
' * add ability to walk up ramps with smooth z-movement inbetween tiles
' * add ability to climb monkey bars (animation like lode runner)
 
' * simultaneously show additional 1st person view
' * add ability for tilting head up/down in first person
 
' * simple open world (players can add/remove tiles, build in real time)
' * make simple games (maze craze, capture the flag, snake, surround, 2.5d pong)
' * make more complex games (berzerk, lode runner, atari combat / tank)
' * make awesome complex games (2.5d lunar lander, atari adventure, asteroids, gravitar, etc.)
' * text adventure features (to create graphic Infocom or Scott Adams style games)
 
' ################################################################################################################################################################
 
' =============================================================================
' GLOBAL DECLARATIONS a$=string, i%=integer, L&=long, s!=single, d#=double
' div: int1% = num1% \ den1%
' mod: rem1% = num1% MOD den1%
 
' -----------------------------------------------------------------------------
' boolean constants
' -----------------------------------------------------------------------------
Const FALSE = 0
Const TRUE = Not FALSE
 
' -----------------------------------------------------------------------------
' KeyDownConstants
' -----------------------------------------------------------------------------
Const c_iKeyDown_Esc = 27
Const c_iKeyDown_F1 = 15104
Const c_iKeyDown_F2 = 15360
Const c_iKeyDown_F3 = 15616
Const c_iKeyDown_F4 = 15872
Const c_iKeyDown_F5 = 16128
Const c_iKeyDown_F6 = 16384
Const c_iKeyDown_F7 = 16640
Const c_iKeyDown_F8 = 16896
Const c_iKeyDown_F9 = 17152
Const c_iKeyDown_F10 = 17408
Const c_iKeyDown_Tilde = 96
Const c_iKeyDown_1 = 49
Const c_iKeyDown_2 = 50
Const c_iKeyDown_3 = 51
Const c_iKeyDown_4 = 52
Const c_iKeyDown_5 = 53
Const c_iKeyDown_6 = 54
Const c_iKeyDown_7 = 55
Const c_iKeyDown_8 = 56
Const c_iKeyDown_9 = 57
Const c_iKeyDown_0 = 48
Const c_iKeyDown_Minus = 45
Const c_iKeyDown_EqualPlus = 61
Const c_iKeyDown_BkSp = 8
Const c_iKeyDown_Ins = 20992
Const c_iKeyDown_Home = 18176
Const c_iKeyDown_PgUp = 18688
Const c_iKeyDown_Del = 21248
Const c_iKeyDown_End = 20224
Const c_iKeyDown_PgDn = 20736
Const c_iKeyDown_KEYPAD_7_Home = 18176
Const c_iKeyDown_KEYPAD_8_Up = 18432
Const c_iKeyDown_KEYPAD_9_PgUp = 18688
Const c_iKeyDown_KEYPAD_4_Left = 19200
Const c_iKeyDown_KEYPAD_6_Right = 19712
Const c_iKeyDown_KEYPAD_1_End = 20224
Const c_iKeyDown_KEYPAD_2_Down = 20480
Const c_iKeyDown_KEYPAD_3_PgDn = 20736
Const c_iKeyDown_KEYPAD_0_Ins = 20992
Const c_iKeyDown_KEYPAD_Period_Del = 21248
Const c_iKeyDown_Tab = 9
Const c_iKeyDown_Q = 113
Const c_iKeyDown_W = 119
Const c_iKeyDown_E = 101
Const c_iKeyDown_R = 114
Const c_iKeyDown_T = 116
Const c_iKeyDown_Y = 121
Const c_iKeyDown_U = 117
Const c_iKeyDown_Pipe = 105
Const c_iKeyDown_O = 111
Const c_iKeyDown_P = 112
Const c_iKeyDown_BracketLeft = 91
Const c_iKeyDown_BracketRight = 93
Const c_iKeyDown_Backslash = 92
Const c_iKeyDown_A = 97
Const c_iKeyDown_S = 115
Const c_iKeyDown_D = 100
Const c_iKeyDown_F = 102
Const c_iKeyDown_G = 103
Const c_iKeyDown_H = 104
Const c_iKeyDown_J = 106
Const c_iKeyDown_K = 107
Const c_iKeyDown_L = 108
Const c_iKeyDown_SemiColon = 59
Const c_iKeyDown_Apostrophe = 39
Const c_iKeyDown_Enter = 13
Const c_iKeyDown_Z = 22
Const c_iKeyDown_X = 120
Const c_iKeyDown_C = 99
Const c_iKeyDown_V = 118
Const c_iKeyDown_B = 98
Const c_iKeyDown_N = 110
Const c_iKeyDown_M = 109
Const c_iKeyDown_Comma = 44
Const c_iKeyDown_Period = 46
Const c_iKeyDown_Slash = 47
Const c_iKeyDown_Up = 18432
Const c_iKeyDown_Left = 19200
Const c_iKeyDown_Down = 20480
Const c_iKeyDown_Right = 19712
Const c_iKeyDown_Spacebar = 32
 
' -----------------------------------------------------------------------------
' Tile value constants for map (MapTileType.Typ)
' -----------------------------------------------------------------------------
Const c_iMapType_Empty = 0
Const c_iMapType_Floor_Tiled = 1
Const c_iMapType_Wall = 2
Const c_iMapType_Water = 3
Const c_iMapType_Window = 4
Const c_iMapType_Player1 = 5
Const c_iMapType_Player2 = 6
Const c_iMapType_Player3 = 7
Const c_iMapType_Player4 = 8
Const c_iMapType_Blinking_Light = 9
Const c_iMapType_Gravity_Tile = 10
Const c_iMapType_Slope45 = 11
Const c_iMapType_InvSlope45 = 12
 
' -----------------------------------------------------------------------------
' constants for 2.5D movement
' -----------------------------------------------------------------------------
Const c_iDir_Down = 1
Const c_iDir_Up = 2
Const c_iDir_Left = 3
Const c_iDir_Right = 4
Const c_iDir_Back = 5
Const c_iDir_Forward = 6
Const c_iDir_Min = 1
Const c_iDir_Max = 6
 
' -----------------------------------------------------------------------------
' constants for drawing the 2.5D screen
' -----------------------------------------------------------------------------
Const cGridOffsetX = 50
Const cGridOffsetY = 50
Const cGridOffsetZ = 0
Const cScreenOffsetX = 500 ' 450
Const cScreenOffsetY = 300 ' 50
Const cScreenOffsetZ = 0
 
' =============================================================================
' USER DEFINED TYPES
' =============================================================================
Type MapTileType
    Typ As Integer ' c_iMapType_Empty, c_iMap_Floor_Tiled, c_iMap_Wall, etc.
    'Vis As Integer ' TRUE = visible, FALSE = don't render
    'Lit As Long ' light offset
    Color1 As Long ' main color
    Color2 As Long ' secondary color if needed
    Color3 As Long ' third color if needed
    Alpha1 As Long ' transparency of tile Color1
    Alpha2 As Long ' transparency of tile Color2
    Alpha3 As Long ' transparency of tile Color3
    AlphaOverride As Integer ' can be used to override alpha (0 treated as opaque)
End Type ' MapTileType
 
Type RecordType
    Command As Integer
    Param1 As Integer
    Param2 As Integer
    Param3 As Integer
    Param4 As Integer
End Type ' RecordType
 
' UDT TO HOLD THE INFO FOR A PLAYER
TYPE PlayerType
    IsEnabled AS Integer ' TRUE or FALSE
    x AS Integer ' player x position
    y AS Integer ' player y position
    z AS Integer ' player z position
    Direction AS Integer ' direction player is moving: c_iDir_Left, c_iDir_Right, c_iDir_Back, c_iDir_Forward; not used: c_iDir_Down, c_iDir_Up
    View AS Integer ' player's viewing orientation (direction screen is being looked at from), can be: c_iDir_Left, c_iDir_Right, c_iDir_Back, c_iDir_Forward, c_iDir_Down, c_iDir_Up
    Tile1 As Long ' later we will instead use directional animation sequences
    
    Color1 As Long ' main color
    'Color2 As Long ' secondary color if needed
    'Color3 As Long ' third color if needed    
    
    Alpha1 As Long ' transparency of player Color1
    'Alpha2 As Long ' transparency of player Color2
    'Alpha3 As Long ' transparency of player Color3
    
    ColorScheme1 As Long ' for cycling colors
    ColorSchemeSpeed1 As Long
    ColorSchemeCount1 As Long
    
    'ColorScheme2 As Long ' for cycling colors
    'ColorSchemeSpeed2 As Long
    'ColorSchemeCount2 As Long
    
    'ColorScheme3 As Long ' for cycling colors
    'ColorSchemeSpeed3 As Long
    'ColorSchemeCount3 As Long
    
    AlphaOverride As Integer ' can be used to override alpha (0 treated as opaque)
    
    IsMoving As Integer ' TRUE/FALSE
    IsMoved As Integer ' TRUE/FALSE
    
        GridSize As Integer
        MapSize As Integer
        
    'hx AS Integer ' home base x position
    'hy AS Integer ' home base y position
    'ex AS Integer ' exit x position
    'ey AS Integer ' exit y position
    'wins AS Integer ' count # of wins
    'points AS Long ' count points (more points for harder)
    'difficulty AS Integer ' 1-5, from 1 (easiest, maze width 5) to 5 (hardest, maze width 1). Each win awards {difficulty} # of points.
    'speed AS Integer ' the higher the faster
    'delay AS Integer ' counter, player can move based on speed
    'bit AS Integer ' bit value for masking player in map
    'rows AS Integer ' # of rows in player's maze
    'cols AS Integer ' # of columns in player's maze
END TYPE ' PlayerType
 
' KEY MAPPING v1
' UDT TO HOLD THE KEY MAPPINGS
TYPE DirKeyMapType
    KeyBack As Long
    KeyForward As Long
    KeyLeft As Long
    KeyRight As Long
    KeyUp As Long
    KeyDown As Long
END TYPE ' DirKeyMapType
 
' SPLIT SCREEN OFFSETS
TYPE SplitScreenType
    GridOffsetX As Integer
    GridOffsetY As Integer
    GridOffsetZ As Integer
    ScreenOffsetX As Integer
    ScreenOffsetY As Integer
    ScreenOffsetZ As Integer
END TYPE ' SplitScreenType
 
' =============================================================================
' GLOBAL VARIABLES
Dim Shared m_ProgramPath$ : m_ProgramPath$ = Left$(Command$(0), _InStrRev(Command$(0), "\"))
Dim Shared m_ProgramName$ : m_ProgramName$ = Mid$(Command$(0), _InStrRev(Command$(0), "\") + 1)
Dim Shared m_iGridSize As Integer : m_iGridSize = 8 ' BEFORE, < 10 wass causing problems with PAINT, but new method doesn't use PAINT, so nyah!
Dim Shared m_iGridSizeMin As Integer : m_iGridSizeMin = 1
Dim Shared m_iGridSizeMax As Integer : m_iGridSizeMax = 128
 
Dim Shared m_iMapMinX As Integer : m_iMapMinX = 0
Dim Shared m_iMapMaxX As Integer : m_iMapMaxX = 32
Dim Shared m_iMapMidX As Integer : m_iMapMidX = (m_iMapMaxX-m_iMapMinX)\2
Dim Shared m_iMapMinY As Integer : m_iMapMinY = 0
Dim Shared m_iMapMaxY As Integer : m_iMapMaxY = 32
Dim Shared m_iMapMidY As Integer : m_iMapMidY = (m_iMapMaxY-m_iMapMinY)\2
Dim Shared m_iMapMinZ As Integer : m_iMapMinZ = 0
Dim Shared m_iMapMaxZ As Integer : m_iMapMaxZ = 32
Dim Shared m_iMapMidZ As Integer : m_iMapMidZ = (m_iMapMaxZ-m_iMapMinZ)\2
 
Dim Shared m_iPlayerMin As Integer : m_iPlayerMin = 1
Dim Shared m_iPlayerMax As Integer : m_iPlayerMax = 4
 
' Max # tiles in (32x32x32) world = 32,768
' Max # tiles for 16 (32x32x32) worlds = 524,288
' Max # tiles for 256 (32x32x32) worlds = 8,388,608
Dim Shared m_iRecordMin As Long : m_iRecordMin = 0
Dim Shared m_iRecordMax As Long : m_iRecordMax = 524288
 
Dim Shared m_arrMap(m_iMapMinX To m_iMapMaxX, m_iMapMinY To m_iMapMaxY, m_iMapMinZ To m_iMapMaxZ) As MapTileType
Dim Shared m_arrRender(m_iMapMinX To m_iMapMaxX, m_iMapMinY To m_iMapMaxY, m_iMapMinZ To m_iMapMaxZ) As MapTileType
Dim Shared m_arrPlayer(m_iPlayerMin To m_iPlayerMax) As PlayerType
Dim Shared m_arrRecord(m_iRecordMin To m_iRecordMax) As RecordType
 
' For each player, map the 6 directional keys differently for each of the 6 directional orientations!
Dim Shared m_arrDirKeyMap(m_iPlayerMin To m_iPlayerMax, c_iDir_Min To c_iDir_Max) As DirKeyMapType
 
' Store offsets for splitscreen
Dim Shared m_arrSplitScreen(m_iPlayerMin To m_iPlayerMax) As SplitScreenType
 
' =============================================================================
' LOCAL VARIABLES
Dim in$
 
' ****************************************************************************************************************************************************************
' ACTIVATE DEBUGGING WINDOW
$Console
_Delay 4
_Console On
_Echo "Started " + m_ProgramName$
_Echo "Debugging on..."
' ****************************************************************************************************************************************************************
 
' =============================================================================
' START THE MAIN ROUTINE
main
 
' =============================================================================
' FINISH
System ' return control to the operating system
Print m_ProgramName$ + " finished."
Input "Press <ENTER> to continue", in$
 
' ****************************************************************************************************************************************************************
' DEACTIVATE DEBUGGING WINDOW
_Console Off
' ****************************************************************************************************************************************************************
 
End
 
' /////////////////////////////////////////////////////////////////////////////
 
Sub main
    Dim RoutineName as String : RoutineName = "main"
    Dim in$
    Dim result$
    
    Screen 0
 
    Do
        Cls
        Print m_ProgramName$
        Print
        Print "Isomatric Mapping Demo Re-visited"
        Print "v2.90, by Softintheheadware (Dec, 2021)"
        Print
        'PRINT "CONTROLS: PRESS <ESC> TO RETURN TO MENU"
        'PRINT "PLAYER  LEFT       RIGHT       UP        DOWN       "
        'PRINT "1       CRSR LEFT  CRSR RIGHT  CRSR UP   CRSR DOWN  "
        'PRINT "2       KEYPAD 4   KEYPAD 6    KEYPAD 8  KEYPAD 2   "
        'PRINT "3       A          S           W         Z          "
        'PRINT "4       J          K           I         M          "
        'PRINT
 
        Print "1. IsometricDemo1"
        Print "2. IsometricDemo2"
        Print "3. Move around in 2.5D"
        Print
        Print "What to do? ('q' to exit)"
 
        Input in$: in$ = LCase$(Left$(in$, 1))
 
        If in$ = "1" Then
            result$ = IsometricDemo1
        ElseIf in$ = "2" Then
            result$ = IsometricDemo2
        ElseIf in$ = "3" Then
            result$ = IsometricDemo3
        End If
        
        If LEN(result$) > 0 Then
            PRINT result$
        End If
        
    Loop Until in$ = "q"
End Sub ' main
 
' /////////////////////////////////////////////////////////////////////////////
 
Function IsometricDemo1$
    Dim RoutineName As String: RoutineName = "IsometricDemo1"
    Dim sResult AS String : sResult = ""
    Dim iGridSize As Integer
        Dim iX%
    Dim iY%
    Dim iZ%
    Dim iNextX%
    Dim iNextY%
    Dim iNextZ%
    Dim iPosX1%
    Dim iPosX2%
    Dim iPosY1%
    Dim iPosY2%
    Dim iLoopX%
    Dim iLoopY%
    Dim iLoopZ%
    Dim iNextColor&
    Dim iColorScheme%
    Dim bContinue As Integer
    Dim iDirection%
    Dim bFinished As Integer
    Dim iCount%
    Dim iOpen%
    Dim iMove%
    Dim iSegmentLength%
    Dim iMaxLength%
    Dim bFirst As Integer
    Dim bQuit As Integer
    Dim in$
    
    ' INITIALIZE
    'Screen _NewImage(1024, 720, 32) : _ScreenMove _Middle
    Screen _NewImage(1280, 1024, 32) : _ScreenMove 0,0
        
    iGridSize = 10
        
    ' =============================================================================
    ' MAIN LOOP
    bQuit = FALSE
    Do
        Cls
 
        ' -----------------------------------------------------------------------------
        ' INITIALIZE MAP TO EMPTY
        ClearIsometricMap
        
        ' -----------------------------------------------------------------------------
        ' DRAW FLOOR
        iZ% = m_iMapMinZ
        For iLoopX% = m_iMapMinX To m_iMapMaxX
            For iLoopY% = m_iMapMinY To m_iMapMaxY
                m_arrMap(iLoopX%, iLoopY%, iZ%).Typ = c_iMapType_Floor_Tiled
                m_arrMap(iLoopX%, iLoopY%, iZ%).Color1 = cGray&
                m_arrMap(iLoopX%, iLoopY%, iZ%).Color2 = cLightGray&
            Next iLoopY%
        Next iLoopX%
        
        ' -----------------------------------------------------------------------------
        ' DRAW TILES TO CHECK ORIENTATION
        
        FOR iLoopZ% = m_iMapMinZ + 1 TO m_iMapMaxZ
            m_arrMap(m_iMapMinX, m_iMapMinY, iLoopZ%).Typ = c_iMapType_Wall
            m_arrMap(m_iMapMinX, m_iMapMinY, iLoopZ%).Color1 = cRed&
            
            m_arrMap(m_iMapMaxX, m_iMapMinY, iLoopZ%).Typ = c_iMapType_Wall
            m_arrMap(m_iMapMaxX, m_iMapMinY, iLoopZ%).Color1 = cBlue&
            
            m_arrMap(m_iMapMinX, m_iMapMaxY, iLoopZ%).Typ = c_iMapType_Wall
            m_arrMap(m_iMapMinX, m_iMapMaxY, iLoopZ%).Color1 = cGreen&
            
            'm_arrMap(m_iMapMaxX, m_iMapMaxY, iLoopZ%).Typ = c_iMapType_Wall
            'm_arrMap(m_iMapMaxX, m_iMapMaxY, iLoopZ%).Color1 = cYellow&
            
            'm_arrMap(m_iMapMinX, m_iMapMidY, iLoopZ%).Typ = c_iMapType_Wall
            'm_arrMap(m_iMapMinX, m_iMapMidY, iLoopZ%).Color1 = cOrange&
            '
            'm_arrMap(m_iMapMaxX, m_iMapMidY, iLoopZ%).Typ = c_iMapType_Wall
            'm_arrMap(m_iMapMaxX, m_iMapMidY, iLoopZ%).Color1 = cPurple&
            '
            'm_arrMap(m_iMapMidX, m_iMapMinY, iLoopZ%).Typ = c_iMapType_Wall
            'm_arrMap(m_iMapMidX, m_iMapMinY, iLoopZ%).Color1 = cLime&
            '
            'm_arrMap(m_iMapMidX, m_iMapMaxY, iLoopZ%).Typ = c_iMapType_Wall
            'm_arrMap(m_iMapMidX, m_iMapMaxY, iLoopZ%).Color1 = cCyan&
        NEXT iLoopZ%
        
        ' -----------------------------------------------------------------------------
        ' DRAW SOME OBJECTS
        If TRUE = TRUE Then
            iX% = 16
            iY% = 3
            
            iNextColor& = cRed&
            iLoopZ% = 1
            iLoopY% = iY%
            For iLoopX% = iX% To (iX% + 10)
                m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Wall
                m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Color1 = iNextColor&
            Next iLoopX%
            
            iNextColor& = cBlue&
            iLoopZ% = 1
            iLoopY% = iY% + 8
            For iLoopX% = iX% To (iX% + 10)
                m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Wall
                m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Color1 = iNextColor&
            Next iLoopX%
            
            iNextColor& = cGreen&
            iLoopZ% = 1
            iLoopX% = iX% + 1
            For iLoopY% = (iY% + 1) To (iY% + 7)
                m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Wall
                m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Color1 = iNextColor&
            Next iLoopY%
            
            iNextColor& = cYellow&
            iLoopZ% = 1
            iLoopX% = iX% + 9
            For iLoopY% = (iY% + 1) To (iY% + 7)
                m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Wall
                m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Color1 = iNextColor&
            Next iLoopY%
        End If
        
        ' -----------------------------------------------------------------------------
        ' DRAW A PYRAMID
        If TRUE = TRUE Then
            iX% = 2
            iY% = 18
            iZ% = 1
            iPosX1% = iX%
            iPosX2% = iX% + 10
            iPosY1% = iY%
            iPosY2% = iY% + 10
            iNextColor& = cRed&
            iColorScheme% = 1 ' 1 = Rainbow6 #1, 9 = Rainbow6 #2, etc.
            
            bContinue = TRUE
            Do
                ' PLOT NEXT LEVEL
                For iLoopX% = iPosX1% To iPosX2%
                    For iLoopY% = iPosY1% To iPosY2%
                        m_arrMap(iLoopX%, iLoopY%, iZ%).Typ = c_iMapType_Wall
                        m_arrMap(iLoopX%, iLoopY%, iZ%).Color1 = iNextColor&
                    Next iLoopY%
                Next iLoopX%
                
                ' MOVE UP A LEVEL
                iPosX1% = iPosX1% + 1
                iPosX2% = iPosX2% - 1
                iPosY1% = iPosY1% + 1
                iPosY2% = iPosY2% - 1
                DoCycleColor iColorScheme%, iNextColor&
                
                ' QUIT AFTER WE REACH THE TOP
                If (iPosX1% <= iPosX2%) And (iPosY1% <= iPosY2%) Then
                    iZ% = iZ% + 1
                Else
                    bContinue = FALSE
                End If
                
            Loop Until bContinue = FALSE
        End If
 
        ' -----------------------------------------------------------------------------
        ' DRAW PIPES
        If TRUE = TRUE Then
            ' START POSITION
            iX% = m_iMapMaxX ' 30 ' RandomNumber%(0, 32)
            iY% = m_iMapMaxY ' 28 ' RandomNumber%(0, 32)
            iZ% = 1 ' 32
            
            ' LENGTH OF PIPES
            iSegmentLength% = 4
            iMaxLength% = 64
            
            ' START COLOR + DEFINE HOW COLOR CHANGES
            iNextColor& = cRed&
            iColorScheme% = 2 ' 0 = don't change, 2 = Rainbow18 #1, 10 = Rainbow18 #2, etc.
            
            ' INITIALIZE
            bFirst = TRUE
            iCount% = 0
            iMove% = 0
            bFinished = FALSE
            Do
                iNextX% = iX%
                iNextY% = iY%
                iNextZ% = iZ%
                
                ' CHANGE DIRECTION EVERY iSegmentLength% SPACES
                iMove% = iMove% + 1
                If iMove% > iSegmentLength% Then
                    iMove% = 0
                    
                    ' PICK A DIRECTION
                    If bFirst = TRUE Then
                        ' MOVE UP FOR FIRST MOVE
                        iDirection% = c_iDir_Up
                        bFirst = FALSE
                    Else
                        ' PICK A RANDOM DIRECTION
                        iDirection% = RandomNumber(c_iDir_Min, c_iDir_Max)
                    End If
                End If
                
                Select Case iDirection%
                    Case c_iDir_Down:
                        If iNextZ% > 0 Then
                            iNextZ% = iNextZ% - 1
                        End If
                    Case c_iDir_Up:
                        If iNextZ% < 32 Then
                            iNextZ% = iNextZ% + 1
                        End If
                    Case c_iDir_Left:
                        If iNextX% > 0 Then
                            iNextX% = iNextX% - 1
                        End If
                    Case c_iDir_Right:
                        If iNextX% < 32 Then
                            iNextX% = iNextX% + 1
                        End If
                    Case c_iDir_Back:
                        If iNextY% > 0 Then
                            iNextY% = iNextY% - 1
                        End If
                    Case Else: ' c_iDir_Forward
                        If iNextY% < 32 Then
                            iNextY% = iNextY% + 1
                        End If
                End Select
                
                ' CHECK IF NEXT SPACE IS EMPTY
                If m_arrMap(iNextX%, iNextY%, iNextZ%).Typ = c_iMapType_Empty Then
                    ' SPACE IS EMPTY
                    ' DRAW HERE
                    
                    iCount% = iCount% + 1
                    iX% = iNextX%
                    iY% = iNextY%
                    iZ% = iNextZ%
                    
                    ' GET NEXT COLOR AND DRAW TILE
                    DoCycleColor iColorScheme%, iNextColor&
                    m_arrMap(iX%, iY%, iZ%).Typ = c_iMapType_Wall
                    m_arrMap(iX%, iY%, iZ%).Color1 = iNextColor&
                    
                    ' HAVE WE PLACED MAX # OF TILES?
                    If iCount% > iMaxLength% Then
                        bFinished = TRUE
                    End If
                Else                    
                    ' SPACE IS OCCUPIED
                    ' SEE IF WE HAVE ANY OPEN SPACES TO MOVE TO
                    iOpen% = 0
                    If iZ% > 0 Then
                        If m_arrMap(iX%, iY%, iZ% - 1).Typ = c_iMapType_Empty Then
                            iOpen% = iOpen% + 1
                        End If
                    End If
                    If iZ% < 32 Then
                        If m_arrMap(iX%, iY%, iZ% + 1).Typ = c_iMapType_Empty Then
                            iOpen% = iOpen% + 1
                        End If
                    End If
                    If iX% > 0 Then
                        If m_arrMap(iX% - 1, iY%, iZ%).Typ = c_iMapType_Empty Then
                            iOpen% = iOpen% + 1
                        End If
                    End If
                    If iX% < 32 Then
                        If m_arrMap(iX% + 1, iY%, iZ%).Typ = c_iMapType_Empty Then
                            iOpen% = iOpen% + 1
                        End If
                    End If
                    If iY% > 0 Then
                        If m_arrMap(iX%, iY% - 1, iZ%).Typ = c_iMapType_Empty Then
                            iOpen% = iOpen% + 1
                        End If
                    End If
                    If iY% < 32 Then
                        If m_arrMap(iX%, iY% + 1, iZ%).Typ = c_iMapType_Empty Then
                            iOpen% = iOpen% + 1
                        End If
                    End If
                    
                    ' QUIT IF NO OPEN SPACES AVAILABLE
                    If iOpen% = 0 Then
                        ' NOWHERE TO GO, EXIT
                        bFinished = TRUE
                    End If
                End If
                
            Loop Until bFinished = TRUE
        End If
 
        ' PLOT GRAPHICS TO SCREEN
        'DrawScreen c_iDir_Forward, cScreenOffsetX, cScreenOffsetY
        'DrawScreen c_iDir_Forward, cScreenOffsetX, cScreenOffsetY, 0, 0, 0
        DrawScreen c_iDir_Forward, cScreenOffsetX, cScreenOffsetY, iGridSize, 0, 0, 0
                
        Input "PRESS <ENTER> TO DRAW ANOTHER, OR 'Q' TO QUIT? ", in$
        
        If LCase$(in$) = LCase$("q") Then
            bQuit = TRUE
        End If
        
    Loop Until bQuit = TRUE
    
    Screen 0
    
    IsometricDemo1 = sResult
End Sub ' IsometricDemo1
 
' /////////////////////////////////////////////////////////////////////////////
 
Function IsometricDemo2$
    Dim RoutineName As String: RoutineName = "IsometricDemo2"
    Dim sResult AS String : sResult = ""
        Dim iGridSize As Integer
    Dim iX%
    Dim iY%
    Dim iZ%
    Dim iNextX%
    Dim iNextY%
    Dim iNextZ%
    Dim iPosX1%
    Dim iPosX2%
    Dim iPosY1%
    Dim iPosY2%
    Dim iLoopX%
    Dim iLoopY%
    Dim iLoopZ%
    Dim iNextColor&
    Dim iColorScheme%
    Dim bContinue As Integer
    Dim iDirection%
    Dim bFinished As Integer
    Dim iCount%
    Dim iOpen%
    Dim iMove%
    Dim iSegmentLength%
    Dim iMaxLength%
    Dim bFirst As Integer
    Dim bQuit As Integer
    Dim in$
    
    ' INITIALIZE
    'Screen _NewImage(1024, 720, 32) : _ScreenMove _Middle
    Screen _NewImage(1280, 1024, 32) : _ScreenMove 0,0
    iGridSize = 10
        
    ' =============================================================================
    ' MAIN LOOP
    bQuit = FALSE
    Do
        Cls
 
        ' -----------------------------------------------------------------------------
        ' INITIALIZE MAP TO EMPTY
        ClearIsometricMap
        
        ' -----------------------------------------------------------------------------
        ' DRAW FLOOR
        'For iLoopZ% = m_iMapMinZ To m_iMapMaxZ Step 8
        For iLoopZ% = m_iMapMinZ To m_iMapMinZ
            For iLoopX% = m_iMapMinX To m_iMapMaxX
                For iLoopY% = m_iMapMinY To m_iMapMaxY
                    m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Floor_Tiled
                    m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Color1 = cGray&
                    m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Color2 = cLightGray&
                Next iLoopY%
            Next iLoopX%
        Next iLoopZ%
        
        ' -----------------------------------------------------------------------------
        ' DRAW FRAME AROUND ENTIRE SPACE
        
        FOR iLoopZ% = m_iMapMinZ+1 TO m_iMapMaxZ
            m_arrMap(m_iMapMinX, m_iMapMinY, iLoopZ%).Typ = c_iMapType_Wall
            m_arrMap(m_iMapMinX, m_iMapMinY, iLoopZ%).Color1 = cRed&
            
            m_arrMap(m_iMapMaxX, m_iMapMinY, iLoopZ%).Typ = c_iMapType_Wall
            m_arrMap(m_iMapMaxX, m_iMapMinY, iLoopZ%).Color1 = cBlue&
            
            m_arrMap(m_iMapMinX, m_iMapMaxY, iLoopZ%).Typ = c_iMapType_Wall
            m_arrMap(m_iMapMinX, m_iMapMaxY, iLoopZ%).Color1 = cGreen&
            
            m_arrMap(m_iMapMaxX, m_iMapMaxY, iLoopZ%).Typ = c_iMapType_Wall
            m_arrMap(m_iMapMaxX, m_iMapMaxY, iLoopZ%).Color1 = cYellow&
        NEXT iLoopZ%
        
        FOR iLoopX% = m_iMapMinX TO m_iMapMaxX
            m_arrMap(iLoopX%, m_iMapMinY, m_iMapMinZ+1).Typ = c_iMapType_Wall
            m_arrMap(iLoopX%, m_iMapMinY, m_iMapMinZ+1).Color1 = cOrange&
            
            m_arrMap(iLoopX%, m_iMapMaxY, m_iMapMaxZ).Typ = c_iMapType_Wall
            m_arrMap(iLoopX%, m_iMapMaxY, m_iMapMaxZ).Color1 = cPurple&
            
            m_arrMap(iLoopX%, m_iMapMaxY, m_iMapMinZ+1).Typ = c_iMapType_Wall
            m_arrMap(iLoopX%, m_iMapMaxY, m_iMapMinZ+1).Color1 = cLime&
            
            m_arrMap(iLoopX%, m_iMapMinY, m_iMapMaxZ).Typ = c_iMapType_Wall
            m_arrMap(iLoopX%, m_iMapMinY, m_iMapMaxZ).Color1 = cCyan&
        NEXT iLoopX%
        
        FOR iLoopY% = m_iMapMinY TO m_iMapMaxY
            m_arrMap(m_iMapMinX, iLoopY%, m_iMapMinZ+1).Typ = c_iMapType_Wall
            m_arrMap(m_iMapMinX, iLoopY%, m_iMapMinZ+1).Color1 = cDodgerBlue&
            
            m_arrMap(m_iMapMinX, iLoopY%, m_iMapMaxZ).Typ = c_iMapType_Wall
            m_arrMap(m_iMapMinX, iLoopY%, m_iMapMaxZ).Color1 = cDeepPurple&
            
            m_arrMap(m_iMapMaxX, iLoopY%, m_iMapMinZ+1).Typ = c_iMapType_Wall
            m_arrMap(m_iMapMaxX, iLoopY%, m_iMapMinZ+1).Color1 = cDarkRed&
            
            m_arrMap(m_iMapMaxX, iLoopY%, m_iMapMaxZ).Typ = c_iMapType_Wall
            m_arrMap(m_iMapMaxX, iLoopY%, m_iMapMaxZ).Color1 = cGold&
        NEXT iLoopY%
        
        ' -----------------------------------------------------------------------------
        ' DRAW PIPES
        If TRUE = TRUE Then
            ' START POSITION
            iX% = m_iMapMidX ' 30 ' RandomNumber(0, 32)
            iY% = m_iMapMidY ' 28 ' RandomNumber(0, 32)
            iZ% = m_iMapMidZ ' 1 ' 32
            
            ' LENGTH OF PIPES
            iSegmentLength% = 8
            iMaxLength% = 512
            
            ' START COLOR + DEFINE HOW COLOR CHANGES
            iNextColor& = cRed&
            iColorScheme% = 3 ' 0 = don't change, 2 = Rainbow18 #1, 10 = Rainbow18 #2, etc.
            
            ' INITIALIZE
            bFirst = TRUE
            iCount% = 0
            iMove% = 0
            bFinished = FALSE
            Do
                iNextX% = iX%
                iNextY% = iY%
                iNextZ% = iZ%
                
                ' CHANGE DIRECTION EVERY iSegmentLength% SPACES
                iMove% = iMove% + 1
                If iMove% > iSegmentLength% Then
                    iMove% = 0
                    
                    ' PICK A DIRECTION
                    If bFirst = TRUE Then
                        ' MOVE UP FOR FIRST MOVE
                        iDirection% = c_iDir_Up
                        bFirst = FALSE
                    Else
                        ' PICK A RANDOM DIRECTION
                        iDirection% = RandomNumber%(c_iDir_Min, c_iDir_Max)
                    End If
                End If
                
                Select Case iDirection%
                    Case c_iDir_Down:
                        If iNextZ% > 0 Then
                            iNextZ% = iNextZ% - 1
                        End If
                    Case c_iDir_Up:
                        If iNextZ% < 32 Then
                            iNextZ% = iNextZ% + 1
                        End If
                    Case c_iDir_Left:
                        If iNextX% > 0 Then
                            iNextX% = iNextX% - 1
                        End If
                    Case c_iDir_Right:
                        If iNextX% < 32 Then
                            iNextX% = iNextX% + 1
                        End If
                    Case c_iDir_Back:
                        If iNextY% > 0 Then
                            iNextY% = iNextY% - 1
                        End If
                    Case Else: ' c_iDir_Forward
                        If iNextY% < 32 Then
                            iNextY% = iNextY% + 1
                        End If
                End Select
                
                ' CHECK IF NEXT SPACE IS EMPTY
                If m_arrMap(iNextX%, iNextY%, iNextZ%).Typ = c_iMapType_Empty Then
                    ' SPACE IS EMPTY
                    ' DRAW HERE
                    
                    iCount% = iCount% + 1
                    iX% = iNextX%
                    iY% = iNextY%
                    iZ% = iNextZ%
                    
                    ' GET NEXT COLOR AND DRAW TILE
                    DoCycleColor iColorScheme%, iNextColor&
                    m_arrMap(iX%, iY%, iZ%).Typ = c_iMapType_Wall
                    m_arrMap(iX%, iY%, iZ%).Color1 = iNextColor&
                    
                    ' HAVE WE PLACED MAX # OF TILES?
                    If iCount% > iMaxLength% Then
                        bFinished = TRUE
                    End If
                Else                    
                    ' SPACE IS OCCUPIED
                    ' SEE IF WE HAVE ANY OPEN SPACES TO MOVE TO
                    iOpen% = 0
                    If iZ% > 0 Then
                        If m_arrMap(iX%, iY%, iZ% - 1).Typ = c_iMapType_Empty Then
                            iOpen% = iOpen% + 1
                        End If
                    End If
                    If iZ% < 32 Then
                        If m_arrMap(iX%, iY%, iZ% + 1).Typ = c_iMapType_Empty Then
                            iOpen% = iOpen% + 1
                        End If
                    End If
                    If iX% > 0 Then
                        If m_arrMap(iX% - 1, iY%, iZ%).Typ = c_iMapType_Empty Then
                            iOpen% = iOpen% + 1
                        End If
                    End If
                    If iX% < 32 Then
                        If m_arrMap(iX% + 1, iY%, iZ%).Typ = c_iMapType_Empty Then
                            iOpen% = iOpen% + 1
                        End If
                    End If
                    If iY% > 0 Then
                        If m_arrMap(iX%, iY% - 1, iZ%).Typ = c_iMapType_Empty Then
                            iOpen% = iOpen% + 1
                        End If
                    End If
                    If iY% < 32 Then
                        If m_arrMap(iX%, iY% + 1, iZ%).Typ = c_iMapType_Empty Then
                            iOpen% = iOpen% + 1
                        End If
                    End If
                    
                    ' QUIT IF NO OPEN SPACES AVAILABLE
                    If iOpen% = 0 Then
                        ' NOWHERE TO GO, EXIT
                        bFinished = TRUE
                    End If
                End If
                
            Loop Until bFinished = TRUE
        End If
 
        ' PLOT GRAPHICS TO SCREEN
        'DrawScreen c_iDir_Forward, cScreenOffsetX, cScreenOffsetY
        'DrawScreen c_iDir_Forward, cScreenOffsetX, cScreenOffsetY, 0, 0, 0
        DrawScreen c_iDir_Forward, cScreenOffsetX, cScreenOffsetY, iGridSize, 0, 0, 0
                
        Input "PRESS <ENTER> TO DRAW ANOTHER, OR 'Q' TO QUIT? ", in$
        
        If LCase$(in$) = LCase$("q") Then
            bQuit = TRUE
        End If
        
    Loop Until bQuit = TRUE
    
    Screen 0
    
    IsometricDemo2 = sResult
End Sub ' IsometricDemo2
 
' /////////////////////////////////////////////////////////////////////////////
 
Function IsometricDemo3$
    Dim RoutineName As String: RoutineName = "IsometricDemo3"
    Dim sResult AS String : sResult = ""
    Dim sError As String: sError = ""
    Dim iX%
    Dim iY%
    Dim iZ%
    Dim iNewX%
    Dim iNewY%
    Dim iNewZ%
    Dim iMyColor&
    Dim iColorScheme%
    Dim iDirection%
    Dim bFound As Integer
    DIM bDone As Integer
    Dim in$
    Dim iTotal% ' compute total available spaces
    Dim iCount% ' count # of spaces searched
    Dim bEnableRepeatingKeys As Integer
    Dim iLastKey As Integer ' USED WHEN REPEATING KEYS DISABLED
    
    Dim iPosX1%
    Dim iPosX2%
    Dim iPosY1%
    Dim iPosY2%
    Dim iNextColor&
    Dim bContinue As Integer
    Dim iLoopX%
    Dim iLoopY%
    Dim iLoopZ%
    Dim iLevelCount%
    Dim iLevelSize%
    
    Dim iDrawX%
    Dim iDrawY%
    
    Dim iNumPlayers AS Integer ' # OF PLAYERS ACTIVE
    Dim iPlayerLoop AS Integer
    Dim iDirLoop AS Integer
    
    ' =============================================================================
    ' GET OPTIONS
    iNumPlayers = 1
    'iNumPlayers = PromptForIntegerInRange%("How many players ({min}-{max} or blank to quit)?", 1, 4, 0)
    'IF iNumPlayers = 0 THEN Goto CleanupAndExit
    bEnableRepeatingKeys = FALSE
    
    ' =============================================================================
    ' INITIALIZE GRAPHIC SCREEN
    'Screen _NewImage(1024, 720, 32) : _ScreenMove _Middle
    Screen _NewImage(1280, 1024, 32) : _ScreenMove 0,0
    
    m_arrSplitScreen(1).GridOffsetX = 50
    m_arrSplitScreen(1).GridOffsetY = 50
    m_arrSplitScreen(1).GridOffsetZ = 0
    m_arrSplitScreen(1).ScreenOffsetX = 450
    m_arrSplitScreen(1).ScreenOffsetY = 200
    m_arrSplitScreen(1).ScreenOffsetZ = 0
    
    m_arrSplitScreen(2).GridOffsetX = 50
    m_arrSplitScreen(2).GridOffsetY = 50
    m_arrSplitScreen(2).GridOffsetZ = 0
    m_arrSplitScreen(2).ScreenOffsetX = 1000
    m_arrSplitScreen(2).ScreenOffsetY = 200
    m_arrSplitScreen(2).ScreenOffsetZ = 0
    
    m_arrSplitScreen(3).GridOffsetX = 50
    m_arrSplitScreen(3).GridOffsetY = 50
    m_arrSplitScreen(3).GridOffsetZ = 0
    m_arrSplitScreen(3).ScreenOffsetX = 450
    m_arrSplitScreen(3).ScreenOffsetY = 700
    m_arrSplitScreen(3).ScreenOffsetZ = 0
    
    m_arrSplitScreen(4).GridOffsetX = 50
    m_arrSplitScreen(4).GridOffsetY = 50
    m_arrSplitScreen(4).GridOffsetZ = 0
    m_arrSplitScreen(4).ScreenOffsetX = 1000
    m_arrSplitScreen(4).ScreenOffsetY = 700
    m_arrSplitScreen(4).ScreenOffsetZ = 0
    
    ' -----------------------------------------------------------------------------
    ' INITIALIZE MAP TO EMPTY
    ClearIsometricMap
    
    ' -----------------------------------------------------------------------------
    ' DRAW FLOOR
    For iLoopZ% = m_iMapMinZ To m_iMapMinZ
        For iLoopX% = m_iMapMinX To m_iMapMaxX
            For iLoopY% = m_iMapMinY To m_iMapMaxY
                m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Floor_Tiled
                m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Color1 = cGray&
                m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Color2 = cLightGray&
            Next iLoopY%
        Next iLoopX%
    Next iLoopZ%
 
    ' -----------------------------------------------------------------------------
    ' DRAW A TALL HOLLOW PYRAMID
    If TRUE = TRUE Then
        iX% = 5
        iY% = 10
        iZ% = 1
        iLevelSize% = 4
        
        iPosX1% = iX%
        iPosX2% = iX% + 7
        iPosY1% = iY%
        iPosY2% = iY% + 7
        iNextColor& = cRed&
        iColorScheme% = 1 ' 1 = Rainbow6 #1, 9 = Rainbow6 #2, etc.
        iLevelCount% = 0
        
        bContinue = TRUE
        Do
            ' PLOT NEXT LEVEL (SOLID)
            'For iLoopX% = iPosX1% To iPosX2%
            '    For iLoopY% = iPosY1% To iPosY2%
            '        m_arrMap(iLoopX%, iLoopY%, iZ%).Typ = c_iMapType_Wall
            '        m_arrMap(iLoopX%, iLoopY%, iZ%).Color1 = iNextColor&
            '    Next iLoopY%
            'Next iLoopX%
            
            ' Draw front/back walls
            For iLoopX% = iPosX1% To iPosX2%
                iLoopY% = iPosY1%
                m_arrMap(iLoopX%, iLoopY%, iZ%).Typ = c_iMapType_Wall
                m_arrMap(iLoopX%, iLoopY%, iZ%).Color1 = iNextColor&
                m_arrMap(iLoopX%, iLoopY%, iZ%).AlphaOverride = 255
                
                iLoopY% = iPosY2%
                m_arrMap(iLoopX%, iLoopY%, iZ%).Typ = c_iMapType_Wall
                m_arrMap(iLoopX%, iLoopY%, iZ%).Color1 = iNextColor&
                m_arrMap(iLoopX%, iLoopY%, iZ%).AlphaOverride = 255
            Next iLoopX%
            
            ' Draw left/right walls
            For iLoopY% = iPosY1% To iPosY2%
                iLoopX% = iPosX1%
                m_arrMap(iLoopX%, iLoopY%, iZ%).Typ = c_iMapType_Wall
                m_arrMap(iLoopX%, iLoopY%, iZ%).Color1 = iNextColor&
                m_arrMap(iLoopX%, iLoopY%, iZ%).AlphaOverride = 255
                
                iLoopX% = iPosX2%
                m_arrMap(iLoopX%, iLoopY%, iZ%).Typ = c_iMapType_Wall
                m_arrMap(iLoopX%, iLoopY%, iZ%).Color1 = iNextColor&
                m_arrMap(iLoopX%, iLoopY%, iZ%).AlphaOverride = 255
            Next iLoopY%
            
            ' Add a door to middle of right wall
            iX% = iPosX1% + ( (iPosX2% - iPosX1%) \ 2)
            m_arrMap(iX%, iPosY2%, iZ%).Typ = c_iMapType_Empty
            
            ' Add a door to middle of front wall
            iY% = iPosY1% + ( (iPosY2% - iPosY1%) \ 2)
            m_arrMap(iPosX2%, iY%, iZ%).Typ = c_iMapType_Empty
            
            ' MOVE UP A LEVEL
            iLevelCount% = iLevelCount% + 1
            IF iLevelCount% > iLevelSize% THEN
                iLevelCount% = 0
                iPosX1% = iPosX1% + 1
                iPosX2% = iPosX2% - 1
                iPosY1% = iPosY1% + 1
                iPosY2% = iPosY2% - 1
            END IF
            
            ' QUIT AFTER WE REACH THE TOP
            If (iPosX1% <= iPosX2%) And (iPosY1% <= iPosY2%) Then
                iZ% = iZ% + 1
                DoCycleColor iColorScheme%, iNextColor&
                If iZ% > m_iMapMaxZ Then
                    bContinue = FALSE
                End If
            Else
                bContinue = FALSE
            End If
            
        Loop Until bContinue = FALSE
    End If    
    
    ' -----------------------------------------------------------------------------
    ' DRAW FRAME AROUND ENTIRE SPACE (TOP)
    
    FOR iLoopX% = m_iMapMinX+3 TO m_iMapMaxX-3
        m_arrMap(iLoopX%, m_iMapMaxY-3, m_iMapMaxZ).Typ = c_iMapType_Wall
        m_arrMap(iLoopX%, m_iMapMaxY-3, m_iMapMaxZ).Color1 = cPurple&
        
        m_arrMap(iLoopX%, m_iMapMinY+3, m_iMapMaxZ).Typ = c_iMapType_Wall
        m_arrMap(iLoopX%, m_iMapMinY+3, m_iMapMaxZ).Color1 = cCyan&
    NEXT iLoopX%
    
    FOR iLoopY% = m_iMapMinY+3 TO m_iMapMaxY-3
        m_arrMap(m_iMapMinX+3, iLoopY%, m_iMapMaxZ).Typ = c_iMapType_Wall
        m_arrMap(m_iMapMinX+3, iLoopY%, m_iMapMaxZ).Color1 = cOrange&
        
        m_arrMap(m_iMapMaxX-3, iLoopY%, m_iMapMaxZ).Typ = c_iMapType_Wall
        m_arrMap(m_iMapMaxX-3, iLoopY%, m_iMapMaxZ).Color1 = cLime&
    NEXT iLoopY%
    
    ' -----------------------------------------------------------------------------
    ' DRAW FRAME AROUND ENTIRE SPACE (MIDDLE)
    
    FOR iLoopX% = m_iMapMinX+2 TO m_iMapMaxX-2
        m_arrMap(iLoopX%, m_iMapMaxY-2, m_iMapMidZ).Typ = c_iMapType_Wall
        m_arrMap(iLoopX%, m_iMapMaxY-2, m_iMapMidZ).Color1 = cDodgerBlue&
        
        m_arrMap(iLoopX%, m_iMapMinY+2, m_iMapMidZ).Typ = c_iMapType_Wall
        m_arrMap(iLoopX%, m_iMapMinY+2, m_iMapMidZ).Color1 = cDeepPurple&
    NEXT iLoopX%
    
    FOR iLoopY% = m_iMapMinY+2 TO m_iMapMaxY-2
        m_arrMap(m_iMapMinX+2, iLoopY%, m_iMapMidZ).Typ = c_iMapType_Wall
        m_arrMap(m_iMapMinX+2, iLoopY%, m_iMapMidZ).Color1 = cDarkRed&
        
        m_arrMap(m_iMapMaxX-2, iLoopY%, m_iMapMidZ).Typ = c_iMapType_Wall
        m_arrMap(m_iMapMaxX-2, iLoopY%, m_iMapMidZ).Color1 = cGold&
    NEXT iLoopY%
    
    ' -----------------------------------------------------------------------------
    ' DRAW FRAME AROUND ENTIRE SPACE (BOTTOM)
    
    FOR iLoopX% = m_iMapMinX+1 TO m_iMapMaxX-1
        m_arrMap(iLoopX%, m_iMapMaxY-1, m_iMapMinZ+1).Typ = c_iMapType_Wall
        m_arrMap(iLoopX%, m_iMapMaxY-1, m_iMapMinZ+1).Color1 = cSeaBlue&
        
        m_arrMap(iLoopX%, m_iMapMinY+1, m_iMapMinZ+1).Typ = c_iMapType_Wall
        m_arrMap(iLoopX%, m_iMapMinY+1, m_iMapMinZ+1).Color1 = cChartreuse&
    NEXT iLoopX%
    
    FOR iLoopY% = m_iMapMinY+1 TO m_iMapMaxY-1
        m_arrMap(m_iMapMinX+1, iLoopY%, m_iMapMinZ+1).Typ = c_iMapType_Wall
        m_arrMap(m_iMapMinX+1, iLoopY%, m_iMapMinZ+1).Color1 = cOrangeRed&
        
        m_arrMap(m_iMapMaxX-1, iLoopY%, m_iMapMinZ+1).Typ = c_iMapType_Wall
        m_arrMap(m_iMapMaxX-1, iLoopY%, m_iMapMinZ+1).Color1 = cDeepSkyBlue&
    NEXT iLoopY%
    
    ' =============================================================================
    ' PLACE PLAYER(S) <- ONLY ONE FOR THIS DEMO
    
    FOR iPlayerLoop = 1 TO iNumPlayers
        
'TODO: GET THIS WORKING (CURRENTLY IT'S ALL WEIRD)
'TODO: WHATEVER THE KEYS MAPPED ARE, SWAP THEM NON-HARDCODED
        ' -----------------------------------------------------------------------------
        ' BEGIN Map the 6 directional keys
        ' -----------------------------------------------------------------------------
        ' differently for each of the 6 directional orientations!
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Down).KeyBack = c_iKeyDown_Down
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Down).KeyForward = c_iKeyDown_Up
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Down).KeyLeft = c_iKeyDown_Left
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Down).KeyRight = c_iKeyDown_Right
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Down).KeyUp = c_iKeyDown_PgDn
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Down).KeyDown = c_iKeyDown_PgUp
        
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Up).KeyBack = c_iKeyDown_PgDn
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Up).KeyForward = c_iKeyDown_PgUp
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Up).KeyLeft = c_iKeyDown_Left
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Up).KeyRight = c_iKeyDown_Right
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Up).KeyUp = c_iKeyDown_Up
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Up).KeyDown = c_iKeyDown_Down
        
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Left).KeyBack = c_iKeyDown_Right
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Left).KeyForward = c_iKeyDown_Left
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Left).KeyLeft = c_iKeyDown_Down
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Left).KeyRight = c_iKeyDown_Up
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Left).KeyUp = c_iKeyDown_PgUp
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Left).KeyDown = c_iKeyDown_PgDn
        
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Right).KeyBack = c_iKeyDown_Left
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Right).KeyForward = c_iKeyDown_Right
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Right).KeyLeft = c_iKeyDown_Up
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Right).KeyRight = c_iKeyDown_Down
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Right).KeyUp = c_iKeyDown_PgUp
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Right).KeyDown = c_iKeyDown_PgDn
        
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Back).KeyBack = c_iKeyDown_Down
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Back).KeyForward = c_iKeyDown_Up
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Back).KeyLeft = c_iKeyDown_Right
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Back).KeyRight = c_iKeyDown_Left
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Back).KeyUp = c_iKeyDown_PgUp
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Back).KeyDown = c_iKeyDown_PgDn
        
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Forward).KeyBack = c_iKeyDown_Up
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Forward).KeyForward = c_iKeyDown_Down
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Forward).KeyLeft = c_iKeyDown_Left
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Forward).KeyRight = c_iKeyDown_Right
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Forward).KeyUp = c_iKeyDown_PgUp
        m_arrDirKeyMap(iPlayerLoop, c_iDir_Forward).KeyDown = c_iKeyDown_PgDn
        ' -----------------------------------------------------------------------------
        ' END Map the 6 directional keys
        ' -----------------------------------------------------------------------------
        
        ' FIND START POSITION
        iX% = RandomNumber(m_iMapMinX, m_iMapMaxX)
        iY% = RandomNumber(m_iMapMinY, m_iMapMaxY)
        iZ% = 1 ' RandomNumber(m_iMapMinZ, m_iMapMaxZ)
        
        ' MAKE SURE IT'S EMPTY
        IF m_arrMap(iX%, iY%, iZ%).Typ = c_iMapType_Empty THEN
            bFound = TRUE
        ELSE
            ' IF NOT EMPTY THEN TRY TO FIND AN EMPTY SPOT
            iTotal% = ((m_iMapMaxX - m_iMapMinX)+1) * ((m_iMapMaxY - m_iMapMinY)+1) * ((m_iMapMaxZ - m_iMapMinZ)+1)
            iCount% = 0
            bFound = FALSE
            Do
                iX% = iX% + 1
                if iX% > m_iMapMaxX then
                    ' reset x and move to next y
                    iX% = m_iMapMinX
                    iY% = iY% + 1
                    if iY% > m_iMapMaxY then
                        ' reset y and move to next z
                        iY% = m_iMapMinY
                        iZ% = iZ% + 1
                        if iZ% > m_iMapMaxZ then
                            ' RESET Z AND SEE IF WE HAVE CHECKED EVERYTHING
                            iZ% = m_iMapMinZ
                            iCount% = iCount% + 1
                            if iCount% >= iTotal% then
                                ' NONE FOUND, EXIT
                                Exit Do
                            end if
                        else
                            iCount% = iCount% + 1
                        end if
                    else
                        iCount% = iCount% + 1
                    end if
                else
                    iCount% = iCount% + 1
                end if
                IF m_arrMap(iX%, iY%, iZ%).Typ = c_iMapType_Empty THEN
                    ' FOUND AN EMPTY SPACE, EXIT
                    bFound = TRUE
                    Exit Do
                END IF
            Loop
        END IF
        
        If bFound = TRUE THEN
            ' PICK A DIRECTION (SIMPLE FOR NOW, LEFT OR RIGHT)
            if iX% <= m_iMapMidX then
                m_arrPlayer(iPlayerLoop).Direction = c_iDir_Right
            else
                m_arrPlayer(iPlayerLoop).Direction = c_iDir_Left
            end if
            
            m_arrPlayer(iPlayerLoop).Tile1 = c_iMapType_Player1
            
            ' SAVE COORDINATES TO PLAYER
            ' ****************************************************************************************************************************************************************
            ' for this demo we'll just use iX% instead of m_arrPlayer(iPlayerLoop).x, etc.
            ' to make it more readable
            ' ****************************************************************************************************************************************************************
            m_arrPlayer(iPlayerLoop).x = iX%
            m_arrPlayer(iPlayerLoop).y = iY%
            m_arrPlayer(iPlayerLoop).z = iZ%
            m_arrPlayer(iPlayerLoop).View = c_iDir_Forward
            m_arrPlayer(iPlayerLoop).Color1 = cRed&
            m_arrPlayer(iPlayerLoop).Alpha1 = 255
            m_arrPlayer(iPlayerLoop).AlphaOverride = 255
            m_arrPlayer(iPlayerLoop).ColorScheme1 = 2
            m_arrPlayer(iPlayerLoop).ColorSchemeSpeed1 = 5 ' change color every 5 frames
            m_arrPlayer(iPlayerLoop).ColorSchemeCount1 = 0
            
                        ' DISPLAY OPTIONS
                        m_arrPlayer(iPlayerLoop).GridSize = 8
                        m_arrPlayer(iPlayerLoop).MapSize = 4
                        
            ' RESET MOVEMENT VARIABLES
            m_arrPlayer(iPlayerLoop).IsMoving = FALSE
            m_arrPlayer(iPlayerLoop).IsMoved = FALSE
            
            ' DRAW PLAYER
            m_arrMap(iX%, iY%, iZ%).Typ = m_arrPlayer(iPlayerLoop).Tile1
            m_arrMap(iX%, iY%, iZ%).Color1 = m_arrPlayer(iPlayerLoop).Color1
            m_arrMap(iX%, iY%, iZ%).AlphaOverride = m_arrPlayer(iPlayerLoop).Alpha1
            
        Else
            sError = "Could not find an empty space to start player."    
            Exit For
        End If
        
    NEXT iPlayerLoop
    
    ' =============================================================================
    ' OTHER SETUP
    If Len(sError)=0 Then
        ' RESET INPUT
        WHILE _DEVICEINPUT(1): WEND ' clear and update the keyboard buffer
        iLastKey = c_iKeyDown_Enter
    End If
    
    ' =============================================================================
    ' MAIN LOOP
    If Len(sError)=0 Then
        bFinished = FALSE
        Do
            CLS ' is cls necessary?
            
            ' SHOW INSTRUCTIONS / COORDINATES ON SCREEN
            LOCATE  1, 1: PRINT "IsometricDemo3"
            LOCATE  3, 1: PRINT "CRSR RT/LF MOVES X = " + CSTR$(iX%)
            LOCATE  4, 1: PRINT "CRSR UP/DN MOVES Y = " + CSTR$(iY%)
            LOCATE  5, 1: PRINT "PAGE UP/DN MOVES Z = " + CSTR$(iZ%)
            LOCATE  6, 1: PRINT "=    / -   CHANGES GRID SIZE   = " + CSTR$(m_arrPlayer(1).GridSize)
            LOCATE  7, 1: PRINT "[    / ]   TOGGLES MOVEMENT    = " + IIFSTR$(m_arrPlayer(1).IsMoving, "TRUE", "FALSE")
            LOCATE  8, 1: PRINT "INS  / DEL TOGGLES REPEAT KEYS = " + IIFSTR$(bEnableRepeatingKeys, "TRUE", "FALSE")
            LOCATE  9, 1: PRINT "HOME / END CHANGES VIEW ANGLE  = " + GetDirection$(m_arrPlayer(1).View)
            LOCATE 10, 1: PRINT ",    / .   CHANGES MAP SIZE    = " + CSTR$(m_arrPlayer(1).MapSize)
            LOCATE 12, 1: PRINT "PRESS <ESC> TO QUIT"
            
            ' ****************************************************************************************************************************************************************
            ' BEGIN PLAYER LOOP
            ' ****************************************************************************************************************************************************************
            DrawScreen c_iDir_Forward, m_arrSplitScreen(1).ScreenOffsetX, m_arrSplitScreen(1).ScreenOffsetY, m_arrPlayer(1).GridSize, iX%, iY%, iZ%
            DrawScreen c_iDir_Back,    m_arrSplitScreen(2).ScreenOffsetX, m_arrSplitScreen(2).ScreenOffsetY, m_arrPlayer(1).GridSize, iX%, iY%, iZ%
            DrawScreen c_iDir_Left,    m_arrSplitScreen(3).ScreenOffsetX, m_arrSplitScreen(3).ScreenOffsetY, m_arrPlayer(1).GridSize, iX%, iY%, iZ%
            DrawScreen c_iDir_Right,   m_arrSplitScreen(4).ScreenOffsetX, m_arrSplitScreen(4).ScreenOffsetY, m_arrPlayer(1).GridSize, iX%, iY%, iZ%
                        
            FOR iPlayerLoop = 1 TO iNumPlayers
                'DrawScreen m_arrPlayer(iPlayerLoop).View, cScreenOffsetX, cScreenOffsetY, iX%, iY%, iZ%
                
                ' -----------------------------------------------------------------------------
                ' BEGIN SHOW 2D MINI MAP ON SCREEN
                ' -----------------------------------------------------------------------------
                ' TODO: FOR MULTIPLAYER, DRAW A SEPARATE MAP PER PLAYER TO SPLIT SCREEN
                FOR iLoopX% = m_iMapMinX TO m_iMapMaxX
                    FOR iLoopY% = m_iMapMinY TO m_iMapMaxY
                        'iDrawX% = (iLoopX% * 4) + 20
                                                iDrawX% = (iLoopX% * m_arrPlayer(1).MapSize) + 20
                                                
                        'iDrawY% = (iLoopY% * 4) + 200
                                                iDrawY% = (iLoopY% * m_arrPlayer(1).MapSize) + 200
                        
                        IF m_arrMap(iLoopX%, iLoopY%, iZ%).Typ = c_iMapType_Wall THEN
                            'DrawBox iDrawX%, iDrawY%, 4, m_arrMap(iLoopX%, iLoopY%, iZ%).Color1
                                                        DrawBox iDrawX%, iDrawY%, m_arrPlayer(1).MapSize, m_arrMap(iLoopX%, iLoopY%, iZ%).Color1
                            
                        ELSEIF m_arrMap(iLoopX%, iLoopY%, iZ%).Typ = c_iMapType_Player1 THEN
                            'DrawBox iDrawX%, iDrawY%, 4, m_arrMap(iLoopX%, iLoopY%, iZ%).Color1
                                                        DrawBox iDrawX%, iDrawY%, m_arrPlayer(1).MapSize, m_arrMap(iLoopX%, iLoopY%, iZ%).Color1
                        ELSEIF m_arrMap(iLoopX%, iLoopY%, iZ%).Typ = c_iMapType_Player2 THEN
                            'DrawBox iDrawX%, iDrawY%, 4, m_arrMap(iLoopX%, iLoopY%, iZ%).Color1
                                                        DrawBox iDrawX%, iDrawY%, m_arrPlayer(1).MapSize, m_arrMap(iLoopX%, iLoopY%, iZ%).Color1
                        ELSEIF m_arrMap(iLoopX%, iLoopY%, iZ%).Typ = c_iMapType_Player3 THEN
                            'DrawBox iDrawX%, iDrawY%, 4, m_arrMap(iLoopX%, iLoopY%, iZ%).Color1
                                                        DrawBox iDrawX%, iDrawY%, m_arrPlayer(1).MapSize, m_arrMap(iLoopX%, iLoopY%, iZ%).Color1
                        ELSEIF m_arrMap(iLoopX%, iLoopY%, iZ%).Typ = c_iMapType_Player4 THEN
                            'DrawBox iDrawX%, iDrawY%, 4, m_arrMap(iLoopX%, iLoopY%, iZ%).Color1
                                                        DrawBox iDrawX%, iDrawY%, m_arrPlayer(1).MapSize, m_arrMap(iLoopX%, iLoopY%, iZ%).Color1
                            
                        'TODO: ADD OTHER TYPES
                        
                        ELSE
                            'DrawBox iDrawX%, iDrawY%, 4, cBlack&
                                                        'DrawBox iDrawX%, iDrawY%, 4, cKhaki&
                                                        DrawBox iDrawX%, iDrawY%, m_arrPlayer(1).MapSize, cKhaki&
                        END IF
                    NEXT iLoopY%
                NEXT iLoopX%
                ' -----------------------------------------------------------------------------
                ' END SHOW 2D MINI MAP ON SCREEN
                ' -----------------------------------------------------------------------------
                
                
                ' -----------------------------------------------------------------------------
                ' BEGIN GET DIRECTIONAL KEYBOARD INPUT
                ' -----------------------------------------------------------------------------
                If _KeyDown(c_iKeyDown_Up) Then
                    If iLastKey <> c_iKeyDown_Up OR bEnableRepeatingKeys=TRUE Then
                        iLastKey = c_iKeyDown_Up
                        m_arrPlayer(iPlayerLoop).Direction = c_iDir_Back
                        bMoved = TRUE
                    End If
                ElseIf _KeyDown(c_iKeyDown_Down) Then
                    If iLastKey <> c_iKeyDown_Down OR bEnableRepeatingKeys=TRUE Then
                        iLastKey = c_iKeyDown_Down
                        m_arrPlayer(iPlayerLoop).Direction = c_iDir_Forward
                        bMoved = TRUE
                    End If
                ElseIf _KeyDown(c_iKeyDown_Left) Then
                    If iLastKey <> c_iKeyDown_Left OR bEnableRepeatingKeys=TRUE Then
                        iLastKey = c_iKeyDown_Left
                        m_arrPlayer(iPlayerLoop).Direction = c_iDir_Left
                        bMoved = TRUE
                    End If
                ElseIf _KeyDown(c_iKeyDown_Right) Then
                    If iLastKey <> c_iKeyDown_Right OR bEnableRepeatingKeys=TRUE Then
                        iLastKey = c_iKeyDown_Right
                        m_arrPlayer(iPlayerLoop).Direction = c_iDir_Right
                        bMoved = TRUE
                    End If
                ElseIf _KeyDown(c_iKeyDown_PgUp) Then
                    If iLastKey <> c_iKeyDown_PgUp OR bEnableRepeatingKeys=TRUE Then
                        iLastKey = c_iKeyDown_PgUp
                        m_arrPlayer(iPlayerLoop).Direction = c_iDir_Up
                        bMoved = TRUE
                    End If
                ElseIf _KeyDown(c_iKeyDown_PgDn) Then
                    If iLastKey <> c_iKeyDown_PgDn OR bEnableRepeatingKeys=TRUE Then
                        iLastKey = c_iKeyDown_PgDn
                        m_arrPlayer(iPlayerLoop).Direction = c_iDir_Down
                        bMoved = TRUE
                    End If                
                ' -----------------------------------------------------------------------------
                ' END GET DIRECTIONAL KEYBOARD INPUT
                ' -----------------------------------------------------------------------------
                
                
                
'TODO: GET THIS WORKING (CURRENTLY IT'S ALL WEIRD)
'                ' -----------------------------------------------------------------------------
'                ' BEGIN GET VARIABLE DIRECTIONAL KEYBOARD INPUT
'                ' -----------------------------------------------------------------------------
'                If _KeyDown(m_arrDirKeyMap(iPlayerLoop, m_arrPlayer(iPlayerLoop).Direction).KeyBack) Then
'                    If iLastKey <> m_arrDirKeyMap(iPlayerLoop, m_arrPlayer(iPlayerLoop).Direction).KeyBack OR bEnableRepeatingKeys=TRUE Then
'                        iLastKey = m_arrDirKeyMap(iPlayerLoop, m_arrPlayer(iPlayerLoop).Direction).KeyBack
'                        m_arrPlayer(iPlayerLoop).Direction = c_iDir_Back
'                        bMoved = TRUE
'                    End If
'                ElseIf _KeyDown(m_arrDirKeyMap(iPlayerLoop, m_arrPlayer(iPlayerLoop).Direction).KeyForward) Then
'                    If iLastKey <> m_arrDirKeyMap(iPlayerLoop, m_arrPlayer(iPlayerLoop).Direction).KeyForward OR bEnableRepeatingKeys=TRUE Then
'                        iLastKey = m_arrDirKeyMap(iPlayerLoop, m_arrPlayer(iPlayerLoop).Direction).KeyForward
'                        m_arrPlayer(iPlayerLoop).Direction = c_iDir_Forward
'                        bMoved = TRUE
'                    End If
'                ElseIf _KeyDown(m_arrDirKeyMap(iPlayerLoop, m_arrPlayer(iPlayerLoop).Direction).KeyLeft) Then
'                    If iLastKey <> m_arrDirKeyMap(iPlayerLoop, m_arrPlayer(iPlayerLoop).Direction).KeyLeft OR bEnableRepeatingKeys=TRUE Then
'                        iLastKey = m_arrDirKeyMap(iPlayerLoop, m_arrPlayer(iPlayerLoop).Direction).KeyLeft
'                        m_arrPlayer(iPlayerLoop).Direction = c_iDir_Left
'                        bMoved = TRUE
'                    End If
'                ElseIf _KeyDown(m_arrDirKeyMap(iPlayerLoop, m_arrPlayer(iPlayerLoop).Direction).KeyRight) Then
'                    If iLastKey <> m_arrDirKeyMap(iPlayerLoop, m_arrPlayer(iPlayerLoop).Direction).KeyRight OR bEnableRepeatingKeys=TRUE Then
'                        iLastKey = m_arrDirKeyMap(iPlayerLoop, m_arrPlayer(iPlayerLoop).Direction).KeyRight
'                        m_arrPlayer(iPlayerLoop).Direction = c_iDir_Right
'                        bMoved = TRUE
'                    End If
'                ElseIf _KeyDown(m_arrDirKeyMap(iPlayerLoop, m_arrPlayer(iPlayerLoop).Direction).KeyUp) Then
'                    If iLastKey <> m_arrDirKeyMap(iPlayerLoop, m_arrPlayer(iPlayerLoop).Direction).KeyUp OR bEnableRepeatingKeys=TRUE Then
'                        iLastKey = m_arrDirKeyMap(iPlayerLoop, m_arrPlayer(iPlayerLoop).Direction).KeyUp
'                        m_arrPlayer(iPlayerLoop).Direction = c_iDir_Up
'                        bMoved = TRUE
'                    End If
'                ElseIf _KeyDown(m_arrDirKeyMap(iPlayerLoop, m_arrPlayer(iPlayerLoop).Direction).KeyDown) Then
'                    If iLastKey <> m_arrDirKeyMap(iPlayerLoop, m_arrPlayer(iPlayerLoop).Direction).KeyDown OR bEnableRepeatingKeys=TRUE Then
'                        iLastKey = m_arrDirKeyMap(iPlayerLoop, m_arrPlayer(iPlayerLoop).Direction).KeyDown
'                        m_arrPlayer(iPlayerLoop).Direction = c_iDir_Down
'                        bMoved = TRUE
'                    End If
'                ' -----------------------------------------------------------------------------
'                ' END GET VARIABLE DIRECTIONAL KEYBOARD INPUT
'                ' -----------------------------------------------------------------------------
 
                ' -----------------------------------------------------------------------------
                ' BEGIN GET OTHER KEYBOARD INPUT
                ' -----------------------------------------------------------------------------
                ElseIf _KeyDown(c_iKeyDown_BracketLeft) Then
                    If iLastKey <> c_iKeyDown_BracketLeft OR bEnableRepeatingKeys=TRUE Then
                        iLastKey = c_iKeyDown_BracketLeft
                        m_arrPlayer(iPlayerLoop).IsMoving = TRUE
                    End If
                ElseIf _KeyDown(c_iKeyDown_BracketRight) Then
                    If iLastKey <> c_iKeyDown_BracketRight OR bEnableRepeatingKeys=TRUE Then
                        iLastKey = c_iKeyDown_BracketRight
                        m_arrPlayer(iPlayerLoop).IsMoving = FALSE
                    End If
                    
                                        
                                        
                                        
'yoda
                ElseIf _KeyDown(c_iKeyDown_Comma) Then
                    If iLastKey <> c_iKeyDown_Comma OR bEnableRepeatingKeys=TRUE Then
                        iLastKey = c_iKeyDown_Comma
                        ' TODO: HAVE MAP SIZE PER PLAYER
                        m_arrPlayer(iPlayerLoop).MapSize = m_arrPlayer(iPlayerLoop).MapSize - 1
                        IF m_arrPlayer(iPlayerLoop).MapSize < 1 THEN
                            m_arrPlayer(iPlayerLoop).MapSize = 1
                        ELSE
                            bMoved = TRUE
                        END IF
                    End If
                ElseIf _KeyDown(c_iKeyDown_Period) Then
                    If iLastKey <> c_iKeyDown_Period OR bEnableRepeatingKeys=TRUE Then
                        iLastKey = c_iKeyDown_Period
                        m_arrPlayer(iPlayerLoop).MapSize = m_arrPlayer(iPlayerLoop).MapSize + 1
                        IF m_arrPlayer(iPlayerLoop).MapSize > m_iGridSizeMax THEN
                            m_arrPlayer(iPlayerLoop).MapSize = m_iGridSizeMax
                        ELSE
                            bMoved = TRUE
                        END IF
                    End If
                                        
                                        
                                        
                                        
                                        
                                        
                ElseIf _KeyDown(c_iKeyDown_Minus) Then
                    If iLastKey <> c_iKeyDown_Minus OR bEnableRepeatingKeys=TRUE Then
                        iLastKey = c_iKeyDown_Minus
                        ' TODO: HAVE SEPARATE GRID SIZE PER PLAYER / SPLIT SCREEN?
                        m_arrPlayer(iPlayerLoop).GridSize = m_arrPlayer(iPlayerLoop).GridSize - 1
                        IF m_arrPlayer(iPlayerLoop).GridSize < m_iGridSizeMin THEN
                            m_arrPlayer(iPlayerLoop).GridSize = m_iGridSizeMin
                        ELSE
                            bMoved = TRUE
                        END IF
                    End If
                ElseIf _KeyDown(c_iKeyDown_EqualPlus) Then
                    If iLastKey <> c_iKeyDown_EqualPlus OR bEnableRepeatingKeys=TRUE Then
                        iLastKey = c_iKeyDown_EqualPlus
                        m_arrPlayer(iPlayerLoop).GridSize = m_arrPlayer(iPlayerLoop).GridSize + 1
                        IF m_arrPlayer(iPlayerLoop).GridSize > m_iGridSizeMax THEN
                            m_arrPlayer(iPlayerLoop).GridSize = m_iGridSizeMax
                        ELSE
                            bMoved = TRUE
                        END IF
                    End If
                    
                ElseIf _KeyDown(c_iKeyDown_Home) Then
                    If iLastKey <> c_iKeyDown_Home OR bEnableRepeatingKeys=TRUE Then
                        iLastKey = c_iKeyDown_Home
                        ' c_iDir_Left, c_iDir_Right, c_iDir_Back, c_iDir_Forward, c_iDir_Down, c_iDir_Up
                        m_arrPlayer(iPlayerLoop).View = m_arrPlayer(iPlayerLoop).View - 1
                        IF m_arrPlayer(iPlayerLoop).View < c_iDir_Min THEN
                            m_arrPlayer(iPlayerLoop).View = c_iDir_Max
                        END IF
                    End If
                ElseIf _KeyDown(c_iKeyDown_End) Then
                    If iLastKey <> c_iKeyDown_End OR bEnableRepeatingKeys=TRUE Then
                        iLastKey = c_iKeyDown_End
                        ' c_iDir_Left, c_iDir_Right, c_iDir_Back, c_iDir_Forward, c_iDir_Down, c_iDir_Up
                        m_arrPlayer(iPlayerLoop).View = m_arrPlayer(iPlayerLoop).View + 1
                        IF m_arrPlayer(iPlayerLoop).View > c_iDir_Max THEN
                            m_arrPlayer(iPlayerLoop).View = c_iDir_Min
                        END IF
                    End If
                    
                ElseIf _KeyDown(c_iKeyDown_Ins) Then
                    ' TODO: DO WE NEED TO HANDLE REPEATING KEYS FOR MULTIPLAYER?
                    If iLastKey <> c_iKeyDown_Ins OR bEnableRepeatingKeys=TRUE Then
                        iLastKey = c_iKeyDown_Ins
                        bEnableRepeatingKeys = TRUE
                    End If
                    
                ElseIf _KeyDown(c_iKeyDown_Del) Then
                    ' TODO: DO WE NEED TO HANDLE REPEATING KEYS FOR MULTIPLAYER?
                    If iLastKey <> c_iKeyDown_Del OR bEnableRepeatingKeys=TRUE Then
                        iLastKey = c_iKeyDown_Del
                        bEnableRepeatingKeys = FALSE
                    End If
                    
                ElseIf _KeyDown(c_iKeyDown_Esc) Then
                    Exit Do
                Else
                    iLastKey = -1
                End If
                ' -----------------------------------------------------------------------------
                ' END GET OTHER KEYBOARD INPUT
                ' -----------------------------------------------------------------------------
                
                ' --------------------------------------------------------------------------------
                ' ERASE OLD POSITION
                ' --------------------------------------------------------------------------------
                m_arrMap(iX%, iY%, iZ%).Typ = c_iMapType_Empty
                m_arrMap(iX%, iY%, iZ%).Color1 = cEmpty&
                m_arrMap(iX%, iY%, iZ%).AlphaOverride = 255
                
                ' --------------------------------------------------------------------------------
                ' MOVE PLAYER BASED ON DIRECTION
                ' --------------------------------------------------------------------------------
                IF m_arrPlayer(iPlayerLoop).IsMoving=TRUE OR bMoved=TRUE THEN
                    bMoved = FALSE
                    
                    SELECT CASE m_arrPlayer(iPlayerLoop).Direction
                        CASE c_iDir_Down:
                            iNewX% = iX%
                            iNewY% = iY%
                            iNewZ% = iZ% - 1
                            If iNewZ% < m_iMapMinZ Then
                                iNewZ% = m_iMapMaxZ
                            End If
                            If m_arrMap(iNewX%, iNewY%, iNewZ%).Typ <> c_iMapType_Empty Then
                                m_arrPlayer(iPlayerLoop).Direction = c_iDir_Up
                                iNewZ% = iZ%
                            End If
                            
                        CASE c_iDir_Up:
                            iNewX% = iX%
                            iNewY% = iY%
                            iNewZ% = iZ% + 1
                            If iNewZ% > m_iMapMaxZ Then
                                iNewZ% = m_iMapMinZ
                            End If
                            If m_arrMap(iNewX%, iNewY%, iNewZ%).Typ <> c_iMapType_Empty Then
                                m_arrPlayer(iPlayerLoop).Direction = c_iDir_Down
                                iNewZ% = iZ%
                            End If
                            
                        CASE c_iDir_Left:
                            iNewX% = iX% - 1
                            iNewY% = iY%
                            iNewZ% = iZ%
                            If iNewX% < m_iMapMinX Then
                                iNewX% = m_iMapMaxX
                            End If
                            If m_arrMap(iNewX%, iNewY%, iNewZ%).Typ <> c_iMapType_Empty Then
                                m_arrPlayer(iPlayerLoop).Direction = c_iDir_Right
                                iNewX% = iX%
                            End If
                            
                        CASE c_iDir_Right:
                            iNewX% = iX% + 1
                            iNewY% = iY%
                            iNewZ% = iZ%
                            If iNewX% > m_iMapMaxX Then
                                iNewX% = m_iMapMinX
                            End If
                            If m_arrMap(iNewX%, iNewY%, iNewZ%).Typ <> c_iMapType_Empty Then
                                m_arrPlayer(iPlayerLoop).Direction = c_iDir_Left
                                iNewX% = iX%
                            End If
                            
                        CASE c_iDir_Back:
                            iNewX% = iX%
                            iNewY% = iY% - 1
                            iNewZ% = iZ%
                            If iNewY% < m_iMapMinY Then
                                iNewY% = m_iMapMaxY
                            End If
                            If m_arrMap(iNewX%, iNewY%, iNewZ%).Typ <> c_iMapType_Empty Then
                                m_arrPlayer(iPlayerLoop).Direction = c_iDir_Forward
                                iNewY% = iY%
                            End If
                            
                        CASE c_iDir_Forward:
                            iNewX% = iX%
                            iNewY% = iY% + 1
                            iNewZ% = iZ%
                            If iNewY% > m_iMapMaxY Then
                                iNewY% = m_iMapMinY
                            End If
                            If m_arrMap(iNewX%, iNewY%, iNewZ%).Typ <> c_iMapType_Empty Then
                                m_arrPlayer(iPlayerLoop).Direction = c_iDir_Back
                                iNewY% = iY%
                            End If
                            
                        CASE ELSE:
                            'iNewX% = iX%
                            'iNewY% = iY%
                            'iNewZ% = iZ%
                    END SELECT
                    
                    ' SAVE NEW POSITION
                    iX% = iNewX%
                    iY% = iNewY%
                    iZ% = iNewZ%
                    
                    ' FOR MULTIPLAYER WE WOULD USE:
                    'm_arrPlayer(iPlayerLoop).x = iNewX%
                    'm_arrPlayer(iPlayerLoop).y = iNewY%
                    'm_arrPlayer(iPlayerLoop).z = iNewZ%
                    
                END IF
                
                ' CYCLE COLOR
                IF m_arrPlayer(iPlayerLoop).ColorScheme1 > 0 THEN
                    m_arrPlayer(iPlayerLoop).ColorSchemeCount1 = m_arrPlayer(iPlayerLoop).ColorSchemeCount1 + 1
                    IF m_arrPlayer(iPlayerLoop).ColorSchemeCount1 > m_arrPlayer(iPlayerLoop).ColorSchemeSpeed1 THEN
                        m_arrPlayer(iPlayerLoop).ColorSchemeCount1 = 0
                        DoCycleColor m_arrPlayer(iPlayerLoop).ColorScheme1, m_arrPlayer(iPlayerLoop).Color1
                    END IF
                END IF
                
                ' REDRAW AT CURRENT POSITION
                m_arrMap(iX%, iY%, iZ%).Typ = m_arrPlayer(iPlayerLoop).Tile1
                m_arrMap(iX%, iY%, iZ%).Color1 = m_arrPlayer(iPlayerLoop).Color1
                m_arrMap(iX%, iY%, iZ%).AlphaOverride = m_arrPlayer(iPlayerLoop).Alpha1
            NEXT iPlayerLoop
            
            ' ****************************************************************************************************************************************************************
            ' END PLAYER LOOP
            ' ****************************************************************************************************************************************************************
            
        _Limit 30
        _Display
        
        Loop
    END IF
    
CleanupAndExit:
    ' FINISH UP AND EXIT
    WHILE _DEVICEINPUT(1): WEND ' clear and update the keyboard buffer
    SCREEN 0
    IsometricDemo3$ = sResult
End Sub ' IsometricDemo3
 
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' BEGIN GRAPHICS FUNCTIONS
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
' =============================================================================
' LET'S GET THE COORDINATES STRAIGHT!
' Coordinates are m_arrMap(x,y,z)
'           ________________
'          /|e            /|e
'         / |            / |
'        /  |           /  |z-axis
'       /   |          /   |
'      /    /---------/----/ 
'     /    / a       /   b/  
'    /    /         /    /         
'   |--------------|    /  
'   |f  /         g|   / y-axis
'   |  /           |  /
'   | /            | /
'   |/c           d|/
'   ----------------
'      x-axis
' 
' POINT    ( X, Y, Z)
' a        ( 0, 0, 0)
' b        (32, 0, 0)
' c        ( 0,32, 0)
' d        (32,32, 0)
' e        ( 0, 0,32)
' f        ( 0,32,32)
' g        (32,32,32)
' =============================================================================
 
' /////////////////////////////////////////////////////////////////////////////
' INITIALIZE MAP TO EMPTY
 
' Requires shared global variable:
' m_arrMap(m_iMapMinX To m_iMapMaxX, m_iMapMinY To m_iMapMaxY, m_iMapMinZ To m_iMapMaxZ) As MapTileType
Sub ClearIsometricMap
    Dim RoutineName As String: RoutineName = "ClearIsometricMap"
    Dim iLoopX%
    Dim iLoopY%
    Dim iLoopZ%
    
    For iLoopZ% = m_iMapMinZ To m_iMapMaxZ
        For iLoopX% = m_iMapMinX To m_iMapMaxX
            For iLoopY% = m_iMapMinY To m_iMapMaxY
                m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Empty
                m_arrMap(iLoopX%, iLoopY%, iLoopZ%).AlphaOverride = 255
            Next iLoopY%
        Next iLoopX%
    Next iLoopZ%
End Sub ' ClearIsometricMap
 
' /////////////////////////////////////////////////////////////////////////////
' INITIALIZE RENDERING MAP TO EMPTY
 
' Requires shared global variable:
' m_arrRender(m_iMapMinX To m_iMapMaxX, m_iMapMinY To m_iMapMaxY, m_iMapMinZ To m_iMapMaxZ) As MapTileType
 
Sub ClearRenderMap
    Dim RoutineName As String: RoutineName = "ClearRenderMap"
    Dim iLoopX%
    Dim iLoopY%
    Dim iLoopZ%
    
    For iLoopZ% = m_iMapMinZ To m_iMapMaxZ
        For iLoopX% = m_iMapMinX To m_iMapMaxX
            For iLoopY% = m_iMapMinY To m_iMapMaxY
                m_arrRender(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Empty
                m_arrRender(iLoopX%, iLoopY%, iLoopZ%).AlphaOverride = 255
            Next iLoopY%
        Next iLoopX%
    Next iLoopZ%
End Sub ' ClearRenderMap
 
' /////////////////////////////////////////////////////////////////////////////
' Determine which squares are visible in isometric map
 
' Original operates directly on the main map array m_arrMap
' and not the copy (m_arrRender) used to rotate the perspective.
 
' Requires shared global variable (3D array of map):
' m_arrMap(x,y,z) = 3D array map of world
' m_arrMap(m_iMapMinX To m_iMapMaxX, m_iMapMinY To m_iMapMaxY, m_iMapMinZ To m_iMapMaxZ) As MapTileType
 
' RECEIVES:
' iX% = player's X positon
' iY% = player's Y position
' iZ% = player's Z position
 
' Direction is assumed to be c_iDir_Forward.
 
' If iX% < 0 then we just render everything with its normal alpha value.
 
Sub ComputeVisible (iX%, iY%, iZ%, iGridSize)
    Dim RoutineName As String: RoutineName = "ComputeVisible"
    Dim iLoopX%
    Dim iLoopY%
    Dim iLoopZ%
    
    Dim iPX1%
    Dim iPY1%
    Dim iPZ1%
    Dim iPlayer2Dx As Integer
    Dim iPlayer2Dy As Integer
    Dim iTile2Dx As Integer
    Dim iTile2Dy As Integer
    
    IF iX% > -1 THEN
        ' CALCULATE PLAYER'S 2-D POSITION
        iPX1% = iX% * iGridSize + cGridOffsetX
        iPY1% = iY% * iGridSize + cGridOffsetY
        iPZ1% = iZ% * iGridSize + cGridOffsetZ
        iPlayer2Dx = CX2I(iPX1%, iPY1%) + cScreenOffsetX
        iPlayer2Dy = (CY2I(iPX1%, iPY1%) + cScreenOffsetY) - iPZ1%
        'fquad TempX1, TempY1 - z, TempX2, TempY2 - z, TempX3, TempY3 - z, TempX4, TempY4 - z, _RGB32(r, g, b, alpha&)    
        
        ' LOOK AT EACH TILE
        For iLoopX% = m_iMapMinX To m_iMapMaxX
            For iLoopY% = m_iMapMinY To m_iMapMaxY
                For iLoopZ% = m_iMapMinZ To m_iMapMaxZ
                    
                    ' *****************************************************************************
                    ' IF SPACE HAS A TILE
                    ' AND ITS 2D (X,Y) IS > PLAYER'S 2D (X,Y)
                    ' THEN MAKE THE TILE TRANSPARENT
                    ' *****************************************************************************
                    ' TODO: COMPARE AGAINST ALL TYPES OF TILES NOT JUST WALL/FLOOR
                    If m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Wall OR m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Floor_Tiled Then
                        ' CALCULATE TILE'S 2-D POSITION
                        iPX1% = iLoopX% * iGridSize + cGridOffsetX
                        iPY1% = iLoopY% * iGridSize + cGridOffsetY
                        iPZ1% = iLoopZ% * iGridSize + cGridOffsetZ
                        iTile2Dx = CX2I(iPX1%, iPY1%) + cScreenOffsetX
                        iTile2Dy = (CY2I(iPX1%, iPY1%) + cScreenOffsetY) - iPZ1%
                        'fquad TempX1, TempY1 - z, TempX2, TempY2 - z, TempX3, TempY3 - z, TempX4, TempY4 - z, _RGB32(r, g, b, alpha&)    
                        
                        'If iLoopZ% >= iZ% Then
                            'If iLoopX% >= iX% Then
                                
                                ' FOR TILES FORWARD OF PLAYER
                                If iLoopY% > iY% Then
                                    
                                    ' IF PLAYER'S 2D Y POSITION IS WITHIN RANGE OF TILE'S 2D Y POSITION
                                    If ( iPlayer2Dy >= (iTile2Dy - iGridSize) ) AND ( iPlayer2Dy <= (iTile2Dy + iGridSize) ) Then
                                        
                                        ' AND IF PLAYER'S 2D X POSITION IS WITHIN RANGE OF TILE'S 2D X POSITION
                                        If ( iPlayer2Dx >= (iTile2Dx - iGridSize) ) AND ( iPlayer2Dx <= (iTile2Dx + iGridSize) ) Then
                                            ' RENDER THE TILE TRANSPARENT SO WE CAN SEE THE PLAYER
                                            ' TODO: CHANGE AlphaOverride TO BE RELATIVE TO ORIGINAL Alpha VALUE
                                            m_arrMap(iLoopX%, iLoopY%, iLoopZ%).AlphaOverride = 86
                                        Else
                                            ' LEAVE THE TILE OPAQUE
                                            ' TODO: CHANGE 255 TO ORIGINAL Alpha VALUE
                                            m_arrMap(iLoopX%, iLoopY%, iLoopZ%).AlphaOverride = 255
                                        End If
                                    Else
                                        ' LEAVE THE TILE OPAQUE
                                        ' TODO: CHANGE 255 TO ORIGINAL Alpha VALUE
                                        m_arrMap(iLoopX%, iLoopY%, iLoopZ%).AlphaOverride = 255
                                    End If
                                Else
                                    ' LEAVE THE TILE OPAQUE
                                    ' TODO: CHANGE 255 TO ORIGINAL Alpha VALUE
                                    m_arrMap(iLoopX%, iLoopY%, iLoopZ%).AlphaOverride = 255
                                End If
                            'End If
                        'End If
                    Else
                        ' LEAVE THE TILE OPAQUE
                        ' TODO: CHANGE 255 TO ORIGINAL Alpha VALUE
                        m_arrMap(iLoopX%, iLoopY%, iLoopZ%).AlphaOverride = 255
                    End If
                Next iLoopZ%
            Next iLoopY%
        Next iLoopX%
    ELSE
        ' JUST MAKE ALL TILES VISIBLE
        For iLoopX% = m_iMapMinX To m_iMapMaxX
            For iLoopY% = m_iMapMinY To m_iMapMaxY
                For iLoopZ% = m_iMapMinZ To m_iMapMaxZ
                    ' LEAVE THE TILE OPAQUE
                    m_arrMap(iLoopX%, iLoopY%, iLoopZ%).AlphaOverride = 255
                    
                    'TODO: CHANGE 255 TO ORIGINAL Alpha VALUE
                    'TODO: SUPPORT CUSTOM ALPHA FOR COLORS (EVENTUALLY 3-COLOR TILES .Alpha1, .Alpha2, .Alpha3)
                    'm_arrMap(iLoopX%, iLoopY%, iLoopZ%).AlphaOverride = m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Alpha1
                    
                Next iLoopZ%
            Next iLoopY%
        Next iLoopX%
    END IF
End Sub ' ComputeVisible
 
' /////////////////////////////////////////////////////////////////////////////
' Determine which squares are visible in isometric map
 
' Same as ComputeVisible except uses the rotated copy 
' (m_arrRender instead of m_arrMap)
 
' Requires shared global variable (3D array of map):
' m_arrRender(x,y,z) = rotated copy of 3D array map of world
' m_arrRender(m_iMapMinX To m_iMapMaxX, m_iMapMinY To m_iMapMaxY, m_iMapMinZ To m_iMapMaxZ) As MapTileType
 
' RECEIVES:
' iX% = player's X positon
' iY% = player's Y position
' iZ% = player's Z position
 
' If iX% < 0 then we just render everything with its normal alpha value.
 
' TODO: FIX FOR c_iDir_Down and c_iDir_Up DIRECTIONS
'       "FOR TILES FORWARD OF PLAYER" SECTION BELOW
'       NEEDS TO LOOK AT Z AXIS INSTEAD OF Y ?
 
Sub ComputeRenderVisible (iX%, iY%, iZ%, iGridSize)
    Dim RoutineName As String: RoutineName = "ComputeRenderVisible"
    Dim iLoopX%
    Dim iLoopY%
    Dim iLoopZ%
    
    Dim iPX1%
    Dim iPY1%
    Dim iPZ1%
    Dim iPlayer2Dx As Integer
    Dim iPlayer2Dy As Integer
    Dim iTile2Dx As Integer
    Dim iTile2Dy As Integer
    
    IF iX% > -1 THEN
        ' CALCULATE PLAYER'S 2-D POSITION
        iPX1% = iX% * iGridSize + cGridOffsetX
        iPY1% = iY% * iGridSize + cGridOffsetY
        iPZ1% = iZ% * iGridSize + cGridOffsetZ
        iPlayer2Dx = CX2I(iPX1%, iPY1%) + cScreenOffsetX
        iPlayer2Dy = (CY2I(iPX1%, iPY1%) + cScreenOffsetY) - iPZ1%
        'fquad TempX1, TempY1 - z, TempX2, TempY2 - z, TempX3, TempY3 - z, TempX4, TempY4 - z, _RGB32(r, g, b, alpha&)    
        
        ' LOOK AT EACH TILE
        For iLoopX% = m_iMapMinX To m_iMapMaxX
            For iLoopY% = m_iMapMinY To m_iMapMaxY
                For iLoopZ% = m_iMapMinZ To m_iMapMaxZ
                    
                    ' *****************************************************************************
                    ' IF SPACE HAS A TILE
                    ' AND ITS 2D (X,Y) IS > PLAYER'S 2D (X,Y)
                    ' THEN MAKE THE TILE TRANSPARENT
                    ' *****************************************************************************
                    ' TODO: COMPARE AGAINST ALL TYPES OF TILES NOT JUST WALL/FLOOR
                    If m_arrRender(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Wall OR m_arrRender(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Floor_Tiled Then
                        ' CALCULATE TILE'S 2-D POSITION
                        iPX1% = iLoopX% * iGridSize + cGridOffsetX
                        iPY1% = iLoopY% * iGridSize + cGridOffsetY
                        iPZ1% = iLoopZ% * iGridSize + cGridOffsetZ
                        iTile2Dx = CX2I(iPX1%, iPY1%) + cScreenOffsetX
                        iTile2Dy = (CY2I(iPX1%, iPY1%) + cScreenOffsetY) - iPZ1%
                        'fquad TempX1, TempY1 - z, TempX2, TempY2 - z, TempX3, TempY3 - z, TempX4, TempY4 - z, _RGB32(r, g, b, alpha&)    
                        
                        'If iLoopZ% >= iZ% Then
                            'If iLoopX% >= iX% Then
                                
                                ' FOR TILES FORWARD OF PLAYER
                                If iLoopY% > iY% Then
                                    
                                    ' IF PLAYER'S 2D Y POSITION IS WITHIN RANGE OF TILE'S 2D Y POSITION
                                    If ( iPlayer2Dy >= (iTile2Dy - iGridSize) ) AND ( iPlayer2Dy <= (iTile2Dy + iGridSize) ) Then
                                        
                                        ' AND IF PLAYER'S 2D X POSITION IS WITHIN RANGE OF TILE'S 2D X POSITION
                                        If ( iPlayer2Dx >= (iTile2Dx - iGridSize) ) AND ( iPlayer2Dx <= (iTile2Dx + iGridSize) ) Then
                                            ' RENDER THE TILE TRANSPARENT SO WE CAN SEE THE PLAYER
                                            'TODO: CHANGE AlphaOverride TO BE RELATIVE TO ORIGINAL Alpha VALUE?
                                            m_arrRender(iLoopX%, iLoopY%, iLoopZ%).AlphaOverride = 86
                                        Else
                                            ' LEAVE THE TILE OPAQUE
                                            m_arrRender(iLoopX%, iLoopY%, iLoopZ%).AlphaOverride = 255
                                            
                                            'TODO: CHANGE 255 TO ORIGINAL Alpha VALUE
                                            'TODO: SUPPORT CUSTOM ALPHA FOR COLORS (EVENTUALLY 3-COLOR TILES .Alpha1, .Alpha2, .Alpha3)
                                            'm_arrRender(iLoopX%, iLoopY%, iLoopZ%).AlphaOverride = m_arrRender(iLoopX%, iLoopY%, iLoopZ%).Alpha1
                                        End If
                                    Else
                                        ' LEAVE THE TILE OPAQUE
                                        m_arrRender(iLoopX%, iLoopY%, iLoopZ%).AlphaOverride = 255
                                        
                                        'TODO: CHANGE 255 TO ORIGINAL Alpha VALUE
                                        'TODO: SUPPORT CUSTOM ALPHA FOR COLORS (EVENTUALLY 3-COLOR TILES .Alpha1, .Alpha2, .Alpha3)
                                        'm_arrRender(iLoopX%, iLoopY%, iLoopZ%).AlphaOverride = m_arrRender(iLoopX%, iLoopY%, iLoopZ%).Alpha1
                                    End If
                                Else
                                    ' LEAVE THE TILE OPAQUE
                                    m_arrRender(iLoopX%, iLoopY%, iLoopZ%).AlphaOverride = 255
                                    
                                    'TODO: CHANGE 255 TO ORIGINAL Alpha VALUE
                                    'TODO: SUPPORT CUSTOM ALPHA FOR COLORS (EVENTUALLY 3-COLOR TILES .Alpha1, .Alpha2, .Alpha3)
                                    'm_arrRender(iLoopX%, iLoopY%, iLoopZ%).AlphaOverride = m_arrRender(iLoopX%, iLoopY%, iLoopZ%).Alpha1
                                End If
                            'End If
                        'End If
                    Else
                        m_arrRender(iLoopX%, iLoopY%, iLoopZ%).AlphaOverride = 255
                        
                        'TODO: SUPPORT CUSTOM ALPHA FOR COLORS (EVENTUALLY 3-COLOR TILES .Alpha1, .Alpha2, .Alpha3)
                        'm_arrRender(iLoopX%, iLoopY%, iLoopZ%).AlphaOverride = m_arrRender(iLoopX%, iLoopY%, iLoopZ%).Alpha1
                    End If
                Next iLoopZ%
            Next iLoopY%
        Next iLoopX%
    ELSE
        ' JUST MAKE ALL TILES VISIBLE
        For iLoopX% = m_iMapMinX To m_iMapMaxX
            For iLoopY% = m_iMapMinY To m_iMapMaxY
                For iLoopZ% = m_iMapMinZ To m_iMapMaxZ
                    m_arrRender(iLoopX%, iLoopY%, iLoopZ%).AlphaOverride = 255
                    
                    'TODO: CHANGE 255 TO ORIGINAL Alpha VALUE
                    'TODO: SUPPORT CUSTOM ALPHA FOR COLORS (EVENTUALLY 3-COLOR TILES .Alpha1, .Alpha2, .Alpha3)
                    'm_arrRender(iLoopX%, iLoopY%, iLoopZ%).AlphaOverride = m_arrRender(iLoopX%, iLoopY%, iLoopZ%).Alpha1
                Next iLoopZ%
            Next iLoopY%
        Next iLoopX%
    END IF
End Sub ' ComputeRenderVisible
 
' /////////////////////////////////////////////////////////////////////////////
' Draw the map in 3D Isometic Perspective
' from the forward (default) perspective.
 
' Requires shared global variable
' m_arrMap(x,y,z) = 3D array map of world
' m_arrMap(m_iMapMinX To m_iMapMaxX, m_iMapMinY To m_iMapMaxY, m_iMapMinZ To m_iMapMaxZ) As MapTileType
 
' TODO: ADD OFFSET PARAMETERS FOR WHERE TO DRAW ON SCREEN (FOR SPLIT SCREEN)
' params instead of constants:
' Const cScreenOffsetX = 500 ' 450
' Const cScreenOffsetY = 300 ' 50
' Const cScreenOffsetZ = 0
 
' what about?
' Const cGridOffsetX = 50
' Const cGridOffsetY = 50
' Const cGridOffsetZ = 0
 
Sub DrawIsometricScreen(iScreenOffsetX, iScreenOffsetY, iGridSize)
    Dim RoutineName As String: RoutineName = "DrawIsometricScreen"
    Dim bTile As Integer
    Dim iLoopX%
    Dim iLoopY%
    Dim iLoopZ%
    Dim iColor As _Unsigned Long
    Dim iPosX1%
    Dim iPosX2%
    Dim iPosY1%
    Dim iPosY2%
    Dim iPosZ1%
    Dim alpha&
    
    alpha& = 255
    bTile = FALSE
    For iLoopZ% = m_iMapMinZ To m_iMapMaxZ
        For iLoopX% = m_iMapMinX To m_iMapMaxX
            For iLoopY% = m_iMapMinY To m_iMapMaxY
                
                ' CALCULATE POSITION
                iPosZ1% = iLoopZ% * iGridSize + cGridOffsetZ
                iPosX1% = iLoopX% * iGridSize + cGridOffsetX
                iPosY1% = iLoopY% * iGridSize + cGridOffsetY
                iPosX2% = iPosX1% + iGridSize
                iPosY2% = iPosY1% + iGridSize
                
                ' DETERMINE COLOR
                If m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Floor_Tiled Then
                    If bTile = TRUE Then
                        iColor = m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Color1
                        bTile = FALSE
                    Else
                        iColor = m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Color2
                        bTile = TRUE
                    End If
                ElseIf m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Wall Then
                    iColor = m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Color1
                    alpha& = m_arrMap(iLoopX%, iLoopY%, iLoopZ%).AlphaOverride
                    
                ElseIf m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Player1 Then
                    iColor = m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Color1
                    alpha& = 255
                    
                ElseIf m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Player2 Then
                    iColor = m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Color1
                    alpha& = 255
                    
                ElseIf m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Player3 Then
                    iColor = m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Color1
                    alpha& = 255
                    
                ElseIf m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Player4 Then
                    iColor = m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Color1
                    alpha& = 255
                    
                ElseIf m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Water Then
                    'TODO: transparent for water
                    iColor = cEmpty&
                    alpha& = 64
                    
                ElseIf m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Window Then
                    'TODO: transparent for windows
                    iColor = cEmpty&
                    alpha& = 64
                    
                Else
                    iColor = cEmpty&
                End If
                
                ' PLOT NEXT TILE
                If iColor <> cEmpty& Then
                    'IsoLine3D(x,      y,       x2,      y2,      z,       iHeight,     xoffset,        yoffset,        iColor As _Unsigned Long, alpha&)
                    'IsoLine3D iPosX1%, iPosY1%, iPosX2%, iPosY2%, iPosZ1%, m_iGridSize, cScreenOffsetX, cScreenOffsetY, iColor, alpha&
                    IsoLine3D iPosX1%, iPosY1%, iPosX2%, iPosY2%, iPosZ1%, iGridSize, iScreenOffsetX, iScreenOffsetY, iColor, alpha&
                End If
                
            Next iLoopY%
        Next iLoopX%
    Next iLoopZ%
End Sub ' DrawIsometricScreen
 
' /////////////////////////////////////////////////////////////////////////////
' Draw the map in 3D Isometic Perspective
' from the forward (default) perspective.
 
' Same as DrawIsometricScreen except uses the rotated copy 
' (m_arrRender instead of m_arrMap)
 
' Requires shared global variable
' m_arrRender(x,y,z) = 3D array map of world
' m_arrRender(m_iMapMinX To m_iMapMaxX, m_iMapMinY To m_iMapMaxY, m_iMapMinZ To m_iMapMaxZ) As MapTileType
 
Sub DrawRenderScreen(iScreenOffsetX, iScreenOffsetY, iGridSize)
    Dim RoutineName As String: RoutineName = "DrawRenderScreen"
    Dim bTile As Integer
    Dim iLoopX%
    Dim iLoopY%
    Dim iLoopZ%
    Dim iColor As _Unsigned Long
    Dim iPosX1%
    Dim iPosX2%
    Dim iPosY1%
    Dim iPosY2%
    Dim iPosZ1%
    Dim alpha&
    
    alpha& = 255
    bTile = FALSE
    For iLoopZ% = m_iMapMinZ To m_iMapMaxZ
        For iLoopX% = m_iMapMinX To m_iMapMaxX
            For iLoopY% = m_iMapMinY To m_iMapMaxY
                
                ' CALCULATE POSITION
                iPosZ1% = iLoopZ% * iGridSize + cGridOffsetZ
                iPosX1% = iLoopX% * iGridSize + cGridOffsetX
                iPosY1% = iLoopY% * iGridSize + cGridOffsetY
                iPosX2% = iPosX1% + iGridSize
                iPosY2% = iPosY1% + iGridSize
                
                ' DETERMINE COLOR
                If m_arrRender(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Floor_Tiled Then
                    If bTile = TRUE Then
                        iColor = m_arrRender(iLoopX%, iLoopY%, iLoopZ%).Color1
                        bTile = FALSE
                    Else
                        iColor = m_arrRender(iLoopX%, iLoopY%, iLoopZ%).Color2
                        bTile = TRUE
                    End If
                ElseIf m_arrRender(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Wall Then
                    iColor = m_arrRender(iLoopX%, iLoopY%, iLoopZ%).Color1
                    alpha& = m_arrRender(iLoopX%, iLoopY%, iLoopZ%).AlphaOverride
                    
                ElseIf m_arrRender(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Player1 Then
                    iColor = m_arrRender(iLoopX%, iLoopY%, iLoopZ%).Color1
                    alpha& = 255
                    
                ElseIf m_arrRender(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Player2 Then
                    iColor = m_arrRender(iLoopX%, iLoopY%, iLoopZ%).Color1
                    alpha& = 255
                    
                ElseIf m_arrRender(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Player3 Then
                    iColor = m_arrRender(iLoopX%, iLoopY%, iLoopZ%).Color1
                    alpha& = 255
                    
                ElseIf m_arrRender(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Player4 Then
                    iColor = m_arrRender(iLoopX%, iLoopY%, iLoopZ%).Color1
                    alpha& = 255
                    
                ElseIf m_arrRender(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Water Then
                    'TODO: transparent for water
                    iColor = cEmpty&
                    alpha& = 64
                    
                ElseIf m_arrRender(iLoopX%, iLoopY%, iLoopZ%).Typ = c_iMapType_Window Then
                    'TODO: transparent for windows
                    iColor = cEmpty&
                    alpha& = 64
                    
                Else
                    iColor = cEmpty&
                End If
                
                ' PLOT NEXT TILE
                If iColor <> cEmpty& Then
                    'IsoLine3D(x,      y,       x2,      y2,      z,       iHeight,     xoffset,        yoffset,        iColor As _Unsigned Long, alpha&)
                    'IsoLine3D iPosX1%, iPosY1%, iPosX2%, iPosY2%, iPosZ1%, m_iGridSize, cScreenOffsetX, cScreenOffsetY, iColor, alpha&
                    IsoLine3D iPosX1%, iPosY1%, iPosX2%, iPosY2%, iPosZ1%, iGridSize, iScreenOffsetX, iScreenOffsetY, iColor, alpha&
                End If
                
            Next iLoopY%
        Next iLoopX%
    Next iLoopZ%
End Sub ' DrawRenderScreen
 
' /////////////////////////////////////////////////////////////////////////////
' Draw the map in 3D Isometic Perspective
' from a different direction.
 
' This is the lazy man's version which simply copies the tiles to 
' a temporary array, rotated to the specified direction/orientation.
' A more efficient + faster method would operate directly on the 
' main array, but I am too bogged down to figure that out right now!
 
' RECEIVES:
' iDirection% = point of view to render from
'     i.e. the direction we are looking at the scene FROM
'     iDirection% can be one of the following:
'     c_iDir_Down
'     c_iDir_Up
'     c_iDir_Left
'     c_iDir_Right
'     c_iDir_Back
'     c_iDir_Forward = default
'     
'     If iDirection% = c_iDir_Forward, just call DrawIsometricScreen instead (faster).
' 
' iScreenOffsetX, iScreenOffsetY = where on display to draw
'
' iX%, iY%, iZ% = player's position, used for ComputeRenderVisible
'     to compute which tiles to hide / make transparent
'     (tiles that might be hiding the player)
'     If these are <0, then ComputeRenderVisible uses original alpha values.
 
' TODO: ADD OFFSET PARAMETERS FOR WHERE TO DRAW ON SCREEN (FOR SPLIT SCREEN)
' params instead of constants:
' Const cScreenOffsetX = 500 ' 450
' Const cScreenOffsetY = 300 ' 50
' Const cScreenOffsetZ = 0
 
' what about?
' Const cGridOffsetX = 50
' Const cGridOffsetY = 50
' Const cGridOffsetZ = 0
 
Sub DrawScreen(iDirection%, iScreenOffsetX, iScreenOffsetY, iGridSize, iX%, iY%, iZ%)
    Dim RoutineName As String: RoutineName = "DrawScreen"
    Dim bTile As Integer
    Dim iLoopX%
    Dim iLoopY%
    Dim iLoopZ%
    Dim iColor As _Unsigned Long
    Dim iPosX1%
    Dim iPosX2%
    Dim iPosY1%
    Dim iPosY2%
    Dim iPosZ1%
    Dim alpha&
    
    IF iDirection% = c_iDir_Forward THEN
        ' NO NEED TO ROTATE, JUST USE THE ORIGINAL ROUTINE
        ComputeVisible iX%, iY%, iZ%, iGridSize
        DrawIsometricScreen iScreenOffsetX, iScreenOffsetY, iGridSize
    ELSE
        ' USE A TEMPORARY ARRAY TO STORE ROTATED SCENE THEN DRAW IT
        ClearRenderMap
        SELECT CASE iDirection%
            CASE c_iDir_Down:
                ' SCENE IS FLIPPED UP (TOP FACE NOW FACING AWAY FROM US)
                For iLoopZ% = m_iMapMinZ To m_iMapMaxZ
                    For iLoopX% = m_iMapMinX To m_iMapMaxX
                        For iLoopY% = m_iMapMinY To m_iMapMaxY
                            m_arrRender(iLoopX%,m_iMapMaxZ-iLoopZ%,iLoopY%) = m_arrMap(iLoopX%, iLoopY%, iLoopZ%)
                        Next iLoopY%
                    Next iLoopX%
                Next iLoopZ%
                ComputeRenderVisible iX%, m_iMapMaxZ-iZ%, iY%, iGridSize
            CASE c_iDir_Up:
                ' SCENE IS FLIPPED DOWN (TOP FACE NOW FACING TOWARD US)
                For iLoopZ% = m_iMapMinZ To m_iMapMaxZ
                    For iLoopX% = m_iMapMinX To m_iMapMaxX
                        For iLoopY% = m_iMapMinY To m_iMapMaxY
                            m_arrRender(iLoopX%,iLoopZ%,m_iMapMaxY-iLoopY%) = m_arrMap(iLoopX%, iLoopY%, iLoopZ%)
                        Next iLoopY%
                    Next iLoopX%
                Next iLoopZ%
                ComputeRenderVisible iX%, iZ%, m_iMapMaxY-iY%, iGridSize
            CASE c_iDir_Left:
                ' SCENE IS ROTATED COUNTER CLOCKWISE FROM TOP (LEFT FACE NOW FACING TOWARD US)
                For iLoopZ% = m_iMapMinZ To m_iMapMaxZ
                    For iLoopX% = m_iMapMinX To m_iMapMaxX
                        For iLoopY% = m_iMapMinY To m_iMapMaxY
                            m_arrRender(iLoopY%,m_iMapMaxX-iLoopX%,iLoopZ%) = m_arrMap(iLoopX%, iLoopY%, iLoopZ%)
                        Next iLoopY%
                    Next iLoopX%
                Next iLoopZ%
                ComputeRenderVisible iY%, m_iMapMaxX-iX%, iZ%, iGridSize
            CASE c_iDir_Right:
                ' SCENE IS ROTATED CLOCKWISE FROM TOP (RIGHT FACE NOW FACING TOWARD US)
                For iLoopZ% = m_iMapMinZ To m_iMapMaxZ
                    For iLoopX% = m_iMapMinX To m_iMapMaxX
                        For iLoopY% = m_iMapMinY To m_iMapMaxY
                            m_arrRender(m_iMapMaxY-iLoopY%,iLoopX%,iLoopZ%) = m_arrMap(iLoopX%, iLoopY%, iLoopZ%)
                        Next iLoopY%
                    Next iLoopX%
                Next iLoopZ%
                ComputeRenderVisible m_iMapMaxY-iY%, iX%, iZ%, iGridSize
            CASE c_iDir_Back:
                ' SCENE IS TURNED AROUND (FRONT FACE NOW FACING AWAY FROM US)
                For iLoopZ% = m_iMapMinZ To m_iMapMaxZ
                    For iLoopX% = m_iMapMinX To m_iMapMaxX
                        For iLoopY% = m_iMapMinY To m_iMapMaxY
                            m_arrRender(m_iMapMaxX-iLoopX%,m_iMapMaxY-iLoopY%,iLoopZ%) = m_arrMap(iLoopX%, iLoopY%, iLoopZ%)
                        Next iLoopY%
                    Next iLoopX%
                Next iLoopZ%
                ComputeRenderVisible m_iMapMaxX-iX%, m_iMapMaxY-iY%, iZ%, iGridSize
            CASE ELSE:
                ' DIRECTION UNKNOWN: for now just draw default (forward)
                For iLoopZ% = m_iMapMinZ To m_iMapMaxZ
                    For iLoopX% = m_iMapMinX To m_iMapMaxX
                        For iLoopY% = m_iMapMinY To m_iMapMaxY
                            m_arrRender(iLoopX%,iLoopY%,iLoopZ%) = m_arrMap(iLoopX%, iLoopY%, iLoopZ%)
                        Next iLoopY%
                    Next iLoopX%
                Next iLoopZ%
                ComputeRenderVisible iX%, iY%, iZ%, iGridSize
        END SELECT
        DrawRenderScreen iScreenOffsetX, iScreenOffsetY, iGridSize
    END IF
End Sub ' DrawScreen
 
' /////////////////////////////////////////////////////////////////////////////
' RETURNS MAP AS TEXT
 
' Requires shared global variable
' m_arrMap(x,y,z) = 3D array map of world
' m_arrMap(m_iMapMinX To m_iMapMaxX, m_iMapMinY To m_iMapMaxY, m_iMapMinZ To m_iMapMaxZ) As MapTileType
 
' USAGE:
'Input "See a text dump (y/n)? ", in$
'If LCase$(in$) = LCase$("y") Then
'    Print MapToText$
'End If
 
Function MapToText$
    Dim RoutineName As String: RoutineName = "MapToText$"
    Dim sResult As String
    Dim iLoopX%
    Dim iLoopY%
    Dim iLoopZ%
    Dim iMinX%
    Dim iMaxX%
    Dim iMinY%
    Dim iMaxY%
    Dim iMinZ%
    Dim iMaxZ%
    Dim sLine As String
    Dim iType%
    Dim iColor1&
    Dim iColor2&
    Dim iColor3&
    Dim in$
 
    sResult = ""
 
    ' FIND USED BOUNDARIES OF MAP
    iMinX% = -1
    iMaxX% = -1
    iMinY% = -1
    iMaxY% = -1
    iMinZ% = -1
    iMaxZ% = -1
    For iLoopZ% = 0 To 32
        For iLoopX% = 0 To 32
            For iLoopY% = 0 To 32
                iType% = m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Typ
                If iType% <> c_iMapType_Empty And iType% <> c_iMapType_Floor_Tiled Then
                    If iMinX% = -1 Then
                        iMinX% = iLoopX%
                    End If
                    If iMinY% = -1 Then
                        iMinY% = iLoopY%
                    End If
                    If iMinZ% = -1 Then
                        iMinZ% = iLoopZ%
                    End If
                    If iLoopX% > iMaxX% Then
                        iMaxX% = iLoopX%
                    End If
                    If iLoopY% > iMaxY% Then
                        iMaxY% = iLoopY%
                    End If
                    If iLoopZ% > iMaxZ% Then
                        iMaxZ% = iLoopZ%
                    End If
                End If
            Next iLoopY%
        Next iLoopX%
    Next iLoopZ%
 
    ' GENERATE OUTPUT
    For iLoopZ% = iMinZ% To iMaxZ%
        sResult = sResult + "-------------------------------------------------------------------------------" + Chr$(13)
        sResult = sResult + "Map Z=" + cstr$(iLoopZ%) + ":" + Chr$(13)
        sResult = sResult + "-------------------------------------------------------------------------------" + Chr$(13)
        For iLoopY% = iMinY% To iMaxY%
            sLine = ""
            For iLoopX% = iMinX% To iMaxX%
                iType% = m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Typ
                iColor1& = m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Color1
                iColor2& = m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Color2
                iColor3& = m_arrMap(iLoopX%, iLoopY%, iLoopZ%).Color3
                
                If iType% = c_iMapType_Empty Then
                    sLine = sLine + " "
                Else
                    If iColor1& = cEmpty& Then
                        sLine = sLine + " "
                    Else
                        sLine = sLine + "#"
                    End If
                End If
            Next iLoopX%
            sResult = sResult + sLine + Chr$(13)
        Next iLoopY%
 
        sResult = sResult + Chr$(13)
    Next iLoopZ%
 
    MapToText$ = sResult
End Function ' MapToText$
 
' /////////////////////////////////////////////////////////////////////////////
' Return string description for 2.5D movement constants
 
FUNCTION GetDirection$(iDir AS INTEGER)
    DIM sDir AS STRING
    SELECT CASE iDir
        CASE c_iDir_Down:
            sDir = "Down"
        CASE c_iDir_Up:
            sDir = "Up"
        CASE c_iDir_Left:
            sDir = "Left"
        CASE c_iDir_Right:
            sDir = "Right"
        CASE c_iDir_Back:
            sDir = "Back"
        CASE c_iDir_Forward:
            sDir = "Forward"
        CASE ELSE:
            sDir = "Unknown"
    END SELECT
    GetDirection$ = sDir
END FUNCTION ' GetDirection$
 
' /////////////////////////////////////////////////////////////////////////////
 
Function CX2I (x As Long, y As Long) 'Convert Cartesian X To Isometic coordinates
    CX2I = x - y
End Function ' CX2I
 
' /////////////////////////////////////////////////////////////////////////////
 
Function CY2I (x As Long, y As Long) 'Convert Cartesian Y To Isometic coordinates
    CY2I = (x + y) / 2
End Function ' CY2I
 
' /////////////////////////////////////////////////////////////////////////////
' since we're drawing a diamond and not a square box, we can't use Line BF.
' We have to manually down the 4 points of the line.
 
Sub IsoLine (x, y, x2, y2, xoffset, yoffset, iColor As _Unsigned Long)
    Line (CX2I(x, y) + xoffset, CY2I(x, y) + yoffset)-(CX2I(x2, y) + xoffset, CY2I(x2, y) + yoffset), iColor
    Line -(CX2I(x2, y2) + xoffset, CY2I(x2, y2) + yoffset), iColor
    Line -(CX2I(x, y2) + xoffset, CY2I(x, y2) + yoffset), iColor
    Line -(CX2I(x, y) + xoffset, CY2I(x, y) + yoffset), iColor
    Paint (CX2I(x, y) + xoffset, CY2I(x, y) + 4), iColor 'and fill the diamond solid
    Line (CX2I(x, y) + xoffset, CY2I(x, y) + yoffset)-(CX2I(x2, y) + xoffset, CY2I(x2, y) + yoffset), &HFFFFFFFF
    Line -(CX2I(x2, y2) + xoffset, CY2I(x2, y2) + yoffset), &HFFFFFFFF
    Line -(CX2I(x, y2) + xoffset, CY2I(x, y2) + yoffset), &HFFFFFFFF
    Line -(CX2I(x, y) + xoffset, CY2I(x, y) + yoffset), &HFFFFFFFF
End Sub ' IsoLine
 
' /////////////////////////////////////////////////////////////////////////////
' Like IsoLine, we're going to have to draw our lines manually.
' only in this case, we also need a Z coordinate to tell us how
' THICK/TALL/HIGH to make our tile
 
' MODIFIED by madscijr to draw a single tile of height iHeight at Z axis
' MODIFIED by madscijr to accept an alpha& value to control transparency (where 0=fully transparent, 255=opaque)
 
''Sub IsoLine3D (x, y, x2, y2, z, xoffset, yoffset, iColor As _Unsigned Long)
'Sub IsoLine3D (x, y, x2, y2, z, iHeight, xoffset, yoffset, iColor As _Unsigned Long)
Sub IsoLine3D (x, y, x2, y2, z, iHeight, xoffset, yoffset, iColor As _Unsigned Long, alpha&)
    dim r as integer
    dim g as integer
    dim b as integer
    'dim iNewColor As _Unsigned Long
    
    r = _Red32(iColor)
    g = _Green32(iColor)
    b = _Blue32(iColor)
    
    ' Let's just do all the math first this time.
    ' We need to turn those 4 normal points into 4 isometric points (x, y, x1, y1)
    TempX1 = CX2I(x, y) + xoffset
    TempY1 = CY2I(x, y) + yoffset
    TempX2 = CX2I(x2, y) + xoffset
    TempY2 = CY2I(x2, y) + yoffset
    TempX3 = CX2I(x2, y2) + xoffset
    TempY3 = CY2I(x2, y2) + yoffset
    TempX4 = CX2I(x, y2) + xoffset
    TempY4 = CY2I(x, y2) + yoffset
    
    ' The top
    'fquad TempX1, TempY1 - z, TempX2, TempY2 - z, TempX3, TempY3 - z, TempX4, TempY4 - z, iColor
    fquad TempX1, TempY1 - z, TempX2, TempY2 - z, TempX3, TempY3 - z, TempX4, TempY4 - z, _RGB32(r, g, b, alpha&)
    
    If z <> 0 Then
        ' TODO: maybe change which sides gets shaded depending on the direction of the light source?
        
        ' draw the left side, shaded 75%
        'fquad TempX4, TempY4 - z, TempX4, TempY4 - z + iHeight, TempX3, TempY3 - z + iHeight, TempX3, TempY3 - z, _RGB32(.75 * r, .75 * g, .75 * b)
        fquad TempX4, TempY4 - z, TempX4, TempY4 - z + iHeight, TempX3, TempY3 - z + iHeight, TempX3, TempY3 - z, _RGB32(.75 * r, .75 * g, .75 * b, alpha&)
        
        ' draw the right side,s haded 50%
        'fquad TempX3, TempY3 - z, TempX3, TempY3 - z + iHeight, TempX2, TempY2 - z + iHeight, TempX2, TempY2 - z, _RGB32(.5 * r, .5 * g, .5 * b)
        fquad TempX3, TempY3 - z, TempX3, TempY3 - z + iHeight, TempX2, TempY2 - z + iHeight, TempX2, TempY2 - z, _RGB32(.5 * r, .5 * g, .5 * b, alpha&)
    Else
        ' no need to draw any height, if there isn't any.
    End If
End Sub ' IsoLine3D
 
' /////////////////////////////////////////////////////////////////////////////
' found at abandoned, outdated and now likely malicious qb64 dot net website
' don’t go there: http://www.[abandoned, outdated and now likely malicious qb64 dot net website - don’t go there]/forum/index.php?topic=14425.0
 
Sub ftri (x1, y1, x2, y2, x3, y3, K As _Unsigned Long)
    Dim D As Long
    Dim a&
 
    D = _Dest
    a& = _NewImage(1, 1, 32)
    _Dest a&
    PSet (0, 0), K
    _Dest D
    _MapTriangle _Seamless(0, 0)-(0, 0)-(0, 0), a& To(x1, y1)-(x2, y2)-(x3, y3)
    _FreeImage a& ' <<< this is important!
End Sub ' ftri
 
' /////////////////////////////////////////////////////////////////////////////
' 2019-11-20 Steve saves some time with STATIC
' and saves and restores last dest
 
Sub ftri1 (x1, y1, x2, y2, x3, y3, K As _Unsigned Long)
    Dim D As Long
    Static a&
 
    D = _Dest
    If a& = 0 Then
        a& = _NewImage(1, 1, 32)
    End If
    _Dest a&
    _DontBlend a&
    PSet (0, 0), K
    _Blend a&
    _Dest D
    _MapTriangle _Seamless(0, 0)-(0, 0)-(0, 0), a& To(x1, y1)-(x2, y2)-(x3, y3)
End Sub ' ftri1
 
' /////////////////////////////////////////////////////////////////////////////
' original fill quad that may be at fault using Steve's fTri version
' need 4 non linear points (not all on 1 line) list them clockwise
' so x2, y2 is opposite of x4, y4
 
Sub fquad1 (x1, y1, x2, y2, x3, y3, x4, y4, K As _Unsigned Long)
    ftri1 x1, y1, x2, y2, x4, y4, K
    ftri1 x3, y3, x2, y2, x4, y4, K
End Sub ' fquad1
 
' /////////////////////////////////////////////////////////////////////////////
' update 2019-12-16 needs orig fTri
' need 4 non linear points (not all on 1 line)
' list them clockwise so x2, y2 is opposite of x4, y4
 
Sub fquad (x1, y1, x2, y2, x3, y3, x4, y4, K As _Unsigned Long)
    ftri x1, y1, x2, y2, x3, y3, K
    ftri x3, y3, x4, y4, x1, y1, K
End Sub ' fquad
 
' /////////////////////////////////////////////////////////////////////////////
' DRAW A 2-D BOX
 
'SUB DrawBox (iX%, iY%, iSize%, iColor%)
SUB DrawBox (iX%, iY%, iSize%, iColor&)
    LINE (iX%, iY%)-(iX% + iSize%, iY% + iSize%), iColor&, BF ' Draw a solid box
    'LINE (iX%, iY%)-(iX% + iSize%, iY% + iSize%), iColor%, BF ' Draw a solid box
    'LINE (60, 60)-(130, 100), iColor%, B ' Draw a box outline
END SUB ' DrawBox
 
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' END GRAPHICS FUNCTIONS
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' BEGIN GENERAL PURPOSE FUNCTIONS
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
' /////////////////////////////////////////////////////////////////////////////
 
Function cstr$ (myValue)
    'cstr$ = LTRIM$(RTRIM$(STR$(myValue)))
    cstr$ = _Trim$(Str$(myValue))
End Function ' cstr$
 
' /////////////////////////////////////////////////////////////////////////////
 
Function cstrl$ (myValue As Long)
    cstrl$ = _Trim$(Str$(myValue))
End Function ' cstrl$
 
' /////////////////////////////////////////////////////////////////////////////
 
Function cstrs$ (myValue As Single)
    ''cstr$ = LTRIM$(RTRIM$(STR$(myValue)))
    cstrs$ = _Trim$(Str$(myValue))
End Function ' cstrs$
 
' /////////////////////////////////////////////////////////////////////////////
 
Function IIF (Condition, IfTrue, IfFalse)
    If Condition Then IIF = IfTrue Else IIF = IfFalse
End Function
 
' /////////////////////////////////////////////////////////////////////////////
 
Function IIFSTR$ (Condition, IfTrue$, IfFalse$)
    If Condition Then IIFSTR$ = IfTrue$ Else IIFSTR$ = IfFalse$
End Function
 
' /////////////////////////////////////////////////////////////////////////////
' From: Bitwise Manipulations By Steven Roman
' http://www.romanpress.com/Articles/Bitwise_R/Bitwise.htm
 
' Returns the 8-bit binary representation
' of an integer iInput where 0 <= iInput <= 255
 
Function GetBinary$ (iInput1 As Integer)
    Dim sResult As String
    Dim iLoop As Integer
    Dim iInput As Integer: iInput = iInput1
 
    sResult = ""
 
    If iInput >= 0 And iInput <= 255 Then
        For iLoop = 1 To 8
            sResult = LTrim$(RTrim$(Str$(iInput Mod 2))) + sResult
            iInput = iInput \ 2
            'If iLoop = 4 Then sResult = " " + sResult
        Next iLoop
    End If
 
    GetBinary$ = sResult
End Function ' GetBinary$
 
' /////////////////////////////////////////////////////////////////////////////
' wonderfully inefficient way to read if a bit is set
' ival = GetBit256%(int we are comparing, int containing the bits we want to read)
 
' See also: GetBit256%, SetBit256%
 
Function GetBit256% (iNum1 As Integer, iBit1 As Integer)
    Dim iResult As Integer
    Dim sNum As String
    Dim sBit As String
    Dim iLoop As Integer
    Dim bContinue As Integer
    'DIM iTemp AS INTEGER
    Dim iNum As Integer: iNum = iNum1
    Dim iBit As Integer: iBit = iBit1
 
    iResult = FALSE
    bContinue = TRUE
 
    If iNum < 256 And iBit <= 128 Then
        sNum = GetBinary$(iNum)
        sBit = GetBinary$(iBit)
        For iLoop = 1 To 8
            If Mid$(sBit, iLoop, 1) = "1" Then
                'if any of the bits in iBit are false, return false
                If Mid$(sNum, iLoop, 1) = "0" Then
                    iResult = FALSE
                    bContinue = FALSE
                    Exit For
                End If
            End If
        Next iLoop
        If bContinue = TRUE Then
            iResult = TRUE
        End If
    End If
 
    GetBit256% = iResult
End Function ' GetBit256%
 
' /////////////////////////////////////////////////////////////////////////////
' From: Bitwise Manipulations By Steven Roman
' http://www.romanpress.com/Articles/Bitwise_R/Bitwise.htm
 
' Returns the integer that corresponds to a binary string of length 8
 
Function GetIntegerFromBinary% (sBinary1 As String)
    Dim iResult As Integer
    Dim iLoop As Integer
    Dim strBinary As String
    Dim sBinary As String: sBinary = sBinary1
 
    iResult = 0
    strBinary = Replace$(sBinary, " ", "") ' Remove any spaces
    For iLoop = 0 To Len(strBinary) - 1
        iResult = iResult + 2 ^ iLoop * Val(Mid$(strBinary, Len(strBinary) - iLoop, 1))
    Next iLoop
 
    GetIntegerFromBinary% = iResult
End Function ' GetIntegerFromBinary%
 
' /////////////////////////////////////////////////////////////////////////////
' By sMcNeill from https://www.qb64.org/forum/index.php?topic=896.0
 
Function IsNum% (text$)
    Dim a$
    Dim b$
    a$ = _Trim$(text$)
    b$ = _Trim$(Str$(Val(text$)))
    If a$ = b$ Then
        IsNum% = TRUE
    Else
        IsNum% = FALSE
    End If
End Function ' IsNum%
 
' /////////////////////////////////////////////////////////////////////////////
' Split and join strings
' https://www.qb64.org/forum/index.php?topic=1073.0
 
'Combine all elements of in$() into a single string with delimiter$ separating the elements.
 
Function join$ (in$(), delimiter$)
    result$ = in$(LBound(in$))
    For i = LBound(in$) + 1 To UBound(in$)
        result$ = result$ + delimiter$ + in$(i)
    Next i
    join$ = result$
End Function ' join$
 
' /////////////////////////////////////////////////////////////////////////////
' ABS was returning strange values with type LONG
' so I created this which does not.
 
Function LongABS& (lngValue As Long)
    If Sgn(lngValue) = -1 Then
        LongABS& = 0 - lngValue
    Else
        LongABS& = lngValue
    End If
End Function ' LongABS&
 
' /////////////////////////////////////////////////////////////////////////////
' Re: Does a Is Number function exist in QB64?
' https://www.qb64.org/forum/index.php?topic=896.15
 
' MWheatley
' « Reply #18 on: January 01, 2019, 11:24:30 AM »
 
' returns 1 if string is an integer, 0 if not
Function IsNumber (text$)
    Dim i As Integer
 
    IsNumber = 1
    For i = 1 To Len(text$)
        If Asc(Mid$(text$, i, 1)) < 45 Or Asc(Mid$(text$, i, 1)) >= 58 Then
            IsNumber = 0
            Exit For
        ElseIf Asc(Mid$(text$, i, 1)) = 47 Then
            IsNumber = 0
            Exit For
        End If
    Next i
End Function ' IsNumber
 
' /////////////////////////////////////////////////////////////////////////////
' iNum% = PromptForIntegerInRange%("Please type a number between {min} and {max} (or blank to quit).", 1, 4, 0)
 
Function PromptForIntegerInRange% (sPrompt$, iMin%, iMax%, iDefault%)
    Dim iValue%
    Dim bFinished%
    Dim sPrompt1$
    Dim in$
 
    If Len(sPrompt$) > 0 Then
        sPrompt1$ = sPrompt$
    Else
        sPrompt1$ = "Please type a number between {min} and {max} (or blank to quit)."
    End If
 
    sPrompt1$ = Replace$(sPrompt1$, "{min}", cstr$(iMin%))
    sPrompt1$ = Replace$(sPrompt1$, "{max}", cstr$(iMax%))
 
    bFinished% = FALSE
    Do
        Print sPrompt1$
 
        Input in$
        in$ = _Trim$(in$)
        If Len(in$) > 0 Then
            If IsNumber(in$) Then
                iValue% = Val(in$)
                If iValue% >= iMin% And iValue% <= iMax% Then
                    'bFinished% = TRUE
                    Exit Do
                Else
                    Print "Number out of range."
                    Print
                End If
            Else
                Print "Not a valid number."
                Print
            End If
        Else
            iValue% = iDefault%
            Exit Do
            'bFinished% = TRUE
        End If
    Loop Until bFinished% = TRUE
 
    PromptForIntegerInRange% = iValue%
End Function ' PromptForIntegerInRange%
 
' /////////////////////////////////////////////////////////////////////////////
' iNum& = PromptForLongInRange&("Please type a number between {min} and {max} (or blank to quit).", 1, 4, 0)
 
Function PromptForLongInRange& (sPrompt$, iMin&, iMax&, iDefault&)
    Dim iValue&
    Dim bFinished&
    Dim sPrompt1$
    Dim in$
    
    bFinished& = FALSE
    Do
        If Len(sPrompt$) > 0 Then
            sPrompt1$ = sPrompt$
        Else
            sPrompt1$ = "Please type a number between {min} and {max} (or blank to quit)."
        End If
        
        sPrompt1$ = Replace$ (sPrompt1$, "{min}", cstrl$(iMin&))
        sPrompt1$ = Replace$ (sPrompt1$, "{max}", cstrl$(iMax&))
        
        Input in$
        in$ = _Trim$(in$)
        If Len(in$) > 0 Then
            If IsNumber(in$) Then
                iValue& = Val(in$)
                If iValue& >= iMin& And iValue& <= iMax& Then
                    bFinished& = TRUE
                Else
                    Print "Number out of range."
                    Print
                End If
            Else
                Print "Not a valid number."
                Print
            End If
        Else
            iValue& = iDefault&
            bFinished& = TRUE
        End If
    Loop Until bFinished&
    
    PromptForLongInRange& = iValue&
End Function ' PromptForLongInRange&
 
' /////////////////////////////////////////////////////////////////////////////
' Returns blank if successful else returns error message.
 
Function PrintFile$ (sFileName As String, sText As String, bAppend As Integer)
    'x = 1: y = 2: z$ = "Three"
 
    Dim sError As String: sError = ""
 
    If Len(sError) = 0 Then
        If (bAppend = TRUE) Then
            If _FileExists(sFileName) Then
                Open sFileName For Append As #1 ' opens an existing file for appending
            Else
                sError = "Error in PrintFile$ : File not found. Cannot append."
            End If
        Else
            Open sFileName For Output As #1 ' opens and clears an existing file or creates new empty file
        End If
    End If
    If Len(sError) = 0 Then
        ' WRITE places text in quotes in the file
        'WRITE #1, x, y, z$
        'WRITE #1, sText
 
        ' PRINT does not put text inside quotes
        Print #1, sText
 
        Close #1
 
        'PRINT "File created with data. Press a key!"
        'K$ = INPUT$(1) 'press a key
 
        'OPEN sFileName FOR INPUT AS #2 ' opens a file to read it
        'INPUT #2, a, b, c$
        'CLOSE #2
 
        'PRINT a, b, c$
        'WRITE a, b, c$
    End If
 
    PrintFile$ = sError
End Function ' PrintFile$
 
' /////////////////////////////////////////////////////////////////////////////
' Generate random value between Min and Max.
Function RandomNumber% (Min%, Max%)
    Dim NumSpread%
 
    ' SET RANDOM SEED
    'Randomize ' Initialize random-number generator.
    Randomize Timer
 
    ' GET RANDOM # Min%-Max%
    'RandomNumber = Int((Max * Rnd) + Min) ' generate number
 
    NumSpread% = (Max% - Min%) + 1
 
    RandomNumber% = Int(Rnd * NumSpread%) + Min% ' GET RANDOM # BETWEEN Max% AND Min%
 
End Function ' RandomNumber%
 
' /////////////////////////////////////////////////////////////////////////////
 
Sub RandomNumberTest
    Dim iCols As Integer: iCols = 10
    Dim iRows As Integer: iRows = 20
    Dim iLoop As Integer
    Dim iX As Integer
    Dim iY As Integer
    Dim sError As String
    Dim sFileName As String
    Dim sText As String
    Dim bAppend As Integer
    Dim iMin As Integer
    Dim iMax As Integer
    Dim iNum As Integer
    Dim iErrorCount As Integer
    Dim sInput$
 
    sFileName = "c:\temp\maze_test_1.txt"
    sText = "Count" + Chr$(9) + "Min" + Chr$(9) + "Max" + Chr$(9) + "Random"
    bAppend = FALSE
    sError = PrintFile$(sFileName, sText, bAppend)
    If Len(sError) = 0 Then
        bAppend = TRUE
        iErrorCount = 0
 
        iMin = 0
        iMax = iCols - 1
        For iLoop = 1 To 100
            iNum = RandomNumber%(iMin, iMax)
            sText = Str$(iLoop) + Chr$(9) + Str$(iMin) + Chr$(9) + Str$(iMax) + Chr$(9) + Str$(iNum)
            sError = PrintFile$(sFileName, sText, bAppend)
            If Len(sError) > 0 Then
                iErrorCount = iErrorCount + 1
                Print Str$(iLoop) + ". ERROR"
                Print "    " + "iMin=" + Str$(iMin)
                Print "    " + "iMax=" + Str$(iMax)
                Print "    " + "iNum=" + Str$(iNum)
                Print "    " + "Could not write to file " + Chr$(34) + sFileName + Chr$(34) + "."
                Print "    " + sError
            End If
        Next iLoop
 
        iMin = 0
        iMax = iRows - 1
        For iLoop = 1 To 100
            iNum = RandomNumber%(iMin, iMax)
            sText = Str$(iLoop) + Chr$(9) + Str$(iMin) + Chr$(9) + Str$(iMax) + Chr$(9) + Str$(iNum)
            sError = PrintFile$(sFileName, sText, bAppend)
            If Len(sError) > 0 Then
                iErrorCount = iErrorCount + 1
                Print Str$(iLoop) + ". ERROR"
                Print "    " + "iMin=" + Str$(iMin)
                Print "    " + "iMax=" + Str$(iMax)
                Print "    " + "iNum=" + Str$(iNum)
                Print "    " + "Could not write to file " + Chr$(34) + sFileName + Chr$(34) + "."
                Print "    " + sError
            End If
        Next iLoop
 
        Print "Finished generating numbers. Errors: " + Str$(iErrorCount)
    Else
        Print "Error creating file " + Chr$(34) + sFileName + Chr$(34) + "."
        Print sError
    End If
 
    Input "Press <ENTER> to continue", sInput$
End Sub ' RandomNumberTest
 
' /////////////////////////////////////////////////////////////////////////////
' FROM: String Manipulation
' http://www.[abandoned, outdated and now likely malicious qb64 dot net website - don’t go there]/forum/index_topic_5964-0/
'
'SUMMARY:
'   Purpose:  A library of custom functions that transform strings.
'   Author:   Dustinian Camburides (dustinian@gmail.com)
'   Platform: QB64 (www.[abandoned, outdated and now likely malicious qb64 dot net website - don’t go there])
'   Revision: 1.6
'   Updated:  5/28/2012
 
'SUMMARY:
'[Replace$] replaces all instances of the [Find] sub-string with the [Add] sub-string within the [Text] string.
'INPUT:
'Text: The input string; the text that's being manipulated.
'Find: The specified sub-string; the string sought within the [Text] string.
'Add: The sub-string that's being added to the [Text] string.
 
Function Replace$ (Text1 As String, Find1 As String, Add1 As String)
    ' VARIABLES:
    Dim Text2 As String
    Dim Find2 As String
    Dim Add2 As String
    Dim lngLocation As Long ' The address of the [Find] substring within the [Text] string.
    Dim strBefore As String ' The characters before the string to be replaced.
    Dim strAfter As String ' The characters after the string to be replaced.
 
    ' INITIALIZE:
    ' MAKE COPIESSO THE ORIGINAL IS NOT MODIFIED (LIKE ByVal IN VBA)
    Text2 = Text1
    Find2 = Find1
    Add2 = Add1
 
    lngLocation = InStr(1, Text2, Find2)
 
    ' PROCESSING:
    ' While [Find2] appears in [Text2]...
    While lngLocation
        ' Extract all Text2 before the [Find2] substring:
        strBefore = Left$(Text2, lngLocation - 1)
 
        ' Extract all text after the [Find2] substring:
        strAfter = Right$(Text2, ((Len(Text2) - (lngLocation + Len(Find2) - 1))))
 
        ' Return the substring:
        Text2 = strBefore + Add2 + strAfter
 
        ' Locate the next instance of [Find2]:
        lngLocation = InStr(1, Text2, Find2)
 
        ' Next instance of [Find2]...
    Wend
 
    ' OUTPUT:
    Replace$ = Text2
End Function ' Replace$
 
' /////////////////////////////////////////////////////////////////////////////
' fantastically inefficient way to set a bit
 
' example use: arrMaze(iX, iY) = SetBit256%(arrMaze(iX, iY), cS, FALSE)
 
' See also: GetBit256%, SetBit256%
 
' newint=SetBit256%(oldint, int containing the bits we want to set, value to set them to)
Function SetBit256% (iNum1 As Integer, iBit1 As Integer, bVal1 As Integer)
    Dim sNum As String
    Dim sBit As String
    Dim sVal As String
    Dim iLoop As Integer
    Dim strResult As String
    Dim iResult As Integer
    Dim iNum As Integer: iNum = iNum1
    Dim iBit As Integer: iBit = iBit1
    Dim bVal As Integer: bVal = bVal1
 
    If iNum < 256 And iBit <= 128 Then
        sNum = GetBinary$(iNum)
        sBit = GetBinary$(iBit)
        If bVal = TRUE Then
            sVal = "1"
        Else
            sVal = "0"
        End If
        strResult = ""
        For iLoop = 1 To 8
            If Mid$(sBit, iLoop, 1) = "1" Then
                strResult = strResult + sVal
            Else
                strResult = strResult + Mid$(sNum, iLoop, 1)
            End If
        Next iLoop
        iResult = GetIntegerFromBinary%(strResult)
    Else
        iResult = iNum
    End If
 
    SetBit256% = iResult
End Function ' SetBit256%
 
' /////////////////////////////////////////////////////////////////////////////
' Split and join strings
' https://www.qb64.org/forum/index.php?topic=1073.0
'
' FROM luke, QB64 Developer
' Date: February 15, 2019, 04:11:07 AM Â»
'
' Given a string of words separated by spaces (or any other character),
' splits it into an array of the words. I've no doubt many people have
' written a version of this over the years and no doubt there's a million
' ways to do it, but I thought I'd put mine here so we have at least one
' version. There's also a join function that does the opposite
' array -> single string.
'
' Code is hopefully reasonably self explanatory with comments and a little demo.
' Note, this is akin to Python/JavaScript split/join, PHP explode/implode.
 
'Split in$ into pieces, chopping at every occurrence of delimiter$. Multiple consecutive occurrences
'of delimiter$ are treated as a single instance. The chopped pieces are stored in result$().
'
'delimiter$ must be one character long.
'result$() must have been REDIMmed previously.
 
Sub split (in$, delimiter$, result$())
    ReDim result$(-1)
    start = 1
    Do
        While Mid$(in$, start, 1) = delimiter$
            start = start + 1
            If start > Len(in$) Then Exit Sub
        Wend
        finish = InStr(start, in$, delimiter$)
        If finish = 0 Then finish = Len(in$) + 1
        ReDim _Preserve result$(0 To UBound(result$) + 1)
        result$(UBound(result$)) = Mid$(in$, start, finish - start)
        start = finish + 1
    Loop While start <= Len(in$)
End Sub ' split
 
' /////////////////////////////////////////////////////////////////////////////
 
Sub SplitTest
 
    Dim in$
    Dim delim$
    ReDim arrTest$(0)
    Dim iLoop%
 
    delim$ = Chr$(10)
    in$ = "this" + delim$ + "is" + delim$ + "a" + delim$ + "test"
    Print "in$ = " + Chr$(34) + in$ + Chr$(34)
    Print "delim$ = " + Chr$(34) + delimeter$ + Chr$(34)
    split in$, delim$, arrTest$()
 
    For iLoop% = LBound(arrTest$) To UBound(arrTest$)
        Print "arrTest$(" + LTrim$(RTrim$(Str$(iLoop%))) + ") = " + Chr$(34) + arrTest$(iLoop%) + Chr$(34)
    Next iLoop%
    Print
    Print "Split test finished."
End Sub ' SplitTest
 
' /////////////////////////////////////////////////////////////////////////////
 
Sub WaitForEnter
    Dim in$
    Input "Press <ENTER> to continue", in$
End Sub ' WaitForEnter
 
' /////////////////////////////////////////////////////////////////////////////
' WaitForKey "Press <ESC> to continue", 27, 0
' WaitForKey "Press <ENTER> to begin;", 13, 0
' waitforkey "", 65, 5
 
Sub WaitForKey (prompt$, KeyCode&, DelaySeconds%)
    ' SHOW PROMPT (IF SPECIFIED)
    If Len(prompt$) > 0 Then
        If Right$(prompt$, 1) <> ";" Then
            Print prompt$
        Else
            Print Right$(prompt$, Len(prompt$) - 1);
        End If
    End If
 
    ' WAIT FOR KEY
    Do: Loop Until _KeyDown(KeyCode&) ' leave loop when specified key pressed
 
    ' PAUSE AFTER (IF SPECIFIED)
    If DelaySeconds% < 1 Then
        _KeyClear: '_DELAY 1
    Else
        _KeyClear: _Delay DelaySeconds%
    End If
End Sub ' WaitForKey
 
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' END GENERAL PURPOSE FUNCTIONS
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' BEGIN COLOR ROUTINES
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
' /////////////////////////////////////////////////////////////////////////////
' Receives:
' cycleColor = determines how foreColor, backColor are modified
' foreColor  = the foreground color
' backColor  = the background color (if needed)
 
' /////////////////////////////////////////////////////////////////////////////
' DoCycleColor colorScheme%, myColor&
 
' colorScheme = color scheme (value is alternated on subsequent calls)
' myColor     = the current color (value is incremented/decremented on subsequent calls)
 
' colorScheme values:
'  1 Rainbow6 #1
'  9 Rainbow6 #2
'  2 Rainbow18 #1
' 10 Rainbow18 #2
'  3 Grayscale #1
' 11 Grayscale #2
'  4 Grayscale #1
' 12 Grayscale #2
 
Sub DoCycleColor (colorScheme As Integer, myColor As Long)
    ' ----------------------------------------------------------------------------------------------------------------------------------------------------------------
    ' CYCLE FORE COLOR
 
    ' 1, 5, 9 = simple rainbow
    If colorScheme = 1 Or colorScheme = 9 Then
        Select Case myColor
            Case cRed&:
                myColor = cOrange&
            Case cOrange&:
                myColor = cYellow&
            Case cYellow&:
                myColor = cGreen&
            Case cGreen&:
                myColor = cBlue&
            Case cBlue&:
                myColor = cPurple&
            Case Else:
                myColor = cRed&
        End Select
 
    ' 2, 6, 10 = complex rainbow
    ElseIf colorScheme = 2 Or colorScheme = 10 Then
        Select Case myColor
            Case cRed&:
                myColor = cOrangeRed&
            Case cOrangeRed&:
                myColor = cDarkOrange&
            Case cDarkOrange&:
                myColor = cOrange&
            Case cOrange&:
                myColor = cGold&
            Case cGold&:
                myColor = cYellow&
            Case cYellow&:
                myColor = cChartreuse&
            Case cChartreuse&:
                myColor = cLime&
            Case cLime&:
                myColor = cMediumSpringGreen&
            Case cMediumSpringGreen&:
                myColor = cCyan&
            Case cCyan&:
                myColor = cDeepSkyBlue&
            Case cDeepSkyBlue&:
                myColor = cDodgerBlue&
            Case cDodgerBlue&:
                myColor = cSeaBlue&
            Case cSeaBlue&:
                myColor = cBlue&
            Case cBlue&:
                myColor = cBluePurple&
            Case cBluePurple&:
                myColor = cDeepPurple&
            Case cDeepPurple&:
                myColor = cPurple&
            Case cPurple&:
                myColor = cPurpleRed&
            Case Else:
                myColor = cRed&
        End Select
 
    ' 3, 7, 11 = grayscale, ascending
    ElseIf colorScheme = 3 Or colorScheme = 11 Then
        Select Case myColor
            Case cBlack&:
                myColor = cDarkGray&
            Case cDarkGray&:
                myColor = cDimGray&
            Case cDimGray&:
                myColor = cGray&
            Case cGray&:
                myColor = cLightGray&
            Case cLightGray&:
                myColor = cSilver&
            Case cSilver&:
                myColor = cWhite&
            Case Else:
                'myColor = cBlack&
                myColor = cSilver&
 
                ' go in the other direction!
                If colorScheme = 3 Then
                    colorScheme = 4
                Else
                    colorScheme = 12
                End If
 
        End Select
 
    ' 4, 8, 12 = grayscale, descending
    ElseIf colorScheme = 4 Or colorScheme = 12 Then
        Select Case myColor
            Case cWhite&:
                myColor = cSilver&
            Case cSilver&:
                myColor = cLightGray&
            Case cLightGray&:
                myColor = cGray&
            Case cGray&:
                myColor = cDimGray&
            Case cDimGray&:
                myColor = cDarkGray&
            Case cDarkGray&:
                myColor = cBlack&
            Case Else:
                myColor = cDarkGray&
 
                ' go in the other direction!
                If colorScheme = 4 Then
                    colorScheme = 3
                Else
                    colorScheme = 11
                End If
        End Select
 
    End If
    
End Sub ' DoCycleColor
 
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' END COLOR ROUTINES
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' BEGIN COLOR FUNCTIONS
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
' NOTE: these are mostly negative numbers
'       and have to be forced to positive
'       when stored in the dictionary
'       (only cEmpty& should be negative)
 
Function cRed& ()
    cRed& = _RGB32(255, 0, 0)
End Function
 
Function cOrangeRed& ()
    cOrangeRed& = _RGB32(255, 69, 0)
End Function ' cOrangeRed&
 
Function cDarkOrange& ()
    cDarkOrange& = _RGB32(255, 140, 0)
End Function ' cDarkOrange&
 
Function cOrange& ()
    cOrange& = _RGB32(255, 165, 0)
End Function ' cOrange&
 
Function cGold& ()
    cGold& = _RGB32(255, 215, 0)
End Function ' cGold&
 
Function cYellow& ()
    cYellow& = _RGB32(255, 255, 0)
End Function ' cYellow&
 
Function cChartreuse& ()
    cChartreuse& = _RGB32(127, 255, 0)
End Function ' cChartreuse&
 
Function cLime& ()
    cLime& = _RGB32(0, 255, 0)
End Function ' cLime&
 
Function cMediumSpringGreen& ()
    cMediumSpringGreen& = _RGB32(0, 250, 154)
End Function ' cMediumSpringGreen&
 
Function cCyan& ()
    cCyan& = _RGB32(0, 255, 255)
End Function ' cCyan&
 
Function cDeepSkyBlue& ()
    cDeepSkyBlue& = _RGB32(0, 191, 255)
End Function ' cDeepSkyBlue&
 
Function cDodgerBlue& ()
    cDodgerBlue& = _RGB32(30, 144, 255)
End Function ' cDodgerBlue&
 
Function cSeaBlue& ()
    cSeaBlue& = _RGB32(0, 64, 255)
End Function ' cSeaBlue&
 
Function cBlue& ()
    cBlue& = _RGB32(0, 0, 255)
End Function ' cBlue&
 
Function cBluePurple& ()
    cBluePurple& = _RGB32(64, 0, 255)
End Function ' cBluePurple&
 
Function cDeepPurple& ()
    cDeepPurple& = _RGB32(96, 0, 255)
End Function ' cDeepPurple&
 
Function cPurple& ()
    cPurple& = _RGB32(128, 0, 255)
End Function ' cPurple&
 
Function cPurpleRed& ()
    cPurpleRed& = _RGB32(128, 0, 192)
End Function ' cPurpleRed&
 
Function cDarkRed& ()
    cDarkRed& = _RGB32(160, 0, 64)
End Function ' cDarkRed&
 
Function cBrickRed& ()
    cBrickRed& = _RGB32(192, 0, 32)
End Function ' cBrickRed&
 
Function cDarkGreen& ()
    cDarkGreen& = _RGB32(0, 100, 0)
End Function ' cDarkGreen&
 
Function cGreen& ()
    cGreen& = _RGB32(0, 128, 0)
End Function ' cGreen&
 
Function cOliveDrab& ()
    cOliveDrab& = _RGB32(107, 142, 35)
End Function ' cOliveDrab&
 
Function cLightPink& ()
    cLightPink& = _RGB32(255, 182, 193)
End Function ' cLightPink&
 
Function cHotPink& ()
    cHotPink& = _RGB32(255, 105, 180)
End Function ' cHotPink&
 
Function cDeepPink& ()
    cDeepPink& = _RGB32(255, 20, 147)
End Function ' cDeepPink&
 
Function cMagenta& ()
    cMagenta& = _RGB32(255, 0, 255)
End Function ' cMagenta&
 
Function cBlack& ()
    cBlack& = _RGB32(0, 0, 0)
End Function ' cBlack&
 
Function cDimGray& ()
    cDimGray& = _RGB32(105, 105, 105)
End Function ' cDimGray&
 
Function cGray& ()
    cGray& = _RGB32(128, 128, 128)
End Function ' cGray&
 
Function cDarkGray& ()
    cDarkGray& = _RGB32(169, 169, 169)
End Function ' cDarkGray&
 
Function cSilver& ()
    cSilver& = _RGB32(192, 192, 192)
End Function ' cSilver&
 
Function cLightGray& ()
    cLightGray& = _RGB32(211, 211, 211)
End Function ' cLightGray&
 
Function cGainsboro& ()
    cGainsboro& = _RGB32(220, 220, 220)
End Function ' cGainsboro&
 
Function cWhiteSmoke& ()
    cWhiteSmoke& = _RGB32(245, 245, 245)
End Function ' cWhiteSmoke&
 
Function cWhite& ()
    cWhite& = _RGB32(255, 255, 255)
End Function ' cWhite&
 
Function cDarkBrown& ()
    cDarkBrown& = _RGB32(128, 64, 0)
End Function ' cDarkBrown&
 
Function cLightBrown& ()
    cLightBrown& = _RGB32(196, 96, 0)
End Function ' cLightBrown&
 
Function cKhaki& ()
    cKhaki& = _RGB32(240, 230, 140)
End Function ' cKhaki&
 
Function cEmpty& ()
    cEmpty& = -1
End Function ' cEmpty&
 
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' END COLOR FUNCTIONS
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 

bplus · « **Reply #1 on:** December 09, 2021, 02:27:03 pm »

A minor point, it's actually = not + that increases size.

I look forward to Christmas themed scene, I am pretty sure you can do a tree as a square pyramid but if you stack circles of various diameter... :)

madscijr · « **Reply #2 on:** December 09, 2021, 04:45:26 pm »

Quote from: bplus on December 09, 2021, 02:27:03 pm

A minor point, it's actually = not + that increases size.

True. I just updated the code above with that and some other minor changes.

The variable keymapping was all messed up: the direction a given key moves you should change based on your viewing orientation, but it was doing weird stuff like moving the cursor diagonally, off the grid, etc. I have idea yet what's wrong with it, so I just reverted to the hardcoded values so it works. Will return to that later.

Quote from: bplus on December 09, 2021, 02:27:03 pm

I look forward to Christmas themed scene, I am pretty sure you can do a tree as a square pyramid but if you stack circles of various diameter... :)

Now that the base functionality is down, I can begin...

madscijr · « **Reply #3 on:** December 09, 2021, 05:00:49 pm »

One last update for this post, fixed a couple annoying bugs/non-features with the keyboard input.
Repeating keys now works.

News:

Author Topic: WIP: Isometric Demo re-revisited v2.90 (multi-simultaneous angles!) (Read 3348 times)

madscijr

WIP: Isometric Demo re-revisited v2.90 (multi-simultaneous angles!)

bplus

Re: WIP: Isometric Demo re-revisited v2.82 (can now change viewing angle)

madscijr

Re: WIP: Isometric Demo re-revisited v2.82 (can now change viewing angle)

madscijr

Re: WIP: Isometric Demo re-revisited v2.84 (can change viewing angle, tweaked input)