-- LUA Script - precede every function and global member with lowercase name of script



ai_newdest_time = {}

ai_cover_on = {}



--cross hairs

local showi = {}

local res = {}

local xang = {}

local dist = {}

--cross hairs



-- init when level first runs

function ai_soldier2_init(e)

 ai_soldier_state[e] = "patrol";

 ai_soldier_pathindex[e] = -1;

 ai_start_x[e] = nil

 ai_starting_heath[e] = nil

 ai_ran_to_cover[e] = 0

 ModulateSpeed(e,1.0)

 ai_old_health[e] = 0

 CharacterControlStand(e)

 ai_returning_home[e] = 0

 ai_newdest_time[e] = -1

 ai_cover_on[e] = 0

 ai_alerted_spoken[e] = 0

 SetCharacterSound(e,"testsoldier")

    --MsgBox ( "soldier init" )

	

--cross hairs

LoadImages("target",1)

SetImagePosition(50,50)

SetImageAlignment(0)

showi[e] = 0

res[e] = 0

xang[e] = 0

dist[e] = 0

--cross hairs

end



-- logic will patrol closest waypoint path, then shoot at player if they

-- get too close, and will run away for cover if their health is low

function ai_soldier2_main(e)



--update cross hairs

if GetPlayerDistance(e) < 2500 then

	SourceAngle = g_PlayerAngY

	while SourceAngle < 0.0 do

		SourceAngle = SourceAngle + 360.0

	end	

	while SourceAngle > 270.0 do

		SourceAngle = SourceAngle - 360.0

	end

		

    PlayerDX = (g_Entity[e]['x'] - g_PlayerPosX)

    PlayerDZ = (g_Entity[e]['z'] - g_PlayerPosZ)

	DestAngle = math.atan2( PlayerDZ , PlayerDX )

	-- Convert to degrees

	DestAngle = (DestAngle * 57.2957795) - 90.0

	

	res[e] = math.abs(math.abs(SourceAngle)-math.abs(DestAngle))

	

	if GetPlayerDistance(e) < 400 then

	dist[e] = 2.5

	xang[e] = 5

	else

	dist[e] = 0.5

	xang[e] = 14

	end

	if res[e] < dist[e] and g_PlayerAngX < xang[e] and g_PlayerAngX > -1 and res[e] ~= 0 then

	showi[e] = 1

	--Prompt(Result)

	ShowImage(1)

	else

	if showi[e] == 1 then

	showi[e] = 0

	HideImage(1)

	end

	end

else

if showi[e] == 1 then

showi[e] = 0

HideImage(1)

end

end

