SceneEditorMenu.c

Go to the documentation of this file.

class SceneEditorMenu extends UIScriptedMenu
{
  //---------------------------------------------------------------------------------
  // >> Public Scope
  static const int POPUP_ID_SCENE_MANAGER = 0;
  static const int POPUP_ID_SCENE_SETTINGS = 1;
  static const int POPUP_ID_SCENE_NEW = 2;
  static const int POPUP_ID_SCENE_RENAME = 3;
  static const int POPUP_ID_SCENE_DELETE = 4;
  static const int POPUP_ID_NOTIFY = 5;
  static const int POPUP_ID_EDITOR_SETTINGS = 6;
  static const int POPUP_ID_INIT_SCRIPT = 7;
  static const int POPUP_ID_POSITION_MANAGER = 8;
  static const int POPUP_ID_PRESET_NEW = 9;
  static const int POPUP_ID_PRESET_RENAME = 10;
  static const int POPUP_ID_CONFIGS = 11;
  const string CONST_DEFAULT_PRESET_PREFIX = "[Default]";
 
  // Render specific Preset Items
  void RenderPresets()
  {
    m_PresetsTextListbox.ClearItems();
 
    int i;
    TBoolArray preset_params;
 
    // load fixed presets list
    TStringArray presets_array = m_ConfigDebugProfileFixed.GetPresets();
    for (i = 0; i < presets_array.Count(); i++)
      m_PresetsTextListbox.AddItem("[" + presets_array.Get(i) + "]", new PresetParams(presets_array.Get(i), true, false), 0);
 
    // load custom presets list
    TStringArray custom_presets_array = m_ConfigDebugProfile.GetPresets();
    for (i = 0; i < custom_presets_array.Count(); i++)
      m_PresetsTextListbox.AddItem(custom_presets_array.Get(i), new PresetParams(custom_presets_array.Get(i), false, false), 0);
 
    string default_preset = m_ConfigDebugProfile.GetDefaultPreset();
    if (default_preset != "")
    {
      // if is fixed
      int index = GetPresetIndexByName(default_preset);
      if (IsPresetFixed(default_preset))
        default_preset = "[" + default_preset + "]";
      PresetParams preset_params_array;
      if (index > -1 && index < m_PresetsTextListbox.GetNumItems())
      {
        m_PresetsTextListbox.GetItemData(index, 0, preset_params_array);
        m_PresetsTextListbox.SetItem(index, default_preset + CONST_DEFAULT_PRESET_PREFIX, preset_params_array, 0);
      }
    }
  }
 
  bool IsPresetFixed(string preset_name)
  {
    int preset_index = GetPresetIndexByName(preset_name);
    PresetParams item_params_array;
    if (preset_index > -1 && preset_index < m_PresetsTextListbox.GetNumItems())
    {
      m_PresetsTextListbox.GetItemData(preset_index, 0, item_params_array);
      return item_params_array.param2;
    }
    return false;
  }
 
  int GetPresetIndexByName(string preset_name)
  {
    int i;
    for (i = 0; i < m_PresetsTextListbox.GetNumItems(); i++)
    {
      PresetParams item_params_array;
      m_PresetsTextListbox.GetItemData(i, 0, item_params_array);
 
      if (item_params_array.param1 == preset_name)
        return i;
    }
    return -1;
  }
 
  void NewPreset(string preset_name)
  {
    m_ConfigDebugProfile.PresetAdd(preset_name);
    RefreshLists();
  }
 
  void DeletePreset()
  {
    if (GetCurrentPresetIndex() != -1)
    {
      bool result = m_ConfigDebugProfile.PresetRemove(GetCurrentPresetName());
      RefreshLists();
    }
  }
 
  void SetDefaultPreset(int preset_index)
  {
    // remove previous default parameter
    string default_preset = m_ConfigDebugProfile.GetDefaultPreset();
    if (default_preset != "")
    {
      int index = GetPresetIndexByName(default_preset);
      // if is fixed
      if (IsPresetFixed(default_preset))
        default_preset = "[" + default_preset + "]";
      PresetParams prev_preset_params_array;
      if (index > -1 && index < m_PresetsTextListbox.GetNumItems())
      {
        m_PresetsTextListbox.GetItemData(index, 0, prev_preset_params_array);
        prev_preset_params_array.param3 = false; // remove DEFAULT
        m_PresetsTextListbox.SetItem(index, default_preset, prev_preset_params_array, 0);
      }
    }
 
    // set preset on preset_index to default
    // if is fixed
    string preset_name = GetCurrentPresetName();
    if (IsPresetFixed(preset_name))
      preset_name = "[" + preset_name + "]";
    // set new default preset
    PresetParams preset_params_array;
    index = GetCurrentPresetIndex();
    if (index > -1 && index < m_PresetsTextListbox.GetNumItems())
    {
      m_PresetsTextListbox.GetItemData(index, 0, preset_params_array);
      preset_params_array.param3 = true; // DEFAULT
      m_PresetsTextListbox.SetItem(index, preset_name + CONST_DEFAULT_PRESET_PREFIX, preset_params_array, 0);
    }
    // store preset
    m_ConfigDebugProfile.SetDefaultPreset(GetCurrentPresetName());
  }
 
  void RefreshLists()
  {
    RenderPresets();
    RenderPresetItems();
  }
 
  void RenamePreset(string new_preset_name)
  {
    if (GetCurrentPresetIndex() != -1)
    {
      bool result = m_ConfigDebugProfile.PresetRename(GetCurrentPresetName(), new_preset_name);
      RefreshLists();
    }
  }
 
  // Render specific Preset Items
  void RenderPresetItems()
  {
    // load preset items list
    int i;
    m_PresetItemsTextListbox.ClearItems();
    if (GetCurrentPresetIndex() != -1)
    {
      bool isFixed = IsCurrentPresetFixed();
      TStringArray preset_array = new TStringArray;
 
      if (isFixed)
        m_ConfigDebugProfileFixed.GetPresetItems(GetCurrentPresetName(), preset_array);
      else
        m_ConfigDebugProfile.GetPresetItems(GetCurrentPresetName(), preset_array);
 
      if (preset_array)
      {
        for (i = 0; i < preset_array.Count(); i++)
          m_PresetItemsTextListbox.AddItem(preset_array.Get(i), NULL, 0);
      }
    }
  }
 
