Hello everyone, this post is about setting up an Isometric Camera Controller for the Godot Engine. This controller enables us to grab, rotate, zoom, and edge pan the camera similar to other Real-Time Strategy (RTS) games. For this guide, I will be using Godot version 4.2.2, and the scripting language will be C#.

Isometric Camera Setup in Godot Editor

First, create a new project and set up a basic scene with a plane and cubes. Then, add a Camera3D node. If you select the Camera3D node, you will see a preview button which, as the name implies, gives you a preview of the camera view.

Then, under Inspector -> Camera3D properties, make sure that the projection is orthogonal, which ensures that objects remain the same size on the screen no matter how far away they are. The “Size” property is used to adjust the camera size and can be used for the zoom in/out feature.

Currently, if you look at the preview, you will see nothing being projected. To make it work, we have to modify the Transform Properties, especially the y-position and x-rotation. The y-position moves the camera up or down depending on the value and can be used to avoid clipping. Here, a rotation of x=-90 gives a flat orthogonal view, while x=-45 gives you an isometric view. You can easily adjust the angle for your desired camera view or effect.

Now, after finishing the camera setup, let’s move toward the camera controller script.

Isometric Camera Controller Script

Since we will be panning and rotating the camera, we don’t want to pan/rotate the actual camera node. Instead, make a new 3D Node and name it appropriately; for this guide, I will name it ‘CameraHolder’. Make the Camera3D a child of the ‘CameraHolder’ node. Create a new script called ‘CameraController’ and attach it to the ‘CameraHolder’ node and open it.

public partial class CameraController : Node3D
{
    private readonly float _edgePanningTriggerOffsetValue = 2f;
    private readonly float _panningCameraSpeed = 50f; 
    private readonly float _middleMouseGrabCameraSpeed = 5f;
    private readonly int _zoomMinDisatance = 20;
    private readonly int _zoomMaxDisatance = 60;
    private readonly int _zoomAmountPerRoll = 10;
    private float _currentSize = 0f;
    private float _smoothTimer = 0.0f;
    private float _smoothZoomTime = 1.0f;
    private float _screenRatio;

    private Vector2 _size;
    private Vector2 _mouseRelativeVel = Vector2.Zero;
    private bool _applyZoomSmooth = false;
    private bool _rotateCamera = false;
    private bool _isDragging = false;

    [Export] private Camera3D _camera;
    public EdgePannigState pannigState = EdgePannigState.None;
    public override void _Ready()
    {
        _currentSize = _camera.Size;
        _size = GetViewport().GetVisibleRect().Size;
        _screenRatio = _size.X / _size.Y;
        GetViewport().SizeChanged += SizeChanged;
        Input.MouseMode = Input.MouseModeEnum.Confined;
    }

    public override void _ExitTree()
    {
        GetViewport().SizeChanged -= SizeChanged;
    }

    private void SizeChanged()
    {
        _size = GetViewport().GetVisibleRect().Size;
        _screenRatio = _size.X / _size.Y;
    }

    public override void _Process(double delta)
    {
        if (_isDragging)
        {
            GlobalPosition -=
                    GlobalTransform.Basis.X * _mouseRelativeVel.X * _middleMouseGrabCameraSpeed * (float)delta +
                    GlobalTransform.Basis.Z * _mouseRelativeVel.Y * _middleMouseGrabCameraSpeed * (float)delta * _screenRatio;
        }
        else
        {
            ApplyPanningStateToCamera(delta);
        }
        if (_applyZoomSmooth)
        {
            ApplyZoom(delta);
        }
        if (_rotateCamera)
        {
            RotateY(-_mouseRelativeVel.X * 0.5f * (float)delta);
        }
        //relative mouse velocity need to be reset after every frame
        _mouseRelativeVel = Vector2.Zero;
    }

    private void ApplyZoom(double delta)
    {
        _smoothTimer += (float)delta;
        if (_smoothTimer < _smoothZoomTime)
        {
            _camera.Size = Mathf.Lerp(_camera.Size, _currentSize, _smoothTimer / _smoothZoomTime);
        }
        else
        {
            _applyZoomSmooth = false;
        }
    }