--cross hairs



 -- Detect player distance (note: possible optimization here)

 PlayerDX = g_Entity[e]['x'] - g_PlayerPosX;

 PlayerDY = g_Entity[e]['y'] - g_PlayerPosY;

 PlayerDZ = g_Entity[e]['z'] - g_PlayerPosZ;

 PlayerDist = math.sqrt(math.abs(PlayerDX*PlayerDX)+math.abs(PlayerDY*PlayerDY)+math.abs(PlayerDZ*PlayerDZ));

 

   -- Entity Object Number

 EntObjNo = g_Entity[e]['obj'];

 

 if ai_starting_heath[e] == nil then

	ai_starting_heath[e] = g_Entity[e]['health']

 end

  

 -- Store starting point so we can return there if player moves far away

 if ai_start_x[e] == nil then

	ai_start_x[e] = g_Entity[e]['x']

	ai_start_z[e] = g_Entity[e]['z']

	AISetEntityControl(EntObjNo,AI_MANUAL);

 end

 

 -- Patrol Mode

 if ai_soldier_state[e] == "patrol" then

 

  -- Try and find a close path to patrol, just check once for it

  if ai_soldier_pathindex[e] == -1 then

  

	ai_soldier_pathindex[e] = -2

	

	CharacterControlArmed(e)

	

   -- find initial waypoint path to follow

   PathIndex = -1;

   pClosest = 99999;

   for pa = 1, AIGetTotalPaths(), 1 do

    for po = 1 , AIGetPathCountPoints(pa), 1 do

     pDX = g_Entity[e]['x'] - AIPathGetPointX(pa,po);

     pDZ = g_Entity[e]['z'] - AIPathGetPointZ(pa,po);

     pDist = math.sqrt(math.abs(pDX*pDX)+math.abs(pDZ*pDZ));

     if pDist < pClosest and pDist < 200 then

      pClosest = pDist;

      PathIndex = pa;

     end

    end -- po

   end -- pa

   

   -- follow found path

   if PathIndex > -1 then

    ai_soldier_pathindex[e] = PathIndex;

	ai_path_point_index[e] = 2

	ModulateSpeed(e,1.0)

	SetCharacterToWalk(e)

	ai_path_point_direction[e] = 1

	ai_path_point_max[e] = AIGetPathCountPoints(ai_soldier_pathindex[e])

   end

   

  end

  

  CharacterControlUnarmed(e)

  

  -- If set to head home, lets go there

  if ai_returning_home[e] == 1 then

    tDistX = g_Entity[e]['x'] - ai_start_x[e];

    tDistZ = g_Entity[e]['z'] - ai_start_z[e];

 

	DistToStart = math.sqrt(math.abs(tDistX*tDistX)+math.abs(tDistZ*tDistZ))

	

	if DistToStart < 200 or GetTimer(e) > ai_combat_state_delay[e] then

		ai_soldier_pathindex[e] = -1

		SetCharacterToWalk(e)

		CharacterControlUnarmed(e)

		AIEntityStop(EntObjNo);

		ModulateSpeed(e,1.0)

		ai_returning_home[e] = 0

		ai_soldier_state[e] = "alerted"

		ai_alerted_mode[e] = 0

	else

		AIEntityGoToPosition(EntObjNo,ai_start_x[e],ai_start_z[e])

	end

	

  -- If we have a path then lets patrol it

  elseif ai_soldier_pathindex[e] > -1 then 



	ai_patrol_x[e] = AIPathGetPointX(ai_soldier_pathindex[e],ai_path_point_index[e])

	ai_patrol_z[e] = AIPathGetPointZ(ai_soldier_pathindex[e],ai_path_point_index[e])

  

	AIEntityGoToPosition(EntObjNo,ai_patrol_x[e],ai_patrol_z[e])

  

    tDistX = g_Entity[e]['x'] - ai_patrol_x[e]

    tDistZ = g_Entity[e]['z'] - ai_patrol_z[e]

  

	DistFromPath = math.sqrt(math.abs(tDistX*tDistX)+math.abs(tDistZ*tDistZ))	

	

	if DistFromPath < 50 then

		if ai_path_point_direction[e] == 1 then

			ai_path_point_index[e] = ai_path_point_index[e] + 1

			if ( ai_path_point_index[e] > ai_path_point_max[e] ) then

				ai_path_point_index[e] = ai_path_point_max[e] -1

				ai_path_point_direction[e] = 0

			end

		else

			ai_path_point_index[e] = ai_path_point_index[e] - 1

			if ( ai_path_point_index[e] < 1 ) then

				ai_path_point_index[e] = 2

				ai_path_point_direction[e] = 1

			end		

		end

	end

  else

	CharacterControlFidget(e)

  end

  

  ai_soldier_AggroCheck(e)

  ai_soldier_AlertAggroCheck(e)

  

   -- Alerted, perhaps player is near or gunshots can be heard?

   if PlayerDist < AIGetEntityViewRange(EntObjNo) / 3 or AIGetEntityHeardSound(EntObjNo) == 1 then

	ai_soldier_state[e] = "alerted"

	ai_alerted_mode[e] = 0

	ai_alert_x = g_Entity[e]['x']

	ai_alert_z = g_Entity[e]['z']

	ai_alert_counter = 10

	ai_alert_entity = e

   end

  

 end

 

  -- alerted mode

 if ai_soldier_state[e] == "alerted" then

 

 	LookAtPlayer(e) 

 

	-- alert taken out

	if g_Entity[e]['plrvisible'] == 1 then 

		ai_soldier_state[e] = "combat";

		PlayCombatMusic(8000,500)

		ai_combat_mode[e] = 0

		-- Add this enemy as a point of aggro, alerting anyone near to join the fight

		ai_aggro_entity = e

		ai_aggro_x = g_Entity[e]['x']

		ai_aggro_z = g_Entity[e]['z']



		AISetEntityControl(EntObjNo,AI_MANUAL)

		AIEntityStop(EntObjNo)

		CharacterControlArmed(e)

		SetCharacterToRun(e)

	else

	



	   if ai_alerted_mode[e] == 0 then

	  

		tSpeed = math.random(100,130) / 100.0

		ModulateSpeed(e,tSpeed)

	   

		angle = math.random(360)

		

		ai_dest_x[e] = g_PlayerPosX + (math.sin(angle) * 150)

		ai_dest_z[e] = g_PlayerPosZ + (math.cos(angle) * 150)

		  

		AIEntityGoToPosition(EntObjNo,ai_dest_x[e],ai_dest_z[e]) 

		ai_alerted_state_delay[e] = math.random(0,1)

		ai_alerted_old_time[e] = os.clock()

		CharacterControlArmed(e)

		ai_alerted_mode[e] = 1

		if ai_alerted_spoken[e] == 0 then

			PlayCharacterSound(e,"onAlert")

			ai_alerted_spoken[e] = 1

		end



		-- Target the player, run in to attack

		elseif ai_alerted_mode[e] == 1 then 

		LookAtPlayer(e) 	

		 if os.clock() - ai_alerted_old_time[e] > ai_alerted_state_delay[e] then

			ai_alerted_state_delay[e] = 2

			ai_alerted_mode[e] = 2	

			AIEntityGoToPosition(EntObjNo,ai_dest_x[e],ai_dest_z[e]) 

		 end

		 

		elseif ai_alerted_mode[e] == 2 then

			 if os.clock() - ai_alerted_old_time[e] > ai_alerted_state_delay[e] then		

				AIEntityStop(EntObjNo)

				ai_alerted_mode[e] = 0

				ai_soldier_state[e] = "patrol";

				ai_soldier_AggroCheck(e)

			 end		

		end

		

		if g_Entity[e]['plrvisible'] == 1 then

			ai_soldier_state[e] = "combat";

			PlayCombatMusic(8000,500)

			ai_combat_mode[e] = 0

			-- Add this enemy as a point of aggro, alerting anyone near to join the fight

			ai_aggro_entity = e

			ai_aggro_x = g_Entity[e]['x']

			ai_aggro_z = g_Entity[e]['z']



			AISetEntityControl(EntObjNo,AI_MANUAL)

			AIEntityStop(EntObjNo)

			CharacterControlArmed(e)

			SetCharacterToRun(e)

		end	

	 end

 end



 -- Combat mode

 if ai_soldier_state[e] == "combat" then

 

	LookAtPlayer(e)



	-- If we are the soldier with aggro then update our position so if we run near to others, we can alert them to the fight

	if ai_aggro_entity ~= null then

		if ai_aggro_entity == e then

			ai_aggro_x = g_Entity[e]['x']

			ai_aggro_z = g_Entity[e]['z']

		end

	end

	

	--Prompt(ai_combat_mode[e])

 

  -- Kick off combat by choosing a destination to head for around the player

  if ai_combat_mode[e] == 0 then

    

	tSpeed = math.random(100,130) / 100.0

	ModulateSpeed(e,tSpeed)

   

	angle = math.random(360)

	

	ai_dest_x[e] = g_PlayerPosX + (math.sin(angle) * 200)

	ai_dest_z[e] = g_PlayerPosZ - (math.cos(angle) * 200)

	

	-- Check if we can get to the new position without going around something

	if ( AICouldSee ( EntObjNo , ai_dest_x[e] , g_Entity[e]['y'] , ai_dest_z[e] ) == 0 )  then

		ai_dest_x[e] = g_PlayerPosX;

		ai_dest_z[e] = g_PlayerPosZ;

	end

	

	if PlayerDist < AI_CLOSEST_TO_PLAYER then

		ai_dest_x[e] = g_Entity[e]['x']

		ai_dest_z[e] = g_Entity[e]['z']		

	end

	

	StartTimer(e)

	

	CharacterControlArmed(e)

	ai_combat_mode[e] = 1

	

	ai_cover_on[e] = AIEntityMoveToCover(EntObjNo,g_PlayerPosX,g_PlayerPosZ)

	if ai_cover_on[e] == 0 then 

		AIEntityGoToPosition(EntObjNo,ai_dest_x[e],ai_dest_z[e])

		ai_combat_state_delay[e] = math.random(250,500)

	else

		ai_combat_state_delay[e] = math.random(1000,2000)

	end



  -- Target the player, wait a short time then run in to attack

  elseif ai_combat_mode[e] == 1 then 

  

	if GetTimer(e) > ai_combat_state_delay[e] then

		ai_combat_state_delay[e] = math.random(1000,2500)

		StartTimer(e)

		ai_combat_mode[e] = 2

	end

	if g_Entity[e]['plrvisible'] == 1 then

		FireWeapon(e)	

	end

	

  -- Run to destination for a small amount of time

  elseif ai_combat_mode[e] == 2 then   

  

	if g_Entity[e]['plrvisible'] == 1 then

		FireWeapon(e)

	end



	if (GetTimer(e) > ai_combat_state_delay[e]) or PlayerDist <= AI_CLOSEST_TO_PLAYER then

		ai_combat_mode[e] = 3

	end	



  -- Target the player

  elseif ai_combat_mode[e] == 3 then

  

	CharacterControlArmed(e)

	ai_combat_mode[e] = 4

	if ai_cover_on[e] == 1 then

		ai_combat_state_delay[e] = math.random(500,1500)

	else

		ai_combat_state_delay[e] = math.random(250,500)

	end

	StartTimer(e)



  -- Shoot the player if we can, if not head off to find him

  elseif ai_combat_mode[e] == 4 then

  	

	if g_Entity[e]['plrvisible'] == 1 then

		FireWeapon(e)

	end

  

	if ai_cover_on[e] == 1 then

		CharacterControlDucked(e)	

	end

			   

	-- Once our shooting time has ended, lets go back to mode 0 and start over

	-- If we cannot see the player, wait a short time before hunting him down

	if GetTimer(e) > ai_combat_state_delay[e] then

		CharacterControlStand(e)

		if g_Entity[e]['plrvisible'] == 0 then

			ai_combat_mode[e] = 7

			ai_cover_on[e] = 0

			ai_combat_state_delay[e] = math.random(1000,2000)

			StartTimer(e)

			AIEntityGoToPosition(EntObjNo,g_PlayerPosX,g_PlayerPosZ)

		else 		

			ai_combat_mode[e] = 0

		end

	end 

	

	ai_old_health[e] = g_Entity[e]['health']				

   

   -- In cover, we wait a while, shoot if we can see the player, before venturing out again

   elseif ai_combat_mode[e] == 5 then

	CharacterControlArmed(e)

	

	if g_Entity[e]['plrvisible'] == 1 then

		FireWeapon(e)	

	end

    

	if GetTimer(e) > ai_combat_old_time[e] then	

		ModulateSpeed(e,1.0)

		--AIEntityStop(EntObjNo)

		ai_combat_mode[e] = 0

	end

	  

  -- Out of the range of the player, heading back to start point for a while, once there going back to Patrol mode

  elseif ai_combat_mode[e] == 6 then

	ai_returning_home[e] = 1

	SetCharacterToWalk(e)

	CharacterControlUnarmed(e)	

	AIEntityGoToPosition(EntObjNo,ai_start_x[e],ai_start_z[e])

	ai_soldier_state[e] = "patrol"

	ai_combat_state_delay[e] = 3000

	StartTimer(e)

	tSpeed = math.random(100,130) / 100.0

	ModulateSpeed(e,tSpeed)	

	return

  

  -- Unable to see the player to shoot, so heading after him

  elseif ai_combat_mode[e] == 7 then

  

  	if g_Entity[e]['plrvisible'] == 1 then

		FireWeapon(e)	

	end	

	

	AIEntityGoToPosition(EntObjNo,g_PlayerPosX,g_PlayerPosZ)

  

	if ( g_Entity[e]['plrvisible'] == 1 or PlayerDist <= AI_CLOSEST_TO_PLAYER ) and GetTimer(e) > ai_combat_state_delay[e] then

		ai_combat_mode[e] = 0

	end

	

  elseif ai_combat_mode[e] == 8 then



	ai_combat_mode[e] = 9

	AIEntityStop(EntObjNo)

	

  elseif ai_combat_mode[e] == 9 then



	ai_combat_mode[e] = 10

  	

	-- Pick left or right strafe

	if ( math.random(0,1) == 0 ) then

		SetCharacterToStrafeLeft(e)

	else

		SetCharacterToStrafeRight(e)

	end		

	

	ai_combat_old_time[e] = os.clock()	



  elseif ai_combat_mode[e] == 10 then



	-- We can see the player, lets shoot him!

	if g_Entity[e]['plrvisible'] == 1 then

		FireWeapon(e)

	end



	if os.clock() - ai_combat_old_time[e] > ai_combat_state_delay[e] then

		ai_combat_state_delay[e] = math.random(1,3)

		ai_combat_mode[e] = 4

		ai_old_health[e] = g_Entity[e]['health']

	end

	

	elseif ai_combat_mode[e] == 11 then

	

	if g_Entity[e]['plrvisible'] == 1 then

		if os.clock() - ai_combat_old_time[e] > ai_combat_state_delay[e] then

			CharacterControlStand(e)

			ai_combat_old_time[e] = os.clock()

			ai_combat_state_delay[e] = 1			

			ai_combat_mode[e] = 12

		end

	end	

	

	if ai_combat_mode[e] == 12 then

  

		if g_Entity[e]['plrvisible'] == 1 then

			FireWeapon(e)	

		end



		if os.clock() - ai_combat_old_time[e] > ai_combat_state_delay[e] then

			ai_combat_mode[e] = 4

		end

       	

	

	end

       

  end   

  

  -- If health is below 30, run and hide, then head to mode 5

  if g_Entity[e]['health'] < 30  and ai_combat_mode[e] ~= 4 and ai_ran_to_cover[e] == 0 then

	ModulateSpeed(e,1.3)

	ai_ran_to_cover[e] = 1

	AISetEntityControl(EntObjNo,AI_MANUAL);

	a=AIEntityMoveToCover(EntObjNo,g_PlayerPosX,g_PlayerPosZ);

	ai_combat_old_time[e] = 3000

	StartTimer(e)

	ai_combat_mode[e] = 5

  end   

  

  -- When player out of range, return to patrol

  if PlayerDist > AIGetEntityViewRange(EntObjNo)*1.5 then

	ai_combat_mode[e] = 6		

  end



 end

 

 --if (ai_combat_mode[e] ~= nil) then

 -- PromptLocal(e,"SS:" .. ai_soldier_state[e] .. " CM:" .. ai_combat_mode[e] .. " PV:" .. g_Entity[e]['plrvisible'] )

 --end