  string GetCurrentPresetName()
  {
    int index = GetCurrentPresetIndex();
    // load preset items list
    if (index > -1 && index < m_PresetsTextListbox.GetNumItems())
    {
      PresetParams item_params_array;
      m_PresetsTextListbox.GetItemData(index, 0, item_params_array);
      return item_params_array.param1;
    }
    return "";
  }
 
  string GetCurrentItemName()
  {
    if (GetCurrentItemIndex() != -1)
    {
      string item_name;
      m_PresetItemsTextListbox.GetItemText(GetCurrentItemIndex(), 0, item_name);
      return item_name;
    }
    return "";
  }
 
  string GetCurrentObjectName()
  {
    int selected_row_index = m_ClWgtLbxClassesList.GetSelectedRow();
    if (selected_row_index != -1)
    {
      string item_name;
      m_ClWgtLbxClassesList.GetItemText(selected_row_index, 0, item_name);
      return item_name;
    }
    return "";
  }
 
  int GetCurrentPresetIndex()
  {
    return m_PresetsTextListbox.GetSelectedRow();
  }
 
  int GetCurrentItemIndex()
  {
    return m_PresetItemsTextListbox.GetSelectedRow();
  }
 
  bool IsCurrentPresetFixed()
  {
    int index = GetCurrentPresetIndex();
    if (index > -1 && index < m_PresetsTextListbox.GetNumItems())
    {
      PresetParams item_params_array;
      m_PresetsTextListbox.GetItemData(index, 0, item_params_array);
      return item_params_array.param2;
    }
    return -1;
  }
 
  void AddItemToPreset()
  {
    int selected_row_index = m_ClWgtLbxClassesList.GetSelectedRow();
    if (selected_row_index != -1 && GetCurrentPresetIndex() != -1)
    {
      string item_name;
      m_ClWgtLbxClassesList.GetItemText(selected_row_index, 0, item_name);
      m_ConfigDebugProfile.ItemAddToPreset(GetCurrentPresetName(), item_name);
      RenderPresetItems();
    }
  }
 
  void RemoveItemFromPreset()
  {
    if (GetCurrentItemIndex() != -1 && GetCurrentPresetIndex() != -1)
    {
      m_ConfigDebugProfile.ItemRemoveFromPreset(GetCurrentPresetName(), GetCurrentItemIndex());
      RenderPresetItems();
    }
  }
 
  void SetPreset(bool clear_inventory, string preset_name)
  {
    int i;
    if (GetCurrentPresetIndex() != -1)
    {
      bool is_preset_fixed = IsCurrentPresetFixed();
      TStringArray preset_array = new TStringArray;
 
      if (is_preset_fixed)
        m_ConfigDebugProfileFixed.GetPresetItems(preset_name, preset_array);
      else
        m_ConfigDebugProfile.GetPresetItems(preset_name, preset_array);
 
      PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
      if (clear_inventory)
        m_Developer.ClearInventory(player);
 
      for (i = 0; i < preset_array.Count(); i++)
      {
        float health = -1;
        int quantity = -1;
        if (is_preset_fixed)
        {
          health = m_ConfigDebugProfileFixed.GetItemHealth(preset_name, i);
          quantity = m_ConfigDebugProfileFixed.GetItemQuantity(preset_name, i);
        }
        else
        {
          health = m_ConfigDebugProfile.GetItemHealth(preset_name, i);
          quantity = m_ConfigDebugProfile.GetItemQuantity(preset_name, i);
        }
 
        m_Developer.SpawnEntityInPlayerInventory(player, preset_array.Get(i), health, quantity);
      }
    }
  }
 
  void ItemMoveUp()
  {
    int new_index = GetCurrentItemIndex() - 1;
    if (GetCurrentItemIndex() != -1 && GetCurrentPresetIndex() != -1 && new_index > -1)
    {
      m_ConfigDebugProfile.SwapItem(GetCurrentPresetName(), GetCurrentItemIndex(), new_index);
      RenderPresetItems();
      m_PresetItemsTextListbox.SelectRow(new_index);
    }
  }
 
  void ItemMoveDown()
  {
    int new_index = GetCurrentItemIndex() + 1;
    if (GetCurrentItemIndex() != -1 && GetCurrentPresetIndex() != -1 && new_index < m_PresetItemsTextListbox.GetNumItems())
    {
      m_ConfigDebugProfile.SwapItem(GetCurrentPresetName(), GetCurrentItemIndex(), new_index);
      RenderPresetItems();
      m_PresetItemsTextListbox.SelectRow(new_index);
    }
  }
 
  void SaveProfileSpawnDistance()
  {
    if (m_ConfigDebugProfile && m_SpawnDistanceEditBox)
      m_ConfigDebugProfile.SetSpawnDistance(m_SpawnDistanceEditBox.GetText().ToFloat());
  }
 
  // Overrided Parent Functions
  //============================================
  // UseMouse (override)
  //============================================
  override bool UseMouse()
  {
    return true;
  }
 
  //============================================
  // UseKeyboard (override)
  //============================================
  override bool UseKeyboard()
  {
    return true;
  }
 
  // System Events
  //============================================
  // SceneEditorMenu
  //============================================
  void SceneEditorMenu()
  {
    m_ModuleSceneManager = PluginSceneManager.Cast(GetPlugin(PluginSceneManager));
    m_ModuleSceneManager.OnUIEditorOpened();
 
    m_Popups = new map<int, ref UIPopupScript>;
    m_SlObjectsList = new map<int, SceneObject>;
    m_OpenedPopups = new TIntArray;
    m_ClClassesList = new TStringArray;
  }
 
  //============================================
  // ~SceneEditorMenu
  //============================================
  void ~SceneEditorMenu()
  {
    PopupCloseAll();
 
    if (IsModuleExist(PluginSceneManager))
    {
      m_ModuleSceneManager.OnUIEditorClosed();
      m_ModuleSceneManager = NULL;
    }
 
    m_NotifyFadeTimer.Stop();
  }
 
