types

When i uses types i always do something like this...

enemy.enemy = new enemy

but i see people do this...

enemy.ship = New ship

what does it do? could somebody give an example?

I have the same question... I always got frustrated in types because I didn't get this:
a.b = ab
What does ab stand for?
or
r.t = qwerty
What does qwerty stand for?

"enemy.ship" is a "variable" who can be local or global from your Type "ship".

So, you can make different "variables" as "car.ship" or "jumper.ship", etc.

"enemy.ship"
>"ship" is the parent variable of Type "ship".
>"enemy" is the child variable of Type "ship".

I hope I didn't say bad things...

-_'

Yeah... types can be pretty confusing if you are new to programming. Think of it like this. If you write "a.b = new b" then a is a variable just like any other. But, variables also come in different formats. For example, string variables hold letters and numbers while "normal" variables only hold numbers. Each "type" that you define basically creates a whole different format of variable, and just like you would add a $ to make a variable hold a string, you have to add the ".b" to make the variable "a" hold data of that format. But now comes the interesting part. As you probably noticed, the whole point of types is to allow you to store more than one variable into a single container variable, and the each type holds different variables than every other type. This is why you have to add the .typename or ".b" in my example to the end of each variable when you first declare it.

Now for the (even more) confusing part. The variables that you declare as .typename aren't really holding the data that you access when you use the \ to access the subvariables. The subvariables are actually being held somewhere in blitz's memory. That variable "a" only tells you where you can find those subvariables in memmory. This means that you can change the contents of the variable "a" without destroying the data which it points to. However, unless you store the place it points to into another variable declared with the same ".typename" suffix (like "a.b =c.b"), you can't get back to it (for the most part). Blitz does keep track of the times that you use the "new" statement to actually create a set of subvariables for "a" to point to. You can access this list the the "for a.b = each b" line of code that you might have seen elsewhere.

I hope that this clears a few things up for you... sorry if it just makes things worse.

i think i understand. sorta. Im making an RTS. If i want to create diffrent types of buildings do i do this?

castle.building = new building
farm.building = new building
barracks.building = new building
tower.building = new building
etc.

That depends. What do you mean by "types of buildings"? Do you want each different building to hold different data than the other ones, or do you want the different buildings to hold different data formats? Put a little bit simpler, do you want your subvariables to be all the same (so each subvariable might still hold different numbers). For example, do you want all of the buildings to have a "peasantnumber" variable, or do you just want to have castle.building variable named "peasantnumber". Also, you need to declare the type before you can use it. So, if you are just using a single type, you would need something like this in your code.

Type building
     Field price
     Field name$
     Field x
     Field y
     Field owner
End Type

Here's an example of what you can do with this type declaration. Hopefully it will clear a few things up, as well as give you some useful tricks.

Graphics 800,600,16,2
SetBuffer(BackBuffer())
SeedRnd(MilliSecs())

Type owner
	Field FirstName$
	Field LastName$
End Type

Type building
	Field price
	Field name$
	Field BuildingID
	Field x
	Field y
	Field owner.owner
End Type

castle.building = New building
farm.building = New building
barracks.building = New building
tower.building = New building

richguy.owner = New owner
	richguy\firstname="Richie"
	richguy\lastname="Rich"
	
castle\owner=richguy
farm\owner=richguy
barracks\owner=richguy
tower\owner=richguy

castle\name$="The king's home"
farm\name$="The peasant's home"
barracks\name$="The soldier's home"
tower\name$="The guard's home"

castle\buildingid=1
farm\buildingid=2
barracks\buildingid=3
tower\buildingid=4

For building.building = Each building
	building\x=Rand(GraphicsWidth())
	building\y=Rand(GraphicsHeight())
Next

Print "--------------------------Welcome to my Types example!--------------------------"

Print "The castle is located at address 0x" + Hex$(Int(castle))
Print "The farm is located at address 0x" + Hex$(Int(farm))
Print "The barracks is located at address 0x" + Hex$(Int(barracks))
Print "The tower is located at address 0x" + Hex$(Int(tower))
Print ""

For show.building = Each building
	Dumpinfo(show)
Next

While Not KeyDown(1)
	Cls
	drawbuildings()
	Flip
Wend

Function drawbuildings()
	For building.building = Each building
		Select building\buildingid
		Case 1
			disptext$="C"
		Case 2
			disptext$="F"
		Case 3
			disptext$="B"
		Case 4
			disptext$="T"
		Default
			disptext$="X"
		End Select
		Text building\x,building\y,disptext$
	Next
End Function

Function DumpInfo(dump.building)
	Print "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
	Print "Name: " + dump\name$
	Print "Address inside of the computer's memmory: 0x" + Hex$(Int(dump))
	Print "Building type: " + buildingwrapper$(dump\buildingid)
	Print "Owner: " + dump\owner\firstname + " " + dump\owner\lastname$
	Print "-------------------------------------------------------------------------------"
	Print ""
End Function

Function buildingwrapper$(buildingid)
	Select buildingid
	Case 1
		Return "Castle"
	Case 2
		Return "Farm"
	Case 3
		Return "Barracks"
	Case 4
		Return "Tower"
	Default
		Return "Unknown"
	End Select
End Function

Also, you could look at my Type Trouble query to help
you even more with types.

Just to add my two pee.

If you make for yourself a strong nameing ethic that you stick to then things like this become less of a hasstle.

For example All my "Types" are preceded with T, so

enemy.enemy = new enemy

would be

enemy.TEnemy = new TEnemy

If its going to be one of many (In a list for example)

AnEnemy.TEnemy = new TEnemy

etc
I could give more examples on how I name fields and the such, but the point is, pick a nameing the things policy that makes sence to you. And then stick with it.