end



function ai_soldier_AggroCheck(e)

  -- If there player is in range and we can see him, or we have been shot, move into combat mode

  if PlayerDist < AIGetEntityViewRange(EntObjNo) then 

	if g_Entity[e]['plrvisible'] == 1 or g_Entity[e]['health'] < ai_starting_heath[e] then

	

		ai_soldier_state[e] = "combat";

		PlayCombatMusic(8000,500)

		ai_combat_mode[e] = 0

		PlayCharacterSound(e,"onAggro")

		-- Add this enemy as a point of aggro, alerting anyone near to join the fight

		ai_aggro_entity = e

		ai_aggro_x = g_Entity[e]['x']

		ai_aggro_z = g_Entity[e]['z']

		

		ai_alert_x = g_Entity[e]['x']

		ai_alert_z = g_Entity[e]['z']



		AISetEntityControl(EntObjNo,AI_MANUAL)

		AIEntityStop(EntObjNo);   

		SetCharacterToRun(e)

	else

		-- We cant see the player, but perhaps we are near someone that can

		if ai_aggro_entity ~= nil then

			tDistX = g_Entity[e]['x'] - ai_aggro_x

			tDistZ = g_Entity[e]['z'] - ai_aggro_z

		  

			tDist = math.sqrt(math.abs(tDistX*tDistX)+math.abs(tDistZ*tDistZ))	

		   

		   if tDist < ai_aggro_range then

			   ai_soldier_state[e] = "combat";

			   PlayCombatMusic(8000,500)

			   ai_combat_mode[e] = 0



			   AISetEntityControl(EntObjNo,AI_MANUAL)

			   AIEntityStop(EntObjNo);   

			   SetCharacterToRun(e)

		   end	

	   end

	   



	end

  end