  //============================================
  // Init
  //============================================
  override Widget Init()
  {
    // Create Main layout menu
    layoutRoot = GetGame().GetWorkspace().CreateWidgets("gui/layouts/scene_editor/day_z_scene_editor.layout");
    m_WgtPnlWrapper = layoutRoot.FindAnyWidget("pnl_presets_wrapper_outer");
    m_SlWgtLoadedScene = TextWidget.Cast(layoutRoot.FindAnyWidget("txt_left_label_loaded_scene"));
    // Find ListTextBoxWidget for objects list
    m_SlWgtLbxObjectsList = TextListboxWidget.Cast(layoutRoot.FindAnyWidget("txtlist_left_items"));
    // Find Edit Box for shearching in object list
    m_SlWgtEbxFilter = EditBoxWidget.Cast(layoutRoot.FindAnyWidget("edit_left_search_item"));
    // Find Select Button for selecting in object list
    m_SlWgtSelect = ButtonWidget.Cast(layoutRoot.FindAnyWidget("btn_left_select"));
    m_SlWgtFocus = ButtonWidget.Cast(layoutRoot.FindAnyWidget("btn_left_focus"));
    // Find Popup main panel
    m_WgtPopupsMain = layoutRoot.FindAnyWidget("pnl_popups");
    // Find Poups backgroudn
    m_WgtPopupsBg = layoutRoot.FindAnyWidget("pnl_popup_bg");
    // Find Edit Box for shearching in class list
    m_ClWgtEbxFilter = EditBoxWidget.Cast(layoutRoot.FindAnyWidget("edit_left_search_class"));
    // Find ListTextBoxWidget for class list
    m_ClWgtLbxClassesList = TextListboxWidget.Cast(layoutRoot.FindAnyWidget("txtlist_left_classes"));
    // Find Buttons
    m_WgtBtnSceneManager = ButtonWidget.Cast(layoutRoot.FindAnyWidget("btn_top_scene_manager"));
    m_WgtBtnPositionManager = ButtonWidget.Cast(layoutRoot.FindAnyWidget("btn_top_position_manager"));
    m_WgtBtnSceneSettings = ButtonWidget.Cast(layoutRoot.FindAnyWidget("btn_top_settings"));
    m_ClWgtButtonAddAtt = ButtonWidget.Cast(layoutRoot.FindAnyWidget("btn_left_cl_add_attachment"));
    m_WgtBtnSceneSave = ButtonWidget.Cast(layoutRoot.FindAnyWidget("btn_top_save_scene"));
    m_WgtBtnEditorSettings = ButtonWidget.Cast(layoutRoot.FindAnyWidget("btn_top_editor_settings"));
    m_WgtBtnEditInitScript = ButtonWidget.Cast(layoutRoot.FindAnyWidget("btn_right_prop_pos_iscr_value"));
    m_WgtBtnDeleteRuler = ButtonWidget.Cast(layoutRoot.FindAnyWidget("btn_delete_ruler"));
    m_WgtBtnLeftPresets = ButtonWidget.Cast(layoutRoot.FindAnyWidget("btn_left_presets"));
 
    // Find Widgets for properties
    m_PrWgtClassName = TextWidget.Cast(layoutRoot.FindAnyWidget("txt_right_prop_class_value"));
    m_PrWgtPoxX = EditBoxWidget.Cast(layoutRoot.FindAnyWidget("ebx_right_prop_pos_x_value"));
    m_PrWgtPoxY = EditBoxWidget.Cast(layoutRoot.FindAnyWidget("ebx_right_prop_pos_y_value"));
    m_PrWgtPoxZ = EditBoxWidget.Cast(layoutRoot.FindAnyWidget("ebx_right_prop_pos_z_value"));
    m_PrWgtDir = EditBoxWidget.Cast(layoutRoot.FindAnyWidget("ebx_right_prop_pos_dir_value"));
    m_PrWgtDmg = EditBoxWidget.Cast(layoutRoot.FindAnyWidget("ebx_right_prop_pos_hlt_value"));
    m_PrWgtAttRoot = layoutRoot.FindAnyWidget("pnl_right_inspector_attachments");
    m_PrWgtAttTitle = layoutRoot.FindAnyWidget("pnl_att_title");
    m_PrWidgetsAttachments = new array<ref UIPropertyAttachment>;
 
    // Notify
    m_NotifyWgtPanel = layoutRoot.FindAnyWidget("pnl_notify");
    m_NotifyWgtPanel.SetAlpha(0.0);
    m_NotifyFadeTimer = new WidgetFadeTimer;
 
    // Register Poups
    m_Popups.Insert(POPUP_ID_SCENE_MANAGER, new UIPopupScriptSceneManager(layoutRoot.FindAnyWidget("pnl_popup_scene_manager")));
    m_Popups.Insert(POPUP_ID_POSITION_MANAGER, new UIPopupScriptPositionManager(layoutRoot.FindAnyWidget("pnl_popup_position_manager")));
    m_Popups.Insert(POPUP_ID_SCENE_SETTINGS, new UIPopupScriptSceneSettings(layoutRoot.FindAnyWidget("pnl_popup_settings")));
    m_Popups.Insert(POPUP_ID_SCENE_NEW, new UIPopupScriptSceneNew(layoutRoot.FindAnyWidget("pnl_popup_scene_new")));
    m_Popups.Insert(POPUP_ID_SCENE_RENAME, new UIPopupScriptSceneRename(layoutRoot.FindAnyWidget("pnl_popup_scene_rename")));
    m_Popups.Insert(POPUP_ID_SCENE_DELETE, new UIPopupScriptSceneDelete(layoutRoot.FindAnyWidget("pnl_popup_scene_delete")));
    m_Popups.Insert(POPUP_ID_NOTIFY, new UIPopupScriptNotify(layoutRoot.FindAnyWidget("pnl_popup_notify")));
    m_Popups.Insert(POPUP_ID_EDITOR_SETTINGS, new UIPopupScriptEditorSettings(layoutRoot.FindAnyWidget("pnl_popup_editor_settings")));
    m_Popups.Insert(POPUP_ID_INIT_SCRIPT, new UIPopupScriptInitScript(layoutRoot.FindAnyWidget("pnl_popup_init_script")));
    m_Popups.Insert(POPUP_ID_PRESET_NEW, new UIPopupScriptPresetNew(layoutRoot.FindAnyWidget("pnl_popup_preset_new")));
    m_Popups.Insert(POPUP_ID_PRESET_RENAME, new UIPopupScriptPresetRename(layoutRoot.FindAnyWidget("pnl_popup_preset_rename")));
    m_Popups.Insert(POPUP_ID_CONFIGS, new UIPopupScriptConfigs(layoutRoot.FindAnyWidget("pnl_popup_configs")));
 
    m_PresetsTextListbox = TextListboxWidget.Cast(layoutRoot.FindAnyWidget("pnl_presets"));
    m_PresetItemsTextListbox = TextListboxWidget.Cast(layoutRoot.FindAnyWidget("pnl_preset_items"));
    m_ConfigDebugProfileFixed = PluginConfigDebugProfileFixed.Cast(GetPlugin(PluginConfigDebugProfileFixed));
    m_ConfigDebugProfile = PluginConfigDebugProfile.Cast(GetPlugin(PluginConfigDebugProfile));
    m_PresetAddItemtButton = ButtonWidget.Cast(layoutRoot.FindAnyWidget("btn_add_to_preset"));
    m_PresetRemoveItemButton = ButtonWidget.Cast(layoutRoot.FindAnyWidget("btn_remove_from_preset"));
    m_SpawnOnGroundButton = ButtonWidget.Cast(layoutRoot.FindAnyWidget("btn_spawn_on_ground"));
    m_SpawnInInventoryButton = ButtonWidget.Cast(layoutRoot.FindAnyWidget("btn_spawn_in_inventory"));
    m_SpawnAsAttachmentButton = ButtonWidget.Cast(layoutRoot.FindAnyWidget("btn_spawn_as_attachment"));
    m_UpButton = ButtonWidget.Cast(layoutRoot.FindAnyWidget("btn_up"));
    m_DownButton = ButtonWidget.Cast(layoutRoot.FindAnyWidget("btn_down"));
    m_Developer = PluginDeveloper.Cast(GetPlugin(PluginDeveloper));
    m_QuantityEditBox = EditBoxWidget.Cast(layoutRoot.FindAnyWidget("txt_quantity_value"));
    m_DamageEditBox = EditBoxWidget.Cast(layoutRoot.FindAnyWidget("txt_damage_value"));
    m_SpawnDistanceEditBox = EditBoxWidget.Cast(layoutRoot.FindAnyWidget("txt_distance_value"));
    m_PresetNewButton = ButtonWidget.Cast(layoutRoot.FindAnyWidget("btn_new"));
    m_PresetDeleteButton = ButtonWidget.Cast(layoutRoot.FindAnyWidget("btn_delete"));
    m_PresetRenameButton = ButtonWidget.Cast(layoutRoot.FindAnyWidget("btn_rename"));
    m_PresetSetDefaultButton = ButtonWidget.Cast(layoutRoot.FindAnyWidget("btn_default"));
    m_CopyToClipboardButton = ButtonWidget.Cast(layoutRoot.FindAnyWidget("btn_copy_to_clipboard"));
    m_ConfigsButton = EditBoxWidget.Cast(layoutRoot.FindAnyWidget("btn_top_configs"));
    m_SpawnDistanceEditBox.SetText(m_ConfigDebugProfile.GetSpawnDistance().ToString());
 
    RenderPresets();
 
    UpdateListObjects();
    UpdateListClasses();
 
    PopupHideAll();
 
    return layoutRoot;
  }
 