    private void ApplyPanningStateToCamera(double delta)
    {
        switch (pannigState)
        {
            case EdgePannigState.None:
                break;
            case EdgePannigState.Left:
                GlobalPosition +=
                  GlobalTransform.Basis.X * -_panningCameraSpeed * (float)delta;
                break;
            case EdgePannigState.Right:
                GlobalPosition +=
                 GlobalTransform.Basis.X * _panningCameraSpeed * (float)delta;
                break;
            case EdgePannigState.Up:
                GlobalPosition +=
                  GlobalTransform.Basis.Z * -_panningCameraSpeed * (float)delta;
                break;
            case EdgePannigState.Down:
                GlobalPosition +=
                 GlobalTransform.Basis.Z * _panningCameraSpeed * (float)delta;
                break;
        }
    }
    public override void _Input(InputEvent @event)
    {
        if (@event is InputEventKey keyEvent)
        {
            if (keyEvent.Keycode == Key.Escape && keyEvent.Pressed)
            {
                Input.MouseMode = Input.MouseMode == Input.MouseModeEnum.Confined ? Input.MouseModeEnum.Visible : Input.MouseModeEnum.Confined;
            }
        }
        if (@event is InputEventMouseButton mouseButton)
        {
            switch (mouseButton.ButtonIndex)
            {
                case MouseButton.WheelDown:
                case MouseButton.WheelUp:
                    {
                        if (!_isDragging)
                        {
                            _currentSize = mouseButton.ButtonIndex == MouseButton.WheelUp ? _currentSize - _zoomAmountPerRoll : _currentSize + _zoomAmountPerRoll;
                            _currentSize = Mathf.Clamp(_currentSize, _zoomMinDisatance, _zoomMaxDisatance);
                            _smoothTimer = 0;
                            _applyZoomSmooth = true;
                        }
                    }
                    break;
                case MouseButton.Middle when mouseButton.Pressed:
                    _isDragging = true;
                    break;
                case MouseButton.Right when mouseButton.Pressed:
                    _rotateCamera = true;
                    break;
                default:
                    _rotateCamera = false;
                    _isDragging = false;
                    break;
            }
        }
        if (@event is InputEventMouseMotion mouseMotion)
        {
            _mouseRelativeVel = mouseMotion.Relative;
            EdgePanningDetection(mouseMotion.Position);
        }
    }

    private void EdgePanningDetection(Vector2 mouseMotion)
    {
        if (mouseMotion.X < _edgePanningTriggerOffsetValue)
        {
            pannigState = EdgePannigState.Left;
        }
        else if (mouseMotion.X > (_size.X - _edgePanningTriggerOffsetValue))
        {
            pannigState = EdgePannigState.Right;
        }
        else if (mouseMotion.Y < _edgePanningTriggerOffsetValue)
        {
            pannigState = EdgePannigState.Up;
        }
        else if (mouseMotion.Y > (_size.Y - _edgePanningTriggerOffsetValue))
        {
            pannigState = EdgePannigState.Down;
        }
        else
        {
            pannigState = EdgePannigState.None;
        }
    }
}
public enum EdgePannigState
{
    None,
    Left,
    Right,
    Up,
    Down
}

Lets breakdown the above code:

Variables | Constants

• _edgePanningTriggerOffsetValue:
  • A constant defining the threshold distance from the edge of the screen to trigger edge panning, meaning that if it has a value of 5, edge panning would start 5 pixels before reaching the edge.
• _panningCameraSpeed:
  • This is a speed at which the camera move when using edge panning.
• _middleMouseGrabCameraSpeed:
  • This define a speed at which the camera move when the middle mouse or grab button is held down.
• _zoomMinDistance, _zoomMaxDistance:
  • These are the constants defining the minimum and maximum zoom distances for camera.
• _zoomAmountPerRoll:
  • This is a amount by which the zoom changes per mouse wheel roll.
• _currentCameraSize:
  • This give the current camera size used for zooming in/out.
• _smoothTimer, _smoothZoomTime:
  • These are used for smooth zoom interpolation.
• _screenRatio, _viewPortSize:
  • These are used to store the screen ratio and size of the viewport.
