--pick up and deliver quest script by smallg

local quest_stage = {}

local time1 = 0
local time2 = 0
local timepassed = 0
local delay = 100
local pressed = 0
local quests = 0

local pickup_quest_npc = {}
local first_pickup_e = {}
local last_pickup_e = {}
local quest_talk_range = {}
local items_collected = {}
local collected = {}
local item_name = {}
local repeatable = {}
local pickup_range = {}
local x = {}
local y = {}
local z = {}
local cash = 0

function pickup_quest_init(e)
quests = quests + 1
quest_stage[quests] = 0
items_collected[quests] = 0
end --init

--setup quests here (***change the entity numbers to fit your own map or script will not work correctly***)
--set the number for the quest (i.e, 1, 2, 3 etc)
quest_number = 1
--set to the entity number of the quest giver
pickup_quest_npc[quest_number] = 2
--entity number of the first item to be collected (lowest entity number)
first_pickup_e[quest_number] = 3
--entity number of the last item to be collected (highest entity number)
last_pickup_e[quest_number] = 7
--name of item to be collected here (for prompts)
item_name[quest_number] = "Explosive Barrel"
--how close the player needs to be to accept and hand-in the quest
quest_talk_range[quest_number] = 150
--how close the player needs to be to pickup the collectable items
pickup_range[quest_number] = 100
--set to 1 if quest can be repeated (no limit) or 0 if a one time only quest
repeatable[quest_number] = 1

--quest2
quest_number = 2
pickup_quest_npc[quest_number] = 10
item_name[quest_number] = "Health Pack"
first_pickup_e[quest_number] = 11
last_pickup_e[quest_number] = 12
quest_talk_range[quest_number] = 150
pickup_range[quest_number] = 100
repeatable[quest_number] = 0

--quest3

--------

function pickup_quest_main(e)
for quest_number = 1, quests do
if g_Entity[pickup_quest_npc[quest_number]] ~= nil then
--check player in range of a quest giver
if GetPlayerDistance(pickup_quest_npc[quest_number]) <= quest_talk_range[quest_number] then
CharacterControlStand(e)
RotateToPlayer(pickup_quest_npc[quest_number])
--if quest not started yet
if quest_stage[quest_number] == 0 then
Prompt("Hi there, please collect " .. 1 + last_pickup_e[quest_number] - first_pickup_e[quest_number] .. " " .. item_name[quest_number] .. "s for me")
--if player accepts quest
if g_KeyPressE == 1 and pressed == 0 then
pressed = 1
PromptDuration("Come back with my " .. item_name[quest_number] .. "s soon please",2000)
quest_stage[quest_number] = quest_stage[quest_number] + 1
end --end accepted quest
--if quest already started
elseif quest_stage[quest_number] == 1 then
--check how many items the player has
if items_collected[quest_number] > 0 then
--if not collected enough then show how many are left to collect
if items_collected[quest_number] < 1 + last_pickup_e[quest_number] - first_pickup_e[quest_number] then
Prompt("I still need " .. 1 + (last_pickup_e[quest_number] - first_pickup_e[quest_number]) - items_collected[quest_number] .. " " .. item_name[quest_number])
else
Prompt("Finish quest?")
--if player has collected all needed items
if g_KeyPressE == 1 and pressed == 0 then
-----
--insert reward code here
--example reward
cash = cash + 100
-----
--change prompt to match reward
PromptDuration("Thank you, cash = " .. cash,2000)
items_collected[quest_number] = 0
quest_stage[quest_number] = quest_stage[quest_number] + 1
pressed = 1
-----
end --player hands quest in
end --items collected number check
end --items collected above 0
end --stage number check
else
--if quest finished but repeatable reset it
if repeatable[quest_number] == 1 and quest_stage[quest_number] == 2 then
quest_stage[quest_number] = 0
--replace collectables
for item = first_pickup_e[quest_number], last_pickup_e[quest_number] do
Show(item)
CollisionOn(item)
collected[item] = 0
end --for item loop
end --quest reset check
end --player in quest giver range check