  override bool OnDoubleClick(Widget w, int x, int y, int button)
  {
    if (w == m_PresetItemsTextListbox || w == m_PresetsTextListbox || w == m_ClWgtLbxClassesList)
    {
      SaveProfileSpawnDistance();
 
      //float distance = m_SpawnDistanceEditBox.GetText().ToFloat();
      if (m_SelectedObjectIsPreset)
      {
        SetPreset(true, m_SelectedObject);
        return true;
      }
      else
      {
        float health = -1;
        int quantity = -1;
        if (GetCurrentItemIndex() != -1)
        {
          health = m_ConfigDebugProfile.GetItemHealth(GetCurrentPresetName(), GetCurrentItemIndex());
          quantity = m_ConfigDebugProfile.GetItemQuantity(GetCurrentPresetName(), GetCurrentItemIndex());
        }
        m_Developer.SpawnEntityInPlayerInventory(PlayerBase.Cast(GetGame().GetPlayer()), m_SelectedObject, health, quantity);
        return true;
      }
    }
    return false;
  }
  //============================================
  // OnClick
  //============================================
  override bool OnClick(Widget w, int x, int y, int button)
  {
    super.OnClick(w, x, y, button);
 
    int row_index;
 
    if (w == m_WgtBtnSceneManager)
    {
      PopupOpen(POPUP_ID_SCENE_MANAGER, Param.Cast(NULL));
 
      return true;
    }
    else if (w == m_ConfigsButton)
    {
      PopupOpen(POPUP_ID_CONFIGS, NULL);
      return true;
    }
    else if (w == m_PresetsTextListbox)
    {
      RenderPresetItems();
      m_SelectedObjectIsPreset = true;
      m_SelectedObject = GetCurrentPresetName();
      return true;
    }
    else if (w == m_PresetSetDefaultButton)
    {
      if (GetCurrentPresetName() != "")
        SetDefaultPreset(GetCurrentPresetIndex());
      return true;
    }
    else if (w == m_PresetNewButton)
    {
      PopupOpen(POPUP_ID_PRESET_NEW, NULL);
      RefreshLists();
      return true;
    }
    else if (w == m_PresetRenameButton)
    {
      PopupOpen(POPUP_ID_PRESET_RENAME, NULL);
      return true;
    }
    else if (w == m_CopyToClipboardButton)
    {
      GetGame().CopyToClipboard(m_SelectedObject);
      return true;
    }
    else if (w == m_PresetDeleteButton)
    {
      if (GetCurrentPresetName() != "")
        DeletePreset();
      return true;
    }
    else if (w == m_SpawnOnGroundButton || w == m_SpawnAsAttachmentButton || w == m_SpawnInInventoryButton)
    {
      SaveProfileSpawnDistance();
 
      float distance = m_SpawnDistanceEditBox.GetText().ToFloat();
      float health = -1;
      int quantity = -1;
      if (GetCurrentItemIndex() != -1)
      {
        health = m_ConfigDebugProfile.GetItemHealth(GetCurrentPresetName(), GetCurrentItemIndex());
        quantity = m_ConfigDebugProfile.GetItemQuantity(GetCurrentPresetName(), GetCurrentItemIndex());
      }
 
      switch (w)
      {
      case m_SpawnOnGroundButton:
      {
        if (m_SelectedObjectIsPreset)
        {
          // SpawnPresetOnGround
          ;//SetPreset( true, m_SelectedObject, spawn_type, distance );
        }
        else
          m_Developer.SpawnEntityOnCursorDir(PlayerBase.Cast(GetGame().GetPlayer()), m_SelectedObject, quantity, distance, health);
        break;
      }
 
      case m_SpawnAsAttachmentButton:
      {
        Man player = GetGame().GetPlayer();
 
        vector rayStart = GetGame().GetCurrentCameraPosition();
        vector rayEnd = rayStart + GetGame().GetCurrentCameraDirection() * 1.5;
        vector hitPos;
        vector hitNormal;
        int hitComponentIndex;
        ref set<Object> hitObjects = new set<Object>;
        DayZPhysics.RaycastRV(rayStart, rayEnd, hitPos, hitNormal, hitComponentIndex, hitObjects, NULL, player);
 
        Object target = NULL;
        if (hitObjects.Count())
          target = hitObjects.Get(0);
 
        if (target != NULL && target.IsInherited(EntityAI))
        {
          EntityAI att_parent = EntityAI.Cast(target);
          m_Developer.SpawnEntityAsAttachment(PlayerBase.Cast(player), att_parent, m_SelectedObject, health, quantity);
        }
        else
          m_Developer.SpawnEntityAsAttachment(PlayerBase.Cast(player), player, m_SelectedObject, health, quantity);
        break;
      }
 
      case m_SpawnInInventoryButton:
      {
        m_Developer.SpawnEntityInPlayerInventory(PlayerBase.Cast(GetGame().GetPlayer()), m_SelectedObject, health, quantity);
        break;
      }
      }
      return true;
    }
    else if (w == m_PresetItemsTextListbox)
    {
      m_SelectedObjectIsPreset = false;
      m_SelectedObject = GetCurrentItemName();
 
      if (GetCurrentItemIndex() != -1)
      {
        float item_health = m_ConfigDebugProfile.GetItemHealth(GetCurrentPresetName(), GetCurrentItemIndex());
        int item_quantity = m_ConfigDebugProfile.GetItemQuantity(GetCurrentPresetName(), GetCurrentItemIndex());
 
        m_DamageEditBox.SetText(item_health.ToString());
        m_QuantityEditBox.SetText(item_quantity.ToString());
      }
 
      return true;
    }
    else if (w == m_UpButton)
    {
      ItemMoveUp();
      return true;
    }
    else if (w == m_DownButton)
    {
      ItemMoveDown();
      return true;
    }
    else if (w == m_WgtBtnLeftPresets)
    {
      if (m_WgtPnlWrapper.IsVisible())
      {
        m_WgtPnlWrapper.Show(false);
        m_WgtBtnLeftPresets.SetText("Presets >>");
      }
      else
      {
        m_WgtPnlWrapper.Show(true);
        m_WgtBtnLeftPresets.SetText("Presets <<");
      }
 
      return true;
    }
    else if (w == m_PresetAddItemtButton)
    {
      AddItemToPreset();
      return true;
    }
    else if (w == m_PresetRemoveItemButton)
    {
      RemoveItemFromPreset();
      return true;
    }
    else if (w == m_WgtBtnPositionManager)
    {
      m_PopupScriptPositionManager = UIPopupScriptPositionManager.Cast(PopupOpen(POPUP_ID_POSITION_MANAGER, Param.Cast(NULL)));
      return true;
    }
    else if (w == m_WgtBtnSceneSettings)
    {
      PopupOpen(POPUP_ID_SCENE_SETTINGS, NULL);
      return true;
    }
    else if (w == m_SlWgtSelect)
    {
      row_index = m_SlWgtLbxObjectsList.GetSelectedRow();
 
      if (m_SlObjectsList.Count() > 0 && m_SlObjectsList.Count() > row_index)
        m_ModuleSceneManager.SelectObject(m_SlObjectsList.GetElement(row_index));
 
      return true;
    }
    else if (w == m_SlWgtFocus)
    {
      m_ModuleSceneManager.SelectedObjectFocus();
 
      return true;
    }
    else if (w == m_WgtBtnSceneSave)
    {
      m_ModuleSceneManager.SceneSave();
 
      return true;
    }
    else if (w == m_WgtBtnEditorSettings)
    {
      PopupOpen(POPUP_ID_EDITOR_SETTINGS, NULL);
 
      return true;
    }
    else if (w == m_WgtBtnEditInitScript)
    {
      Param2<int, SceneObject> param = new Param2<int, SceneObject>(m_ModuleSceneManager.GetSelectedSceneObjectIndex(), m_ModuleSceneManager.GetSelectedSceneObject());
      PopupOpen(POPUP_ID_INIT_SCRIPT, param);
 
      return true;
    }
    else if (w == m_WgtBtnDeleteRuler)
    {
      m_ModuleSceneManager.RulerDelete();
 
      return true;
    }
 
    bool ret = ComponentsOnClick(w, x, y, button);
 
    return ret;
  }
 