end



function ai_soldier_AlertAggroCheck(e)

  -- If there is an alert close by

  

	if e == ai_alert_entity then

		ai_alert_counter = ai_alert_counter - 1

		if ai_alert_counter <= 0 then

			ai_alert_x = -10000

			ai_alert_z = -10000

			ai_alert_entity = 0  

		end

	end

  

     pDX = g_Entity[e]['x'] - ai_alert_x

     pDZ = g_Entity[e]['z'] - ai_alert_z;

     pDist = math.sqrt(math.abs(pDX*pDX)+math.abs(pDZ*pDZ));

     if pDist < 800 then

		ai_soldier_state[e] = "alerted"

		ai_alerted_mode[e] = 0		

	 end

  

end



function ai_soldier2_exit(e)

	PlayCharacterSound(e,"onDeath")

	showi[e] = 0

	HideImage(1)

end

--cross hairs

local showi = {}

local res = {}

local xang = {}

local dist = {}

--cross hairs



--cross hairs

LoadImages("target",1)

SetImagePosition(50,50)

SetImageAlignment(0)

showi[e] = 0

res[e] = 0

xang[e] = 0

dist[e] = 0

--cross hairs



--update cross hairs

if GetPlayerDistance(e) < 2500 then

	SourceAngle = g_PlayerAngY

	while SourceAngle < 0.0 do

		SourceAngle = SourceAngle + 360.0

	end	

	while SourceAngle > 270.0 do

		SourceAngle = SourceAngle - 360.0

	end

		

    PlayerDX = (g_Entity[e]['x'] - g_PlayerPosX)

    PlayerDZ = (g_Entity[e]['z'] - g_PlayerPosZ)

	DestAngle = math.atan2( PlayerDZ , PlayerDX )

	-- Convert to degrees

	DestAngle = (DestAngle * 57.2957795) - 90.0

	

	res[e] = math.abs(math.abs(SourceAngle)-math.abs(DestAngle))

	

	if GetPlayerDistance(e) < 400 then

	dist[e] = 2.5

	xang[e] = 5

	else

	dist[e] = 0.5

	xang[e] = 14

	end

	if res[e] < dist[e] and g_PlayerAngX < xang[e] and g_PlayerAngX > -1 and res[e] ~= 0 then

	showi[e] = 1

	--Prompt(Result)

	ShowImage(1)

	else

	if showi[e] == 1 then

	showi[e] = 0

	HideImage(1)

	end

	end

else

if showi[e] == 1 then

showi[e] = 0

HideImage(1)

end

end

--cross hairs



--cross hairs

showi[e] = 0

HideImage(1)

--cross hairs

local time1 = 0

local time2 = g_Time

local timepassed = time2 - time1

local imagenumber = 0



--change to however many different images you have

local max_images = 8

local delay = 0.01

--local lightning = 0

--local xpos = math.random(5,95)



function nightvisionshow2_init(e)

LoadImages("nightvision",0)

SetImagePosition(0,0)

SetImageAlignment(1)

--LoadImages("weather/lightning",4)

end



function nightvisionshow2_main(e)



 if g_Entity[e]['plrinzone']==1 then

  SetFogNearest(1)

  SetFogDistance(20)

  SetFogRed(32)

  SetFogGreen(64)

  SetFogBlue(32)

  SetAmbienceIntensity(80)

  SetAmbienceRed(64)

  SetAmbienceGreen(128)

  SetAmbienceBlue(128)

  SetSurfaceRed(64)

  SetSurfaceGreen(128)

  SetSurfaceBlue(128)

 end



if time1 == 0 then

time1 = g_Time

end

time2 = g_Time

timepassed = (time2 - time1) / 1000

if timepassed >= delay then

ShowImage(imagenumber)

if imagenumber < max_images - 1 then

imagenumber = imagenumber + 1

--if math.random(10) == 5 then 

--lightning = 0

--xpos = math.random(5,95)

--end

else

imagenumber = 0

end

time1 = 0

end







 if g_Entity[e]['plrinzone']==0 then



  SetFogNearest(1)

  SetFogDistance(20)

  SetFogRed(40)

  SetFogGreen(40)

  SetFogBlue(32)

  SetAmbienceIntensity(20)

  SetAmbienceRed(32)

  SetAmbienceGreen(32)

  SetAmbienceBlue(32)

  SetSurfaceRed(32)

  SetSurfaceGreen(32)

  SetSurfaceBlue(32)

HideImage(0)

 end

end

local time1 = 0
local time2 = g_Time
local timepassed = time2 - time1
local imagenumber = 0

--change to however many different images you have
local max_images = 8
local delay = 0.01

function nightvisionshow2_init(e)
LoadImages("nightvision",0)
SetImagePosition(0,0)
SetImageAlignment(1)

--starts map as night time
SetFogNearest(1)
SetFogDistance(20)
SetFogRed(40)
SetFogGreen(40)
SetFogBlue(32)
SetAmbienceIntensity(20)
SetAmbienceRed(32)
SetAmbienceGreen(32)
SetAmbienceBlue(32)
SetSurfaceRed(32)
SetSurfaceGreen(32)
SetSurfaceBlue(32)
end
local pressed = 0
local nightvision_on = 0

function nightvisionshow2_main(e)
if nightvision_on == 0 then
Prompt("Press E to put night vision googles on")
else
if time1 == 0 then
	time1 = g_Time
	end
	time2 = g_Time
	timepassed = (time2 - time1) / 1000
	if timepassed >= delay then
	ShowImage(imagenumber)
	time1 = 0
	if imagenumber < max_images - 1 then
	imagenumber = imagenumber + 1
	else
	imagenumber = 0
	end
end

