RPG System 0.18.44 modification by Honktown

require "mod-gui"
require "util"
local format_number = util.format_number
--[[
  ** RPG SYSTEM **
by MFerrari
]]

function Log(what)
game.write_file("myrpg.log", serpent.block(what), true)
end


local colors = {
	white = {r = 1, g = 1, b = 1},
	black = {r = 0, g = 0, b = 0},
	darkgrey = {r = 0.25, g = 0.25, b = 0.25},
	grey = {r = 0.5, g = 0.5, b = 0.5},
	lightgrey = {r = 0.75, g = 0.75, b = 0.75},

	red = {r = 1, g = 0, b = 0},
	darkred = {r = 0.5, g = 0, b = 0},
	lightred = {r = 1, g = 0.5, b = 0.5},
	green = {r = 0, g = 1, b = 0},
	darkgreen = {r = 0, g = 0.5, b = 0},
	lightgreen = {r = 0.5, g = 1, b = 0.5},
	blue = {r = 0, g = 0, b = 1},
	darkblue = {r = 0, g = 0, b = 0.5},
	lightblue = {r = 0.5, g = 0.5, b = 1},

	orange = {r = 1, g = 0.55, b = 0.1},
	yellow = {r = 1, g = 1, b = 0},
	pink = {r = 1, g = 0, b = 1},
	purple = {r = 0.6, g = 0.1, b = 0.6},
	brown = {r = 0.6, g = 0.4, b = 0.1},
}

local stats = {
  ["character_crafting_speed_modifier"] = {name = 'LV_Craft_Speed', mod = 100},
  ["character_mining_speed_modifier"] = {name = 'LV_Mining_Speed', mod = 100},
  ["character_running_speed_modifier"] = {name = 'LV_Run_Speed', mod = 100},
  ["character_build_distance_bonus"] = {name = 'LV_Reach_Dist', mod = 1},
  ["character_reach_distance_bonus"] = {name = 'LV_Reach_Dist', mod = 1},
  ["character_item_drop_distance_bonus"] = {name = 'LV_Reach_Dist', mod = 1},
  ["character_resource_reach_distance_bonus"] = {name = 'LV_Reach_Dist', mod = 1},
  ["character_inventory_slots_bonus"] = {name = 'LV_Inv_Bonus', mod = 1},
  ["character_health_bonus"] = {name = 'LV_Health_Bonus', mod = 1},
  ["character_loot_pickup_distance_bonus"] = {name = 'LV_Reach_Dist', mod = 1}
}

local function apply_bonus_relatively(player, modifier, internal)
  if player.valid and player.character.valid then
    player.character[modifier] = player.character[modifier] + global.personalxp[internal.name][player.name] * global.RPG_Bonus[internal.name] / internal.mod
  end
end

local function apply_one_bonus(player, modifier, internal)
  if player.valid and player.character.valid then
    player[modifier] = player[modifier] + 1 * global.RPG_Bonus[internal.name] / internal.mod
  end
end


-- CUSTOM EVENT HANDLING --
--(remote interface is lower in the file, there I describe how to subscribe to my events)
-- if your mod alters the character bonus settings, then you should get_on_player_updated_status to make required adjusts to your mod, if necessary
local on_player_updated_status = script.generate_event_name() --uint
local on_player_level_up = script.generate_event_name() --uint



function printXP(player,XP)
if player and player.valid then
if settings.get_player_settings(player)["charxpmod_print_xp_user"].value then
	player.surface.create_entity{name = "flying-text", position = player.position, text = "+" .. format_number(XP) ..' XP', color = colors.yellow}
	end
end
end


function ResetXPTables()
local xp = settings.startup["charxpmod_xpinilevel"].value
global.xp_table = {[1] = xp}
local mp = settings.startup["charxpmod_xpmult"].value
local red = settings.startup["charxpmod_xp_mp_reductor"].value

local m
for k=2,1000 do
    m = mp - k*(red-red*k/100)  -- (Multiplier - Level * (reductor-reductor*Level/100))
	xp = math.ceil(xp * m)

	if (xp / global.xp_table[k-1]) < 1.02 then
		xp = global.xp_table[k-1] * 1.02
		end

	global.xp_table[k] = xp
	end
global.max_xp = xp
end


function SetForceValues(name)
	global.kills_spawner[name] = 0
	global.kills_units[name] = 0
	global.kills_worms[name] = 0
	global.XP[name] = 0
	global.XP_GANHO[name] = 0
	global.XP_TECH[name] = 0
	global.XP_LEVEL[name] = 1
	global.XP_LEVEL_MIN[name] = 0
	global.XP_KILL_HP[name] = 0
	global.XP_MAX_PLAYTIME[name] = 0
	global.XP_AVG_PLAYTIME[name] = 0
end



function CheckAddPlayerStatus(name)
if global.personalxp[name] == nil then
	global.personalxp[name] = {}
	for _, player in pairs(game.players) do
		global.personalxp[name][player.name] = 0
	end
end
end


function VersionChange()

if global.personalxp.opt_Pick_Extender == nil then
	global.personalxp.opt_Pick_Extender = {}
	for _, player in pairs(game.players) do
		global.personalxp.opt_Pick_Extender[player.name] = false
	end
end

if global.XP_MAX_PLAYTIME == nil then
	global.XP_MAX_PLAYTIME={}
		for name, force in pairs (game.forces) do
			if name~='neutral' and name~='enemy' then
			global.XP_MAX_PLAYTIME[name] = 0
			end
		end
	end

if global.XP_AVG_PLAYTIME == nil then
	global.XP_AVG_PLAYTIME={}
		for name, force in pairs (game.forces) do
			if name~='neutral' and name~='enemy' then
			global.XP_AVG_PLAYTIME[name] = 0
			end
		end
	end


CheckAddPlayerStatus('rocketsXP_count')
CheckAddPlayerStatus('LV_Damage_Bonus')
CheckAddPlayerStatus('LV_Damage_Critical')
CheckAddPlayerStatus('LV_Armor_Bonus')
end


function SetupPlayer(player,ResetXP)
local name = player.name
	if ResetXP then
		global.personalxp.XP[name] = 0
		global.personalxp.Death[name] = 0
		global.personal_kill_units[name] = 0
		global.personal_kill_spawner[name] = 0
		global.personal_kill_turrets[name] = 0
		end

	global.personalxp.Level[name] = 1

	for k=1,#global.Player_Attributes do
		local attrib = global.Player_Attributes[k]
		global.personalxp[attrib][name]= 0
		end

	global.personalxp.opt_Pick_Extender[name] = false



	local tech_states = {}

	for tech_name, tech in pairs(player.force.technologies) do
		table.insert(tech_states, {name = tech_name, enabled = tech.enabled, visible_when_disabled = tech.visible_when_disabled})
	end

	--log(serpent.block(tech_states))
    player.force.reset_technology_effects()

	for _, tech in pairs(tech_states) do
		--log(serpent.block(tech))
		player.force.technologies[tech.name].enabled = tech.enabled
		player.force.technologies[tech.name].visible_when_disabled = tech.visible_when_disabled
	end

    --UpdatePlayerLvStats(player)
end

function CheckPlayers()
	for _, player in pairs(game.players) do
		if not (global.personalxp.Level[player.name]) then
			SetupPlayer(player,true)
			end

		if not global.personal_kill_units[player.name] then
			global.personal_kill_units[player.name] = 0
			global.personal_kill_spawner[player.name] = 0
			global.personal_kill_turrets[player.name] = 0
			end

		InitPlayerGui(player)
		end
end

function CheckPlayer(player)
	if not (global.personalxp.Level[player.name]) then
		SetupPlayer(player,true)
	end
end

function ReadRunTimeSettings(event)
global.setting_print_critical   =  settings.global["charxpmod_print_critical"].value
global.setting_afk_time         =  settings.global["charxpmod_afk"].value
global.setting_time_ratio_xp    =  settings.global["charxpmod_time_ratio_xp"].value
global.setting_death_penal      =  settings.global["charxpmod_death_penal"].value

if event and event.setting_type=='runtime-per-user' and event.setting=='charxpmod_hide_xp_panel' then
	local player = game.players[event.player_index]
	player.gui.top.chartopframe.visible = not settings.get_player_settings(player)["charxpmod_hide_xp_panel"].value
	end
end

function XPModSetup()

global.Player_Attributes = {
	"LV_Health_Bonus",
	"LV_Armor_Bonus",
	"LV_Damage_Bonus",
	"LV_Damage_Critical",
	"LV_Run_Speed",
	"LV_Craft_Speed",
	"LV_Mining_Speed",
	"LV_Reach_Dist",
	"LV_Inv_Bonus",
--	"LV_InvLog_Bonus",
	"LV_InvTrash_Bonus",
	"LV_Robot_Bonus",
	}

global.setting_allow_xp_by_tech   =  settings.startup["charxpmod_allow_xp_by_tech"].value
global.setting_allow_xp_by_kill   =  settings.startup["charxpmod_allow_xp_by_kill"].value
global.setting_allow_xp_by_rocket =  settings.startup["charxpmod_allow_xp_by_rocket"].value
global.setting_allow_xp_by_mining =  settings.startup["charxpmod_allow_xp_by_mining"].value
global.XP_Mult                    =  settings.startup["charxpmod_xp_multiplier_bonus"].value
global.setting_allow_damage_attribs =  settings.startup["charxpmod_enable_damage_attribs"].value

ReadRunTimeSettings()


if global.CharXPMOD == nil then
	global.CharXPMOD = 1
	global.kills_spawner={}
	global.kills_units={}
	global.kills_worms={}
	global.XP={}
	global.XP_GANHO={}
	global.XP_KILL_HP={}
	global.XP_TECH={}
	global.XP_LEVEL={}
	global.XP_LEVEL_MIN={}
	global.XP_MAX_PLAYTIME={}
	global.XP_AVG_PLAYTIME={}

	global.personalxp = {}
	global.personalxp.Level = {}
	global.personalxp.XP = {}
	global.personalxp.Death = {}



	for k=1,#global.Player_Attributes do
		global.personalxp[global.Player_Attributes[k]]= {}
		end

	global.personalxp.opt_Pick_Extender = {}

	for name, force in pairs (game.forces) do
		if name~='neutral' and name~='enemy' then
			SetForceValues(name)
			end
		end


	ResetXPTables()
	end



global.RPG_Bonus = {}
  for k=1,#global.Player_Attributes do
    local attrib = global.Player_Attributes[k]
    global.RPG_Bonus[attrib] = settings.startup["charxpmod_"..attrib].value
  end

  global.personal_kill_units = global.personal_kill_units or {}
  global.personal_kill_spawner = global.personal_kill_spawner or {}
  global.personal_kill_turrets = global.personal_kill_turrets or {}

  VersionChange()
  CheckPlayers()
end


function ResetAll()
  ResetXPTables()
  for name, force in pairs (game.forces) do
    if name~='neutral' and name~='enemy' then
      SetForceValues(name)
    end
  end
  for _, player in pairs(game.players) do
    SetupPlayer(player,true)
    UpdatePanel(player)
  end
end


function ResetPointSpent()
  ResetXPTables()

  for _, player in pairs(game.players) do
    SetupPlayer(player,false)
  end
end



function InitPlayerGui(player)

local nome = player.name

-- close main panel
if player.gui.center["char-panel"] then
   player.gui.center["char-panel"].destroy() end

-- remove previous versions
if (mod_gui.get_button_flow(player).chartopframe) then
	mod_gui.get_button_flow(player).chartopframe.destroy() end
if (mod_gui.get_button_flow(player).btcharxp) then
	mod_gui.get_button_flow(player).btcharxp.destroy() end
if player.gui.top.chartopframe then  player.gui.top.chartopframe.destroy() end
if player.gui.top.btcharxp then  player.gui.top.btcharxp.destroy() end

-- create new ones
local Topframe = player.gui.top.add{name="chartopframe", direction = "horizontal", type="frame", style=mod_gui.frame_style}
 	Topframe.style.minimal_height = 30
-- 	Topframe.style.maximal_height = 37
	Topframe.style.minimal_width = 200
--	Topframe.style.maximal_width  = 250

Topframe.add{name="btcharxp", type="sprite-button", sprite = "entity/character", tooltip = {"panel-title"}, style = mod_gui.top_button_style} -- "mod_gui_button"}

local tabFrame = Topframe.add{type = "table", name = "tabtopframexp", column_count = 1}
Level = global.personalxp.Level[nome]
local pnivel = tabFrame.add{type="label", name='chartoplvtxt', caption={'actual_lv',Level}}
    pnivel.style.font="charxpmod_font_17b"
local TopXPbar = tabFrame.add{type = "progressbar", name = "TopXPbar"}
TopXPbar.style.width=150
UpdatePanel(player)
end


----------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------


function RatioXP(player)
local ratioXP = 1
	if global.setting_time_ratio_xp and global.XP_AVG_PLAYTIME[player.force.name]>0 then
		ratioXP = player.online_time/global.XP_AVG_PLAYTIME[player.force.name]
		if ratioXP >= 1.10 then ratioXP = 1.10
			elseif ratioXP < 0.05 then ratioXP = 0.05 end
		end
return ratioXP
end


function XP_Player_upd()

 	for name, force in pairs (game.forces) do
	if name~='neutral' and name~='enemy' then

		local cp = #force.connected_players
		local afk = global.setting_afk_time
		if cp>0 then
			local XP = global.XP[name]   --math.ceil(global.XP[name] / cp)

			if XP>0 then
			for p, PL in pairs (force.connected_players) do
				if afk==0 or PL.afk_time<afk*3600 then
				local ratioXP = RatioXP(PL)
				XP = math.ceil(XP*ratioXP)
				global.personalxp.XP[PL.name] = global.personalxp.XP[PL.name] + XP
				printXP(PL,XP)
				UpdatePanel(PL)
				end
				end
			end
		global.XP[name]=0
		end
	end
	end