• _mouseRelativeVel:
  • This give the relative mouse velocity whenever mouse is moved.
• _applyZoomSmooth, _rotateCamera, _isDragging:
  • These flags are used to control zooming, camera rotation, and dragging behavior.
• _camera:
  • Reference to the Camera3D node.
• panningState:
  • The current panning state (e.g., Left, Right, Up, Down, None) represented by Enum.

Methods

• _Ready():
  • In this method we Initializes variables related to camera size, viewport size, and aspect ratio and subscribes to the viewport size changed event.
• _ExitTree():
  • This is called when the node is removed from the scene tree. we usually unsubscribes to all event here to avoid memory leaks.
• SizeChanged():
  • This is called when the viewport size changes and will updates the size and aspect ratio variables accordingly.
• _Process(double delta):
  • Here we handles camera movement, zooming, and rotation based on user input and current panning states.
• ApplyZoom(double delta):
  • This is used to apply smooth zooming by interpolating the camera size over time.
• EdgePanningDetection(Vector2 mouseMotion):
  • This method detects if the mouse cursor is near the edges of the screen and sets the corresponding panning state (Left, Right, Up, Down, or None) based on the cursor position.
• ApplyPanningStateToCamera(double delta):
  • This method applies the current panning state to the camera, moving it in the corresponding direction based on the panning camera speed.
• _Input(InputEvent @event):
  • Here we handles various input events such as key presses, mouse button presses, and mouse motion. Controls camera zoom, rotation, and dragging behavior.

Conclusion

In this post, we’ve created an Isometric Camera Controller in Godot Engine using C#. You can easily integrate this controller into your project to enable smooth camera movements for your RTS game or any other 3D project.

Feel free to customize the script further to suit your specific requirements and enhance your game’s camera control functionality. Here is the Github link for this project.

The post Isometric Camera Controller 3D – Godot Engine appeared first on TweakGame.

First, open Godot Engine and create a new project. Then, navigate to Editor -> Editor Settings. Find Dotnet -> Editor tab and select it. Make sure “External Editor” is set to Visual Studio and that the “Custom Exec Path” is pointing to your installed Visual Studio executable path.

Once you’ve completed the previous step, open your project in Visual Studio. Then, navigate to Debug -> [Your Project Name] Debug Properties and open it. Also, you can delete the default launch profile if it exists.

Next, select create a new profile option and choose the “Executable” option. You can also rename your profile to whatever you like.

First, make sure that the path to the executable to run is pointing to your Godot Engine executable file (Godot_v4.2-stable_mono_win64.exe).
For Command Line Arguments, you can pass any supported argument.
Use ‘.’ for the Working Directory to indicate that this is the current working directory.
Also, make sure to enable the “Native Code Debugging” option.

Once you have completed all these steps, you will be able to run and debug your game from within Visual Studio. If you encounter an error, you most likely have forgotten to set the startup Main Scene in Godot Engine.

The post How to Setup Visual Studio with Godot Engine appeared first on TweakGame.

This code creates a grid, and I believe it’s largely self-explanatory. However, if you encounter any confusion, feel free to ask in the comments.

public class CustomGrid<TItem>
{
    public delegate void GridItemChangedDelegate(int coordinateX, int coordinateY, TItem obj);

    public event GridItemChangedDelegate GridItemChanged;

    public int Height { get; private set; }
    public int CellSize { get; private set; }
    public int Width { get; private set; }

    public TItem[,] GridCellCollection { get; private set; }

    public List<Vector2> GridPositions { get; private set; }

    private readonly Func<Vector2> _originPosition;
    public CustomGrid(int width, int height, int cellSize, Func<Vector2> originPosition = null)
    {
        _originPosition = originPosition;
        Height = height;
        CellSize = cellSize;
        Width = width;
        GridCellCollection = new TItem[width, height];
        GridPositions = new();
        // Initialize grid cells and positions
        for (int i = 0; i < Width; i++)
        {
            for (int j = 0; j < Height; j++)
            {

                GridCellCollection[i, j] = default;
                GridPositions.Add(GetWorldPosition(i, j));
            }
        }
    }
    private void CreateGrid()
    {
        for (int i = 0; i < Width; i++)
        {
            for (int j = 0; j < Height; j++)
            {
                //each cell data
            }
        }
    }


    private Vector2 GetParentPosition() => _originPosition?.Invoke() ?? Vector2.Zero;

    private bool TryGetGridCoordinate(Vector2 pos, Vector2 parentPos, out (int x, int y) coordinate)
    {
        var x = Mathf.FloorToInt((pos.X - parentPos.X) / (CellSize));
        var y = Mathf.FloorToInt((pos.Y - parentPos.Y) / (CellSize));
        coordinate = (x, y);
        return x >= 0 && x < Width && y >= 0 && y < Height;
    }

    private bool IsCellEmpty(int x, int y)
    {
        var obj = GridCellCollection[x, y];
        return obj == null || EqualityComparer<TItem>.Default.Equals(obj, default);
    }

    private bool IsCellEmpty(int x, int y, out TItem item)
    {
        item = GridCellCollection[x, y];
        return GridCellCollection[x, y] == null || EqualityComparer<TItem>.Default.Equals(GridCellCollection[x, y], default);
    }

    public bool IsCellEmpty(Vector2 pos)
    {
        return TryGetGridCoordinate(pos, GetParentPosition(), out var coordinate) && IsCellEmpty(coordinate.x, coordinate.y);
    }

    private Vector2 GetWorldPosition(int x, int y) => new Vector2(x * CellSize, y * CellSize) + GetParentPosition();

    public bool TrySetItem(Vector2 pos, TItem obj, out Vector2 positionToSet)
    {
        if (obj == null)
        {
            positionToSet = Vector2.Zero;
            return false;
        }
        var parentPos = GetParentPosition();
        if (TryGetGridCoordinate(pos, parentPos, out var coordinate) && IsCellEmpty(coordinate.x, coordinate.y))
        {
            GridCellCollection[coordinate.x, coordinate.y] = obj;
            positionToSet = new Vector2(coordinate.x * CellSize, coordinate.y * CellSize) + parentPos;
            GridItemChanged?.Invoke(coordinate.x, coordinate.y, obj);
            return true;
        }
        positionToSet = Vector2.Zero;
        return false;
    }
    public void TriggerItemChangedEvent(int x, int y)
    {
        GridItemChanged?.Invoke(x, y, GridCellCollection[x, y]);
    }

    public bool TryGetItem(Vector2 pos, out TItem obj)
    {
        if (TryGetGridCoordinate(pos, GetParentPosition(), out var coordinate))
        {
            if (!IsCellEmpty(coordinate.x, coordinate.y))
            {
                obj = GridCellCollection[coordinate.x, coordinate.y];
                return true;
            }
        }
        obj = default;
        return false;
    }

    public bool TryRemoveItem(Vector2 pos, out TItem removedItem)
    {
        if (TryGetGridCoordinate(pos, GetParentPosition(), out var coordinate))
        {
            if (IsCellEmpty(coordinate.x, coordinate.y, out removedItem))
            {
                return false;
            }
            GridCellCollection[coordinate.x, coordinate.y] = default;
            return true;
        }
        removedItem = default;
        return false;
    }
}

But how does it all work? Let’s break down above code:

Variables

• GridItemChanged (event):
  • This event is triggered when a grid item changes. It’s of type GridItemChangedDelegate, which defines the signature of methods that can be subscribed to this event.
• Height, Width, CellSize:
  • These are properties that define the dimensions and cell size of the grid.
• GridCellCollection:
  • It’s a 2D array of type TItem that holds grid items. Each cell in the grid can contain an item of type TItem. Since, TItem is generic, it can hold any type of data.
• GridPositions:
  • It’s a list that stores grid positions as Vector2 and can be used to draw visual representation of grid.
• _originPosition:
  • It’s a private field that holds a reference to a function returning a Vector2, representing the origin position of the grid.

Methods

• CustomGrid() constructor:
  • This is use to Initializes a new instance of the CustomGrid class with specified width, height, cell size, and optionally, an origin position function.
• GetParentPosition():
  • This method Returns the parent position of the grid. If _originPosition is not null, it invokes the function and returns the result; otherwise, it returns Vector2.Zero.
• TryGetGridCoordinate(Vector2 pos, Vector2 parentPos, out (int x, int y) coordinate):
  • Given a world position and parent position, this method calculates the corresponding grid coordinate. This returns true if the coordinate is valid within the grid bounds.
• IsCellEmpty(int x, int y), IsCellEmpty(int x, int y, out TItem item):
  • This method is use to check if the cell at the specified grid coordinates is empty (i.e., does not contain an item).
• IsCellEmpty(Vector2 pos):
  • This is a overloaded method that checks if the cell at the specified world position is empty.
• GetWorldPosition(int x, int y):
  • This method calculates and returns the world position of a grid cell based on its coordinates.
• TrySetItem(Vector2 pos, TItem obj, out Vector2 positionToSet):
  • Tries to set an item at the specified world position in the grid. If the position is valid and the cell is empty, sets the item in the grid and returns true.
• TriggerItemChangedEvent(int x, int y):
  • This is use to invokes the GridItemChanged event for the specified grid coordinates.
• TryGetItem(Vector2 pos, out TItem obj):
  • Attempts to get the item at the specified world position in the grid, respectively. Returns true if successful, along with the item.
• TryRemoveItem(Vector2 pos, out TItem removedItem):
  • Attempts to remove the item at the specified world position in the grid, respectively. Returns true if successful, along with the item so it can be cleanup.

This is how you can create a custom grid. It’s important to note that this implementation isn’t perfect or exhaustive. It’s a simple demonstration, and further optimization and feature additions can be made based on specific requirements. If you’re unsure how to use this grid, you can refer to the GitHub pages for a simple demo.

Check out my other post :

• Implementing Scene Management with Loading Screen in Godot Engine.
• How to implement Google Game Play Services in Godot using C#.

The post Godot Engine – Build Custom Grid System using C# appeared first on TweakGame.

First things first, let’s introduce the SceneManager class. This class is going to be our go-to for managing scene transitions. But before we get into the nitty-gritty, let’s talk about the importance of scene management in game development.

Smooth scene transitions are like the glue that holds your game together. Whether your players are moving between levels, accessing menus, or triggering cutscenes, you want those transitions to be seamless. And that’s where the SceneManager comes in. Our SceneManager class is designed to be a singleton, ensuring that there’s only ever one instance floating around. This helps prevent any messy conflicts during transitions and keeps things running smoothly behind the scenes.

Now, let’s talk about the loading screen. We’ve all experienced those moments when a game seems to freeze up while loading a new scene. It’s not the most elegant experience, is it? That’s why we’ve implemented a loading screen feature right into our SceneManager class for simplicity sake, but of course it can be done in many different ways.

With our loading screen in place, players get a visual cue that something’s happening in the background. No more staring at a blank screen wondering if the game has crashed! Plus, with the option to use threads for asynchronous loading, we can keep the main thread free and the gameplay uninterrupted.