if g_KeyPressE == 1 and pressed == 0 and nightvision_on == 0 then
	nightvision_on = 1
	SetImagePosition(0,0)
	pressed = 1
	SetFogNearest(1)
	SetFogDistance(20)
	SetFogRed(32)
	SetFogGreen(64)
	SetFogBlue(32)
	SetAmbienceIntensity(80)
	SetAmbienceRed(64)
	SetAmbienceGreen(128)
	SetAmbienceBlue(128)
	SetSurfaceRed(64)
	SetSurfaceGreen(128)
	SetSurfaceBlue(128)
	
	
elseif g_KeyPressE == 1 and pressed == 0 and nightvision_on == 1 then
	nightvision_on = 0
	HideImage(0)
	imagenumber = 0
	pressed = 1
	SetFogNearest(1)
	SetFogDistance(20)
	SetFogRed(40)
	SetFogGreen(40)
	SetFogBlue(32)
	SetAmbienceIntensity(20)
	SetAmbienceRed(32)
	SetAmbienceGreen(32)
	SetAmbienceBlue(32)
	SetSurfaceRed(32)
	SetSurfaceGreen(32)
	SetSurfaceBlue(32)
end

if g_KeyPressE == 0 then
	pressed = 0
end
end

function images_init(e)
    LoadImages("hud")
   end

function images_main(e) 

img = health
   SetImagePosition(50,50,15)
   ShowImage(img)  
    end

coverx = {}
coverz = {}
cover_true = {}
--script to define an object as cover
function this_is_cover_init(e)
cover_true[e] = 1
CollisionOff(e)
--Scale(e,50)
end

function this_is_cover_main(e)
CollisionOff(e)
coverx[e] = g_Entity[e]['x']
coverz[e] = g_Entity[e]['z']
end

--cover script by smallg


--change (increase) values here to make the enemies move further when moving around cover (when player is flanking)
local xoffset = 80
local zoffset = 80


local state = {}
local nearest_cover = {}
local cover = {}
local health = {}
local character_stood = {}
local destx = {}
local destz = {}
function ai_init(e)
CharacterControlUnarmed(e)
state[e] = "alert"
nearest_cover[e] = 9999
cover[e] = -1
health[e] = 0
character_stood[e] = 1
destx[e] = 0
destz[e] = 0
end

function ai_main(e)
local ent = g_Entity[e]['obj']

if state[e] == "find_cover" then

--cycle through all available cover and find nearest 1 (except one already at so if we get hit we can find new cover)
for a = 1, 2999 do
if cover_true[a] == 1 then
--range within which to ignore cover (so we actually move)
if GetDistance(e,a) > 150 then
--check new cover is closer then others
if GetDistance(e,a) < nearest_cover[e] then
--first run this will be -1 as we dont have any current cover so need this to stop entity error
if cover[e] ~= -1 then
--this checks for player position (so we wont move closer to the player - hopefully making us harder targets while moving)
if GetPlayerDistance(a) > GetPlayerDistance(cover[e]) then
--we have found new cover so update the nearest distance
nearest_cover[e] = GetDistance(e,a)
--set the entity number of the cover
cover[e] = a
CharacterControlStand(e)
SetCharacterToRun(e)
end
else
nearest_cover[e] = GetDistance(e,a)
cover[e] = a
end
end
end
end
end

destx[e] = coverx[cover[e]]
destz[e] = coverz[cover[e]]

--move the enemy to the new cover
AIEntityGoToPosition(ent,destx[e],destz[e])
state[e] = "moving to new cover"

elseif state[e] == "moving to new cover" then

--range at which we are in cover and can start checking for combat / damage
if GetDistance(e,cover[e]) <= 250 then
nearest_cover[e] = 9999
state[e] = "combat"
--store our current health so we can detect any damage taken while in this cover
health[e] = g_Entity[e]['health']
end


--inital state (currently only rotates to face player and moves to cover when we can see the player)
elseif state[e] == "alert" then
CharacterControlArmed(e)
SetCharacterToRun(e)
RotateToPlayerSlowly(e,4)
if g_Entity[e]['plrvisible'] == 1 then
state[e] = "find_cover"
end

elseif state[e] == "combat" then
--check player position again and update as needed (so we can try stay on the correct side of the cover if he flanks us)
if g_PlayerPosX < coverx[cover[e]] and g_Entity[e]['x'] < coverx[cover[e]] then
destx[e] = coverx[cover[e]] + xoffset
elseif g_PlayerPosX > coverx[cover[e]] and g_Entity[e]['x'] > coverx[cover[e]] then
destx[e] = coverx[cover[e]] - xoffset
end
if g_PlayerPosZ < coverz[cover[e]] and g_Entity[e]['z'] < coverz[cover[e]] then
destz[e] = coverz[cover[e]] + zoffset
elseif g_PlayerPosZ > coverz[cover[e]] and g_Entity[e]['z'] > coverz[cover[e]] then
destz[e] = coverz[cover[e]] - zoffset
end
AIEntityGoToPosition(ent,destx[e],destz[e])

--look at and fire at the player
LookAtPlayer(e)
FireWeapon(e)

--if we can duck and still see the player we will do so (for better cover)
if character_stood[e] == 1 then
CharacterControlDucked(e)
character_stood[e] = 0
end
--if we cant see the player try standing up
if g_Entity[e]['plrvisible'] == 0 then
if character_stood[e] == 0 then
CharacterControlStand(e)
character_stood[e] = 1
--if still cant see the player then we'll go back to alert state -- assumes player moved out of range
else
state[e] = "alert"
end
end

--if we are hit while in cover we should try move to new cover
if g_Entity[e]['health'] < health[e] then
state[e] = "find_cover"
end
end

Prompt(state[e])
end --main

--function called by script to compare 2 entity distances
function GetDistance(e,v)
if g_Entity[e] ~= nil and g_Entity[e] ~= 0 and g_Entity[v] ~= nil and g_Entity[v] ~= 0 then
local disx = g_Entity[e]['x'] - g_Entity[v]['x']
local disz = g_Entity[e]['z'] - g_Entity[v]['z']
local disy = g_Entity[e]['y'] - g_Entity[v]['y']
return math.sqrt(disx^2 + disz^2 + disy^2)
end
end

--cover script by smallg





--change (increase) values here to make the enemies move further when moving around cover (when player is flanking)

local xoffset = 80

local zoffset = 80





local state = {}

local nearest_cover = {}

local cover = {}

local health = {}

local character_stood = {}

local destx = {}

local destz = {}

function ai_init(e)

CharacterControlUnarmed(e)

state[e] = "patrol"

nearest_cover[e] = 9999

cover[e] = -1

health[e] = 0

character_stood[e] = 1

destx[e] = 0

destz[e] = 0

ai_soldier_pathindex[e] = -1

end



function ai_main(e)

local ent = g_Entity[e]['obj']



if state[e] == "patrol" then