end


function XP_PlayerLv_upd()

	for _, player in pairs(game.players) do
		if player.connected then
			local name = player.name
			local Lv = global.personalxp.Level[name]
			if global.personalxp.XP[name]>global.max_xp then
			   global.personalxp.Level[name]=1000
			else

				for L=Lv, #global.xp_table do
					if global.personalxp.XP[name]< global.xp_table[L] then
						global.personalxp.Level[name]=L
						break
					end
				end
			end

			if global.personalxp.Level[name] > Lv then
				player.print({'player_lv_up',global.personalxp.Level[name]})
				player.play_sound{path = 'player_level_up'}
				script.raise_event(on_player_level_up, {player_index = player.index, player_level = global.personalxp.Level[name]})
				end
			UpdatePanel(player)
		end
	end
end


function XP_Time_upd()
 	for name, force in pairs (game.forces) do
	if name~='neutral' and name~='enemy' then
	local PT
	local TT=0
	local QP=0

		for p, PL in pairs (force.players) do
			PT = PL.online_time
			if PT > global.XP_AVG_PLAYTIME[name]/20 then  -- a player time count for avg if he has at least 5% of the avg time
				TT = TT + PT
				QP = QP + 1
				end

			if global.XP_MAX_PLAYTIME[name] < PT then
				global.XP_MAX_PLAYTIME[name] = PT
				end
			end
	if QP>0 then global.XP_AVG_PLAYTIME[name] = TT/QP end
	end
	end
end


function XP_UPDATE_tick()

XP_Time_upd()
XP_Player_upd()
XP_PlayerLv_upd()


end





function SumPointSpent(name)
local sum = 0
for k=1,#global.Player_Attributes do
	local attrib = global.Player_Attributes[k]
	sum = sum + global.personalxp[attrib][name]
	end
return sum
end


function update_char_panel(player)
XP_Time_upd()

  local force = player.force.name
  local painel = player.gui.center["char-panel"]
  local frame = painel.tabcharScroll
  local nome = player.name
  local Level = global.personalxp.Level[nome]


local ptime = player.online_time
local txtPTime = {"time-played" ,string.format("%d:%02d:%02d", math.floor(ptime / 216000), math.floor(ptime / 3600) % 60, math.floor(ptime / 60) % 60)}

local PontosXP = Level - 1 - SumPointSpent(nome)
if PontosXP<0 then PontosXP=0 end

  local tabChar = frame.add{type = "table", name = "tab_tbchar", column_count = 2}
  tabChar.add{type = "sprite", sprite = "charxpmod_space_suit"}

  local tabScroll = tabChar.add{type = "scroll-pane", name= "tabScroll2", vertical_scroll_policy="auto", horizontal_scroll_policy="auto"}
	tabScroll.style.minimal_height = 150
	tabScroll.style.minimal_width = 320
	tabScroll.style.maximal_width = 350

  local tabPName = tabScroll.add{type = "table", name = "tab_pname", column_count = 3}
  local pname = tabPName.add{type="label", name='ocharname',  caption=nome}
  pname.style.font="charxpmod_font_30b"
  pname.style.font_color=player.color
  tabPName.add{type="label", name='blanklab1', caption='        - '}
  local pnivel = tabPName.add{type="label", name='ocharlevel', caption={'actual_lv',Level}}
  pnivel.style.font="charxpmod_font_30"
  pnivel.style.font_color=player.color


  local tabPStat = tabScroll.add{type = "table", name = "tab_PStat", column_count = 2}
  tabPStat.add{type="label", name='STT1', caption= txtPTime}.style.font="charxpmod_font_17"
  tabPStat.add{type="label", name='STT2', caption={'xp_deaths',global.personalxp.Death[nome]}}.style.font="charxpmod_font_17"

  tabScroll.add{type="label", name='blankL1', caption=' '}

  -- stats
  local wd =170

  local tabStats = tabScroll.add{type = "table", name = "tabStats", column_count = 2}

  --[[  tabStats.add{type="label", name='STT3', caption={'xp_spawnk',global.kills_spawner[force]}}.style.width = wd
  tabStats.add{type="label", name='STT4', caption={'xp_techs',global.XP_TECH[force]}}.style.width = wd
  tabStats.add{type="label", name='STT5', caption={'xp_wormk',global.kills_worms[force]}}.style.width = wd
  tabStats.add{type="label", name='STT6', caption={'xp_unitk',global.kills_units[force]}}.style.width = wd  ]]


  tabStats.add{type="label", name='STT3', caption={'xp_spawnk',format_number( global.personal_kill_spawner[nome])}}.style.width = wd
  tabStats.add{type="label", name='STT4', caption={'xp_techs',format_number(global.XP_TECH[force])}}.style.width = wd
  tabStats.add{type="label", name='STT5', caption={'xp_wormk',format_number(global.personal_kill_turrets[nome])}}.style.width = wd
  tabStats.add{type="label", name='STT6', caption={'xp_unitk',format_number(global.personal_kill_units[nome])}}.style.width = wd



local pbvalue = CalculateXP_PB(player.name)
--local pbvalue = player.gui.top.chartopframe.TopXPbar.value
local XP = global.personalxp.XP[nome]
local NextLevel = global.xp_table[Level]

  local NextLtxt = format_number( NextLevel)
  if XP >= global.max_xp then NextLtxt = 'MAX' end

  local tabXP = frame.add{type = "table", name = "tab_XP", column_count = 2}

  local tabBar = tabXP.add{type = "table", column_count = 1}
  tabBar.style.vertical_spacing = 1
  tabBar.add{type="label", name='lbxpatual', caption='XP: ' .. format_number( XP ) }.style.font="charxpmod_font_17"
  local bar = tabBar.add{type = "progressbar", value = pbvalue, name = "tab_XPbar"}
  bar.style.width = 320

  local tabNextLv = tabXP.add{type = "table", column_count = 1}
  tabNextLv.style.vertical_spacing = 1
  tabNextLv.add{type="label", caption=' '}
  tabNextLv.add{type="label", caption={'next_lv'}} --.style.font="charxpmod_font_17"
  tabNextLv.add{type="label", caption=NextLtxt} --.style.font="charxpmod_font_17"


-- XP RATIO
  local ratioXP = RatioXP(player)
  ratioXP = math.floor(ratioXP*100)
  frame.add{type="label", name='lbxratioxp', caption={'xp_ratio', ratioXP}}

  frame.add{type="label", name='blankL3', caption=' '}
  frame.add{type="label", name='lbxPAGastar', caption={'xp_points',PontosXP}}.style.font="charxpmod_font_20"

