Sorry your browser is not supported!

/*******************************************************************************************************************************
	LoadCryptImage(filename, key)
	filename - The file containing the encrypted image
	key - The key used to decrypt the file
	
	returns;
		The id of the loaded image or 0 if it fails
 *******************************************************************************************************************************/	
function LoadCryptImage(filename as string, key as string)
	block as integer
	r as integer
	
	block = CreateMemblockFromFile(filename)
	
	CryptMemBlock32(block, key)
	
	r = CreateImageFromMemblock(block)
	
	DeleteMemblock(block)	
		
endfunction r
	
/*******************************************************************************************************************************
	CryptImage(source, destination, key)
	source - The image file to encrypt
	destination - The file that will contain the encrypted result
	key - The key used to encrypt the file
	
	returns;
		The size of the memblock (and encrypted file) or 0 if it fails	
 *******************************************************************************************************************************/	
function	CryptImage(source as string, destination as string, key as string)
	block as integer
	r as integer


	block = CryptMemBlock32(CreateMemblockFromImage(LoadImage(source)), key)	

	if (block = 0)
		exitfunction 0
	endif
	
	SetRawWritePath(readpath)		
	CreateFileFromMemblock(destination, block)

	if (GetFileExists(destination) = 1)
		r = GetMemblockSize(block)
	else
		r = 0
	endif
	
	DeleteMemblock(block)
	
endfunction r	

/*******************************************************************************************************************************
	CryptMemBlock(block, key)
	block - The id of a memblock to encrypt/decrypt
	key - The key used to generate a hash key to encrypt the block
	
	returns;
		The id of the memblock or 0 if it fails		
 *******************************************************************************************************************************/
function CryptMemBlock32(block as integer, key as string)
	size as integer
	length as integer
	hash as string
	i as integer
	k as integer
	r as integer
	l as integer
	b as integer
	remain as integer
	ints as integer	
	integers as integer[]
		
	size = GetMemblockSize(block)		
	dec size
	if (size = 0)
		exitfunction 0
	endif
	
	hash = sha1(key+"AgkIsAwesome")			/* Make a hash of the key */
	length = len(hash)
	
	ints = CreateMemblock(length + 1)		/* Create a memblock of the hash */
	SetMemblockString(ints, 0, hash)
	
	for i=0 to length - 1 step 4			/* Convert the memblock to an array of integers */
		integers.insert(GetMemblockInt(ints, i))		
	next
	
	DeleteMemblock(ints)					/* Now that we have an array of integers we dont need the memblock */
		
	l=0
	for i=0 to size step 4					/* Encrypt the memblock */
		k = integers[l]						/* Load an integer from the array */
		inc l
		if l > integers.length				/* If we are at the end of the array start again from the beginning */
			l=0
		endif
		b = GetMemblockInt(block, i) ~~ k	/* Xor the integer in the memblock with our integer entry */
		SetMemblockInt(block, i, b)			/* Save it back into the memblock */
	next	
		

endfunction block

/************************************************************************************************************
image_crop(image, x, y, width, height)
	image 	image id to crop
	x     	Starting column to crop (from zero)
	y   	Starting row to crop (from zero)
	width  	Width of the crop area
	height 	Height of the crop area
	
returns;
	image id of the new cropped image
************************************************************************************************************/

function image_crop(image as integer, x as integer, y as integer, width as integer, height as integer)
	m as integer
	w as integer
	h as integer
	n as integer
	i as integer
	a as integer
	d as integer
	
	n = CreateMemblock(width * height * 4 + 12)			/* Create a memblock for the cropped image */
	m = CreateMemblockFromImage(image)					/* Creat a memblock from the larger image */

	SetMemblockInt(n, 0, width)							/* Setup the width/hight/bit depth for the new image */
	SetMemblockInt(n, 4, height)	
	SetMemblockInt(n, 8, getmemblockint(m, 8))		

	w = getmemblockint(m, 0)							/* Get the width/height of the larger image */
	h =	getmemblockint(m, 4)	
	
	for d=y to height + y - 1							/* Crop that suckka! */
		for a=x to width + x - 1
			SetMemblockInt(n, ((d - y) * width * 4) + ((a - x) * 4) + 12, GetMemblockInt(m, (d * w * 4) + (a * 4) + 12))
		next
	next 
		
	i = CreateImageFromMemblock(n)						/* Create the cropped image from the newly created memblock */
	
	DeleteMemblock(n)									/* Cleanup the memblocks */
	DeleteMemblock(m)
	