SetCharacterToWalk(e)

if ai_soldier_pathindex[e] == -1 then

	if health[e] < g_Entity[e]['health'] then

	health[e] = g_Entity[e]['health']

	end  

	ai_soldier_pathindex[e] = -2

	

   -- find initial waypoint path to follow

   PathIndex = -1;

   pClosest = 99999;

   for pa = 1, AIGetTotalPaths(), 1 do

    for po = 1 , AIGetPathCountPoints(pa), 1 do

     pDX = g_Entity[e]['x'] - AIPathGetPointX(pa,po);

     pDZ = g_Entity[e]['z'] - AIPathGetPointZ(pa,po);

     pDist = math.sqrt(math.abs(pDX*pDX)+math.abs(pDZ*pDZ));

     if pDist < pClosest and pDist < 200 then

      pClosest = pDist;

      PathIndex = pa;

     end

    end -- po

   end -- pa

   

   -- follow found path

   if PathIndex > -1 then

    ai_soldier_pathindex[e] = PathIndex;

	ai_path_point_index[e] = 2

	ModulateSpeed(e,1.0)

	SetCharacterToWalk(e)

	ai_path_point_direction[e] = 1

	ai_path_point_max[e] = AIGetPathCountPoints(ai_soldier_pathindex[e])

   end

   

  end

  -- If we have a path then lets patrol it

  if ai_soldier_pathindex[e] > -1 then 



	ai_patrol_x[e] = AIPathGetPointX(ai_soldier_pathindex[e],ai_path_point_index[e])

	ai_patrol_z[e] = AIPathGetPointZ(ai_soldier_pathindex[e],ai_path_point_index[e])

  

	AIEntityGoToPosition(ent,ai_patrol_x[e],ai_patrol_z[e])

  

    tDistX = g_Entity[e]['x'] - ai_patrol_x[e]

    tDistZ = g_Entity[e]['z'] - ai_patrol_z[e]

  

	DistFromPath = math.sqrt(math.abs(tDistX*tDistX)+math.abs(tDistZ*tDistZ))	

	

	if DistFromPath < 300 then

		if ai_path_point_direction[e] == 1 then

			ai_path_point_index[e] = ai_path_point_index[e] + 1

			if ( ai_path_point_index[e] > ai_path_point_max[e] ) then

				ai_path_point_index[e] = ai_path_point_max[e] -1

				ai_path_point_direction[e] = 0

			end

		else

			ai_path_point_index[e] = ai_path_point_index[e] - 1

			if ( ai_path_point_index[e] < 1 ) then

				ai_path_point_index[e] = 2

				ai_path_point_direction[e] = 1

			end		

		end

	end

	else

	RotateToPlayerSlowly(e,1)

	CharacterControlFidget(e)

	end

	if AIGetEntityHeardSound(ent) == 1 or g_Entity[e]['health'] < health[e] or g_Entity[e]['plrvisible'] == 1 then

	RotateToPlayer(e)

	state[e] = "alert"

	end



elseif state[e] == "find_cover" then



--cycle through all available cover and find nearest 1 (except one already at so if we get hit we can find new cover)

for a = 1, 2999 do

if cover_true[a] == 1 then

--range within which to ignore cover (so we actually move)

if GetDistance(e,a) > 150 then

--check new cover is closer then others

if GetDistance(e,a) < nearest_cover[e] then

--first run this will be -1 as we dont have any current cover so need this to stop entity error

if cover[e] ~= -1 then

--this checks for player position (so we wont move closer to the player - hopefully making us harder targets while moving)

if GetPlayerDistance(a) > GetPlayerDistance(cover[e]) then

--we have found new cover so update the nearest distance

nearest_cover[e] = GetDistance(e,a)

--set the entity number of the cover

cover[e] = a

CharacterControlStand(e)

SetCharacterToRun(e)

end

else

nearest_cover[e] = GetDistance(e,a)

cover[e] = a

end

end

end

end

end



destx[e] = coverx[cover[e]]

destz[e] = coverz[cover[e]]



--move the enemy to the new cover

AIEntityGoToPosition(ent,destx[e],destz[e])

state[e] = "moving to new cover"



elseif state[e] == "moving to new cover" then



--range at which we are in cover and can start checking for combat / damage

if GetDistance(e,cover[e]) <= 250 then

nearest_cover[e] = 9999

state[e] = "combat"

--store our current health so we can detect any damage taken while in this cover

health[e] = g_Entity[e]['health']

end





--inital state (currently only rotates to face player and moves to cover when we can see the player)

elseif state[e] == "alert" then

AIEntityGoToPosition(ent,g_Entity[e]['x'],g_Entity[e]['z'])

CharacterControlArmed(e)

SetCharacterToRun(e)

RotateToPlayer(e)



if g_Entity[e]['plrvisible'] == 1 then

state[e] = "find_cover"

end



elseif state[e] == "combat" then

--check player position again and update as needed (so we can try stay on the correct side of the cover if he flanks us)

if g_PlayerPosX < coverx[cover[e]] and g_Entity[e]['x'] < coverx[cover[e]] then

destx[e] = coverx[cover[e]] + xoffset

elseif g_PlayerPosX > coverx[cover[e]] and g_Entity[e]['x'] > coverx[cover[e]] then

destx[e] = coverx[cover[e]] - xoffset

end

if g_PlayerPosZ < coverz[cover[e]] and g_Entity[e]['z'] < coverz[cover[e]] then

destz[e] = coverz[cover[e]] + zoffset

elseif g_PlayerPosZ > coverz[cover[e]] and g_Entity[e]['z'] > coverz[cover[e]] then

destz[e] = coverz[cover[e]] - zoffset

end

AIEntityGoToPosition(ent,destx[e],destz[e])



--look at and fire at the player

LookAtPlayer(e)

FireWeapon(e)



--if we can duck and still see the player we will do so (for better cover)

if character_stood[e] == 1 then

CharacterControlDucked(e)

character_stood[e] = 0

end

--if we cant see the player try standing up

if g_Entity[e]['plrvisible'] == 0 then

if character_stood[e] == 0 then

CharacterControlStand(e)

character_stood[e] = 1

--if still cant see the player then we'll go back to alert state -- assumes player moved out of range

else

state[e] = "alert"

end

end



--if we are hit while in cover we should try move to new cover

if g_Entity[e]['health'] < health[e] then

state[e] = "find_cover"

end

end



end --main



--function called by script to compare 2 entity distances

function GetDistance(e,v)

if g_Entity[e] ~= nil and g_Entity[e] ~= 0 and g_Entity[v] ~= nil and g_Entity[v] ~= 0 then

local disx = g_Entity[e]['x'] - g_Entity[v]['x']

local disz = g_Entity[e]['z'] - g_Entity[v]['z']