  //============================================
  // OnChange
  //============================================
  override bool OnChange(Widget w, int x, int y, bool finished)
  {
    super.OnChange(w, x, y, finished);
 
    if (w == m_ClWgtEbxFilter)
    {
      UpdateListClasses();
      return true;
    }
    else if (w == m_SlWgtEbxFilter)
    {
      UpdateListObjects();
      return true;
    }
    else if (w == m_PrWgtPoxX && finished)
      m_ModuleSceneManager.SelectedObjectSetPosX(m_PrWgtPoxX.GetText().ToFloat());
    else if (w == m_PrWgtPoxY && finished)
      m_ModuleSceneManager.SelectedObjectSetPosY(m_PrWgtPoxY.GetText().ToFloat());
    else if (w == m_PrWgtPoxZ && finished)
      m_ModuleSceneManager.SelectedObjectSetPosZ(m_PrWgtPoxZ.GetText().ToFloat());
    else if (w == m_PrWgtDir && finished)
    {
      m_ModuleSceneManager.SelectedObjectSetRot(m_PrWgtDir.GetText().ToFloat());
      return true;
    }
    else if (w == m_PrWgtDmg && finished)
    {
      m_ModuleSceneManager.SelectedObjectSetDamage(m_PrWgtDmg.GetText().ToFloat());
      return true;
    }
    else if (w == m_QuantityEditBox)
    {
      m_ConfigDebugProfile.SetItemQuantity(GetCurrentPresetName(), GetCurrentItemIndex(), m_QuantityEditBox.GetText().ToInt());
      return true;
    }
    else if (w == m_DamageEditBox)
    {
      m_ConfigDebugProfile.SetItemHealth(GetCurrentPresetName(), GetCurrentItemIndex(), m_DamageEditBox.GetText().ToFloat());
      return true;
    }
 
    bool ret = ComponentsOnChange(w, x, y, finished);
 
    return false;
  }
 