for item = first_pickup_e[quest_number], last_pickup_e[quest_number] do
if g_Entity[item] ~= nil then
if collected[item] == nil then
collected[item] = 0
end
if GetPlayerDistance(item) <= pickup_range[quest_number] and quest_stage[quest_number] == 1 and collected[item] == 0 then
Prompt("Collect " .. item_name[quest_number] .. "?")
if g_KeyPressE == 1 and pressed == 0 then
pressed = 1
collected[item] = 1
items_collected[quest_number] = items_collected[quest_number] + 1
Hide(item)
CollisionOff(item)
end --collected item
end --player in range of item
end --exist check
end --for item loop
end --quest giver exist
end --for quest_number loop
--reset input
if g_KeyPressE == 0 then
pressed = 0
end

end --main

--if quest finished but repeatable reset it
if repeatable[quest_number] == 1 and quest_stage[quest_number] == 2 then
quest_stage[quest_number] = 0
--replace collectables
for item = first_pickup_e[quest_number], last_pickup_e[quest_number] do
Show(item)
CollisionOn(item)
collected[item] = 0
end --for item loop
end --quest reset check

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']
return math.sqrt(disx^2 + disz^2)
end
end

function name_init(e)
--entity number of first object to compare
entity1 = 10
--entity number of second object to compare
entity2 = 15
end
function name_main(e)
if GetDistance(entity1,entity2) < 100 then
Prompt("within 100 distance, actual distance is = " .. GetDistance(entity1,entity2))
end
end

function RotateToEntity(e,v)
if g_Entity[e] ~= nil and g_Entity[e] ~= 0 and g_Entity[v] ~= nil and g_Entity[v] ~= 0 then
local x = g_Entity[v]['x'] - g_Entity[e]['x']
local z = g_Entity[v]['z'] - g_Entity[e]['z']
local angle = math.atan2(x,z)
angle = angle * (180.0 / math.pi)
if angle < 0 then
angle = 360 + angle
elseif angle > 360 then
angle = angle - 360
end
SetRotation(e,0,angle,0)
return angle
end
end

function name_init(e)
--entity number of first entity to compare
entity1 = 10
--entity number of second entity to compare
entity2 = 15
end

function name_main(e)
RotateToEntity(entity1,entity2)
Prompt(angle)
end

local attack_range = {}

local fire_delay = {}

local damage = {}

local fire_delay_init = {}

local turn_speed = {}

local angle_found = {}

local angle = {}



function turret2_init(e)

--set default values for all turrets (these will be overwritten if individual settings are set)

attack_range[e] = 1000

fire_delay[e] = 1000

fire_delay_init[e] = fire_delay[e]

damage[e] = 50

turn_speed[e] = 1

--do not change as it's required to find the starting angle

angle_found[e] = -1

angle[e] = 0



--set individual settings here

--eg

--damage[2] = 200

--damage[300] = 5000

end



function turret2_main(e)

--find entity starting angle so we can compare with players later (this is done by rotating turret to face the player on load)

--note this may cause problems if you wish your turret to stay a certain facing but i wouldn't recommend this script if so, sorry)

if angle_found[e] < 0 then

local x = g_PlayerPosX - g_Entity[e]['x']

local z = g_PlayerPosZ - g_Entity[e]['z']

angle[e] = math.atan2(x,z)

angle[e] = angle[e] * (180.0 / math.pi)

if angle[e] < 0 then

angle[e] = 360 + angle[e]

elseif angle[e] > 360 then

angle[e] = angle[e] - 360

end

CollisionOff(e)

SetRotation(e,0,angle[e],0)

angle_found[e] = angle[e]

end





--check player enters turrets sensor range

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

--find the angle required to face the player

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

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

angle[e] = math.atan2(x,z)

angle[e] = angle[e] * (180.0 / math.pi)

if angle[e] < 0 then

angle[e] = 360 + angle[e]

elseif angle[e] > 360 then

angle[e] = angle[e] - 360

end

--compare angle to face player with our turret's current angle and update as needed

if angle_found[e] < angle[e] then

angle_found[e] = angle_found[e] + turn_speed[e]

elseif angle_found [e]> angle[e] then

angle_found[e] = angle_found[e] - turn_speed[e]

end



--keep angle within 0 ~ 360

if angle_found[e] > 360 then

angle_found[e] = 0

end



--update the new angle to be closer to player's position

SetRotation(e,0,angle_found[e],0)



--if we are facing the player

if angle[e] >= angle_found[e] - 1 and angle[e] <= angle_found[e] + 1 then