local disy = g_Entity[e]['y'] - g_Entity[v]['y']

return math.sqrt(disx^2 + disz^2 + disy^2)

end

end

--cover script by smallg


--change (increase) values here to make the enemies move further when moving around cover (when player is flanking)
local xoffset = 80
local zoffset = 80


local state = {}
local nearest_cover = {}
local cover = {}
local health = {}
local character_stood = {}
local destx = {}
local destz = {}
function ai_init(e)
CharacterControlUnarmed(e)
state[e] = "patrol"
nearest_cover[e] = 9999
cover[e] = e
health[e] = 0
character_stood[e] = 1
destx[e] = 0
destz[e] = 0
ai_soldier_pathindex[e] = -1
end

function ai_main(e)
local ent = g_Entity[e]['obj']

if state[e] == "patrol" then
SetCharacterToWalk(e)
ModulateSpeed(e,1)
CharacterControlUnarmed(e)
CharacterControlStand(e)
if ai_soldier_pathindex[e] == -1 then
	if health[e] < g_Entity[e]['health'] then
	health[e] = g_Entity[e]['health']
	end  
	ai_soldier_pathindex[e] = -2
	
   -- find initial waypoint path to follow
   PathIndex = -1;
   pClosest = 99999;
   for pa = 1, AIGetTotalPaths(), 1 do
    for po = 1 , AIGetPathCountPoints(pa), 1 do
     pDX = g_Entity[e]['x'] - AIPathGetPointX(pa,po);
     pDZ = g_Entity[e]['z'] - AIPathGetPointZ(pa,po);
     pDist = math.sqrt(math.abs(pDX*pDX)+math.abs(pDZ*pDZ));
     if pDist < pClosest and pDist < 200 then
      pClosest = pDist;
      PathIndex = pa;
     end
    end -- po
   end -- pa
   
   -- follow found path
   if PathIndex > -1 then
    ai_soldier_pathindex[e] = PathIndex;
	ai_path_point_index[e] = 2
	ModulateSpeed(e,1.0)
	SetCharacterToWalk(e)
	ai_path_point_direction[e] = 1
	ai_path_point_max[e] = AIGetPathCountPoints(ai_soldier_pathindex[e])
   end
   
  end
  -- If we have a path then lets patrol it
  if ai_soldier_pathindex[e] > -1 then 

	ai_patrol_x[e] = AIPathGetPointX(ai_soldier_pathindex[e],ai_path_point_index[e])
	ai_patrol_z[e] = AIPathGetPointZ(ai_soldier_pathindex[e],ai_path_point_index[e])
  
	AIEntityGoToPosition(ent,ai_patrol_x[e],ai_patrol_z[e])
  
    tDistX = g_Entity[e]['x'] - ai_patrol_x[e]
    tDistZ = g_Entity[e]['z'] - ai_patrol_z[e]
  
	DistFromPath = math.sqrt(math.abs(tDistX*tDistX)+math.abs(tDistZ*tDistZ))	
	
	if DistFromPath < 300 then
		if ai_path_point_direction[e] == 1 then
			ai_path_point_index[e] = ai_path_point_index[e] + 1
			if ( ai_path_point_index[e] > ai_path_point_max[e] ) then
				ai_path_point_index[e] = ai_path_point_max[e] -1
				ai_path_point_direction[e] = 0
			end
		else
			ai_path_point_index[e] = ai_path_point_index[e] - 1
			if ( ai_path_point_index[e] < 1 ) then
				ai_path_point_index[e] = 2
				ai_path_point_direction[e] = 1
			end		
		end
	end
	else
	RotateToPlayerSlowly(e,3)
	CharacterControlFidget(e)
	end
	if AIGetEntityHeardSound(ent) == 1 or g_Entity[e]['health'] < health[e] or g_Entity[e]['plrvisible'] == 1 then
	RotateToPlayer(e)
	state[e] = "alert"
	end

elseif state[e] == "find_cover" then