  override void OnShow()
  {
    GetGame().GetMission().AddActiveInputExcludes({"menu"});
  }
 
  override void OnHide()
  {
    GetGame().GetMission().RemoveActiveInputExcludes({"menu"}, true);
  }
 
  //============================================
  // OnMouseWheel
  //============================================
  override bool OnMouseWheel(Widget w, int x, int y, int wheel)
  {
    super.OnMouseWheel(w, x, y, wheel);
 
    m_ModuleSceneManager.OnMouseWheel(wheel);
    return true;
  }
 
  //============================================
  // OnItemSelected
  //============================================
  override bool OnItemSelected(Widget w, int x, int y, int row, int column, int oldRow, int oldColumn)
  {
 
    super.OnItemSelected(w, x, y, row, column, oldRow, oldColumn);
 
    if (w == m_ClWgtLbxClassesList)
    {
      string selected_class_name;
      m_ClWgtLbxClassesList.GetItemText(m_ClWgtLbxClassesList.GetSelectedRow(), 0, selected_class_name);
      m_ModuleSceneManager.SelectClassName(selected_class_name);
 
      SceneObject obj_selected = m_ModuleSceneManager.GetSelectedSceneObject();
      m_SelectedObject = GetCurrentObjectName();
      m_SelectedObjectIsPreset = false;
    }
    else if (w == m_SlWgtLbxObjectsList)
    {
      int row_index = m_SlWgtLbxObjectsList.GetSelectedRow();
 
      if (m_SlObjectsList && row_index > -1 && m_SlObjectsList.Count() > 0 && m_SlObjectsList.Count() > row_index)
        m_ModuleSceneManager.SelectObject(m_SlObjectsList.GetElement(row_index));
    }
 
    if (m_PopupScriptPositionManager != NULL)
      m_PopupScriptPositionManager.OnItemSelected(w, x, y, row, column, oldRow, oldColumn);
 
    return true;
  }
 
  // Scripted Events
  //============================================
  // PopupOpen
  //============================================
  UIPopupScript PopupOpen(int popup_id, Param param)
  {
    // Open background image (black transparent) under popups
    if (m_OpenedPopups.Count() == 0)
    {
      m_WgtPopupsMain.Show(true);
      m_WgtPopupsBg.Show(true);
    }
    else
    {
      int popup_curr_id = m_OpenedPopups.Get(m_OpenedPopups.Count() - 1);
      m_Popups.Get(popup_curr_id).Show(false);
    }
 
    m_OpenedPopups.Insert(popup_id);
 
    UIPopupScript popup = m_Popups.Get(popup_id);
 
    popup.Show(true);
    popup.OnOpen(param);
 
    return popup;
  }
 
  //============================================
  // PopupBack
  //============================================
  UIPopupScript PopupBack()
  {
    if (m_OpenedPopups.Count() > 0)
    {
      int popup_curr_id = m_OpenedPopups.Get(m_OpenedPopups.Count() - 1);
 
      m_Popups.Get(popup_curr_id).Show(false);
      m_Popups.Get(popup_curr_id).OnClose();
 
      m_OpenedPopups.Remove(m_OpenedPopups.Count() - 1);
 
      if (m_OpenedPopups.Count() > 0)
      {
        int ppp_id = m_OpenedPopups.Get(m_OpenedPopups.Count() - 1);
        m_Popups.Get(ppp_id).Show(true);
        m_Popups.Get(ppp_id).OnOpen(NULL);
 
        return m_Popups.Get(ppp_id);
      }
    }
 
    m_WgtPopupsMain.Show(false);
    m_WgtPopupsBg.Show(false);
 
    return NULL;
  }
 
  //============================================
  // PopupCloseAll
  //============================================
  void PopupCloseAll()
  {
    if (m_OpenedPopups.Count() > 0)
    {
      int popup_curr_id = m_OpenedPopups.Get(m_OpenedPopups.Count() - 1);
 
      m_Popups.Get(popup_curr_id).Show(false);
      m_Popups.Get(popup_curr_id).OnClose();
 
      m_OpenedPopups.Clear();
    }
  }
 
 
  //============================================
  // ToggleVisibility (Show/Hide of editor)
  //============================================
  void ToggleVisibility()
  {
    m_WgtRoot.Show(m_ModuleSceneManager.IsOpened());
  }
 
  //============================================
  // Refresh
  //============================================
  override void Refresh()
  {
    UpdateListObjects();
 
    string class_name = "n/a";
    string pos_x = "n/a";
    string pos_y = "n/a";
    string pos_z = "n/a";
    string rot = "n/a";
    string hlt = "n/a";
 
    // Clear attachments
    for (int i = 0; i < m_PrWidgetsAttachments.Count(); ++i)
      m_PrWidgetsAttachments.Get(i).Hide();
 
    if (m_ModuleSceneManager.GetSelectedSceneObject())
    {
      SceneObject obj = m_ModuleSceneManager.GetSelectedSceneObject();
      vector v = obj.GetPosition();
 
      class_name = obj.GetTypeName();
      pos_x = v[0].ToString();
      pos_y = v[1].ToString();
      pos_z = v[2].ToString();
      rot = obj.GetRotation().ToString();
      hlt = obj.GetHealth().ToString();
 
      ref TStringArray attachments_slots = obj.GetConfigAttachments();
 
      float prop_h = 0.03;
      float prop_count = attachments_slots.Count();
      float prop_root_h = prop_h * (prop_count + 1);
      float line_h = 1.0 / (prop_count + 1);
 
      m_PrWgtAttRoot.SetSize(1, prop_root_h);
      m_PrWgtAttTitle.SetSize(1, line_h);
 
 
      EntityAI e = m_ModuleSceneManager.GetSelectedSceneObject().GetObject();
 
      map<string, ref TStringArray> attachments_in_slots = GetItemNamesForSlots(attachments_slots);
 
 
      for (int j = 0; j < attachments_in_slots.Count(); ++j)
      {
        TStringArray attachments_in_slot = attachments_in_slots.GetElement(j);
 
        UIPropertyAttachment ui_prop = GetFreeUIPropertyAttchament();
 
        ui_prop.Show(m_ModuleSceneManager.GetSelectedSceneObject().GetObject(), attachments_in_slots.GetKey(j), attachments_in_slot);
        ui_prop.SetPos(0, (1 + j) * line_h);
        ui_prop.SetSize(1, line_h);
      }
 
      m_WgtBtnEditInitScript.Enable(true);
    }
    else
      m_WgtBtnEditInitScript.Enable(false);
 
    m_PrWgtClassName.SetText(class_name);
    m_PrWgtPoxX.SetText(pos_x);
    m_PrWgtPoxY.SetText(pos_y);
    m_PrWgtPoxZ.SetText(pos_z);
    m_PrWgtDir.SetText(rot);
    m_PrWgtDmg.SetText(hlt);
 
    m_SlWgtLoadedScene.SetText("Loaded Scene: " + m_ModuleSceneManager.SceneGetName());
 
    //Ruler
    if (m_ModuleSceneManager.IsRulerActivated())
      m_WgtBtnDeleteRuler.SetColor(0xFF5DE028);
    else
      m_WgtBtnDeleteRuler.SetColor(0xFFFFFFFF);
 
  }
 