--if haven't fired lately then fire! :)

if GetTimer(e) >= fire_delay[e] then

PlaySound(e,1)

HurtPlayer(e,damage[e])

fire_delay[e] = GetTimer(e) + fire_delay_init[e]

end

end



--if player not in sensor range then rotate so we arent static

--remove this if you wish v

else

angle_found[e] = angle_found[e] + turn_speed[e]



if angle_found[e] > 360 then

angle_found[e] = 0

end



SetRotation(e,0,angle_found[e],0)

--end of removal of optional rotations ^

end

end

--if we are facing the player
if angle[e] >= angle_found[e] - 1 and angle[e] <= angle_found[e] + 1 then
--if haven't fired lately then fire! :)
if GetTimer(e) >= fire_delay[e] then
PlaySound(e,1)
HurtPlayer(e,damage[e])
fire_delay[e] = GetTimer(e) + fire_delay_init[e]
end
end
 
--if player not in sensor range then rotate so we arent static
--remove this if you wish v
else
angle_found[e] = angle_found[e] + turn_speed[e]

--if we are facing the player
if angle[e] >= angle_found[e] - 1 and angle[e] <= angle_found[e] + 1 then
LoopSound(e,0)
--if haven't fired lately then fire! :)
if GetTimer(e) >= fire_delay[e] then
PlaySound(e,1)
HurtPlayer(e,damage[e])
fire_delay[e] = GetTimer(e) + fire_delay_init[e]
end
end
 
--if player not in sensor range then rotate so we arent static
--remove this if you wish v
else
angle_found[e] = angle_found[e] + turn_speed[e]
StopSound(e,0)

local attack_range = {}
local fire_delay = {}
local damage = {}
local fire_delay_init = {}
local turn_speed = {}
local angle_found = {}
local angle = {}
 
function turret2_init(e)
--set default values for all turrets (these will be overwritten if individual settings are set)
attack_range[e] = 1000
fire_delay[e] = 1000
fire_delay_init[e] = fire_delay[e]
damage[e] = 50
turn_speed[e] = 1
--do not change as it's required to find the starting angle
angle_found[e] = -1
angle[e] = 0
 
--set individual settings here
--eg
--damage[2] = 200
--damage[300] = 5000
end
 
function turret2_main(e)
--find entity starting angle so we can compare with players later (this is done by rotating turret to face the player on load)
--note this may cause problems if you wish your turret to stay a certain facing but i wouldn't recommend this script if so, sorry)
if angle_found[e] < 0 then
local x = g_PlayerPosX - g_Entity[e]['x']
local z = g_PlayerPosZ - g_Entity[e]['z']
angle[e] = math.atan2(x,z)
angle[e] = angle[e] * (180.0 / math.pi)
if angle[e] < 0 then
angle[e] = 360 + angle[e]
elseif angle[e] > 360 then
angle[e] = angle[e] - 360
end
CollisionOff(e)
SetRotation(e,0,angle[e],0)
angle_found[e] = angle[e]
end
 
 
--check player enters turrets sensor range
if GetPlayerDistance(e) <= attack_range[e] then
--find the angle required to face the player
x = g_PlayerPosX - g_Entity[e]['x']
z = g_PlayerPosZ - g_Entity[e]['z']
angle[e] = math.atan2(x,z)
angle[e] = angle[e] * (180.0 / math.pi)
if angle[e] < 0 then
angle[e] = 360 + angle[e]
elseif angle[e] > 360 then
angle[e] = angle[e] - 360
end
--compare angle to face player with our turret's current angle and update as needed
if angle_found[e] < angle[e] then
angle_found[e] = angle_found[e] + turn_speed[e]
elseif angle_found [e]> angle[e] then
angle_found[e] = angle_found[e] - turn_speed[e]
end
 
--keep angle within 0 ~ 360
if angle_found[e] > 360 then
angle_found[e] = 0
end
 
--update the new angle to be closer to player's position
SetRotation(e,0,angle_found[e],0)
 
--if we are facing the player
if angle[e] >= angle_found[e] - 1 and angle[e] <= angle_found[e] + 1 then
LoopSound(e,0)
--if haven't fired lately then fire! :)
if GetTimer(e) >= fire_delay[e] then
PlaySound(e,1)
HurtPlayer(e,damage[e])
fire_delay[e] = GetTimer(e) + fire_delay_init[e]
end
end
  