endfunction i

// Project: Simulated Limbs - Alex Schmidt - online-arts.de
// Created: 2016-05-06

// This functions can simulate limbs in AGK. Every limb will be registered and can be
// found and then manipulated with the standard object commands.


// set window properties
SetWindowTitle( "Simulated Limbs - Alex Schmidt - online-arts.de" )
SetWindowSize( 1024, 768, 0 )

// set display properties
SetVirtualResolution( 1024, 768 )
SetOrientationAllowed( 1, 1, 1, 1 )





// create demo media:

// create the main object, the root for the other limbs
main = CreateObjectBox(1,1,1)
setobjectposition(main,-5,0,0)

// create a 2nd main object
main2 = CreateObjectBox(1,1,1)
setobjectposition(main2,5,0,0)



	// add 20 planes to the object main
		for i=0 to 19
			limb = CreateObjectPlane(1,1)
			
			
			addLimb(limb,main)
			
			// rotate, position limb object randomly
			SetObjectPosition(limb,random(0,4)-2,random(0,4),random(0,4)-2)
			SetObjectRotation(limb,random(-180,180),random(-180,180),random(-180,180))
		next i


	// add 10 planes to the object main2
		for i=0 to 9
			limb = CreateObjectPlane(1,1)
			
			
			addLimb(limb,main2)
			
			// rotate, position limb object randomly
			SetObjectPosition(limb,random(0,4)-2,random(0,4),random(0,4)-2)
			SetObjectRotation(limb,random(-180,180),random(-180,180),random(-180,180))
		next i


do
	
	
	print("Limbs Simuation in AGK")
	print("======================")
	print("")
	print("")
	print("")
	print("")
	print("")
	print("")
	print("")
	print("")
	print("")
	print("")
	print("")
	print("")
	print("")
	print("")
	print("")
	
	
	print("Object main limb count: "+ str(getObjectLimbCount(main)))
	print("Object main2 limb count: "+ str(getObjectLimbCount(main2)))
	
	print("Object(s) with limbs: "+str(ObjectLimb.length))
	
	
	
	// point all limbs of main to the camera
	
	for i=1 to getObjectLimbCount(main)
		limb=getObjectLimb(main,i)
		SetObjectLookAt( limb,getcamerax(1),getcameray(1),getcameraz(1),1 ) 
	next i
	
	
	
	// rotate main objects
	SetObjectRotation(main,0,sin(timer())*3600,0)
	SetObjectRotation(main2,0,sin(timer())*3600,0)
    

    Print( ScreenFPS() )
    Sync()
loop




// LIMB Functions by Jack 
// ======================

// yet small and simple but powerful (if you need it), use this functions to add objects to objects.
// Each attached object is saved as a virtual limb, it still remains an object but is saved inside 
// the list attached to the main object.
// you can get the total limb list, and find the Object for each defined limb 
// ==================================================================

// adds a limb to the object and saves that information for later use
function addLimb(limb,main)

list as integer

	if ObjectLimb.length=-1	// if no array to count the limb objects exists, add a new one 
		dim ObjectLimb[0,0] as integer
	endif
	

	// first, search if the main object is already in the limb object list (already limbs added)
	for i=0 to ObjectLimb.length

		
		if ObjectLimb[i,0] = main // if so, then the list is the list number of the limb object
			list = i
			exit
		endif
	next i
		
		
		FixObjectToObject(limb,main)
		
		if list = 0 // if there is nothing found, increase the array count
			
			ObjectLimb.length=ObjectLimb.length+1
			
			
	
			ObjectLimb[ObjectLimb.length].length=ObjectLimb[ObjectLimb.length].length+1
			ObjectLimb[ObjectLimb.length,0] = main // define main object in array count [x,0]
			ObjectLimb[ObjectLimb.length].length=ObjectLimb[ObjectLimb.length].length+1
			
			
			ObjectLimb[ObjectLimb.length,ObjectLimb[ObjectLimb.length].length] = limb
			
		else // if something was found, just add the limb to the limb list
			ObjectLimb[list].length=ObjectLimb[list].length+1
			ObjectLimb[list,ObjectLimb[list].length] = limb
						
		endif
		