  void SceneEditorCommand(Param params)
  {
    Param2<int, Param> p = Param2<int, Param>.Cast(params);
    int cmd_id = p.param1;
 
    switch (cmd_id)
    {
    case PluginSceneManager.SCENE_EDITOR_CMD_REFRESH:
      Refresh();
      break;
 
    case PluginSceneManager.SCENE_EDITOR_CMD_SAVE:
      m_NotifyWgtPanel.SetAlpha(1.0);
      m_NotifyFadeTimer.FadeOut(m_NotifyWgtPanel, 2, true);
      break;
    }
  }
 
 
  //---------------------------------------------------------------------------------
  // >> Protected Scope
  protected Widget m_WgtRoot;
  protected PluginSceneManager m_ModuleSceneManager;
 
  //---------------------------------------------------------------------------------
  // >> protected Scope
 
  // Top Panel
  protected ButtonWidget m_WgtBtnSceneManager;
  protected ButtonWidget m_WgtBtnSceneSettings;
  protected ButtonWidget m_WgtBtnSceneSave;
  protected ButtonWidget m_WgtBtnEditorSettings;
  protected ButtonWidget m_WgtBtnDeleteRuler;
 
  // Popups
  protected Widget m_WgtPopupsMain;
  protected Widget m_WgtPopupsBg;
  protected ref TIntArray m_OpenedPopups;
  protected ref map<int, ref UIPopupScript> m_Popups;
 
  // Scene Object List
  protected TextWidget m_SlWgtLoadedScene;
  protected string m_SlSelectedClass;
  protected ref map<int, SceneObject> m_SlObjectsList;
  protected TextListboxWidget m_SlWgtLbxObjectsList;
  protected EditBoxWidget m_SlWgtEbxFilter;
  protected ButtonWidget m_SlWgtSelect;
  protected ButtonWidget m_SlWgtFocus;
 
  // Config Class List
  protected string m_ClSelectedClass;
  protected ref TStringArray m_ClClassesList;
  protected EditBoxWidget m_ClWgtEbxFilter;
  protected TextListboxWidget m_ClWgtLbxClassesList;
  protected ButtonWidget m_ClWgtButtonAddAtt;
 
  // Properties
  protected TextWidget m_PrWgtClassName;
  protected EditBoxWidget m_PrWgtPoxX;
  protected EditBoxWidget m_PrWgtPoxY;
  protected EditBoxWidget m_PrWgtPoxZ;
  protected EditBoxWidget m_PrWgtDir;
  protected EditBoxWidget m_PrWgtDmg;
  protected ButtonWidget m_WgtBtnEditInitScript;
  protected Widget m_PrWgtAttRoot;
  protected Widget m_PrWgtAttTitle;
 
  protected ref array<ref UIPropertyAttachment> m_PrWidgetsAttachments;
 
  // Notify
  protected ref WidgetFadeTimer m_NotifyFadeTimer;
  protected Widget m_NotifyWgtPanel;
 
  //Other
  protected TextListboxWidget m_PresetsTextListbox;
  protected TextListboxWidget m_PresetItemsTextListbox;
  protected ButtonWidget m_PresetAddItemtButton;
  protected ButtonWidget m_PresetRemoveItemButton;
  protected ButtonWidget m_SpawnOnGroundButton;
  protected ButtonWidget m_SpawnInInventoryButton;
  protected ButtonWidget m_SpawnAsAttachmentButton;
  protected ButtonWidget m_UpButton;
  protected ButtonWidget m_DownButton;
  protected ButtonWidget m_PresetNewButton;
  protected ButtonWidget m_PresetDeleteButton;
  protected ButtonWidget m_PresetRenameButton;
  protected ButtonWidget m_PresetSetDefaultButton;
  protected ButtonWidget m_CopyToClipboardButton;
  protected EditBoxWidget m_DamageEditBox;
  protected EditBoxWidget m_QuantityEditBox;
  protected EditBoxWidget m_SpawnDistanceEditBox;
  protected EditBoxWidget m_ConfigsButton;
  protected Widget m_WgtPnlWrapper;
  protected ButtonWidget m_WgtBtnLeftPresets;
  protected ButtonWidget m_WgtBtnPositionManager;
 
  protected string m_SelectedObject;
  protected bool m_SelectedObjectIsPreset;
  protected PluginDeveloper m_Developer;
  protected UIPopupScriptPositionManager m_PopupScriptPositionManager;
  protected PluginConfigDebugProfileFixed m_ConfigDebugProfileFixed;
  protected PluginConfigDebugProfile m_ConfigDebugProfile;
 
  //---- Functions
  protected void RefreshByLocalProfile();
 
  //--------------------------------------------
  // UpdateListObjects
  //--------------------------------------------
  private void UpdateListObjects()
  {
    m_SlObjectsList = GetFiltredSceneObjects(m_SlWgtEbxFilter.GetText(), m_SlObjectsList);
 
    m_SlWgtLbxObjectsList.ClearItems();
 
    int row = -1;
    SceneObject selected_object = m_ModuleSceneManager.GetSelectedSceneObject();
 
    for (int i = 0; i < m_SlObjectsList.Count(); ++i)
    {
      SceneObject scene_obj = m_SlObjectsList.GetElement(i);
 
      if (selected_object != NULL && selected_object == scene_obj)
        row = i;
 
      m_SlWgtLbxObjectsList.AddItem(scene_obj.GetTypeName(), NULL, 0);
    }
 
    m_SlWgtLbxObjectsList.SelectRow(row);
  }
 
