/// <summary>
/// Converts one or more arguments of any type to string in the best way possible.
/// </summary>
/// <param name="what">Arguments that will converted to string.</param>
/// <returns>The string formed by the given arguments.</returns>
public static string Str(params Variant[] what)
{
using var whatGodot = new Godot.Collections.Array(what);
NativeFuncs.godotsharp_str((godot_array)whatGodot.NativeValue, out godot_string ret);
using (ret)
return(Marshaling.ConvertStringToManaged(ret));
}
public ConnectAttribute(string nodePath, string signal, Godot.Collections.Array binds, ConnectFlags flags)
{
path = nodePath;
sig = signal;
f = (uint)flags;
b = binds;
}
public override void InitModule()
{
if (excludeBodies == null)
{
excludeBodies = new Godot.Collections.Array();
}
}
public override void _Ready()
{
GetPopup().AddCheckItem("Show Inspector");
GetPopup().AddCheckItem("Show Binder");
GetPopup().AddCheckItem("Show Dock");
GetPopup().AddCheckItem("Big Icons");
Array inspectorActionList = InputMap.GetActionList("inspector_toggle");
InputEventKey inspectorKey = (InputEventKey)inspectorActionList[0];
GetPopup().SetItemAccelerator(0, inspectorKey.GetScancodeWithModifiers());
Array binderActionList = InputMap.GetActionList("binder_toggle");
InputEventKey binderKey = (InputEventKey)binderActionList[0];
GetPopup().SetItemAccelerator(1, binderKey.GetScancodeWithModifiers());
Array dockActionList = InputMap.GetActionList("dock_toggle");
InputEventKey dockKey = (InputEventKey)dockActionList[0];
GetPopup().SetItemAccelerator(2, dockKey.GetScancodeWithModifiers());
GetPopup().Connect("index_pressed", this, nameof(OnItemPressed));
CallDeferred(nameof(SetValues));
}
/// <summary>Sets the current inventory for a given <see cref="GridInventory"/>.</summary>
/// <param name="inventory"><see cref="GridInventory"/> to set the inventory</param>
/// <param name="hero">Is this being set for the <see cref="Hero"/>?</param>
internal static void SetInventoryFromGrid(GridInventory inventory, bool hero = true)
{
Godot.Collections.Array allSlots = inventory.GetChild(0).GetChildren();
List <Item> allItems = new List <Item>();
foreach (ItemSlot slot in allSlots)
{
if (slot?.Item?.Item != new Item() && slot.Item.Item.Name != "Fists")
{
allItems.Add(slot?.Item?.Item);
}
else if (slot?.Item?.Item?.Name == "Fists")
{
slot.RemoveChild(slot.GetChild(1));
slot.Item = new InventoryItem();
}
}
if (hero)
{
CurrentHero.Inventory = allItems;
}
else
{
CurrentEnemy.Inventory = allItems;
}
}
private void FillMesh(ref ArrayMesh mesh, bool calculateBounds, bool autoIndexFormat)
{
if (vertexCount > 65535)
{
if (autoIndexFormat)
{
//FIXME
//mesh.indexFormat = IndexFormat.UInt32;
}
else
{
// BEGIN: Modified by Microsoft Corporation for generic logging purposes.
API.MREAPI.Logger.LogError("A mesh can't have more than 65535 vertices with 16 bit index buffer. Vertex count: " + vertexCount);
// END: Modified by Microsoft Corporation for generic logging purposes.
//FIXME
//mesh.indexFormat = IndexFormat.UInt16;
}
}
else
{
//FIXME
//mesh.indexFormat = IndexFormat.UInt16;
}
//mesh.Name = name;
var array = new Godot.Collections.Array();
array.Resize((int)ArrayMesh.ArrayType.Max);
if (vertices.Count > 0)
{
array[(int)ArrayMesh.ArrayType.Vertex] = vertices.ToArray();
}
if (normals.Count > 0)
{
array[(int)ArrayMesh.ArrayType.Normal] = normals.ToArray();
}
if (tangents.Count > 0)
{
array[(int)ArrayMesh.ArrayType.Tangent] = tangents.ToArray();
}
if (uv.Count > 0)
{
array[(int)ArrayMesh.ArrayType.TexUv] = uv.ToArray();
}
if (uv2.Count > 0)
{
array[(int)ArrayMesh.ArrayType.TexUv2] = uv2.ToArray();
}
if (colors.Count > 0)
{
array[(int)ArrayMesh.ArrayType.Color] = colors.ToArray();
}
if (triangles.Count > 0)
{
array[(int)ArrayMesh.ArrayType.Index] = triangles.ToArray();
}
mesh.AddSurfaceFromArrays(Godot.ArrayMesh.PrimitiveType.Triangles, array);
}
private static Node FindNode(Node Instance, string PathToNode)
{
// First, if we have an explicit node path, try that
Node BoundNode = Instance.GetNodeOrNull(PathToNode);
if (BoundNode != null)
{
return(BoundNode);
}
// Check if we have a child with the same name
Godot.Collections.Array Children = Instance.GetChildren();
foreach (Node Child in Children)
{
if (Child != null && Child.Name == PathToNode)
{
return(Child);
}
}
// Then check if a child has the node instead
foreach (Node Child in Children)
{
BoundNode = FindNode(Child, PathToNode);
if (BoundNode != null)
{
return(BoundNode);
}
}
return(null);
}
public static object WasEmittedWithArgs(Object emitter, string signal, Array arguments, string context)
{
var passed = $"Signal {signal} was emitted from {emitter} with arguments {arguments}";
var failed = $"Signal {signal} was not emitted from {emitter} with arguments {arguments}";
var altFailure = $"Signal {signal} was not emitted from {emitter}";
var success = false;
var result = "";
var watcher = (Object)emitter.GetMeta("watcher");
var data = (IDictionary)watcher.Call("get_data", signal);
if ((int)data["emit_count"] <= 0)
{
success = false;
result = altFailure;
}
else if (FoundMatchingCall(arguments, (IEnumerable)data["calls"]))
{
success = true;
result = passed;
}
else
{
success = false;
result = failed;
}
return(Result(success, passed, result, context));
}
public override void UpdateModule(float delta)
{
if (excludeBodies == null)
{
excludeBodies = new Godot.Collections.Array();
}
}
// Convert an AnatomyEngine mesh to a Godot mesh:
public GodotMeshConverter(UVMesh mesh)
{
// Initialize the arrays that are needed:
Godot.Collections.Array arrays = new Godot.Collections.Array();
arrays.Resize((int)Mesh.ArrayType.Max);
int vertexCount = mesh.VertexList.Count;
Godot.Vector3[] normal_array = new Godot.Vector3[vertexCount];
Godot.Vector3[] vertex_array = new Godot.Vector3[vertexCount];
// Populate the arrays from the input mesh data:
for (int i = 0; i < vertexCount; i++)
{
Numerics.Vector3 vertex = mesh.VertexList[i].Position;
Numerics.Vector3 normal = mesh.VertexList[i].Normal;
vertex_array[i] = new Godot.Vector3(vertex.X, vertex.Y, vertex.Z);
normal_array[i] = new Godot.Vector3(normal.X, normal.Y, normal.Z);
}
// The index list doesn't need to be converted:
int[] index_array = mesh.IndexList.ToArray();
// Put the data arrays in a larger array for Godot to understand what the arrays represent:
arrays[(int)Mesh.ArrayType.Vertex] = vertex_array;
arrays[(int)Mesh.ArrayType.Normal] = normal_array;
arrays[(int)Mesh.ArrayType.Index] = index_array;
// Finally, upload the mesh to GPU:
this.AddSurfaceFromArrays(Mesh.PrimitiveType.Triangles, arrays);
}
//Workaround to get initial focus
public void GuiCollectFocusGroup()
{
_focusGroup.Clear();
_focusGroup = GetTree().GetNodesInGroup("FocusGroup");
//Save references to call main buttons in sections
foreach (Button button in _focusGroup)
{
var groups = button.GetGroups();
if (groups.Contains("MainMenu"))
{
_buttonsSections["MainMenu"] = button;
}
if (groups.Contains("Pause"))
{
_buttonsSections["Pause"] = button;
}
if (groups.Contains("OptionsMain"))
{
_buttonsSections["OptionsMain"] = button;
}
if (groups.Contains("OptionsControls"))
{
_buttonsSections["OptionsControls"] = button;
}
}
}
public static string CallNetworkEvent(object networkeventclass, string eventKey, object[] args)
{
var fields = new Godot.Collections.Dictionary();
// if (((NetworkClass)obj.GetType().GetCustomAttribute(typeof(NetworkClass))).key)
// fields.Add("ObjectType", ((NetworkClass)obj.GetType().GetCustomAttribute(typeof(NetworkClass))).key);
fields.Add("EventType", networkeventclass.GetType().AssemblyQualifiedName);
foreach (var field in networkeventclass.GetType().GetMethods())
{
if (Attribute.IsDefined(field, typeof(NetworkEventProperty)) &&
!((NetworkEventProperty)field.GetCustomAttribute(typeof(NetworkEventProperty))).key.Equals("EventType") &&
!((NetworkEventProperty)field.GetCustomAttribute(typeof(NetworkEventProperty))).key.Equals("args") &&
!((NetworkEventProperty)field.GetCustomAttribute(typeof(NetworkEventProperty))).key.Equals("event") &&
((NetworkEventProperty)field.GetCustomAttribute(typeof(NetworkEventProperty))).key.Equals(eventKey))
{
// fields.Add(((NetworkProperty)field.GetCustomAttribute(typeof(NetworkProperty))).key, field.GetValue(obj));
fields.Add("event", ((NetworkEventProperty)field.GetCustomAttribute(typeof(NetworkEventProperty))).key);
break;
}
}
var eventargs = new Godot.Collections.Array();
foreach (var arg in args)
{
eventargs.Add(arg);
}
fields.Add("args", eventargs);
return(JSON.Print(fields));
}
public override void OnReady <T>(T node, MemberInfo memberInfo)
{
var connectNode = node.GetNode(NodePath);
if (connectNode == null)
{
return;
}
if (!connectNode.HasSignal(SignalName))
{
GD.PushError($"'{connectNode.GetPath()}' does not have a signal '{SignalName}'");
return;
}
GArray binds = null;
var lastParam = ((MethodInfo)memberInfo).GetParameters().LastOrDefault();
if (lastParam?.ParameterType == typeof(ulong) && lastParam.Name == "_triggerId")
{
binds = new GArray {
connectNode.GetInstanceId()
}
}
;
connectNode.Connect(SignalName, node, memberInfo.Name, binds, (uint)Flags);
}
}
/// <summary>
/// Is called by the main process 60x per second, calls the LIDAR detector to collect data, and then resets the LIDAR's oritentation
/// </summary>
public override void _PhysicsProcess(float delta)
{
LIDAR_DRIVER();
Godot.Collections.Array cams = GetTree().GetNodesInGroup("liCams");
foreach (Camera Cam in cams)
{
Cam.Orthonormalize();
}
}
/// <summary>
/// Drives the LIDAR process, writes to file, closes file, handles interpolation logic and LIDAR camera movement control
/// </summary>
public void LIDAR_DRIVER()
{
Godot.Collections.Array gridSpace = gridding();
GetTree().CallGroup("liCams", "RotateObjectLocal", new Godot.Collections.Array {
Vector3.Left, maxLR
});
GetTree().CallGroup("liCams", "RotateObjectLocal", new Godot.Collections.Array {
Vector3.Up, _maxAng
});
string largerSide = (string)gridSpace[3];
int topside = 0;
int sideSide = 0;
switch (largerSide)
{
case "lr":
sideSide = (int)gridSpace[1];
topside = (int)gridSpace[2];
break;
case "ud":
sideSide = (int)gridSpace[2];
topside = (int)gridSpace[1];
break;
default:
break;
}
for (int i = 0; i < topside; i++)
{
if (i > 0)
{
camResetTop();
}
for (int j = 0; j < sideSide; j++)
{
var result = imaging();
if (!result.Equals(new Vector3(0, 0, 0)))
{
var collisionLoc = result;
float collisionDist = distancing(result);
pointCloud.Add(collisionLoc);
distCloud.Add(collisionDist);
}
camMovement((float)gridSpace[0], "down");
}
camMovement((float)gridSpace[0], "left");
}
if (_resolution < 1)
{
interp();
}
writeFile();
}
/// <summary>
/// This gets all the defined tile graphics from the world tilemap and maps their names to their indices.
/// </summary>
private void CreateTileDictionary()
{
Godot.Collections.Array tileIDs = tileMap.TileSet.GetTilesIds();
for (int i = 0; i < tileIDs.Count; i++)
{
int tileID = (int)tileIDs[i];
tileIndexMap.Add(tileMap.TileSet.TileGetName(tileID), tileID);
}
}
public static Godot.Collections.Array ArrayFrom(params object[] objects)
{
Godot.Collections.Array result = new Godot.Collections.Array();
foreach (object obj in objects)
{
result.Add(obj);
}
return(result);
}
/// <summary>
/// This gets all the defined object graphics from the installed object tilemap and maps their names to their indices.
/// </summary>
private void CreateFurnitureDictionary()
{
Godot.Collections.Array installedObjectIDs = furnitureMap.TileSet.GetTilesIds();
for (int i = 0; i < installedObjectIDs.Count; i++)
{
int tileID = (int)installedObjectIDs[i];
furnitureIndexMap.Add(furnitureMap.TileSet.TileGetName(tileID), tileID);
}
}
public ArrayTraverse(System.Array array)
{
this.maxLengths = new int[array.Rank];
for (int i = 0; i < array.Rank; ++i)
{
this.maxLengths[i] = array.GetLength(i) - 1;
}
this.Position = new int[array.Rank];
}
public ICollection <T> GetCollectionFromArray <T>(Array array)
{
List <T> data = new List <T>();
foreach (var d in array)
{
data.Add(this.GetValueFromProperty <T>(d));
}
return(data);
}
private void _ConnectGUIElements()
{
var startingWorld = (PackedScene)ResourceLoader.Load(StartWorldPath);
var newGameParams = new Godot.Collections.Array
{
this._main,
startingWorld
};
this._newGameBtn.Connect("pressed", this._newGameBtn, nameof(NewGameBtn.OnPressed), newGameParams);
}
private void OnSkuDetailsQueryCompleted(Godot.Collections.Array arrSkuDetails)
{
ShowAlert(JSON.Print(arrSkuDetails));
var skuDetails = GooglePlayBillingUtils.ConvertSkuDetailsDictionaryArray(arrSkuDetails);
foreach (var skuDetail in skuDetails)
{
GD.Print($"Sku {skuDetail.Sku}");
}
}
private void setWaveDirection(Godot.Collections.Array <float> new_wave_directions)
{
_wave_directions = new_wave_directions;
if (waves.Count != wave_directions.Count)
{
GD.PrintErr("new wave directions size not equal to waves size");
}
else
{
update_waves();
}
}
private static Button AddButton(string text, Control parent, DebugMenuAction action)
{
Button btn = new Button();
btn.Text = text;
btn.SizeFlagsHorizontal = (int)SizeFlags.Expand + (int)SizeFlags.Fill;
Instance.ActionList.Add(action);
Godot.Collections.Array parameters = new Godot.Collections.Array();
parameters.Add(Instance.ActionList.Count - 1);
btn.Connect("pressed", Instance, nameof(ButtonPressed), parameters);
parent.AddChild(btn);
return(btn);
}
public override void _Ready()
{
slots = new SkillButton[TOTAL_SPELLS];
for (int k = 0; k < TOTAL_SPELLS; k++)
{
SkillButton skill = GetNode <SkillButton>("Skill-" + (k + 1));
Godot.Collections.Array bind = Global.ArrayFrom(k);
skill.Connect("pressed", this, nameof(on_SkillActivated), bind);
skill.Connect("mouse_entered", this, nameof(on_SkillHovered), bind);
skill.Connect("mouse_exited", this, nameof(on_SkillUnHovered), bind);
slots[k] = skill;
}
}
private void OnGooglePlayBilling_SkuDetailsQueryCompleted(Godot.Collections.Array arrSkuDetails)
{
var skuDetails = GooglePlayBillingUtils.ConvertSkuDetailsDictionaryArray(arrSkuDetails);
foreach (var sku in skuDetails)
{
switch (sku.Sku)
{
// our fake potion
case "android.test.purchased":
_buyPotionButton.Text = $"Buy {sku.Price}";
_buyPotionButton.Show();
break;
}
}
}
public GroundNode(MeshInstance meshInstance) : base()
{
this.meshInstance = meshInstance;
Godot.Collections.Array children = meshInstance.GetChildren();
foreach (var child in children)
{
if (child is CollisionObject collider)
{
collider.Connect("input_event", this, nameof(this.onInputEvent));
collider.Connect("mouse_entered", this, nameof(this.onMouseEntered));
collider.Connect("mouse_exited", this, nameof(this.onMouseExited));
break;
}
}
// meshInstance.MaterialOverride = new
}
public override void _PhysicsProcess(float delta)
{
_collidingBodies = GetCollidingBodies();
if (_collidingBodies.Count != 0 || _currentBulletTimeLeft <= 0)
{
if (_collidingBodies.Count != 0)
{
SpawnBulletExplosion();
NotifyCollider((Object)_collidingBodies[0]);
}
RemoveBulletFromTree();
}
_currentBulletTimeLeft -= delta;
}
private static string FindSelectedXcode()
{
var outputWrapper = new Godot.Collections.Array();
int exitCode = Godot.OS.Execute("xcode-select", new string[] { "--print-path" }, blocking: true, output: outputWrapper);
if (exitCode == 0)
{
string output = (string)outputWrapper[0];
return(output.Trim());
}
Console.Error.WriteLine($"'xcode-select --print-path' exited with code: {exitCode}");
return(null);
}
private void OnGooglePlayBilling_PurchasesUpdated(Godot.Collections.Array arrPurchases)
{
_panel.Show();
_processLabel.Show();
_thanksLabel.Hide();
var purchases = GooglePlayBillingUtils.ConvertPurchaseDictionaryArray(arrPurchases);
foreach (var purchase in purchases)
{
_purchases.Add(purchase.PurchaseToken, purchase.Sku);
// We only expect this SKU
if (purchase.Sku == "android.test.purchased")
{
_googlePlayBilling.AcknowledgePurchase(purchase.PurchaseToken);
}
}
}
