Sorry your browser is not supported!

sync on
sync rate 20
autocam off

Rem PJY - this first behaviour moves the green cube to the white sphere
Rem PJY - its a very basic behaviour and so not appropriate for objects that are
Rem PJY - close together

TYPE vec
	
	x AS float
	y AS float
	z AS float
	
ENDTYPE

TYPE obj

	current_pos AS vec
	target_pos AS vec
	heading_vec AS vec
	desired_vec AS vec
	targ_vec AS vec
	side_vec AS vec
	velocity AS vec
	max_speed AS float
	max_force AS float
	targ_distance AS float
	mass AS integer
	max_force AS double integer
	max_turn_force AS double integer
	
ENDTYPE

dim ship(1) AS obj
ship(1).current_pos.x = -10
ship(1).current_pos.y = 5
ship(1).current_pos.z = -10
ship(1).velocity.x = 0
ship(1).velocity.y = 0
ship(1).velocity.z = 0
ship(1).max_speed = 10
ship(1).max_force = 15
ship(1).mass = 100
ship(1).target_pos.x = 400
ship(1).target_pos.y = 5
ship(1).target_pos.z = 400

Rem PJY - create a matrix to act as a reference point for the human eye
make matrix 1, 1000, 1000, 100, 100
position matrix 1, -500, 0, -500

Rem PJY - this green cube is going to be the hero of the piece. He's going to do all the seeking
make object cube 1, 10
position object 1, ship(1).current_pos.x, ship(1).current_pos.y, ship(1).current_pos.z
color object 1, rgb(0, 255, 0)

REm PJY - and he's going to be seeking towards this white sphere
make object sphere 2, 8
position object 2, ship(1).target_pos.x, ship(1).target_pos.y, ship(1).target_pos.z

Rem PJY - we'll just position the camera
position camera 0, ship(1).current_pos.x - 50, 100, ship(1).current_pos.z - 50
point camera 0, ship(1).current_pos.x, ship(1).current_pos.y, ship(1).current_pos.z

Rem PJY - and create a nice red cube to sit in the middle of the matrix, just to help give a sense of perspective
make object cube 3, 8
color object 3, rgb(255, 0, 0)

current_time = timer()

