Sorry your browser is not supported!

Function GetAngle2D(x1#,y1#,x2#,y2#)
    angle# = atanfull(x2# - x1#, y2# - y1#)
EndFunction angle#
	
Function Distance2D(x1#,y1#,x2#,y2#)
    distance# = sqrt((x1# - x2#)^2 + (y1# - y2#)^2)
EndFunction Distance#

Function WrapAngle(angle#)
    angle# = angle# - floor(angle#/360) * 360
Endfunction angle#

// Project: SpriteInScreen 
// Created: 2020-05-08

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "SpriteInScreen" )
SetWindowSize( 1080, 720, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1080, 720 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
SetScissor( 0,0,0,0 ) // use the maximum available screen space, no black borders
UseNewDefaultFonts( 1 ) // since version 2.0.22 we can use nicer default fonts

SetPrintSize(16)

This= CreateSprite(0)	:	SetSpriteSize(This,32,64)	:	SetSpritePosition(This,100,100)	:	SetSpriteColorAlpha(This,128)

SetSpriteShapePolygon(This,4,0,-16,-32)
SetSpriteShapePolygon(This,4,1,16, -32)
SetSpriteShapePolygon(This,4,2,16,  32)
SetSpriteShapePolygon(This,4,3,-16, 32)


Type VertData
	Angle as Float
	Distance as Float
EndType

Verts as VertData []

for x = 1 to GetSpriteShapeNumVertices(this,1)
	ThisX# = GetSpriteShapeVertexX(This,1,x)
	ThisY# = GetSpriteShapeVertexY(This,1,x)
	ThisVert as VertData
		ThisVert.Angle = GetAngle2D(0,0,ThisX#, ThisY#)
		ThisVert.Distance = Distance2D(0,0,ThisX#, ThisY#)
	Verts.Insert(ThisVert)
next x


Point as integer [] `sprite representations
for x = 0 to Verts.Length
	p = CreateSprite(0)
	SetSpriteSize(p,2,2)
	point.Insert(p)
next x

do
    PAngle# = GetSpriteAngle(this)
	LR = GetRawKeyState(39) - GetRawKeyState(37)
    If LR <> 0 
		PAngle# = WrapAngle(GetSpriteAngle(This) + LR*5.0)
		SetSpriteAngle(this,PAngle#)
    Endif
    

    CX# = GetSpriteXByOffset(this)
    CY# = GetSpriteYByOffset(this)
    
    for x = 0 to Verts.Length
		ThisAngle# = Verts[x].Angle
		ThisDistance# = Verts[x].Distance
		print( STR(ThisAngle#,2) + " @ " + STR(ThisDistance#,2) )
		
			NewAngle# = WrapAngle(ThisAngle# + PAngle#)
			
			SX# = CX# + SIN(NewAngle#) * ThisDistance#
			SY# = CY# + -COS(NewAngle#) * ThisDistance#

			SetSpritePositionByOffset(point[x],SX#,SY#)
    next x

    
    Print (GetSpriteAngle(This))
    Sync()
loop


Function GetAngle2D(x1#,y1#,x2#,y2#)
    angle# = atanfull(x2# - x1#, y2# - y1#)
EndFunction angle#
	
Function Distance2D(x1#,y1#,x2#,y2#)
    distance# = sqrt((x1# - x2#)^2 + (y1# - y2#)^2)
EndFunction Distance#

Function WrapAngle(angle#)
    angle# = angle# - floor(angle#/360) * 360
Endfunction angle#

SetErrorMode(2)

// set window properties
SetWindowTitle( "Test" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
SetScissor( 0,0,0,0 ) // use the maximum available screen space, no black borders
UseNewDefaultFonts( 1 )

id=createSprite(0)
SetSpriteSize(id,50,50)

do
	
	if GetRawKeyState(37) //left
			x=x-5
	endif
	if GetRawKeyState(38) //up
			y=y-5
	endif
	if GetRawKeyState(39) //right
			x=x+5
	endif
	if GetRawKeyState(40) //down
		y=y+5
	endif 				
	//25 is used becuase the sprite is 50 pixels 
	 if GetSpriteX(id)+25<=GetScreenBoundsLeft() then print("Offscreen")
	 if GetSpriteX(id)-25>=GetScreenBoundsRight() then print("Offscreen")
	 if GetSpriteY(id)+25<=GetScreenBoundsTop () then print("Offscreen")
	 if GetSpriteY(id)-25>=GetScreenBoundsBottom () then print("Offscreen")
	SetSpritePositionByOffset(id,x,y)
	Print("X "+str(x))
	Print("Y "+str(y))
	
	sync()
loop

#constant SL GetScreenBoundsLeft()
#constant SR GetScreenBoundsRight()
#constant ST GetScreenBoundsTop()
#constant SB GetScreenBoundsBottom()

#constant TRUE 1
#constant FALSE 0

w = 800
h = 600
SetVirtualResolution(w, h)
SetWindowSize(w, h, 0)


type tVector
	x as float
	y as float
endtype


type tAst
	spr as integer
	ang as float
	rotSpeed as float
	pos as tVector
	vel as tVector
	size as tVector
	vertex as tVector[3]
endtype


global ast as tAst[]


CreateAsteroids()


//**********************************
//		Main Loop
//**********************************
repeat
	UpdateAsteroids()
	sync()
until GetPointerPressed() or GetRawKeyPressed(27)

end



//**********************************
//		Create Asteroids
//**********************************
function CreateAsteroids()
	for k = 0 to 9
		a as tAst
		a.spr = CreateSprite(0)
		a.size.x = Random(25, 100)
		a.size.y = Random(25, 100)
		a.pos.x = Random(SL, SR)
		a.pos.y = Random(ST, SB)
		a.vel.x = Random(0, 100)-50
		a.vel.y = Random(0, 100)-50
		a.rotSpeed = Random(10, 20) - 15
		SetVectorNormalize(a.vel)
		SetSpriteColor(a.spr, 255, 64, 64, 255)
		SetSpriteSize(a.spr, a.size.x, a.size.y)

		ast.insert(a)
	next k
endfunction



//**********************************
//		Update Asteroids
//**********************************
function UpdateAsteroids()
	for k = 0 to ast.length
		
		//Move asteroid
		SetVectorAdd(ast[k].pos, ast[k].vel)
		SetSpritePositionByOffset(ast[k].spr, ast[k].pos.x, ast[k].pos.y)
		
		//Rotate Asteroid
		inc ast[k].ang, ast[k].rotSpeed
		SetSpriteAngle(ast[k].spr, ast[k].ang)
				
		//Perform cheap check for edge wrap
		//If the centre of the asteroid is off screen then do a DeepCheck (more costly maths)
		wrap = FALSE
		if ast[k].pos.x > SR then wrap = DeepCheck(k)
		if ast[k].pos.x < SL then wrap = DeepCheck(k)
		if ast[k].pos.y > SB then wrap = DeepCheck(k)
		if ast[k].pos.y < ST then wrap = DeepCheck(k)
		
		if wrap = TRUE
			WrapAsteroid(k)
		endif	
	next k
endfunction



//**********************************
//		Deep Check()
//**********************************
function DeepCheck(k)	
	//Get all four corner positions
	w# = ast[k].size.x * 0.5
	h# = ast[k].size.y * 0.5
	ast[k].vertex[0].x  = ast[k].pos.x + w# * cos(ast[k].ang) - h# * sin(ast[k].ang)
	ast[k].vertex[0].y  = ast[k].pos.y + w# * sin(ast[k].ang) + h# * cos(ast[k].ang)
	ast[k].vertex[1].x = ast[k].pos.x - w# * cos(ast[k].ang) - h# * sin(ast[k].ang)
	ast[k].vertex[1].y = ast[k].pos.y - w# * sin(ast[k].ang) + h# * cos(ast[k].ang)
	ast[k].vertex[2].x = ast[k].pos.x + w# * cos(ast[k].ang) + h# * sin(ast[k].ang)
	ast[k].vertex[2].y = ast[k].pos.y + w# * sin(ast[k].ang) - h# * cos(ast[k].ang)
	ast[k].vertex[3].x = ast[k].pos.x - w# * cos(ast[k].ang) + h# * sin(ast[k].ang)
	ast[k].vertex[3].y = ast[k].pos.y - w# * sin(ast[k].ang) - h# * cos(ast[k].ang)
	
	//Draw a debug ellipse at each vertex to show we are deep checking
	for vx = 0 to 3
		DrawEllipse(ast[k].vertex[vx].x, ast[k].vertex[vx].y, 5, 5, 0xFFFFFF, 0xFFFFFF, 1)
	next vx
	
	/*	Check each of the four corners in turn
		If any of them are in stll on screen then exit the function
		as FALSE because at least part of the asteroid is still on screen */	
	for vx = 0 to 3
		if ast[k].vertex[vx].x > SL
			if ast[k].vertex[vx].x < SR
				if ast[k].vertex[vx].y > ST
					if ast[k].vertex[vx].y < SB
						exitfunction FALSE
					endif
				endif
			endif
		endif	
	next vx
	//To get this far in the function must mean that the asteroid is completely off screen
	//So end the function and return TRUE
endfunction TRUE



//**********************************
//		Wrap Asteroid()
//**********************************
function WrapAsteroid(k)
	/*	Wrap the asteroid to the other side of the screen using 
		an offset of how far off it has already gone */
	if ast[k].pos.x > SR
		ast[k].pos.x = SL + (SR - ast[k].pos.x)
	elseif ast[k].pos.x < SL
		ast[k].pos.x = SR + (SL - ast[k].pos.x)
	endif
	
	if ast[k].pos.y > SB
		ast[k].pos.y = ST + (SB - ast[k].pos.y)
	elseif ast[k].pos.y < ST
		ast[k].pos.y = SB + (ST - ast[k].pos.y)
	endif
endfunction



//********************************************* V E C T O R   M A T H S **********************************************

//**********************************
//	Vector Normalise
//**********************************
//Directly normalise the passed vector
function SetVectorNormalize(v ref as tVector)
	l# = GetVectorLength(v)
	v.x = v.x / l#
	v.y = v.y / l#
endfunction



//**********************************
//	Vector Addition
//**********************************
//Adds two vectors and puts the return value in v1
function SetVectorAdd(v1 ref as tVector, v2 as tVector)
	inc v1.x, v2.x 
	inc v1.y, v2.y
endfunction 



//**********************************
//	Vector Get Length
//**********************************
function GetVectorLength(v as tVector)
	l# = sqrt( (v.x*v.x) + (v.y*v.y) )
endfunction l#