Download scripts/3_Game/DayZ/GUI/Effects/RadialMenu.c from FelonieZ/DayZ_Scripts: direct link, hf CLI and curl.
- Browser
- Download file 17.9 kB
-
https://huggingface.co/datasets/FelonieZ/DayZ_Scripts/resolve/main/scripts/3_Game/DayZ/GUI/Effects/RadialMenu.c
- Command line
-
hf download hf://datasets/FelonieZ/DayZ_Scripts/scripts/3_Game/DayZ/GUI/Effects/RadialMenu.c
-
curl -L -o RadialMenu.c https://huggingface.co/datasets/FelonieZ/DayZ_Scripts/resolve/main/scripts/3_Game/DayZ/GUI/Effects/RadialMenu.c
17.9 kB
| enum RadialMenuControlType | |
| { | |
| MOUSE, | |
| CONTROLLER | |
| } | |
| class RadialMenu : ScriptedWidgetEventHandler | |
| { | |
| protected Widget m_Parent; | |
| protected Widget m_ItemCardsContainer; | |
| protected Widget m_RadialSelector; | |
| protected ImageWidget m_RadialSelectorImage; | |
| protected ImageWidget m_RadialSelectorPointerImage; | |
| protected int m_RadialSelectorOriginalColor; | |
| protected int m_RadialSelectorDisabledColor; | |
| protected Widget m_SelectedObject; | |
| protected ref map<Widget, float> m_RadialItemCards; | |
| protected float m_AngleRadOffset; | |
| protected ref Timer m_UpdateTimer; | |
| //widget | |
| static const string RADIAL_SELECTOR = "RadialSelector"; | |
| static const string RADIAL_SELECTOR_IMAGE = "SelectorImage"; | |
| static const string RADIAL_SELECTOR_POINTER = "SelectorPointer"; | |
| static const string RADIAL_DELIMITER_CONTAINER = "RadialDelimiterContainer"; | |
| static const string RADIAL_ITEM_CARD_CONTAINER = "RadialItemCardContainer"; | |
| //controls | |
| protected RadialMenuControlType m_ControlType; | |
| private UAIDWrapper m_SelectInputWrapper; | |
| private UAIDWrapper m_BackInputWrapper; | |
| protected float m_ControllerAngle; | |
| protected float m_ControllerTilt; | |
| //controller | |
| protected int m_ControllerTimout; | |
| protected bool m_IsControllerTimoutEnabled = true; //enables/disables controller deselect timeout reset | |
| protected const float CONTROLLER_DESELECT_TIMEOUT = 1000; //timeout [ms] after which selection is automatically deselect when controller is not active | |
| protected const float CONTROLLER_TILT_TRESHOLD_SELECT = 0.8; //tilt value (0.0-1.0) for controller sticks after which the selection will be selected | |
| protected const float CONTROLLER_TILT_TRESHOLD_EXECUTE = 1.0; //tilt value (0.0-1.0) for controller sticks after which the selection will be executed | |
| //mouse | |
| protected bool m_WidgetInitialized; | |
| protected const float MOUSE_SAFE_ZONE_RADIUS = 120; //Radius [px] of safe zone where every previous selection is deselected | |
| //References | |
| protected float m_RadiusOffset; //Radius [% of the main container size] | |
| protected float m_ExecuteDistanceOffset; //Distance offset [% of the main container size] after which the selection will be automatically executed | |
| protected float m_OffsetFromTop; //first item in the menu won't be directly on top but offset by a rad angle value (clock-wise) | |
| protected float m_ItemCardRadiusOffset; //Radius [% of the main container size] for item cards | |
| protected string m_DelimiterLayout; //layout file name with path | |
| ref UIScriptedMenu m_RegisteredClass; | |
| ref static RadialMenu m_Instance; | |
| /* | |
| RADIAL MENU EVENTS | |
| Mouse: | |
| OnMouseSelect | |
| OnMouseDeselect | |
| OnMouseExecute - unused, press events used instead | |
| OnMousePressLeft | |
| OnMousePressRight | |
| Controller: | |
| OnControllerSelect | |
| OnControllerDeselect | |
| OnControllerExecute - unused, press events used instead | |
| OnControllerPressSelect | |
| OnControllerPressBack | |
| Common: | |
| OnControlsChanged - controls has been changed (mouse<->controller) | |
| */ | |
| //============================================ | |
| // RadialMenu | |
| //============================================ | |
| void RadialMenu() | |
| { | |
| m_Instance = this; | |
| //set default control type | |
| Input inp = GetGame().GetInput(); | |
| if (inp && inp.IsEnabledMouseAndKeyboardEvenOnServer()) | |
| { | |
| m_ControlType = RadialMenuControlType.MOUSE; | |
| } | |
| else | |
| { | |
| m_ControlType = RadialMenuControlType.CONTROLLER; | |
| } | |
| m_ControlType = RadialMenuControlType.MOUSE; | |
| m_SelectInputWrapper = GetUApi().GetInputByID(UAUISelect).GetPersistentWrapper(); | |
| m_BackInputWrapper= GetUApi().GetInputByID(UAUIBack).GetPersistentWrapper(); | |
| //radial cards | |
| m_RadialItemCards = new map<Widget, float>; | |
| m_UpdateTimer = new Timer(); | |
| m_UpdateTimer.Run(0.01, this, "Update", NULL, true); | |
| } | |
| void ~RadialMenu() | |
| { | |
| } | |
| static RadialMenu GetInstance() | |
| { | |
| return m_Instance; | |
| } | |
| //Set handler | |
| void OnWidgetScriptInit(Widget w) | |
| { | |
| m_ItemCardsContainer = w.FindAnyWidget(RADIAL_ITEM_CARD_CONTAINER); | |
| m_RadialSelector = w.FindAnyWidget(RADIAL_SELECTOR); | |
| m_RadialSelectorImage = ImageWidget.Cast(m_RadialSelector.FindAnyWidget(RADIAL_SELECTOR_IMAGE)); | |
| m_RadialSelectorPointerImage = ImageWidget.Cast(m_RadialSelector.FindAnyWidget(RADIAL_SELECTOR_POINTER)); | |
| m_RadialSelectorOriginalColor = m_RadialSelectorImage.GetColor(); | |
| m_RadialSelectorDisabledColor = ARGB(255,150,150,150); | |
| //parent | |
| m_Parent = w; | |
| m_Parent.SetHandler(this); | |
| } | |
| //controls | |
| void SetControlType(RadialMenuControlType type) | |
| { | |
| if (m_ControlType != type) | |
| { | |
| m_ControlType = type; | |
| GetGame().GameScript.CallFunction(m_RegisteredClass, "OnControlsChanged", NULL, type); | |
| } | |
| } | |
| bool IsUsingMouse() | |
| { | |
| if (m_ControlType == RadialMenuControlType.MOUSE) | |
| { | |
| return true; | |
| } | |
| return false; | |
| } | |
| bool IsUsingController() | |
| { | |
| if (m_ControlType == RadialMenuControlType.CONTROLLER) | |
| { | |
| return true; | |
| } | |
| return false; | |
| } | |
| void SetWidgetInitialized(bool state) | |
| { | |
| m_WidgetInitialized = state; | |
| } | |
| bool IsWidgetInitialized() | |
| { | |
| return m_WidgetInitialized; | |
| } | |
| //============================================ | |
| // Setup | |
| //============================================ | |
| void RegisterClass(UIScriptedMenu class_name) | |
| { | |
| m_RegisteredClass = class_name; | |
| if (m_UpdateTimer && !m_UpdateTimer.IsRunning()) | |
| m_UpdateTimer.Run(0.01, this, "Update", NULL, true); | |
| } | |
| //Set radial menu parameters | |
| //Radius offset [% of the main container size] | |
| void SetRadiusOffset(float radius_offset) | |
| { | |
| m_RadiusOffset = radius_offset; | |
| } | |
| //Distance offset [% of the main container size] after which the selection will be automatically executed | |
| void SetExecuteDistOffset(float execute_dist_offset) | |
| { | |
| m_ExecuteDistanceOffset = execute_dist_offset; | |
| } | |
| //First item in the menu won't be directly on top but offset by a rad angle value (clock-wise) | |
| void SetOffsetFromTop(float offset_from_top) | |
| { | |
| m_OffsetFromTop = offset_from_top; | |
| } | |
| //Radius [% of the main container size] for item cards | |
| void SetItemCardRadiusOffset(float item_card_radius_offset) | |
| { | |
| m_ItemCardRadiusOffset = item_card_radius_offset; | |
| } | |
| //Enable/Disable controller timeout | |
| void ActivateControllerTimeout(bool state) | |
| { | |
| m_IsControllerTimoutEnabled = state; | |
| } | |
| void SetWidgetProperties(string delimiter_layout) | |
| { | |
| m_DelimiterLayout = delimiter_layout; | |
| } | |
| //============================================ | |
| // Visual | |
| //============================================ | |
| //hide_selector => shows/hides radial selector when refreshing radial menu | |
| void Refresh(bool hide_selector = true) | |
| { | |
| int item_cards_count = GetItemCardsCount(); | |
| if (item_cards_count > 0) | |
| m_AngleRadOffset = 2 * Math.PI / item_cards_count; | |
| float angle_rad = -Math.PI / 2; | |
| //--PARAM top offset-- | |
| if (m_OffsetFromTop != 0) | |
| { | |
| angle_rad = angle_rad + m_OffsetFromTop; | |
| } | |
| //-------------------- | |
| //delete all delimiters | |
| Widget delimiters_panel = m_Parent.FindAnyWidget(RADIAL_DELIMITER_CONTAINER); | |
| if (delimiters_panel) | |
| { | |
| Widget del_child = delimiters_panel.GetChildren(); | |
| while (del_child) | |
| { | |
| Widget child_to_destroy1 = del_child; | |
| del_child = del_child.GetSibling(); | |
| delete child_to_destroy1; | |
| } | |
| } | |
| //Position item cards, crate radial delimiters | |
| Widget item_cards_panel = m_Parent.FindAnyWidget(RADIAL_ITEM_CARD_CONTAINER); | |
| Widget item_card = item_cards_panel.GetChildren(); | |
| //get radius | |
| float original_r = GetRadius(); | |
| float item_cards_r = original_r; | |
| //--PARAM top offset--.... | |
| if (m_ItemCardRadiusOffset != 0) | |
| { | |
| item_cards_r = item_cards_r * m_ItemCardRadiusOffset; | |
| if (item_cards_r < 0) item_cards_r = 0; //min radius is 0 | |
| } | |
| m_RadialItemCards.Clear(); | |
| for (int i = 0; i < item_cards_count; ++i) | |
| { | |
| //position item cards | |
| if (item_card) | |
| { | |
| //creates circle from simple widget items | |
| float pos_x = item_cards_r * Math.Cos(angle_rad); | |
| float pos_y = item_cards_r * Math.Sin(angle_rad); | |
| pos_x = pos_x / original_r; | |
| pos_y = pos_y / original_r; | |
| item_card.SetPos(pos_x, pos_y); | |
| //store item card | |
| m_RadialItemCards.Insert(item_card, angle_rad); | |
| //get next child | |
| item_card = item_card.GetSibling(); | |
| } | |
| //------------------------- | |
| //create delimiter | |
| if (item_cards_count > 1 && delimiters_panel && m_DelimiterLayout) | |
| { | |
| Widget delimiter_widget = GetGame().GetWorkspace().CreateWidgets(m_DelimiterLayout, delimiters_panel); | |
| float delim_angle_rad = angle_rad + (m_AngleRadOffset / 2); | |
| delimiter_widget.SetPos(0, 0); | |
| delimiter_widget.SetRotation(0, 0, GetAngleInDegrees(delim_angle_rad) + 90); | |
| } | |
| //calculate next angle | |
| angle_rad += m_AngleRadOffset; | |
| } | |
| //hide selector on refresh | |
| if (hide_selector) | |
| { | |
| HideRadialSelector(); | |
| } | |
| } | |
| //Radial selector | |
| protected void ShowRadialSelector(Widget selected_item) | |
| { | |
| if (m_RadialSelector && selected_item) | |
| { | |
| int item_count = m_RadialItemCards.Count(); | |
| if (item_count > 1) | |
| { | |
| int angle_deg = GetAngleInDegrees(m_RadialItemCards.Get(selected_item)); | |
| m_RadialSelector.SetRotation(0, 0, angle_deg + 90); //rotate widget according to its desired rotation | |
| //set radial selector size | |
| float progress = (1 / item_count) * 2; | |
| m_RadialSelectorImage.SetMaskProgress(progress); | |
| m_RadialSelector.Show(true); | |
| bool grey_selector = selected_item.GetFlags() & WidgetFlags.DISABLED; | |
| if (!grey_selector) | |
| { | |
| m_RadialSelectorImage.SetColor(m_RadialSelectorDisabledColor); | |
| m_RadialSelectorPointerImage.SetColor(m_RadialSelectorDisabledColor); | |
| } | |
| else | |
| { | |
| m_RadialSelectorImage.SetColor(m_RadialSelectorOriginalColor); | |
| m_RadialSelectorPointerImage.SetColor(m_RadialSelectorOriginalColor); | |
| } | |
| } | |
| } | |
| } | |
| protected void HideRadialSelector() | |
| { | |
| if (m_RadialSelector) | |
| { | |
| m_RadialSelector.Show(false); | |
| } | |
| } | |
| //============================================ | |
| // Widget size calculations | |
| //============================================ | |
| protected int GetItemCardsCount() | |
| { | |
| Widget child = m_ItemCardsContainer.GetChildren(); | |
| int count = 0; | |
| while (child) | |
| { | |
| ++count; | |
| child = child.GetSibling(); | |
| } | |
| return count; | |
| } | |
| protected float GetRadius() | |
| { | |
| float radius = Math.AbsFloat(GetParentMinSize() * 0.5); | |
| //PARAM --radius-- | |
| if (m_RadiusOffset > 0) | |
| { | |
| return radius * m_RadiusOffset; | |
| } | |
| //---------------- | |
| return radius; | |
| } | |
| protected void GetParentCenter(out float center_x, out float center_y) | |
| { | |
| if (m_Parent) | |
| { | |
| float wx; | |
| float wy; | |
| m_Parent.GetScreenPos(wx, wy); | |
| float ww; | |
| float wh; | |
| m_Parent.GetScreenSize(ww, wh); | |
| center_x = wx + ww / 2; //center | |
| center_y = wy + wh / 2; | |
| } | |
| } | |
| protected float GetParentMinSize() | |
| { | |
| if (m_Parent) | |
| { | |
| float size_x; | |
| float size_y; | |
| m_Parent.GetScreenSize(size_x, size_y); | |
| return Math.Min(size_x, size_y); | |
| } | |
| return 0; | |
| } | |
| //============================================ | |
| // Angle calculations | |
| //============================================ | |
| //get object by angle (degrees) | |
| protected Widget GetObjectByDegAngle(float deg_angle) | |
| { | |
| for (int i = 0; i < m_RadialItemCards.Count(); ++i) | |
| { | |
| Widget w = m_RadialItemCards.GetKey(i); | |
| float w_angle = GetAngleInDegrees(m_RadialItemCards.Get(w)); | |
| float offset = GetAngleInDegrees(m_AngleRadOffset) / 2; | |
| float min_angle = w_angle - offset; | |
| float max_angle = w_angle + offset; | |
| if (min_angle < 0) min_angle += 360; //clamp 0-360 | |
| if (max_angle > 360) max_angle -= 360; | |
| if (min_angle > max_angle) //angle radius is in the cycling point 360-> | |
| { | |
| if (min_angle <= deg_angle) //is cursor position also before this point | |
| { | |
| if (deg_angle > max_angle) | |
| { | |
| return w; | |
| } | |
| } | |
| else //is cursor position after this point | |
| { | |
| if (deg_angle < max_angle) | |
| { | |
| return w; | |
| } | |
| } | |
| } | |
| else | |
| { | |
| if (deg_angle >= min_angle && deg_angle < max_angle) //min, max angles are within 0-360 radius | |
| { | |
| return w; | |
| } | |
| } | |
| } | |
| return NULL; | |
| } | |
| //returns GUI compatible mouse-to-parent angle | |
| protected float GetMousePointerAngle() | |
| { | |
| int mouse_x; | |
| int mouse_y; | |
| GetMousePos(mouse_x, mouse_y); | |
| float center_x; | |
| float center_y; | |
| GetParentCenter(center_x, center_y); | |
| float tan_x = mouse_x - center_x; | |
| float tan_y = mouse_y - center_y; | |
| float angle = Math.Atan2(tan_y, tan_x); | |
| return angle; | |
| } | |
| //returns distance from parent center | |
| protected float GetMouseDistance() | |
| { | |
| int mouse_x; | |
| int mouse_y; | |
| GetMousePos(mouse_x, mouse_y); | |
| float center_x; | |
| float center_y; | |
| GetParentCenter(center_x, center_y); | |
| float distance = vector.Distance(Vector(mouse_x, mouse_y, 0), Vector(center_x, center_y, 0)); | |
| return distance; | |
| } | |
| //return angle 0-360 deg | |
| protected float GetAngleInDegrees(float rad_angle) | |
| { | |
| float rad_deg = rad_angle * Math.RAD2DEG; | |
| int angle_mp = rad_deg / 360; | |
| if (rad_deg < 0) | |
| { | |
| rad_deg = rad_deg - (360 * angle_mp); | |
| rad_deg += 360; | |
| } | |
| return rad_deg; | |
| } | |
| //============================================ | |
| // Update | |
| //============================================ | |
| //mouse | |
| int last_time = -1; | |
| protected void Update() | |
| { | |
| if (this && !m_RegisteredClass) | |
| { | |
| m_UpdateTimer.Stop(); | |
| return; | |
| } | |
| //get delta time | |
| if (last_time < 0) | |
| { | |
| last_time = GetGame().GetTime(); | |
| } | |
| int delta_time = GetGame().GetTime() - last_time; | |
| last_time = GetGame().GetTime(); | |
| //controls | |
| if (this && m_RegisteredClass && m_RegisteredClass.IsVisible()) | |
| { | |
| //mouse controls | |
| if (IsUsingMouse() && m_WidgetInitialized) | |
| { | |
| float mouse_angle = GetMousePointerAngle(); | |
| float mouse_distance = GetMouseDistance(); | |
| //--PARAM --safe zone radius-- | |
| if (mouse_distance <= MOUSE_SAFE_ZONE_RADIUS) | |
| { | |
| //Deselect | |
| GetGame().GameScript.CallFunction(m_RegisteredClass, "OnMouseDeselect", NULL, m_SelectedObject); | |
| m_SelectedObject = NULL; | |
| //hide selector | |
| HideRadialSelector(); | |
| } | |
| else | |
| { | |
| //Deselect | |
| GetGame().GameScript.CallFunction(m_RegisteredClass, "OnMouseDeselect", NULL, m_SelectedObject); | |
| //Select | |
| m_SelectedObject = GetObjectByDegAngle(GetAngleInDegrees(mouse_angle)); | |
| GetGame().GameScript.CallFunction(m_RegisteredClass, "OnMouseSelect", NULL, m_SelectedObject); | |
| //show selector | |
| ShowRadialSelector(m_SelectedObject); | |
| } | |
| } | |
| //controller controls | |
| else if (IsUsingController()) | |
| { | |
| UpdataControllerInput(); | |
| //Controller tilt | |
| if (m_ControllerAngle > -1 && m_ControllerTilt > -1) | |
| { | |
| //Right analogue stick | |
| Widget w_selected = GetObjectByDegAngle(m_ControllerAngle); | |
| //Select | |
| if (w_selected) | |
| { | |
| if (w_selected != m_SelectedObject) | |
| { | |
| if (m_ControllerTilt >= CONTROLLER_TILT_TRESHOLD_SELECT) | |
| { | |
| //Deselect | |
| GetGame().GameScript.CallFunction(m_RegisteredClass, "OnControllerDeselect", NULL, m_SelectedObject); | |
| //Select new object | |
| m_SelectedObject = w_selected; | |
| GetGame().GameScript.CallFunction(m_RegisteredClass, "OnControllerSelect", NULL, m_SelectedObject); | |
| //show selector | |
| ShowRadialSelector(m_SelectedObject); | |
| } | |
| } | |
| } | |
| else | |
| { | |
| GetGame().GameScript.CallFunction(m_RegisteredClass, "OnControllerDeselect", NULL, m_SelectedObject); | |
| m_SelectedObject = NULL; | |
| //hide selector | |
| HideRadialSelector(); | |
| } | |
| } | |
| //if controller is giving no feedback | |
| else | |
| { | |
| if (m_IsControllerTimoutEnabled) | |
| { | |
| m_ControllerTimout += delta_time; | |
| if (m_ControllerTimout >= CONTROLLER_DESELECT_TIMEOUT) | |
| { | |
| GetGame().GameScript.CallFunction(m_RegisteredClass, "OnControllerDeselect", NULL, m_SelectedObject); | |
| m_SelectedObject = NULL; | |
| //hide selector | |
| HideRadialSelector(); | |
| m_ControllerTimout = 0; //reset controller timeout | |
| } | |
| } | |
| } | |
| m_ControllerAngle = -1; //reset angle and tilt | |
| m_ControllerTilt = -1; | |
| } | |
| m_WidgetInitialized = true; | |
| } | |
| } | |
| float NormalizeInvertAngle(float angle) | |
| { | |
| float new_angle = 360 - angle; | |
| int angle_mp = new_angle / 360; | |
| new_angle = new_angle - (360 * angle_mp); | |
| return new_angle; | |
| } | |
| //============================================ | |
| // Controls | |
| //============================================ | |
| void UpdataControllerInput() | |
| { | |
| Input input = GetGame().GetInput(); | |
| //Controller radial | |
| float angle; | |
| float tilt; | |
| input.GetGamepadThumbDirection(GamepadButton.THUMB_RIGHT, angle, tilt); | |
| angle = NormalizeInvertAngle(angle * Math.RAD2DEG); | |
| m_ControllerAngle = angle; | |
| m_ControllerTilt = tilt; | |
| m_ControllerTimout = 0; //reset controller timeout | |
| //Controller buttons | |
| //Select (A,cross) | |
| if (m_SelectInputWrapper.InputP().LocalPress()) | |
| { | |
| GetGame().GameScript.CallFunction(m_RegisteredClass, "OnControllerPressSelect", NULL, m_SelectedObject); | |
| } | |
| //Back (B,circle) | |
| if (m_BackInputWrapper.InputP().LocalPress()) | |
| { | |
| GetGame().GameScript.CallFunction(m_RegisteredClass, "OnControllerPressBack", NULL, m_SelectedObject); | |
| } | |
| } | |
| override bool OnMouseButtonUp(Widget w, int x, int y, int button) | |
| { | |
| if (button == MouseState.LEFT && m_SelectedObject/* && w == m_SelectedObject*/) | |
| { | |
| //Execute | |
| GetGame().GameScript.CallFunction(m_RegisteredClass, "OnMousePressLeft", NULL, m_SelectedObject); | |
| return true; | |
| } | |
| if (button == MouseState.RIGHT) | |
| { | |
| //Back one level | |
| GetGame().GameScript.CallFunction(m_RegisteredClass, "OnMousePressRight", NULL, NULL); | |
| return true; | |
| } | |
| return false; | |
| } | |
| } |