-- LEVELS / UPGRADES
  local tabUpgrades = frame.add{type = "table", name = "tabUpgrades", column_count = 2}
  		tabUpgrades.style.horizontal_spacing = 20
		tabUpgrades.style.vertical_spacing = 8
	--	tabUpgrades.draw_horizontal_lines = true
	--	tabUpgrades.draw_vertical_lines = true
	--	tabUpgrades.draw_horizontal_line_after_headers = true



  local Max = 200
  local custo = 1
  local vchar
  local at_level
  local attrib
  local bonus

  for A=1,#global.Player_Attributes do
		attrib = global.Player_Attributes[A]
		local enabled = true
		if (attrib=="LV_Armor_Bonus" or attrib=="LV_Damage_Bonus" or attrib=="LV_Damage_Critical")
			and (not global.setting_allow_damage_attribs) then enabled = false end
		if enabled then

			vchar    = 'global.personalxp.'..attrib
			at_level = global.personalxp[attrib][nome]
			bonus    = global.RPG_Bonus[attrib]

			local tabAttrib = tabUpgrades.add{type = "table", column_count = 2}

			local btAttribute = tabAttrib.add{type="button", caption={vchar}, name='btLVU_'..vchar, style = 'rounded_button', tooltip={'xp_hint_'..vchar,bonus}}
			local txtAttLv  = tabAttrib.add{type="label", caption=at_level}
			txtAttLv.style.font="charxpmod_font_20"
			txtAttLv.style.width = 30
			btAttribute.style.font= "default-bold"
			btAttribute.style.width = 190
			btAttribute.enabled = PontosXP>=custo and at_level<Max
			end
		end


local pickbutton = frame.add{type = "checkbox", name = "cb_pick_extender", caption={'xp_opt_Pick_Extender'}, state = global.personalxp.opt_Pick_Extender[nome]}

   frame.add{type="label", name='blankL4', caption=' '}

  --TAG
  local frametag = frame.add{type="frame", name="char_frametag", direction = "horizontal", style=mod_gui.frame_style}
		frametag.style.minimal_width = 455
		frametag.style.maximal_width = 455

  local tabtag = frametag.add{type = "table", name = "tabchartag", column_count = 4}
  tabtag.add{type="label", name="lab_ctag", caption="Tag  "}
  tabtag.add{type="textfield", name="ctag_field", text=player.tag}
  local btTagOK= tabtag.add{name="btTagCharOK", type="button", style = mod_gui.button_style, caption='OK'}
  --local btColors= tabtag.add{name="btColorsChar", type="button", style = 'confirm_double_arrow_button', caption={'panel-colors-title'}}
  end


function ListAll(player)
expand_char_gui(player)
expand_char_gui(player)

  local force = player.force
  local painel = player.gui.center["char-panel"]
  local frame = painel.tabcharScroll


  frame.add{type="label", name='lbxplayerlst', caption=Players}.style.font="charxpmod_font_20"
  local tabpllst = frame.add{type = "table", name = "tabpllst", column_count = 3}
  for p,PL in pairs (force.players) do

	local ptime = PL.online_time
	local txtPTime = string.format("%d:%02d", math.floor(ptime / 216000), math.floor(ptime / 3600) % 60)
	local ratioXP = math.floor(RatioXP(PL) * 100)
	tabpllst.add{type="label", name='pllstname'..p, caption=PL.name .. ' '..global.personalxp.Level[PL.name] .. ' (' ..txtPTime.. ' '..ratioXP..'%)'}
	end
end


function ListXPTable(player)
player.print('XP Level Table:')
for k=1,20 do
	player.print('Level '.. k .. ' - ' .. global.xp_table[k] )
	end
end


function CalculateXP_PB(plname)
local Level = global.personalxp.Level[plname]
local XP = global.personalxp.XP[plname]
if XP > global.max_xp then XP = global.max_xp end
local NextLevel = global.xp_table[Level]
local XP_ant
if Level==1 then XP_ant = 0 else XP_ant = global.xp_table[Level-1] end
local Interval_XP = NextLevel - XP_ant
local pbvalue = (XP-XP_ant)/Interval_XP
return pbvalue
end


function CalculateXP_GAIN_LV(playername)

local pbvalue = CalculateXP_PB(playername)
local Level = global.personalxp.Level[playername]
local NextLevel = global.xp_table[Level]
local XP = global.personalxp.XP[playername]

local ThisLevel = NextLevel - XP + 1
local PartialXP = 0

if Level<1000 then
	PartialXP = math.ceil((global.xp_table[Level+1] - ThisLevel) * pbvalue)
	end

return ThisLevel + PartialXP
end



function UpdatePanel(player)
-- BARRA DE XP  tabtopframexp
local TopXPbar = player.gui.top.chartopframe.tabtopframexp.TopXPbar
local txtlv    = player.gui.top.chartopframe.tabtopframexp.chartoplvtxt

local Level = global.personalxp.Level[player.name]
local pbvalue = CalculateXP_PB(player.name)

txtlv.caption={'actual_lv',Level}
TopXPbar.value=pbvalue

local color_frame = player.gui.center["rpg-char-color-panel"]
if color_frame then return end

local frame = player.gui.center["char-panel"]
    if frame then
	local textImput = player.gui.center["char-panel"].tabcharScroll.char_frametag.tabchartag.ctag_field.text
	if player.tag~=textImput then return end
	expand_char_gui(player)
	expand_char_gui(player)
	end

end

function expand_char_gui(player)
    local color_frame = player.gui.center["rpg-char-color-panel"]
    if color_frame then color_frame.destroy() end

    local frame = player.gui.center["char-panel"]
    if frame then
        frame.destroy()
    else
	local  wid = 530
		frame = player.gui.center.add{type="frame", name="char-panel", direction = "vertical", style=mod_gui.frame_style, caption={"panel-title"}}
		frame.style.minimal_height = 430
  		--frame.style.maximal_height = 430
		frame.style.minimal_width = wid
		frame.style.maximal_width = 485
		local tabcharScroll = frame.add{type = "scroll-pane", name= "tabcharScroll", vertical_scroll_policy="auto", horizontal_scroll_policy="auto"}
		tabcharScroll.style.minimal_height = 400
		--tabcharScroll.style.maximal_height = 1000
		tabcharScroll.style.minimal_width = wid - 15
		tabcharScroll.style.maximal_width = wid - 15
		update_char_panel(player)
    end
end



--[[
function expand_char_color_gui(player)
    local frame = player.gui.center["rpg-char-color-panel"]
    if frame then
        frame.destroy()
    else
		frame = player.gui.center.add{type="frame", name="rpg-char-color-panel", direction = "vertical", style=mod_gui.frame_style, caption={"panel-colors-title"}}

		local tabBars = frame.add{type = "table", name='table_char_colors', column_count = 2}
		      tabBars.add{type = "label", caption='R'}.style.font_color=colors.lightred
		local sliderR = tabBars.add{type = "slider", name='slider_color_R', value = player.color.r,minimum_value=0,maximum_value=1}

		      tabBars.add{type = "label", caption='G'}.style.font_color=colors.lightgreen
		local sliderG = tabBars.add{type = "slider",  name='slider_color_G', value = player.color.g,minimum_value=0,maximum_value=1}

		      tabBars.add{type = "label", caption='B'}.style.font_color=colors.lightblue
		local sliderB = tabBars.add{type = "slider",  name='slider_color_B', value = player.color.b,minimum_value=0,maximum_value=1}

		local tabBarsBt = frame.add{type = "table", column_count = 2}
		local btCancel= tabBarsBt.add{name="btColorsCharCancel", type="button", style = "back_button", caption={'cancel'}}
		local btApply = tabBarsBt.add{name="btColorsCharApply",  type="button", style = "confirm_button", caption={'apply'}}
	end

end
]]

function apply_char_color(player)
    local frame = player.gui.center["rpg-char-color-panel"]
    if frame then

	local sliderR = frame.table_char_colors.slider_color_R
	local sliderG = frame.table_char_colors.slider_color_G
	local sliderB = frame.table_char_colors.slider_color_B

	player.color = {r=sliderR.slider_value,g=sliderG.slider_value,b=sliderB.slider_value}
	frame.destroy()
	end

    local frame = player.gui.center["char-panel"]
    if frame then frame.destroy() end


end



function UpdatePlayerLvStats(player)
local name=player.name

if player.character ~= nil then

		player.character.character_crafting_speed_modifier = global.personalxp.LV_Craft_Speed[name] * global.RPG_Bonus['LV_Craft_Speed']/100
		player.character.character_mining_speed_modifier = global.personalxp.LV_Mining_Speed[name] * global.RPG_Bonus['LV_Mining_Speed']/100
		player.character.character_running_speed_modifier = global.personalxp.LV_Run_Speed[name] * global.RPG_Bonus['LV_Run_Speed']/100

		player.character.character_build_distance_bonus = global.personalxp.LV_Reach_Dist[name] * global.RPG_Bonus['LV_Reach_Dist']
		player.character.character_reach_distance_bonus = global.personalxp.LV_Reach_Dist[name] * global.RPG_Bonus['LV_Reach_Dist']
		player.character.character_item_drop_distance_bonus = global.personalxp.LV_Reach_Dist[name] * global.RPG_Bonus['LV_Reach_Dist']
		player.character.character_resource_reach_distance_bonus = global.personalxp.LV_Reach_Dist[name] * global.RPG_Bonus['LV_Reach_Dist']

		player.character.character_inventory_slots_bonus = global.personalxp.LV_Inv_Bonus[name] * global.RPG_Bonus['LV_Inv_Bonus']
	--	player.character.character_logistic_slot_count_bonus = global.personalxp.LV_InvLog_Bonus[name] * global.RPG_Bonus['LV_InvLog_Bonus']
		player.character.character_trash_slot_count_bonus = global.personalxp.LV_InvTrash_Bonus[name] * global.RPG_Bonus['LV_InvTrash_Bonus']
		player.character.character_maximum_following_robot_count_bonus = global.personalxp.LV_Robot_Bonus[name] * global.RPG_Bonus['LV_Robot_Bonus']
		player.character.character_health_bonus = global.personalxp.LV_Health_Bonus[name] * global.RPG_Bonus['LV_Health_Bonus']

	if global.personalxp.opt_Pick_Extender[name] then
		player.character.character_item_pickup_distance_bonus = player.character.character_reach_distance_bonus
		player.character.character_loot_pickup_distance_bonus = player.character.character_reach_distance_bonus
		else
		player.character.character_item_pickup_distance_bonus = 0
		player.character.character_loot_pickup_distance_bonus = 0
		end

end
end



local p_attribs = { 'character_crafting_speed_modifier',
					'character_mining_speed_modifier',
					'character_running_speed_modifier',
					'character_reach_distance_bonus',
					'character_item_drop_distance_bonus',
					'character_resource_reach_distance_bonus',
					'character_inventory_slots_bonus',
				--	'character_logistic_slot_count_bonus',
					'character_trash_slot_count_bonus',
					'character_maximum_following_robot_count_bonus',
					'character_health_bonus',
					'character_item_pickup_distance_bonus'}

function CopyPlayerStats(name)
local player = game.players[name]
if player and player.valid then
	local character_attribs = {}

	if player.character and player.character.valid then
		for a=1,#p_attribs do
		table.insert(character_attribs,player.character[p_attribs[a]]) end
	end

	local rpg_stats = {global.personalxp.Level[name],
					   global.personalxp.XP[name],
					   global.personalxp.Death[name],
					   global.personalxp.opt_Pick_Extender[name],
					   global.personal_kill_units[name],
					   global.personal_kill_spawner[name],
					   global.personal_kill_turrets[name],
						}
	for k=1,#global.Player_Attributes do
		local attrib = global.Player_Attributes[k]
		table.insert (rpg_stats, global.personalxp[attrib][name] )
		end
	return {character_attribs=character_attribs, rpg_stats=rpg_stats}
	end
end


function PastePlayerStats(name,status)
local player = game.players[name]
if player and player.valid and status then
	local character_attribs = status.character_attribs

	if player.character and player.character.valid then
		for a=1,#p_attribs do  player.character[p_attribs[a]]=character_attribs[a] end
	end

	local rpg_stats = status.rpg_stats
	global.personalxp.Level[name] = rpg_stats[1]
    global.personalxp.XP[name]    = rpg_stats[2]
    global.personalxp.Death[name] = rpg_stats[3]
    global.personalxp.opt_Pick_Extender[name] = rpg_stats[4]
    global.personal_kill_units[name] = rpg_stats[5]
    global.personal_kill_spawner[name] = rpg_stats[6]
    global.personal_kill_turrets[name] = rpg_stats[7]

	for k=1,#global.Player_Attributes do
		local attrib = global.Player_Attributes[k]
		global.personalxp[attrib][name] = rpg_stats[k+7]
		end
	UpdatePanel(player)
	end
end


-- this will calculate the stat using sum, instead of replacing the value
-- used for compatibility with other mods
function AdjustPlayerStat(player,stat)
	local name=player.name

	if player.character ~= nil then
	  apply_bonus_relatively(player, stat, stats[stat])
	end
end

local function on_technology_effects_reset(event)
  -- character bonuses do *not* get reset by resetting technology effects
  do return end

  local force = event.force
  local players = force.connected_players
  local player = nil

  local mod = nil
  local internal = nil
  for _, player in pairs(players) do
    for mod, internal in pairs(stats) do
      apply_bonus_relatively(player, mod, internal)
    end
  end
end

function LevelUPPlayer(player,btname)