  //--------------------------------------------
  // UpdateListClasses
  //--------------------------------------------
  protected void UpdateListClasses()
  {
    m_ClClassesList = GetFiltredConfigClasses(m_ClWgtEbxFilter.GetText(), m_ClClassesList);
 
    m_ClWgtLbxClassesList.ClearItems();
 
    for (int i = 0; i < m_ClClassesList.Count(); ++i)
      m_ClWgtLbxClassesList.AddItem(m_ClClassesList.Get(i), NULL, 0);
  }
 
  //--------------------------------------------
  // GetFiltredSceneObjects
  //--------------------------------------------
  protected map<int, SceneObject> GetFiltredSceneObjects(string search_string, map<int, SceneObject> array_ret)
  {
    array<ref SceneObject> scene_objects = m_ModuleSceneManager.GetSceneObjectsAll();
 
    search_string.ToLower();
 
    array_ret.Clear();
 
    if (scene_objects != NULL)
    {
      for (int i = 0; i < scene_objects.Count(); ++i)
      {
        SceneObject sc_obj = scene_objects.Get(i);
 
        string obj_name = sc_obj.GetTypeName();
 
        obj_name.ToLower();
 
        if (obj_name.Contains(search_string))
          array_ret.Insert(i, sc_obj);
      }
    }
 
    return array_ret;
  }
 
  //--------------------------------------------
  // GetFiltredConfigClasses
  //--------------------------------------------
  TStringArray GetFiltredConfigClasses(string search_string, TStringArray array_ret)
  {
    TStringArray searching_in = new TStringArray;
    searching_in.Insert(CFG_VEHICLESPATH);
    searching_in.Insert(CFG_WEAPONSPATH);
    searching_in.Insert(CFG_MAGAZINESPATH);
 
    array_ret.Clear();
 
    search_string.ToLower();
 
    for (int s = 0; s < searching_in.Count(); ++s)
    {
      string config_path = searching_in.Get(s);
 
      int objects_count = g_Game.ConfigGetChildrenCount(config_path);
      for (int i = 0; i < objects_count; i++)
      {
        string childName;
        g_Game.ConfigGetChildName(config_path, i, childName);
 
        int scope = g_Game.ConfigGetInt(config_path + " " + childName + " scope");
        if (scope == 0)
          continue;
 
        string nchName = childName;
        nchName.ToLower();
 
        if (nchName.Contains(search_string))
          array_ret.Insert(childName);
      }
    }
 
    return array_ret;
  }
 
  //--------------------------------------------
  // PopupClose
  //--------------------------------------------
  private void PopupClose(int popup_id)
  {
  }
 
  //--------------------------------------------
  // PopupCloseAll
  //--------------------------------------------
  private void PopupHideAll()
  {
    for (int i = 0; i < m_Popups.Count(); ++i)
      m_Popups.Get(i).Show(false);
 
    m_WgtPopupsMain.Show(false);
    m_WgtPopupsBg.Show(false);
  }
 
  //--------------------------------------------
  // ComponentsOnClick
  //--------------------------------------------
  private bool ComponentsOnClick(Widget w, int x, int y, int button)
  {
    for (int i = 0; i < m_Popups.Count(); ++i)
    {
      if (m_Popups.Get(i).OnClick(w, x, y, button))
        return true;
    }
 
    for (int j = 0; j < m_PrWidgetsAttachments.Count(); ++j)
    {
      if (m_PrWidgetsAttachments.Get(j).OnClick(w, x, y, button))
        return true;
    }
 
    return false;
  }
 
  //--------------------------------------------
  // ComponentsOnChange
  //--------------------------------------------
  private bool ComponentsOnChange(Widget w, int x, int y, bool finished)
  {
    for (int i = 0; i < m_Popups.Count(); ++i)
    {
      if (m_Popups.Get(i).OnChange(w, x, y, finished))
        return true;
    }
 
    return false;
  }
 
  //--------------------------------------------
  // GetFreeUIPropertyAttchament
  //--------------------------------------------
  UIPropertyAttachment GetFreeUIPropertyAttchament()
  {
    for (int i = 0; i < m_PrWidgetsAttachments.Count(); ++i)
    {
      UIPropertyAttachment ui_comp = m_PrWidgetsAttachments.Get(i);
 
      if (!ui_comp.IsVisible())
        return ui_comp;
    }
 
    UIPropertyAttachment ui_prop = new UIPropertyAttachment(m_PrWgtAttRoot);
    m_PrWidgetsAttachments.Insert(ui_prop);
 
    return ui_prop;
  }
 
  //--------------------------------------------
  // GetItemNamesForSlots
  //--------------------------------------------
  private map<string, ref TStringArray> GetItemNamesForSlots(TStringArray slots)
  {
    TStringArray searching_in = new TStringArray;
    searching_in.Insert(CFG_VEHICLESPATH);
    searching_in.Insert(CFG_WEAPONSPATH);
    searching_in.Insert(CFG_MAGAZINESPATH);
 
    map<string, ref TStringArray> array_ret = new map<string, ref TStringArray>;
 
    for (int m = 0; m < slots.Count(); ++m)
      array_ret.Insert(slots.Get(m), new TStringArray);
 
    TStringArray inv_slots = new TStringArray;
    string inv_slot;
    string childName;
 
    for (int s = 0; s < searching_in.Count(); ++s)
    {
      string config_path = searching_in.Get(s);
 
      int objects_count = g_Game.ConfigGetChildrenCount(config_path);
      for (int i = 0; i < objects_count; i++)
      {
        g_Game.ConfigGetChildName(config_path, i, childName);
 
        g_Game.ConfigGetTextArray(config_path + " " + childName + " inventorySlot", inv_slots);
 
        if (inv_slots.Count() > 0)
        {
          for (int j = 0; j < inv_slots.Count(); ++j)
          {
            inv_slot = "";
            inv_slot = inv_slots.Get(j);
 
            for (int k = 0; k < slots.Count(); ++k)
            {
              string finding_slot_type = slots.Get(k);
 
              if (inv_slot == finding_slot_type)
                array_ret.Get(finding_slot_type).Insert(childName);
            }
          }
        }
        else
        {
          inv_slot = "";
          g_Game.ConfigGetText(config_path + " " + childName + " inventorySlot", inv_slot);
 
          if (inv_slot != "")
          {
            for (int l = 0; l < slots.Count(); ++l)
            {
              string finding_slot_type_2 = slots.Get(l);
 
              if (inv_slot == finding_slot_type_2)
                array_ret.Get(finding_slot_type_2).Insert(childName);
            }
          }
        }
      }
    }
 
    return array_ret;
  }
}