Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- 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,100 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
- --we should subtract any previous change with a function
- local attrib = global.Player_Attributes[k]
- global.personalxp[attrib][name]= 0
- end
- global.personalxp.opt_Pick_Extender[name] = false
- UpdatePlayerLvStats(player) --breaks changes with other mods
- 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]=100
- 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 = 20
- 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<100 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
- function LevelUPPlayer(player,btname)
- local name=player.name
- local attribute = string.match(btname, "([^.]-)$")
- if attribute == nil then
- game.print("no attribute found in btname: "..btname)
- return
- end
- global.personalxp[attribute][player.name] = global.personalxp[attribute][player.name] + 1
- for mod, internal in pairs(stats) do
- if internal.name == attribute then
- apply_one_bonus(player, mod, internal)
- --script.raise_event(on_player_updated_status, {player_index = player.index, player_level = global.personalxp.Level[name], attribute=attrib}) --old event pasted here
- end
- 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()
- 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)
- -- closes panel when player open inventory E
- script.on_event(defines.events.on_gui_opened, function(event)
- if event.gui_type and event.gui_type ==defines.gui_type.controller then
- local player = game.players[event.player_index]
- local frame = player.gui.center["char-panel"]
- if frame then frame.destroy() end
- end
- end)
- 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 * 5
- 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) * global.XP_Mult * XP/2)
- 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
- XP=math.ceil(XP/2)
- 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 )
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement