khanat-client-data-NeL/data/ryz/ryz_ring/r2_ui_displayer_npc.lua

3093 lines
92 KiB
Lua

-- SEX -----------------------------------------------------------------------------------
r2.male = "male"
r2.female = "female"
r2.sexSelection = "male"
-- RACE ----------------------------------------------------------------------------------
r2.raceSelection = "Fyros"
r2.fyros = "Fyros"
r2.matis = "Matis"
r2.tryker = "Tryker"
r2.zorai = "Zorai"
r2.NPCNames = {} -- All available names
r2.NPCAllNames = {} -- All Names (even those who are not available)
-- CHANGE VIEW ---------------------------------------------------------------------------
r2.faceView = false
r2.camPosY = -16.4
r2.camZoomPosY = -3.9
r2.camTgtZ = -0.79
r2.camTgtZZorai = -0.75
r2.camPosYZorai = -18.3
r2.distlimitmin = 9.0
r2.distlimitmax = -r2.camPosY
r2.distlimitminZoom = 2.5
-- FACE MORPH EDIT TEXT ------------------------------------------------------------------
r2.raceMorphEditText = {}
r2.raceMorphEditText[r2.fyros] = { [1]="Mouth level", [2]="Eyes",
[3]="Nose level", [4]="Mouth width",
[5]="Nose length", [6]="Nose width",
[7]="Brown width", [8]="Chin"}
r2.raceMorphEditText[r2.matis] = { [1]="Eyes level", [2]="Nose level",
[3]="Nose length", [4]="Nose width",
[5]="Mouth width", [6]="Mouth level",
[7]="Ear size", [8]="Chin"}
r2.raceMorphEditText[r2.tryker] = { [1]="Eyes level", [2]="Nose level",
[3]="Nose length", [4]="Nose width",
[5]="Mouth width", [6]="Mouth level",
[7]="Ear size", [8]="Chin"}
r2.raceMorphEditText[r2.zorai] = { [1]="Eyes size", [2]="bottom horn 1",
[3]="bottom horn 2",[4]="middle horn 1",
[5]="middle horn 2",[6]="top horn 1",
[7]="top horn 2", [8]=""}
r2.tableBodySets = {}
r2.tableFaceSets = {}
r2.tableFaceMorph = {}
r2.raceSheetNameMatch =
{
["basic_fyros_male.creature"] = "Fyros",
["basic_fyros_female.creature"] = "Fyros",
["basic_matis_male.creature"] = "Matis",
["basic_matis_female.creature"] = "Matis",
["basic_tryker_male.creature"] = "Tryker",
["basic_tryker_female.creature"] = "Tryker",
["basic_zorai_male.creature"] = "Zorai",
["basic_zorai_female.creature"] = "Zorai"
}
r2.raceSheetClient =
{
male = {Fyros="basic_fyros_male.creature",
Matis="basic_matis_male.creature",
Tryker="basic_tryker_male.creature",
Zorai="basic_zorai_male.creature"},
female= {Fyros="basic_fyros_female.creature",
Matis="basic_matis_female.creature",
Tryker="basic_tryker_female.creature",
Zorai="basic_zorai_female.creature"}
}
-- ITEM INDEX / SLIDER VALUE FACES SETS --------------------------------------------------
r2.sliderValueToItemIndex = {}
r2.sliderValueToItemIndex[r2.fyros] = {[0] = "fy_cheveux_shave01.sitem", [1] = "fy_cheveux_short01.sitem",
[2] = "fy_cheveux_short02.sitem", [3] = "fy_cheveux_medium01.sitem",
[4] = "fy_cheveux_medium02.sitem", [5] = "fy_cheveux_medium03.sitem",
[6] = "fy_cheveux_long01.sitem"}
r2.sliderValueToItemIndex[r2.matis] = {[0] = "ma_cheveux_shave01.sitem", [1] = "ma_cheveux_short01.sitem",
[2] = "ma_cheveux_short02.sitem", [3] = "ma_cheveux_medium01.sitem",
[4] = "ma_cheveux_medium02.sitem", [5] = "ma_cheveux_long01.sitem",
[6] = "ma_cheveux_long02.sitem"}
r2.sliderValueToItemIndex[r2.tryker] = {[0] = "tr_cheveux_shave01.sitem", [1] = "tr_cheveux_short01.sitem",
[2] = "tr_cheveux_short02.sitem", [3] = "tr_cheveux_short03.sitem",
[4] = "tr_cheveux_medium01.sitem", [5] = "tr_cheveux_medium02.sitem",
[6] = "tr_cheveux_long01.sitem"}
r2.sliderValueToItemIndex[r2.zorai] = {[0] = "zo_cheveux_shave01.sitem", [1] = "zo_cheveux_short01.sitem",
[2] = "zo_cheveux_medium01.sitem", [3] = "zo_cheveux_medium02.sitem",
[4] = "zo_cheveux_medium03.sitem", [5] = "zo_cheveux_long01.sitem",
[6] = "zo_cheveux_long02.sitem"}
r2.itemIndexToSliderValue = {}
r2.hasHelmet = false
r2.hairType = {}
r2.selectEquipmentSet = false
-----------------------------------------------------------------------
-- Current fonction to change an attribute in a npc
-- default is to do a 'requestSetNode'
function r2:setNpcAttribute(instanceId, propName, propValue)
r2.requestSetNode(instanceId, propName, propValue)
end
-- INIT ITEM INDEX TO SLIDER VALUE TABLE -------------------------------------------------
function r2:initItemIndexToSliderValueTable()
r2.itemIndexToSliderValue={}
local races = {r2.fyros, r2.matis, r2.tryker, r2.zorai}
for key1, value1 in pairs(races) do
r2.itemIndexToSliderValue[value1] = {}
for key2, value2 in pairs(r2.sliderValueToItemIndex[value1]) do
local itemIndex = getSheetId(value2)
r2.itemIndexToSliderValue[value1][itemIndex] = key2
end
end
end
local body_sliders = {GabaritHeight ="slider_height",
GabaritTorsoWidth ="slider_torso",
GabaritArmsWidth ="slider_arms",
GabaritLegsWidth ="slider_legs",
GabaritBreastSize ="slider_breast",
HairType ="slider_haircut",
HairColor ="slider_hair_color",
Tattoo ="slider_tattoos",
EyesColor ="slider_eye_color",
MorphTarget1 ="slider_morph_target1",
MorphTarget2 ="slider_morph_target2",
MorphTarget3 ="slider_morph_target3",
MorphTarget4 ="slider_morph_target4",
MorphTarget5 ="slider_morph_target5",
MorphTarget6 ="slider_morph_target6",
MorphTarget7 ="slider_morph_target7",
MorphTarget8 ="slider_morph_target8"}
r2.sheetTypeCB = {}
-- share npc displayer between all instances
local npcCustomPropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())
local oldCustomNPCOnAttrModified = npcCustomPropertySheetDisplayerTable.onAttrModified
------------------------------------------------
function npcCustomPropertySheetDisplayerTable:onPostCreate(instance)
end
------------------------------------------------
function npcCustomPropertySheetDisplayerTable:onErase(instance)
end
------------------------------------------------
function npcCustomPropertySheetDisplayerTable:onPreHrcMove(instance)
r2:npcPropertySheetDisplayer():onPreHrcMove(instance)
end
------------------------------------------------
function npcCustomPropertySheetDisplayerTable:onPostHrcMove(instance)
r2:npcPropertySheetDisplayer():onPostHrcMove(instance)
end
------------------------------------------------
function npcCustomPropertySheetDisplayerTable:onFocus(instance, hasFocus)
end
------------------------------------------------
r2.customizationOpen = false
function npcCustomPropertySheetDisplayerTable:onSelect(instance, isSelected)
r2:npcPropertySheetDisplayer():onSelect(instance, isSelected)
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
if not isSelected then
r2.customizationOpen = npcUI.active
npcUI.active = false
else
r2.raceSelection = getR2PlayerRace(instance.SheetClient)
if r2.customizationOpen == true then
r2.customizationOpen = false
npcCustomPropertySheetDisplayerTable:updateAll(instance)
end
end
end
------------------------------------------------
function npcCustomPropertySheetDisplayerTable:updateAll(instance)
-- nico patch :
-- replace the r2:setNpcProperty function, so that it does call 'requestSetNode', but rather forward call
-- to the displayer directly...
local function bypassRequestNode(this, instanceId, propName, propValue)
local instance = r2:getInstanceFromId(instanceId)
instance.DisplayerProperties:onAttrModified(instance, propName)
end
local oldSetNpcAttribute = r2.setNpcAttribute
r2.setNpcAttribute = bypassRequestNode
local ok, msg = pcall(self.updateAllPrivate, self, instance)
if not ok then
debugInfo(msg)
end
r2.setNpcAttribute = oldSetNpcAttribute
end
------------------------------------------------
function npcCustomPropertySheetDisplayerTable:updateAllPrivate(instance)
-- if attribute is visible in the generic property sheet, then update it
local propDesc = instance:getPropDesc(attributeName)
if propDesc and propDesc.Visible ~= false then -- NB : "visible" may be nil, which default to 'true'...
-- property visible in the generic property sheet so update it
--debugInfo("Updating in generic property sheet : " .. attributeName)
oldCustomNPCOnAttrModified(self, instance, attributeName)
end
assert(instance)
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local propWnd = r2:getPropertySheet(instance)
if propWnd.active then
local nameEBox = propWnd:find("Name"):find("eb")
local name = nameEBox.uc_input_string:toUtf8()
r2:setNpcAttribute(instance.InstanceId, "Name", name)
end
npcUI.active = true
r2:updateNPCView(instance)
r2.hairType = {}
-- update sex
local sexCB = npcUI:find("sex").combo_box
assert(sexCB)
if isR2PlayerMale(instance.SheetClient) then
r2.sexSelection = r2.male
else
r2.sexSelection = r2.female
end
sexCB.Env.locked = true
sexCB.selection_text = r2.sexSelection
sexCB.Env.locked = false
-- update race in combo box
local raceCB = npcUI:find("race").combo_box
assert(raceCB)
r2.raceSelection = getR2PlayerRace(instance.SheetClient)
local sliderHairType = r2.itemIndexToSliderValue[r2.raceSelection][instance.HairType]
r2.hasHelmet = (sliderHairType == nil)
if not r2.hasHelmet then
r2.hairType.hairCut = sliderHairType
r2.hairType.hairColor = instance.HairColor
else
r2.hairType.hairCut = 0
r2.hairType.hairColor = 0
end
raceCB.Env.locked = true
raceCB.selection_text = r2.raceSelection
raceCB.Env.locked = false
-- update name
local editName = npcUI:find("name").edit_box_group
assert(editName)
editName.uc_input_string = instance:getDisplayName()
npcUI.uc_title = concatUCString(i18n.get("uiRE2DPropertiesOf"), instance:getDisplayName())
-- update notes
local editNotes = npcUI:find("small_description")
assert(editNotes)
if instance.Notes ~= nil then
editNotes.input_string = instance.Notes
else
editNotes.input_string = ""
end
-- update avoidable equipment
r2:updateEquipment(instance, false)
-- update link color
local toggleB = npcUI:find("color_link").toggle_butt
assert(toggleB)
local link = false
if instance.LinkColor==1 then link=true end
toggleB.pushed = not link
-- update weapons
comboBox = npcUI:find("hands"):find("combo_box")
local handsLevel = r2:getHandsLevel(instance.SheetModel, instance.Sheet)
local rightHandIndex = instance.WeaponRightHand
local leftHandIndex = instance.WeaponLeftHand
local handsKey = rightHandIndex..":"..leftHandIndex..":"..handsLevel
local weaponsName = r2.itemIndexEquipmentToSelectionText[instance.Equipment][comboBox.Env.nameComboBox][handsKey]
comboBox.Env.locked = true
comboBox.selection_text = weaponsName
comboBox.Env.locked = false
-- camera target is out of 3D character
r2:updateRaceView()
r2.faceView = false
-- update body sliders
for key, value in pairs(body_sliders) do
local slider = npcUI:find(value):find("slider")
assert(slider)
if value == "slider_haircut" and not r2.hasHelmet then
slider.value = r2.itemIndexToSliderValue[r2.raceSelection][instance["HairType"] ]
else
slider.value = instance[key]
end
end
-- empty body/face/morph sets
local bodyCB = npcUI:find("body_sets").combo_box
assert(bodyCB)
bodyCB.view_text = r2.emptyComboLine
local faceCB = npcUI:find("face_sets").combo_box
assert(faceCB)
faceCB.view_text = r2.emptyComboLine
local morphCB = npcUI:find("face_morph").combo_box
assert(morphCB)
morphCB.view_text = r2.emptyComboLine
r2:updateRaceUI()
end
------------------------------------------------
function r2:initTypeUI(instance)
local propertiesUI = getUI(r2:getDefaultPropertySheetUIPath(instance.Class))
assert(propertiesUI)
-- update avoidable types
local typeCB = propertiesUI:find("TypeNPC")
assert(typeCB)
typeCB:resetTexts()
local currentType = ""
-- search for current ecosystem et level selected in palette UI
local levelMin, levelMax, ecosystem = r2:getPaletteAccessibilityFactors()
local place = 0
if ecosystem and levelMin and levelMax then
-- parent palette element in palette UI (type node)
local typePalette = r2.PaletteIdToType[instance.Base]
r2.sheetTypeCB = {}
-- for each element of this type, check if must be added in combo box (only if also showed in palette UI)
-- then the same test is used than in r2:setupPaletteAccessibleContent
for typeKey, typeValue in pairs(typePalette) do
local typeTranslation = typeValue.Translation
local typeElement = r2.getPaletteElement(typeValue.Id)
local show = false
local levelElt = defaulting(typeElement.Level, 1)
local ecosystemElt = defaulting(typeElement.Ecosystem, "")
if string.match(typeElement.SheetClient, "object.*") then
show = true
elseif levelElt >= levelMin and levelElt <= levelMax and (ecosystemElt == "" or string.match(ecosystemElt, ecosystem)) then
show = true
end
if show then
r2.sheetTypeCB[typeCB:getNumTexts()] = typeValue
typeCB:addText(i18n.get(typeTranslation))
if instance.Base==typeValue.Id then
currentType = typeValue.Translation
end
if currentType=="" then place = place+1 end
end
end
if tostring(instance.TypeNPC)=="-1" then
-- TypeNPC
r2:setNpcAttribute(instance.InstanceId, "TypeNPC", place)
end
end
end
------------------------------------------------
r2.bodyAttributesCB = {
["GabaritHeight"] = {comboBox="body_sets", updateComboBox="r2ed_add_body_sets", tableSets="tableBodySets"},
["GabaritTorsoWidth"] = {comboBox="body_sets", updateComboBox="r2ed_add_body_sets", tableSets="tableBodySets"},
["GabaritArmsWidth"] = {comboBox="body_sets", updateComboBox="r2ed_add_body_sets", tableSets="tableBodySets"},
["GabaritLegsWidth"] = {comboBox="body_sets", updateComboBox="r2ed_add_body_sets", tableSets="tableBodySets"},
["GabaritBreastSize"] = {comboBox="body_sets", updateComboBox="r2ed_add_body_sets", tableSets="tableBodySets"},
["EyesColor"] = {comboBox="face_sets", updateComboBox="r2ed_add_face_sets", tableSets="tableFaceSets"},
["Tattoo"] = {comboBox="face_sets", updateComboBox="r2ed_add_face_sets", tableSets="tableFaceSets"},
["HairType"] = {comboBox="face_sets", updateComboBox="r2ed_add_face_sets", tableSets="tableFaceSets"},
["HairColor"] = {comboBox="face_sets", updateComboBox="r2ed_add_face_sets", tableSets="tableFaceSets"},
["MorphTarget1"] = {comboBox="face_morph", updateComboBox="r2ed_add_face_morph", tableSets="tableFaceMorph"},
["MorphTarget2"] = {comboBox="face_morph", updateComboBox="r2ed_add_face_morph", tableSets="tableFaceMorph"},
["MorphTarget3"] = {comboBox="face_morph", updateComboBox="r2ed_add_face_morph", tableSets="tableFaceMorph"},
["MorphTarget4"] = {comboBox="face_morph", updateComboBox="r2ed_add_face_morph", tableSets="tableFaceMorph"},
["MorphTarget5"] = {comboBox="face_morph", updateComboBox="r2ed_add_face_morph", tableSets="tableFaceMorph"},
["MorphTarget6"] = {comboBox="face_morph", updateComboBox="r2ed_add_face_morph", tableSets="tableFaceMorph"},
["MorphTarget7"] = {comboBox="face_morph", updateComboBox="r2ed_add_face_morph", tableSets="tableFaceMorph"},
["MorphTarget8"] = {comboBox="face_morph", updateComboBox="r2ed_add_face_morph", tableSets="tableFaceMorph"},
}
function npcCustomPropertySheetDisplayerTable:onAttrModified(instance, attributeName)
r2:npcPropertySheetDisplayer():onAttrModified(instance, attributeName)
if r2:getSelectedInstance()==nil or r2:getSelectedInstance().InstanceId ~= instance.InstanceId then
return
end
r2:updateNPCView(instance)
local npcUI = getUI("ui:interface:r2ed_npc")
local comboBox
if attributeName == "HairType" then
local sliderHairType = r2.itemIndexToSliderValue[r2.raceSelection][instance.HairType]
r2.hasHelmet = (sliderHairType == nil)
end
-- SEX AND RACE
if attributeName == "SheetClient" then
-- sex
comboBox = npcUI:find("sex").combo_box
local isFemale = string.find(instance[attributeName], "female")
if isFemale ~= nil then
r2.sexSelection = r2.female
else
r2.sexSelection = r2.male
end
comboBox.Env.locked = true
comboBox.selection_text = r2.sexSelection
comboBox.Env.locked = false
-- race
local comboBox = npcUI:find("race").combo_box
r2.raceSelection = r2.raceSheetNameMatch[instance[attributeName]]
comboBox.Env.locked = true
comboBox.selection_text = r2.raceSelection
comboBox.Env.locked = false
r2:updateRaceView()
r2:updateFaceView()
r2:updateRaceUI()
return
end
-- NAME
if attributeName == "Name" then
local editName = npcUI:find("name").edit_box_group
assert(editName)
editName.uc_input_string = instance:getDisplayName()
npcUI.uc_title = concatUCString(i18n.get("uiRE2DPropertiesOf"), instance:getDisplayName())
editName:cancelFocusOnText()
return
end
-- NOTES
if attributeName == "Notes" then
local editNotes= npcUI:find("small_description")
assert(editNotes)
editNotes.input_string = instance[attributeName]
editNotes:cancelFocusOnText()
return
end
-- EQUIPMENT PIECE
local slider
for cbbName, v in pairs(r2.equipmentEnv) do
if v.propName == attributeName then
comboBox = npcUI:find(cbbName):find("combo_box")
assert(comboBox)
local CBText = r2.itemIndexEquipmentToSelectionText[instance.Equipment][cbbName][instance[attributeName]]
if CBText==nil then CBText= r2.noPiece end
if attributeName == "HairType" then
slider = npcUI:find("slider_haircut")
assert(slider)
slider.active = (CBText == r2.noPiece)
if slider.active then
local value = r2.itemIndexToSliderValue[r2.raceSelection][instance["HairType"] ]
if value then
slider:find("slider").value = value
end
end
slider = npcUI:find("slider_hair_color")
assert(slider)
slider.active = (CBText == r2.noPiece)
if slider.active then
slider:find("slider").value = instance.HairColor
end
end
comboBox.Env.locked = true
comboBox.selection_text = CBText
comboBox.Env.locked = false
-- if equipment is 'no one', color slider must be hidden
slider = npcUI:find(cbbName):find("slider")
assert(slider)
local line = npcUI:find(cbbName):find("line_slider")
assert(line)
slider.active = (CBText ~= r2.noPiece)
line.active = (CBText ~= r2.noPiece)
if slider.active then
slider.value = instance[v.propColorName]
end
return
end
if v.propColorName == attributeName then
if attributeName == "HairColor" then
if not r2.hasHelmet then
slider = npcUI:find("slider_hair_color"):find("slider")
assert(slider)
slider.value = instance[attributeName]
end
else
slider = npcUI:find(cbbName):find("slider")
assert(slider)
slider.value = instance[attributeName]
end
for k, v1 in pairs(r2.equipementComboB) do
slider = npcUI:find(v1):find("slider")
local comboBox = npcUI:find(cbbName):find("combo_box")
local propName = r2.equipmentEnv[v1].propName
local comboText
if propName=="HairType" then
if r2.hasHelmet then
comboText = r2.itemIndexEquipmentToSelectionText[instance.Equipment][v1][instance[propName]]
else
comboText = r2.noPiece
end
else
comboText = r2.itemIndexEquipmentToSelectionText[instance.Equipment][v1][instance[propName]]
end
end
return
end
end
-- EQUIPMENT
if attributeName == "Equipment" then
r2:updateEquipment(instance, false)
end
-- LINK COLOR
if attributeName == "LinkColor" then
local toggleB = npcUI:find("color_link").toggle_butt
assert(toggleB)
local link = false
if instance.LinkColor==1 then link=true end
toggleB.pushed = not link
end
-- BODY SETS / FACE SETS/ FACE MORPH
local sliderUIPath = body_sliders[attributeName]
if sliderUIPath then
r2:updateBodyAttribute(attributeName, instance[attributeName])
return
end
-- FUNCTION
if attributeName == "Function" then
local functionCB = npcUI:find("fonction").combo_box
assert(functionCB)
functionCB.Env.locked = true
functionCB.selection_text = instance[attributeName]
functionCB.Env.locked = false
return
end
-- SHEET
if attributeName == "Sheet" then
-- update weapons
local weaponsCB = npcUI:find("hands"):find("combo_box")
assert(weaponsCB)
local handsLevel = r2:getHandsLevel(instance.SheetModel, instance.Sheet)
local rightHandIndex = instance.WeaponRightHand
local leftHandIndex = instance.WeaponLeftHand
local handsKey = rightHandIndex..":"..leftHandIndex..":"..handsLevel
local weaponsName = r2.itemIndexEquipmentToSelectionText[instance.Equipment][weaponsCB.Env.nameComboBox][handsKey]
if weaponsName then
weaponsCB.Env.locked = true
weaponsCB.selection_text = weaponsName
weaponsCB.Env.locked = false
end
return
end
-- PROFILE
if attributeName == "Profile" then
local profileCB = npcUI:find("speed_aggro").profile.combo_box
assert(profileCB)
profileCB.Env.locked = true
profileCB.selection_text = r2.profileCB[instance[attributeName]]
profileCB.Env.locked = false
return
end
end
-------------------------------------------------------------------------------------------
function r2:npcCustomPropertySheetDisplayer()
return npcCustomPropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
end
-- share npc displayer between all instances
local npcPropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())
local oldNPCOnAttrModified = npcPropertySheetDisplayerTable.onAttrModified
------------------------------------------------
function npcPropertySheetDisplayerTable:onPostCreate(instance)
end
------------------------------------------------
function npcPropertySheetDisplayerTable:onErase(instance)
end
------------------------------------------------
function npcPropertySheetDisplayerTable:onPreHrcMove(instance)
end
------------------------------------------------
function npcPropertySheetDisplayerTable:onPostHrcMove(instance)
local selectedInstance = r2:getSelectedInstance()
if selectedInstance and selectedInstance==instance then
r2.miniActivities:openEditor()
if r2.activities.isInitialized then
r2.activities.isInitialized = false
r2.activities:initEditorAfterFirstCall()
end
end
instance:updatePermanentStatutIcon()
r2.events:updateElementsUI()
end
------------------------------------------------
function npcPropertySheetDisplayerTable:onFocus(instance, hasFocus)
end
------------------------------------------------
function npcPropertySheetDisplayerTable:onSelect(instance, isSelected)
r2:activeLogicEntityPropertySheetDisplayer():onSelect(instance, isSelected)
r2:initTypeUI(instance)
end
------------------------------------------------
function npcPropertySheetDisplayerTable:onAttrModified(instance, attributeName)
-- if attribute is visible in the generic property sheet, then update it
local propDesc = instance:getPropDesc(attributeName)
if propDesc and propDesc.Visible ~= false then -- NB : "visible" may be nil, which default to 'true'...
-- property visible in the generic property sheet so update it
oldNPCOnAttrModified(self, instance, attributeName)
end
r2:activeLogicEntityPropertySheetDisplayer():onAttrModified(instance, attributeName)
end
-------------------------------------------------------------------------------------------
function r2:npcPropertySheetDisplayer()
return npcPropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
end
------------------ UPDATE NPC EDITOR -------------------------------------------------------
function r2:updateNPCView(instance)
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local char3D = npcUI:find("char3d").char
assert(char3D)
local slotEntity = instance.DisplayerVisual.slotEntity
assert(slotEntity)
if slotEntity > -1 then
char3D:setupCharacter3D(slotEntity)
end
-- disable char LOD interpolation
char3D:enableLOD(false)
end
------------------ BODY --------------------------------------------------------------------
r2.bodyAttNb = 5
r2.bodyAttributes = {[1] = "GabaritHeight", [2] = "GabaritTorsoWidth",
[3] = "GabaritArmsWidth", [4] = "GabaritLegsWidth",
[5] = "GabaritBreastSize"}
r2.bodySliders = {[1] = "slider_height", [2] = "slider_torso",
[3] = "slider_arms", [4] = "slider_legs",
[5] = "slider_breast"}
r2.bodyKeys = {[1] = "GabaritHeight", [2] = "GabaritTorsoWidth",
[3] = "GabaritArmsWidth", [4] = "GabaritLegsWidth",
[5] = "GabaritBreastSize"}
------------------ FACE ---------------------------------------------------------------------
r2.faceAttNb = 4
r2.faceAttributes = {[1] = "HairType", [2] = "HairColor",
[3] = "Tattoo", [4] = "EyesColor"}
r2.faceSliders = {[1] = "slider_haircut", [2] = "slider_hair_color",
[3] = "slider_tattoos", [4] = "slider_eye_color"}
r2.faceKeys = {[1] = "HairType", [2] = "HairColor",
[3] = "Tattoo", [4] = "EyesColor"}
------------------ MORPH --------------------------------------------------------------------
r2.morphAttNb = 8
r2.morphAttributes = {[1] = "MorphTarget1", [2] = "MorphTarget2",
[3] = "MorphTarget3", [4] = "MorphTarget4",
[5] = "MorphTarget5", [6] = "MorphTarget6",
[7] = "MorphTarget7", [8] = "MorphTarget8"}
r2.morphSliders = {[1] = "slider_morph_target1", [2] = "slider_morph_target2",
[3] = "slider_morph_target3", [4] = "slider_morph_target4",
[5] = "slider_morph_target5", [6] = "slider_morph_target6",
[7] = "slider_morph_target7", [8] = "slider_morph_target8"}
r2.morphKeys = {[1] = "MorphTarget1", [2] = "MorphTarget2",
[3] = "MorphTarget3", [4] = "MorphTarget4",
[5] = "MorphTarget5", [6] = "MorphTarget6",
[7] = "MorphTarget7", [8] = "MorphTarget8"}
r2.emptyComboLine = ""
-- INIT NPC EDITOR ---------------------------------------------------------------------------
function r2:initNpcEditor()
local npcUI = getUI("ui:interface:r2ed_npc")
-- equipment color sliders
local levelDesignEnabled = getClientCfgVar("LevelDesignEnabled")
local maxVal = 5
if tonumber(levelDesignEnabled)==1 then maxVal = 7 end
for i=1, r2.equipmentAttNb do
local slider = npcUI:find(r2.equipementComboB[i]):find("slider")
assert(slider)
slider.max = maxVal
end
-- race
local raceCB = npcUI:find("race").combo_box
assert(raceCB)
raceCB:resetTexts()
raceCB:addText(ucstring("Fyros"))
raceCB:addText(ucstring("Matis"))
raceCB:addText(ucstring("Tryker"))
raceCB:addText(ucstring("Zorai"))
-- sex
local sexCB = npcUI:find("sex").combo_box
assert(sexCB)
sexCB:resetTexts()
sexCB:addText(ucstring(r2.female))
sexCB:addText(ucstring(r2.male))
-- Equipment
r2:initEquipmentEnv()
r2:loadTables()
-- body sets
local bodySetsCB = npcUI:find("body_sets").combo_box
assert(bodySetsCB)
local updateBodySetsCB = getUI("ui:interface:r2ed_add_body_sets"):find("update_sets").combo_box
assert(updateBodySetsCB)
bodySetsCB:resetTexts()
updateBodySetsCB:resetTexts()
for k, v in pairs(r2.tableBodySets) do
bodySetsCB:addText(ucstring(k))
updateBodySetsCB:addText(ucstring(k))
end
-- face sets
local faceSetsCB = npcUI:find("face_sets").combo_box
assert(faceSetsCB)
local updateFaceSetsCB = getUI("ui:interface:r2ed_add_face_sets"):find("update_sets").combo_box
assert(updateFaceSetsCB)
faceSetsCB:resetTexts()
updateFaceSetsCB:resetTexts()
for k, v in pairs(r2.tableFaceSets) do
faceSetsCB:addText(ucstring(k))
updateFaceSetsCB:addText(ucstring(k))
end
-- face morph
local faceMorphCB = npcUI:find("face_morph").combo_box
assert(faceMorphCB)
local updateFaceMorphCB = getUI("ui:interface:r2ed_add_face_morph"):find("update_sets").combo_box
assert(updateFaceMorphCB)
faceMorphCB:resetTexts()
updateFaceMorphCB:resetTexts()
for k, v in pairs(r2.tableFaceMorph) do
faceMorphCB:addText(ucstring(k))
updateFaceMorphCB:addText(ucstring(k))
end
bodySetsCB.view_text = r2.emptyComboLine
updateBodySetsCB.view_text = r2.emptyComboLine
faceSetsCB.view_text = r2.emptyComboLine
updateFaceSetsCB.view_text = r2.emptyComboLine
faceMorphCB.view_text = r2.emptyComboLine
updateFaceMorphCB.view_text = r2.emptyComboLine
r2:initItemIndexToSliderValueTable()
end
-- SAVE TABLE ------------------------------------------------------------------------------
function r2:saveTable(fileName, t)
io.output(io.open(fileName,"w"))
r2:serialize(t)
io.close()
end
function r2:serialize(o)
if type(o) == "number" then
io.write(o)
elseif type(o) == "string" then
--io.write(string.format('%q', o))
io.write("["..o.."]")
elseif type(o) == "table" then
io.write("{\n")
for k,v in pairs(o) do
r2:serialize(k)
io.write(" = ")
r2:serialize(v)
io.write("\n")
end
io.write("}")
end
end
-- LOAD TABLE ------------------------------------------------------------------------------
function r2:loadTables()
r2.equipmentSets = r2:loadTable("save\\equipmentSets.txt")
r2.tableBodySets = r2:loadTable("save\\tableBodySets.txt")
r2.tableFaceSets = r2:loadTable("save\\tableFaceSets.txt")
r2.tableFaceMorph = r2:loadTable("save\\tableFaceMorph.txt")
r2:loadRaceSexNames(r2.fyros, r2.male)
r2:loadRaceSexNames(r2.fyros, r2.female)
r2:loadRaceSexNames(r2.matis, r2.male)
r2:loadRaceSexNames(r2.matis, r2.female)
r2:loadRaceSexNames(r2.tryker, r2.male)
r2:loadRaceSexNames(r2.tryker, r2.female)
r2:loadRaceSexNames(r2.zorai, r2.male)
r2:loadRaceSexNames(r2.zorai, r2.female)
end
function r2:loadTable(fileName)
function loadTableR(file)
local resultT = {}
local s, e, l, line, key, value
local line = file:read("*l")
while line ~= "}" do
s, e = string.find(line, " = ")
key = string.sub(line, 1, s-1)
value = string.sub(line, e+1)
-- KEY
-- string key
if string.sub(key, 1, 1) == "[" then
l = string.len(key)
key= string.sub(key, 2, l-1)
-- number key
else
key = tonumber(key)
end
-- VALUE
-- string value
if string.sub(value, 1, 1) == "[" then
l = string.len(value)
value= string.sub(value, 2, l-1)
-- number value
elseif value == "{" then
value = loadTableR(file)
else
value = tonumber(value)
end
resultT[key] = value
line = file:read("*l")
end
return resultT
end
local file = io.open(fileName, "r")
if file == nil then return {} end
if file:read("*l") ~= "{" then
io.close(file)
return {}
end
local resultT = loadTableR(file)
io.close(file)
return resultT
end
function r2:loadRaceSexNamesImpl(race, sex)
local fileName = fileLookup(race.."_" .. sex .. ".txt")
if fileName == "" then return end
local resultT = {}
local count = 1
for line in io.lines(fileName) do
resultT[count] = line
count = count + 1
end
return resultT
end
function r2:loadRaceSexNames(race, sex)
local resultT = r2:loadRaceSexNamesImpl(race, sex)
r2.NPCNames[race .. "_" .. sex] = resultT
end
function r2:loadAllRaceSexNames(race, sex)
local resultT = r2:loadRaceSexNamesImpl(race, sex)
r2.NPCAllNames[race .. "_" .. sex] = resultT
end
function r2:getAllNames()
if (table.getn(r2.NPCAllNames) == 0) then
r2:loadAllRaceSexNames(r2.fyros, r2.male)
r2:loadAllRaceSexNames(r2.fyros, r2.female)
r2:loadAllRaceSexNames(r2.matis, r2.male)
r2:loadAllRaceSexNames(r2.matis, r2.female)
r2:loadAllRaceSexNames(r2.tryker, r2.male)
r2:loadAllRaceSexNames(r2.tryker, r2.female)
r2:loadAllRaceSexNames(r2.zorai, r2.male)
r2:loadAllRaceSexNames(r2.zorai, r2.female)
end
return r2.NPCAllNames
end
-- UPDATE RACE VIEW ---------------------------------------------------------------------------
function r2:updateRaceView()
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local scene3D = npcUI:find("char3d")
assert(scene3D)
-- camera target is out of 3D character
local camera = scene3D.cam
assert(camera)
if r2.raceSelection == r2.zorai then
camera.tgtz = r2.camTgtZZorai
camera.posy = r2.camPosYZorai
r2.distlimitmax = -r2.camPosYZorai
scene3D.distlimitmax = r2.distlimitmax
else
camera.tgtz = r2.camTgtZ
camera.posy = r2.camPosY
r2.distlimitmax = -r2.camPosY
end
end
-- CHANGE VIEW --------------------------------------------------------------------------------
function r2:changeView()
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local scene3D = npcUI:find("char3d")
assert(scene3D)
local camera = scene3D.cam
assert(camera)
if r2.faceView then
scene3D.distlimitmin = r2.distlimitmin
scene3D.distlimitmax = r2.distlimitmax
if r2.raceSelection == r2.zorai then
camera.tgtz = r2.camTgtZZorai
camera.posy = r2.camPosYZorai
else
camera.tgtz = r2.camTgtZ
camera.posy = r2.camPosY
end
r2.faceView = false
else
scene3D.distlimitmin = r2.distlimitminZoom
scene3D.distlimitmax = -r2.camZoomPosY
local char3D = scene3D.char
assert(char3D)
local headZ = char3D.headz
camera.tgtz = headZ + 0.07
camera.posy = r2.camZoomPosY
r2.faceView = true
end
end
-----------------------------------------------------------------------------------------------
-- PROFILE ------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------
-- UPDATE NAME --------------------------------------------------------------------------------
function r2:updateName()
local selection = r2:getSelectedInstance()
if selection == nil then return end
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local editName = npcUI:find("name").edit_box_group
assert(editName)
local newString = editName.uc_input_string:toUtf8()
local oldString = defaulting(selection.Name, "")
if newString ~= oldString then
r2.requestNewAction(i18n.get("uiR2EDUpdateNpcNameAction"))
r2:setNpcAttribute(selection.InstanceId, "Name", newString)
end
return editName.uc_input_string:toUtf8()
end
-- UPDATE NOTES --------------------------------------------------------------------------------
function r2:updateNotes()
local selection = r2:getSelectedInstance()
if selection == nil then return end
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local editNotes = npcUI:find("small_description")
assert(editNotes)
local newString = editNotes.uc_input_string:toUtf8()
local oldString = defaulting(selection.Notes, "")
if newString ~= oldString then
r2.requestNewAction(i18n.get("uiR2EDUpdateNpcNotesAction"))
r2:setNpcAttribute(selection.InstanceId, "Notes", newString)
end
end
-- UPDATE RACE --------------------------------------------------------------------------------
function r2:updateRace(race)
local selection = r2:getSelectedInstance()
if selection == nil then
debugInfo("No selection")
return
end
local name = selection.Name
if not race and not getUICaller().Env.locked then
r2:updateNotes()
name = r2:updateName()
end
r2.requestNewAction(i18n.get("uiR2EDUpdateNpcRaceAction"))
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local sliderValue
if r2.hasHelmet then
sliderValue = r2.hairType.hairCut
else
sliderValue = r2.itemIndexToSliderValue[r2.raceSelection][selection.HairType]
end
local oldRaceSelection = r2.raceSelection
if race==nil then
race = getUICaller().selection_text
end
r2.raceSelection = race
-- requestSetNode
local sheetClientName = r2.raceSheetClient[r2.sexSelection][r2.raceSelection]
if not getUICaller().Env.locked then
r2:setNpcAttribute(selection.InstanceId, "SheetClient", sheetClientName)
-- hairType item index of new race
if not r2.hasHelmet then
local itemIndex = getSheetId(r2.sliderValueToItemIndex[r2.raceSelection][sliderValue])
r2:setNpcAttribute(selection.InstanceId, "HairType", itemIndex)
end
if r2:isRandomizedNPCName(name, oldRaceSelection, r2.sexSelection) then
local name = r2:randomNPCName(r2.raceSelection, r2.sexSelection)
r2:setNpcAttribute(selection.InstanceId, "Name", name)
end
end
r2.requestEndAction()
end
function r2:updateRaceUI()
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
-- no eyes color and morph8 for Zorai
local eyesColor = npcUI:find("slider_eye_color")
assert(eyesColor)
local sliderMorph8 = npcUI:find("slider_morph_target8")
assert(sliderMorph8)
if r2.raceSelection == r2.zorai then
eyesColor.active = false
sliderMorph8.active = false
else
eyesColor.active = true
sliderMorph8.active = true
end
-- update morph sliders labels
for key, value in pairs(r2.morphSliders) do
local sliderMorph = npcUI:find(value)
assert(sliderMorph)
sliderMorph:find("slider_text_place"):find("slider_text").hardtext = r2.raceMorphEditText[r2.raceSelection][key]
end
end
-- UPDATE SEX ---------------------------------------------------------------------------------
function r2:updateSex()
local selection = r2:getSelectedInstance()
if selection == nil then
debugInfo("No selection")
return
end
local name = selection.Name
if not getUICaller().Env.locked then
r2:updateNotes()
name = r2:updateName()
end
r2.requestNewAction(i18n.get("uiR2EDUpdateNpcSexAction"))
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local oldSexSelection = r2.sexSelection
r2.sexSelection = getUICaller().selection_text
-- update sex
local breastGroup = npcUI:find("slider_breast")
assert(breastGroup)
if r2.sexSelection == r2.male then
breastGroup.active = false
else
breastGroup.active = true
end
if not getUICaller().Env.locked then
-- requestSetNode
local sheetClientName = r2.raceSheetClient[r2.sexSelection][r2.raceSelection]
r2:setNpcAttribute(selection.InstanceId, "SheetClient", sheetClientName)
if r2:isRandomizedNPCName(name, r2.raceSelection, oldSexSelection) then
local name = r2:randomNPCName(r2.raceSelection, r2.sexSelection)
r2:setNpcAttribute(selection.InstanceId, "Name", name)
end
end
r2.requestEndAction()
end
-- UPDATE SEX ---------------------------------------------------------------------------------
function r2:updateType()
local selection = r2:getSelectedInstance()
if selection == nil then return end
local oldTypeNPC = selection.TypeNPC
local typeNPC = getUICaller().selection
local base = r2.sheetTypeCB[typeNPC].Id
local typeElement = r2.getPaletteElement(base)
r2.requestNewAction(i18n.get("uiR2EDUpdateNpcTypeAction"))
-- TypeNPC
r2:setNpcAttribute(selection.InstanceId, "TypeNPC", typeNPC)
-- RingAccess
r2:setNpcAttribute(selection.InstanceId, "RingAccess", typeElement.RingAccess)
if selection:isKindOf("NpcCustom") then
-- SheetModel
r2:setNpcAttribute(selection.InstanceId, "SheetModel", typeElement.SheetModel)
-- Sheet
local level = r2:getLevel(selection)+1
local sheet = typeElement.Sheet
local s,e = string.find(sheet, ".creature")
local firstPart = string.sub(sheet, 1, s-2)
local newSheet = firstPart .. level .. ".creature"
r2:setNpcAttribute(selection.InstanceId, "Sheet", newSheet)
-- Base
r2:setNpcAttribute(selection.InstanceId, "Base", base)
-- Type
r2:setNpcAttribute(selection.InstanceId, "Type", typeElement.Type)
-- Equipment
local tableEquipment = r2.equipmentPalette[selection.Equipment]
local newTableEquipment = r2.equipmentPalette[typeElement.Equipment]
local chestNb = r2:getPieceEquipmentNumber(tableEquipment.chest_plate, selection.JacketModel)
local jacketModel = r2:getPieceEquipmentFromNumber(newTableEquipment.chest_plate, chestNb)
local legsNb = r2:getPieceEquipmentNumber(tableEquipment.legs, selection.TrouserModel)
local trouserModel = r2:getPieceEquipmentFromNumber(newTableEquipment.legs, legsNb)
local bootsNb = r2:getPieceEquipmentNumber(tableEquipment.boots, selection.FeetModel)
local feetModel = r2:getPieceEquipmentFromNumber(newTableEquipment.boots, bootsNb)
local glovesNb = r2:getPieceEquipmentNumber(tableEquipment.gloves, selection.HandsModel)
local handsModel = r2:getPieceEquipmentFromNumber(newTableEquipment.gloves, glovesNb)
local armsNb = r2:getPieceEquipmentNumber(tableEquipment.arms_guard, selection.ArmModel)
local armModel = r2:getPieceEquipmentFromNumber(newTableEquipment.arms_guard, armsNb)
local weaponRHNb = r2:getPieceEquipmentNumber(tableEquipment.hands, selection.WeaponRightHand)
local weaponRightHand = r2:getPieceEquipmentFromNumber(newTableEquipment.hands, weaponRHNb, "right")
local weaponLHNb = r2:getPieceEquipmentNumber(tableEquipment.hands, selection.WeaponLeftHand)
local weaponLeftHand = r2:getPieceEquipmentFromNumber(newTableEquipment.hands, weaponLHNb, "left")
local helmetNb = r2:getPieceEquipmentNumber(tableEquipment.helmet, selection.HairType)
r2:setNpcAttribute(selection.InstanceId, "Equipment", typeElement.Equipment)
r2:setNpcAttribute(selection.InstanceId, "JacketModel", jacketModel)
r2:setNpcAttribute(selection.InstanceId, "TrouserModel", trouserModel)
r2:setNpcAttribute(selection.InstanceId, "FeetModel", feetModel)
r2:setNpcAttribute(selection.InstanceId, "HandsModel", handsModel)
r2:setNpcAttribute(selection.InstanceId, "ArmModel", armModel)
r2:setNpcAttribute(selection.InstanceId, "WeaponRightHand", weaponRightHand)
r2:setNpcAttribute(selection.InstanceId, "WeaponLeftHand", weaponLeftHand)
if helmetNb>=0 then
local helmetType = r2:getPieceEquipmentFromNumber(newTableEquipment.helmet, helmetNb)
if helmetType>0 then
r2:setNpcAttribute(selection.InstanceId, "HairType", helmetType)
elseif helmetType==0 then
local itemIndex = getSheetId(r2.sliderValueToItemIndex[r2.raceSelection][0])
r2:setNpcAttribute(selection.InstanceId, "HairType", itemIndex)
--r2:setNpcAttribute(selection.InstanceId, "HairColor", r2.hairType.hairColor)
end
end
else
-- Base
r2:setNpcAttribute(selection.InstanceId, "Base", base)
-- SheetClient
r2:setNpcAttribute(selection.InstanceId, "SheetClient", typeElement.SheetClient)
-- Name
local oldName = i18n.get(r2.sheetTypeCB[oldTypeNPC].Translation):toUtf8()
if selection.Class == "Npc" and string.find(selection.Name, oldName) then
local ucNewName = getUICaller():getText(typeNPC)
local newName = r2:genInstanceName(ucNewName):toUtf8()
r2:setNpcAttribute(selection.InstanceId, "Name", newName)
elseif selection.Name == oldName then
r2:setNpcAttribute(selection.InstanceId, "Name", getUICaller().selection_text)
end
end
r2.requestEndAction()
end
-- UPDATE FUCNTION ----------------------------------------------------------------------------
function r2:updateFunction()
if getUICaller().Env.locked then
return
end
local selection = r2:getSelectedInstance()
assert(selection)
r2.requestNewAction(i18n.get("uiR2EDUpdateNpcFunctionAction"))
r2:setNpcAttribute(selection.InstanceId, "Function", getUICaller().selection_text)
end
-- UPDATE LEVEL ------------------------------------------------------------------------------
r2.updateLevel = function(value)
local selection = r2:getSelectedInstance()
assert(selection)
local level = tonumber(value)+1
local sheet = selection.Sheet
local s,e = string.find(sheet, ".creature")
local firstPart = string.sub(sheet, 1, s-2)
local newSheet = firstPart .. level .. ".creature"
r2.requestNewAction(i18n.get("uiR2EDUpdateNpcLevelAction"))
r2:setNpcAttribute(selection.InstanceId, "Sheet", newSheet)
end
function r2:getHandsLevel(sheetModel, sheet)
local s,e = string.find(sheetModel, "$hands")
local base = string.sub(sheetModel, 1, s-1)
local endSheetModel = string.sub(sheetModel, e+1)
s,e = string.find(endSheetModel, "$level")
local titi = string.sub(endSheetModel, 1, s-1)
s,e = string.find(sheet, base)
local startHands = string.sub(sheet, e+1)
s,e = string.find(startHands, titi)
return string.sub(startHands, 1, s-1)
end
function r2:getLevel(instance)
local sheet = instance.Sheet
local s,e = string.find(sheet, ".creature")
return tonumber(string.sub(sheet, s-1, s-1))-1
end
-----------------------------------------------------------------------------------------------
-- BODY ---------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------
-- UPDATE FACE VIEW ---------------------------------------------------------------------------
function r2:updateFaceView()
if r2.faceView then
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local camera = npcUI:find("char3d").cam
assert(camera)
local char3D = npcUI:find("char3d").char
assert(char3D)
local headZ = char3D.headz
camera.tgtz = headZ + 0.07
camera.posy = r2.camZoomPosY
end
end
-- UPDATE BODY ATTRIBUTE ----------------------------------------------------------------------
function r2:changeBodyAttribute(attributeName, requestType)
local value = getUICaller().value
local sliderValue = nil
if attributeName == "HairType" then
r2.hairType.hairCut = value
sliderValue = getSheetId(r2.sliderValueToItemIndex[r2.raceSelection][value])
elseif attributeName == "HairColor" then
r2.hairType.hairColor = value
end
local selection = r2:getSelectedInstance()
if selection == nil then
debugInfo("No selection")
return
end
r2.requestNewAction(i18n.get("uiR2EDChangeNpcBodyAttributeAction"))
if sliderValue == nil then
sliderValue = value
end
if requestType == 'local' then
r2.requestSetLocalNode(selection.InstanceId, attributeName, sliderValue)
elseif requestType == 'commit' then
r2.requestCommitLocalNode(selection.InstanceId, attributeName)
elseif requestType == 'cancel' then
r2.requestRollbackLocalNode(selection.InstanceId, attributeName)
end
r2.requestEndAction()
end
-- UPDATE BODY ATTRIBUTE FROM ON ATTRIBUTE MODIFIED -----------------------------------------------
function r2:updateBodyAttribute(attributeName, value)
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
if attributeName == "HairType" then
value = r2.itemIndexToSliderValue[r2.raceSelection][value]
end
local slider = npcUI:find(body_sliders[attributeName]):find("slider")
assert(slider)
slider.value = value
if attributeName == "GabaritHeight" then r2:updateFaceView() end
if not r2:matchWithBodyAttributesSet(attributeName, value) then
local comboBox = npcUI:find(r2.bodyAttributesCB[attributeName].comboBox).combo_box
assert(comboBox)
comboBox.view_text = r2.emptyComboLine
local updateComboBox = "ui:interface:"..r2.bodyAttributesCB[attributeName].updateComboBox
local updateCB = getUI(updateComboBox):find("update_sets").combo_box
assert(updateCB)
updateCB.view_text = r2.emptyComboLine
end
end
function r2:matchWithBodyAttributesSet(attributeName, value)
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local comboBox = npcUI:find(r2.bodyAttributesCB[attributeName].comboBox).combo_box
assert(comboBox)
local tableSets = r2[r2.bodyAttributesCB[attributeName].tableSets]
if tableSets == nil then return false end
local setValues = tableSets[tostring(comboBox.selection_text)]
if setValues == nil then return false end
return (setValues[attributeName] == value)
end
-- RANDOM BODY ------------------------------------------------------------------------------
function r2:randomBody()
local selection = r2:getSelectedInstance()
if selection == nil then
debugInfo("No selection")
return
end
r2.requestNewAction(i18n.get("uiR2EDRandomNpcBodyAction"))
local randomValue
for i = 1,r2.bodyAttNb do
randomValue = math.random(0,14)
r2:setNpcAttribute(selection.InstanceId, r2.bodyAttributes[i], randomValue)
end
r2.requestEndAction()
end
-- RANDOM BODY SETS ---------------------------------------------------------------------------
function r2:randomSets(sets)
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local setsCombo = getUI("ui:interface:r2ed_npc"):find(sets).combo_box
assert(setsCombo)
if setsCombo.selectionNb > 0 then
local randomSelection = math.random(1, setsCombo.selectionNb)
if setsCombo.selectionNb > 1 then
while randomSelection == (setsCombo.selection+1) do
randomSelection = math.random(1, setsCombo.selectionNb)
end
end
setsCombo.selection = randomSelection-1
end
end
-- ADD BODY SETS -----------------------------------------------------------------------------
function r2:addBodySets()
local addBodySets = getUI("ui:interface:r2ed_add_body_sets")
assert(addBodySets)
local editText = addBodySets:find("new_sets").edit_box_group
assert(editText)
if editText.input_string~="" then
local updateBodySetsCombo = addBodySets:find("update_sets").combo_box
assert(updateBodySetsCombo)
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local bodySetsCombo = npcUI:find("body_sets").combo_box
assert(bodySetsCombo)
bodySetsCombo:addText(editText.uc_input_string)
updateBodySetsCombo:addText(editText.uc_input_string)
-- add new sets in table
local bodySets = npcUI:find("body_sets_scroll_target")
assert(bodySets)
r2.tableBodySets[editText.input_string] = {}
local sliderValue
for i = 1,r2.bodyAttNb do
sliderValue = bodySets:find(r2.bodySliders[i]):find("slider").value
r2.tableBodySets[editText.input_string][r2.bodyKeys[i]] = sliderValue
end
r2:saveTable("save\\tableBodySets.txt", r2.tableBodySets)
-- update set of main window combo box
bodySetsCombo.selection_text = editText.input_string
updateBodySetsCombo.selection_text = editText.input_string
editText.input_string = ""
end
end
-- UPDATE BODY SETS --------------------------------------------------------------------------
function r2:updateBodySets()
local updateBodySetsCombo = getUI("ui:interface:r2ed_add_body_sets"):find("update_sets").combo_box
assert(updateBodySetsCombo)
local bodySetsName = updateBodySetsCombo.selection_text
-- update sets in table
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local bodySets = npcUI:find("body_sets_scroll_target")
assert(bodySets)
local sliderValue
for i = 1,r2.bodyAttNb do
sliderValue = bodySets:find(r2.bodySliders[i]):find("slider").value
r2.tableBodySets[bodySetsName][r2.bodyKeys[i]] = sliderValue
end
r2:saveTable("save\\tableBodySets.txt", r2.tableBodySets)
-- update set of main window combo box
local bodySetsCombo = npcUI:find("body_sets").combo_box
assert(bodySetsCombo)
bodySetsCombo.selection_text = bodySetsName
end
-- REMOVE BODY SETS ---------------------------------------------------------------------------
function r2:removeBodySets()
local updateBodySetsCombo = getUI("ui:interface:r2ed_add_body_sets"):find("update_sets").combo_box
assert(updateBodySetsCombo)
local bodySetsName = updateBodySetsCombo.selection_text
-- delete sets in table
r2.tableBodySets[bodySetsName] = nil
r2:saveTable("save\\tableBodySets.txt", r2.tableBodySets)
-- delete sets in combo box
updateBodySetsCombo:removeSelection(updateBodySetsCombo.selection)
updateBodySetsCombo.view_text = r2.emptyComboLine
local bodySetsCombo = getUI("ui:interface:r2ed_npc"):find("body_sets").combo_box
assert(bodySetsCombo)
bodySetsCombo:removeText(bodySetsName)
bodySetsCombo.view_text = r2.emptyComboLine
end
-- SELECT BODY SETS ---------------------------------------------------------------------------
function r2:selectBodySets()
local bodySetsCombo = getUI("ui:interface:r2ed_npc"):find("body_sets").combo_box
assert(bodySetsCombo)
local selection = r2:getSelectedInstance()
if bodySetsCombo.view_text == r2.emptyComboLine then
return
else
r2.requestNewAction(i18n.get("uiR2EDSelectNpcBodySetsAction"))
local bodySetsValue = r2.tableBodySets[bodySetsCombo.selection_text]
if bodySetsValue == nil then return end
-- update sliders values
for i = 1,r2.bodyAttNb do
r2:setNpcAttribute(selection.InstanceId, r2.bodyAttributes[i], bodySetsValue[r2.bodyKeys[i]])
end
r2.requestEndAction()
end
local bodySetsPopup = getUI("ui:interface:r2ed_add_body_sets"):find("update_sets").combo_box
assert(bodySetsPopup)
bodySetsPopup.selection_text = bodySetsCombo.selection_text
end
----------------------------------------------------------------------------------------------
-- RANDOM FACE ------------------------------------------------------------------------------
function r2:randomFace()
local selection = r2:getSelectedInstance()
if selection == nil then
debugInfo("No selection")
return
end
r2.requestNewAction(i18n.get("uiR2EDRandomNpcFaceAction"))
local randomValue
for i = 1,r2.faceAttNb do
if r2.faceAttributes[i] == "HairColor" then
randomValue = math.random(0,5)
elseif r2.faceAttributes[i] == "Tattoo" then
randomValue = math.random(0,31)
elseif r2.faceAttributes[i] == "HairType" then
randomValue = math.random(0,6)
else
randomValue = math.random(0,7)
end
if r2.faceAttributes[i] == "HairType" then
if not r2.hasHelmet then
local itemIndex = getSheetId(r2.sliderValueToItemIndex[r2.raceSelection][randomValue])
r2:setNpcAttribute(selection.InstanceId, r2.faceAttributes[i], itemIndex)
end
elseif not (r2.faceAttributes[i] == "HairColor" and r2.hasHelmet) then
r2:setNpcAttribute(selection.InstanceId, r2.faceAttributes[i], randomValue)
end
end
r2.requestEndAction()
end
-- ADD FACE SETS -----------------------------------------------------------------------------
function r2:addFaceSets()
local addFaceSets = getUI("ui:interface:r2ed_add_face_sets")
assert(addFaceSets)
local editText = addFaceSets:find("new_sets").edit_box_group
assert(editText)
if editText.input_string~="" then
local updateFaceSetsCombo = addFaceSets:find("update_sets").combo_box
assert(updateFaceSetsCombo)
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local faceSetsCombo = npcUI:find("face_sets").combo_box
assert(faceSetsCombo)
faceSetsCombo:addText(editText.uc_input_string)
updateFaceSetsCombo:addText(editText.uc_input_string)
-- add new sets in table
local faceSets = npcUI:find("face_sets_scroll_target")
assert(faceSets)
r2.tableFaceSets[editText.input_string] = {}
local sliderValue
for i = 1,r2.faceAttNb do
sliderValue = faceSets:find(r2.faceSliders[i]):find("slider").value
r2.tableFaceSets[editText.input_string][r2.faceKeys[i] ] = sliderValue
end
r2:saveTable("save\\tableFaceSets.txt", r2.tableFaceSets)
-- update set of main window combo box
faceSetsCombo.selection_text = editText.input_string
updateFaceSetsCombo.selection_text = editText.input_string
editText.input_string = ""
end
end
-- UPDATE FACE SETS --------------------------------------------------------------------------
function r2:updateFaceSets()
local updateFaceSetsCombo = getUI("ui:interface:r2ed_add_face_sets"):find("update_sets").combo_box
assert(updateFaceSetsCombo)
local faceSetsName = updateFaceSetsCombo.selection_text
-- update sets in table
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local faceSets = npcUI:find("face_sets_scroll_target")
assert(faceSets)
local sliderValue
for i = 1,r2.faceAttNb do
sliderValue = faceSets:find(r2.faceSliders[i]):find("slider").value
r2.tableFaceSets[faceSetsName][r2.faceKeys[i] ] = sliderValue
end
r2:saveTable("save\\tableFaceSets.txt", r2.tableFaceSets)
-- update set of main window combo box
local faceSetsCombo = npcUI:find("face_sets").combo_box
assert(faceSetsCombo)
faceSetsCombo.selection_text = faceSetsName
end
-- REMOVE FACE SETS ---------------------------------------------------------------------------
function r2:removeFaceSets()
local updateFaceSetsCombo = getUI("ui:interface:r2ed_add_face_sets"):find("update_sets").combo_box
assert(updateFaceSetsCombo)
local faceSetsName = updateFaceSetsCombo.selection_text
-- delete sets in table
r2.tableFaceSets[faceSetsName] = nil
r2:saveTable("save\\tableFaceSets.txt", r2.tableFaceSets)
-- delete sets in combo box
updateFaceSetsCombo:removeSelection(updateFaceSetsCombo.selection)
local faceSetsCombo = getUI("ui:interface:r2ed_npc"):find("face_sets").combo_box
assert(faceSetsCombo)
faceSetsCombo:removeText(faceSetsName)
faceSetsCombo.view_text = r2.emptyComboLine
end
-- SELECT FACE SETS ---------------------------------------------------------------------------
function r2:selectFaceSets()
local faceSetsCombo = getUI("ui:interface:r2ed_npc"):find("face_sets").combo_box
assert(faceSetsCombo)
local selection = r2:getSelectedInstance()
if faceSetsCombo.view_text == r2.emptyComboLine then
return
else
r2.requestNewAction(i18n.get("uiR2EDSelectNpcFaceSetsAction"))
local faceSetsValue = r2.tableFaceSets[faceSetsCombo.selection_text]
if faceSetsValue == nil then return end
-- update sliders values
for i = 1,r2.faceAttNb do
local requestSetNode = true
local requestValue = faceSetsValue[r2.faceKeys[i] ]
if r2.faceAttributes[i] == "HairType" then
if not r2.hasHelmet then
requestValue = getSheetId(r2.sliderValueToItemIndex[r2.raceSelection][faceSetsValue[r2.faceKeys[i]]])
else
r2.hairType.hairCut = faceSetsValue[r2.faceKeys[i] ]
requestSetNode = false
end
elseif r2.faceAttributes[i] == "HairColor" and r2.hasHelmet then
r2.hairType.hairColor = faceSetsValue[r2.faceKeys[i] ]
requestSetNode = false
end
if requestSetNode then
r2:setNpcAttribute(selection.InstanceId, r2.faceAttributes[i], requestValue)
end
end
r2.requestEndAction()
end
local faceSetsPopup = getUI("ui:interface:r2ed_add_face_sets"):find("update_sets").combo_box
assert(faceSetsPopup)
faceSetsPopup.selection_text = faceSetsCombo.selection_text
end
----------------------------------------------------------------------------------------------
-- RANDOM FACE MORPH -------------------------------------------------------------------------
function r2:randomFaceMorph()
local selection = r2:getSelectedInstance()
if selection == nil then
debugInfo("No selection")
return
end
r2.requestNewAction(i18n.get("uiR2EDRandomNPCFaceMorphAction"))
local randomValue
for i = 1,r2.morphAttNb do
randomValue = math.random(0,7)
r2:setNpcAttribute(selection.InstanceId, r2.morphAttributes[i], randomValue)
end
r2.requestEndAction()
end
-- ADD FACE MORPH ---------------------------------------------------------------------------
function r2:addFaceMorph()
local addFaceMorph = getUI("ui:interface:r2ed_add_face_morph")
assert(addFaceMorph)
local editText = addFaceMorph:find("new_sets").edit_box_group
assert(editText)
if editText.input_string~="" then
local updateFaceMorphCombo = addFaceMorph:find("update_sets").combo_box
assert(updateFaceMorphCombo)
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local faceMorphCombo = npcUI:find("face_morph").combo_box
assert(faceMorphCombo)
faceMorphCombo:addText(editText.uc_input_string)
updateFaceMorphCombo:addText(editText.uc_input_string)
-- add new sets in table
local faceMorph = npcUI:find("face_morph_scroll_target")
assert(faceMorph)
r2.tableFaceMorph[editText.input_string] = {}
local sliderValue
for i = 1,r2.morphAttNb do
sliderValue = faceMorph:find(r2.morphSliders[i]):find("slider").value
r2.tableFaceMorph[editText.input_string][r2.morphKeys[i] ] = sliderValue
end
r2:saveTable("save\\tableFaceMorph.txt", r2.tableFaceMorph)
-- update set of main window combo box
faceMorphCombo.selection_text = editText.input_string
updateFaceMorphCombo.selection_text = editText.input_string
editText.input_string = ""
end
end
-- UPDATE FACE MORPH ------------------------------------------------------------------------
function r2:updateFaceMorph()
local updateFaceMorphCombo = getUI("ui:interface:r2ed_add_face_morph"):find("update_sets").combo_box
assert(updateFaceMorphCombo)
local faceMorphName = updateFaceMorphCombo.selection_text
-- update sets in table
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local faceMorph = npcUI:find("face_morph_scroll_target")
assert(faceMorph)
local sliderValue
for i = 1,r2.morphAttNb do
sliderValue = faceMorph:find(r2.morphSliders[i]):find("slider").value
r2.tableFaceMorph[faceMorphName][r2.morphKeys[i] ] = sliderValue
end
r2:saveTable("save\\tableFaceMorph.txt", r2.tableFaceMorph)
-- update set of main window combo box
local faceMorphCombo = npcUI:find("face_morph").combo_box
assert(faceMorphCombo)
faceMorphCombo.selection_text = faceMorphName
end
-- REMOVE FACE MORPH ---------------------------------------------------------------------------
function r2:removeFaceMorph()
local updateFaceMorphCombo = getUI("ui:interface:r2ed_add_face_morph"):find("update_sets").combo_box
assert(updateFaceMorphCombo)
local faceMorphName = updateFaceMorphCombo.selection_text
-- delete sets in table
r2.tableFaceMorph[faceMorphName] = nil
r2:saveTable("save\\tableFaceMorph.txt", r2.tableFaceMorph)
-- delete sets in combo box
updateFaceMorphCombo:removeSelection(updateFaceMorphCombo.selection)
updateFaceMorphCombo.view_text = r2.emptyComboLine
local faceMorphCombo = getUI("ui:interface:r2ed_npc"):find("face_morph").combo_box
assert(faceMorphCombo)
faceMorphCombo:removeText(faceMorphName)
faceMorphCombo.view_text = r2.emptyComboLine
end
-- SELECT FACE MORPH ---------------------------------------------------------------------------
function r2:selectMorphSets()
local faceMorphCombo = getUI("ui:interface:r2ed_npc"):find("face_morph").combo_box
assert(faceMorphCombo)
local selection = r2:getSelectedInstance()
if faceMorphCombo.view_text == r2.emptyComboLine then
return
else
r2.requestNewAction(i18n.get("uiR2EDSelectNPCMorphSetsAction"))
local faceMorphValue = r2.tableFaceMorph[faceMorphCombo.selection_text]
if faceMorphValue == nil then return end
-- update sliders values
for i = 1,r2.morphAttNb do
r2:setNpcAttribute(selection.InstanceId, r2.morphAttributes[i], faceMorphValue[r2.morphKeys[i]])
end
r2.requestEndAction()
end
local faceMorphPopup = getUI("ui:interface:r2ed_add_face_morph"):find("update_sets").combo_box
assert(faceMorphPopup)
faceMorphPopup.selection_text = faceMorphCombo.selection_text
end
-- CLOSE MODAL SETS WINDOW ----------------------------------------------------------------------
function r2:closeModalBodySets()
r2:closeModal("ui:interface:r2ed_add_body_sets")
end
function r2:closeModalFaceSets()
r2:closeModal("ui:interface:r2ed_add_face_sets")
end
function r2:closeModalFaceMorph()
r2:closeModal("ui:interface:r2ed_add_face_morph")
end
function r2:closeModal(window)
local modalWindow = getUI(window)
assert(modalWindow)
local editText = modalWindow:find("new_sets").edit_box_group
assert(editText)
editText.input_string = ""
modalWindow.active = false
end
-----------------------------------------------------------------------------------------------
-- GROUP --------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------
r2.profile = {Civil="normal", Bandit="bandit", Guard = "guard"}
r2.profileCB = {normal="Civil", bandit="Bandit", guard="Guard"}
-- UPDATE PROFILE -----------------------------------------------------------------------------
function r2:updateProfile()
if getUICaller().Env.locked then
return
end
local selection = r2:getSelectedInstance()
assert(selection)
r2.requestNewAction(i18n.get("uiR2EDUpdateNPCProfileAction"))
r2:setNpcAttribute(selection.InstanceId, "Profile", r2.profile[getUICaller().selection_text])
end
-----------------------------------------------------------------------------------------------
-- EQUIPMENT ----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------
r2.equipmentPalette = {}
r2.itemIndexEquipmentToSelectionText = {}
r2.equipmentEnv = {}
r2.noPiece = i18n.get("uiR2EdNoPiece"):toUtf8()
r2.equipmentAttNb = 6
r2.colorAttributes = {[1] = "JacketColor", [2] = "TrouserColor",
[3] = "FeetColor", [4] = "HandsColor",
[5] = "ArmColor"}
r2.equipementComboB = {[1] = "chest_plate", [2] = "legs",
[3] = "boots", [4] = "gloves",
[5] = "arms_guard", [6] = "helmet",
}
r2.equipmentKeys = r2.equipementComboB
r2.equipmentSets = {}
r2.linkColorB = false
r2.linkedColor = 0
function r2:initEquipmentEnv()
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local nameComboBox = "helmet"
local comboBox = npcUI:find(nameComboBox).label_combo_box.combo_box
local slider = npcUI:find(nameComboBox):find("slider")
comboBox.Env.nameComboBox = nameComboBox
slider.name = nameComboBox
r2.equipmentEnv[nameComboBox] = {propName = "HairType", propColorName = "HairColor"}
nameComboBox = "chest_plate"
comboBox = npcUI:find(nameComboBox).label_combo_box.combo_box
slider = npcUI:find(nameComboBox):find("slider")
comboBox.Env.nameComboBox = nameComboBox
slider.name = nameComboBox
r2.equipmentEnv[nameComboBox] = {propName = "JacketModel", propColorName = "JacketColor"}
nameComboBox = "legs"
comboBox = npcUI:find(nameComboBox).label_combo_box.combo_box
slider = npcUI:find(nameComboBox):find("slider")
comboBox.Env.nameComboBox = nameComboBox
slider.name = nameComboBox
r2.equipmentEnv[nameComboBox] = {propName = "TrouserModel", propColorName = "TrouserColor"}
nameComboBox = "boots"
comboBox = npcUI:find(nameComboBox).label_combo_box.combo_box
slider = npcUI:find(nameComboBox):find("slider")
comboBox.Env.nameComboBox = nameComboBox
slider.name = nameComboBox
r2.equipmentEnv[nameComboBox] = {propName = "FeetModel", propColorName = "FeetColor"}
nameComboBox = "gloves"
comboBox = npcUI:find(nameComboBox).label_combo_box.combo_box
slider = npcUI:find(nameComboBox):find("slider")
comboBox.Env.nameComboBox = nameComboBox
slider.name = nameComboBox
r2.equipmentEnv[nameComboBox] = {propName = "HandsModel", propColorName = "HandsColor"}
nameComboBox = "arms_guard"
comboBox = npcUI:find(nameComboBox).label_combo_box.combo_box
slider = npcUI:find(nameComboBox):find("slider")
comboBox.Env.nameComboBox = nameComboBox
slider.name= nameComboBox
r2.equipmentEnv[nameComboBox] = {propName = "ArmModel", propColorName = "ArmColor"}
nameComboBox = "hands"
comboBox = npcUI:find(nameComboBox).combo_box
comboBox.Env.nameComboBox = nameComboBox
for equId, equTable in pairs(r2.equipmentPalette) do
r2.itemIndexEquipmentToSelectionText[equId] = {}
for comboName, comboList in pairs(equTable) do
r2.itemIndexEquipmentToSelectionText[equId][comboName] = {}
if tostring(comboName) ~= "hands" then
for k, v in pairs(comboList) do
local itemIndex = getSheetId(v.itemFile)
r2.itemIndexEquipmentToSelectionText[equId][comboName][itemIndex] = v.trad
end
else
for k, v in pairs(comboList) do
local rightHandIndex = getSheetId(v.rightHand)
local leftHandIndex = getSheetId(v.leftHand)
local handsLevel = v.handsLevel
local handsKey = rightHandIndex..":"..leftHandIndex..":"..handsLevel
r2.itemIndexEquipmentToSelectionText[equId][comboName][handsKey] = v.trad
end
end
r2.itemIndexEquipmentToSelectionText[equId][comboName][0] = r2.noPiece
end
end
end
-----------------------------------------------------------------------------------------------
function r2.addR2PlayerEquipment(paletteElt, equipmentTable)
local tempTable = {}
for equType, v in pairs(equipmentTable) do
tempTable[equType] = {}
for equName, equFile in pairs(v) do
local tradEquName = i18n.get(equName):toUtf8()
if tostring(equType) ~= "hands" then
if equName == "uiR2EDequipment_none" then
table.insert(tempTable[equType], 1, {["trad"]=tradEquName, ["itemFile"]=equFile})
else
table.insert(tempTable[equType], {["trad"]=tradEquName, ["itemFile"]=equFile})
end
else
local s, e = string.find(equFile, ":")
if s==nil or e==nil then
debugInfo("Palette problem with equipment : "..paletteElt.Equipment)
end
local rightHand = string.sub(equFile, 1, e-1)
equFile = string.sub(equFile, e+1)
s, e = string.find(equFile, ":")
if s==nil or e==nil then
debugInfo("Palette probleme with equipment : "..paletteElt.Equipment)
end
local leftHand = string.sub(equFile, 1, e-1)
equFile = string.sub(equFile, e+1)
local handsLevel = equFile
table.insert(tempTable[equType], {
["trad"]=tradEquName,
["rightHand"]=rightHand,
["leftHand"]=leftHand,
["handsLevel"]=handsLevel
})
end
end
end
r2.equipmentPalette[paletteElt.Equipment] = tempTable
end
-----------------------------------------------------------------------------------------------
function r2:updateEquipment(instance, init)
local equipmentId = instance.Equipment
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local comboBox
-- update current equipment
if r2.equipmentPalette[equipmentId] then
for k, v in pairs(r2.equipmentPalette[equipmentId]) do
comboBox = npcUI:find(k):find("combo_box")
assert(comboBox)
comboBox:resetTexts()
for k1, v1 in pairs(v) do
comboBox:addText(ucstring(v1.trad))
end
end
if init then r2.hasHelmet = false end
end
-- update equipment sets
comboBox = npcUI:find("equipment_sets").combo_box
assert(comboBox)
local comboBoxPopup = getUI("ui:interface:r2ed_add_equipment_set"):find("update_sets").combo_box
assert(comboBoxPopup)
comboBox:resetTexts()
comboBoxPopup:resetTexts()
if r2.equipmentSets[equipmentId] then
for k1, v1 in pairs(r2.equipmentSets[equipmentId]) do
comboBox:addText(ucstring(k1))
comboBoxPopup:addText(ucstring(k1))
end
end
comboBox.view_text = r2.emptyComboLine
comboBoxPopup.view_text = r2.emptyComboLine
local toggleB = npcUI:find("color_link").toggle_butt
assert(toggleB)
toggleB.pushed = true
r2:linkColor()
-- update selection texts
local comboBox, slider
local helmetB = true
for k, v in pairs(r2.equipmentEnv) do
comboBox = npcUI:find(k):find("combo_box")
assert(comboBox)
slider = npcUI:find(k):find("slider")
local line = npcUI:find(k):find("line_slider")
local CBText = r2.itemIndexEquipmentToSelectionText[instance.Equipment][comboBox.Env.nameComboBox][instance[v.propName] ]
if CBText==nil then CBText=r2.noPiece end
comboBox.Env.locked = true
comboBox.selection_text = CBText
comboBox.Env.locked = false
line.active = (CBText~=r2.noPiece)
slider.active = (CBText~=r2.noPiece)
if slider.active then
slider.value = instance[v.propColorName]
end
if v.propName == "HairType" then
slider = npcUI:find("slider_haircut")
assert(slider)
slider.active = (CBText == r2.noPiece)
if slider.active then
local value = r2.itemIndexToSliderValue[r2.raceSelection][instance.HairType]
if value then
slider:find("slider").value = value
end
end
slider = npcUI:find("slider_hair_color")
assert(slider)
slider.active = (CBText == r2.noPiece)
if slider.active then
slider:find("slider").value = instance.HairColor
end
end
end
end
-----------------------------------------------------------------------------------------------
function r2:updatePieceEquipment()
if not r2.selectEquipmentSet then
r2.requestNewAction(i18n.get("uiR2EDUpdateEquipmentPieceAction"))
end
local selection = r2:getSelectedInstance()
if selection == nil then
debugInfo("No selection")
return
end
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local equipmentType = getUICaller().selection_text
local nameComboBox = getUICaller().Env.nameComboBox
local itemIndex
if equipmentType == r2.noPiece then
if r2.equipmentEnv[nameComboBox].propName == "HairType" then
local sliderHair = npcUI:find("slider_haircut")
assert(sliderHair)
local sliderHairColor = npcUI:find("slider_hair_color")
assert(sliderHairColor)
if not getUICaller().Env.locked and r2.hasHelmet then
itemIndex = getSheetId(r2.sliderValueToItemIndex[r2.raceSelection][r2.hairType.hairCut])
r2:setNpcAttribute(selection.InstanceId, r2.equipmentEnv[nameComboBox].propName, itemIndex)
r2:setNpcAttribute(selection.InstanceId, r2.equipmentEnv[nameComboBox].propColorName, r2.hairType.hairColor)
end
else
if not getUICaller().Env.locked then
r2:setNpcAttribute(selection.InstanceId, r2.equipmentEnv[nameComboBox].propName, 0)
end
end
else
if r2.equipmentEnv[nameComboBox].propName == "HairType" then
local sliderHair = npcUI:find("slider_haircut")
assert(sliderHair)
local sliderHairColor = npcUI:find("slider_hair_color")
assert(sliderHairColor)
end
local itemFile = ""
for k, v in pairs(r2.equipmentPalette[selection.Equipment][nameComboBox]) do
if v.trad == equipmentType then itemFile = v.itemFile break end
end
itemIndex = getSheetId(itemFile)
if not getUICaller().Env.locked then
r2:setNpcAttribute(selection.InstanceId, r2.equipmentEnv[nameComboBox].propName, itemIndex)
end
if r2.linkColorB then
r2:updateColor(npcUI:find(nameComboBox):find("slider"))
end
end
if not r2.saveEquipmentSet and not r2:matchWithEquipmentSet(nameComboBox, equipmentType) then
local updateEquSetCombo = getUI("ui:interface:r2ed_add_equipment_set"):find("update_sets").combo_box
assert(updateEquSetCombo)
updateEquSetCombo.view_text = r2.emptyComboLine
local equSetCombo = npcUI:find("equipment_sets").combo_box
assert(equSetCombo)
equSetCombo.view_text = r2.emptyComboLine
end
end
function r2:matchWithEquipmentSet(nameComboBox, equipmentType)
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local equSetCombo = npcUI:find("equipment_sets").combo_box
assert(equSetCombo)
local setName = equSetCombo.selection_text
if setName==r2.emptyComboLine then return false end
local selection = r2:getSelectedInstance()
if r2.equipmentSets[selection.Equipment] == nil then return false end
local equSetsValue = r2.equipmentSets[selection.Equipment][setName]
if equSetsValue == nil then return false end
return (equSetsValue[nameComboBox].comboSelection == equipmentType)
end
function r2:updateWeapons()
local selection = r2:getSelectedInstance()
local hands = getUICaller()
if hands.Env.locked == true then return end
r2.requestNewAction(i18n.get("uiR2EDUpdateNPCWeaponsAction"))
local equipmentType = hands.selection_text
local handsTable
for k, v in pairs(r2.equipmentPalette[selection.Equipment][hands.Env.nameComboBox]) do
if v.trad == equipmentType then handsTable = v break end
end
assert(handsTable)
local rightHandFile = handsTable.rightHand
local rightHandIndex = getSheetId(rightHandFile)
local leftHandFile = handsTable.leftHand
local leftHandIndex = getSheetId(leftHandFile)
local handsLevel = handsTable.handsLevel
local sheet = selection.Sheet
local s, e = string.find(sheet, ".creature")
local level = string.sub(sheet, s-1, s-1)
local newSheet = selection.SheetModel
newSheet = string.gsub(newSheet, "$hands", handsLevel)
newSheet = string.gsub(newSheet, "$level", level)
r2:setNpcAttribute(selection.InstanceId, "WeaponRightHand", rightHandIndex)
r2:setNpcAttribute(selection.InstanceId, "WeaponLeftHand", leftHandIndex)
r2:setNpcAttribute(selection.InstanceId, "Sheet", newSheet)
r2.requestEndAction()
end
-----------------------------------------------------------------------------------------------
function r2:closeModalEquipment()
r2:closeModal("ui:interface:r2ed_add_equipment_set")
end
-----------------------------------------------------------------------------------------------
function r2:addEquipmentSet()
local selection = r2:getSelectedInstance()
assert(selection)
local addEquSet = getUI("ui:interface:r2ed_add_equipment_set")
assert(addEquSet)
local editText = addEquSet:find("new_sets").edit_box_group
assert(editText)
if editText.input_string~="" then
local updateEquSetCombo = addEquSet:find("update_sets").combo_box
assert(updateEquSetCombo)
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local equSetCombo = npcUI:find("equipment_sets").combo_box
assert(equSetCombo)
updateEquSetCombo:addText(editText.uc_input_string)
equSetCombo:addText(editText.uc_input_string)
if r2.equipmentSets[selection.Equipment] == nil then
r2.equipmentSets[selection.Equipment] = {}
end
r2.equipmentSets[selection.Equipment][editText.input_string] = {}
for i=1, r2.equipmentAttNb do
local comboBox = npcUI:find(r2.equipementComboB[i]):find("combo_box")
local slider = npcUI:find(r2.equipementComboB[i]):find("slider")
r2.equipmentSets[selection.Equipment][editText.input_string][r2.equipmentKeys[i] ] = {
comboSelection = comboBox.selection_text, color = slider.value}
end
r2:saveTable("save\\equipmentSets.txt", r2.equipmentSets)
equSetCombo.selection_text = editText.input_string
editText.input_string=""
end
end
-- SELECT EQUIPMENT SETS ---------------------------------------------------------------------------
r2.saveEquipmentSet = false
function r2:selectEquipmentSets()
r2.selectEquipmentSet = true
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local equSetCombo = npcUI:find("equipment_sets").combo_box
assert(equSetCombo)
local selection = r2:getSelectedInstance()
if equSetCombo.view_text == r2.emptyComboLine then
return
else
if r2.equipmentSets[selection.Equipment] == nil then return end
local equSetsValue = r2.equipmentSets[selection.Equipment][equSetCombo.selection_text]
if equSetsValue == nil then return end
r2.requestNewAction(i18n.get("uiR2EDSelectNPCEquipmentSetsAction"))
r2.saveEquipmentSet = true
-- update comboBoxes and sliders values
for i = 1,r2.equipmentAttNb do
local comboItemText = equSetsValue[r2.equipementComboB[i]].comboSelection
local colorPiece = equSetsValue[r2.equipementComboB[i]].color
local comboBox = npcUI:find(r2.equipementComboB[i]).label_combo_box.combo_box
assert(comboBox)
if comboItemText == r2.noPiece then
local propName = r2.equipmentEnv[r2.equipementComboB[i]].propName
if not (propName == "HairType" and not r2.hasHelmet) then
comboBox.selection_text = r2.noPiece
if r2.equipmentEnv[r2.equipementComboB[i] ].propColorName ~= "HairColor" then
r2:setNpcAttribute(selection.InstanceId, r2.equipmentEnv[r2.equipementComboB[i]].propColorName, 0)
npcUI:find(r2.equipementComboB[i]):find("slider").value = 0
end
end
else
comboBox.selection_text = equSetsValue[r2.equipmentKeys[i]].comboSelection
r2:setNpcAttribute(selection.InstanceId, r2.equipmentEnv[r2.equipementComboB[i]].propColorName, colorPiece)
npcUI:find(r2.equipementComboB[i]):find("slider").value = colorPiece
end
end
local updateEquSetsCombo = getUI("ui:interface:r2ed_add_equipment_set"):find("update_sets").combo_box
assert(updateEquSetsCombo)
updateEquSetsCombo.selection_text = equSetCombo.selection_text
r2.saveEquipmentSet = false
r2.requestEndAction(i18n.get("uiR2EDSelectNPCEquipmentSetsAction"))
end
r2.selectEquipmentSet = false
end
-----------------------------------------------------------------------------------------------
function r2:updateEquipmentSet()
if r2.saveEquipmentSet then return end
local selection = r2:getSelectedInstance()
local updateEquSetsCombo = getUI("ui:interface:r2ed_add_equipment_set"):find("update_sets").combo_box
assert(updateEquSetsCombo)
local equSetsName = updateEquSetsCombo.selection_text
-- update sets in table
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local comboBSelection, slider
for i = 1,r2.equipmentAttNb do
comboBSelection = npcUI:find(r2.equipementComboB[i]):find("combo_box").selection_text
r2.equipmentSets[selection.Equipment][equSetsName][r2.equipementComboB[i] ].comboSelection = comboBSelection
slider = npcUI:find(r2.equipementComboB[i]):find("slider")
r2.equipmentSets[selection.Equipment][equSetsName][r2.equipementComboB[i] ].color = slider.value
end
r2:saveTable("save\\equipmentSets.txt", r2.equipmentSets)
local equSetCombo = npcUI:find("equipment_sets").combo_box
assert(equSetCombo)
equSetCombo.selection_text = updateEquSetsCombo.selection_text
end
-----------------------------------------------------------------------------------------------
function r2:removeEquipment()
local selection = r2:getSelectedInstance()
local updateEquSetsCombo = getUI("ui:interface:r2ed_add_equipment_set"):find("update_sets").combo_box
assert(updateEquSetsCombo)
local equSetsName = updateEquSetsCombo.selection_text
-- delete sets in table
r2.equipmentSets[selection.Equipment][equSetsName] = nil
r2:saveTable("save\\equipmentSets.txt", r2.equipmentSets)
-- delete sets in combo box
updateEquSetsCombo:removeSelection(updateEquSetsCombo.selection)
local equSetsCombo = getUI("ui:interface:r2ed_npc"):find("equipment_sets").combo_box
assert(equSetsCombo)
equSetsCombo:removeText(equSetsName)
equSetsCombo.view_text = r2.emptyComboLine
updateEquSetsCombo.view_text = r2.emptyComboLine
end
-----------------------------------------------------------------------------------------------
function r2:randomEquipment()
r2.requestNewAction(i18n.get("uiR2EDRandomNpcEquipmentAction"))
r2.selectEquipmentSet = true
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
for i=1, r2.equipmentAttNb do -- no right or left hand
local comboBox = npcUI:find(r2.equipementComboB[i]):find("combo_box")
if comboBox.selectionNb > 0 then
comboBox.selection = math.random(1, comboBox.selectionNb) - 1
end
end
r2.selectEquipmentSet = false
r2.requestEndAction()
end
-----------------------------------------------------------------------------------------------
function r2:randomColor()
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local levelDesignEnabled = getClientCfgVar("LevelDesignEnabled")
local maxVal = 5
if tonumber(levelDesignEnabled)==1 then maxVal = 7 end
if r2.linkColorB then
local randomColor = math.random(0, maxVal)
while r2.linkedColor == randomColor do
randomColor = math.random(0, maxVal)
end
r2.linkedColor = randomColor
end
for i=1, r2.equipmentAttNb do -- no right or left hand
local slider = npcUI:find(r2.equipementComboB[i]):find("slider")
if not r2.linkColorB then
slider.value = math.random(0, maxVal)
end
end
r2:updateLinkColor()
end
---------RANDOM ALL NPC PROPERTIES -------------------------------------------------------------
function r2:randomNPCSex(sheetClient)
local race
local s = string.find(sheetClient, "fyros")
if s ~= nil then race = "Fyros" end
s = string.find(sheetClient, "matis")
if s ~= nil then race = "Matis" end
s = string.find(sheetClient, "tryker")
if s ~= nil then race = "Tryker" end
s = string.find(sheetClient, "zorai")
if s ~= nil then race = "Zorai" end
local sex = (math.random(0,10)>5)
if sex == true then
sex = r2.male
else
sex = r2.female
end
return r2.raceSheetClient[sex][race]
end
function r2:randomNPCProperties(equipmentId, race)
local result = {}
-- random body
result["GabaritHeight"] = math.random(0,14)
result["GabaritTorsoWidth"] = math.random(0,14)
result["GabaritArmsWidth"] = math.random(0,14)
result["GabaritLegsWidth"] = math.random(0,14)
result["GabaritBreastSize"] = math.random(0,14)
-- random face
result["HairColor"] = math.random(0,5)
result["Tattoo"] = math.random(0,31)
result["HairType"] = getSheetId(r2.sliderValueToItemIndex[race][math.random(0,6)])
result["EyesColor"] = math.random(0,7)
-- random face morph
result["MorphTarget1"] = math.random(0,7)
result["MorphTarget2"] = math.random(0,7)
result["MorphTarget3"] = math.random(0,7)
result["MorphTarget4"] = math.random(0,7)
result["MorphTarget5"] = math.random(0,7)
result["MorphTarget6"] = math.random(0,7)
result["MorphTarget7"] = math.random(0,7)
result["MorphTarget8"] = math.random(0,7)
-- random equipment
r2:randomNPCEquipment(equipmentId, result)
return result
end
function r2:randomNPCEquipment(equipmentId, result)
if result == nil then
result = {}
end
local tableEquipment = r2.equipmentPalette[equipmentId]
assert(tableEquipment)
local hasHelmet = false
local size = 0
local hasNudeOption = false
for k, v in pairs(tableEquipment.helmet) do
size = size+1
if k == r2.noPiece then
hasNudeOption = true
end
end
if size > 0 and (not hasNudeOption or (math.random(0,10) > 5)) then
local helmetType = r2:randomPieceEquipment(tableEquipment.helmet, false)
if helmetType ~= 0 then
result["HairType"] = helmetType
hasHelmet = true
end
end
result["JacketModel"] = r2:randomPieceEquipment(tableEquipment.chest_plate, false)
result["TrouserModel"] = r2:randomPieceEquipment(tableEquipment.legs, false)
result["FeetModel"] = r2:randomPieceEquipment(tableEquipment.boots, false)
result["HandsModel"] = r2:randomPieceEquipment(tableEquipment.gloves, false)
result["ArmModel"] = r2:randomPieceEquipment(tableEquipment.arms_guard, false)
local weaponRH, weaponLH = r2:randomPieceEquipment(tableEquipment.hands, true)
result["WeaponRightHand"] = weaponRH
result["WeaponLeftHand"] = weaponLH
-- random equipment color
local levelDesignEnabled = getClientCfgVar("LevelDesignEnabled")
local maxVal = 5
if tonumber(levelDesignEnabled)==1 then maxVal = 7 end
result["JacketColor"] = math.random(0, maxVal)
result["ArmColor"] = math.random(0, maxVal)
result["HandsColor"] = math.random(0, maxVal)
result["TrouserColor"] = math.random(0, maxVal)
result["FeetColor"] = math.random(0, maxVal)
if hasHelmet then
result["HairColor"] = math.random(0,maxVal)
end
return result
end
-- Same as randomNPCName but can return 2 times the same name
function r2:randomNPCName2(race, sex)
local allNames = r2:getAllNames()
local tableNames = allNames[race .."_" .. sex]
if not tableNames or table.getn(tableNames) == 0 then return "" end
local indexName = math.random(1, table.getn(tableNames))
return tableNames[indexName]
end
function r2:randomNPCName(race, sex)
-- random name
local tableNames = r2.NPCNames[race .."_" .. sex]
local name = ""
if table.getn(tableNames) == 0 then
r2:loadRaceSexNames(race, sex)
tableNames = r2.NPCNames[race .."_" .. sex]
end
if table.getn(tableNames) > 0 then
local indexName = math.random(1, table.getn(tableNames))
name = tableNames[indexName]
tableNames[indexName] = tableNames[table.getn(tableNames)]
tableNames[table.getn(tableNames)] = nil
end
return name
end
function r2:isRandomizedNPCName(name, race, sex)
local tableNames = r2:loadRaceSexNamesImpl(race, sex)
for k, vName in pairs(tableNames) do
if vName==name then return true end
end
return false
end
function r2:searchSheet(equipmentId, weaponRH, weaponLH, sheet, sheetModel)
local tableEquipment = r2.equipmentPalette[equipmentId]
assert(tableEquipment)
local hands = tableEquipment.hands
for k, v in pairs(hands) do
local rightHand = v.rightHand
local leftHand = v.leftHand
if weaponRH==getSheetId(rightHand) and weaponLH==getSheetId(leftHand) then
local handsLevel = v.handsLevel
local s, e = string.find(sheet, ".creature")
local level = string.sub(sheet, s-1, s-1)
local newSheet = sheetModel
newSheet = string.gsub(newSheet, "$hands", handsLevel)
newSheet = string.gsub(newSheet, "$level", level)
return newSheet
end
end
return ""
end
-- Return a random NPC (Warning names can be duplicates)
function r2:randomNPC(base)
assert(base)
local npc = r2.newComponent("NpcCustom")
npc.Base = base
-- random equipment and random sex
local sheetClient = r2.getPropertyValue(npc, "SheetClient")
local sexSheetClient = r2:randomNPCSex(sheetClient)
npc.SheetClient = sexSheetClient
local raceSelection = getR2PlayerRace(npc.SheetClient)
local sexSelection = nil
if isR2PlayerMale(npc.SheetClient) then
sexSelection = r2.male
else
sexSelection = r2.female
end
local equipment = r2.getPropertyValue(npc, "Equipment")
local results = r2:randomNPCProperties(equipment, raceSelection)
local k,v = next(results, nil)
while v do
npc[k] = v
k,v = next(results, k)
end
npc.Name = r2:randomNPCName2(raceSelection, sexSelection)
return npc
end
function r2:randomPieceEquipment(pieces, isHands)
local keyPlace = 1
assert(pieces ~= nil)
local size = 0
-- why table.getn(pieces) doesn't work???
for k, v in pairs(pieces) do
size = size + 1
end
if size > 1 then
keyPlace = math.random(1,size)
end
local key, itemFileName
local count = 1
for k, v in pairs(pieces) do
if count == keyPlace then
key = k
tempTable = v
break
end
count = count + 1
end
if key == r2.noPiece or tempTable == nil then
return 0
elseif isHands==true then
local rightHand = getSheetId(tempTable.rightHand)
local leftHand = getSheetId(tempTable.leftHand)
return rightHand, leftHand
else
return getSheetId(tempTable.itemFile)
end
end
function r2:getPieceEquipmentNumber(pieces, piece)
local pieceNb = 0
for k, v in pairs(pieces) do
if v.rightHand and v.leftHand then
if getSheetId(v.rightHand) == piece then
return pieceNb
elseif getSheetId(v.leftHand) == piece then
return pieceNb
end
elseif getSheetId(v.itemFile) == piece then
return pieceNb
end
pieceNb = pieceNb + 1
end
return -1
end
function r2:getPieceEquipmentFromNumber(pieces, number, handSide)
local pieceNb = 0
for k, v in pairs(pieces) do
if pieceNb == number then
if v.rightHand and v.leftHand then
if handSide == "right" then
return getSheetId(v.rightHand)
elseif handSide == "left" then
return getSheetId(v.leftHand)
end
else
return getSheetId(v.itemFile)
end
end
pieceNb = pieceNb + 1
end
return -1
end
-----------------------------------------------------------------------------------------------
function r2:updatePieceEquipmentColor(requestType)
if not r2.linkColorB then
r2:updateColor(getUICaller(), requestType)
else
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
r2.linkedColor = getUICaller().value
r2:updateLinkColor(requestType)
end
end
-----------------------------------------------------------------------------------------------
r2.updateLinkColors = false
function r2:updateLinkColor(requestType)
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
if not r2.linkColorAction then
r2.requestNewAction(i18n.get("uiR2EDUpdateLinkedNPCColorAction"))
end
r2.updateLinkColors = true
for i=1, r2.equipmentAttNb do
r2:updateColor(npcUI:find(r2.equipementComboB[i]):find("slider"), requestType)
end
r2.updateLinkColors = false
if not r2.linkColorAction then
r2.requestEndAction()
end
end
function r2:updateColor(slider, requestType)
local selection = r2:getSelectedInstance()
if selection == nil then
debugInfo("No selection")
return
end
if not r2.updateLinkColors then
r2.requestNewAction(i18n.get("uiR2EDUpdateNPCColorAction"))
end
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local nameComboBox = slider.name
local equipmentType = npcUI:find(nameComboBox):find("combo_box").selection_text
if equipmentType == r2.noPiece then
slider.value = 0
else
if r2.linkColorB then
slider.value = r2.linkedColor
end
local propColor = r2.equipmentEnv[nameComboBox].propColorName
if requestType == nil then
r2:setNpcAttribute(selection.InstanceId, propColor, slider.value)
elseif requestType == 'local' then
r2.requestSetLocalNode(selection.InstanceId, propColor, slider.value)
elseif requestType == 'commit' then
r2.requestCommitLocalNode(selection.InstanceId, propColor)
elseif requestType == 'cancel' then
r2.requestRollbackLocalNode(selection.InstanceId, propColor)
else
debugInfo("r2:updateColor : unknown request type")
end
end
r2.requestEndAction()
end
-----------------------------------------------------------------------------------------------
r2.linkColorAction=false
function r2:linkColor()
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local toggleB = npcUI:find("color_link").toggle_butt
assert(toggleB)
r2.linkColorB = not toggleB.pushed
-- update LinkColor property
local selection = r2:getSelectedInstance()
if selection == nil then return end
r2.linkColorAction = true
r2.requestNewAction(i18n.get("uiR2EDLinkColorEquipment"))
local link = 0
if r2.linkColorB then link=1 end
r2:setNpcAttribute(selection.InstanceId, "LinkColor", link)
-- update colors
if not r2.linkColorB then
r2.linkedColor = 0
else
local colors = {}
local slider
for i=r2.equipmentAttNb, 1, -1 do -- no right or left hand
slider = npcUI:find(r2.equipementComboB[i]):find("slider")
local nameComboBox = slider.name
local equipmentType = npcUI:find(nameComboBox):find("combo_box").selection_text
if equipmentType ~= r2.noPiece then
local value = slider.value
if colors[value] == nil then colors[value] = 0 end
colors[value] = colors[value] + 1
end
end
local colorMax = -1
local colorMaxCount = 0
for k, v in pairs(colors) do
if v > colorMaxCount then
colorMaxCount = v
colorMax = k
end
end
if colorMax~=-1 then
if colorMaxCount==1 then colorMax = slider.value end
r2.linkedColor = colorMax
r2:updateLinkColor()
end
end
r2.requestEndAction()
r2.linkColorAction = false
end
---------PREVIEW -----------------------------------------------------------------------------
function r2:preview()
local npcUI = getUI("ui:interface:r2ed_npc")
assert(npcUI)
local npcView = npcUI:find("npc_view")
assert(npcView)
local sep = npcUI:find("v_sep")
assert(sep)
if npcView.active then
npcUI.pop_min_w = npcUI.pop_min_w - 300
npcUI.pop_max_w = npcUI.pop_max_w - 300
npcUI.x = npcUI.x + 300
else
npcUI.pop_min_w = npcUI.pop_min_w + 300
npcUI.pop_max_w = npcUI.pop_max_w + 300
npcUI.x = npcUI.x - 300
end
npcView.active = not npcView.active
sep.active = not sep.active
end
function r2:isNPCPlant(sheetClient)
return string.match(sheetClient, "cp[%w_]*%.creature")
end