public partial class SceneManager : Node
{
    public static SceneManager Instance { get; private set; }
    private string _sceneToLoad = "";
    private double _time = 0;
    private double _minimumWaitTime = 2f;
    private bool _useThread = false;
    private string _loadingScreenScenePath = "res://loading_screen.tscn";
    private LoadingScreen _loadingScreen;
    private Array _progressArray;
    public override void _Ready()
    {
        if (Instance == null)
        {
            Instance = this;
            _loadingScreen = ResourceLoader.Load<PackedScene>(_loadingScreenScenePath).Instantiate<LoadingScreen>();
        }
        else
        {
            QueueFree();
        }
    }
    /// <summary>
    /// Go to scene without loading screen and without using threads
    /// </summary>
    /// <param name="scenePath"></param>
    public void GoToSceneNoLoadingScreen(string scenePath)
    {
        var packedScene = ResourceLoader.Load<PackedScene>(scenePath);
        var scene = packedScene.Instantiate();
        var root = GetTree().Root;
        // get current scene and remove it
        var currentScene = root.GetChild(root.GetChildCount() - 1);
        currentScene.QueueFree();
        root.AddChild(scene);
    }
    /// <summary>
    /// Go to scene with loading screen and using threads
    /// </summary>
    /// <param name="scenePath"></param>
    /// <param name="minimumWaitTime"></param>
    /// <param name="useSubThreads"></param>
    public void GoToSceneThreadedWithLoadingScreen(string scenePath, double minimumWaitTime = 2f, bool useSubThreads = false)
    {
        AddChild(_loadingScreen);
        _progressArray = new Array();
        _useThread = true;
        _minimumWaitTime = minimumWaitTime;
        _sceneToLoad = scenePath;
        // currently retun value is discarded 
        // but if you need to log more information, you can use the return value
        _ = ResourceLoader.LoadThreadedRequest(path: scenePath, useSubThreads: useSubThreads);
    }
    public override void _Process(double delta)
    {

        if (_useThread)
        {
            _time += delta;
            
            if (ResourceLoader.LoadThreadedGetStatus(_sceneToLoad, _progressArray) == ResourceLoader.ThreadLoadStatus.InProgress)
            {
                _loadingScreen.SetProgress(_progressArray.First().AsSingle() * 100);
            }
            else if (ResourceLoader.LoadThreadedGetStatus(_sceneToLoad,_progressArray) == ResourceLoader.ThreadLoadStatus.Loaded && _time > _minimumWaitTime)
            {
                // You can also use CallDeferred method to run at idle time
                //CallDeferred(MethodName.LoadScene);
                LoadScene();
            }
            // or use dummy % for loading screen
            if (_time < _minimumWaitTime)
            {
                _loadingScreen.SetProgress((float)(_time / _minimumWaitTime) * 100);
            }
        }
    }
    private void LoadScene()
    {
        if (ResourceLoader.LoadThreadedGet(_sceneToLoad) is PackedScene packedScene)
        {
            var scene = packedScene.Instantiate();
            var root = GetTree().Root;
            // remove current scene
            var currentScene = root.GetChild(root.GetChildCount() - 1);
            currentScene.QueueFree();
            root.AddChild(scene);
        }
        RemoveChild(_loadingScreen);
        ResetParam();
    }
    public override void _ExitTree()
    {
        // if you add node manually, make sure to free it
        _loadingScreen?.QueueFree();
    }
    private void ResetParam()
    {
        _time = 0;
        _useThread = false;
    }
}

But how does it all work? Let’s break it down:

1. Scene Loading Methods: We’ve provided two handy methods for transitioning between scenes. Need to jump to a new scene without any fuss? Use GoToSceneNoLoadingScreen. Want to add some pizzazz with a loading screen? Opt for GoToSceneThreadedWithLoadingScreen.
2. Threaded Loading: By leveraging threads, we can load resources in the background while the game continues to run smoothly. This is especially useful for loading large scenes or assets without causing any dreaded lag spikes.
3. Loading Progress: Our SceneManager class continuously updates the loading progress on the loading screen. Players can see exactly how far along the loading process is, keeping them engaged and informed. It can be further optimized by checking status between certain interval.
4. Cleanup: We’ve made sure to clean up after ourselves with the _ExitTree method. No orphaned nodes hanging around causing memory leaks here!

In conclusion, scene management is a critical aspect of game development, and with the right tools, you can take your game to the next level. By implementing a threaded loading approach and incorporating a sleek loading screen, you can create seamless transitions that keep players immersed in your game world.

Also check out the full source code with demo on GitHub!”

Check out my other post :

• Godot Engine – Build Custom Grid System using C#
• How to implement Google Game Play Services in Godot using C#.

The post Scene Management with Loading Screen – Godot Engine appeared first on TweakGame.

To achieve this, we’ll utilize this plugin (don’t forget to give it a star) and ensure to follow the setup process outlined on its official page. Once the plugin is correctly set up, it should function seamlessly. However, since everything is in GDScript, we need to create a wrapper around it to utilize it within C# code. This approach is not only applicable to this plugin but can also be applied to any other plugin. For simplicity, I’ll create a wrapper for initializing the plugin and SignInClient only. However, implementing other features is equally straightforward, as you’ll see below.

To begin, you can explore all the methods exposed by the plugin by referring to the Documentation Section and locating the GodotAndroidPlugin class. Once you’ve familiarized yourself with the available methods, let’s dive into the implementation process.