local name=player.name
local attribute = string.match(btname, "([^.]-)$")
if attribute then
  log("leveled up "..attribute)
else
  log("did not find attribute to level up")
end

global.personalxp[attribute][player.name] = global.personalxp[attribute][player.name] + 1

local mod = nil
for mod, internal in pairs(stats) do
  if internal.name == attribute then
    apply_one_bonus(player, mod, internal)
  end
end


do return end

for A=1,#global.Player_Attributes do
	local attrib = global.Player_Attributes[A]

	if btname=='btLVU_global.personalxp.'.. attrib then
		global.personalxp[attrib][name] = global.personalxp[attrib][name] + 1

		if btname=='btLVU_global.personalxp.LV_Craft_Speed' then
			player.character.character_crafting_speed_modifier = player.character.character_crafting_speed_modifier + global.RPG_Bonus[attrib]/100 end
		if btname=='btLVU_global.personalxp.LV_Mining_Speed' then
			player.character.character_mining_speed_modifier = player.character.character_mining_speed_modifier + global.RPG_Bonus[attrib]/100 end
		if btname=='btLVU_global.personalxp.LV_Run_Speed' then
			player.character.character_running_speed_modifier = player.character.character_running_speed_modifier + global.RPG_Bonus[attrib]/100 end

		if btname=='btLVU_global.personalxp.LV_Reach_Dist' then
			player.character.character_build_distance_bonus = player.character.character_build_distance_bonus + global.RPG_Bonus[attrib]
			player.character.character_reach_distance_bonus = player.character.character_reach_distance_bonus + global.RPG_Bonus[attrib]
			player.character.character_item_drop_distance_bonus = player.character.character_item_drop_distance_bonus + global.RPG_Bonus[attrib]
			player.character.character_resource_reach_distance_bonus = player.character.character_resource_reach_distance_bonus + global.RPG_Bonus[attrib] end

		if btname=='btLVU_global.personalxp.LV_Inv_Bonus' then
			player.character.character_inventory_slots_bonus = player.character.character_inventory_slots_bonus + global.RPG_Bonus[attrib] end

--		if btname=='btLVU_global.personalxp.LV_InvLog_Bonus' then
	--		player.character.character_logistic_slot_count_bonus = player.character.character_logistic_slot_count_bonus + global.RPG_Bonus[attrib] end

		if btname=='btLVU_global.personalxp.LV_InvTrash_Bonus' then
			player.character.character_trash_slot_count_bonus = player.character.character_trash_slot_count_bonus + global.RPG_Bonus[attrib] end

		if btname=='btLVU_global.personalxp.LV_Robot_Bonus' then
			player.character.character_maximum_following_robot_count_bonus = player.character.character_maximum_following_robot_count_bonus + global.RPG_Bonus[attrib] end

		if btname=='btLVU_global.personalxp.LV_Health_Bonus' then
			player.character.character_health_bonus = player.character.character_health_bonus + global.RPG_Bonus[attrib] end

		script.raise_event(on_player_updated_status, {player_index = player.index, player_level = global.personalxp.Level[name], attribute=attrib})

		break
		end
	end



if global.personalxp.opt_Pick_Extender[name] then
	player.character.character_item_pickup_distance_bonus = player.character.character_reach_distance_bonus
	player.character.character_loot_pickup_distance_bonus = player.character.character_reach_distance_bonus
	else
	player.character.character_item_pickup_distance_bonus = 0
	player.character.character_loot_pickup_distance_bonus = 0
	end
end



script.on_nth_tick(60 * 6,function (event)
XP_UPDATE_tick()
end)


function Cria_Player(event)
local player = game.players[event.player_index]
SetupPlayer(player,true)
end


function on_force_created(event)
local name = event.force.name
SetForceValues(name)
end


function onPlayerJoin(event)
local player = game.players[event.player_index]
CheckPlayer(player)
InitPlayerGui(player)
end


function On_Init()
XPModSetup()
end


function on_configuration_changed(data)
XPModSetup()
ResetXPTables()
end

script.on_event(defines.events.on_player_created, Cria_Player)
script.on_event(defines.events.on_player_joined_game, onPlayerJoin)
script.on_event(defines.events.on_runtime_mod_setting_changed, ReadRunTimeSettings)

--script.on_event(defines.events.on_tick, on_tick )
script.on_event(defines.events.on_force_created,on_force_created)
script.on_configuration_changed(on_configuration_changed)
script.on_init(On_Init)
script.on_event("key-I", function(event) expand_char_gui(game.players[event.player_index]) end)
script.on_event(defines.events.on_technology_effects_reset, on_technology_effects_reset)


local function on_gui_click(event)

local player = game.players[event.element.player_index]
local name = event.element.name

    if (name == "btcharxp") then
        expand_char_gui(player)
    elseif (name == "btTagCharOK")then
		local textImput = player.gui.center["char-panel"].tabcharScroll.char_frametag.tabchartag.ctag_field.text

		if textImput == "{reset-points}" then
			if player.admin then
				expand_char_gui(player)
				ResetPointSpent()
				game.print({'xp_reset_altert'})
				end
			return
		elseif textImput == "{reset-all}" then
			if player.admin then
				expand_char_gui(player)
				ResetAll()
				game.print({'xp_reset_altert'})
				end
			return
		elseif textImput == "{list}" then
			ListAll(player)
			player.gui.center["char-panel"].tabcharScroll.char_frametag.tabchartag.ctag_field.text = "{list}"
			return
		elseif textImput == "{listXPTable}" then
			ListXPTable(player)
			return
			end



		player.tag = textImput
		expand_char_gui(player)

	elseif string.sub(name,1,6)=='btLVU_' then
		if player.character and player.character.valid then
		LevelUPPlayer(player,name)
		expand_char_gui(player)
		expand_char_gui(player)
		end

	elseif name == "cb_pick_extender" then
		if player.character == nil then
			player.gui.center["char-panel"].tabcharScroll.cb_pick_extender.state = global.personalxp.opt_Pick_Extender[player.name]
			return
			end
		local cb_pick_extender = player.gui.center["char-panel"].tabcharScroll.cb_pick_extender.state
		global.personalxp.opt_Pick_Extender[player.name] = cb_pick_extender

		if cb_pick_extender then
			player.character.character_item_pickup_distance_bonus = player.character.character_reach_distance_bonus
			player.character.character_loot_pickup_distance_bonus = player.character.character_reach_distance_bonus
		else
			player.character.character_item_pickup_distance_bonus = 0
			player.character.character_loot_pickup_distance_bonus = 0
		end

--[[	elseif name == "btColorsChar" or name == "btColorsCharCancel" then
		expand_char_color_gui(player)
	elseif name == "btColorsCharApply" then
		apply_char_color(player)]]
	end

end
script.on_event(defines.events.on_gui_click, on_gui_click)