--if player not in sensor range then rotate so we arent static
--remove this if you wish v
else
angle_found[e] = angle_found[e] + turn_speed[e]
StopSound(e,0)
 
if angle_found[e] > 360 then
angle_found[e] = 0
end
 
SetRotation(e,0,angle_found[e],0)
--end of removal of optional rotations ^
end
end

state = {}

break_time = {}

break_delay = {}

place_time = {}

place_delay = {}

block_range = 90

pressed = 0

grass_block = 0

inventory = {}



function grass_block_init(e)

if first_grass == nil then

first_grass = e

end

last_grass = e

state[e] = "placed" --initial state of the block

Scale(e,305) --size of block in world

break_delay[e] = 0

break_time[e] = 300 --time till block is broken while pressing e

place_delay[e] = 99999999999

place_time[e] = 1000 --time need to hold e to place a block (needs to be larger or smaller than the break time or u will do both)

end







function grass_block_main(e)

Prompt("Grass blocks in inventory: " .. grass_block)

if GetPlayerDistance(e) <= block_range then

if state[e] == "placed" then

CollisionOn(e)

if breaking == 0 then

	breaking = 1

	SetPosition(e,g_Entity[e]['x'],g_Entity[e]['y']+300,g_Entity[e]['z'])

end

	PromptLocal(e,"Hold E to break block")

	if g_KeyPressE == 1 and pressed == 0 then

		pressed = 1

		breaking = 2

		break_delay[e] = GetTimer(e) + break_time[e]

	end --check for e first pressed (for timer)

	if g_KeyPressE == 1 and pressed == 1 and breaking == 2 and GetTimer(e) >= break_delay[e] then

		state[e] = "broken"

		Scale(e,50) --make block small to show it's broken state

		CollisionOff(e) --turn off it's collision so we can pass through it

		pressed = 2

	end --check e is held down longer than timer

	

elseif state[e] == "broken" then

PromptLocal(e,"Press E to collect block")

	if g_KeyPressE == 1 and pressed == 0 then

		grass_block = grass_block + 1

		inventory[grass_block] = e

		pressed = 1

		Hide(e)

		state[e] = "inventory"

		--SetPosition(e,g_PlayerPosX,g_PlayerPosY,g_PlayerPosZ)

		--SetRotation(e,0,g_PlayerAngY,0)

	end





		

end --state



elseif state[e] == "inventory" then

	itemdist = 150

	itemx=g_PlayerPosX

	itemz=g_PlayerPosZ

	itemy=g_PlayerPosY

	itemx = itemx+math.sin(math.rad(g_PlayerAngY))*itemdist

	itemz = itemz+math.cos(math.rad(g_PlayerAngY))*itemdist

	itemy = itemy-math.sin(math.rad(g_PlayerAngX))*itemdist

	SetPosition(e,itemx,itemy-15,itemz)

	SetRotation(e,0,g_PlayerAngY,0)

	if g_KeyPressE == 1 and pressed == 0 then

		pressed = 1

		placing = 1

		place_delay[e] = GetTimer(e) + place_time[e]

	end

	if g_KeyPressE == 1 and pressed == 1 and placing == 1 and breaking == 0 then

		Prompt("Placing block")

		Show(inventory[grass_block])

		Scale(inventory[grass_block],305)

		if GetTimer(e) >= place_delay[e] then

			state[inventory[grass_block]] = "placed"

			Scale(inventory[grass_block],305)

			CollisionOn(inventory[grass_block])

			Show(inventory[grass_block])

			grass_block = grass_block - 1

			pressed = 2

		end --block placed

	end --holding e to place block

--end --state = inventory

end --player distance







		

if g_KeyPressE == 0 then

	pressed = 0

	placing = 0

	breaking = 0

	break_delay[e] = GetTimer(e) + break_time[e]

	place_delay[e] = GetTimer(e) + place_time[e]

	if grass_block > 0 then

		Hide(inventory[grass_block])

		Scale(inventory[grass_block],50)

	end

end --reset input if e is let go

end --main

i.e.

loadimages("animation1",1)

loadimages("animation2",10)



for x = 1 to 9

showimage(x)

end

for x = 10 to 19

ShowImage(x)

end