repeat

	position object 2, ship(1).target_pos.x, ship(1).target_pos.y, ship(1).target_pos.z

	Rem PJY - some nice info
	text 0, 0, "Current_pos : " + str$(ship(1).current_pos.x) + " " + str$(ship(1).current_pos.y) + " " + str$(ship(1).current_pos.z)
	text 0, 30, "targ: " + str$(ship(1).targ_vec.x) + " " + str$(ship(1).targ_vec.y) + " " + str$(ship(1).targ_vec.z)
	text 0, 60, "Velocity: " + str$(ship(1).velocity.x) + " " + str$(ship(1).velocity.y) + " " + str$(ship(1).velocity.z)
	
	Rem PJY - this calculates the steering force
	behaviour_seek(1)
	
	Rem PJY - update the time since the last loop
	last_time = current_time
	current_time = timer()
	time_elapsed# = current_time - last_time
	time_elapsed# = time_elapsed# * 0.01
	
	Rem PJY - now apply the steering force + the time elapsed to the green cube
	update_vehicle(time_elapsed#, 1)
	
	position object 1, ship(1).current_pos.x, ship(1).current_pos.y, ship(1).current_pos.z
	
	Rem PJY - keep camera aimed at the cube
	position camera 0, ship(1).current_pos.x - 50, ship(1).current_pos.y + 30, ship(1).current_pos.z - 40
	point camera 0, ship(1).current_pos.x, ship(1).current_pos.y, ship(1).current_pos.z
	
	Rem PJY - if the green cube gets within 2 of the white sphere, reposition the white sphere
	if ship(1).targ_distance < 2
	
		ship(1).target_pos.x = rnd(800) - 400  
		ship(1).target_pos.y = 5
		ship(1).target_pos.z = rnd(800) - 400
	
	endif
	
	sync
	
until spacekey() > 0


Rem PJY - clean up
for i = 1 to 100
	
	if matrix exist(i) = 1
		
		delete matrix i
		
	endif
	
	if object exist(i) = 1
		
		delete object i
		
	endif
	
next i




Rem PJY - function that updates the ship's behaviour

function behaviour_seek(obj_no AS integer)

	null = make vector3(1)
	null = make vector3(2)
	null = make vector3(3)
	
	Rem PJY - get the new vector to target
	set vector3 1, ship(obj_no).target_pos.x - ship(obj_no).current_pos.x, ship(obj_no).target_pos.y - ship(obj_no).current_pos.y, ship(obj_no).target_pos.z - ship(obj_no).current_pos.z
	
	Rem PJY - check its not further than the maximum speed of the cube
	ship(obj_no).targ_distance = length vector3(1)
	normalize vector3 1, 1
	multiply vector3 1, ship(obj_no).max_speed
	ship(obj_no).targ_vec.x = x vector3(1)
	ship(obj_no).targ_vec.y = y vector3(1)
	ship(obj_no).targ_vec.z = z vector3(1)
	
	Rem PJY - subtract desired velocity from current velocity
	set vector3 2, ship(obj_no).velocity.x, ship(obj_no).velocity.y, ship(obj_no).velocity.z
	subtract vector3 1, 1, 2

	ship(obj_no).desired_vec.x = x vector3(1)
	ship(obj_no).desired_vec.y = y vector3(1)
	ship(obj_no).desired_vec.z = z vector3(1)
	
	null = delete vector3(1)
	null = delete vector3(2)
	null = delete vector3(3)

endfunction



Rem PJY - function to update the vehicle's physics

function update_vehicle(time_elapsed AS float, obj_no AS integer)
	
	null = make vector3(1)
	null = make vector3(2)

	Rem PJY - first calculate that old favourite Newtonian equation
	Rem PJY - Force = Acceleration / Mass
	Rem PJY - and hence convert the steering force (the desired vector) into acceleration
	acceleration AS vec
	acceleration.x = ship(obj_no).desired_vec.x
	acceleration.y = ship(obj_no).desired_vec.y
	acceleration.z = ship(obj_no).desired_vec.z

	set vector3 1, acceleration.x, acceleration.y, acceleration.z
	divide vector3 1, ship(obj_no).mass	
	acceleration.x = x vector3(1)
	acceleration.y = y vector3(1)
	acceleration.z = z vector3(1)
	
	set vector3 1, acceleration.x, acceleration.y, acceleration.z
	multiply vector3 1, time_elapsed
	
	Rem PJY - now add the acceleration to the existing velocity
	ship(obj_no).velocity.x = ship(obj_no).velocity.x + x vector3(1)
	ship(obj_no).velocity.y = ship(obj_no).velocity.y + y vector3(1)
	ship(obj_no).velocity.z = ship(obj_no).velocity.z + z vector3(1)

	Rem PJY - but make sure the resulting velocity is not greater than the cube's maximum velocity
	set vector3 1, ship(obj_no).velocity.x, ship(obj_no).velocity.y, ship(obj_no).velocity.z
	length# = length vector3(1)
	if length# => ship(obj_no).max_speed
		
		normalize vector3 1, 1
		multiply vector3 1, ship(obj_no).max_speed
		
	endif
	ship(obj_no).velocity.x = x vector3(1)
	ship(obj_no).velocity.y = y vector3(1)
	ship(obj_no).velocity.z = z vector3(1)
	
	Rem PJY - now update the cube's position with the new velocity
	multiply vector3 1, time_elapsed
	
	ship(obj_no).current_pos.x = ship(obj_no).current_pos.x + x vector3(1)
	ship(obj_no).current_pos.y = ship(obj_no).current_pos.y + y vector3(1)
	ship(obj_no).current_pos.z = ship(obj_no).current_pos.z + z vector3(1)
	
	Rem PJY - create a new heading vector
	Rem PJY - none of the code below does anything for the seek behaviour, but is included
	Rem PJY - because you'll see it in later behaviours
	set vector3 1, ship(obj_no).velocity.x, ship(obj_no).velocity.y, ship(obj_no).velocity.z
	normalize vector3 1, 1
	ship(obj_no).heading_vec.x = x vector3(1)
	ship(obj_no).heading_vec.y = y vector3(1)
	ship(obj_no).heading_vec.z = z vector3(1)
	
	set vector3 2, 0, 0, 0
	cross product vector3 1, 1, 2
	ship(obj_no).side_vec.x = x vector3(1)
	ship(obj_no).side_vec.y = y vector3(1)
	ship(obj_no).side_vec.z = z vector3(1)
	
	null = delete vector3(1)
	null = delete vector3(2)
	
endfunction

sync on
sync rate 20
autocam off

Rem PJY - this second behaviour moves the green cube AWAY from the white sphere
Rem PJY - everytime the green cube gets too far away, its repositioned near the white sphere again

TYPE vec
	
	x AS float
	y AS float
	z AS float
	
ENDTYPE

TYPE obj

	current_pos AS vec
	target_pos AS vec
	heading_vec AS vec
	desired_vec AS vec
	targ_vec AS vec
	side_vec AS vec
	velocity AS vec
	max_speed AS float
	max_force AS float
	targ_distance AS float
	mass AS integer
	max_force AS double integer
	max_turn_force AS double integer
	
ENDTYPE

dim ship(1) AS obj
ship(1).current_pos.x = -10
ship(1).current_pos.y = 5
ship(1).current_pos.z = -10
ship(1).velocity.x = 0
ship(1).velocity.y = 0
ship(1).velocity.z = 0
ship(1).max_speed = 20
ship(1).max_force = 25
ship(1).mass = 50
ship(1).target_pos.x = 0
ship(1).target_pos.y = 5
ship(1).target_pos.z = 0

Rem PJY - create a matrix to act as a reference point for the human eye
make matrix 1, 1000, 1000, 100, 100
position matrix 1, -500, 0, -500

Rem PJY - all the same stuff as for seek
make object cube 1, 10
position object 1, ship(1).current_pos.x, ship(1).current_pos.y, ship(1).current_pos.z
color object 1, rgb(0, 255, 0)

make object sphere 2, 8
position object 2, ship(1).target_pos.x, ship(1).target_pos.y, ship(1).target_pos.z

position camera 0, ship(1).current_pos.x - 50, 100, ship(1).current_pos.z - 50
point camera 0, ship(1).current_pos.x, ship(1).current_pos.y, ship(1).current_pos.z

make object cube 3, 8
color object 3, rgb(255, 0, 0)

current_time = timer()

repeat

	Rem PJY - display some info
	text 0, 0, "Current_pos : " + str$(ship(1).current_pos.x) + " " + str$(ship(1).current_pos.y) + " " + str$(ship(1).current_pos.z)
	text 0, 30, "targ: " + str$(ship(1).targ_vec.x) + " " + str$(ship(1).targ_vec.y) + " " + str$(ship(1).targ_vec.z)
	text 0, 60, "Velocity: " + str$(ship(1).velocity.x) + " " + str$(ship(1).velocity.y) + " " + str$(ship(1).velocity.z)
	
	behaviour_flee(1)
	
	last_time = current_time
	current_time = timer()
	time_elapsed# = current_time - last_time
	time_elapsed# = time_elapsed# * 0.01
	
	update_vehicle(time_elapsed#, 1)
	
	position object 1, ship(1).current_pos.x, ship(1).current_pos.y, ship(1).current_pos.z
	
	Rem PJY - keep camera aimed at the cube
	position camera 0, ship(1).current_pos.x - 50, ship(1).current_pos.y + 30, ship(1).current_pos.z - 40
	point camera 0, ship(1).current_pos.x, ship(1).current_pos.y, ship(1).current_pos.z

	
	Rem PJY - if the green cube goes more than 500 away from the white sphere, reposition the green cube near the white sphere
	if ship(1).targ_distance > 500
			
		ship(1).current_pos.x = rnd(20) - 10
		ship(1).current_pos.y = 5
		ship(1).current_pos.z = rnd(20) - 10
		ship(1).velocity.x = 0
		ship(1).velocity.y = 0
		ship(1).velocity.z = 0
	
	endif
	
	sync
	
until spacekey() > 0


Rem PJY - clean up
for i = 1 to 100
	
	if matrix exist(i) = 1
		
		delete matrix i
		
	endif
	
	if object exist(i) = 1
		
		delete object i
		
	endif
	
next i




Rem PJY - function that updates the ship's behaviour

function behaviour_flee(obj_no AS integer)

	null = make vector3(1)
	null = make vector3(2)
	null = make vector3(3)
	
	Rem PJY - get the new vector away from target
	set vector3 1, ship(obj_no).current_pos.x - ship(obj_no).target_pos.x, ship(obj_no).current_pos.y - ship(obj_no).target_pos.y,  ship(obj_no).current_pos.z - ship(obj_no).target_pos.z
	
	Rem PJY - check its not further than the maximum speed of the cube
	ship(obj_no).targ_distance = length vector3(1)
	normalize vector3 1, 1
	multiply vector3 1, ship(obj_no).max_speed
	ship(obj_no).targ_vec.x = x vector3(1)
	ship(obj_no).targ_vec.y = y vector3(1)
	ship(obj_no).targ_vec.z = z vector3(1)
	
	Rem PJY - subtract desired velocity from current velocity
	set vector3 2, ship(obj_no).velocity.x, ship(obj_no).velocity.y, ship(obj_no).velocity.z
	subtract vector3 1, 1, 2

	ship(obj_no).desired_vec.x = x vector3(1)
	ship(obj_no).desired_vec.y = y vector3(1)
	ship(obj_no).desired_vec.z = z vector3(1)
	
	null = delete vector3(1)
	null = delete vector3(2)
	null = delete vector3(3)

endfunction



Rem PJY - function to update the vehicle's physics

function update_vehicle(time_elapsed AS float, obj_no AS integer)
	
	null = make vector3(1)
	null = make vector3(2)

	Rem PJY - first calculate that old favourite Newtonian equation
	Rem PJY - Force = Acceleration / Mass
	Rem PJY - and hence convert the steering force (the desired vector) into acceleration
	acceleration AS vec
	acceleration.x = ship(obj_no).desired_vec.x
	acceleration.y = ship(obj_no).desired_vec.y
	acceleration.z = ship(obj_no).desired_vec.z

	set vector3 1, acceleration.x, acceleration.y, acceleration.z
	divide vector3 1, ship(obj_no).mass	
	acceleration.x = x vector3(1)
	acceleration.y = y vector3(1)
	acceleration.z = z vector3(1)
	
	set vector3 1, acceleration.x, acceleration.y, acceleration.z
	multiply vector3 1, time_elapsed
	
	Rem PJY - now add the acceleration to the existing velocity
	ship(obj_no).velocity.x = ship(obj_no).velocity.x + x vector3(1)
	ship(obj_no).velocity.y = ship(obj_no).velocity.y + y vector3(1)
	ship(obj_no).velocity.z = ship(obj_no).velocity.z + z vector3(1)

	Rem PJY - but make sure the resulting velocity is not greater than the cube's maximum velocity
	set vector3 1, ship(obj_no).velocity.x, ship(obj_no).velocity.y, ship(obj_no).velocity.z
	length# = length vector3(1)
	if length# => ship(obj_no).max_speed
		
		normalize vector3 1, 1
		multiply vector3 1, ship(obj_no).max_speed
		
	endif
	ship(obj_no).velocity.x = x vector3(1)
	ship(obj_no).velocity.y = y vector3(1)
	ship(obj_no).velocity.z = z vector3(1)
	
	Rem PJY - now update the cube's position with the new velocity
	multiply vector3 1, time_elapsed
	
	ship(obj_no).current_pos.x = ship(obj_no).current_pos.x + x vector3(1)
	ship(obj_no).current_pos.y = ship(obj_no).current_pos.y + y vector3(1)
	ship(obj_no).current_pos.z = ship(obj_no).current_pos.z + z vector3(1)
	
	Rem PJY - create a new heading vector
	Rem PJY - none of the code below does anything for the seek behaviour, but is included
	Rem PJY - because you'll see it in later behaviours
	set vector3 1, ship(obj_no).velocity.x, ship(obj_no).velocity.y, ship(obj_no).velocity.z
	normalize vector3 1, 1
	ship(obj_no).heading_vec.x = x vector3(1)
	ship(obj_no).heading_vec.y = y vector3(1)
	ship(obj_no).heading_vec.z = z vector3(1)
	
	set vector3 2, 0, 0, 0
	cross product vector3 1, 1, 2
	ship(obj_no).side_vec.x = x vector3(1)
	ship(obj_no).side_vec.y = y vector3(1)
	ship(obj_no).side_vec.z = z vector3(1)
	
	null = delete vector3(1)
	null = delete vector3(2)
	
endfunction

sync on
sync rate 20
autocam off

Rem PJY - this behaviour is more sophisticated version of seek. The green cube
Rem PJY - still "seeks" toward the white sphere but this time it slows down as
Rem PJY - it gets closer. It'll come to a complete halt when it hits the same
Rem PJY - coordinates as the white sphere. Except that in this version, you'll see
rem PJY - I reposition the white sphere when the cube gets too close to it

TYPE vec
	
	x AS float
	y AS float
	z AS float
	
ENDTYPE

TYPE obj

	current_pos AS vec
	target_pos AS vec
	heading_vec AS vec
	desired_vec AS vec
	targ_vec AS vec
	side_vec AS vec
	velocity AS vec
	max_speed AS float
	max_force AS float
	targ_distance AS float
	mass AS integer
	max_force AS double integer
	max_turn_force AS double integer
	
ENDTYPE

dim ship(1) AS obj

ship(1).current_pos.x = -10
ship(1).current_pos.y = 5
ship(1).current_pos.z = -10
ship(1).velocity.x = 0
ship(1).velocity.y = 0
ship(1).velocity.z = 0
ship(1).max_speed = 25
ship(1).max_force = 30
ship(1).mass = 10

ship(1).target_pos.x = 300
ship(1).target_pos.y = 5
ship(1).target_pos.z = 300

Rem PJY - same set up stuff as before
make matrix 1, 1000, 1000, 100, 100
position matrix 1, -500, 0, -500

make object cube 1, 10
position object 1, ship(1).current_pos.x, ship(1).current_pos.y, ship(1).current_pos.z
color object 1, rgb(0, 255, 0)

make object sphere 2, 8
position object 2, ship(1).target_pos.x, ship(1).target_pos.y, ship(1).target_pos.z

position camera 0, ship(1).current_pos.x - 50, 30, ship(1).current_pos.z - 50
point camera 0, ship(1).current_pos.x, ship(1).current_pos.y, ship(1).current_pos.z

current_time = timer()

repeat

	position object 2, ship(1).target_pos.x, ship(1).target_pos.y, ship(1).target_pos.z

	text 0, 0, "Current_pos : " + str$(ship(1).current_pos.x) + " " + str$(ship(1).current_pos.y) + " " + str$(ship(1).current_pos.z)
	text 0, 30, "targ: " + str$(ship(1).targ_vec.x) + " " + str$(ship(1).targ_vec.y) + " " + str$(ship(1).targ_vec.z)
	null = make vector3(1)
	set vector3 1, ship(1).velocity.x, ship(1).velocity.y, ship(1).velocity.z
	velocity# = length vector3(1)
	text 0, 60, "velocity: " + str$(velocity#)
	null = delete vector3(1)
	
	Rem PJY - deceleration is set at 10. This acts as a drag force and is passed
	Rem PJY - as a parameter to the arrive behaviour
	behaviour_arrive(10)
	
	last_time = current_time
	current_time = timer()
	time_elapsed# = current_time - last_time
	time_elapsed# = time_elapsed# * 0.01
	
	update_vehicle(time_elapsed#)
	
	position object 1, ship(1).current_pos.x, ship(1).current_pos.y, ship(1).current_pos.z
	position camera 0, ship(1).current_pos.x - 50, ship(1).current_pos.y + 100, ship(1).current_pos.z - 40
	point camera 0, ship(1).current_pos.x, ship(1).current_pos.y, ship(1).current_pos.z

	Rem PJY - if the green cube gets within 2 of the white sphere, reposition the white sphere
	if ship(1).targ_distance < 2
			
		ship(1).target_pos.x = rnd(800) - 400  
		ship(1).target_pos.y = 5
		ship(1).target_pos.z = rnd(800) - 400

	endif

	sync
	
until spacekey() > 0



Rem PJY - a bit of clean up
for i = 1 to 100
	
	if matrix exist(i) = 1
		
		delete matrix i
		
	endif
	
	if object exist(i) = 1
		
		delete object i
		
	endif
	
next i



Rem PJY - function that updates the ship's behaviour

function behaviour_arrive(deceleration AS integer)

	null = make vector3(1)
	null = make vector3(2)
	null = make vector3(3)
	
	Rem PJY - get the new vector to target
	set vector3 1, ship(1).target_pos.x - ship(1).current_pos.x, ship(1).target_pos.y - ship(1).current_pos.y, ship(1).target_pos.z - ship(1).current_pos.z
	
	ship(1).targ_vec.x = x vector3(1)
	ship(1).targ_vec.y = y vector3(1)
	ship(1).targ_vec.z = z vector3(1)
	
	Rem PJY - check its not further than the maximum speed of the cube
	ship(1).targ_distance = length vector3(1)
	
	if ship(1).targ_distance > 0
		
		tweaker AS float
		tweaker = 10
		
		speed AS float
		speed = ship(1).targ_distance / (deceleration * tweaker)
		
		if speed > ship(1).max_speed
			
			speed = ship(1).max_speed
			
		endif
				
		normalize vector3 1, 1
		multiply vector3 1, speed
		ship(1).desired_vec.x = x vector3(1)
		ship(1).desired_vec.y = y vector3(1)
		ship(1).desired_vec.z = z vector3(1)
	
		set vector3 1, ship(1).desired_vec.x, ship(1).desired_vec.y, ship(1).desired_vec.z
		set vector3 2, ship(1).velocity.x, ship(1).velocity.y, ship(1).velocity.z
		subtract vector3 1, 1, 2
		length2# = length vector3(1)
		length# = length vector3(2)
		ship(1).desired_vec.x = x vector3(1)
		ship(1).desired_vec.y = y vector3(1)
		ship(1).desired_vec.z = z vector3(1)
		
	else

		ship(1).desired_vec.x = 0
		ship(1).desired_vec.y = 0
		ship(1).desired_vec.z = 0
		
	endif
		
	null = delete vector3(1)
	null = delete vector3(2)
	null = delete vector3(3)

endfunction




Rem PJY - function to update the vehicle's physics

function update_vehicle(time_elapsed AS float)

	Rem PJY - this is basically the same code as in the previous examples

	null = make vector3(1)

	steering_force AS vec
	steering_force.x = ship(1).desired_vec.x
	steering_force.y = ship(1).desired_vec.y
	steering_force.z = ship(1).desired_vec.z
	set vector3 1, steering_force.x, steering_force.y, steering_force.z
	length# = length vector3(1)
	if length# > ship(1).max_force
		
		normalize vector3 1, 1
		multiply vector3 1, ship(1).max_force
		
	endif
	steering_force.x = x vector3(1)
	steering_force.y = y vector3(1)
	steering_force.z = z vector3(1)

	acceleration AS vec
	acceleration.x = steering_force.x
	acceleration.y = steering_force.y
	acceleration.z = steering_force.z

	set vector3 1, acceleration.x, acceleration.y, acceleration.z
	divide vector3 1, ship(1).mass	
	acceleration.x = x vector3(1)
	acceleration.y = y vector3(1)
	acceleration.z = z vector3(1)
	
	set vector3 1, acceleration.x, acceleration.y, acceleration.z
	multiply vector3 1, time_elapsed
	
	
	ship(1).velocity.x = ship(1).velocity.x + x vector3(1)
	ship(1).velocity.y = ship(1).velocity.y + y vector3(1)
	ship(1).velocity.z = ship(1).velocity.z + z vector3(1)
	set vector3 1, ship(1).velocity.x, ship(1).velocity.y, ship(1).velocity.z
	length# = length vector3(1)
	if length# => ship(1).max_speed
		
		normalize vector3 1, 1
		multiply vector3 1, ship(1).max_speed
		
	endif
	ship(1).velocity.x = x vector3(1)
	ship(1).velocity.y = y vector3(1)
	ship(1).velocity.z = z vector3(1)
	
	multiply vector3 1, time_elapsed
	
	ship(1).current_pos.x = ship(1).current_pos.x + x vector3(1)
	ship(1).current_pos.y = ship(1).current_pos.y + y vector3(1)
	ship(1).current_pos.z = ship(1).current_pos.z + z vector3(1)
	
	set vector3 1, ship(1).velocity.x, ship(1).velocity.y, ship(1).velocity.z
	normalize vector3 1, 1
	ship(1).heading_vec.x = x vector3(1)
	ship(1).heading_vec.y = y vector3(1)
	ship(1).heading_vec.z = z vector3(1)
	
	null = delete vector3(1)
	
endfunction

sync on
sync rate 20
autocam off
randomize timer()

Rem PJY - this is an even more complex behaviour. This behaviour makes the green cube
Rem PJY - randomly wander in 3 dimensions. It does this by moving a point around the surface of
Rem PJY - a sphere and then adding the vector from the cube to that point to the green cube's existing heading
Rem PJY - the point is represented in this example as a green sphere. The bigger sphere on which the "green sphere"
Rem PJY - moves is NOT represented.

Rem PJY - you may be wondering why do this instead of something like lots of rnd()s or perlin noise. The answer is that
Rem PJY - both create "jerky" random movement. This creates very smooth random movement. It looks nicer.

TYPE vec
	
	x AS float
	y AS float
	z AS float
	
ENDTYPE

TYPE obj

	current_pos AS vec
	target_pos AS vec
	heading_vec AS vec
	desired_vec AS vec
	targ_vec AS vec
	side_vec AS vec
	velocity AS vec
	max_speed AS float
	max_force AS float
	targ_distance AS float
	mass AS integer
	max_force AS double integer
	max_turn_force AS double integer
	wander_radius AS float
	wander_distance AS float
	wander_jitter AS float
	wander_target AS vec
	
ENDTYPE

Rem PJY - lets implement a bit of sophistication with the camera as well.
Rem PJY - camera control is now based on spherical coordinates
global camera AS vec
global camera_distance AS float
global camera_azimuth AS float
global camera_bearing AS float
camera_distance = 50
camera_azimuth = 70
camera_bearing = 30

dim ship(1) AS obj

ship(1).current_pos.x = -10
ship(1).current_pos.y = 5
ship(1).current_pos.z = -10
ship(1).velocity.x = 0
ship(1).velocity.y = 0
ship(1).velocity.z = 0
ship(1).max_speed = 10
ship(1).max_force = 30
ship(1).mass = 10

Rem PJY - some new and slightly cryptic variables.
ship(1).wander_radius = 3
Rem PJY - thats the radius of the bigger sphere
ship(1).wander_distance = 10
Rem PJY - thats the distance between green cube and bigger sphere
ship(1).wander_jitter = 0.5
Rem PJY - thats the movement of the green sphere around the bigger sphere each loop
ship(1).wander_target.x = ship(1).current_pos.x
ship(1).wander_target.y = ship(1).current_pos.y
ship(1).wander_target.z = ship(1).current_pos.z

Rem PJY - usual stuff
make matrix 1, 1000, 1000, 100, 100
position matrix 1, -500, 0, -500

make object cube 1, 10
position object 1, ship(1).current_pos.x, ship(1).current_pos.y, ship(1).current_pos.z
color object 1, rgb(0, 255, 0)

make object sphere 2, 8
position object 2, ship(1).target_pos.x, ship(1).target_pos.y, ship(1).target_pos.z

position camera 0, ship(1).current_pos.x - 50, 100, ship(1).current_pos.z - 50
point camera 0, ship(1).current_pos.x, ship(1).current_pos.y, ship(1).current_pos.z

current_time = timer()

repeat

	Rem PJY - safety code to ensure that the wandering cube hasn't "wandered off" hehe
	if ship(1).current_pos.x > 450 then ship(1).current_pos.x = -400
	if ship(1).current_pos.x < -450 then ship(1).current_pos.x = 400
	if ship(1).current_pos.y > 450 then ship(1).current_pos.y = -400
	if ship(1).current_pos.y < -450 then ship(1).current_pos.y = 400
	if ship(1).current_pos.z > 450 then ship(1).current_pos.z = -400
	if ship(1).current_pos.z < -450 then ship(1).current_pos.z = 400

	text 0, 0, "Current_pos : " + str$(ship(1).current_pos.x) + " " + str$(ship(1).current_pos.y) + " " + str$(ship(1).current_pos.z)
	null = make vector3(1)
	set vector3 1, ship(1).velocity.x, ship(1).velocity.y, ship(1).velocity.z
	velocity# = length vector3(1)
	text 0, 30, "velocity: " + str$(velocity#)
	null = delete vector3(1)
	
	Rem PJY - create the steering force for wandering
	behaviour_wander()
	
	last_time = current_time
	current_time = timer()
	time_elapsed# = current_time - last_time
	time_elapsed# = time_elapsed# * 0.01
	
	update_vehicle(time_elapsed#)
	
	position object 1, ship(1).current_pos.x, ship(1).current_pos.y, ship(1).current_pos.z
	position object 2, ship(1).target_pos.x, ship(1).target_pos.y, ship(1).target_pos.z

	Rem PJY - keep camera aimed at the cube
	control_camera()
	position camera 0, camera.x, camera.y, camera.z
	point camera 0, ship(1).current_pos.x, ship(1).current_pos.y, ship(1).current_pos.z

	sync
	
until spacekey() > 0


Rem PJY - clean up time
for i = 1 to 100
	
	if matrix exist(i) = 1
		
		delete matrix i
		
	endif
	
	if object exist(i) = 1
		
		delete object i
		
	endif
next i



Rem PJY - control camera

function control_camera()

 	if upkey() > 0 
		
		camera_azimuth = camera_azimuth + 1		
		if camera_azimuth => 180
			
			camera_azimuth = 180
			
		endif
		
	endif

	if downkey() > 0
		
		camera_azimuth = camera_azimuth - 1
		if camera_azimuth =< 0
			
			camera_azimuth = 0
			
		endif
		
	endif

	if rightkey() > 0
		
		camera_bearing = wrapvalue(camera_bearing + 1)
		
	endif

	if leftkey() > 0
		
		camera_bearing = wrapvalue(camera_bearing - 1)
		
	endif

	Rem PJY - use spherical 3d coordinates to calculate the camera's new position
	camera.x = ship(1).current_pos.x + (camera_distance * sin(camera_azimuth) * cos(camera_bearing))
	camera.z = ship(1).current_pos.z + (camera_distance * sin(camera_azimuth) * sin(camera_bearing))
	camera.y = ship(1).current_pos.y + (camera_distance * cos(camera_azimuth))

endfunction



Rem PJY - function that updates the ship's behaviour

function behaviour_wander()

	null = make vector3(1)
	null = make vector3(2)
	null = make vector3(3)
	null = make vector3(4)
	
	Rem PJY - get 3 random numbers between -1 and 1
	random1# = random_clamped()
	random2# = random_clamped()
	random3# = random_clamped()
	set vector3 1, random1# * ship(1).wander_jitter,  random2# * ship(1).wander_jitter,  random3# * ship(1).wander_jitter
	ship(1).wander_target.x = ship(1).wander_target.x + x vector3(1)
	ship(1).wander_target.y = ship(1).wander_target.y + y vector3(1)
	ship(1).wander_target.z = ship(1).wander_target.z + z vector3(1)
	set vector3 2, ship(1).wander_target.x, ship(1).wander_target.y, ship(1).wander_target.z
	normalize vector3 2, 2
	multiply vector3 2, ship(1).wander_radius
	ship(1).wander_target.x = x vector3(2)
	ship(1).wander_target.y = y vector3(2)	
	ship(1).wander_target.z = z vector3(2)
	
	targetlocal AS vec
	targetlocal.x = ship(1).wander_target.x * ship(1).wander_distance
	targetlocal.y = ship(1).wander_target.y * ship(1).wander_distance
	targetlocal.z = ship(1).wander_target.z * ship(1).wander_distance

	targetworld AS vec
	set vector3 1, targetlocal.x, targetlocal.y, targetlocal.z
	set vector3 2, ship(1).current_pos.x, ship(1).current_pos.y, ship(1).current_pos.z
	set vector3 3, ship(1).heading_vec.x, ship(1).heading_vec.y, ship(1).heading_vec.z
	set vector3 4, ship(1).side_vec.x, ship(1).side_vec.y, ship(1).side_vec.z
	add vector3 1, 1, 2
	add vector3 1, 1, 3
	add vector3 1, 1, 4
	
	ship(1).target_pos.x = x vector3(1)
	ship(1).target_pos.y = y vector3(1)
	ship(1).target_pos.z = z vector3(1)
	
	subtract vector3 1, 1, 2
	
	ship(1).desired_vec.x = x vector3(1)
	ship(1).desired_vec.y = y vector3(1)
	ship(1).desired_vec.z = z vector3(1)

	null = delete vector3(1)
	null = delete vector3(2)
	null = delete vector3(3)
	null = delete vector3(4)

endfunction



Rem PJY - function to update the vehicle's physics

function update_vehicle(time_elapsed AS float)

	null = make vector3(1)
	null = make vector3(2)

	steering_force AS vec
	steering_force.x = ship(1).desired_vec.x
	steering_force.y = ship(1).desired_vec.y
	steering_force.z = ship(1).desired_vec.z
	set vector3 1, steering_force.x, steering_force.y, steering_force.z
	length# = length vector3(1)
	if length# > ship(1).max_force
		
		normalize vector3 1, 1
		multiply vector3 1, ship(1).max_force
		
	endif
	steering_force.x = x vector3(1)
	steering_force.y = y vector3(1)
	steering_force.z = z vector3(1)

	acceleration AS vec
	acceleration.x = steering_force.x
	acceleration.y = steering_force.y
	acceleration.z = steering_force.z

	set vector3 1, acceleration.x, acceleration.y, acceleration.z
	divide vector3 1, ship(1).mass	
	acceleration.x = x vector3(1)
	acceleration.y = y vector3(1)
	acceleration.z = z vector3(1)
	
	set vector3 1, acceleration.x, acceleration.y, acceleration.z
	multiply vector3 1, time_elapsed
	
	
	ship(1).velocity.x = ship(1).velocity.x + x vector3(1)
	ship(1).velocity.y = ship(1).velocity.y + y vector3(1)
	ship(1).velocity.z = ship(1).velocity.z + z vector3(1)
	set vector3 1, ship(1).velocity.x, ship(1).velocity.y, ship(1).velocity.z
	length# = length vector3(1)
	if length# => ship(1).max_speed
		
		normalize vector3 1, 1
		multiply vector3 1, ship(1).max_speed
		
	endif
	ship(1).velocity.x = x vector3(1)
	ship(1).velocity.y = y vector3(1)
	ship(1).velocity.z = z vector3(1)
	
	multiply vector3 1, time_elapsed
	
	ship(1).current_pos.x = ship(1).current_pos.x + x vector3(1)
	ship(1).current_pos.y = ship(1).current_pos.y + y vector3(1)
	ship(1).current_pos.z = ship(1).current_pos.z + z vector3(1)
	
	Rem PJY - create a new heading vector
	set vector3 1, ship(1).velocity.x, ship(1).velocity.y, ship(1).velocity.z
	normalize vector3 1, 1
	ship(1).heading_vec.x = x vector3(1)
	ship(1).heading_vec.y = y vector3(1)
	ship(1).heading_vec.z = z vector3(1)
	
	set vector3 2, 0, 0, 0
	cross product vector3 1, 1, 2
	ship(1).side_vec.x = x vector3(1)
	ship(1).side_vec.y = y vector3(1)
	ship(1).side_vec.z = z vector3(1)
	
	null = delete vector3(1)
	null = delete vector3(2)
	
endfunction



Rem PJY - returns a value between -1 and 1

function random_clamped()
	
	local temp#
	temp# = rnd(200)
	temp# = temp# - 100
	temp# = temp# * 0.01
	
endfunction temp#

sync on
sync rate 20
autocam off
randomize timer()

Rem PJY - this behaviour demonstrates a "clever" method of pursuit. The idea here
Rem PJY - is for a blue cube to "pursue" a green cube that is "wandering". The clever bit is that
Rem PJY - the pursuer is not chasing towards where the wanderer IS but where the pursuer calculates
Rem PJY - the wanderer will be in the future. Ahahahaha! (Pause) Ha!
Rem PJY - this location is represented by a gigantic yellow sphere. 

TYPE vec
	
	x AS float
	y AS float
	z AS float
	
ENDTYPE

TYPE obj

	current_pos AS vec
	target_pos AS vec
	heading_vec AS vec
	desired_vec AS vec
	targ_vec AS vec
	side_vec AS vec
	velocity AS vec
	current_speed AS float
	max_speed AS float
	max_force AS float
	targ_distance AS float
	mass AS integer
	max_force AS double integer
	max_turn_force AS double integer
	wander_radius AS float
	wander_distance AS float
	wander_jitter AS float
	wander_target AS vec
	
ENDTYPE

global camera AS vec
global camera_distance AS float
global camera_azimuth AS float
global camera_bearing AS float
camera_distance = 100
camera_azimuth = 70
camera_bearing = 30

global wanderer = 1
global pursuer = 0
dim ship(1) AS obj

Rem PJY - array 1 will contain the wanderer, array 0 will contain the pursuer

ship(1).current_pos.x = -10
ship(1).current_pos.y = 5
ship(1).current_pos.z = -10
ship(1).velocity.x = 0
ship(1).velocity.y = 0
ship(1).velocity.z = 0
ship(1).current_speed = 0
ship(1).max_speed = 10
ship(1).max_force = 30
ship(1).mass = 10
ship(1).wander_radius = 3
ship(1).wander_distance = 10
ship(1).wander_jitter = 0.5
ship(1).wander_target.x = ship(1).current_pos.x
ship(1).wander_target.y = ship(1).current_pos.y
ship(1).wander_target.z = ship(1).current_pos.z

Rem PJY - create random position for object 2
ship(pursuer).current_pos.x = (rnd(300)) - 300
ship(pursuer).current_pos.y = (rnd(300)) - 300
ship(pursuer).current_pos.z = (rnd(300)) - 300
ship(pursuer).current_speed = 0
ship(pursuer).max_speed = 12
ship(pursuer).max_force = 30
ship(pursuer).mass = 10

Rem PJY - standard setup stuff
make matrix 1, 1000, 1000, 100, 100
position matrix 1, -500, 0, -500
set matrix 1, 1, 0, 1, 0, 0, 0, 0

Rem PJY - cube 1 will be the wanderer
make object cube 1, 10
position object 1, ship(1).current_pos.x, ship(1).current_pos.y, ship(1).current_pos.z
color object 1, rgb(0, 255, 0)

make object sphere 2, 8
position object 2, ship(1).target_pos.x, ship(1).target_pos.y, ship(1).target_pos.z
color object 2, rgb(0, 244, 0)

position camera 0, ship(1).current_pos.x - 50, 100, ship(1).current_pos.z - 50
point camera 0, ship(1).current_pos.x, ship(1).current_pos.y, ship(1).current_pos.z

Rem PJY - blue cube 3 will be the pursuer
make object cube 3, 8
position object 3, ship(pursuer).current_pos.x, ship(pursuer).current_pos.y, ship(pursuer).current_pos.z
color object 3, rgb(0, 0, 255)

Rem PJY - yellow sphere to represent the projected position of where the blue cube meets the wandering cube
make object sphere 4, 15
color object 4, rgb(255, 255, 0)

Rem PJY - create a chase camera
make camera 1
set camera view 1, 824, 0, 1024, 200
set current camera 0

current_time = timer()

repeat

	Rem PJY - safety code to ensure that the wandering cube hasn't "wandered off" hehe
	if ship(1).current_pos.x > 450 then ship(1).current_pos.x = -400
	if ship(1).current_pos.x < -450 then ship(1).current_pos.x = 400
	if ship(1).current_pos.y > 450 then ship(1).current_pos.y = -400
	if ship(1).current_pos.y < -450 then ship(1).current_pos.y = 400
	if ship(1).current_pos.z > 450 then ship(1).current_pos.z = -400
	if ship(1).current_pos.z < -450 then ship(1).current_pos.z = 400

	text 0, 0, "Current_pos : " + str$(ship(1).current_pos.x) + " " + str$(ship(1).current_pos.y) + " " + str$(ship(1).current_pos.z)
	text 0, 30, "targ: " + str$(ship(pursuer).targ_vec.x) + " " + str$(ship(pursuer).targ_vec.y) + " " + str$(ship(pursuer).targ_vec.z)
	text 0, 60, "Velocity vec: " + str$(ship(pursuer).velocity.x) + " " + str$(ship(pursuer).velocity.y) + " " + str$(ship(pursuer).velocity.z)
	null = make vector3(1)
	set vector3 1, ship(wanderer).current_pos.x - ship(pursuer).current_pos.x, ship(wanderer).current_pos.y - ship(pursuer).current_pos.y, ship(wanderer).current_pos.z - ship(pursuer).current_pos.z
	length# = length vector3(1)
	text 0, 90, "length between objects: " + str$(length#)
	null = delete vector3(1)
	
	Rem PJY - calculate steering forces
	behaviour_wander(wanderer)
	behaviour_pursuit(pursuer, wanderer)
	
	last_time = current_time
	current_time = timer()
	time_elapsed# = current_time - last_time
	time_elapsed# = time_elapsed# * 0.01
	
	Rem PJY - note the way that we're updating each vehicle in turn. I could have done this with a 
	Rem PJY - for loop but I decided to write the function call twice to make this even clearer
	update_vehicle(time_elapsed#, wanderer)
	update_vehicle(time_elapsed#, pursuer)
	
	position object 1, ship(wanderer).current_pos.x, ship(wanderer).current_pos.y, ship(wanderer).current_pos.z
	position object 2, ship(wanderer).target_pos.x, ship(wanderer).target_pos.y, ship(wanderer).target_pos.z
	position object 3, ship(pursuer).current_pos.x, ship(pursuer).current_pos.y, ship(pursuer).current_pos.z

	Rem PJY - now use EZrotate's rotateto command to rotate the blue cube to point to the new heading
	Rem PJY - I'm ASsuming that the cube is moving along its X axis (i.e. thats its front). A bit naughty AS usually
	Rem PJY - the local Z axis is the facing of the object. But what the hell, I'm a scoundrel. Hehehe.
	null = make vector3(1)
	null = make vector3(2)
	null = make vector3(3)
	EZro_SetEuler object angle x(3), object angle y(3), object angle z(3)
	set vector3 1, EZro_GetMatxX(), EZro_GetMatxY(), EZro_GetMatxZ()
	set vector3 2, ship(pursuer).heading_vec.x, ship(pursuer).heading_vec.y, ship(pursuer).heading_vec.z
	angle# = acos(dot product vector3(1, 2))	
	set vector3 3, ship(pursuer).current_pos.x, ship(pursuer).current_pos.y, ship(pursuer).current_pos.z	
	add vector3 3, 2, 3
	EZro_SetPos ship(pursuer).current_pos.x, ship(pursuer).current_pos.y, ship(pursuer).current_pos.z
	EZRo_rotateto 0, x vector3(3), y vector3(3), z vector3(3), angle#
	EZro_FindEuler
	rotate object 3, EZro_GetEulerX(), EZro_GetEulerY(), EZro_GetEulerZ()
	null = delete vector3(1)
	null = delete vector3(2)
	null = delete vector3(3)

	Rem PJY - keep camera aimed at the pursuer
	control_camera()
	position camera 0, camera.x, camera.y, camera.z
	point camera 0, ship(pursuer).current_pos.x, ship(pursuer).current_pos.y, ship(pursuer).current_pos.z

	Rem PJY - position the chase camera 1
	center text 924, 0, "Chase camera"
	EZro_SetEuler object angle x(3), object angle y(3), object angle z(3)
	EZro_SetPos ship(pursuer).current_pos.x, ship(pursuer).current_pos.y, ship(pursuer).current_pos.z
	EZro_FindPointFromOffset -30, 15, 0
     position camera 1, EZro_GetOffsetX(), EZro_GetOffsetY(), EZro_GetOffsetZ()
	point camera 1, ship(pursuer).current_pos.x, ship(pursuer).current_pos.y, ship(pursuer).current_pos.z

	sync
	
until spacekey() > 0


Rem PJY - clean up
for i = 1 to 100
	
	if matrix exist(i) = 1
		
		delete matrix i
		
	endif
	
	if object exist(i) = 1
		
		delete object i
		
	endif
	
next i


Rem PJY - control camera

function control_camera()

 	if upkey() > 0 
		
		camera_azimuth = camera_azimuth + 2		
		if camera_azimuth => 180
			
			camera_azimuth = 180
			
		endif
		
	endif

	if downkey() > 0
		
		camera_azimuth = camera_azimuth - 2
		if camera_azimuth =< 0
			
			camera_azimuth = 0
			
		endif
		
	endif

	if rightkey() > 0
		
		camera_bearing = wrapvalue(camera_bearing + 2)
		
	endif

	if leftkey() > 0
		
		camera_bearing = wrapvalue(camera_bearing - 2)
		
	endif
		
	Rem PJY - use spherical 3d coordinates to calculate the camera's new position
	camera.x = ship(pursuer).current_pos.x + (camera_distance * sin(camera_azimuth) * cos(camera_bearing))
	camera.z = ship(pursuer).current_pos.z + (camera_distance * sin(camera_azimuth) * sin(camera_bearing))
	camera.y = ship(pursuer).current_pos.y + (camera_distance * cos(camera_azimuth))

endfunction




Rem PJY - function that updates the ship's behaviour

function behaviour_wander(obj_no AS integer)

	Rem PJY - this function is the same AS for the wander example

	null = make vector3(1)
	null = make vector3(2)
	null = make vector3(3)
	null = make vector3(4)
	
	random1# = random_clamped()
	random2# = random_clamped()
	random3# = random_clamped()
	set vector3 1, random1# * ship(obj_no).wander_jitter,  random2# * ship(obj_no).wander_jitter,  random3# * ship(obj_no).wander_jitter
	ship(obj_no).wander_target.x = ship(obj_no).wander_target.x + x vector3(1)
	ship(obj_no).wander_target.y = ship(obj_no).wander_target.y + y vector3(1)
	ship(obj_no).wander_target.z = ship(obj_no).wander_target.z + z vector3(1)
	set vector3 2, ship(obj_no).wander_target.x, ship(obj_no).wander_target.y, ship(obj_no).wander_target.z
	normalize vector3 2, 2
	multiply vector3 2, ship(obj_no).wander_radius
	ship(obj_no).wander_target.x = x vector3(2)
	ship(obj_no).wander_target.y = y vector3(2)	
	ship(obj_no).wander_target.z = z vector3(2)
	
	targetlocal AS vec
	targetlocal.x = ship(obj_no).wander_target.x * ship(obj_no).wander_distance
	targetlocal.y = ship(obj_no).wander_target.y * ship(obj_no).wander_distance
	targetlocal.z = ship(obj_no).wander_target.z * ship(obj_no).wander_distance

	targetworld AS vec
	set vector3 1, targetlocal.x, targetlocal.y, targetlocal.z
	set vector3 2, ship(obj_no).current_pos.x, ship(obj_no).current_pos.y, ship(obj_no).current_pos.z
	set vector3 3, ship(obj_no).heading_vec.x, ship(obj_no).heading_vec.y, ship(obj_no).heading_vec.z
	set vector3 4, ship(obj_no).side_vec.x, ship(obj_no).side_vec.y, ship(obj_no).side_vec.z
	add vector3 1, 1, 2
	add vector3 1, 1, 3
	add vector3 1, 1, 4
	
	ship(obj_no).target_pos.x = x vector3(1)
	ship(obj_no).target_pos.y = y vector3(1)
	ship(obj_no).target_pos.z = z vector3(1)
	
	subtract vector3 1, 1, 2
	
	ship(obj_no).desired_vec.x = x vector3(1)
	ship(obj_no).desired_vec.y = y vector3(1)
	ship(obj_no).desired_vec.z = z vector3(1)

	null = delete vector3(1)
	null = delete vector3(2)
	null = delete vector3(3)
	null = delete vector3(4)

endfunction




Rem PJY - function that updates the ship's behaviour

function behaviour_pursuit(pursuer AS integer, wanderer AS integer)

	null = make vector3(1)
	null = make vector3(2)
	null = make vector3(3)
	null = make vector3(4)

	set vector3 1, ship(wanderer).current_pos.x - ship(pursuer).current_pos.x, ship(wanderer).current_pos.y - ship(pursuer).current_pos.y, ship(wanderer).current_pos.z - ship(pursuer).current_pos.z
	set vector3 2, ship(pursuer).heading_vec.x, ship(pursuer).heading_vec.y, ship(pursuer).heading_vec.z
	set vector3 3, ship(wanderer).heading_vec.x, ship(wanderer).heading_vec.y, ship(wanderer).heading_vec.z

	relative_heading AS float
	relative_heading = dot product vector3(3, 2)

	if relative_heading > 0 AND relative_heading < -0.95
		
		Rem PJY - if the wanderer is almost directly in front of the pursuer then just use
		Rem PJY - the simple seek behaviour
		ship(pursuer).target_pos.x = ship(wanderer).current_pos.x
		ship(pursuer).target_pos.y = ship(wanderer).current_pos.y
		ship(pursuer).target_pos.z = ship(wanderer).current_pos.z
		behaviour_seek(pursuer)

	else

		Rem PJY - otherwise get a bit more complex and calculate where the wanderer will be in the future
		Rem PJY - assume his velocity remains the same etc
		look_ahead_time AS float
		length# = length vector3(1)
		look_ahead_time = length# / (ship(pursuer).max_speed + ship(wanderer).current_speed)
		set vector3 1, ship(wanderer).current_pos.x, ship(wanderer).current_pos.y, ship(wanderer).current_pos.z
		set vector3 2, ship(wanderer).velocity.x, ship(wanderer).velocity.y, ship(wanderer).velocity.z
		multiply vector3 2, look_ahead_time
		add vector3 1, 1, 2
		ship(pursuer).target_pos.x = x vector3(1)
		ship(pursuer).target_pos.y = y vector3(1)
		ship(pursuer).target_pos.z = z vector3(1)
		
		position object 4, ship(pursuer).target_pos.x, ship(pursuer).target_pos.y, ship(pursuer).target_pos.z
		
		Rem PJY - now we've calculated that, seek towards the future coordinates
		behaviour_seek(pursuer)
		
	endif

	null = delete vector3(1)
	null = delete vector3(2)
	null = delete vector3(3)
	null = delete vector3(4)

endfunction




Rem PJY - function that updates the ship

function behaviour_seek(obj_no AS integer)

	null = make vector3(1)
	null = make vector3(2)
	null = make vector3(3)
	
	Rem PJY - get the new vector to target
	set vector3 1, ship(obj_no).target_pos.x - ship(obj_no).current_pos.x, ship(obj_no).target_pos.y - ship(obj_no).current_pos.y, ship(obj_no).target_pos.z - ship(obj_no).current_pos.z
	
	Rem PJY - check its not further than the maximum speed of the cube
	ship(obj_no).targ_distance = length vector3(1)
	normalize vector3 1, 1
	multiply vector3 1, ship(obj_no).max_speed
	ship(obj_no).targ_vec.x = x vector3(1)
	ship(obj_no).targ_vec.y = y vector3(1)
	ship(obj_no).targ_vec.z = z vector3(1)
	
	Rem PJY - subtract desired velocity from current velocity
	set vector3 2, ship(obj_no).velocity.x, ship(obj_no).velocity.y, ship(obj_no).velocity.z
	subtract vector3 1, 1, 2

	ship(obj_no).desired_vec.x = x vector3(1)
	ship(obj_no).desired_vec.y = y vector3(1)
	ship(obj_no).desired_vec.z = z vector3(1)
	
	null = delete vector3(1)
	null = delete vector3(2)
	null = delete vector3(3)

endfunction




Rem PJY - function to update the vehicle's physics

function update_vehicle(time_elapsed AS float, obj_no AS integer)

	Rem PJY - this is the same function as in the other examples

	null = make vector3(1)
	null = make vector3(2)

	steering_force AS vec
	steering_force.x = ship(obj_no).desired_vec.x
	steering_force.y = ship(obj_no).desired_vec.y
	steering_force.z = ship(obj_no).desired_vec.z
	set vector3 1, steering_force.x, steering_force.y, steering_force.z
	length# = length vector3(1)
	if length# > ship(obj_no).max_force
		
		normalize vector3 1, 1
		multiply vector3 1, ship(obj_no).max_force
		
	endif
	steering_force.x = x vector3(1)
	steering_force.y = y vector3(1)
	steering_force.z = z vector3(1)

	acceleration AS vec
	acceleration.x = steering_force.x
	acceleration.y = steering_force.y
	acceleration.z = steering_force.z

	set vector3 1, acceleration.x, acceleration.y, acceleration.z
	divide vector3 1, ship(obj_no).mass	
	acceleration.x = x vector3(1)
	acceleration.y = y vector3(1)
	acceleration.z = z vector3(1)
	
	set vector3 1, acceleration.x, acceleration.y, acceleration.z
	multiply vector3 1, time_elapsed
	
	
	ship(obj_no).velocity.x = ship(obj_no).velocity.x + x vector3(1)
	ship(obj_no).velocity.y = ship(obj_no).velocity.y + y vector3(1)
	ship(obj_no).velocity.z = ship(obj_no).velocity.z + z vector3(1)
	set vector3 1, ship(obj_no).velocity.x, ship(obj_no).velocity.y, ship(obj_no).velocity.z
	length# = length vector3(1)
	if length# => ship(obj_no).max_speed
		
		normalize vector3 1, 1
		multiply vector3 1, ship(obj_no).max_speed
		
	endif
	ship(obj_no).velocity.x = x vector3(1)
	ship(obj_no).velocity.y = y vector3(1)
	ship(obj_no).velocity.z = z vector3(1)
	ship(obj_no).current_speed = length vector3(1)
	
	multiply vector3 1, time_elapsed
	
	ship(obj_no).current_pos.x = ship(obj_no).current_pos.x + x vector3(1)
	ship(obj_no).current_pos.y = ship(obj_no).current_pos.y + y vector3(1)
	ship(obj_no).current_pos.z = ship(obj_no).current_pos.z + z vector3(1)
	
	set vector3 1, ship(obj_no).velocity.x, ship(obj_no).velocity.y, ship(obj_no).velocity.z
	normalize vector3 1, 1
	ship(obj_no).heading_vec.x = x vector3(1)
	ship(obj_no).heading_vec.y = y vector3(1)
	ship(obj_no).heading_vec.z = z vector3(1)
	
	set vector3 2, 0, 0, 0
	cross product vector3 1, 1, 2
	ship(obj_no).side_vec.x = x vector3(1)
	ship(obj_no).side_vec.y = y vector3(1)
	ship(obj_no).side_vec.z = z vector3(1)
	
	null = delete vector3(1)
	null = delete vector3(2)
	
endfunction



Rem PJY - returns a value between -1 and 1

function random_clamped()
	
	local temp#
	temp# = rnd(200)
	temp# = temp# - 100
	temp# = temp# * 0.01
	
endfunction temp#

sync on
sync rate 20
autocam off
randomize timer()

Rem PJY - this behaviour demonstrates evading, which is basically the opposite of pursuit.
Rem PJY - this time the blue cube is trying to run away from the wandering green cube

TYPE vec
	
	x AS float
	y AS float
	z AS float
	
ENDTYPE

TYPE obj

	current_pos AS vec
	target_pos AS vec
	heading_vec AS vec
	desired_vec AS vec
	targ_vec AS vec
	side_vec AS vec
	velocity AS vec
	current_speed AS float
	max_speed AS float
	max_force AS float
	targ_distance AS float
	mass AS integer
	max_force AS double integer
	max_turn_force AS double integer
	wander_radius AS float
	wander_distance AS float
	wander_jitter AS float
	wander_target AS vec
	
ENDTYPE

global camera AS vec
global camera_distance AS float
global camera_azimuth AS float
global camera_bearing AS float
camera_distance = 100
camera_azimuth = 70
camera_bearing = 30

global wanderer = 1
global evader = 0
dim ship(1) AS obj

Rem PJY - array 1 will contain the wanderer, array 0 will contain the evader

ship(1).current_pos.x = -10
ship(1).current_pos.y = 5
ship(1).current_pos.z = -10
ship(1).velocity.x = 0
ship(1).velocity.y = 0
ship(1).velocity.z = 0
ship(1).current_speed = 0
ship(1).max_speed = 10
ship(1).max_force = 30
ship(1).mass = 10
ship(1).wander_radius = 3
ship(1).wander_distance = 10
ship(1).wander_jitter = 0.5
ship(1).wander_target.x = ship(1).current_pos.x
ship(1).wander_target.y = ship(1).current_pos.y
ship(1).wander_target.z = ship(1).current_pos.z

Rem PJY - create random position for object 2
ship(evader).current_pos.x = (rnd(300)) - 300
ship(evader).current_pos.y = (rnd(300)) - 300
ship(evader).current_pos.z = (rnd(300)) - 300
ship(evader).current_speed = 0
ship(evader).max_speed = 12
ship(evader).max_force = 30
ship(evader).mass = 10

Rem PJY - standard setup stuff
make matrix 1, 1000, 1000, 100, 100
position matrix 1, -500, 0, -500
set matrix 1, 1, 0, 1, 0, 0, 0, 0

Rem PJY - cube 1 will be the wanderer
make object cube 1, 10
position object 1, ship(1).current_pos.x, ship(1).current_pos.y, ship(1).current_pos.z
color object 1, rgb(0, 255, 0)

make object sphere 2, 8
position object 2, ship(1).target_pos.x, ship(1).target_pos.y, ship(1).target_pos.z
color object 2, rgb(0, 244, 0)

position camera 0, ship(1).current_pos.x - 50, 100, ship(1).current_pos.z - 50
point camera 0, ship(1).current_pos.x, ship(1).current_pos.y, ship(1).current_pos.z

Rem PJY - blue cube 3 will be the evader
make object cube 3, 8
position object 3, ship(evader).current_pos.x, ship(evader).current_pos.y, ship(evader).current_pos.z
color object 3, rgb(0, 0, 255)

Rem PJY - yellow sphere to represent the projected position of where the blue cube meets the wandering cube
make object sphere 4, 15
color object 4, rgb(255, 255, 0)

Rem PJY - create a chase camera
make camera 1
set camera view 1, 824, 0, 1024, 200
set camera range 1, 1, 20000
set current camera 0

current_time = timer()

repeat

	Rem PJY - safety code to ensure that the wandering cube hasn't "wandered off" hehe
	if ship(1).current_pos.x > 450 then ship(1).current_pos.x = -400
	if ship(1).current_pos.x < -450 then ship(1).current_pos.x = 400
	if ship(1).current_pos.y > 450 then ship(1).current_pos.y = -400
	if ship(1).current_pos.y < -450 then ship(1).current_pos.y = 400
	if ship(1).current_pos.z > 450 then ship(1).current_pos.z = -400
	if ship(1).current_pos.z < -450 then ship(1).current_pos.z = 400

	Rem PJY - if the blue cube has "evaded" away from the wandering cube by more than 1000, reposition it in the centre
	if ship(evader).targ_distance > 1000

		ship(evader).current_pos.x = 0
		ship(evader).current_pos.y = 0
		ship(evader).current_pos.z = 0
		
	endif

	text 0, 0, "Current_pos : " + str$(ship(1).current_pos.x) + " " + str$(ship(1).current_pos.y) + " " + str$(ship(1).current_pos.z)
	text 0, 30, "Velocity vec: " + str$(ship(evader).velocity.x) + " " + str$(ship(evader).velocity.y) + " " + str$(ship(evader).velocity.z)
	text 0, 90, "Distance between green and blue cubes: " + str$(ship(evader).targ_distance)
	
	Rem PJY - calculate steering forces
	behaviour_wander(wanderer)
	behaviour_evade(evader, wanderer)
	
	last_time = current_time
	current_time = timer()
	time_elapsed# = current_time - last_time
	time_elapsed# = time_elapsed# * 0.01
	
	Rem PJY - note the way that we're updating each vehicle in turn. I could have done this with a 
	Rem PJY - for loop but I decided to write the function call twice to make this even clearer
	update_vehicle(time_elapsed#, wanderer)
	update_vehicle(time_elapsed#, evader)
	
	position object 1, ship(wanderer).current_pos.x, ship(wanderer).current_pos.y, ship(wanderer).current_pos.z
	position object 2, ship(wanderer).target_pos.x, ship(wanderer).target_pos.y, ship(wanderer).target_pos.z
	position object 3, ship(evader).current_pos.x, ship(evader).current_pos.y, ship(evader).current_pos.z

	Rem PJY - now use EZrotate's rotateto command to rotate the blue cube to point to the new heading
	Rem PJY - I'm ASsuming that the cube is moving along its X axis (i.e. thats its front). A bit naughty AS usually
	Rem PJY - the local Z axis is the facing of the object. But what the hell, I'm a scoundrel. Hehehe.
	null = make vector3(1)
	null = make vector3(2)
	null = make vector3(3)
	EZro_SetEuler object angle x(3), object angle y(3), object angle z(3)
	set vector3 1, EZro_GetMatxX(), EZro_GetMatxY(), EZro_GetMatxZ()
	set vector3 2, ship(evader).heading_vec.x, ship(evader).heading_vec.y, ship(evader).heading_vec.z
	angle# = acos(dot product vector3(1, 2))	
	set vector3 3, ship(evader).current_pos.x, ship(evader).current_pos.y, ship(evader).current_pos.z	
	add vector3 3, 2, 3
	EZro_SetPos ship(evader).current_pos.x, ship(evader).current_pos.y, ship(evader).current_pos.z
	EZRo_rotateto 0, x vector3(3), y vector3(3), z vector3(3), angle#
	EZro_FindEuler
	rotate object 3, EZro_GetEulerX(), EZro_GetEulerY(), EZro_GetEulerZ()
	null = delete vector3(1)
	null = delete vector3(2)
	null = delete vector3(3)

	Rem PJY - keep camera aimed at the evader
	control_camera()
	position camera 0, camera.x, camera.y, camera.z
	point camera 0, ship(evader).current_pos.x, ship(evader).current_pos.y, ship(evader).current_pos.z

	Rem PJY - position the chase camera 1
	center text 924, 0, "Chase camera"
	EZro_SetEuler object angle x(3), object angle y(3), object angle z(3)
	EZro_SetPos ship(evader).current_pos.x, ship(evader).current_pos.y, ship(evader).current_pos.z
	EZro_FindPointFromOffset 30, 15, 0
     position camera 1, EZro_GetOffsetX(), EZro_GetOffsetY(), EZro_GetOffsetZ()
	point camera 1, ship(evader).current_pos.x, ship(evader).current_pos.y, ship(evader).current_pos.z

	sync
	
until spacekey() > 0


Rem PJY - clean up
for i = 1 to 100
	
	if matrix exist(i) = 1
		
		delete matrix i
		
	endif
	
	if object exist(i) = 1
		
		delete object i
		
	endif
	
next i


Rem PJY - control camera

function control_camera()

 	if upkey() > 0 
		
		camera_azimuth = camera_azimuth + 2		
		if camera_azimuth => 180
			
			camera_azimuth = 180
			
		endif
		
	endif

	if downkey() > 0
		
		camera_azimuth = camera_azimuth - 2
		if camera_azimuth =< 0
			
			camera_azimuth = 0
			
		endif
		
	endif

	if rightkey() > 0
		
		camera_bearing = wrapvalue(camera_bearing + 2)
		
	endif

	if leftkey() > 0
		
		camera_bearing = wrapvalue(camera_bearing - 2)
		
	endif
		
	Rem PJY - use spherical 3d coordinates to calculate the camera's new position
	camera.x = ship(evader).current_pos.x + (camera_distance * sin(camera_azimuth) * cos(camera_bearing))
	camera.z = ship(evader).current_pos.z + (camera_distance * sin(camera_azimuth) * sin(camera_bearing))
	camera.y = ship(evader).current_pos.y + (camera_distance * cos(camera_azimuth))

endfunction




Rem PJY - function that updates the ship's behaviour

function behaviour_wander(obj_no AS integer)

	Rem PJY - this function is the same AS for the wander example

	null = make vector3(1)
	null = make vector3(2)
	null = make vector3(3)
	null = make vector3(4)
	
	random1# = random_clamped()
	random2# = random_clamped()
	random3# = random_clamped()
	set vector3 1, random1# * ship(obj_no).wander_jitter,  random2# * ship(obj_no).wander_jitter,  random3# * ship(obj_no).wander_jitter
	ship(obj_no).wander_target.x = ship(obj_no).wander_target.x + x vector3(1)
	ship(obj_no).wander_target.y = ship(obj_no).wander_target.y + y vector3(1)
	ship(obj_no).wander_target.z = ship(obj_no).wander_target.z + z vector3(1)
	set vector3 2, ship(obj_no).wander_target.x, ship(obj_no).wander_target.y, ship(obj_no).wander_target.z
	normalize vector3 2, 2
	multiply vector3 2, ship(obj_no).wander_radius
	ship(obj_no).wander_target.x = x vector3(2)
	ship(obj_no).wander_target.y = y vector3(2)	
	ship(obj_no).wander_target.z = z vector3(2)
	
	targetlocal AS vec
	targetlocal.x = ship(obj_no).wander_target.x * ship(obj_no).wander_distance
	targetlocal.y = ship(obj_no).wander_target.y * ship(obj_no).wander_distance
	targetlocal.z = ship(obj_no).wander_target.z * ship(obj_no).wander_distance

	targetworld AS vec
	set vector3 1, targetlocal.x, targetlocal.y, targetlocal.z
	set vector3 2, ship(obj_no).current_pos.x, ship(obj_no).current_pos.y, ship(obj_no).current_pos.z
	set vector3 3, ship(obj_no).heading_vec.x, ship(obj_no).heading_vec.y, ship(obj_no).heading_vec.z
	set vector3 4, ship(obj_no).side_vec.x, ship(obj_no).side_vec.y, ship(obj_no).side_vec.z
	add vector3 1, 1, 2
	add vector3 1, 1, 3
	add vector3 1, 1, 4
	
	ship(obj_no).target_pos.x = x vector3(1)
	ship(obj_no).target_pos.y = y vector3(1)
	ship(obj_no).target_pos.z = z vector3(1)
	
	subtract vector3 1, 1, 2
	
	ship(obj_no).desired_vec.x = x vector3(1)
	ship(obj_no).desired_vec.y = y vector3(1)
	ship(obj_no).desired_vec.z = z vector3(1)

	null = delete vector3(1)
	null = delete vector3(2)
	null = delete vector3(3)
	null = delete vector3(4)

endfunction




Rem PJY - function that updates the ship's behaviour

function behaviour_evade(evader AS integer, wanderer AS integer)

	null = make vector3(1)
	null = make vector3(2)

	Rem PJY - unlike in the pursuit example, there is no need to seek where the pursuer is immediately in front of the evader
	set vector3 1, ship(wanderer).current_pos.x - ship(evader).current_pos.x, ship(wanderer).current_pos.y - ship(evader).current_pos.y, ship(wanderer).current_pos.z - ship(evader).current_pos.z

	look_ahead_time AS float
	ship(evader).targ_distance = length vector3(1)
	look_ahead_time = ship(evader).targ_distance / (ship(evader).max_speed + ship(wanderer).current_speed)
	
	set vector3 1, ship(wanderer).current_pos.x, ship(wanderer).current_pos.y, ship(wanderer).current_pos.z
	set vector3 2, ship(wanderer).velocity.x, ship(wanderer).velocity.y, ship(wanderer).velocity.z
	multiply vector3 2, look_ahead_time
	add vector3 1, 1, 2
	ship(evader).target_pos.x = x vector3(1)
	ship(evader).target_pos.y = y vector3(1)
	ship(evader).target_pos.z = z vector3(1)
		
	position object 4, ship(evader).target_pos.x, ship(evader).target_pos.y, ship(evader).target_pos.z
	behaviour_flee(evader)

	null = delete vector3(1)
	null = delete vector3(2)

endfunction




Rem PJY - function that updates the ship's behaviour

function behaviour_flee(obj_no AS integer)

	null = make vector3(1)
	null = make vector3(2)
	null = make vector3(3)
	
	Rem PJY - get the new vector away from target
	set vector3 1, ship(obj_no).current_pos.x - ship(obj_no).target_pos.x, ship(obj_no).current_pos.y - ship(obj_no).target_pos.y,  ship(obj_no).current_pos.z - ship(obj_no).target_pos.z
	
	Rem PJY - check its not further than the maximum speed of the cube
	ship(obj_no).targ_distance = length vector3(1)
	normalize vector3 1, 1
	multiply vector3 1, ship(obj_no).max_speed
	ship(obj_no).targ_vec.x = x vector3(1)
	ship(obj_no).targ_vec.y = y vector3(1)
	ship(obj_no).targ_vec.z = z vector3(1)
	
	Rem PJY - subtract desired velocity from current velocity
	set vector3 2, ship(obj_no).velocity.x, ship(obj_no).velocity.y, ship(obj_no).velocity.z
	subtract vector3 1, 1, 2

	ship(obj_no).desired_vec.x = x vector3(1)
	ship(obj_no).desired_vec.y = y vector3(1)
	ship(obj_no).desired_vec.z = z vector3(1)
	
	null = delete vector3(1)
	null = delete vector3(2)
	null = delete vector3(3)

endfunction




Rem PJY - function to update the vehicle's physics

function update_vehicle(time_elapsed AS float, obj_no AS integer)

	Rem PJY - this is the same function as in the other examples

	null = make vector3(1)
	null = make vector3(2)

	steering_force AS vec
	steering_force.x = ship(obj_no).desired_vec.x
	steering_force.y = ship(obj_no).desired_vec.y
	steering_force.z = ship(obj_no).desired_vec.z
	set vector3 1, steering_force.x, steering_force.y, steering_force.z
	length# = length vector3(1)
	if length# > ship(obj_no).max_force
		
		normalize vector3 1, 1
		multiply vector3 1, ship(obj_no).max_force
		
	endif
	steering_force.x = x vector3(1)
	steering_force.y = y vector3(1)
	steering_force.z = z vector3(1)

	acceleration AS vec
	acceleration.x = steering_force.x
	acceleration.y = steering_force.y
	acceleration.z = steering_force.z

	set vector3 1, acceleration.x, acceleration.y, acceleration.z
	divide vector3 1, ship(obj_no).mass	
	acceleration.x = x vector3(1)
	acceleration.y = y vector3(1)
	acceleration.z = z vector3(1)
	
	set vector3 1, acceleration.x, acceleration.y, acceleration.z
	multiply vector3 1, time_elapsed
	
	
	ship(obj_no).velocity.x = ship(obj_no).velocity.x + x vector3(1)
	ship(obj_no).velocity.y = ship(obj_no).velocity.y + y vector3(1)
	ship(obj_no).velocity.z = ship(obj_no).velocity.z + z vector3(1)
	set vector3 1, ship(obj_no).velocity.x, ship(obj_no).velocity.y, ship(obj_no).velocity.z
	length# = length vector3(1)
	if length# => ship(obj_no).max_speed
		
		normalize vector3 1, 1
		multiply vector3 1, ship(obj_no).max_speed
		
	endif
	ship(obj_no).velocity.x = x vector3(1)
	ship(obj_no).velocity.y = y vector3(1)
	ship(obj_no).velocity.z = z vector3(1)
	ship(obj_no).current_speed = length vector3(1)
	
	multiply vector3 1, time_elapsed
	
	ship(obj_no).current_pos.x = ship(obj_no).current_pos.x + x vector3(1)
	ship(obj_no).current_pos.y = ship(obj_no).current_pos.y + y vector3(1)
	ship(obj_no).current_pos.z = ship(obj_no).current_pos.z + z vector3(1)
	
	set vector3 1, ship(obj_no).velocity.x, ship(obj_no).velocity.y, ship(obj_no).velocity.z
	normalize vector3 1, 1
	ship(obj_no).heading_vec.x = x vector3(1)
	ship(obj_no).heading_vec.y = y vector3(1)
	ship(obj_no).heading_vec.z = z vector3(1)
	
	set vector3 2, 0, 0, 0
	cross product vector3 1, 1, 2
	ship(obj_no).side_vec.x = x vector3(1)
	ship(obj_no).side_vec.y = y vector3(1)
	ship(obj_no).side_vec.z = z vector3(1)
	
	null = delete vector3(1)
	null = delete vector3(2)
	
endfunction



Rem PJY - returns a value between -1 and 1

function random_clamped()
	
	local temp#
	temp# = rnd(200)
	temp# = temp# - 100
	temp# = temp# * 0.01
	
endfunction temp#

sync on
sync rate 20
autocam off
randomize timer()
d3d_init
set camera view 0, 0, 1024, 768
d3d_setview 0, 0, 1024, 768
d3d_color 255, 0, 255, 100

Rem PJY - the idea behind this example programme is that the green cube is "wandering"
Rem PJY - there are however lots of purple spheres which act AS obstacles. 
Rem PJY - the cube tries to avoid these by applying a suitable steering force

TYPE vec
	
	x AS float
	y AS float
	z AS float
	
ENDTYPE

TYPE obj

	current_pos AS vec
	target_pos AS vec
	heading_vec AS vec
	desired_vec AS vec
	targ_vec AS vec
	side_vec AS vec
	velocity AS vec
	current_speed AS float
	max_speed AS float
	max_force AS float
	targ_distance AS float
	mass AS integer
	max_force AS double integer
	max_turn_force AS double integer
	wander_radius AS float
	wander_distance AS float
	wander_jitter AS float
	wander_target AS vec
	bounding_radius AS integer
	box_length AS float
	
ENDTYPE

TYPE obstacle

	current_pos AS vec
	obj_no AS integer
	radius AS integer

ENDTYPE


global camera AS vec
global camera_distance AS float
global camera_azimuth AS float
global camera_bearing AS float
camera_distance = 100
camera_azimuth = 70
camera_bearing = 30

global wanderer = 1
dim ship(1) AS obj

Rem PJY - lots of standard stuff to set up the green cube
ship(1).current_pos.x = -10
ship(1).current_pos.y = 5
ship(1).current_pos.z = -10
ship(1).velocity.x = 0
ship(1).velocity.y = 0
ship(1).velocity.z = 0
ship(1).current_speed = 0
ship(1).max_speed = 10
ship(1).max_force = 30
ship(1).mass = 10
ship(1).wander_radius = 3
ship(1).wander_distance = 10
ship(1).wander_jitter = 0.5
ship(1).wander_target.x = ship(1).current_pos.x
ship(1).wander_target.y = ship(1).current_pos.y
ship(1).wander_target.z = ship(1).current_pos.z
ship(1).bounding_radius = 6

Rem PJY - create 20 purple spheres AS obstacles
global gTotal_obstacles = 30
dim obstacles(gTotal_obstacles) AS obstacle
for i = 1 to gTotal_obstacles
	
	obstacles(i).current_pos.x = (rnd(400)) - 200
	obstacles(i).current_pos.y = (rnd(400)) - 200
	obstacles(i).current_pos.z = (rnd(400)) - 200
	obstacles(i).obj_no = i + 9
	obstacles(i).radius = 20
	make object sphere obstacles(i).obj_no, obstacles(i).radius * 2, 15, 15
	position object obstacles(i).obj_no, obstacles(i).current_pos.x, obstacles(i).current_pos.y, obstacles(i).current_pos.z
	color object obstacles(i).obj_no, rgb(160, 032, 240)
	
next i

Rem PJY - create a matrix just to act AS a reference for the human eye
make matrix 1, 1000, 1000, 100, 100
position matrix 1, -500, 0, -500
set matrix 1, 1, 0, 1, 1, 0, 1, 0 

Rem PJY - cube 1 will be the wanderer
make object cube 1, 10
position object 1, ship(1).current_pos.x, ship(1).current_pos.y, ship(1).current_pos.z
color object 1, rgb(0, 255, 0)

Rem PJY - sphere 2 has the same role AS in the "wandering" example, i.e. it
Rem PJY - demonstrates movement
make object sphere 2, 8
position object 2, ship(1).target_pos.x, ship(1).target_pos.y, ship(1).target_pos.z
color object 2, rgb(0, 244, 0)

Rem PJY - create a wireframe long rectangle thing to demonstrate the box's obstacle collision area
make object cube 3, 10
set object wireframe 3, 1

position camera 0, ship(1).current_pos.x - 50, 100, ship(1).current_pos.z - 50
point camera 0, ship(1).current_pos.x, ship(1).current_pos.y, ship(1).current_pos.z

Rem PJY - create a chase camera
make camera 1
set camera view 1, 824, 0, 1024, 200
set current camera 0

current_time = timer()

repeat

	Rem PJY - safety code to ensure that the wandering cube hasn't "wandered off" hehe
	if ship(wanderer).current_pos.x > 450 then ship(wanderer).current_pos.x = -400
	if ship(wanderer).current_pos.x < -450 then ship(wanderer).current_pos.x = 400
	if ship(wanderer).current_pos.y > 450 then ship(wanderer).current_pos.y = -400
	if ship(wanderer).current_pos.y < -450 then ship(wanderer).current_pos.y = 400
	if ship(wanderer).current_pos.z > 450 then ship(wanderer).current_pos.z = -400
	if ship(wanderer).current_pos.z < -450 then ship(wanderer).current_pos.z = 400

	Rem PJY - a bit of info
	text 0, 0, "Current_pos : " + str$(ship(wanderer).current_pos.x) + " " + str$(ship(wanderer).current_pos.y) + " " + str$(ship(wanderer).current_pos.z)
	text 0, 30, "Velocity vec: " + str$(ship(wanderer).velocity.x) + " " + str$(ship(wanderer).velocity.y) + " " + str$(ship(wanderer).velocity.z)
	
	Rem PJY - now what happens is that you ADD TOGETHER the steering forces
	Rem PJY - generated by wandering AND obstacle avoidance (if any)
	behaviour_wander(wanderer)
	behaviour_obstacle_avoidance(wanderer)
	
	Rem PJY - update the time
	last_time = current_time
	current_time = timer()
	time_elapsed# = current_time - last_time
	time_elapsed# = time_elapsed# * 0.01
	
	Rem PJY - update the vehicle (the green cube)
	update_vehicle(time_elapsed#, wanderer)
	
	position object 1, ship(wanderer).current_pos.x, ship(wanderer).current_pos.y, ship(wanderer).current_pos.z
	position object 2, ship(wanderer).target_pos.x, ship(wanderer).target_pos.y, ship(wanderer).target_pos.z

	Rem PJY - keep camera aimed at the wandering green cube
	control_camera()
	position camera 0, camera.x, camera.y, camera.z
	point camera 0, ship(wanderer).current_pos.x, ship(wanderer).current_pos.y, ship(wanderer).current_pos.z

	Rem PJY - position the chase camera 1
	center text 924, 0, "Chase camera"
	EZro_SetEuler object angle x(wanderer), object angle y(wanderer), object angle z(wanderer)
	EZro_SetPos ship(wanderer).current_pos.x, ship(wanderer).current_pos.y, ship(wanderer).current_pos.z
	EZro_FindPointFromOffset -30, 15, 0
     position camera 1, EZro_GetOffsetX(), EZro_GetOffsetY(), EZro_GetOffsetZ()
	point camera 1, ship(wanderer).current_pos.x, ship(wanderer).current_pos.y, ship(wanderer).current_pos.z

	sync
	
until spacekey() > 0

Rem PJY - a bit of clean up
for i = 1 to 200
	
	if matrix exist(i) = 1
		
		delete matrix i
		
	endif
	
	if object exist(i) = 1
		
		delete object i
		
	endif
	
next i



Rem PJY - control camera using spherical coordinates

function control_camera()

 	if upkey() > 0 
		
		camera_azimuth = camera_azimuth + 2		
		if camera_azimuth => 180
			
			camera_azimuth = 180
			
		endif
		
	endif

	if downkey() > 0
		
		camera_azimuth = camera_azimuth - 2
		if camera_azimuth =< 0
			
			camera_azimuth = 0
			
		endif
		
	endif

	if rightkey() > 0
		
		camera_bearing = wrapvalue(camera_bearing + 2)
		
	endif

	if leftkey() > 0
		
		camera_bearing = wrapvalue(camera_bearing - 2)
		
	endif
		
	Rem PJY - use spherical 3d coordinates to calculate the camera's new position
	camera.x = ship(wanderer).current_pos.x + (camera_distance * sin(camera_azimuth) * cos(camera_bearing))
	camera.z = ship(wanderer).current_pos.z + (camera_distance * sin(camera_azimuth) * sin(camera_bearing))
	camera.y = ship(wanderer).current_pos.y + (camera_distance * cos(camera_azimuth))

endfunction




Rem PJY - function that updates the ship's behaviour

function behaviour_wander(obj_no AS integer)

	null = make vector3(1)
	null = make vector3(2)
	null = make vector3(3)
	null = make vector3(4)
	
	random1# = random_clamped()
	random2# = random_clamped()
	random3# = random_clamped()
	set vector3 1, random1# * ship(obj_no).wander_jitter,  random2# * ship(obj_no).wander_jitter,  random3# * ship(obj_no).wander_jitter
	ship(obj_no).wander_target.x = ship(obj_no).wander_target.x + x vector3(1)
	ship(obj_no).wander_target.y = ship(obj_no).wander_target.y + y vector3(1)
	ship(obj_no).wander_target.z = ship(obj_no).wander_target.z + z vector3(1)
	set vector3 2, ship(obj_no).wander_target.x, ship(obj_no).wander_target.y, ship(obj_no).wander_target.z
	normalize vector3 2, 2
	multiply vector3 2, ship(obj_no).wander_radius
	ship(obj_no).wander_target.x = x vector3(2)
	ship(obj_no).wander_target.y = y vector3(2)	
	ship(obj_no).wander_target.z = z vector3(2)
		
	targetlocal AS vec
	
	targetlocal.x = ship(obj_no).wander_target.x * ship(obj_no).wander_distance
	targetlocal.y = ship(obj_no).wander_target.y * ship(obj_no).wander_distance
	targetlocal.z = ship(obj_no).wander_target.z * ship(obj_no).wander_distance

	targetworld AS vec
	
	set vector3 1, targetlocal.x, targetlocal.y, targetlocal.z
	set vector3 2, ship(obj_no).current_pos.x, ship(obj_no).current_pos.y, ship(obj_no).current_pos.z
	set vector3 3, ship(obj_no).heading_vec.x, ship(obj_no).heading_vec.y, ship(obj_no).heading_vec.z
	set vector3 4, ship(obj_no).side_vec.x, ship(obj_no).side_vec.y, ship(obj_no).side_vec.z
	add vector3 1, 1, 2
	add vector3 1, 1, 3
	add vector3 1, 1, 4
	
	ship(obj_no).target_pos.x = x vector3(1)
	ship(obj_no).target_pos.y = y vector3(1)
	ship(obj_no).target_pos.z = z vector3(1)
	
	subtract vector3 1, 1, 2
	
	ship(obj_no).desired_vec.x = x vector3(1)
	ship(obj_no).desired_vec.y = y vector3(1)
	ship(obj_no).desired_vec.z = z vector3(1)

	null = delete vector3(1)
	null = delete vector3(2)
	null = delete vector3(3)
	null = delete vector3(4)

endfunction




Rem PJY - function that updates the ship's behaviour

function behaviour_seek(obj_no AS integer)

	null = make vector3(1)
	null = make vector3(2)
	null = make vector3(3)
	
	Rem PJY - get the new vector to target
	set vector3 1, ship(obj_no).target_pos.x - ship(obj_no).current_pos.x, ship(obj_no).target_pos.y - ship(obj_no).current_pos.y, ship(obj_no).target_pos.z - ship(obj_no).current_pos.z
	
	Rem PJY - check its not further than the maximum speed of the cube
	ship(obj_no).targ_distance = length vector3(1)
	normalize vector3 1, 1
	multiply vector3 1, ship(obj_no).max_speed
	ship(obj_no).targ_vec.x = x vector3(1)
	ship(obj_no).targ_vec.y = y vector3(1)
	ship(obj_no).targ_vec.z = z vector3(1)
	
	Rem PJY - subtract desired velocity from current velocity
	set vector3 2, ship(obj_no).velocity.x, ship(obj_no).velocity.y, ship(obj_no).velocity.z
	subtract vector3 1, 1, 2

	ship(obj_no).desired_vec.x = x vector3(1)
	ship(obj_no).desired_vec.y = y vector3(1)
	ship(obj_no).desired_vec.z = z vector3(1)
	
	null = delete vector3(1)
	null = delete vector3(2)
	null = delete vector3(3)

endfunction




Rem PJY - function that updates the ship's behaviour
Rem PJY - this function ASsumes the ship's facing in object space is the X axis

function behaviour_obstacle_avoidance(obj_no AS integer)

	Rem PJY - calculate the "box" collision area of our wandering cube
	Rem PJY - 5 just acts as a minimum detection length
	ship(obj_no).box_length = 6 + (ship(obj_no).current_speed / ship(obj_no).max_speed * 6)
	scale object 3, 100 + (100 * ship(obj_no).box_length), 100, 100
	
	Rem PJY - tag obstacles close to the box
	Rem PJY - we won't do this step in this example but you would have to 
	Rem PJY - in a large and complex world
	dist_to_closest_obstacle AS float
	dist_to_closest_obstacle = 1000000
	
	closest_obstacle AS integer
	closest_obstacle = 0
	closest_obstacle_pos AS vec
	
	Rem PJY - iterate through the obstacles and find the closest obstacle
	for i = 1 to gTotal_obstacles
		
		Rem PJY - reset colour of obstacles to purple
		color object obstacles(i).obj_no, rgb(160, 032, 240)
		
		Rem PJY - here you should normally test whether obstacle is within range
		Rem PJY - i.e. do a distance test
		Rem PJY - but because I'm not dealing with some kind of horrific game world, just 20 purple spheres,
		Rem PJY - I'm not going to bother.
		
		
		Rem PJY - now onto something more interesting
		
		
		Rem PJY - transform obstacle into the wanderer's object space (Mike, I WISH we had a native DBPro command that did this easily hint hint)
		Rem PJY - set eZrotate up with wanderer's current rotation
      	EZro_SetEuler object angle x(obj_no), object angle y(obj_no), object angle z(obj_no)
      	Rem PJY - set EZrotate up with wanderer's current position
      	EZro_SetPos ship(obj_no).current_pos.x, ship(obj_no).current_pos.y, ship(obj_no).current_pos.z
		Rem PJY - calculate offsets to the wanderer's local space
      	EZro_FindoffsetFrompoint obstacles(i).current_pos.x, obstacles(i).current_pos.y, obstacles(i).current_pos.z
      	Rem PJY - put them into variables
      	localpos AS vec
      	localpos.x = EZro_GetOffsetX()
      	localpos.y = EZro_GetOffsetY()
      	localpos.z = EZro_GetOffsetZ()
		
		Rem PJY - ignore objects that lay behind the wanderer
		Rem PJY - btw this assumes that the object's default facing is along the X axis
		Rem PJY - actually in most games its actually along the Z axis
		Rem PJY - but I'm just a v. difficult person
		if localpos.x => 0
		
			expanded_radius AS float
			expanded_radius = (obstacles(i).radius + ship(obj_no).bounding_radius)
			if (abs(localpos.y) < expanded_radius) AND (abs(localpos.z) < expanded_radius)
		
				Rem PJY - now do a line/circle intersection test
				cX AS float
				cY AS float
				cZ AS float
				cX = localpos.x
				cY = localpos.y
				cZ = localpos.z
				
				distance# = (cX * cX) + (cY * cY) + (cZ * cZ)
		
				if distance# < dist_to_closest_obstacle
		
					dist_to_closest_obstacle = distance#
					closest_obstacle = i
					closest_obstacle_pos = localpos
					
				endif
		
			endif
		
		endif
				
	next i

	Rem PJY - if there is a closest obstacle, calculate a steering force
	steering_force AS vec
	temp_vec AS vec
	if closest_obstacle > 0
		
		Rem PJY - colour the closest obstacle YELLOW
		color object obstacles(closest_obstacle).obj_no, RGB(255,255,000)

		text 0, 90, "Closest test active"
		multiplier AS float
		multiplier = 2.0 + (box_length - localpos.x) / box_length
		steering_force.y = (obstacles(closest_obstacle).radius - localpos.y) * multiplier
		steering_force.z = (obstacles(closest_obstacle).radius - localpos.z) * multiplier
	
		braking_weight AS float
		braking_weight = 0.2
		steering_force.x = (obstacles(closest_obstacle).radius - localpos.x) * braking_weight

		Rem PJY - now recalculate the steering force vector into world space
		Rem PJY - setup EZrotate with the object's current rotation
	   	EZro_SetEuler object angle x(obj_no), object angle y(obj_no), object angle z(obj_no)
	   	Rem PJY - setup EZrotate with the object's current position
	   	EZro_SetPos ship(obj_no).current_pos.x, ship(obj_no).current_pos.y, ship(obj_no).current_pos.z
	   	Rem PJY - find the new vector from the steering force
	   	EZro_FindPointFromOffset steering_force.x, steering_force.y, steering_force.z
	 	
	 	temp_vec.x = EZro_GetOffsetX()
		temp_vec.y = EZro_GetOffsetY()
		temp_vec.z = EZro_GetOffsetZ()
		
	endif
	
  	Rem PJY - insert into the desired vector
   	ship(obj_no).desired_vec.x = ship(obj_no).desired_vec.x + temp_vec.x
   	ship(obj_no).desired_vec.y = ship(obj_no).desired_vec.y + temp_vec.y
   	ship(obj_no).desired_vec.z = ship(obj_no).desired_vec.z + temp_vec.z

endfunction




Rem PJY - function to update the vehicle's physics

function update_vehicle(time_elapsed AS float, obj_no AS integer)

	null = make vector3(1)
	null = make vector3(2)
	null = make vector3(3)
	null = make vector3(4)

	steering_force AS vec
	steering_force.x = ship(obj_no).desired_vec.x
	steering_force.y = ship(obj_no).desired_vec.y
	steering_force.z = ship(obj_no).desired_vec.z
	set vector3 1, steering_force.x, steering_force.y, steering_force.z
	length# = length vector3(1)
	if length# > ship(obj_no).max_force
		
		normalize vector3 1, 1
		multiply vector3 1, ship(obj_no).max_force
		
	endif
	steering_force.x = x vector3(1)
	steering_force.y = y vector3(1)
	steering_force.z = z vector3(1)

	acceleration AS vec
	acceleration.x = steering_force.x
	acceleration.y = steering_force.y
	acceleration.z = steering_force.z

	set vector3 1, acceleration.x, acceleration.y, acceleration.z
	divide vector3 1, ship(obj_no).mass	
	acceleration.x = x vector3(1)
	acceleration.y = y vector3(1)
	acceleration.z = z vector3(1)
	
	set vector3 1, acceleration.x, acceleration.y, acceleration.z
	multiply vector3 1, time_elapsed
	
	ship(obj_no).velocity.x = ship(obj_no).velocity.x + x vector3(1)
	ship(obj_no).velocity.y = ship(obj_no).velocity.y + y vector3(1)
	ship(obj_no).velocity.z = ship(obj_no).velocity.z + z vector3(1)
	set vector3 1, ship(obj_no).velocity.x, ship(obj_no).velocity.y, ship(obj_no).velocity.z
	length# = length vector3(1)
	if length# => ship(obj_no).max_speed
		
		normalize vector3 1, 1
		multiply vector3 1, ship(obj_no).max_speed
		
	endif
	ship(obj_no).velocity.x = x vector3(1)
	ship(obj_no).velocity.y = y vector3(1)
	ship(obj_no).velocity.z = z vector3(1)
	ship(obj_no).current_speed = length vector3(1)
	
	multiply vector3 1, time_elapsed
	
	ship(obj_no).current_pos.x = ship(obj_no).current_pos.x + x vector3(1)
	ship(obj_no).current_pos.y = ship(obj_no).current_pos.y + y vector3(1)
	ship(obj_no).current_pos.z = ship(obj_no).current_pos.z + z vector3(1)
	
	old_heading AS vec
	old_heading.x = ship(obj_no).heading_vec.x
	old_heading.y = ship(obj_no).heading_vec.y
	old_heading.z = ship(obj_no).heading_vec.z
	
	Rem PJY - create a new heading vector
	set vector3 1, ship(obj_no).velocity.x, ship(obj_no).velocity.y, ship(obj_no).velocity.z
	normalize vector3 1, 1
	ship(obj_no).heading_vec.x = x vector3(1)
	ship(obj_no).heading_vec.y = y vector3(1)
	ship(obj_no).heading_vec.z = z vector3(1)
	
	Rem PJY - point the wandering cube towards that new heading
	Rem PJY - using its local X axis
	Rem PJY - first calculate the angle between the cube and the new heading
	EZro_SetEuler object angle x(obj_no), object angle y(obj_no), object angle z(obj_no)
	set vector3 2, EZro_GetMatxX(), EZro_GetMatxY(), EZro_GetMatxZ()
	set vector3 3, ship(obj_no).heading_vec.x, ship(obj_no).heading_vec.y, ship(obj_no).heading_vec.z
	angle# = acos(dot product vector3(3, 2))	
	
	Rem PJY - next calculate the new heading location
	set vector3 4, ship(obj_no).current_pos.x, ship(obj_no).current_pos.y, ship(obj_no).current_pos.z	
	add vector3 3, 3, 4
	
	Rem PJY - now use EZrotate's rotateto command to rotate the cube to the new heading
	EZro_SetEuler object angle x(obj_no), object angle y(obj_no), object angle z(obj_no)
	EZro_SetPos ship(obj_no).current_pos.x, ship(obj_no).current_pos.y, ship(obj_no).current_pos.z
	EZRo_rotateto 0, x vector3(3), y vector3(3), z vector3(3), angle#
	EZro_FindEuler
	rotate object obj_no, EZro_GetEulerX(), EZro_GetEulerY(), EZro_GetEulerZ()
	
	Rem PJY - create a blue line to demonstrate the heading of the wandering cube
	temp_vec AS vec
	temp_vec.x = ship(obj_no).heading_vec.x * 15
	temp_vec.y = ship(obj_no).heading_vec.y * 15
	temp_vec.z = ship(obj_no).heading_vec.z * 15
	d3d_line3d ship(obj_no).current_pos.x, ship(obj_no).current_pos.y, ship(obj_no).current_pos.z, ship(obj_no).current_pos.x + temp_vec.x, ship(obj_no).current_pos.y + temp_vec.y, ship(obj_no).current_pos.z + temp_vec.z, 1

	Rem PJY - reposition the collision box (shouldn't put this code here as it'd look better
	Rem PJY - in the main loop. But I'm lazy. C'est la vie)
	set object to object orientation 3, 1
 	set vector3 3, ship(obj_no).heading_vec.x, ship(obj_no).heading_vec.y, ship(obj_no).heading_vec.z
	multiply vector3 3, ship(obj_no).box_length * 5
	add vector3 3, 3, 4
	position object 3, x vector3(3), y vector3(3), z vector3(3)

	Rem PJY - create a new perpendicular vector that represents the side
	set vector3 2, 0, 0, 0
	cross product vector3 1, 1, 2
	ship(obj_no).side_vec.x = x vector3(1)
	ship(obj_no).side_vec.y = y vector3(1)
	ship(obj_no).side_vec.z = z vector3(1)
	
	null = delete vector3(1)
	null = delete vector3(2)
	null = delete vector3(3)
	null = delete vector3(4)
	
endfunction




Rem PJY - returns a value between -1 and 1

function random_clamped()
	
	local temp#
	temp# = rnd(200)
	temp# = temp# - 100
	temp# = temp# * 0.01
	
endfunction temp#

sync on
sync rate 20
autocam off
randomize timer()
d3d_init
set camera view 0, 0, 1024, 768
d3d_setview 0, 0, 1024, 768
d3d_color 255, 0, 255, 100

Rem PJY - this behaviour attempts to demonstrate things like formation flying etc.
Rem PJY - It makes extensive use of the arrive behaviour
Rem PJY - The idea is that there is one leader (a green cube) who is merrily flying around 
Rem PJY - in this case in a big circle. Lots of blue "wingmen" cubes fly towards particular
Rem PJY - offset positions, and then follow the green cube in those offsets
Rem PJY - I've used Cloggy's D3D plugin to create lines to show where the blue cubes are trying to go

TYPE vec
	
	x AS float
	y AS float
	z AS float
	
ENDTYPE

TYPE obj

	obj_no AS integer
	offset AS vec
	current_pos AS vec
	target_pos AS vec
	heading_vec AS vec
	desired_vec AS vec
	targ_vec AS vec
	side_vec AS vec
	velocity AS vec
	max_speed AS float
	max_force AS float
	targ_distance AS float
	mass AS integer
	max_force AS double integer
	max_turn_force AS double integer
	
ENDTYPE

global camera AS vec
global camera_distance AS float
global camera_azimuth AS float
global camera_bearing AS float
camera_distance = 100
camera_azimuth = 70
camera_bearing = 30

Rem PJY - same set up stuff as before
make matrix 1, 1000, 1000, 100, 100
position matrix 1, -500, 0, -500

Rem PJY - create a leader for the followers to follow. To try and simplify things
Rem PJY - I'm going to approximate the leader's movement by just making it move around in a circle
leader AS obj
angle# = 0
global leader_speed AS Float
leader_speed = 0.5
Rem PJY - NB: I'm using leader_speed as a quick hack in this example. Its better to calculate this
Rem PJY - as being the length of the leader's velocity vector each turn. But, to simply things, I'm just
Rem PJY - arbitrarily saying its 0.5 each turn.

Rem PJY - green cube is the leader
make object cube 1, 10
color object 1, rgb(0, 255, 0)
Rem PJY - update the leader's position. It'll circulate around the centre of the matrix
angle = wrapvalue(angle + 1)
leader.current_pos.x = newxvalue(0, angle, 200)
leader.current_pos.y = 0
leader.current_pos.z = newzvalue(0, angle, 200)
position object 1, leader.current_pos.x, 0, leader.current_pos.z

Rem PJY - now create other blue cubes to represent the followers
Rem PJY - and randomly position them
dim ship(10) AS obj

for i = 2 to 10

	ship(i).obj_no = i
	ship(i).current_pos.x = rnd(500) - 250
	ship(i).current_pos.y = rnd(500) - 250
	ship(i).current_pos.z = rnd(500) - 250
	random = get_random_offset()
	
	Rem PJY - note the -20 in the next line. As I've chosen to make the leader
	Rem PJY - green cube's facing direction its local X axis, I'm setting this as 
	Rem PJY - minus 20 to mean that all the offsets are BEHIND the leader. Obviously
	Rem PJY - you can make them in front by setting it a positive figure.
	ship(i).offset.x = random - 20
	random = get_random_offset()
	ship(i).offset.y = random
	random = get_random_offset()
	ship(i).offset.z = random 
	ship(i).max_speed = 35
	ship(i).max_force = 35
	ship(i).mass = 10
	make object cube i, 8
	color object i, rgb(0, 0, 255)

next i

current_time = timer()

repeat

	Rem PJY - update the leader's position. It'll circle around the centre of the matrix
	angle# = wrapvalue(angle# + 0.1)
	old_pos AS vec
	old_pos.x = leader.current_pos.x
	old_pos.z = leader.current_pos.z
	leader.current_pos.x = newxvalue(0, angle#, 200)
	leader.current_pos.z = newzvalue(0, angle#, 200)

	position object 1, leader.current_pos.x, leader.current_pos.y, leader.current_pos.z

	Rem PJY - point the leader in its direction of movement
	EZro_SetEuler object angle x(1), object angle y(1), object angle z(1)
	EZro_SetPos old_pos.x, 0, old_pos.z
	null = make vector3(1)
	null = make vector3(2)
	set vector3 1, EZro_GetMatxX(), EZro_GetMatxY(), EZro_GetMatxZ()
	set vector3 2, leader.current_pos.x - old_pos.x, 0, leader.current_pos.z - old_pos.z
	normalize vector3 2, 2
	angle1# = acos(dot product vector3(2, 1))
	set vector3 1, leader.current_pos.x + x vector3(2), 0, leader.current_pos.z + z vector3(2)
	EZRo_rotateto 2, x vector3(1), y vector3(1), z vector3(1), angle1#
	EZro_FindEuler
	rotate object 1, EZro_GetEulerX(), EZro_GetEulerY(), EZro_GetEulerZ()
	null = delete vector3(1)
	null = delete vector3(2)

	
	last_time = current_time
	current_time = timer()
	time_elapsed# = current_time - last_time
	time_elapsed# = time_elapsed# * 0.01
	
	Rem PJY - iterate through the followers and update them
	for i = 2 to 10

		behaviour_offset_pursuit(i)
		update_vehicle(time_elapsed#, i)	
		position object i, ship(i).current_pos.x, ship(i).current_pos.y, ship(i).current_pos.z
		
	next i
	
	control_camera()
	position camera 0, camera.x, camera.y, camera.z
	point camera 0, leader.current_pos.x, leader.current_pos.y, leader.current_pos.z

	sync
	
until spacekey() > 0



Rem PJY - a bit of clean up
for i = 1 to 100
	
	if matrix exist(i) = 1
		
		delete matrix i
		
	endif
	
	if object exist(i) = 1
		
		delete object i
		
	endif
	
next i




Rem PJY - control camera

function control_camera()

 	if upkey() > 0 
		
		camera_azimuth = camera_azimuth + 2		
		if camera_azimuth => 180
			
			camera_azimuth = 180
			
		endif
		
	endif

	if downkey() > 0
		
		camera_azimuth = camera_azimuth - 2
		if camera_azimuth =< 0
			
			camera_azimuth = 0
			
		endif
		
	endif

	if rightkey() > 0
		
		camera_bearing = wrapvalue(camera_bearing + 2)
		
	endif

	if leftkey() > 0
		
		camera_bearing = wrapvalue(camera_bearing - 2)
		
	endif
		
	Rem PJY - use spherical 3d coordinates to calculate the camera's new position
	camera.x = leader.current_pos.x + (camera_distance * sin(camera_azimuth) * cos(camera_bearing))
	camera.z = leader.current_pos.z + (camera_distance * sin(camera_azimuth) * sin(camera_bearing))
	camera.y = leader.current_pos.y + (camera_distance * cos(camera_azimuth))

endfunction




Rem PJY - function to update the ship's behaviour

function behaviour_offset_pursuit(ship_no AS integer)

	null = make vector3(1)
	null = make vector3(2)
	null = make vector3(3)

	Rem PJY - calculate the XYZ worldspace coords equivalent to the relevant offset from the leader
	EZro_SetEuler object angle x(1), object angle y(1), object angle z(1)
	EZro_SetPos leader.current_pos.x, leader.current_pos.y, leader.current_pos.z
	EZro_FindPointFromOffset ship(ship_no).offset.x, ship(ship_no).offset.y, ship(ship_no).offset.z
     set vector3 1, EZro_GetOffsetX(), EZro_GetOffsetY(), EZro_GetOffsetZ()

	Rem PJY - draw a nice friendly line between each cube and where it is trying to go
	d3d_line3d ship(ship_no).current_pos.x, ship(ship_no).current_pos.y, ship(ship_no).current_pos.z, EZro_GetOffsetX(), EZro_GetOffsetY(), EZro_GetOffsetZ(), 1

	Rem PJY - calculate vector to that location
	set vector3 2, ship(ship_no).current_pos.x, ship(ship_no).current_pos.y, ship(ship_no).current_pos.z
	subtract vector3 3, 1, 2
	
	Rem PJY - now get a bit more complex and calculate lookahead time, etc.
	look_ahead_time AS float
	length# = length vector3(3)
	look_ahead_time = length# / (ship(ship_no).max_speed + leader_speed)
	
	Rem PJY - that use of "leader_speed" was a quick hack
	Rem PJY - note my comments above about the leader_speed global variable
	rem PJY - in an ideal example, it should be the length of the leader's velocity vector
	
	Rem PJY - likewise, note the + 1 to each dimension of the vector immediately below these comments
	Rem PJY - this is another quick hack. In reality you should add the X Y and Z dimensions of the leaders' velocity
	Rem PJY - vector to this vector, i.e. it should be:
	Rem PJY - set vector3 2, x vector3(3) + leader_velocity.x, y vector3(3) + leader_velocity.y etc.
	Rem PJY - again, this hack is done for simplicity just because the leader is being made to travel around in a circle and it 
	Rem PJY - doesn't have a velocity vector in this example
	set vector3 2, x vector3(3) + 1, y vector3(3) + 1, z vector3(3) + 1
	multiply vector3 2, look_ahead_time
	ship(ship_no).target_pos.x = x vector3(1)
	ship(ship_no).target_pos.y = y vector3(1)
	ship(ship_no).target_pos.z = z vector3(1)
	
	Rem PJY - note that the deceleration factor is lower than in the arrive example
	Rem PJY - i.e. its 4 rather than 10. This is because I want the blue cubes to "brake" harder
	behaviour_arrive(4, ship_no)
	
	null = delete vector3(1)
	null = delete vector3(2)
	null = delete vector3(3)

endfunction




Rem PJY - function that updates the ship's behaviour

function behaviour_arrive(deceleration AS integer, ship_no AS integer)

	null = make vector3(1)
	null = make vector3(2)
	null = make vector3(3)
	
	set vector3 1, ship(ship_no).target_pos.x - ship(ship_no).current_pos.x, ship(ship_no).target_pos.y - ship(ship_no).current_pos.y, ship(ship_no).target_pos.z - ship(ship_no).current_pos.z
	
	ship(ship_no).targ_vec.x = x vector3(1)
	ship(ship_no).targ_vec.y = y vector3(1)
	ship(ship_no).targ_vec.z = z vector3(1)
	
	ship(ship_no).targ_distance = length vector3(1)
	
	if ship(ship_no).targ_distance > 0
		
		tweaker AS float
		tweaker = 10
		
		speed AS float
		speed = ship(ship_no).targ_distance / (deceleration * tweaker)
		
		if speed > ship(ship_no).max_speed
			
			speed = ship(ship_no).max_speed
			
		endif
				
		normalize vector3 1, 1
		multiply vector3 1, speed
		ship(ship_no).desired_vec.x = x vector3(1)
		ship(ship_no).desired_vec.y = y vector3(1)
		ship(ship_no).desired_vec.z = z vector3(1)
	
		set vector3 1, ship(ship_no).desired_vec.x, ship(ship_no).desired_vec.y, ship(ship_no).desired_vec.z
		set vector3 2, ship(ship_no).velocity.x, ship(ship_no).velocity.y, ship(ship_no).velocity.z
		subtract vector3 1, 1, 2
		length2# = length vector3(1)
		length# = length vector3(2)
		ship(ship_no).desired_vec.x = x vector3(1)
		ship(ship_no).desired_vec.y = y vector3(1)
		ship(ship_no).desired_vec.z = z vector3(1)
		
	else

		ship(ship_no).desired_vec.x = 0
		ship(ship_no).desired_vec.y = 0
		ship(ship_no).desired_vec.z = 0
		
	endif
		
	null = delete vector3(1)
	null = delete vector3(2)
	null = delete vector3(3)

endfunction




Rem PJY - function to update the vehicle's physics

function update_vehicle(time_elapsed AS float, ship_no AS integer)

	Rem PJY - this is basically the same code as in the previous examples

	null = make vector3(1)
	null = make vector3(2)

	steering_force AS vec
	steering_force.x = ship(ship_no).desired_vec.x
	steering_force.y = ship(ship_no).desired_vec.y
	steering_force.z = ship(ship_no).desired_vec.z
	set vector3 1, steering_force.x, steering_force.y, steering_force.z
	length# = length vector3(1)
	if length# > ship(ship_no).max_force
		
		normalize vector3 1, 1
		multiply vector3 1, ship(ship_no).max_force
		
	endif
	steering_force.x = x vector3(1)
	steering_force.y = y vector3(1)
	steering_force.z = z vector3(1)

	acceleration AS vec
	acceleration.x = steering_force.x
	acceleration.y = steering_force.y
	acceleration.z = steering_force.z

	set vector3 1, acceleration.x, acceleration.y, acceleration.z
	divide vector3 1, ship(ship_no).mass	
	acceleration.x = x vector3(1)
	acceleration.y = y vector3(1)
	acceleration.z = z vector3(1)
	
	set vector3 1, acceleration.x, acceleration.y, acceleration.z
	multiply vector3 1, time_elapsed
	
	
	ship(ship_no).velocity.x = ship(ship_no).velocity.x + x vector3(1)
	ship(ship_no).velocity.y = ship(ship_no).velocity.y + y vector3(1)
	ship(ship_no).velocity.z = ship(ship_no).velocity.z + z vector3(1)
	set vector3 1, ship(ship_no).velocity.x, ship(ship_no).velocity.y, ship(ship_no).velocity.z
	length# = length vector3(1)
	if length# => ship(ship_no).max_speed
		
		normalize vector3 1, 1
		multiply vector3 1, ship(ship_no).max_speed
		
	endif
	ship(ship_no).velocity.x = x vector3(1)
	ship(ship_no).velocity.y = y vector3(1)
	ship(ship_no).velocity.z = z vector3(1)
	
	multiply vector3 1, time_elapsed
	
	ship(ship_no).current_pos.x = ship(ship_no).current_pos.x + x vector3(1)
	ship(ship_no).current_pos.y = ship(ship_no).current_pos.y + y vector3(1)
	ship(ship_no).current_pos.z = ship(ship_no).current_pos.z + z vector3(1)
	
	set vector3 1, ship(ship_no).velocity.x, ship(ship_no).velocity.y, ship(ship_no).velocity.z
	normalize vector3 1, 1
	ship(ship_no).heading_vec.x = x vector3(1)
	ship(ship_no).heading_vec.y = y vector3(1)
	ship(ship_no).heading_vec.z = z vector3(1)
	
	Rem PJY - point the pursuing blue cubes towards their destinations
	Rem PJY - using their local X axis
	EZro_SetEuler object angle x(ship(ship_no).obj_no), object angle y(ship(ship_no).obj_no), object angle z(ship(ship_no).obj_no)
	EZro_SetPos ship(ship_no).current_pos.x, ship(ship_no).current_pos.y, ship(ship_no).current_pos.z
	set vector3 1, EZro_GetMatxX(), EZro_GetMatxY(), EZro_GetMatxZ()
	set vector3 2, ship(ship_no).heading_vec.x, ship(ship_no).heading_vec.y, ship(ship_no).heading_vec.z
	temp_angle# = acos(dot product vector3(1, 2))	
	set vector3 1, ship(ship_no).current_pos.x, ship(ship_no).current_pos.y, ship(ship_no).current_pos.z	
	add vector3 1, 1, 2
	EZRo_rotateto 0, x vector3(1), y vector3(1), z vector3(1), temp_angle#
	EZro_FindEuler
	rotate object ship(ship_no).obj_no, EZro_GetEulerX(), EZro_GetEulerY(), EZro_GetEulerZ()
	
	null = delete vector3(1)
	null = delete vector3(2)
	
endfunction




function get_random_offset()

	repeat
		
		random = rnd(40) - 20
		
	until random => 10 OR random =< -10

endfunction random

sync on
sync rate 20
autocam off
randomize timer()

Rem PJY - this behaviour seeks to demonstrate a blue cube trying to get to a position
Rem PJY - midway between two wandering green cubes

TYPE vec
	
	x AS float
	y AS float
	z AS float
	
ENDTYPE

TYPE obj

	obj_no AS integer
	current_pos AS vec
	target_pos AS vec
	heading_vec AS vec
	desired_vec AS vec
	targ_vec AS vec
	side_vec AS vec
	velocity AS vec
	current_speed AS float
	max_speed AS float
	max_force AS float
	targ_distance AS float
	mass AS integer
	max_force AS double integer
	max_turn_force AS double integer
	wander_radius AS float
	wander_distance AS float
	wander_jitter AS float
	wander_target AS vec
	
ENDTYPE

Rem PJY - lets implement a bit of sophistication with the camera as well.
Rem PJY - camera control is now based on spherical coordinates
global camera AS vec
global camera_distance AS float
global camera_azimuth AS float
global camera_bearing AS float
camera_distance = 50
camera_azimuth = 70
camera_bearing = 30

dim ship(3) AS obj

Rem PJY - create two green cube wanderers
for i = 1 to 2

	ship(i).obj_no = i
	ship(i).current_pos.x = rnd(50) - 25
	ship(i).current_pos.y = rnd(50) - 25
	ship(i).current_pos.z = rnd(50) - 25
	ship(i).velocity.x = 0
	ship(i).velocity.y = 0
	ship(i).velocity.z = 0
	ship(i).max_speed = 5
	ship(i).max_force = 30
	ship(i).mass = 400
	
	Rem PJY - some new and slightly cryptic variables.
	ship(i).wander_radius = 3
	Rem PJY - thats the radius of the bigger sphere
	ship(i).wander_distance = 10
	Rem PJY - thats the distance between green cube and bigger sphere
	ship(i).wander_jitter = 0.5
	Rem PJY - thats the movement of the green sphere around the bigger sphere each loop
	ship(i).wander_target.x = ship(i).current_pos.x
	ship(i).wander_target.y = ship(i).current_pos.y
	ship(i).wander_target.z = ship(i).current_pos.z

	Rem PJY - create two green cubes 
	make object cube i, 10
	position object i, ship(i).current_pos.x, ship(i).current_pos.y, ship(i).current_pos.z
	color object i, rgb(0, 255, 0)

next i

Rem PJY - now create our blue interposing cube
ship(3).obj_no = 3
ship(3).current_pos.x = rnd(200) - 200
ship(3).current_pos.y = 100
ship(3).current_pos.z = rnd(200) - 200
ship(3).velocity.x = 0
ship(3).velocity.y = 0
ship(3).velocity.z = 0
ship(3).max_speed = 25
ship(3).max_force = 40
ship(3).mass = 20
make object cube 3, 10
position object 3, ship(3).current_pos.x, ship(3).current_pos.y, ship(3).current_pos.z
color object 3, rgb(0, 0, 255)

Rem PJY - usual stuff
make matrix 1, 1000, 1000, 100, 100
position matrix 1, -500, 0, -500

position camera 0, ship(3).current_pos.x - 50, 30, ship(3).current_pos.z - 50
point camera 0, ship(3).current_pos.x, ship(3).current_pos.y, ship(3).current_pos.z

Rem PJY - make a yellow sphere to represent the interposed position
make object sphere 4, 15
color object 4, RGB(255,255,000)

Rem PJY - create a chase camera
make camera 1
set camera view 1, 824, 0, 1024, 200
set camera range 1, 1, 10000
set current camera 0

current_time = timer()

repeat

	for i = 1 to 2

		Rem PJY - safety code to ensure that the wandering cubes haven't "wandered off" hehe
		if ship(i).current_pos.x > 250 then ship(i).current_pos.x = -200
		if ship(i).current_pos.x < -250 then ship(i).current_pos.x = 200
		if ship(i).current_pos.y > 250 then ship(i).current_pos.y = -200
		if ship(i).current_pos.y < -250 then ship(i).current_pos.y = 200
		if ship(i).current_pos.z > 250 then ship(i).current_pos.z = -200
		if ship(i).current_pos.z < -250 then ship(i).current_pos.z = 200

		Rem PJY - create the steering force for wandering
		behaviour_wander(i)

	next i
	
	Rem PJY - now for the cleverer stuff
	behaviour_interpose(3, 1, 2)
	
	last_time = current_time
	current_time = timer()
	time_elapsed# = current_time - last_time
	time_elapsed# = time_elapsed# * 0.01
	
	for i = 1 to 3
	
		update_vehicle(time_elapsed#, i)
		position object ship(i).obj_no, ship(i).current_pos.x, ship(i).current_pos.y, ship(i).current_pos.z
		update_heading(i)

	next i
	
	control_camera()
	position camera 0, camera.x, camera.y, camera.z
	point camera 0, ship(3).current_pos.x, ship(3).current_pos.y, ship(3).current_pos.z

	Rem PJY - position the chase camera 1
	center text 924, 0, "Chase camera"
	EZro_SetEuler object angle x(ship(3).obj_no), object angle y(ship(3).obj_no), object angle z(ship(3).obj_no)
	EZro_SetPos ship(3).current_pos.x, ship(3).current_pos.y, ship(3).current_pos.z
	EZro_FindPointFromOffset -30, 15, 0
     position camera 1, EZro_GetOffsetX(), EZro_GetOffsetY(), EZro_GetOffsetZ()
	point camera 1, ship(3).current_pos.x, ship(3).current_pos.y, ship(3).current_pos.z

	sync
	
until spacekey() > 0


Rem PJY - clean up time
for i = 1 to 100
	
	if matrix exist(i) = 1
		
		delete matrix i
		
	endif
	
	if object exist(i) = 1
		
		delete object i
		
	endif
next i



Rem PJY - control camera

function control_camera()

 	if upkey() > 0 
		
		camera_azimuth = camera_azimuth + 1		
		if camera_azimuth => 180
			
			camera_azimuth = 180
			
		endif
		
	endif

	if downkey() > 0
		
		camera_azimuth = camera_azimuth - 1
		if camera_azimuth =< 0
			
			camera_azimuth = 0
			
		endif
		
	endif

	if rightkey() > 0
		
		camera_bearing = wrapvalue(camera_bearing + 1)
		
	endif

	if leftkey() > 0
		
		camera_bearing = wrapvalue(camera_bearing - 1)
		
	endif

	Rem PJY - use spherical 3d coordinates to calculate the camera's new position
	camera.x = ship(3).current_pos.x + (camera_distance * sin(camera_azimuth) * cos(camera_bearing))
	camera.z = ship(3).current_pos.z + (camera_distance * sin(camera_azimuth) * sin(camera_bearing))
	camera.y = ship(3).current_pos.y + (camera_distance * cos(camera_azimuth))

endfunction



Rem PJY - function that updates the ship's behaviour

function behaviour_wander(ship_no AS integer)

	null = make vector3(1)
	null = make vector3(2)
	null = make vector3(3)
	null = make vector3(4)
	
	Rem PJY - get 3 random numbers between -1 and 1
	random1# = random_clamped()
	random2# = random_clamped()
	random3# = random_clamped()
	set vector3 1, random1# * ship(ship_no).wander_jitter,  random2# * ship(ship_no).wander_jitter,  random3# * ship(ship_no).wander_jitter
	ship(ship_no).wander_target.x = ship(ship_no).wander_target.x + x vector3(1)
	ship(ship_no).wander_target.y = ship(ship_no).wander_target.y + y vector3(1)
	ship(ship_no).wander_target.z = ship(ship_no).wander_target.z + z vector3(1)
	set vector3 2, ship(ship_no).wander_target.x, ship(ship_no).wander_target.y, ship(ship_no).wander_target.z
	normalize vector3 2, 2
	multiply vector3 2, ship(ship_no).wander_radius
	ship(ship_no).wander_target.x = x vector3(2)
	ship(ship_no).wander_target.y = y vector3(2)	
	ship(ship_no).wander_target.z = z vector3(2)
	
	targetlocal AS vec
	targetlocal.x = ship(ship_no).wander_target.x * ship(ship_no).wander_distance
	targetlocal.y = ship(ship_no).wander_target.y * ship(ship_no).wander_distance
	targetlocal.z = ship(ship_no).wander_target.z * ship(ship_no).wander_distance

	targetworld AS vec
	set vector3 1, targetlocal.x, targetlocal.y, targetlocal.z
	set vector3 2, ship(ship_no).current_pos.x, ship(ship_no).current_pos.y, ship(ship_no).current_pos.z
	set vector3 3, ship(ship_no).heading_vec.x, ship(ship_no).heading_vec.y, ship(ship_no).heading_vec.z
	set vector3 4, ship(ship_no).side_vec.x, ship(ship_no).side_vec.y, ship(ship_no).side_vec.z
	add vector3 1, 1, 2
	add vector3 1, 1, 3
	add vector3 1, 1, 4
	
	ship(ship_no).target_pos.x = x vector3(1)
	ship(ship_no).target_pos.y = y vector3(1)
	ship(ship_no).target_pos.z = z vector3(1)
	
	subtract vector3 1, 1, 2
	
	ship(ship_no).desired_vec.x = x vector3(1)
	ship(ship_no).desired_vec.y = y vector3(1)
	ship(ship_no).desired_vec.z = z vector3(1)

	null = delete vector3(1)
	null = delete vector3(2)
	null = delete vector3(3)
	null = delete vector3(4)

endfunction




Rem PJY - function that updates the ship's behaviour

function behaviour_interpose(ship_no AS integer, target1_no AS integer, target2_no AS integer)

	null = make vector3(1)
	null = make vector3(2)

	Rem PJY - first calculate where the two green wandering cubes will be in the future
	set vector3 1, ship(target1_no).current_pos.x + ship(target2_no).current_pos.x, ship(target1_no).current_pos.y + ship(target2_no).current_pos.y, ship(target1_no).current_pos.z + ship(target2_no).current_pos.z
	divide vector3 1, 2
	time_to_reach_midpoint AS float
	set vector3 2, ship(ship_no).current_pos.x, ship(ship_no).current_pos.y, ship(ship_no).current_pos.z
	subtract vector3 2, 1, 2
	temp_length# = length vector3(2)
	time_to_reach_midpoint = temp_length# / ship(ship_no).max_speed

	Rem PJY - now we make an assumption that both the two green wandering cubes will continue on a straight trajectory. 
	Rem PJY - we extrapolate to get their future positions
	set vector3 1, ship(target1_no).current_pos.x + ship(target1_no).velocity.x, ship(target1_no).current_pos.y + ship(target1_no).velocity.y, ship(target1_no).current_pos.z + ship(target1_no).velocity.z
	multiply vector3 1, time_to_reach_midpoint

	set vector3 2, ship(target2_no).current_pos.x + ship(target2_no).velocity.x, ship(target2_no).current_pos.y + ship(target2_no).velocity.y, ship(target2_no).current_pos.z + ship(target2_no).velocity.z
	multiply vector3 2, time_to_reach_midpoint
	
	Rem PJY - now we calculate the midpoints of both the resulting vectors
	add vector3 1, 1, 2
	divide vector3 1, 2
	
	Rem PJY - position the happy yellow sphere at the new target coords
	position object 4, x vector3(1), y vector3(1), z vector3(1)
	
	Rem PJY - ... and feed the result into the arrive behaviour
	ship(ship_no).target_pos.x = x vector3(1)
	ship(ship_no).target_pos.y = y vector3(1)
	ship(ship_no).target_pos.z = z vector3(1)
	behaviour_arrive(2, 3)

	null = delete vector3(1)
	null = delete vector3(2)

endfunction




Rem PJY - function that updates the ship's behaviour

function behaviour_arrive(deceleration AS integer, ship_no AS integer)

	null = make vector3(1)
	null = make vector3(2)
	null = make vector3(3)
	
	Rem PJY - get the new vector to target
	set vector3 1, ship(ship_no).target_pos.x - ship(ship_no).current_pos.x, ship(ship_no).target_pos.y - ship(ship_no).current_pos.y, ship(ship_no).target_pos.z - ship(ship_no).current_pos.z
	
	ship(ship_no).targ_vec.x = x vector3(1)
	ship(ship_no).targ_vec.y = y vector3(1)
	ship(ship_no).targ_vec.z = z vector3(1)
	
	Rem PJY - check its not further than the maximum speed of the cube
	ship(ship_no).targ_distance = length vector3(1)
	
	if ship(ship_no).targ_distance > 0
		
		tweaker AS float
		tweaker = 10
		
		speed AS float
		speed = ship(ship_no).targ_distance / (deceleration * tweaker)
		
		if speed > ship(ship_no).max_speed
			
			speed = ship(ship_no).max_speed
			
		endif
				
		normalize vector3 1, 1
		multiply vector3 1, speed
		ship(ship_no).desired_vec.x = x vector3(1)
		ship(ship_no).desired_vec.y = y vector3(1)
		ship(ship_no).desired_vec.z = z vector3(1)
	
		set vector3 1, ship(ship_no).desired_vec.x, ship(ship_no).desired_vec.y, ship(ship_no).desired_vec.z
		set vector3 2, ship(ship_no).velocity.x, ship(ship_no).velocity.y, ship(ship_no).velocity.z
		subtract vector3 1, 1, 2
		length2# = length vector3(1)
		length# = length vector3(2)
		ship(ship_no).desired_vec.x = x vector3(1)
		ship(ship_no).desired_vec.y = y vector3(1)
		ship(ship_no).desired_vec.z = z vector3(1)
		
	else

		ship(ship_no).desired_vec.x = 0
		ship(ship_no).desired_vec.y = 0
		ship(ship_no).desired_vec.z = 0
		
	endif
		
	null = delete vector3(1)
	null = delete vector3(2)
	null = delete vector3(3)

endfunction




Rem PJY - function to update the vehicle's physics

function update_vehicle(time_elapsed AS float, obj_no AS integer)

	null = make vector3(1)
	null = make vector3(2)
	null = make vector3(3)
	null = make vector3(4)

	steering_force AS vec
	steering_force.x = ship(obj_no).desired_vec.x
	steering_force.y = ship(obj_no).desired_vec.y
	steering_force.z = ship(obj_no).desired_vec.z
	set vector3 1, steering_force.x, steering_force.y, steering_force.z
	length# = length vector3(1)
	if length# > ship(obj_no).max_force
		
		normalize vector3 1, 1
		multiply vector3 1, ship(obj_no).max_force
		
	endif
	steering_force.x = x vector3(1)
	steering_force.y = y vector3(1)
	steering_force.z = z vector3(1)

	acceleration AS vec
	acceleration.x = steering_force.x
	acceleration.y = steering_force.y
	acceleration.z = steering_force.z

	set vector3 1, acceleration.x, acceleration.y, acceleration.z
	divide vector3 1, ship(obj_no).mass	
	acceleration.x = x vector3(1)
	acceleration.y = y vector3(1)
	acceleration.z = z vector3(1)
	
	set vector3 1, acceleration.x, acceleration.y, acceleration.z
	multiply vector3 1, time_elapsed
	
	ship(obj_no).velocity.x = ship(obj_no).velocity.x + x vector3(1)
	ship(obj_no).velocity.y = ship(obj_no).velocity.y + y vector3(1)
	ship(obj_no).velocity.z = ship(obj_no).velocity.z + z vector3(1)
	set vector3 1, ship(obj_no).velocity.x, ship(obj_no).velocity.y, ship(obj_no).velocity.z
	length# = length vector3(1)
	if length# => ship(obj_no).max_speed
		
		normalize vector3 1, 1
		multiply vector3 1, ship(obj_no).max_speed
		
	endif
	ship(obj_no).velocity.x = x vector3(1)
	ship(obj_no).velocity.y = y vector3(1)
	ship(obj_no).velocity.z = z vector3(1)
	ship(obj_no).current_speed = length vector3(1)
	
	multiply vector3 1, time_elapsed
	
	ship(obj_no).current_pos.x = ship(obj_no).current_pos.x + x vector3(1)
	ship(obj_no).current_pos.y = ship(obj_no).current_pos.y + y vector3(1)
	ship(obj_no).current_pos.z = ship(obj_no).current_pos.z + z vector3(1)
	
	old_heading AS vec
	old_heading.x = ship(obj_no).heading_vec.x
	old_heading.y = ship(obj_no).heading_vec.y
	old_heading.z = ship(obj_no).heading_vec.z
	
	set vector3 1, ship(obj_no).velocity.x, ship(obj_no).velocity.y, ship(obj_no).velocity.z
	normalize vector3 1, 1
	ship(obj_no).heading_vec.x = x vector3(1)
	ship(obj_no).heading_vec.y = y vector3(1)
	ship(obj_no).heading_vec.z = z vector3(1)
	
	set vector3 2, 0, 0, 0
	cross product vector3 1, 1, 2
	ship(obj_no).side_vec.x = x vector3(1)
	ship(obj_no).side_vec.y = y vector3(1)
	ship(obj_no).side_vec.z = z vector3(1)
	
	null = delete vector3(1)
	null = delete vector3(2)
	null = delete vector3(3)
	null = delete vector3(4)
	
endfunction



Rem PJY - function that updates the heading of the cube

function update_heading(ship_no AS integer)

	null = make vector3(1)
	null = make vector3(2)

	EZro_SetEuler object angle x(ship(ship_no).obj_no), object angle y(ship(ship_no).obj_no), object angle z(ship(ship_no).obj_no)
	EZro_SetPos ship(ship_no).current_pos.x, ship(ship_no).current_pos.y, ship(ship_no).current_pos.z
	set vector3 1, EZro_GetMatxX(), EZro_GetMatxY(), EZro_GetMatxZ()
	set vector3 2, ship(ship_no).heading_vec.x, ship(ship_no).heading_vec.y, ship(ship_no).heading_vec.z
	temp_angle# = acos(dot product vector3(1, 2))	
	set vector3 1, ship(ship_no).current_pos.x, ship(ship_no).current_pos.y, ship(ship_no).current_pos.z	
	add vector3 1, 1, 2
	EZRo_rotateto 0, x vector3(1), y vector3(1), z vector3(1), temp_angle#
	EZro_FindEuler
	rotate object ship(ship_no).obj_no, EZro_GetEulerX(), EZro_GetEulerY(), EZro_GetEulerZ()
	null = delete vector3(1)
	null = delete vector3(2)

endfunction



Rem PJY - returns a value between -1 and 1

function random_clamped()
	
	local temp#
	temp# = rnd(200)
	temp# = temp# - 100
	temp# = temp# * 0.01
	
endfunction temp#

sync on
sync rate 20
autocam off
randomize timer()
d3d_init
set camera view 0, 0, 1024, 768
set camera range 0, 1, 10000
d3d_setview 0, 0, 1024, 768
d3d_color 255, 0, 255, 100

Rem PJY - this behaviour demonstrates path following using the seek behaviour. 
Rem PJY - The green cubes start at random positions and then run to their first
Rem PJY - waypoint, then run around the path, which is marked by lines and yellow 
Rem PJY - spheres. Enjoy

TYPE vec
	
	x AS float
	y AS float
	z AS float
	
ENDTYPE

TYPE obj

	obj_no AS integer
	current_pos AS vec
	target_pos AS vec
	heading_vec AS vec
	desired_vec AS vec
	targ_vec AS vec
	side_vec AS vec
	velocity AS vec
	current_speed AS float
	max_speed AS float
	max_force AS float
	targ_distance AS float
	mass AS integer
	max_force AS double integer
	max_turn_force AS double integer
	wander_radius AS float
	wander_distance AS float
	wander_jitter AS float
	wander_target AS vec
	Rem PJY - this is new
	current_waypoint AS integer
	
ENDTYPE

Rem PJY - lets implement a bit of sophistication with the camera as well.
Rem PJY - camera control is now based on spherical coordinates
global camera AS vec
global camera_distance AS float
global camera_azimuth AS float
global camera_bearing AS float
camera_distance = 250
camera_azimuth = 70
camera_bearing = 30

dim ship(10) AS obj

Rem PJY - create 10 green cubes to follow the path
for i = 1 to 10

	ship(i).obj_no = i
	ship(i).current_pos.x = rnd(500) - 250
	ship(i).current_pos.y = rnd(500) - 250
	ship(i).current_pos.z = rnd(500) - 250
	ship(i).velocity.x = 0
	ship(i).velocity.y = 0
	ship(i).velocity.z = 0
	ship(i).max_speed = 5
	ship(i).max_force = 5
	ship(i).mass = 5
	
	Rem PJY - chose a random waypoint to start at
	repeat
	
		ship(i).current_waypoint = rnd(15)
	
	until ship(i).current_waypoint > 0
	
	Rem PJY - create green cubes 
	make object cube ship(i).obj_no, 10
	position object ship(i).obj_no, ship(i).current_pos.x, ship(i).current_pos.y, ship(i).current_pos.z
	color object ship(i).obj_no, rgb(0, 255, 0)

next i

Rem PJY - usual stuff
make matrix 1, 1000, 1000, 100, 100
position matrix 1, -500, 0, -500

Rem PJY - create a path with 15 waypoints
dim path(15) AS vec
for i = 1 to 15
	
	path(i).x = rnd(300) - 150
	path(i).y = rnd(300) - 150
	path(i).z = rnd(300) - 150
	
	Rem PJY - create some yellow spheres to represent the waypoints
	make object sphere i + 20, 8
	color object i + 20, RGB(255,255,000)
	position object i + 20, path(i).x, path(i).y, path(i).z
	
next i

Rem PJY - this is the distance from the next waypoint that the green cube has to be within
Rem PJY - in order to start seeking to the next waypoint
global waypoint_seek_distance AS integer
waypoint_seek_distance = 10

current_time = timer()

repeat

	for i = 1 to 10
		
		behaviour_follow_path(i)		
		
	next i
	
	last_time = current_time
	current_time = timer()
	time_elapsed# = current_time - last_time
	time_elapsed# = time_elapsed# * 0.01
	
	for i = 1 to 10
	
		update_vehicle(time_elapsed#, i)
		position object ship(i).obj_no, ship(i).current_pos.x, ship(i).current_pos.y, ship(i).current_pos.z
		rem update_heading(i)

		Rem PJY - very weird issue here. I've commented the update_heading() function out
		Rem PJY - because it causes the green cubes to vanish???? Don't think I've made a mathematical error. MIKE! HELP!

	next i
	
	create_path_lines()
	
	Rem PJY - difference to the camera this time. It rotates around the centre of the matrix
	control_camera()
	position camera 0, camera.x, camera.y, camera.z
	point camera 0, 0, 0, 0
	sync
	
until spacekey() > 0


Rem PJY - clean up time
for i = 1 to 100
	
	if matrix exist(i) = 1
		
		delete matrix i
		
	endif
	
	if object exist(i) = 1
		
		delete object i
		
	endif
	
next i


Rem PJY - control camera using spherical coordinates

function control_camera()

 	if upkey() > 0 
		
		camera_azimuth = camera_azimuth + 2		
		if camera_azimuth => 180
			
			camera_azimuth = 180
			
		endif
		
	endif

	if downkey() > 0
		
		camera_azimuth = camera_azimuth - 2
		if camera_azimuth =< 0
			
			camera_azimuth = 0
			
		endif
		
	endif

	if rightkey() > 0
		
		camera_bearing = wrapvalue(camera_bearing + 2)
		
	endif

	if leftkey() > 0
		
		camera_bearing = wrapvalue(camera_bearing - 2)
		
	endif
		
	Rem PJY - use spherical 3d coordinates to calculate the camera's new position
	camera.x = (camera_distance * sin(camera_azimuth) * cos(camera_bearing))
	camera.z = (camera_distance * sin(camera_azimuth) * sin(camera_bearing))
	camera.y = (camera_distance * cos(camera_azimuth))

endfunction



Rem PJY - function that updates the ship's behaviour

function behaviour_follow_path(ship_no AS integer)

	null = make vector3(1)

	Rem PJY - move to next waypoint if close enough to current waypoint
	set vector3 1, ship(ship_no).current_pos.x - path(ship(ship_no).current_waypoint).x, ship(ship_no).current_pos.y - path(ship(ship_no).current_waypoint).y, ship(ship_no).current_pos.z - path(ship(ship_no).current_waypoint).z
	length# = length vector3(1)

	if length# < waypoint_seek_distance

		if ship(ship_no).current_waypoint < 15

			ship(ship_no).current_waypoint = ship(ship_no).current_waypoint + 1

		else

			ship(ship_no).current_waypoint = 1

		endif

	endif

	ship(ship_no).target_pos.x = path(ship(ship_no).current_waypoint).x
	ship(ship_no).target_pos.y = path(ship(ship_no).current_waypoint).y
	ship(ship_no).target_pos.z = path(ship(ship_no).current_waypoint).z
	
	behaviour_seek(ship_no)

	null = delete vector3(1)

endfunction




Rem PJY - function that updates the ship's behaviour

function behaviour_seek(obj_no AS integer)

	null = make vector3(1)
	null = make vector3(2)
	
	set vector3 1, ship(obj_no).target_pos.x - ship(obj_no).current_pos.x, ship(obj_no).target_pos.y - ship(obj_no).current_pos.y, ship(obj_no).target_pos.z - ship(obj_no).current_pos.z
	
	ship(obj_no).targ_distance = length vector3(1)
	normalize vector3 1, 1
	multiply vector3 1, ship(obj_no).max_speed
	ship(obj_no).targ_vec.x = x vector3(1)
	ship(obj_no).targ_vec.y = y vector3(1)
	ship(obj_no).targ_vec.z = z vector3(1)
	
	set vector3 2, ship(obj_no).velocity.x, ship(obj_no).velocity.y, ship(obj_no).velocity.z
	subtract vector3 1, 1, 2

	ship(obj_no).desired_vec.x = x vector3(1)
	ship(obj_no).desired_vec.y = y vector3(1)
	ship(obj_no).desired_vec.z = z vector3(1)
	
	null = delete vector3(1)
	null = delete vector3(2)

endfunction




Rem PJY - function to update the vehicle's physics

function update_vehicle(time_elapsed AS float, obj_no AS integer)

	null = make vector3(1)
	null = make vector3(2)
	null = make vector3(3)
	null = make vector3(4)

	steering_force AS vec
	steering_force.x = ship(obj_no).desired_vec.x
	steering_force.y = ship(obj_no).desired_vec.y
	steering_force.z = ship(obj_no).desired_vec.z
	set vector3 1, steering_force.x, steering_force.y, steering_force.z
	length# = length vector3(1)
	if length# > ship(obj_no).max_force
		
		normalize vector3 1, 1
		multiply vector3 1, ship(obj_no).max_force
		
	endif
	steering_force.x = x vector3(1)
	steering_force.y = y vector3(1)
	steering_force.z = z vector3(1)

	acceleration AS vec
	acceleration.x = steering_force.x
	acceleration.y = steering_force.y
	acceleration.z = steering_force.z

	set vector3 1, acceleration.x, acceleration.y, acceleration.z
	divide vector3 1, ship(obj_no).mass	
	acceleration.x = x vector3(1)
	acceleration.y = y vector3(1)
	acceleration.z = z vector3(1)
	
	set vector3 1, acceleration.x, acceleration.y, acceleration.z
	multiply vector3 1, time_elapsed
	
	ship(obj_no).velocity.x = ship(obj_no).velocity.x + x vector3(1)
	ship(obj_no).velocity.y = ship(obj_no).velocity.y + y vector3(1)
	ship(obj_no).velocity.z = ship(obj_no).velocity.z + z vector3(1)
	set vector3 1, ship(obj_no).velocity.x, ship(obj_no).velocity.y, ship(obj_no).velocity.z
	length# = length vector3(1)
	if length# => ship(obj_no).max_speed
		
		normalize vector3 1, 1
		multiply vector3 1, ship(obj_no).max_speed
		
	endif
	ship(obj_no).velocity.x = x vector3(1)
	ship(obj_no).velocity.y = y vector3(1)
	ship(obj_no).velocity.z = z vector3(1)
	ship(obj_no).current_speed = length vector3(1)
	
	multiply vector3 1, time_elapsed
	
	ship(obj_no).current_pos.x = ship(obj_no).current_pos.x + x vector3(1)
	ship(obj_no).current_pos.y = ship(obj_no).current_pos.y + y vector3(1)
	ship(obj_no).current_pos.z = ship(obj_no).current_pos.z + z vector3(1)
	
	old_heading AS vec
	old_heading.x = ship(obj_no).heading_vec.x
	old_heading.y = ship(obj_no).heading_vec.y
	old_heading.z = ship(obj_no).heading_vec.z
	
	set vector3 1, ship(obj_no).velocity.x, ship(obj_no).velocity.y, ship(obj_no).velocity.z
	normalize vector3 1, 1
	ship(obj_no).heading_vec.x = x vector3(1)
	ship(obj_no).heading_vec.y = y vector3(1)
	ship(obj_no).heading_vec.z = z vector3(1)
	
	set vector3 2, 0, 0, 0
	cross product vector3 1, 1, 2
	ship(obj_no).side_vec.x = x vector3(1)
	ship(obj_no).side_vec.y = y vector3(1)
	ship(obj_no).side_vec.z = z vector3(1)
	
	null = delete vector3(1)
	null = delete vector3(2)
	null = delete vector3(3)
	null = delete vector3(4)
	
endfunction



Rem PJY - function that updates the heading of the cube

function update_heading(ship_no AS integer)

	null = make vector3(1)
	null = make vector3(2)

	EZro_SetEuler object angle x(ship(ship_no).obj_no), object angle y(ship(ship_no).obj_no), object angle z(ship(ship_no).obj_no)
	EZro_SetPos ship(ship_no).current_pos.x, ship(ship_no).current_pos.y, ship(ship_no).current_pos.z
	set vector3 1, EZro_GetMatxX(), EZro_GetMatxY(), EZro_GetMatxZ()
	set vector3 2, ship(ship_no).heading_vec.x, ship(ship_no).heading_vec.y, ship(ship_no).heading_vec.z
	temp_angle# = acos(dot product vector3(1, 2))	
	set vector3 1, ship(ship_no).current_pos.x, ship(ship_no).current_pos.y, ship(ship_no).current_pos.z	
	add vector3 1, 1, 2
	EZRo_rotateto 0, x vector3(1), y vector3(1), z vector3(1), temp_angle#
	EZro_FindEuler
	rotate object ship(ship_no).obj_no, EZro_GetEulerX(), EZro_GetEulerY(), EZro_GetEulerZ()
	
	null = delete vector3(1)
	null = delete vector3(2)

endfunction




Rem PJY - create some lines to illustrate the path

function create_path_lines()

	for i = 1 to 15

		if i < 15
		
			d3d_line3d path(i).x, path(i).y, path(i).z, path(i + 1).x, path(i + 1).y, path(i + 1).z, 1
	
		else
			
			d3d_line3d path(i).x, path(i).y, path(i).z, path(1).x, path(1).y, path(1).z, 1

		endif
	
	next i

endfunction

sync on
sync rate 20
autocam off
randomize timer()

Rem PJY - this is wandering with separation. In other words, the wanderers try
Rem PJY - to stay separated from each other

TYPE vec
	
	x AS float
	y AS float
	z AS float
	
ENDTYPE

TYPE obj

	obj_no AS integer
	current_pos AS vec
	target_pos AS vec
	heading_vec AS vec
	desired_vec AS vec
	targ_vec AS vec
	side_vec AS vec
	velocity AS vec
	max_speed AS float
	current_speed AS float
	max_force AS float
	targ_distance AS float
	mass AS integer
	max_force AS double integer
	max_turn_force AS double integer
	wander_radius AS float
	wander_distance AS float
	wander_jitter AS float
	wander_target AS vec
	
ENDTYPE

Rem PJY - lets implement a bit of sophistication with the camera as well.
Rem PJY - camera control is now based on spherical coordinates
global camera AS vec
global camera_distance AS float
global camera_azimuth AS float
global camera_bearing AS float
camera_distance = 350
camera_azimuth = 70
camera_bearing = 30
set camera range 0, 1, 10000

global total_ships = 30
dim ship(total_ships) AS obj

for i = 1 to total_ships

	ship(i).obj_no = i
	ship(i).current_pos.x = rnd(300) - 150
	ship(i).current_pos.y = rnd(300) - 150
	ship(i).current_pos.z = rnd(300) - 150
	ship(i).velocity.x = 0
	ship(i).velocity.y = 0
	ship(i).velocity.z = 0
	ship(i).max_speed = 10
	ship(i).max_force = 30
	ship(i).mass = 20
	
	Rem PJY - some new and slightly cryptic variables.
	ship(i).wander_radius = 3
	Rem PJY - thats the radius of the bigger sphere
	ship(i).wander_distance = 10
	Rem PJY - thats the distance between green cube and bigger sphere
	ship(i).wander_jitter = 0.5
	Rem PJY - thats the movement of the green sphere around the bigger sphere each loop
	ship(i).wander_target.x = ship(i).current_pos.x
	ship(i).wander_target.y = ship(i).current_pos.y
	ship(i).wander_target.z = ship(i).current_pos.z

	make object cube ship(i).obj_no, 10
	position object ship(i).obj_no, ship(i).current_pos.x, ship(i).current_pos.y, ship(i).current_pos.z
	color object ship(i).obj_no, rgb(0, 255, 0)

next i

Rem PJY - usual stuff
make matrix 1, 1000, 1000, 100, 100
position matrix 1, -500, 0, -500

current_time = timer()

repeat

	for i = 1 to total_ships

		Rem PJY - safety code to ensure that the wandering cubes haven't "wandered off" hehe
		if ship(i).current_pos.x > 450 then ship(i).current_pos.x = -400
		if ship(i).current_pos.x < -450 then ship(i).current_pos.x = 400
		if ship(i).current_pos.y > 450 then ship(i).current_pos.y = -400
		if ship(i).current_pos.y < -450 then ship(i).current_pos.y = 400
		if ship(i).current_pos.z > 450 then ship(i).current_pos.z = -400
		if ship(i).current_pos.z < -450 then ship(i).current_pos.z = 400

		behaviour_wander(i)
		behaviour_separation(i)

	next i
		
	last_time = current_time
	current_time = timer()
	time_elapsed# = current_time - last_time
	time_elapsed# = time_elapsed# * 0.01
	
	for i = 1 to total_ships
	
		update_vehicle(time_elapsed#, i)
		position object ship(i).obj_no, ship(i).current_pos.x, ship(i).current_pos.y, ship(i).current_pos.z

	next i

	Rem PJY - rotate camera around the centre of the matrix
	control_camera()
	position camera 0, camera.x, camera.y, camera.z
	point camera 0, 0, 0, 0
	sync
	
until spacekey() > 0



Rem PJY - clean up time
for i = 1 to 100
	
	if matrix exist(i) = 1
		
		delete matrix i
		
	endif
	
	if object exist(i) = 1
		
		delete object i
		
	endif
next i



Rem PJY - control camera

function control_camera()

 	if upkey() > 0 
		
		camera_azimuth = camera_azimuth + 1		
		if camera_azimuth => 180
			
			camera_azimuth = 180
			
		endif
		
	endif

	if downkey() > 0
		
		camera_azimuth = camera_azimuth - 1
		if camera_azimuth =< 0
			
			camera_azimuth = 0
			
		endif
		
	endif

	if rightkey() > 0
		
		camera_bearing = wrapvalue(camera_bearing + 1)
		
	endif

	if leftkey() > 0
		
		camera_bearing = wrapvalue(camera_bearing - 1)
		
	endif

	Rem PJY - use spherical 3d coordinates to calculate the camera's new position
	camera.x = (camera_distance * sin(camera_azimuth) * cos(camera_bearing))
	camera.z = (camera_distance * sin(camera_azimuth) * sin(camera_bearing))
	camera.y = (camera_distance * cos(camera_azimuth))

endfunction




Rem PJY - function that updates the ship's behaviour

function behaviour_wander(ship_no AS integer)

	null = make vector3(1)
	null = make vector3(2)
	null = make vector3(3)
	null = make vector3(4)
	
	Rem PJY - get 3 random numbers between -1 and 1
	random1# = random_clamped()
	random2# = random_clamped()
	random3# = random_clamped()
	set vector3 1, random1# * ship(ship_no).wander_jitter,  random2# * ship(ship_no).wander_jitter,  random3# * ship(ship_no).wander_jitter
	ship(ship_no).wander_target.x = ship(ship_no).wander_target.x + x vector3(1)
	ship(ship_no).wander_target.y = ship(ship_no).wander_target.y + y vector3(1)
	ship(ship_no).wander_target.z = ship(ship_no).wander_target.z + z vector3(1)
	set vector3 2, ship(ship_no).wander_target.x, ship(ship_no).wander_target.y, ship(ship_no).wander_target.z
	normalize vector3 2, 2
	multiply vector3 2, ship(ship_no).wander_radius
	ship(ship_no).wander_target.x = x vector3(2)
	ship(ship_no).wander_target.y = y vector3(2)	
	ship(ship_no).wander_target.z = z vector3(2)
	
	targetlocal AS vec
	targetlocal.x = ship(ship_no).wander_target.x * ship(ship_no).wander_distance
	targetlocal.y = ship(ship_no).wander_target.y * ship(ship_no).wander_distance
	targetlocal.z = ship(ship_no).wander_target.z * ship(ship_no).wander_distance

	targetworld AS vec
	set vector3 1, targetlocal.x, targetlocal.y, targetlocal.z
	set vector3 2, ship(ship_no).current_pos.x, ship(ship_no).current_pos.y, ship(ship_no).current_pos.z
	set vector3 3, ship(ship_no).heading_vec.x, ship(ship_no).heading_vec.y, ship(ship_no).heading_vec.z
	set vector3 4, ship(ship_no).side_vec.x, ship(ship_no).side_vec.y, ship(ship_no).side_vec.z
	add vector3 1, 1, 2
	add vector3 1, 1, 3
	add vector3 1, 1, 4
	
	ship(ship_no).target_pos.x = x vector3(1)
	ship(ship_no).target_pos.y = y vector3(1)
	ship(ship_no).target_pos.z = z vector3(1)
	
	subtract vector3 1, 1, 2
	
	ship(ship_no).desired_vec.x = x vector3(1)
	ship(ship_no).desired_vec.y = y vector3(1)
	ship(ship_no).desired_vec.z = z vector3(1)

	null = delete vector3(1)
	null = delete vector3(2)
	null = delete vector3(3)
	null = delete vector3(4)

endfunction




Rem PJY - function that updates the ship's behaviour

function behaviour_separation(ship_no AS integer)

	Rem PJY - the way this works is that each cube checks to see if any of the other cubes are within
	Rem PJY - the separation_distance of that cube. If any are, then it applies an inverse vector to get
	Rem PJY - away from it 
	separation_distance = 3
	null = make vector3(1)
	
	Rem PJY - the following method is an inefficient way of achieving this (AS the checking method
	Rem PJY - could be improved to reduce the number of checks needed each processor cycle), but I'll 
	Rem PJY - use it here AS it is simple to understand
	for i = 1 to total_ships
		
		Rem PJY - ensure that we're not checking against the cube we want to move
		if i <> ship_no
		
			set vector3 1, ship(ship_no).current_pos.x - ship(i).current_pos.x, ship(ship_no).current_pos.y - ship(i).current_pos.y, ship(ship_no).current_pos.z - ship(i).current_pos.z
			temp_length# = length vector3(1)
			if temp_length# =< separation_distance
				
				normalize vector3 1, 1
				divide vector3 1, temp_length#
				ship(ship_no).desired_vec.x = ship(ship_no).desired_vec.x + x vector3(1)
				ship(ship_no).desired_vec.y = ship(ship_no).desired_vec.y + y vector3(1)
				ship(ship_no).desired_vec.z = ship(ship_no).desired_vec.z + z vector3(1)
				
			endif
		
		endif
		
	next i
	
	null = delete vector3(1)

endfunction




Rem PJY - function to update the vehicle's physics

function update_vehicle(time_elapsed AS float, obj_no AS integer)

	null = make vector3(1)
	null = make vector3(2)
	null = make vector3(3)
	null = make vector3(4)

	steering_force AS vec
	steering_force.x = ship(obj_no).desired_vec.x
	steering_force.y = ship(obj_no).desired_vec.y
	steering_force.z = ship(obj_no).desired_vec.z
	set vector3 1, steering_force.x, steering_force.y, steering_force.z
	length# = length vector3(1)
	if length# > ship(obj_no).max_force
		
		normalize vector3 1, 1
		multiply vector3 1, ship(obj_no).max_force
		
	endif
	steering_force.x = x vector3(1)
	steering_force.y = y vector3(1)
	steering_force.z = z vector3(1)

	acceleration AS vec
	acceleration.x = steering_force.x
	acceleration.y = steering_force.y
	acceleration.z = steering_force.z

	set vector3 1, acceleration.x, acceleration.y, acceleration.z
	divide vector3 1, ship(obj_no).mass	
	acceleration.x = x vector3(1)
	acceleration.y = y vector3(1)
	acceleration.z = z vector3(1)
	
	set vector3 1, acceleration.x, acceleration.y, acceleration.z
	multiply vector3 1, time_elapsed
	
	ship(obj_no).velocity.x = ship(obj_no).velocity.x + x vector3(1)
	ship(obj_no).velocity.y = ship(obj_no).velocity.y + y vector3(1)
	ship(obj_no).velocity.z = ship(obj_no).velocity.z + z vector3(1)
	set vector3 1, ship(obj_no).velocity.x, ship(obj_no).velocity.y, ship(obj_no).velocity.z
	length# = length vector3(1)
	if length# => ship(obj_no).max_speed
		
		normalize vector3 1, 1
		multiply vector3 1, ship(obj_no).max_speed
		
	endif
	ship(obj_no).velocity.x = x vector3(1)
	ship(obj_no).velocity.y = y vector3(1)
	ship(obj_no).velocity.z = z vector3(1)
	ship(obj_no).current_speed = length vector3(1)
	
	multiply vector3 1, time_elapsed
	
	ship(obj_no).current_pos.x = ship(obj_no).current_pos.x + x vector3(1)
	ship(obj_no).current_pos.y = ship(obj_no).current_pos.y + y vector3(1)
	ship(obj_no).current_pos.z = ship(obj_no).current_pos.z + z vector3(1)
	
	old_heading AS vec
	old_heading.x = ship(obj_no).heading_vec.x
	old_heading.y = ship(obj_no).heading_vec.y
	old_heading.z = ship(obj_no).heading_vec.z
	
	set vector3 1, ship(obj_no).velocity.x, ship(obj_no).velocity.y, ship(obj_no).velocity.z
	normalize vector3 1, 1
	ship(obj_no).heading_vec.x = x vector3(1)
	ship(obj_no).heading_vec.y = y vector3(1)
	ship(obj_no).heading_vec.z = z vector3(1)
	
	set vector3 2, 0, 0, 0
	cross product vector3 1, 1, 2
	ship(obj_no).side_vec.x = x vector3(1)
	ship(obj_no).side_vec.y = y vector3(1)
	ship(obj_no).side_vec.z = z vector3(1)
	
	null = delete vector3(1)
	null = delete vector3(2)
	null = delete vector3(3)
	null = delete vector3(4)

endfunction



Rem PJY - returns a value between -1 and 1

function random_clamped()
	
	local temp#
	temp# = rnd(200)
	temp# = temp# - 100
	temp# = temp# * 0.01
	
endfunction temp#

sync on
sync rate 20
autocam off
randomize timer()

Rem PJY - this is wandering with separation, alignment and cohesion.
Rem PJY - In other words, its wandering with flocking!

TYPE vec
	
	x AS float
	y AS float
	z AS float
	
ENDTYPE

TYPE obj

	obj_no AS integer
	current_pos AS vec
	target_pos AS vec
	heading_vec AS vec
	desired_vec AS vec
	targ_vec AS vec
	side_vec AS vec
	velocity AS vec
	max_speed AS float
	current_speed AS float
	max_force AS float
	targ_distance AS float
	mass AS integer
	max_force AS double integer
	max_turn_force AS double integer
	wander_radius AS float
	wander_distance AS float
	wander_jitter AS float
	wander_target AS vec
	
ENDTYPE

Rem PJY - lets implement a bit of sophistication with the camera as well.
Rem PJY - camera control is now based on spherical coordinates
global camera AS vec
global camera_distance AS float
global camera_azimuth AS float
global camera_bearing AS float
camera_distance = 350
camera_azimuth = 70
camera_bearing = 30
set camera range 0, 1, 10000

global total_ships = 30
dim ship(total_ships) AS obj

for i = 1 to total_ships

	ship(i).obj_no = i
	ship(i).current_pos.x = rnd(100) - 50
	ship(i).current_pos.y = rnd(100) - 50
	ship(i).current_pos.z = rnd(100) - 50
	ship(i).velocity.x = 0
	ship(i).velocity.y = 0
	ship(i).velocity.z = 0
	ship(i).max_speed = 3
	ship(i).max_force = 100
	ship(i).mass = 20
	
	Rem PJY - some new and slightly cryptic variables.
	ship(i).wander_radius = 3
	Rem PJY - thats the radius of the bigger sphere
	ship(i).wander_distance = 10
	Rem PJY - thats the distance between green cube and bigger sphere
	ship(i).wander_jitter = 0.5
	Rem PJY - thats the movement of the green sphere around the bigger sphere each loop
	ship(i).wander_target.x = ship(i).current_pos.x
	ship(i).wander_target.y = ship(i).current_pos.y
	ship(i).wander_target.z = ship(i).current_pos.z

	make object cube ship(i).obj_no, 10
	position object ship(i).obj_no, ship(i).current_pos.x, ship(i).current_pos.y, ship(i).current_pos.z
	color object ship(i).obj_no, rgb(0, 255, 0)

next i



Rem PJY - usual stuff
make matrix 1, 1000, 1000, 100, 100
position matrix 1, -500, 0, -500

current_time = timer()

repeat

	for i = 1 to total_ships

		Rem PJY - safety code to ensure that the wandering cubes haven't "wandered off" hehe
		if ship(i).current_pos.x > 450 then ship(i).current_pos.x = -400
		if ship(i).current_pos.x < -450 then ship(i).current_pos.x = 400
		if ship(i).current_pos.y > 450 then ship(i).current_pos.y = -400
		if ship(i).current_pos.y < -450 then ship(i).current_pos.y = 400
		if ship(i).current_pos.z > 450 then ship(i).current_pos.z = -400
		if ship(i).current_pos.z < -450 then ship(i).current_pos.z = 400

		behaviour_wander(i)
		behaviour_separation(i)
		behaviour_alignment(i)
		behaviour_cohesion(i)
		
	next i
		
	last_time = current_time
	current_time = timer()
	time_elapsed# = current_time - last_time
	time_elapsed# = time_elapsed# * 0.01
	
	for i = 1 to total_ships
	
		update_vehicle(time_elapsed#, i)
		position object ship(i).obj_no, ship(i).current_pos.x, ship(i).current_pos.y, ship(i).current_pos.z

	next i

	Rem PJY - rotate camera around the centre of the matrix
	control_camera()
	position camera 0, camera.x, camera.y, camera.z
	point camera 0, 0, 0, 0
	sync
	
until spacekey() > 0



Rem PJY - clean up time
for i = 1 to 100
	
	if matrix exist(i) = 1
		
		delete matrix i
		
	endif
	
	if object exist(i) = 1
		
		delete object i
		
	endif
next i



Rem PJY - control camera

function control_camera()

 	if upkey() > 0 
		
		camera_azimuth = camera_azimuth + 1		
		if camera_azimuth => 180
			
			camera_azimuth = 180
			
		endif
		
	endif

	if downkey() > 0
		
		camera_azimuth = camera_azimuth - 1
		if camera_azimuth =< 0
			
			camera_azimuth = 0
			
		endif
		
	endif

	if rightkey() > 0
		
		camera_bearing = wrapvalue(camera_bearing + 1)
		
	endif

	if leftkey() > 0
		
		camera_bearing = wrapvalue(camera_bearing - 1)
		
	endif

	Rem PJY - use spherical 3d coordinates to calculate the camera's new position
	camera.x = (camera_distance * sin(camera_azimuth) * cos(camera_bearing))
	camera.z = (camera_distance * sin(camera_azimuth) * sin(camera_bearing))
	camera.y = (camera_distance * cos(camera_azimuth))

endfunction




Rem PJY - function that updates the ship's behaviour

function behaviour_wander(ship_no AS integer)

	null = make vector3(1)
	null = make vector3(2)
	null = make vector3(3)
	null = make vector3(4)
	
	Rem PJY - get 3 random numbers between -1 and 1
	random1# = random_clamped()
	random2# = random_clamped()
	random3# = random_clamped()
	set vector3 1, random1# * ship(ship_no).wander_jitter,  random2# * ship(ship_no).wander_jitter,  random3# * ship(ship_no).wander_jitter
	ship(ship_no).wander_target.x = ship(ship_no).wander_target.x + x vector3(1)
	ship(ship_no).wander_target.y = ship(ship_no).wander_target.y + y vector3(1)
	ship(ship_no).wander_target.z = ship(ship_no).wander_target.z + z vector3(1)
	set vector3 2, ship(ship_no).wander_target.x, ship(ship_no).wander_target.y, ship(ship_no).wander_target.z
	normalize vector3 2, 2
	multiply vector3 2, ship(ship_no).wander_radius
	ship(ship_no).wander_target.x = x vector3(2)
	ship(ship_no).wander_target.y = y vector3(2)	
	ship(ship_no).wander_target.z = z vector3(2)
	
	targetlocal AS vec
	targetlocal.x = ship(ship_no).wander_target.x * ship(ship_no).wander_distance
	targetlocal.y = ship(ship_no).wander_target.y * ship(ship_no).wander_distance
	targetlocal.z = ship(ship_no).wander_target.z * ship(ship_no).wander_distance

	targetworld AS vec
	set vector3 1, targetlocal.x, targetlocal.y, targetlocal.z
	set vector3 2, ship(ship_no).current_pos.x, ship(ship_no).current_pos.y, ship(ship_no).current_pos.z
	set vector3 3, ship(ship_no).heading_vec.x, ship(ship_no).heading_vec.y, ship(ship_no).heading_vec.z
	set vector3 4, ship(ship_no).side_vec.x, ship(ship_no).side_vec.y, ship(ship_no).side_vec.z
	add vector3 1, 1, 2
	add vector3 1, 1, 3
	add vector3 1, 1, 4
	
	ship(ship_no).target_pos.x = x vector3(1)
	ship(ship_no).target_pos.y = y vector3(1)
	ship(ship_no).target_pos.z = z vector3(1)
	
	subtract vector3 1, 1, 2
	
	ship(ship_no).desired_vec.x = ship(ship_no).desired_vec.x + x vector3(1)
	ship(ship_no).desired_vec.y = ship(ship_no).desired_vec.y + y vector3(1)
	ship(ship_no).desired_vec.z = ship(ship_no).desired_vec.z + z vector3(1)

	null = delete vector3(1)
	null = delete vector3(2)
	null = delete vector3(3)
	null = delete vector3(4)

endfunction




Rem PJY - function that updates the ship's behaviour

function behaviour_separation(ship_no AS integer)

	Rem PJY - the way this works is that each cube checks to see if any of the other cubes are within
	Rem PJY - the separation_distance of that cube. If any are, then it applies an inverse vector to get
	Rem PJY - away from it 
	null = make vector3(1)
	
	separation_distance = 30
	
	Rem PJY - the following method is an inefficient way of achieving this (AS the checking method
	Rem PJY - could be improved to reduce the number of checks needed each processor cycle), but I'll 
	Rem PJY - use it here AS it is simple to understand
	for i = 1 to total_ships
		
		Rem PJY - ensure that we're not checking against the cube we want to move
		if i <> ship_no
		
			set vector3 1, ship(ship_no).current_pos.x - ship(i).current_pos.x, ship(ship_no).current_pos.y - ship(i).current_pos.y, ship(ship_no).current_pos.z - ship(i).current_pos.z
			temp_length# = length vector3(1)
			if temp_length# =< separation_distance
				
				remstart
				divide vector3 1, temp_length#
				normalize vector3 1, 1
				ship(ship_no).desired_vec.x = ship(ship_no).desired_vec.x + x vector3(1)
				ship(ship_no).desired_vec.y = ship(ship_no).desired_vec.y + y vector3(1)
				ship(ship_no).desired_vec.z = ship(ship_no).desired_vec.z + z vector3(1)
				remend
				
				normalize vector3 1, 1
				set vector3 1, x vector3(1) + ship(ship_no).desired_vec.x, y vector3(1) + ship(ship_no).desired_vec.y, z vector3(1) + ship(ship_no).desired_vec.z
				divide vector3 1, temp_length#
				ship(ship_no).desired_vec.x = x vector3(1)
				ship(ship_no).desired_vec.y = y vector3(1)
				ship(ship_no).desired_vec.z = z vector3(1)
				
			endif
		
		endif
		
	next i
	
	null = delete vector3(1)

endfunction




Rem PJY - function that updates the ship's behaviour

function behaviour_alignment(ship_no AS integer)

	Rem PJY - this function tries to average out the heading of all the neighbours of the cube
	average_heading AS vec
	separation_distance = 30
	
	null = make vector3(1)
	
	neighbour_count = 0
	
	Rem PJY - the following method is an inefficient way of achieving this (AS the checking method
	Rem PJY - could be improved to reduce the number of checks needed each processor cycle), but I'll 
	Rem PJY - use it here AS it is simple to understand
	for i = 1 to total_ships
		
		Rem PJY - ensure that we're not checking against the cube we want to move
		if i <> ship_no
		
			set vector3 1, ship(ship_no).current_pos.x - ship(i).current_pos.x, ship(ship_no).current_pos.y - ship(i).current_pos.y, ship(ship_no).current_pos.z - ship(i).current_pos.z
			temp_length# = length vector3(1)
			if temp_length# =< separation_distance
				
				average_heading.x = average_heading.x + ship(i).heading_vec.x
				average_heading.y = average_heading.y + ship(i).heading_vec.y
				average_heading.z = average_heading.z + ship(i).heading_vec.z
				neighbour_count = neighbour_count + 1

			endif
		
		endif
		
	next i
	
	Rem PJY - if there are any neighbours, average out the vectors
	if neighbour_count > 0
		
		set vector3 1, average_heading.x, average_heading.y, average_heading.z
		divide vector3 1, neighbour_count
		average_heading.x = x vector3(1) - ship(ship_no).heading_vec.x
		average_heading.y = y vector3(1) - ship(ship_no).heading_vec.y
		average_heading.z = z vector3(1) - ship(ship_no).heading_vec.z
		ship(ship_no).desired_vec.x = ship(ship_no).desired_vec.x + average_heading.x
		ship(ship_no).desired_vec.y = ship(ship_no).desired_vec.y + average_heading.y
		ship(ship_no).desired_vec.z = ship(ship_no).desired_vec.z + average_heading.z
	
	endif
	
	null = delete vector3(1)

endfunction




Rem PJY - function that updates the ship's behaviour

function behaviour_cohesion(ship_no AS integer)

	Rem PJY - this function creates a steering force that moves the cube towards the
	Rem PJY - the centre of mass of all its neighbours
	centre_of_mass AS vec
	neighbour_count = 0
	separation_distance = 30

	null = make vector3(1)
	
	Rem PJY - the following method is an inefficient way of achieving this (AS the checking method
	Rem PJY - could be improved to reduce the number of checks needed each processor cycle), but I'll 
	Rem PJY - use it here AS it is simple to understand
	for i = 1 to total_ships
		
		Rem PJY - ensure that we're not checking against the cube we want to move
		if i <> ship_no
		
			set vector3 1, ship(ship_no).current_pos.x - ship(i).current_pos.x, ship(ship_no).current_pos.y - ship(i).current_pos.y, ship(ship_no).current_pos.z - ship(i).current_pos.z
			temp_length# = length vector3(1)
			if temp_length# =< separation_distance
				
				centre_of_mass.x = centre_of_mass.x + ship(i).current_pos.x
				centre_of_mass.y = centre_of_mass.y + ship(i).current_pos.y
				centre_of_mass.z = centre_of_mass.z + ship(i).current_pos.z
				neighbour_count = neighbour_count + 1

			endif
		
		endif
		
	next i

	Rem PJY - if there are neighbours, average them together and Seek towards
	Rem PJY - the centre of mass
	if neighbour_count > 0
	
		set vector3 1, centre_of_mass.x, centre_of_mass.y, centre_of_mass.z
		divide vector3 1, neighbour_count
		ship(ship_no).target_pos.x = x vector3(1)
		ship(ship_no).target_pos.y = y vector3(1)
		ship(ship_no).target_pos.z = z vector3(1)
		behaviour_seek(ship_no)
	
	endif

endfunction




Rem PJY - function that updates the ship's behaviour

function behaviour_seek(obj_no AS integer)

	null = make vector3(1)
	null = make vector3(2)
	
	set vector3 1, ship(obj_no).target_pos.x - ship(obj_no).current_pos.x, ship(obj_no).target_pos.y - ship(obj_no).current_pos.y, ship(obj_no).target_pos.z - ship(obj_no).current_pos.z
	
	ship(obj_no).targ_distance = length vector3(1)
	normalize vector3 1, 1
	multiply vector3 1, ship(obj_no).max_speed
	ship(obj_no).targ_vec.x = x vector3(1)
	ship(obj_no).targ_vec.y = y vector3(1)
	ship(obj_no).targ_vec.z = z vector3(1)
	
	set vector3 2, ship(obj_no).velocity.x, ship(obj_no).velocity.y, ship(obj_no).velocity.z
	subtract vector3 1, 1, 2

	ship(obj_no).desired_vec.x = ship(obj_no).desired_vec.x + x vector3(1)
	ship(obj_no).desired_vec.y = ship(obj_no).desired_vec.y + y vector3(1)
	ship(obj_no).desired_vec.z = ship(obj_no).desired_vec.z + z vector3(1)
	
	null = delete vector3(1)
	null = delete vector3(2)

endfunction




Rem PJY - function to update the vehicle's physics

function update_vehicle(time_elapsed AS float, obj_no AS integer)

	null = make vector3(1)
	null = make vector3(2)
	null = make vector3(3)
	null = make vector3(4)

	steering_force AS vec
	steering_force.x = ship(obj_no).desired_vec.x
	steering_force.y = ship(obj_no).desired_vec.y
	steering_force.z = ship(obj_no).desired_vec.z
	set vector3 1, steering_force.x, steering_force.y, steering_force.z
	length# = length vector3(1)
	if length# > ship(obj_no).max_force
		
		normalize vector3 1, 1
		multiply vector3 1, ship(obj_no).max_force
		
	endif
	steering_force.x = x vector3(1)
	steering_force.y = y vector3(1)
	steering_force.z = z vector3(1)

	acceleration AS vec
	acceleration.x = steering_force.x
	acceleration.y = steering_force.y
	acceleration.z = steering_force.z

	set vector3 1, acceleration.x, acceleration.y, acceleration.z
	divide vector3 1, ship(obj_no).mass	
	acceleration.x = x vector3(1)
	acceleration.y = y vector3(1)
	acceleration.z = z vector3(1)
	
	set vector3 1, acceleration.x, acceleration.y, acceleration.z
	multiply vector3 1, time_elapsed
	
	ship(obj_no).velocity.x = ship(obj_no).velocity.x + x vector3(1)
	ship(obj_no).velocity.y = ship(obj_no).velocity.y + y vector3(1)
	ship(obj_no).velocity.z = ship(obj_no).velocity.z + z vector3(1)
	set vector3 1, ship(obj_no).velocity.x, ship(obj_no).velocity.y, ship(obj_no).velocity.z
	length# = length vector3(1)
	if length# => ship(obj_no).max_speed
		
		normalize vector3 1, 1
		multiply vector3 1, ship(obj_no).max_speed
		
	endif
	ship(obj_no).velocity.x = x vector3(1)
	ship(obj_no).velocity.y = y vector3(1)
	ship(obj_no).velocity.z = z vector3(1)
	ship(obj_no).current_speed = length vector3(1)
	
	multiply vector3 1, time_elapsed
	
	ship(obj_no).current_pos.x = ship(obj_no).current_pos.x + x vector3(1)
	ship(obj_no).current_pos.y = ship(obj_no).current_pos.y + y vector3(1)
	ship(obj_no).current_pos.z = ship(obj_no).current_pos.z + z vector3(1)
	
	old_heading AS vec
	old_heading.x = ship(obj_no).heading_vec.x
	old_heading.y = ship(obj_no).heading_vec.y
	old_heading.z = ship(obj_no).heading_vec.z
	
	set vector3 1, ship(obj_no).velocity.x, ship(obj_no).velocity.y, ship(obj_no).velocity.z
	normalize vector3 1, 1
	ship(obj_no).heading_vec.x = x vector3(1)
	ship(obj_no).heading_vec.y = y vector3(1)
	ship(obj_no).heading_vec.z = z vector3(1)
	
	set vector3 2, 0, 0, 0
	cross product vector3 1, 1, 2
	ship(obj_no).side_vec.x = x vector3(1)
	ship(obj_no).side_vec.y = y vector3(1)
	ship(obj_no).side_vec.z = z vector3(1)
	
	null = delete vector3(1)
	null = delete vector3(2)
	null = delete vector3(3)
	null = delete vector3(4)

endfunction



Rem PJY - returns a value between -1 and 1

function random_clamped()
	
	local temp#
	temp# = rnd(200)
	temp# = temp# - 100
	temp# = temp# * 0.01
	
endfunction temp#