-- ANTI RESPAWN EVENT DEPENDENCY
script.on_nth_tick(60*21, function (event)
for p, PL in pairs (game.connected_players) do
	if PL.valid and PL.character and PL.character.valid then
		local name = PL.name
		if (PL.character.character_crafting_speed_modifier==0 and global.personalxp.LV_Craft_Speed[name]>0) or
		   (PL.character.character_running_speed_modifier==0  and global.personalxp.LV_Mining_Speed[name]>0) then
			UpdatePlayerLvStats(PL) end
		end
	end
end)


script.on_event(defines.events.on_player_respawned, function(event)
local player = game.players[event.player_index]
UpdatePlayerLvStats(player)
end)


script.on_event(defines.events.on_pre_player_died, function(event)
local player = game.players[event.player_index]
local name = player.name
local XP = global.personalxp.XP[name]
local Level = global.personalxp.Level[name]
local NextLevel = global.xp_table[Level]
local XP_ant
if Level==1 then XP_ant = 0 else XP_ant = global.xp_table[Level-1] end
local Interval_XP = NextLevel - XP_ant
local Penal = math.floor((XP-XP_ant)*global.setting_death_penal/100)
global.personalxp.Death[name] = global.personalxp.Death[name]+1

if Penal>0 then
global.personalxp.XP[name] = global.personalxp.XP[name]-Penal
player.print({"", {'xp_lost'}, format_number(Penal)},colors.lightred)
end

end)




function GetXPByKill(entity,killer,force)
if force then
if global.setting_allow_xp_by_kill then
if not global.last_overkill or (global.last_overkill and global.last_overkill~=entity) then



if entity and entity.valid then
local XP = entity.prototype.max_health
local player , plname



if killer and killer.valid then
	if killer.type == 'character' then
		player=killer.player
		if player then
			plname=player.name
			end
		force=killer.force
		end
	end

local nforce=force.name

if (not force.get_friend(entity.force)) then

if entity.type == 'character' then XP = XP * 100 end

	if entity.type == 'unit' then
		global.kills_units[nforce] = global.kills_units[nforce] + 1
		if player then global.personal_kill_units[plname]=global.personal_kill_units[plname]+1 end
		elseif entity.type == 'unit-spawner' then
		XP = XP * 3
		global.kills_spawner[nforce] = global.kills_spawner[nforce] +1
		if player then global.personal_kill_spawner[plname]=global.personal_kill_spawner[plname]+1 end
		elseif entity.type == 'turret' then
		global.kills_worms[nforce] = global.kills_worms[nforce] +1
		if player then global.personal_kill_turrets[plname]=global.personal_kill_turrets[plname]+1 end
		XP = XP * 3
		end

--	if XP > 999999 then XP=999999 end
	XP = math.ceil((1+force.evolution_factor*2) * global.XP_Mult * XP/100)
	if XP<1 then XP=1 end

	local teamxp = true
		if plname then
			if global.personalxp.XP[plname] then
				global.personalxp.XP[plname] = global.personalxp.XP[plname] + XP
				printXP(player,XP)
				teamxp = false
				end
			end

		if teamxp and global.XP_KILL_HP[nforce] then
			global.XP_KILL_HP[nforce] = global.XP_KILL_HP[nforce] + XP
			global.XP[nforce] = global.XP[nforce] + XP
			end


end
end
end
end
global.last_overkill=nil
end
end

--- XP FOR KILL
script.on_event(defines.events.on_entity_died, function(event)
if not event.force then return end


local force=event.force  -- force that kill
local killer=event.cause


--if event.entity.force.name == 'enemy' and force~='neutral' and force~='enemy' then --aliens
if killer and killer.valid and global.kills_units[force.name] and event.entity.force~=game.forces.neutral then
	if event.entity.prototype and event.entity.prototype.max_health and (not force.get_friend(event.entity.force)) then

		if killer.type=='car' then
			if killer.get_driver() and killer.get_driver().valid then
				killer = killer.get_driver()
				elseif killer.get_passenger() and killer.get_passenger().valid then
				killer = killer.get_passenger()
				end
			end

		GetXPByKill(event.entity,killer,force)

		end
	end


if not killer then
   if global.kills_units[force.name] and event.entity.force~=game.forces.neutral then
   GetXPByKill(event.entity,killer,force)
   end end

end)



if settings.startup["charxpmod_enable_damage_attribs"].value then
-- damage bonus,  criticals , natural armor
script.on_event(defines.events.on_entity_damaged, function(event)
local entity = event.entity
local damage_type = event.damage_type
local original_damage_amount = event.original_damage_amount
local cause = event.cause


if cause and cause.valid and entity and entity.valid and entity.health>0 and damage_type and original_damage_amount then

	-- NATURAL ARMOR
	if event.final_damage_amount>0 and entity.type == 'character' then
		local player = entity.player
		if player and player.valid then
			local armor_lv = global.personalxp.LV_Armor_Bonus[player.name]
			if armor_lv>0 then
				local bonus = (global.RPG_Bonus.LV_Armor_Bonus * armor_lv)
				local recover = event.final_damage_amount*bonus/100
				entity.health = entity.health + recover
				end
			end
		end

	-- DAMAGE BONUS
	if cause.type == 'character' and damage_type.name~='poison' then
		local player = cause.player
		if player and player.valid then
		local dmg_lv = global.personalxp.LV_Damage_Bonus[player.name]
		local critical_lv = global.personalxp.LV_Damage_Critical[player.name]
		local new_damage = original_damage_amount
		if dmg_lv>0 then
			local bonus = 1+ (global.RPG_Bonus.LV_Damage_Bonus * dmg_lv/100)
			new_damage = original_damage_amount * bonus
			end

		-- CRITICAL HITS
		if critical_lv>0 and (entity.type=='unit' or entity.type=='unit-spawner' or entity.type=='turret' or entity.type=='character')  then
		if math.random(1,200)<=critical_lv then
			new_damage = math.ceil(new_damage * (5 + critical_lv/2))
			if global.setting_print_critical then
				local txt = '[img=fluid.heavy-oil]' -- .. new_damage
				entity.surface.create_entity{name = "flying-text", position = entity.position, text = txt, color = colors.lightred}
				end
			end
			end

		if new_damage > original_damage_amount then
			local dif = new_damage - original_damage_amount
			if entity.health < dif then  -- give kill xp to player because the extra damage will kill entity
				GetXPByKill(entity,cause,cause.force)
				global.last_overkill = event.entity
				end
			entity.health = entity.health + event.final_damage_amount
			entity.damage(new_damage,player.force,damage_type.name)	-- this fires the event again
			end
		end
		end

	end


end,  {{filter = "type", type = "unit"}, {filter = "type", type = "unit-spawner"},
		{filter = "type", type = "wall"}, {filter = "type", type = "gate"},
		{filter = "type", type = "electric-turret"}, {filter = "type", type = "gun-turret"},  {filter = "type", type = "turret"},
		{filter = "type", type = "character"}}) -- event filters for on_built_entity