Define the GodotPlayGameService class as a partial class inheriting from the Node class in Godot.

public partial class GodotPlayGameService : Node
{
}

Define a property Plugin of type GodotObject with a private setter. This property will be used to store a reference to the Android plugin for the GodotPlayGameService, allowing interaction with it within the class methods.

public partial class GodotPlayGameService : Node
{
     public GodotObject Plugin { get; private set; }
}

Implement the _Ready() method override and Initialize the plugin.

public partial class GodotPlayGameService : Node
{
    // Represents the Android plugin for the GodotPlayGameService.
    public GodotObject Plugin { get; private set; }
    const string plugin_name = "GodotPlayGameServices";
    public override void _Ready()
    {
        if (Plugin == null)
        {
            if (Engine.HasSingleton(plugin_name))
            {
                Plugin = Engine.GetSingleton(plugin_name);
                Plugin.Call("initialize");
            }
            else
            {
                GD.PrintErr("No plugin found.");
            }
        }
    }
}

For the Sign In functionality, we will implement three methods of plugin: isAuthenticated, signIn, and requestServerSideAccess, along with their corresponding signals. Let’s proceed with the implementation process.

 public partial class GodotPlayGameService : Node
 {
     // Represents the Android plugin for the GodotPlayGameService.
     public GodotObject Plugin { get; private set; }
     const string plugin_name = "GodotPlayGameServices";

     public delegate void AuthenticationDelegate(bool isAuthenticated);
     // Event for when the user is authenticated
     public event AuthenticationDelegate UserAuthenticated;

     // Event for when server side access is requested
     public event AuthenticationDelegate ServerSideAccessRequested;
     public override void _Ready()
     {
         if (Plugin == null)
         {
             if (Engine.HasSingleton(plugin_name))
             {
                 Plugin = Engine.GetSingleton(plugin_name);
                 Plugin.Call("initialize");
             }
             else
             {
                 GD.PrintErr("No plugin found.");
             }
         }
         // Connects signals from the AndroidPlugin instance to corresponding methods
         Plugin?.Connect("userAuthenticated", new Callable(this, nameof(OnUserAuthenticatedSignalConnected)));
         Plugin?.Connect("serverSideAccessRequested", new Callable(this, nameof(ServerSideAccessRequestedSignalConnected)));
     }
     /// <summary>
     /// Invokes the UserAuthenticated event with the specified authentication status.
     /// </summary>
     /// <param name="isAuthenticated">The authentication status.</param>
     private void OnUserAuthenticatedSignalConnected(bool isAuthenticated)
     {
         UserAuthenticated?.Invoke(isAuthenticated);
     }

     /// <summary>
     /// Invokes the ServerSideAccessRequested event with the specified authentication status.
     /// </summary>
     /// <param name="isAuthenticated">The authentication status.</param>
     private void ServerSideAccessRequestedSignalConnected(bool isAuthenticated)
     {
         ServerSideAccessRequested?.Invoke(isAuthenticated);
     }
     /// <summary>
     /// Check if the user is authenticated.
     /// </summary>
     public void IsAuthenticated()
     {
         Plugin?.Call("isAuthenticated");
     }

     /// <summary>
     /// Sign in the user.
     /// </summary>
     public void SignIn()
     {
         Plugin?.Call("signIn");
     }

     /// <summary>
     /// Request server side access with the specified server client ID and force refresh token flag.
     /// </summary>
     /// <param name="serverClientId">The server client ID to request access for.</param>
     /// <param name="forceRefreshToken">Whether to force refresh the token.</param>
     public void RequestServerSideAccess(string serverClientId, bool forceRefreshToken)
     {
         Plugin?.Call("requestServerSideAccess", serverClientId, forceRefreshToken);
     }
 }

If you’ve noticed, all methods and signals correspond to the exposed methods of the plugin, making it incredibly easy to work with. This is just a simple demonstration; for further details and a demo, you can check out this GitHub repository.

Check out my other post :

• Implementing Scene Management with Loading Screen in Godot Engine.
• Godot Engine – Build Custom Grid System using C#.

The post Google Play Game Services in Godot using C# appeared first on TweakGame.