endfunction


// gets the total limb count of the object
function getObjectLimbCount(main)
	
limbcount as integer

	
		// first, search if the main object is already in the limb object list (already limbs added)
	for i=0 to ObjectLimb.length
		
		if ObjectLimb[i,0] = main // if so, then the list is the list number of the limb object
			limbcount = ObjectLimb[i].length
			
			exit
		endif
	next i
	
	
	
	
	
endfunction limbcount


// returns the limb object for the given limb number inside the given main object
function getObjectLimb(main,limbnum)

limb as integer

		// first, search if the main object is already in the limb object list (already limbs added)
	for i=0 to ObjectLimb.length
		
		if ObjectLimb[i,0] = main
			limb = ObjectLimb[i,limbnum]
			exit
		endif
	next i

	
endfunction limb

// ==================================================================

remstart
	This function generates a circle image with a radial gradient.
	This function is very slow on mobile so avoid using large images if you can.
	The rule is, stay below 1024 total width.
	
	_sizeInPixels + _emptyBorderInPixels = image width/height
	ex. 480 + 32 = 512x512 image
	ex. Generate_Radial_Gradient_Circle_Image( 480, 32, 0.0, 25, 225, 225, 255, 0, 0, 0, 0 )
	
	_sizeInPixels - This is the size of the circle.
	_emptyBorderInPixels - This is the empty transparent edge pixels.
	_ratio# - This controls how much of the gradient to apply. 0.0 = no gradient, 1.0 = full gradient
	
	The color applied to the center of the circle.
	_c0r - Red
	_c0g - Green
	_c0b - Blue
	_c0a - Alpha
	
	The color applied to the outside of the circle.
	_c1r - Red
	_c1g - Green
	_c1b - Blue
	_c1a - Alpha