end



-- XP by research
script.on_event(defines.events.on_research_finished, function(event)
if global.setting_allow_xp_by_tech and game.tick > 3600 * 2 then

if event.research.force ~= nil then
	local force = event.research.force.name
	if force~='neutral' and force~='enemy' then
	if global.XP_TECH[force] then
		local techXP = event.research.research_unit_count * #event.research.research_unit_ingredients
		techXP = math.ceil(global.XP_Mult * techXP * (1+ (6*game.forces["enemy"].evolution_factor)))
		global.XP_TECH[force] = global.XP_TECH[force]  +techXP
		global.XP[force] = global.XP[force]  +techXP
		end
	end
	end
end
end)



-- XP by Rocket
script.on_event(defines.events.on_rocket_launched, function(event)
if global.setting_allow_xp_by_rocket then
local rocket = event.rocket
local force = rocket.force
local XP

	for p, PL in pairs (force.connected_players) do
		local r_count = global.personalxp.rocketsXP_count[PL.name]
		if r_count == nil then r_count=0 end
		XP = math.ceil(global.XP_Mult * global.personalxp.XP[PL.name]/(5+(r_count*2))) --20% inicial
		global.personalxp.XP[PL.name] = global.personalxp.XP[PL.name] + XP
		printXP(PL,XP)
		global.personalxp.rocketsXP_count[PL.name] = r_count+1
	end
end
end)


--- XP FOR Mining rocks, trees
function XPByMiningRT(player,ent)
local XP = 0


if  ent.prototype.max_health then
	XP=ent.prototype.max_health
	if ent.type=='tree' then XP=XP/100 else XP=XP/400 end
	end


if XP>0 then
   local plname = player.name
   XP = math.ceil(XP * global.personalxp.Level[plname] * global.XP_Mult)
   global.personalxp.XP[plname] = global.personalxp.XP[plname] + XP
   printXP(player,XP)
   end

end


script.on_event(defines.events.on_player_mined_entity, function(event)
if global.setting_allow_xp_by_mining then
local player = game.players[event.player_index]
if not player.valid then return end

local ent = event.entity
local name= ent.name

if ent.type=='tree' or (ent.type=='simple-entity' and name:find('rock')) then
	XPByMiningRT(player,ent)
	end
end
end)





-- Potions
script.on_event(defines.events.on_player_used_capsule, function(event)
local player = game.players[event.player_index]
local item = event.item


	if item.name=='rpg_small_xp_potion' then
	   remote.call("RPG","PlayerXPPerc",player.name,15)
		player.print("You feel better now...", colors.yellow)

	elseif item.name=='rpg_big_xp_potion' then
	   remote.call("RPG","PlayerXPPerc",player.name,25)
		player.print("You feel better now...", colors.yellow)

	elseif item.name=='rpg_level_up_potion' then
	   remote.call("RPG","PlayerGainLevel",player.name)
		player.print("You feel much better now.. yeah!", colors.yellow)
	elseif item.name=='rpg_amnesia_potion' then

		local XP = math.ceil(global.personalxp.XP[player.name] * 0.7)
		SetupPlayer(player)
		global.personalxp.XP[player.name] = XP
		XP_UPDATE_tick()
		player.print("You feel strange... you don't even know where you are... What is it you just drunk?", colors.lightgreen)
		end

end)

-- INTERFACE  --
--------------------------------------------------------------------------------------
-- /c remote.call("RPG","TeamXP","player",150)
local interface = {}

-- Give XP to Team (may be negative)
function interface.TeamXP(forcename,XP)
global.XP[forcename] = global.XP[forcename] + XP
XP_UPDATE_tick()
end

-- Give XP to a player (may be negative)
function interface.PlayerXP(playername,XP)
global.personalxp.XP[playername] = global.personalxp.XP[playername] + XP
printXP(game.players[playername],XP)
XP_UPDATE_tick()
end

-- Give a fixed XP multiplyed by player level (may be negative)
function interface.PlayerXPPerLevel(playername,XP)
global.personalxp.XP[playername] = global.personalxp.XP[playername] + (XP * global.personalxp.Level[playername])
XP_UPDATE_tick()
end

-- Player gain one level
function interface.PlayerGainLevel(playername)
if global.personalxp.XP[playername] then
	local XP = CalculateXP_GAIN_LV(playername)
	global.personalxp.XP[playername] = global.personalxp.XP[playername] + XP
	XP_UPDATE_tick()
end
end


-- Give player XP % of his own XP
function interface.PlayerXPPerc(playername,Perc)
local XP = math.ceil(global.personalxp.XP[playername]*Perc/100)
global.personalxp.XP[playername] = global.personalxp.XP[playername] + XP
printXP(game.players[playername],XP)
XP_UPDATE_tick()
end

-- Penalty XP for a % of his own XP
function interface.PlayerXPPenalPerc(playername,Perc)
global.personalxp.XP[playername] = global.personalxp.XP[playername] - math.ceil(global.personalxp.XP[playername]*Perc/100)
XP_UPDATE_tick()
end


-- Give all force players a XP% of his own XP
function interface.TeamXPPerc(forcename,Perc)
local XP
	for p, PL in pairs (game.forces[forcename].connected_players) do
		XP = math.ceil(global.personalxp.XP[PL.name]*Perc/100)
		global.personalxp.XP[PL.name] = global.personalxp.XP[PL.name] + XP
		printXP(PL,XP)
	end
XP_UPDATE_tick()
end

-- Used only for compatibility with other mods
function interface.OtherEventsByPlayer(player,event_name,parameter)
if event_name=='mine_rock' then
   XPByMiningRT(player.name,parameter)
   end
if event_name=='adjust_player_stats' then
   AdjustPlayerStat(player,parameter)
   end
end


function interface.ResetAll()
ResetAll()
end


interface.CopyPlayerStats = CopyPlayerStats
function interface.PastePlayerStats(playername,stats)
PastePlayerStats(playername,stats)
end


--[[ HOW TO subscribe to my 2 events below:
	script.on_event(remote.call("RPG", "get_on_player_updated_status"), function(event)
		--do your stuff
	end)
	WARNING: this has to be done within on_init and on_load, otherwise the game will error about the remote.call

	if your dependency on my mod is optional, remember to check if the remote interface exists before calling it:
	if remote.interfaces["RPG"] then
		--interface exists
	end]]

function interface.get_on_player_updated_status()
return on_player_updated_status
end
		-- Returns :
		-- event.player_index = Index of the player that upgraded an attribute
		-- event.level        = Player current XP Level
		-- event.attribute    = The attribute that was upgraded

function interface.get_on_player_level_up()
return on_player_level_up
end
		-- Returns :
		-- event.player_index = Index of the player that has just leveled up
		-- event.level        = Player current XP Level


remote.add_interface("RPG", interface )