Need help debugging

BlitzMax Forums/BlitzMax Beginners Area/Need help debugging

abelian_grape

(Posted 2010) [#1]

So here's a puzzler. Currently I am building a map editor that allows you to create a new map, left click on a blank tile to place the current texture/RGB tile there, and if you right-click, you are prompted with some Editing options (which calls the function below).

'This function will prompt the user with some editing options
			Function Edit:TTile(x:Int, y:Int)
			
				Local Char:Int				'This variable will catch the user input character codes
				Local inputNum:String		'This variable will be used to collect the user input in a string
				Local RGBTile:Int = True	'Determines whether or not the tile to be edited will be RGB(True)
				Local rValue:Int
				Local gValue:Int
				Local bValue:Int
				
				'PROMPT USER WITH TILE OPTIONS
				While Not KeyHit(KEY_ENTER)
					
					Cls
					
					SetColor(120, 120, 120)	'Dark gray
					DrawRect(262, 234, 500, 56)
					SetColor(255, 255, 255)
					DrawText("Do you want a texture tile?", 381, 234)
					SetColor(0, 0, 0)
					DrawRect(442, 260, 40, 20)
					DrawRect(492, 260, 40, 20)
					SetColor(255, 255, 255)
					DrawText("Yes", 452, 265)
					DrawText("No", 502, 265)
					
					If MouseHit(1) And MouseX() >= 442 And MouseX() <= 482 And MouseY() <= 296 And MouseY() >= 244
						RGBTile = False
						Exit
					ElseIf MouseHit(1) And MouseX() >= 492 And MouseX() <= 532 And MouseY() <= 296 And MouseY() >= 244
						RGBTile = True
				
						'IF THE USER WANTS AN RGB TILE, PROMPT THEM FOR THE RGB VALUES
						'THIS LOOP TAKES THE R VALUE
						While Not KeyDown(KEY_ENTER) And RGBTile = True
							Cls
							SetColor(120, 120, 120)	'Dark gray
							DrawRect(262, 234, 500, 56)
							SetColor(255, 255, 255)
							DrawText("Enter R value for RGB tile: " + inputNum, 381, 234)
							DrawText("Press ENTER when done, BACKSPACE to clear input.", 381, 250)
							
							Char = GetChar()
							If Char >= 48 And Char <= 57	'As long as it's a number 0 - 9, accept input into string
								inputNum :+ Chr(Char)
							ElseIf Char = 8					'If user hits BACKSPACE, clear the input
								inputNum = Null
							EndIf
						
							Flip
						Wend
						
						'Store input, reset input
						rValue = Int(inputNum)
						FlushKeys()
						inputNum = Null
						
						
						'THIS LOOP TAKES THE G VALUE
						While Not KeyDown(KEY_ENTER) And RGBTile = True
							Cls
							SetColor(120, 120, 120)	'Dark gray
							DrawRect(262, 234, 500, 56)
							SetColor(255, 255, 255)
							DrawText("Enter G value for RGB tile: " + inputNum, 381, 234)
							DrawText("Press ENTER when done, BACKSPACE to clear input.", 381, 250)
							Char = GetChar()
							If Char >= 48 And Char <= 57	'As long as it's a number 0 - 9, accept input into string
								inputNum :+ Chr(Char)
							ElseIf Char = 8					'If user hits BACKSPACE, clear the input
								inputNum = Null
							EndIf
						
							Flip
						Wend
						
						'Store input, reset input
						gValue = Int(inputNum)
						FlushKeys()
						inputNum = Null
						
						'THIS LOOP TAKES THE B VALUE
						While Not KeyDown(KEY_ENTER) And RGBTile = True
							Cls
							SetColor(120, 120, 120)	'Dark gray
							DrawRect(262, 234, 500, 56)
							SetColor(255, 255, 255)
							DrawText("Enter B value for RGB tile: " + inputNum, 381, 234)
							DrawText("Press ENTER when done, BACKSPACE to clear input.", 381, 250)
							Char = GetChar()
							If Char >= 48 And Char <= 57	'As long as it's a number 0 - 9, accept input into string
								inputNum :+ Chr(Char)
							ElseIf Char = 8					'If user hits BACKSPACE, clear the input
								inputNum = Null
							EndIf
						
							Flip
						Wend
						
						
						'Store input, reset input, create tile
						bValue = Int(inputNum)
						FlushKeys()
						inputNum = Null
						
						
					EndIf
					
					Flip
					
				Wend
				
				If RGBTile = True
					'CREATE THE TILE HERE
					floors[rgb_id] = TFloor.Create(rValue, gValue, bValue, "RGB")
					map[x, y] = TTile.Create(x, y, rgb_id, passableToggle)
					curr_id = rgb_id		'Set the current floor_id
				EndIf
				
				'Reset input
				FlushKeys()
				inputNum = Null
				
				'IF THE USER WANTS A TEXTURE TILE, PROMPT THEM TO PICK A TEXTURE
				While Not KeyHit(KEY_ENTER) And RGBTile = False
					
					Cls
					SetColor(120, 120, 120)	'Dark gray
					DrawRect(262, 234, 500, 56)
					SetColor(255, 255, 255)
					DrawText("Please choose the number of the texture (0 to " + (floor_num - 1) + "): " + inputNum, 331, 234)
					DrawText("Press ENTER when done, BACKSPACE to clear input.", 331, 250)
					Char = GetChar()
					If Char >= 48 And Char <= 57	'As long as it's a number 0 - 9, accept input into string
						inputNum :+ Chr(Char)
					ElseIf Char = 8					'If user hits BACKSPACE, clear the input
						inputNum = Null
					EndIf
					Flip
				WEnd
				
				'Cast the input from string to int, create the tile, reset input
				If RGBTile = False
					map[x, y] = TTile.Create(x, y, Int(inputNum), passableToggle)
					curr_id = Int(inputNum)		'set current floor_id
					FlushKeys()
					inputNum = Null
				EndIf
				
				
			EndFunction

I tried to set up an elementary GUI so that when you click within a rectangle that has been designated a button, it's like clicking a button.

There is a portion of code that just doesn't seem to be executing, and I don't know why. In this block:

					If MouseHit(1) And MouseX() >= 442 And MouseX() <= 482 And MouseY() <= 296 And MouseY() >= 244
						RGBTile = False
						Exit
					ElseIf MouseHit(1) And MouseX() >= 492 And MouseX() <= 532 And MouseY() <= 296 And MouseY() >= 244
						RGBTile = True

There are bounds on where the mouse can be when left clicking to determine if a button has been pressed. The two buttons are Yes and No (Yes is the top one, No is the bottom one). If you click Yes, the program actually works and you can create a texture tile. If you click in the No box, nothing happens. This is so annoying because I can't see any difference between the two conditions, other than the No box is right-shifted further than the Yes box. So apparently, what isn't working is this:

				ElseIf MouseHit(1) And MouseX() >= 492 And MouseX() <= 532 And MouseY() <= 296 And MouseY() >= 244
						RGBTile = True

Because if it were, the rest of the code would be executed which looks like:

ElseIf MouseHit(1) And MouseX() >= 492 And MouseX() <= 532 And MouseY() <= 296 And MouseY() >= 244
						RGBTile = True
				
						'IF THE USER WANTS AN RGB TILE, PROMPT THEM FOR THE RGB VALUES
						'THIS LOOP TAKES THE R VALUE
						While Not KeyDown(KEY_ENTER) And RGBTile = True
							Cls
							SetColor(120, 120, 120)	'Dark gray
							DrawRect(262, 234, 500, 56)
							SetColor(255, 255, 255)
							DrawText("Enter R value for RGB tile: " + inputNum, 381, 234)
							DrawText("Press ENTER when done, BACKSPACE to clear input.", 381, 250)
							
							Char = GetChar()
							If Char >= 48 And Char <= 57	'As long as it's a number 0 - 9, accept input into string
								inputNum :+ Chr(Char)
							ElseIf Char = 8					'If user hits BACKSPACE, clear the input
								inputNum = Null
							EndIf
						
							Flip
						Wend
						
						'Store input, reset input
						rValue = Int(inputNum)
						FlushKeys()
						inputNum = Null
						
						
						'THIS LOOP TAKES THE G VALUE
						While Not KeyDown(KEY_ENTER) And RGBTile = True
							Cls
							SetColor(120, 120, 120)	'Dark gray
							DrawRect(262, 234, 500, 56)
							SetColor(255, 255, 255)
							DrawText("Enter G value for RGB tile: " + inputNum, 381, 234)
							DrawText("Press ENTER when done, BACKSPACE to clear input.", 381, 250)
							Char = GetChar()
							If Char >= 48 And Char <= 57	'As long as it's a number 0 - 9, accept input into string
								inputNum :+ Chr(Char)
							ElseIf Char = 8					'If user hits BACKSPACE, clear the input
								inputNum = Null
							EndIf
						
							Flip
						Wend
						
						'Store input, reset input
						gValue = Int(inputNum)
						FlushKeys()
						inputNum = Null
						
						'THIS LOOP TAKES THE B VALUE
						While Not KeyDown(KEY_ENTER) And RGBTile = True
							Cls
							SetColor(120, 120, 120)	'Dark gray
							DrawRect(262, 234, 500, 56)
							SetColor(255, 255, 255)
							DrawText("Enter B value for RGB tile: " + inputNum, 381, 234)
							DrawText("Press ENTER when done, BACKSPACE to clear input.", 381, 250)
							Char = GetChar()
							If Char >= 48 And Char <= 57	'As long as it's a number 0 - 9, accept input into string
								inputNum :+ Chr(Char)
							ElseIf Char = 8					'If user hits BACKSPACE, clear the input
								inputNum = Null
							EndIf
						
							Flip
						Wend
						
						
						'Store input, reset input, create tile
						bValue = Int(inputNum)
						FlushKeys()
						inputNum = Null
						
						
					EndIf
					
					Flip
					
				Wend
				
				If RGBTile = True
					'CREATE THE TILE HERE
					floors[rgb_id] = TFloor.Create(rValue, gValue, bValue, "RGB")
					map[x, y] = TTile.Create(x, y, rgb_id, passableToggle)
					curr_id = rgb_id		'Set the current floor_id
				EndIf
				
				'Reset input
				FlushKeys()
				inputNum = Null

This is seriously driving me up the wall.

-muffins

Jesse

(Posted 2010) [#2]

what seems to be happening and I am just guessing but I am 99.9% shure, when you check the MouseHit in the first if statement, the mouseHit automatically is cleared out of the buffer so if you check it again it is no longer present and therefore that condition will never be true for the second,third... if statement. I suggest you store the mouseHit in a variable and do the tests from the variable.
I have never liked the way the mouseHit or keyhit works.
that is one of the reasons I created my own mouse handling object

abelian_grape

(Posted 2010) [#3]

That is exactly it, thank you Jesse! I hadn't even considered that.

If the admins choose, please feel free to delete this thread.

TaskMaster

(Posted 2010) [#4]

Why delete a thread? It is a good learning experience for others. That is the point of a forum like this.

This is something a lot of people don't realize, when you call mousehit or keyhit, it clears it. So, you should save its results in a variable before testing it multiple times.

Czar Flavius

(Posted 2010) [#5]

In my main game loop I have an input gathering function, which stores in global variables things such as left button pressed/right button pressed etc, so the rest of my game loop knows if the button has been hit or not.

abelian_grape

(Posted 2010) [#6]

I guess while we're on it, there is another issue that I cannot reconcile, and I believe it is a product of the whole "MouseHit" debacle. Here is the deal. When a user right-clicks on a tile in my tile editor, an "Edit" function is called which is a Type function. The function within this Tile Type looks like this:

'This function will prompt the user with some editing options
			Function Edit:TTile(x:Int, y:Int)
				
				'PROMPT USER WITH TILE OPTIONS
				While (Not KeyDown(KEY_ENTER))
					Local mousePressed:Int = False
					
					Cls
					
					'Set up the message box
					SetColor(120, 120, 120)	'Dark gray
					DrawRect(262, 234, 500, 56)
					SetColor(255, 255, 255)
					DrawText("Do you want a texture tile?", 381, 234)
					
					'Draw 'Yes' and 'No' buttons
					SetColor(0, 0, 0)
					DrawRect(442, 260, 40, 20)
					DrawRect(492, 260, 40, 20)
					SetColor(255, 255, 255)
					DrawText("Yes", 452, 265)
					DrawText("No", 502, 265)
					
					
					'This variable gives the program time to check to see if 'Yes' or 'No' was clicked
					If MouseHit(1)
						mousePressed = True
					End If
					
					'If the user clicks within this bounding box, user selects 'Yes' and selects a texture tile
					If mousePressed And MouseX() >= 442 And MouseX() <= 482 And MouseY() <= 296 And MouseY() >= 244
						Setup_Texture(x, y)
						Exit
					'If the user clicks within this bounding box, user selects 'No' and selects an RGB tile
					ElseIf mousePressed And MouseX() >= 492 And MouseX() <= 532 And MouseY() <= 296 And MouseY() >= 244
						Setup_RGB(x, y)
						Exit
					EndIf
					
					Flip
					
				Wend
				
			EndFunction

Now, when the Edit function is called, essentially a message box pops up prompting the user to choose between a pre-defined texture tile, or a custom RGB tile whereby one can define their own RGB values for a solid-colored tile. Depending on whether the user answers yes (create texture) or no (create RGB), another function is called (this time the function does not belong to a type). Setup_Texture(x,y) to create the texture tile, and Setup_RGB(x,y) for creating the RGB tile, where the parameters to both functions are the coordinates of the particular tile chosen within the map array.

Here is the Setup_RGB function:

		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'Function Setup_RGB(x:Int, y:Int)
		'Parameters: x and y coordinates of the tile in the array
		'Returns: NONE
		'Prompts user to setup a RGB tile
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''	
		Function Setup_RGB(x:Int, y:Int)
				
				Local Char:Int				'This variable will catch the user input character codes
				Local inputNum:String		'This variable will be used to collect the user input in a string
				Local rValue:Int
				Local gValue:Int
				Local bValue:Int
				Local Cycle:Int = 0	'This variable keeps track of what value you are editing (R = 0, G = 1, or B = 2)
				Local createTile:Int = False 'This variable is used in a button to create the tile as it is
				


			'IF THE USER WANTS AN RGB TILE, PROMPT THEM FOR THE RGB VALUES
					While createTile = False
					
						While Cycle = 0
						'THIS LOOP TAKES THE R VALUE
							Cls
							
							'Boxes
							SetColor(120, 120, 120)	'Dark gray
							DrawRect(262, 234, 500, 68)	'Main message box
							DrawRect(550, 352, 100, 14)	'Create Tile button
							SetColor(255, 255, 255)
							
							'Text to be displayed on screen
							DrawText("Preview:", 400, 350)
							DrawText("R: " + rValue + " G: " + gValue + " B: " + bValue, 400, 400)
							DrawText("Create Tile", 556, 352)
							DrawText("Enter R value for RGB tile: " + inputNum, 262, 234)
							DrawText("OR Press UP/DOWN arrows to increment/decrement R preview.", 262, 246)
							DrawText("Press ENTER when done, BACKSPACE to clear input.", 262, 258)
							DrawText("Press LEFT/RIGHT arrows to cycle through R, G, B settings.", 262, 270)
							
							Cycle = Update_Menu_Cycle(Cycle, 0, 2)'Check to see if user scrolls between R, G, B
							Draw_Preview_RGB(480, 350 - (tileSize / 2), rValue, gValue, bValue)	'Draw the preview tile
							rValue = Update_Preview_RGB(rValue)	'Check to see if adjustments were made to the preview tile
							
							
							'Check to see if Create Tile button was pressed.
							If MouseHit(1) And MouseX() <= 650 And MouseX() >= 550 And MouseY() >= 352 And MouseY() <= 366
								FlushKeys()
								createTile = True
								Exit
							EndIf
							 
							'Grab user input
							Char = GetChar()
							If Char >= 48 And Char <= 57	'As long as it's a number 0 - 9, accept input into string
								inputNum :+ Chr(Char)
							ElseIf Char = 8					'If user hits BACKSPACE, clear the input
								inputNum = Null
							EndIf
						
							Flip
							
						Wend
						
						FlushKeys()
						
						'Store input, reset input
						If Not (inputNum = Null)
							rValue = Int(inputNum)
							FlushKeys()
							inputNum = Null
						EndIf
						
						While Cycle = 1
						'THIS LOOP TAKES THE G VALUE
							Cls
							
							'Boxes
							SetColor(120, 120, 120)	'Dark gray
							DrawRect(262, 234, 500, 68)	'Main message box
							DrawRect(550, 352, 100, 14)	'Create Tile button
							SetColor(255, 255, 255)
							
							'Text to be displayed on screen
							DrawText("Preview:", 400, 350)
							DrawText("R: " + rValue + " G: " + gValue + " B: " + bValue, 400, 400)
							DrawText("Create Tile", 556, 352)
							DrawText("Enter G value for RGB tile: " + inputNum, 262, 234)
							DrawText("OR Press UP/DOWN arrows to increment/decrement G preview.", 262, 246)
							DrawText("Press ENTER when done, BACKSPACE to clear input.", 262, 258)
							DrawText("Press LEFT/RIGHT arrows to cycle through R, G, B settings.", 262, 270)
							
							Cycle = Update_Menu_Cycle(Cycle, 0, 2)'Check to see if user scrolls between R, G, B
							Draw_Preview_RGB(480, 350 - (tileSize / 2), rValue, gValue, bValue)	'Draw the preview tile
							gValue = Update_Preview_RGB(gValue)	'Check to see if adjustments were made to the preview tile
							
							
							'Check to see if Create Tile button was pressed.
							If MouseHit(1) And MouseX() <= 650 And MouseX() >= 550 And MouseY() >= 352 And MouseY() <= 366
								FlushKeys()
								createTile = True
								Exit
							EndIf
							 
							'Grab user input
							Char = GetChar()
							If Char >= 48 And Char <= 57	'As long as it's a number 0 - 9, accept input into string
								inputNum :+ Chr(Char)
							ElseIf Char = 8					'If user hits BACKSPACE, clear the input
								inputNum = Null
							EndIf
						
							Flip
							
						Wend
						
						FlushKeys()
						
						'Store input, reset input
						If Not (inputNum = Null)
							gValue = Int(inputNum)
							FlushKeys()
							inputNum = Null
						EndIf
						
						While Cycle = 2
						'THIS LOOP TAKES THE B VALUE
							Cls
							
							'Boxes
							SetColor(120, 120, 120)	'Dark gray
							DrawRect(262, 234, 500, 68)	'Main message box
							DrawRect(550, 352, 100, 14)	'Create Tile button
							SetColor(255, 255, 255)
							
							'Text to be displayed on screen
							DrawText("Preview:", 400, 350)
							DrawText("R: " + rValue + " G: " + gValue + " B: " + bValue, 400, 400)
							DrawText("Create Tile", 556, 352)
							DrawText("Enter B value for RGB tile: " + inputNum, 262, 234)
							DrawText("OR Press UP/DOWN arrows to increment/decrement B preview.", 262, 246)
							DrawText("Press ENTER when done, BACKSPACE to clear input.", 262, 258)
							DrawText("Press LEFT/RIGHT arrows to cycle through R, G, B settings.", 262, 270)
							
							Cycle = Update_Menu_Cycle(Cycle, 0, 2)'Check to see if user scrolls between R, G, B
							Draw_Preview_RGB(480, 350 - (tileSize / 2), rValue, gValue, bValue)	'Draw the preview tile
							bValue = Update_Preview_RGB(bValue)	'Check to see if adjustments were made to the preview tile
							
							'Check to see if Create Tile button was pressed.
							If MouseHit(1) And MouseX() <= 650 And MouseX() >= 550 And MouseY() >= 352 And MouseY() <= 366
								FlushKeys()
								createTile = True
								Exit
							EndIf
							 
							'Grab user input
							Char = GetChar()
							If Char >= 48 And Char <= 57	'As long as it's a number 0 - 9, accept input into string
								inputNum :+ Chr(Char)
							ElseIf Char = 8					'If user hits BACKSPACE, clear the input
								inputNum = Null
							EndIf
						
							Flip
							
						Wend
						
						FlushKeys()
						
						'Store input, reset input, create tile
						If Not (inputNum = Null)
							bValue = Int(inputNum)
							FlushKeys()
							inputNum = Null
						EndIf
					Wend
					
					FlushKeys()
					
					'Once createTile gets set to TRUE from user pressing the "Create Tile" button, create the tile.
					If createTile = True
						'CREATE THE TILE HERE
						floors[rgb_id] = TFloor.Create(rValue, gValue, bValue, "RGB")
						map[x, y] = TTile.Create(x, y, rgb_id, passableToggle)
						curr_id = rgb_id		'Set the current floor_id
					EndIf
					
					
		End Function

Therefore, once the person right clicks a tile, the position of that tile within the 2D map array of tiles is recorded and once the user sets up the texture or RGB tile, the tile will be placed at that location. My problem is this:

When the user chooses to create an RGB tile, they are presented with a message box telling them to enter the explicit values for R, G, B, and the user can cycle between the 3 using left and right arrow keys. There is also a preview window for the overall color, and depending on whether the user is editing R, G, or B, the up/down arrows will adjust the value of R, G, or B between 0 - 255. At any time between editing R, G, or B, the user has the option of clicking a button labeled "Create Tile" where the colors chosen are locked in and then the tile is created. ISSUE: Not only does the editor create the tile of specified RGB values at the tile that was originally right clicked, it creates a duplicate tile at the location of the Create Tile button. So by having that button, and having the user click it with a mouse, for some reason the code is creating a duplicate tile at the location of the Create Tile button. All the Setup_RGB function was passed was the x, y coordinates of the tile in the 2D map array, and it was only used for the TTile.Create() function call. I would guess that because the Edit function is a Type function, and the Setup_RGB function is not a type function, then the Edit function seems to still be registering left mouse clicks (which creates the most recently created tile at the location left-clicked) even though the program control is in the Setup_RGB function.

abelian_grape

(Posted 2010) [#7]

I should also note that clicking anywhere other than the "Create Tile" button doesn't create a new tile at that spot, nor does the act of clicking "No" in the first menu to create an RGB tile cause a tile to be created there either. Very strange.

Jesse

(Posted 2010) [#8]

try "FlushMouse" after selecting the tile. If that doesn't work, you might have to post a sample executable or executable source code.

abelian_grape

(Posted 2010) [#9]

haha, It needed a FlushMouse. I was using FlushKeys and wondering why it didn't do anything. Thanks Jesse!

abelian_grape

(Posted 2010) [#10]

Any help would be AWESOME on debugging the following code. If no one wants to, I understand, because it is a big heap of code. It's big for me, at least...still under 1000 lines, many of which are blank or comments.

NOTE: In order to get this code to 'work', create a "Textures" directory in the same directory as the .bmx file. Put TWO 32x32 pixel images that can be drawn by BlitzMax using the DrawImage function in the "Textures" directory.

When I run the program, create a new map, right-click on a tile, choose "Yes" for when I get prompted if I want a texture tile, the program crashes with a "Unhandled Exception:Attempt to access field or method of Null object" error. I know what the error relates to (it is fairly self-explanatory) but I can't figure out where my code is failing. I get re-directed to the DrawImage function which leads me to believe that the texture floors that are being created in this block of code:

			'Load the textures from the Textures directory
			For Local i:Int = 0 To (texture_num - 1)
				texture_file_name = NextFile(dir)
				Local texture_img:TImage = LoadImage(texture_file_name)
				textures[i] = TFloor.Create(255, 255, 255, texture_file_name, texture_img)
				texture_file_name = Null
			Next

are somehow falling out of scope for when I go to draw them in this block of code:

							'Draw the textures in the texture array
							For Local j:Int = 0 To (texture_num - 1)
								textures[j].Draw(texture_x, texture_y)
								texture_x:+tileSize	'Move the next texture over to prevent overlap
								'Wrap the texture images to remain on the screen
								If texture_x > (1024 - (tileSize / 2))
									texture_x = (tileSize / 2)
									texture_y:+tileSize
								EndIf
							Next

In any event, I think the areas to focus on are the Setup_Texture() function, as well as the TFloor.Draw() method. Here is the code in its entirety:

Rem
WORKING TITLE: Cartographer
AUTHOR: Daniel Allen

ABOUT:
This is a map creator for a tile-based game.  The user can specify
the dimensions of the map by specifying the number of tiles in the map
horizontally and vertically, as well as specifying the dimensions of
each tile. 

IDEAS:
Have some shaded tile follow the mouse when the mouse is over the map
Allow for selecting multiple tiles

TO DO BEFORE CREATING A MAP:
*Set the map dimensions
*Set the tile dimensions
*Set the number of textures in the Textures folder
*Ensure that all texture images in the Textures folder are of the same dimensions as the pre-defined tile dimensions

TO DO:
*Create Tiles
	-Give user the option of making the tile passable (Right clicking a tile will toggle passable)
		-Make a function, when called, draw a transparent graphic over all impassable tiles
	-Allow for features to be added to tiles (rocks, pillars, etc.)
*Save map option
	-Dump the information to a text file that can be read by the game - this code can be used in the game
*Load map option
	-Load the information from a text file  - this code can be used in the game
*Fix the program crash when clicking outside the map
*Create hotkeys
*Allow on-the-fly map re-sizing (Maybe use +/- keys in conjunction with arrow keys to expand in a certain direction.

EndRem

SuperStrict

'Initialize graphics mode
Graphics(1024,768)

'Center image handle
AutoMidHandle True

'Seed the timer
SeedRnd(MilliSecs())


''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'MUSIC & SOUND FILES
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''



''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'IMAGES
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'Background Images
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'Object Images
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'Load Fonts
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		
		
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'GLOBAL VARIABLES / CONSTANTS
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'MAP VARIABLES
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		Global tileSize:Int = 32		'The size of each tile
		Const screenOffset:Int = 32	'A screen offset to provide space for inventory
		Global xMap:Int = 50			'Number of tiles horizontally
		Global yMap:Int	= 50		'Number of tiles vertically
		Const xRes:Int = 1024 - (screenOffset*2)	'The visible length of the map horizontally
		Const yRes:Int = 768 - (screenOffset*2)		'The visible length of the map vertically
		
		
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'TILE VARIABLES
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'The id numbers for the different types of floors
		Const blank_id:Int = 0
		Const rgb_id:Int = 1
		Const texture_id:Int = 2

		Global curr_id:Int = 0	'Use this variable to point to the last selected floor_id
		
		Const floor_num:Int = 3								'The total number of types of floors
		Global floors:TFloor[] = New TFloor[floor_num]		'An array that holds the different types of floors
		Global draw_list:TList = CreateList()				'A list that holds every tile to be drawn
		Global map:TTile[,] = New TTile[xMap, yMap]			'The 2-dimensional map array
		
		Const texture_num:Int = 2	'Number of textures in the Textures directory
		
		
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'SCROLLING VARIABLES
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		Global xScroll:Int = 0		'x coordinate of pixel for scrolling
		Global yScroll:Int = 0		'y coordinate of pixel for scrolling
		
		
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'PROGRAM FLOW VARIABLES
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		Global title:Int = True		'If TRUE, display the title screen
		Global mainProgram:Int = False			'If TRUE, execute main editor code
		
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'TOOLBAR VARIABLES
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		Global passableToggle:Int = False

''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'TYPES
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		
		
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'Tile Type
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		Type TTile
			
			Field my_floor:TFloor	 'the floor on a particular tile (e.g. grass, snow, etc.)
			Field my_feature:TFeature'the feature on a particular tile (e.g. rocks, trees, pillars, etc.)
			Field x:Int		'x coordinate of tile in the array
			Field y:Int		'y coordinate of tile in the array
			Field passable:Int 'True if characters can go through it (i.e. grass, stairs, etc.), False if characters cannot pass through it (i.e. pillars, rocks, etc.)
			Field occupants:TList = CreateList()	'A list of objects on the tile
			
			
			'This method will draw an individual tile, starting with the floor of the tile, and then placing any features on the tile
			Method Draw()
				
				my_floor.Draw(x, y)		'Draw the floor on this tile
				
				'my_feature.Draw(x, y, featureImage)	'Draw the features on this tile
				
				
			End Method
			
			
			'This function will clear the drawing queue, cycle through the map array and determine what tiles are currently visible,
			'and then add the visible tiles to the drawing queue
			Function UpdateTiles()
				
				
				draw_list.Clear() 'reset the drawing list
				For Local y:Int = 0 To (yMap - 1)		'For every tile
					For Local x:Int = 0 To (xMap - 1)
						If visible(x,y)		'If the tile is visible, then add it to the end of the list so the tiles in the foreground are drawn last
							ListAddLast(draw_list:TList, map[x,y])
						End If
						
						
						If MouseDown(1)	'If left clicking, grab the mouse's location, and create a tile of the last known specifications.
							x = pixel_to_tile_x(MouseX())
							y = pixel_to_tile_y(MouseY())
							map[x, y] = TTile.Create(x, y, curr_id, passableToggle)
							
						ElseIf MouseDown(2)	'If right clicking, grab the mouse's location, and prompt user to edit the tile
							x = pixel_to_tile_x(MouseX())
							y = pixel_to_tile_y(MouseY())
							map[x, y].Edit(x, y)
						EndIf
			
					Next
				Next
				
			End Function
			
			
			
			'This function will take all tiles in the drawing queue and draw them
			Function DrawTiles()
			
				'Draw the tiles
				For Local tile:TTile = EachIn draw_list
					tile.Draw()
				Next
			
				'Draws a black border around the visible tiles
				SetColor(0, 0, 0)
				DrawRect(0, 0, xRes + screenOffset * 2, screenOffset)
				DrawRect(0, 0, screenOffset, yRes + screenOffset*2)
				DrawRect(xRes + screenOffset, screenOffset, screenOffset, yRes + screenOffset)
				DrawRect(screenOffset, yRes + screenOffset, xRes + screenOffset, screenOffset)
				SetColor(255, 255, 255)
			
				
				
			End Function
			
			
			'This function will create a tile at the specified coordinates, initialize it, give it a floor, and return the tile
			Function Create:TTile(x:Int, y:Int, floor_id:Int, passableToggle:Int)
			
				Local tile:TTile = New TTile
				tile.x = x
				tile.y = y
				tile.my_floor = floors[floor_id]
				tile.passable = passableToggle
				
				Return tile
				
			End Function
			
			'This function will prompt the user with some editing options
			Function Edit:TTile(x:Int, y:Int)
				
				'PROMPT USER WITH TILE OPTIONS
				While (Not KeyDown(KEY_ENTER))
					Local mousePressed:Int = False
					
					Cls
					
					'Set up the message box
					SetColor(120, 120, 120)	'Dark gray
					DrawRect(262, 234, 500, 56)
					SetColor(255, 255, 255)
					DrawText("Do you want a texture tile?", 381, 234)
					
					'Draw 'Yes' and 'No' buttons
					SetColor(0, 0, 0)
					DrawRect(442, 260, 40, 20)
					DrawRect(492, 260, 40, 20)
					SetColor(255, 255, 255)
					DrawText("Yes", 452, 265)
					DrawText("No", 502, 265)
					
					
					'This variable gives the program time to check to see if 'Yes' or 'No' was clicked
					If MouseHit(1)
						mousePressed = True
						FlushMouse()
					End If
					
					'If the user clicks within this bounding box, user selects 'Yes' and selects a texture tile
					If mousePressed And MouseX() >= 442 And MouseX() <= 482 And MouseY() <= 296 And MouseY() >= 244
						FlushMouse()
						Setup_Texture(x, y)
						Exit
					'If the user clicks within this bounding box, user selects 'No' and selects an RGB tile
					ElseIf mousePressed And MouseX() >= 492 And MouseX() <= 532 And MouseY() <= 296 And MouseY() >= 244
						FlushMouse()
						Setup_RGB(x, y)
						Exit
					EndIf
					
					Flip
					
				Wend
				
			EndFunction
			
		
		End Type
		
		
		
		
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'Floor Type
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		Type TFloor
			
			Field r:Int		'red value for RGB tile
			Field g:Int		'green value for RGB tile
			Field b:Int		'blue value for RGB tile
			Field texture:String 'The name of the texture to be used
			Field texture_img:TImage 'The image to be used for the texture
			
			
			'This method will draw a rectangle of the specified size and give it a color (RGB value)
			Method Draw(x:Int, y:Int)
				
				If texture = Null
					SetColor(r, g, b)
					DrawRect (tile_to_pixel_x(x), tile_to_pixel_y(y), tileSize, tileSize)
				Else
					DrawImage(texture_img, tile_to_pixel_x(x), tile_to_pixel_y(y))
				EndIf
				
			End Method
			
			
			'This function will create a floor with the specified RGB value and name
			Function Create:TFloor(r:Int, g:Int, b:Int, texture:String, texture_img:TImage)
				
				Local a_floor:TFloor = New TFloor
				a_floor.r = r
				a_floor.g = g
				a_floor.b = b
				a_floor.texture = texture
				a_floor.texture_img = texture_img
				
				Return a_floor
				
			End Function
			
		End Type
		
		
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'Feature Type
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		Type TFeature
			
			Field featureImage:TImage
		
			'Draws the feature over a tile or floor
			Method Draw(x:Int, y:Int, featureImage:TImage)
				
				DrawImage(featureImage, tile_to_pixel_x(x), tile_to_pixel_y(y))
				
			End Method
			
			'Function creates a feature on a particular tile
			Function Create:TFeature(featureImage:TImage)
				
				Local a_feature:TFeature = New TFeature
				
				a_feature.featureImage = featureImage
				
				Return a_feature
				
			End Function
		
		End Type
		
	


''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'MAIN LOOP
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

While Not KeyDown(KEY_ESCAPE)	'Press Esc to exit

Cls 						'Clear the screen

CheckInput()					'Check for user input

If title

		
EndIf


If mainProgram

	TTile.UpdateTiles()	'update tiles
	TTile.DrawTiles()	'draw tiles
	
EndIf

Delay 10		'Wait 1/10 of a second

Flip			'Flip the buffers

Wend			'END OF MAIN LOOP





''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'FUNCTIONS
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'Function NewMap()
		'Parameters: None
		'Returns: Nothing
		'Prompts user for the map dimensions, tile dimensions
		'Creates a map of the defined dimensions
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		Function NewMap()
			
			'This block creates a tile that corresponds to its id tag and stores it in the floors array
			floors[blank_id] = TFloor.Create(255, 250, 250, Null, Null)
			floors[rgb_id] = TFloor.Create(100, 100, 100, Null, Null)
			floors[texture_id] = TFloor.Create(255, 0, 0, Null, Null)
			
			FlushKeys()		'clear any extraneous input
			
			'Cycle through 2D map array and create blank tiles
			For Local x:Int = 0 To (xMap - 1) 
				For Local y:Int = 0 To (yMap - 1)
					'Give each tile a white floor
					map[x, y] = TTile.Create(x, y, blank_id, passableToggle)
				Next
			Next
			
			'Change program flow from title menu to main program
			title = 0
			mainProgram = 1
			
		End Function
		
		
		
		
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'Function SaveMap()
		'Parameters: None
		'Returns: Nothing
		'Function cycles through the 2D Map Array created, and dumps
		'the tile information (map dimensions, type of tile) into
		'a text file so it can be read back when calling LoadMap()
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		Function SaveMap()
			
		End Function
		
		
		
		
		
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'Function LoadMap()
		'Parameters: None
		'Returns: Nothing
		'Function should be run at start-up of program.  It loads 
		'the floors array with floor types, and then places the floors
		'in the appropriate locations in the map.
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		Function LoadMap()
			
		End Function
		
		
		
		
		
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'Function tile_to_pixel_x
		'Parameters: x is the horizontal coordinate of tile in map array
		'Returns: The x coordinate of the pixel where the tile will be placed
		'Takes x location in array and returns its x coordinate (pixel)
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

		Function tile_to_pixel_x:Int(x:Int)
			Return screenOffset + (tileSize*x) - xScroll
		End Function
		
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'Function tile_to_pixel_y
		'Parameters: y is the vertical coordinate of tile in map array
		'Returns: The x coordinate of the pixel where the tile will be placed
		'Takes y location in array and returns its y coordinate (pixel)
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

		Function tile_to_pixel_y:Int(y:Int)
			Return screenOffset + (tileSize*y) - yScroll
		End Function
		
		
	
		
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'Function pixel_to_tile_x
		'Parameters: A pixel x coordinate
		'Returns: The tile number at that x coordinate
		'Takes a pixel and reports that the tile is there.
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

		Function pixel_to_tile_x:Int(pixel:Int)
			Return (pixel:Int - screenOffset:Int + xScroll:Int) / tileSize:Int
		End Function
		
		
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'Function pixel_to_tile_y
		'Parameters: A pixel y coordinate
		'Returns: The tile number at that y coordinate
		'Takes a pixel and reports that the tile is there.
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

		Function pixel_to_tile_y:Int(pixel:Int)
			Return (pixel:Int - screenOffset:Int + yScroll:Int) / tileSize:Int
		End Function
		
		
		
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'Function visible
		'Parameters: The tile's x, y coordinates
		'Returns: 0 if false, 1 if true
		'Checks if the tile at x, y is visible or not
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

		Function visible:Int(x:Int, y:Int)
			Local x_pixel:Int = tile_to_pixel_x(x)
			Local y_pixel:Int = tile_to_pixel_y(y)
			Return (x_pixel + tileSize) >= screenOffset And (x_pixel - tileSize) <= xRes And (y_pixel + tileSize) >= screenOffset And (y_pixel - tileSize) <= yRes 
		End Function

		

		
		
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'Function CheckInput()
		'Parameters: NONE
		'Returns: NONE
		'Checks for user input
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

		Function CheckInput()
		
			'Keyboard shortcuts
			If (KeyDown(KEY_LCONTROL) Or KeyDown(KEY_RCONTROL)) And KeyHit(KEY_N) Then NewMap()
			If (KeyDown(KEY_LCONTROL) Or KeyDown(KEY_RCONTROL)) And KeyHit(KEY_L) Then LoadMap()
			If (KeyDown(KEY_LCONTROL) Or KeyDown(KEY_RCONTROL)) And KeyHit(KEY_S) Then SaveMap()
			If (KeyDown(KEY_LCONTROL) Or KeyDown(KEY_RCONTROL)) And KeyHit(KEY_P) Then MakePassable()
			
			'Use to scroll around
			If KeyDown(KEY_LEFT) Then xScroll :- 5
			If KeyDown(KEY_RIGHT) Then xScroll :+ 5
			If KeyDown(KEY_UP) Then yScroll :- 5 
			If KeyDown(KEY_DOWN) Then yScroll:+5
			
		End Function
		
		
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'Function MakePassable()
		'Parameters: NONE
		'Returns: NONE
		'Makes a tile passable if the tile is clicked
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

		Function MakePassable()
		
			'Toggle the passableToggle variable
			If passableToggle = False
				passableToggle = True
			ElseIf passableToggle = True
				passableToggle = False
			EndIf
			
		End Function
		
		
		
		
		
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'Function Setup_Texture(x:Int, y:Int)
		'Parameters: x and y coordinates of the tile in the array
		'Returns: NONE
		'Prompts user to setup a texture tile
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''	
		Function Setup_Texture(x:Int, y:Int)
			Local Char:Int				'This variable will catch the user input character codes
			Local inputNum:String		'This variable will be used to collect the user input in a string
			Global textures:TFloor[] = New TFloor[texture_num]		'An array that holds the different types of textures
			Local texture_file_name:String = Null	'Name of the current texture image file under consideration
			Local dir:Int = ReadDir(AppDir + "\Textures")	'Textures directory
			Local texture_x:Int = (tileSize / 2)	'x-coordinate of displayed texture
			Local texture_y:Int = 24 + (tileSize / 2)'y-coordinate of displayed texture
			
			'Load the textures from the Textures directory
			For Local i:Int = 0 To (texture_num - 1)
				texture_file_name = NextFile(dir)
				Local texture_img:TImage = LoadImage(texture_file_name)
				textures[i] = TFloor.Create(255, 255, 255, texture_file_name, texture_img)
				texture_file_name = Null
			Next

			'IF THE USER WANTS A TEXTURE TILE, PROMPT THEM TO PICK A TEXTURE
						While Not KeyHit(KEY_ENTER)
							
							Cls
							
							SetColor(255, 255, 255)
							DrawText("Please choose the number of the texture (0 to " + (texture_num - 1) + "): " + inputNum, 0, 0)
							DrawText("Press ENTER when done, BACKSPACE to clear input.", 0, 12)
							Char = GetChar()
							If Char >= 48 And Char <= 57	'As long as it's a number 0 - 9, accept input into string
								inputNum :+ Chr(Char)
							ElseIf Char = 8					'If user hits BACKSPACE, clear the input
								inputNum = Null
							EndIf
							
							'Draw the textures in the texture array
							For Local j:Int = 0 To (texture_num - 1)
								textures[j].Draw(texture_x, texture_y)
								texture_x:+tileSize	'Move the next texture over to prevent overlap
								'Wrap the texture images to remain on the screen
								If texture_x > (1024 - (tileSize / 2))
									texture_x = (tileSize / 2)
									texture_y:+tileSize
								EndIf
							Next
							
							Flip
							
						WEnd
						
						'Cast the input from string to int, create the tile, reset input
							floors[texture_id] = textures[Int(inputNum)]	'Load this texture into the floors array
							map[x, y] = TTile.Create(x, y, Int(inputNum), passableToggle)
							curr_id = texture_id 'set current floor_id
							FlushKeys()
							inputNum = Null
		End Function
		
		
		
		
		
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'Function Setup_RGB(x:Int, y:Int)
		'Parameters: x and y coordinates of the tile in the array
		'Returns: NONE
		'Prompts user to setup a RGB tile
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''	
		Function Setup_RGB(x:Int, y:Int)
				
				Local Char:Int				'This variable will catch the user input character codes
				Local inputNum:String		'This variable will be used to collect the user input in a string
				Local rValue:Int
				Local gValue:Int
				Local bValue:Int
				Local Cycle:Int = 0	'This variable keeps track of what value you are editing (R = 0, G = 1, or B = 2)
				Local createTile:Int = False 'This variable is used in a button to create the tile as it is
				


			'IF THE USER WANTS AN RGB TILE, PROMPT THEM FOR THE RGB VALUES
					While createTile = False
					
						While Cycle = 0
						'THIS LOOP TAKES THE R VALUE
							Cls
							
							'Boxes
							SetColor(120, 120, 120)	'Dark gray
							DrawRect(262, 234, 500, 68)	'Main message box
							DrawRect(550, 352, 100, 14)	'Create Tile button
							SetColor(255, 255, 255)
							
							'Text to be displayed on screen
							DrawText("Preview:", 400, 350)
							DrawText("R: " + rValue + " G: " + gValue + " B: " + bValue, 400, 400)
							DrawText("Create Tile", 556, 352)
							DrawText("Enter R value for RGB tile: " + inputNum, 262, 234)
							DrawText("OR Press UP/DOWN arrows to increment/decrement R preview.", 262, 246)
							DrawText("Press ENTER when done, BACKSPACE to clear input.", 262, 258)
							DrawText("Press LEFT/RIGHT arrows to cycle through R, G, B settings.", 262, 270)
							
							Cycle = Update_Menu_Cycle(Cycle, 0, 2)'Check to see if user scrolls between R, G, B
							Draw_Preview_RGB(480, 350 - (tileSize / 2), rValue, gValue, bValue)	'Draw the preview tile
							rValue = Update_Preview_RGB(rValue)	'Check to see if adjustments were made to the preview tile
							
							
							'Check to see if Create Tile button was pressed.
							If MouseHit(1) And MouseX() <= 650 And MouseX() >= 550 And MouseY() >= 352 And MouseY() <= 366
								FlushMouse()
								createTile = True
								Exit
							EndIf
							 
							'Grab user input
							Char = GetChar()
							If Char >= 48 And Char <= 57	'As long as it's a number 0 - 9, accept input into string
								inputNum :+ Chr(Char)
							ElseIf Char = 8					'If user hits BACKSPACE, clear the input
								inputNum = Null
							EndIf
						
							Flip
							
						Wend
						
						FlushKeys()
						
						'Store input, reset input
						If Not (inputNum = Null)
							rValue = Int(inputNum)
							FlushKeys()
							inputNum = Null
						EndIf
						
						While Cycle = 1
						'THIS LOOP TAKES THE G VALUE
							Cls
							
							'Boxes
							SetColor(120, 120, 120)	'Dark gray
							DrawRect(262, 234, 500, 68)	'Main message box
							DrawRect(550, 352, 100, 14)	'Create Tile button
							SetColor(255, 255, 255)
							
							'Text to be displayed on screen
							DrawText("Preview:", 400, 350)
							DrawText("R: " + rValue + " G: " + gValue + " B: " + bValue, 400, 400)
							DrawText("Create Tile", 556, 352)
							DrawText("Enter G value for RGB tile: " + inputNum, 262, 234)
							DrawText("OR Press UP/DOWN arrows to increment/decrement G preview.", 262, 246)
							DrawText("Press ENTER when done, BACKSPACE to clear input.", 262, 258)
							DrawText("Press LEFT/RIGHT arrows to cycle through R, G, B settings.", 262, 270)
							
							Cycle = Update_Menu_Cycle(Cycle, 0, 2)'Check to see if user scrolls between R, G, B
							Draw_Preview_RGB(480, 350 - (tileSize / 2), rValue, gValue, bValue)	'Draw the preview tile
							gValue = Update_Preview_RGB(gValue)	'Check to see if adjustments were made to the preview tile
							
							
							'Check to see if Create Tile button was pressed.
							If MouseHit(1) And MouseX() <= 650 And MouseX() >= 550 And MouseY() >= 352 And MouseY() <= 366
								FlushMouse()
								createTile = True
								Exit
							EndIf
							 
							'Grab user input
							Char = GetChar()
							If Char >= 48 And Char <= 57	'As long as it's a number 0 - 9, accept input into string
								inputNum :+ Chr(Char)
							ElseIf Char = 8					'If user hits BACKSPACE, clear the input
								inputNum = Null
							EndIf
						
							Flip
							
						Wend
						
						FlushKeys()
						
						'Store input, reset input
						If Not (inputNum = Null)
							gValue = Int(inputNum)
							FlushKeys()
							inputNum = Null
						EndIf
						
						While Cycle = 2
						'THIS LOOP TAKES THE B VALUE
							Cls
							
							'Boxes
							SetColor(120, 120, 120)	'Dark gray
							DrawRect(262, 234, 500, 68)	'Main message box
							DrawRect(550, 352, 100, 14)	'Create Tile button
							SetColor(255, 255, 255)
							
							'Text to be displayed on screen
							DrawText("Preview:", 400, 350)
							DrawText("R: " + rValue + " G: " + gValue + " B: " + bValue, 400, 400)
							DrawText("Create Tile", 556, 352)
							DrawText("Enter B value for RGB tile: " + inputNum, 262, 234)
							DrawText("OR Press UP/DOWN arrows to increment/decrement B preview.", 262, 246)
							DrawText("Press ENTER when done, BACKSPACE to clear input.", 262, 258)
							DrawText("Press LEFT/RIGHT arrows to cycle through R, G, B settings.", 262, 270)
							
							Cycle = Update_Menu_Cycle(Cycle, 0, 2)'Check to see if user scrolls between R, G, B
							Draw_Preview_RGB(480, 350 - (tileSize / 2), rValue, gValue, bValue)	'Draw the preview tile
							bValue = Update_Preview_RGB(bValue)	'Check to see if adjustments were made to the preview tile
							
							'Check to see if Create Tile button was pressed.
							If MouseHit(1) And MouseX() <= 650 And MouseX() >= 550 And MouseY() >= 352 And MouseY() <= 366
								FlushMouse()
								createTile = True
								Exit
							EndIf
							 
							'Grab user input
							Char = GetChar()
							If Char >= 48 And Char <= 57	'As long as it's a number 0 - 9, accept input into string
								inputNum :+ Chr(Char)
							ElseIf Char = 8					'If user hits BACKSPACE, clear the input
								inputNum = Null
							EndIf
						
							Flip
							
						Wend
						
						FlushKeys()
						
						'Store input, reset input, create tile
						If Not (inputNum = Null)
							bValue = Int(inputNum)
							FlushKeys()
							inputNum = Null
						EndIf
					Wend
					
					FlushKeys()
					
					'Once createTile gets set to TRUE from user pressing the "Create Tile" button, create the tile.
					If createTile = True
						'CREATE THE TILE HERE
						floors[rgb_id] = TFloor.Create(rValue, gValue, bValue, Null, Null)
						map[x, y] = TTile.Create(x, y, rgb_id, passableToggle)
						curr_id = rgb_id		'Set the current floor_id
					EndIf
					
					
		End Function
		
		
		
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'Function Draw_Preview_RGB(x:Int, y:Int, rValue:Int, gValue:Int, bValue:Int))
		'Parameters: x, y (coordinates of the preview tile)
		'			rValue, gValue, bValue (RGB values of current tile)
		'Returns: NONE
		'Draws a tile that displays the current RGB value selected
		'for an RGB tile and allows user to adjust the colors
		'using the arrow keys.
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		Function Draw_Preview_RGB(x:Int, y:Int, rValue:Int, gValue:Int, bValue:Int)
			
			SetColor(rValue, gValue, bValue)
			DrawRect(x:Int, y:Int, tileSize:Int, tileSize:Int)
			SetColor(255, 255, 255)
			
		End Function
		
		
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'Function Update_Preview_RGB(currValue:Int)
		'Parameters: currValue (either R, G, or B value that is being adjusted)
		'Returns: currValue
		'Increments/decrements R,G, or B value if UP/DOWN arrows pressed
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		Function Update_Preview_RGB:Int(currValue:Int)
			
			'If user presses UP/DOWN arrows, increment/decrement currValue
			If KeyDown(KEY_UP)
				currValue:+1
			ElseIf KeyDown(KEY_DOWN)
				currValue:-1
			End If
			
			'Keep R, G, B values between 0 and 255
			If currValue > 255
				currValue = 255
			ElseIf currValue < 0
				currValue = 0
			End If
			
			Return currValue
			
		End Function
		
		
		
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		'Function Update_Menu_Cycle(cycleVar:Int, min:Int, max:Int)
		'Parameters: cycleVar, min, max
		'Returns: cycleVar
		'Cycles through menu
		''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		Function Update_Menu_Cycle:Int(cycleVar:Int, cycleMin:Int, cycleMax:Int)
				
				'This block of code checks input and cycles through menu
				If KeyDown(KEY_RIGHT)
					cycleVar:+1
					FlushKeys()
				ElseIf KeyDown(KEY_LEFT)
					cycleVar:-1
					FlushKeys()
				EndIf
				
				'Bound cycle between min and max
				If cycleVar > cycleMax
					cycleVar = cycleMin
				ElseIf cycleVar < cycleMin
					cycleVar = cycleMax
				End If
				
				Return cycleVar
				
		End Function

Controls for the program:

CTRL + N will create a new map. Do this first.
Right click any blank (white) tile to edit it. (Clicking "Yes" will go on to crash the program as it stands. Clicking "no" will allow you to define an RGB tile.)
Once you've created a tile (at this point you can only create RGB tiles), you will be returned to the map, and if you left click, you will create a tile that is the same as the last one you created.

Even if you can't or don't want to track down this problem, I am open to suggestions/comments about my code. This is my second BlitzMax program, and my first attempt at creating a tool to be used in a later game, so please, don't be too harsh :)

-muffins

Jesse

(Posted 2010) [#11]

your main problem is with reading the directory. when you get a chance, make a program that display the contents of a directory. you will see that you get a file name: "." and another one: "..". Those are trace back directories to the parent directory. you can use them to change directories with the ChangeDir command. it will take you to the parent directory. figure out a way to ignore them and your problem will be solved.

[edit]

I forgot to mention that you need to move the directory pointer using"ChangeDir" to the "Textures" dir before you can actually read the files in it.

abelian_grape

(Posted 2010) [#12]

Isn't the directory pointer already at the "Textures" dir?

Local dir:Int = ReadDir(AppDir + "/Textures")	'Textures directory

I think I figured out how to bypass the "." and "..":

For Local i:Int = 0 To (texture_num - 1)
				texture_file_name = NextFile(dir)
				If texture_file_name = "" Exit
				If texture_file_name = "." Or ".."
					texture_file_name = NextFile(dir)
				Else
					Local texture_img:TImage = LoadImage(texture_file_name)
					textures[i] = TFloor.Create(255, 255, 255, texture_file_name, texture_img)
				EndIf
				
			Next

I still get the same error message though. My program is definitely reading in the correct names for the texture_file_name, so I'm not sure why it's still a Null object.

Jesse

(Posted 2010) [#13]

Isn't the directory pointer already at the "Textures" dir?

No. you are just telling it to read the names from the specific directory.
and all you get are a bunch of name not pointing to anything and sense the directory pointer is currently pointing to the "appDir" because that is where it point when the application starts, it will never find any images. you can access them directly like this:

  
LoadImage(AppDir+"\Textures\"+texture_file_name)

or change directory:

ChangeDir(AppDir+"\Textures")

then do all of the ReadDir and load files with out having to do as in the previous example.
if you change directory to the "Textures" directory you won't need to add "AppDir" or "\Textures\" for the "LoadImage" Command.

abelian_grape

(Posted 2010) [#14]

Okay, I definitely understand the error I was making between using ReadDir and needing ChangeDir unless I wanted to modify the directory LoadImage was loading from. I really didn't understand how the filesystem was working. I initially thought that ReadDir was performing the same task that ChangeDir actually does.

As a check for debugging purposes, I made the console print out the names of the files that its reading. For some reason, it skips over the ".." but not the "." as the "." gets printed first every time, and then my first texture gets printed. The second texture file name doesn't get printed, and I assume the program is crashing because it can't create a tile with the "." because that is not an image, and therefore it can't load it.

ChangeDir(AppDir + "/Textures")
Local texture_file_name:String = Null	'Name of the current texture image file under consideration
Local dir:Int = ReadDir(AppDir + "/Textures")	'Textures directory
		
'Load the textures from the Textures directory
For Local i:Int = 0 To (texture_num - 1)
        texture_file_name = NextFile(dir)
	Print texture_file_name
	If (texture_file_name = ".") Or (texture_file_name = "..")
		texture_file_name = NextFile(dir)
	Else
		Local texture_img:TImage = LoadImage(texture_file_name)
		textures[i] = TFloor.Create(255, 255, 255, texture_file_name, texture_img)
	EndIf
Next
			
CloseDir(dir)

ima747

(Posted 2010) [#15]

late to this conversation, but just a side note, if you're doing dynamic loading it's usually a good idea to confirm that the load worked before doing anything with the result. e.g.

local anImage:TImage = LoadImage(a_var_path)
if(anImage) ' ensure that the image loaded
	'do stuff with the image
end if

LoadImage should return null if the load fails unless I'm miss-remembering the docs...

Czar Flavius

(Posted 2010) [#16]

I just load all images with a function that checks for me so I never forget.

Function safe_image_load:TImage(path:String, animation, width = 0, height = 0, first = 0, count = 0, flags = -1)
	Local image:TImage
	If animation
		image = LoadAnimImage(path, width, height, first, count, flags)
	Else
		image = LoadImage(path, flags)
	End If
	If Not image
		RuntimeError "Cannot find " + path
	End If
	Return image
End Function

Jesse

(Posted 2010) [#17]

For some reason, it skips over the ".." but not the "." as the "." gets printed first every time, and then my first texture gets printed. The second texture file name doesn't get printed, and I assume the program is crashing because it can't create a tile with the "."

Really simple. The first nextFile() you print but the seconde one inside the if statement you are not printing it so when you get back to the next loop you nextFile() it again and is why you never get to see the second one.

abelian_grape

(Posted 2010) [#18]

Alright, I made the correction, so now it prints "." and "..". I think the problem still remains that it's not actually skipping over the "." and ".." like I had hoped. But if that were true, I'm not sure why it's even making it to printing out "grass.bmp", since I defined texture_num = 2 as a Const, and the loop is going from 0 to (texture_num - 1). It's not printing out the actual second texture which I'm calling "water.bmp".

I am so frustrated with this I might just hard code everything into the program, because at this point, I think the map editor has taken up more time than it should have since it was supposed to expedite the game-making process :[

Edit:
Well let me ask this. I have my textures array as a global array of TFloor objects. TFloor is a type I have defined. My program is claiming that it is attempting to access a Null method or object, and pointing to the line

DrawImage(textures[0].texture_img, texture_x, texture_y).

Now, what is living at index 0 of textures is a TFloor object that was initialized in this line:

textures[i] = TFloor.Create(255, 255, 255, texture_file_name, texture_img)

In which it was given r, g, b values for a base color, a name, and an image loaded into the texture_img field. Could it be that since my textures array is an array of TFloors, that it is trying to access a field of the textures array and not the field of the TFloor object at that index in the array? Is it treating the textures array as a type with its own fields?

Czar Flavius

(Posted 2010) [#19]

It might be easier to define your floors (and a list of their paths) in a text file which you load rather than trying to "find" them in the folder. It gives you the flexibility without the headache.

	If (texture_file_name = ".") Or (texture_file_name = "..")
		texture_file_name = NextFile(dir)
	Else
		Local texture_img:TImage = LoadImage(texture_file_name)
		textures[i] = TFloor.Create(255, 255, 255, texture_file_name, texture_img)
	EndIf

If the file is . or .., it won't do the else and will skip to the next i. Try something like While texture_file_name = "." Or texture_file_name = ".." texture_file_name = NextFile(dir)

abelian_grape

(Posted 2010) [#20]

Well the way I figure, if I have to create a separate text file in which I define the floors and reference their paths, then I am just as well off hard-coding them into the .bmx file, and then modifying the .bmx file with the appropriate file names each time I modify the contents of the Textures folder. Because if I made the text file with this information, all the text file is doing is loading everything, where I could do the same thing with some copying and pasting. The dynamic file "finding" and loading seemed to be more of a time saver because then I didn't have to record any changes I made anywhere, but it's looking like this is beyond me.

Jesse

(Posted 2010) [#21]

i did a lazy test like this:

			For Local i:Int = 0 To (texture_num - 1)
				Repeat
					texture_file_name = NextFile(dir)
				Until texture_file_name <> "." And texture_file_name <> ".."
				Local texture_img:TImage = LoadImage(AppDir + "\Textures\"+texture_file_name)
				If texture_img = Null Print "texture image = Null " End
				textures[i] = TFloor.Create(255, 255, 255, texture_file_name, texture_img)
				texture_file_name = Null
			Next

and it works fine.

Czar Flavius

(Posted 2010) [#22]

The only reason you softcode anything is to allow the user to mod your program or it's the biggest time saver just to hardcore it :D