--cycle through all available cover and find nearest 1 (except one already at so if we get hit we can find new cover)
for a = 1, 2999 do
if cover_true[a] == 1 then
--range within which to ignore cover (so we actually move)
if GetDistance(e,a) > 150 then
--check new cover is closer then others
if GetDistance(e,a) < nearest_cover[e] then
--this checks for player position (so we're unlikely to move closer to the player - hopefully making us harder targets while moving)
if GetPlayerDistance(a) > GetPlayerDistance(cover[e]) and GetDistance(e,a) <= 800 then
--we have found new cover so update the nearest distance
nearest_cover[e] = GetDistance(e,a)
--set the entity number of the cover
cover[e] = a
CharacterControlStand(e)
SetCharacterToRun(e)
ModulateSpeed(e,1.6)
end
end
end
end
end

destx[e] = coverx[cover[e]]
destz[e] = coverz[cover[e]]

--move the enemy to the new cover
AIEntityGoToPosition(ent,destx[e],destz[e])
state[e] = "moving to new cover"

elseif state[e] == "moving to new cover" then

--range at which we are in cover and can start checking for combat / damage
if GetDistance(e,cover[e]) <= 70 then
nearest_cover[e] = 9999
state[e] = "combat"
--store our current health so we can detect any damage taken while in this cover
health[e] = g_Entity[e]['health']
end


--inital state (currently only rotates to face player and moves to cover when we can see the player)
elseif state[e] == "alert" then
AIEntityGoToPosition(ent,g_Entity[e]['x'],g_Entity[e]['z'])
CharacterControlArmed(e)
SetCharacterToRun(e)
ModulateSpeed(e,1.2)
RotateToPlayer(e)

if g_Entity[e]['plrvisible'] == 1 then
state[e] = "find_cover"
end

elseif state[e] == "combat" then
ModulateSpeed(e,2)
--check player position again and update as needed (so we can try stay on the correct side of the cover if he flanks us)
if g_PlayerPosX < coverx[cover[e]] and g_Entity[e]['x'] < coverx[cover[e]] then
destx[e] = coverx[cover[e]] + xoffset
elseif g_PlayerPosX > coverx[cover[e]] and g_Entity[e]['x'] > coverx[cover[e]] then
destx[e] = coverx[cover[e]] - xoffset
end
if g_PlayerPosZ < coverz[cover[e]] and g_Entity[e]['z'] < coverz[cover[e]] then
destz[e] = coverz[cover[e]] + zoffset
elseif g_PlayerPosZ > coverz[cover[e]] and g_Entity[e]['z'] > coverz[cover[e]] then
destz[e] = coverz[cover[e]] - zoffset
end

AIEntityGoToPosition(ent,destx[e],destz[e])
--look at and fire at the player
ModulateSpeed(e,1.2)
LookAtPlayer(e)
FireWeapon(e)

--if we can duck and still see the player we will do so (for better cover)
if character_stood[e] == 1 then
CharacterControlDucked(e)
character_stood[e] = 0
end
--if we cant see the player try standing up
if g_Entity[e]['plrvisible'] == 0 then
if character_stood[e] == 0 then
CharacterControlStand(e)
character_stood[e] = 1
--if still cant see the player then we'll go back to alert state
else
state[e] = "alert"
end
end

end

--if we are hit we should try move to new cover
if g_Entity[e]['health'] < health[e] then
state[e] = "find_cover"
health[e] = g_Entity[e]['health']
else
--if player too far away go back to patrol
if GetPlayerDistance(e) > 1500 then
state[e] = "patrol"
end
end

end --main

--function called by script to compare 2 entity distances
function GetDistance(e,v)
if g_Entity[e] ~= nil and g_Entity[e] ~= 0 and g_Entity[v] ~= nil and g_Entity[v] ~= 0 then
local disx = g_Entity[e]['x'] - g_Entity[v]['x']
local disz = g_Entity[e]['z'] - g_Entity[v]['z']
local disy = g_Entity[e]['y'] - g_Entity[v]['y']
return math.sqrt(disx^2 + disz^2 + disy^2)
end
end

--lift script by smallg



local low_height = {}

local high_height = {}

local use_range = {}

local lift_speed = {}

local pressed = 0

local state = {}

local up = {}

function lift2_init(e)

state[e] = "wait"

up[e] = 0

use_range[e] = 100

lift_speed[e] = 100

low_height[e] = 610

high_height[e] = 800





--high_height[6] = 1000

--lift_speed[6] = 200

--lift_speed[7] = 400

--high_height[7] = 2000





CollisionOff(e)

Scale(e,175)

end



function lift2_main(e)



if state[e] == "wait" then

if g_Entity[e]['y'] > low_height[e] and up[e] == 0 then

CollisionOff(e)

MoveUp(e,-10)

SetRotation(e,0,0,0)

elseif g_Entity[e]['y'] < high_height[e] and up[e] == 1 then

CollisionOff(e)

MoveUp(e,20)

SetRotation(e,0,0,0)

end

if GetPlayerDistance(e) <= use_range[e] then

if g_KeyPressE == 1 and pressed == 0 then

pressed = 1

if g_Entity[e]['y'] <= low_height[e] then

state[e] = "going up"

up[e] = 1

elseif g_Entity[e]['y'] >= high_height[e] - 10 then

state[e] = "going down"

MoveUp(e,-lift_speed[e]/2)

up[e] = 0

end

end

end

elseif state[e] == "going up" and g_Entity[e]['y'] < high_height[e] then

CollisionOff(e)

MoveUp(e,lift_speed[e])

SetRotation(e,0,0,0)

elseif state[e] == "going down" and g_Entity[e]['y'] > low_height[e] then

CollisionOff(e)

MoveUp(e,-lift_speed[e]/4)

SetRotation(e,0,0,0)

else

state[e] = "wait"

end



CollisionOn(e)

if GetPlayerDistance(e) <= use_range[e] then

Prompt(state[e])

end

if g_KeyPressE == 0 and pressed == 1 then

pressed = 0

end

end

--key to cycle left
local left = "o"
--key to cycle right
local right = "p"
--key to purchase item
local confirm = "["

--distance to shop (to interact)
local shop = 120

--variable used for in game currency
local money = 10000

local pressed = 0
local item = 1
local item_name = {}
local max_item = 5
local item_number = {}
local cost = {}

function shop_init(e)

item_name[1] = "Pistol"
item_name[2] = "Magnum"
item_name[3] = "Uzi"
item_name[4] = "Shotgun"
item_name[5] = "Rifle"

--set item number here of items to be sold (if weapon or ammo etc - if not a real item then enter 0)
item_number[1] = 11
item_number[2] = 12
item_number[3] = 13
item_number[4] = 14
item_number[5] = 15

--set cost of each item here
cost[1] = 100
cost[2] = 150
cost[3] = 200
cost[4] = 250
cost[5] = 300

--folder containing images
LoadImages("shop",1)

end

function shop_main(e)

--if player near shop
if GetPlayerDistance(e) = cost[item] then
--update money and give item
money = money - cost[item]
PlaySound(e,0)
AddPlayerWeapon(item_number[item])
pressed = 1
end
end
--cycle through items
if GetInKey() ==  right then
pressed = 1
if item < max_item then
item = item + 1
else
item = 1
end
elseif GetInKey() == left then
pressed = 1
if item > 1 then
item = item - 1
else
item = max_item
end
end

--show prompt while near shop
Prompt(item_name[item] .. " Costs " .. cost[item] .. " , You have " .. money .. "$")
else

--reset input if key's are released
if GetInKey() ~= left and GetInKey() ~= right and GetInKey() ~= confirm then
pressed = 0
end
end

--update images
SetImageAlignment(0)
SetImagePosition(50,50)
ShowImage(item)
else
HideImage(item)
end
end

--landslide script by smallg

--set to amount of damage to apply per falling rock
local damage = 10
--set to range player needs to be within to start the landslide
local start_fall_range = 300
--set to range player needs to be within to get hit by a rock
local in_damage_range = 70

--set to the starting height you require
local startingY = 300

local state = {}
local damaged = {}
local height = {}
local land_time = {}
 
function landslide_init(e)
CollisionOff(e)
state[e] = "init"
--remember to change scale if rocks are too small / big
Scale(e,2.5)
Hide(e)
damaged[e] = 0
height[e] = 999999
end
 
 
 
function landslide_main(e)
 PlayerDX = g_Entity[e]['x'] - g_PlayerPosX;
 PlayerDZ = g_Entity[e]['z'] - g_PlayerPosZ;
 PlayerDist = math.sqrt(math.abs(PlayerDX*PlayerDX)+math.abs(PlayerDZ*PlayerDZ));
 
 if state[e] == "init" then
 if PlayerDist < start_fall_range then
 Show(e)
 SetPosition(e,g_Entity[e]['x'],g_Entity[e]['y'] + startingY,g_Entity[e]['z'])
 land_time[e] = GetTimer(e) + 10
 CollisionOn(e)
 state[e] = "falling"
 end
elseif state[e] == "falling" then
if GetPlayerDistance(e) < in_damage_range and damaged[e] == 0 then
    HurtPlayer(e,damage)
    damaged[e] = 1
end --end damage check
if GetTimer(e) > land_time[e] then
if g_Entity[e]['y'] >= height[e] + 0.5 then
state[e] = "end"
else
land_time[e] = GetTimer(e) + 10
height[e] = g_Entity[e]['y']
end
end
end
end --end function