remend
function Generate_Radial_Gradient_Circle_Image( _sizeInPixels, _emptyBorderInPixels, _ratio#, _c0r, _c0g, _c0b, _c0a, _c1r, _c1g, _c1b, _c1a )
	if _sizeInPixels < 0 or _emptyBorderInPixels < 0
		Message("Parameters cannot be less than zero." + chr( 10 ) + chr( 10 ) + "> Error from Generate_Radial_Gradient_Circle_Image() <")
		//~ exitfunction
		end
	endif
	// Total size in pixels for width/height.
	_totSizePix = _sizeInPixels + _emptyBorderInPixels
	_imgID = 0
	_cratio# = clamp_float( 1.0 - _ratio#, 0.0, 1.0 )
		
	if _totSizePix >= 4
		// Total amount of bytes plus header.
		_totSizeBytes = ( ( _totSizePix * _totSizePix ) * 4 ) + 12
			
		if _totSizeBytes <= 100000000
			// The distance to compare to the pixel.
			_dist# = _sizeInPixels * ( _sizeInPixels * 0.25 )
			
			// Ratio * distance.
			_rDist# = _dist# * _cratio#
			
			_rFac# = _dist# / 1.5
			
			// The center point to determine distance.
			_c# = _totSizePix * 0.5 + 0.5
			
			_mb = CreateMemblock( _totSizeBytes )
			
			// Set header
			SetMemblockInt( _mb, 0, _totSizePix )
			SetMemblockInt( _mb, 4, _totSizePix )
			SetMemblockInt( _mb, 8, 32 )
			
			_currByte = 12
			
			// Set pixel data.
			for x = 1 to _totSizePix
				for y = 1 to _totSizePix
					// The distance from the center to the current pixel.
					_testDist = pow( _c# - x, 2 ) + pow( _c# - y, 2 )
					
					// The scalar used to interpolate the colors.
					_factor# = clamp_float(( _testDist - _rDist# ) / _rFac#, 0.0, 1.0 )
					
					// If the distance from the center to the pixel is less than a distance derived from the ratio * circle width.
					if _testDist < _rDist#
						SetMemblockByte( _mb, _currByte, _c0r )		// R
						SetMemblockByte( _mb, _currByte + 1, _c0g )	// G
						SetMemblockByte( _mb, _currByte + 2, _c0b )	// B
						SetMemblockByte( _mb, _currByte + 3, _c0a )	// A
						
					// If the distance from the center to the pixel is less than _dist#.
					elseif _testDist < _dist#
						// Linear Interpolate colors.
						SetMemblockByte( _mb, _currByte, (( 1.0 - _factor# ) * _c0r ) + ( _factor# * _c1r ) )		// R
						SetMemblockByte( _mb, _currByte + 1, (( 1.0 - _factor# ) * _c0g ) + ( _factor# * _c1r ) )	// G
						SetMemblockByte( _mb, _currByte + 2, (( 1.0 - _factor# ) * _c0b ) + ( _factor# * _c1b ) )	// B
						SetMemblockByte( _mb, _currByte + 3, (( 1.0 - _factor# ) * _c0a ) + ( _factor# * _c1a ) )	// A
						
					// Else the color is transparent.
					else
						SetMemblockByte( _mb, _currByte, 0 )		// R
						SetMemblockByte( _mb, _currByte + 1, 0 )	// G
						SetMemblockByte( _mb, _currByte + 2, 0 )	// B
						SetMemblockByte( _mb, _currByte + 3, 0 )	// A
					endif
					inc _currByte, 4
				next y
			next x
			
			// Create the image and clean up.
			_imgID = CreateImageFromMemblock( _mb )
			DeleteMemblock( _mb )
		else
			Message("Memblock bytes exceeded the maximum limit of 100,000,000 bytes." + chr( 10 ) + chr( 10 ) + "< Error from Generate_Radial_Gradient_Circle_Image() >")
			end
		endif
	else
		Message("Image must be at least 16 pixels." + chr( 10 ) + chr( 10 ) + "< Error from Generate_Radial_Gradient_Circle_Image() >")
		end
	endif
endfunction _imgID

// Returns a value clamped between min/max. This is used in the Generate_Radial_Gradient_Circle_Image() function above.
function clamp_float( _val#, _min#, _max# )
	if _val# <= _min#
		exitfunction _min#
	elseif _val# >= _max#
		exitfunction _max#
	endif
endfunction _val#

image = CreateImageColor(70,70,255,0) // enter whatever colour you want here
sprite = CreateSprite(image)
SetSpriteSize(sprite,320,320)   // enter whatever size you want here
SetSpriteTransparency(sprite,1)
vertshad$="attribute highp vec4 position; attribute mediump vec4 color; attribute mediump vec2 uv; varying mediump vec2 uvVarying; varying mediump vec4 colorVarying; uniform highp mat4 agk_Ortho; void main(){ gl_Position = agk_Ortho * position; uvVarying = uv; colorVarying = color; }"
pixshad$="uniform sampler2D texture0; varying mediump vec2 uvVarying; varying mediump vec4 colorVarying;"+"mediump vec2 Centre = vec2(0.5,0.5);mediump float Dist;"+"void main(){gl_FragColor = texture2D(texture0, uvVarying) * colorVarying;"+"Dist = distance(Centre,uvVarying)*2.0; Dist = 1.0- pow(Dist,1.5);gl_FragColor.w = Dist;}"
shader = LoadShaderFromString( vertshad$, pixshad$ )
SetSpriteShader(sprite,shader)

//place these at top of program
#constant    white        =   MakeColor(0,0,255)
#constant    green        =   MakeColor(0,255,0)
#constant    blue         =   MakeColor(0,0,255)
#constant    yellow       =   MakeColor(255,255,0)
#constant    black        =   MakeColor(0,0,0)

//main program here
createSprite(1,createTriangleSprImage())
createSprite(2,createEnemySprImage())
SetSpritePosition(1,random(100,200),random(100,200))
SetSpritePosition(2,random(200,300),random(200,300))
do
     sync()
loop
end

function createTriangleSprImage()
    rem draw a triangle image used for the player sprite on radar
    SetClearColor(0,0,0)
    ClearScreen()
    Render()
    DrawLine(5,0,9,9,green,green)
    DrawLine(1,8,8,8,green,green)
    DrawLine(1,9,5,0,green,green)
    //DrawLine(5,0,5,9,green,green)
     
    //draw these if you want it filled
    DrawLine(4,0,8,9,green,green)
    DrawLine(0,9,8,9,green,green)
    DrawLine(0,9,4,0,green,green)   
    DrawBox(4,1,6,8,green,green,green,green,1)
     
    swap()
    img = getimage(0,0,10,10)
    SetImageTransparentColor(img,0,0,0)
endfunction img
 
function createEnemySprImage()
    rem draw a circle image used for the player sprite on radar
    SetClearColor(0,0,0)
    ClearScreen()
    Render()
    DrawEllipse(6,6,4,4,yellow,yellow,0)
    DrawEllipse(6,6,3,3,yellow,yellow,0)
    swap()
    img = getimage(0,0,12,12)
    SetImageTransparentColor(img,0,0,0)
endfunction img

function	CenterObjectAtObject(object as integer, center as integer, x as integer, y as integer, z as integer)
	o 	as point
	c	as point
	d	as point
	n	as point
	
	o.x = GetObjectX(object)
	o.y = GetObjectY(object)
	o.z = GetObjectZ(object)
	
	c.x = GetObjectX(center)
	c.y = GetObjectY(center)		
	c.z = GetObjectZ(center)
		
	d.x = c.x - o.x
	d.y = c.y - o.y
	d.z = c.z - o.z
	
	n.x = 0
	n.y = 0
	n.z = 0
	
	if x = TRUE
		n.x = d.x * -1
	endif
		
	if y = TRUE
		n.y = d.y * -1
	endif

	if z = TRUE
		n.z = d.z * -1
	endif
	
	SetObjectPosition(object, n.x, n.y, n.z)
	FixObjectPivot(object)

	if x = TRUE
		o.x = c.x
	endif
		
	if y = TRUE
		o.y = c.y 
	endif

	if z = TRUE
		o.z = c.z
	endif
	
	SetObjectPosition(object, o.x, o.y, o.z)
			
endfunction

function Clamp( value#, lowestvalue#, highestvalue# )
	if value# < lowestvalue#
		value# = lowestvalue#
	elseif value# > highestvalue#
		value# = highestvalue#
	endif
endfunction value#

Function Crunch_Image( id as integer ,filter as integer)
    saveimage(id,str(id)+".png")
    deleteimage(id)
    LoadImageResized(id,str(id)+".png",(240.0/getdevicewidth())*3.04,(160.0/getdeviceheight())*3.04,0)
    SetImageMagFilter(id,filter)
    SetImageMinFilter(id,filter)
Endfunction

       x as float = 0.0
       y as float =0.0
       xPixel as float
       yPixel as float
       // to get the grabbed image as small as possible
       if getdevicewidth()>(240*5)
          xPixel=getdevicewidth()/(240*5)
          yPixel=GetDeviceHeight()/(160*5)
       elseif getdevicewidth()>(240*4)
	      xPixel=getdevicewidth()/(240*4)
          yPixel=GetDeviceHeight()/(160*4)
	   elseif getdevicewidth()>(240*3.5)
	      xPixel=getdevicewidth()/(240*3.5)
          yPixel=GetDeviceHeight()/(160*3.5)
	   else 
	      xPixel=getdevicewidth()/(240*3)
          yPixel=GetDeviceHeight()/(160*3)
    endif
   	     

    c=MakeColor(r,g,b)
    drawbox(x,y,x+xPixel,y+yPixel,c,c,c,c,1)
    getimage(tile,0,0,16*xPixel,16*yPixel)