[GameLift][FlexMatch] Update session interface for clients to make matchmaking requests (#4450)

* [GameLift][FlexMatch] Update session interface for clients to make matchmaking requests Signed-off-by: Junbo Liang <junbo@amazon.com>
2021-10-06 10:56:49 -07:00
parent 0848a9cdf9
commit 4f51b53558
24 changed files with 885 additions and 131 deletions
@@ -112,6 +112,16 @@ namespace AWSGameLift
        return AZ::Uuid::CreateRandom().ToString<AZStd::string>(includeBrackets, includeDashes);
    }

+    void AWSGameLiftClientManager::AcceptMatch(const AzFramework::AcceptMatchRequest& acceptMatchRequest)
+    {
+        AZ_UNUSED(acceptMatchRequest);
+    }
+
+    void AWSGameLiftClientManager::AcceptMatchAsync(const AzFramework::AcceptMatchRequest& acceptMatchRequest)
+    {
+        AZ_UNUSED(acceptMatchRequest);
+    }
+
    AZStd::string AWSGameLiftClientManager::CreateSession(const AzFramework::CreateSessionRequest& createSessionRequest)
    {
        AZStd::string result = "";
@@ -349,6 +359,28 @@ namespace AWSGameLift
        return response;
    }

+    AZStd::string AWSGameLiftClientManager::StartMatchmaking(const AzFramework::StartMatchmakingRequest& startMatchmakingRequest)
+    {
+        AZ_UNUSED(startMatchmakingRequest);
+
+        return AZStd::string{};
+    }
+
+    void AWSGameLiftClientManager::StartMatchmakingAsync(const AzFramework::StartMatchmakingRequest& startMatchmakingRequest)
+    {
+        AZ_UNUSED(startMatchmakingRequest);
+    }
+
+    void AWSGameLiftClientManager::StopMatchmaking(const AzFramework::StopMatchmakingRequest& stopMatchmakingRequest)
+    {
+        AZ_UNUSED(stopMatchmakingRequest);
+    }
+
+    void AWSGameLiftClientManager::StopMatchmakingAsync(const AzFramework::StopMatchmakingRequest& stopMatchmakingRequest)
+    {
+        AZ_UNUSED(stopMatchmakingRequest);
+    }
+
    void AWSGameLiftClientManager::SetGameLiftClient(AZStd::shared_ptr<Aws::GameLift::GameLiftClient> gameliftClient)
    {
        m_gameliftClient.swap(gameliftClient);
@@ -9,6 +9,8 @@
 #pragma once

 #include <AzCore/std/smart_ptr/shared_ptr.h>
+#include <AzFramework/Matchmaking/MatchmakingNotifications.h>
+
 #include <Request/IAWSGameLiftRequests.h>

 namespace Aws
@@ -26,6 +28,54 @@ namespace AWSGameLift
    struct AWSGameLiftJoinSessionRequest;
    struct AWSGameLiftSearchSessionsRequest;

+    // MatchAcceptanceNotificationBus EBus handler for scripting
+    class AWSGameLiftMatchAcceptanceNotificationBusHandler
+        : public AzFramework::MatchAcceptanceNotificationBus::Handler
+        , public AZ::BehaviorEBusHandler
+    {
+    public:
+        AZ_EBUS_BEHAVIOR_BINDER(
+            AWSGameLiftMatchAcceptanceNotificationBusHandler,
+            "{CBE057D3-F5CE-46D3-B02D-8A6A1446B169}",
+            AZ::SystemAllocator,
+            OnMatchAcceptance);
+
+        void OnMatchAcceptance() override
+        {
+            Call(FN_OnMatchAcceptance);
+        }
+    };
+
+    // MatchmakingAsyncRequestNotificationBus EBus handler for scripting
+    class AWSGameLiftMatchmakingAsyncRequestNotificationBusHandler
+        : public AzFramework::MatchmakingAsyncRequestNotificationBus::Handler
+        , public AZ::BehaviorEBusHandler
+    {
+    public:
+        AZ_EBUS_BEHAVIOR_BINDER(
+            AWSGameLiftMatchmakingAsyncRequestNotificationBusHandler,
+            "{2045EE8F-2AB7-4ED0-9614-3496A1A43677}",
+            AZ::SystemAllocator,
+            OnAcceptMatchAsyncComplete,
+            OnStartMatchmakingAsyncComplete,
+            OnStopMatchmakingAsyncComplete);
+
+        void OnAcceptMatchAsyncComplete() override
+        {
+            Call(FN_OnAcceptMatchAsyncComplete);
+        }
+
+        void OnStartMatchmakingAsyncComplete(const AZStd::string& matchmakingTicketId) override
+        {
+            Call(FN_OnStartMatchmakingAsyncComplete, matchmakingTicketId);
+        }
+
+        void OnStopMatchmakingAsyncComplete() override
+        {
+            Call(FN_OnStopMatchmakingAsyncComplete);
+        }
+    };
+
    // SessionAsyncRequestNotificationBus EBus handler for scripting
    class AWSGameLiftSessionAsyncRequestNotificationBusHandler
        : public AzFramework::SessionAsyncRequestNotificationBus::Handler
@@ -66,6 +116,8 @@ namespace AWSGameLift
    //! GameLift client manager to support game and player session related client requests
    class AWSGameLiftClientManager
        : public AWSGameLiftRequestBus::Handler
+        , public AWSGameLiftMatchmakingAsyncRequestBus::Handler
+        , public AWSGameLiftMatchmakingRequestBus::Handler
        , public AWSGameLiftSessionAsyncRequestBus::Handler
        , public AWSGameLiftSessionRequestBus::Handler
    {
@@ -91,12 +143,22 @@ namespace AWSGameLift
        bool ConfigureGameLiftClient(const AZStd::string& region) override;
        AZStd::string CreatePlayerId(bool includeBrackets, bool includeDashes) override;

+        // AWSGameLiftMatchmakingAsyncRequestBus interface implementation
+        void AcceptMatchAsync(const AzFramework::AcceptMatchRequest& acceptMatchRequest) override;
+        void StartMatchmakingAsync(const AzFramework::StartMatchmakingRequest& startMatchmakingRequest) override;
+        void StopMatchmakingAsync(const AzFramework::StopMatchmakingRequest& stopMatchmakingRequest) override;
+
        // AWSGameLiftSessionAsyncRequestBus interface implementation
        void CreateSessionAsync(const AzFramework::CreateSessionRequest& createSessionRequest) override;
        void JoinSessionAsync(const AzFramework::JoinSessionRequest& joinSessionRequest) override;
        void SearchSessionsAsync(const AzFramework::SearchSessionsRequest& searchSessionsRequest) const override;
        void LeaveSessionAsync() override;

+        // AWSGameLiftMatchmakingRequestBus interface implementation
+        void AcceptMatch(const AzFramework::AcceptMatchRequest& acceptMatchRequest) override;
+        AZStd::string StartMatchmaking(const AzFramework::StartMatchmakingRequest& startMatchmakingRequest) override;
+        void StopMatchmaking(const AzFramework::StopMatchmakingRequest& stopMatchmakingRequest) override;
+
        // AWSGameLiftSessionRequestBus interface implementation
        AZStd::string CreateSession(const AzFramework::CreateSessionRequest& createSessionRequest) override;
        bool JoinSession(const AzFramework::JoinSessionRequest& joinSessionRequest) override;
@@ -13,10 +13,13 @@

 #include <AWSGameLiftClientManager.h>
 #include <AWSGameLiftClientSystemComponent.h>
+#include <Request/AWSGameLiftAcceptMatchRequest.h>
 #include <Request/AWSGameLiftCreateSessionOnQueueRequest.h>
 #include <Request/AWSGameLiftCreateSessionRequest.h>
 #include <Request/AWSGameLiftJoinSessionRequest.h>
 #include <Request/AWSGameLiftSearchSessionsRequest.h>
+#include <Request/AWSGameLiftStartMatchmakingRequest.h>
+#include <Request/AWSGameLiftStopMatchmakingRequest.h>

 #include <aws/gamelift/GameLiftClient.h>

@@ -29,18 +32,13 @@ namespace AWSGameLift

    void AWSGameLiftClientSystemComponent::Reflect(AZ::ReflectContext* context)
    {
-        ReflectCreateSessionRequest(context);
-        AWSGameLiftCreateSessionOnQueueRequest::Reflect(context);
-        AWSGameLiftCreateSessionRequest::Reflect(context);
-        AWSGameLiftJoinSessionRequest::Reflect(context);
-        AWSGameLiftSearchSessionsRequest::Reflect(context);
-        ReflectSearchSessionsResponse(context);
+        ReflectGameLiftMatchmaking(context);
+        ReflectGameLiftSession(context);

        if (AZ::SerializeContext* serialize = azrtti_cast<AZ::SerializeContext*>(context))
        {
            serialize->Class<AWSGameLiftClientSystemComponent, AZ::Component>()
-                ->Version(0)
-                ;
+                ->Version(1);

            if (AZ::EditContext* editContext = serialize->GetEditContext())
            {
@@ -50,8 +48,7 @@ namespace AWSGameLift
                        "Create the GameLift client manager that handles communication between game clients and the GameLift service.")
                    ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
                        ->Attribute(AZ::Edit::Attributes::AppearsInAddComponentMenu, AZ_CRC("System"))
-                        ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
-                    ;
+                        ->Attribute(AZ::Edit::Attributes::AutoExpand, true);
            }
        }

@@ -63,33 +60,7 @@ namespace AWSGameLift
                    {{{"Region", ""}}})
                ->Event("CreatePlayerId", &AWSGameLiftRequestBus::Events::CreatePlayerId,
                    {{{"IncludeBrackets", ""},
-                      {"IncludeDashes", ""}}})
-                ;
-            behaviorContext->EBus<AWSGameLiftSessionAsyncRequestBus>("AWSGameLiftSessionAsyncRequestBus")
-                ->Attribute(AZ::Script::Attributes::Category, "AWSGameLift")
-                ->Event("CreateSessionAsync", &AWSGameLiftSessionAsyncRequestBus::Events::CreateSessionAsync,
-                    {{{"CreateSessionRequest", ""}}})
-                ->Event("JoinSessionAsync", &AWSGameLiftSessionAsyncRequestBus::Events::JoinSessionAsync,
-                    {{{"JoinSessionRequest", ""}}})
-                ->Event("SearchSessionsAsync", &AWSGameLiftSessionAsyncRequestBus::Events::SearchSessionsAsync,
-                    {{{"SearchSessionsRequest", ""}}})
-                ->Event("LeaveSessionAsync", &AWSGameLiftSessionAsyncRequestBus::Events::LeaveSessionAsync)
-                ;
-            behaviorContext
-                ->EBus<AzFramework::SessionAsyncRequestNotificationBus>("AWSGameLiftSessionAsyncRequestNotificationBus")
-                ->Attribute(AZ::Script::Attributes::Category, "AWSGameLift")
-                ->Handler<AWSGameLiftSessionAsyncRequestNotificationBusHandler>()
-                ;
-            behaviorContext->EBus<AWSGameLiftSessionRequestBus>("AWSGameLiftSessionRequestBus")
-                ->Attribute(AZ::Script::Attributes::Category, "AWSGameLift")
-                ->Event("CreateSession", &AWSGameLiftSessionRequestBus::Events::CreateSession,
-                    {{{"CreateSessionRequest", ""}}})
-                ->Event("JoinSession", &AWSGameLiftSessionRequestBus::Events::JoinSession,
-                    {{{"JoinSessionRequest", ""}}})
-                ->Event("SearchSessions", &AWSGameLiftSessionRequestBus::Events::SearchSessions,
-                    {{{"SearchSessionsRequest", ""}}})
-                ->Event("LeaveSession", &AWSGameLiftSessionRequestBus::Events::LeaveSession)
-                ;
+                      {"IncludeDashes", ""}}});
        }
    }

@@ -126,6 +97,74 @@ namespace AWSGameLift
    {
        m_gameliftClientManager->DeactivateManager();
    }
+    
+    void AWSGameLiftClientSystemComponent::ReflectGameLiftMatchmaking(AZ::ReflectContext* context)
+    {
+        AWSGameLiftAcceptMatchRequest::Reflect(context);
+        AWSGameLiftStartMatchmakingRequest::Reflect(context);
+        AWSGameLiftStopMatchmakingRequest::Reflect(context);
+
+        if (AZ::BehaviorContext* behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
+        {
+            behaviorContext->EBus<AWSGameLiftMatchmakingAsyncRequestBus>("AWSGameLiftMatchmakingAsyncRequestBus")
+                ->Attribute(AZ::Script::Attributes::Category, "AWSGameLift")
+                ->Event("AcceptMatchAsync", &AWSGameLiftMatchmakingAsyncRequestBus::Events::AcceptMatchAsync,
+                    { { { "AcceptMatchRequest", "" } } })
+                ->Event("StartMatchmakingAsync", &AWSGameLiftMatchmakingAsyncRequestBus::Events::StartMatchmakingAsync,
+                    { { { "StartMatchmakingRequest", "" } } })
+                ->Event("StopMatchmakingAsync", &AWSGameLiftMatchmakingAsyncRequestBus::Events::StopMatchmakingAsync,
+                    { { { "StopMatchmakingRequest", "" } } });
+
+            behaviorContext->EBus<AzFramework::MatchmakingAsyncRequestNotificationBus>("AWSGameLiftMatchmakingAsyncRequestNotificationBus")
+                ->Attribute(AZ::Script::Attributes::Category, "AWSGameLift")
+                ->Handler<AWSGameLiftMatchmakingAsyncRequestNotificationBusHandler>();
+
+            behaviorContext->EBus<AWSGameLiftMatchmakingRequestBus>("AWSGameLiftMatchmakingRequestBus")
+                ->Attribute(AZ::Script::Attributes::Category, "AWSGameLift")
+                ->Event("AcceptMatch", &AWSGameLiftMatchmakingRequestBus::Events::AcceptMatch, { { { "AcceptMatchRequest", "" } } })
+                ->Event("StartMatchmaking", &AWSGameLiftMatchmakingRequestBus::Events::StartMatchmaking,
+                    { { { "StartMatchmakingRequest", "" } } })
+                ->Event("StopMatchmaking", &AWSGameLiftMatchmakingRequestBus::Events::StopMatchmaking,
+                    { { { "StopMatchmakingRequest", "" } } });
+
+            behaviorContext->EBus<AzFramework::MatchAcceptanceNotificationBus>("AWSGameLiftMatchAcceptanceNotificationBus")
+                ->Attribute(AZ::Script::Attributes::Category, "AWSGameLift")
+                ->Handler<AWSGameLiftMatchAcceptanceNotificationBusHandler>();
+        }
+    }
+
+    void AWSGameLiftClientSystemComponent::ReflectGameLiftSession(AZ::ReflectContext* context)
+    {
+        ReflectCreateSessionRequest(context);
+        AWSGameLiftCreateSessionOnQueueRequest::Reflect(context);
+        AWSGameLiftCreateSessionRequest::Reflect(context);
+        AWSGameLiftJoinSessionRequest::Reflect(context);
+        AWSGameLiftSearchSessionsRequest::Reflect(context);
+        ReflectSearchSessionsResponse(context);
+
+        if (AZ::BehaviorContext* behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
+        {
+            behaviorContext->EBus<AWSGameLiftSessionAsyncRequestBus>("AWSGameLiftSessionAsyncRequestBus")
+                ->Attribute(AZ::Script::Attributes::Category, "AWSGameLift")
+                ->Event("CreateSessionAsync", &AWSGameLiftSessionAsyncRequestBus::Events::CreateSessionAsync,
+                    { { { "CreateSessionRequest", "" } } })
+                ->Event("JoinSessionAsync", &AWSGameLiftSessionAsyncRequestBus::Events::JoinSessionAsync, { { { "JoinSessionRequest", "" } } })
+                ->Event("SearchSessionsAsync", &AWSGameLiftSessionAsyncRequestBus::Events::SearchSessionsAsync,
+                    { { { "SearchSessionsRequest", "" } } })
+                ->Event("LeaveSessionAsync", &AWSGameLiftSessionAsyncRequestBus::Events::LeaveSessionAsync);
+
+            behaviorContext->EBus<AzFramework::SessionAsyncRequestNotificationBus>("AWSGameLiftSessionAsyncRequestNotificationBus")
+                ->Attribute(AZ::Script::Attributes::Category, "AWSGameLift")
+                ->Handler<AWSGameLiftSessionAsyncRequestNotificationBusHandler>();
+
+            behaviorContext->EBus<AWSGameLiftSessionRequestBus>("AWSGameLiftSessionRequestBus")
+                ->Attribute(AZ::Script::Attributes::Category, "AWSGameLift")
+                ->Event("CreateSession", &AWSGameLiftSessionRequestBus::Events::CreateSession, { { { "CreateSessionRequest", "" } } })
+                ->Event("JoinSession", &AWSGameLiftSessionRequestBus::Events::JoinSession, { { { "JoinSessionRequest", "" } } })
+                ->Event("SearchSessions", &AWSGameLiftSessionRequestBus::Events::SearchSessions, { { { "SearchSessionsRequest", "" } } })
+                ->Event("LeaveSession", &AWSGameLiftSessionRequestBus::Events::LeaveSession);
+        }
+    }

    void AWSGameLiftClientSystemComponent::ReflectCreateSessionRequest(AZ::ReflectContext* context)
    {
@@ -43,6 +43,9 @@ namespace AWSGameLift
        void SetGameLiftClientManager(AZStd::unique_ptr<AWSGameLiftClientManager> gameliftClientManager);

    private:
+        static void ReflectGameLiftMatchmaking(AZ::ReflectContext* context);
+        static void ReflectGameLiftSession(AZ::ReflectContext* context);
+
        static void ReflectCreateSessionRequest(AZ::ReflectContext* context);
        static void ReflectSearchSessionsResponse(AZ::ReflectContext* context);

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <AzCore/RTTI/BehaviorContext.h>
+#include <AzCore/Serialization/EditContext.h>
+#include <AzCore/Serialization/SerializeContext.h>
+
+#include <Request/AWSGameLiftAcceptMatchRequest.h>
+
+namespace AWSGameLift
+{
+    void AWSGameLiftAcceptMatchRequest::Reflect(AZ::ReflectContext* context)
+    {
+        AzFramework::AcceptMatchRequest::Reflect(context);
+
+        if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
+        {
+            serializeContext->Class<AWSGameLiftAcceptMatchRequest, AzFramework::AcceptMatchRequest>()
+                ->Version(0);
+
+            if (AZ::EditContext* editContext = serializeContext->GetEditContext())
+            {
+                editContext->Class<AWSGameLiftAcceptMatchRequest>("AWSGameLiftAcceptMatchRequest", "")
+                    ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
+                    ->Attribute(AZ::Edit::Attributes::Visibility, AZ::Edit::PropertyVisibility::ShowChildrenOnly);
+            }
+        }
+
+        if (AZ::BehaviorContext* behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
+        {
+            behaviorContext->Class<AWSGameLiftAcceptMatchRequest>("AWSGameLiftAcceptMatchRequest")
+                ->Attribute(AZ::Script::Attributes::Storage, AZ::Script::Attributes::StorageType::Value)
+                ->Property("AcceptMatch", BehaviorValueProperty(&AWSGameLiftAcceptMatchRequest::m_acceptMatch))
+                ->Property("PlayerIds", BehaviorValueProperty(&AWSGameLiftAcceptMatchRequest::m_playerIds))
+                ->Property("TicketId", BehaviorValueProperty(&AWSGameLiftAcceptMatchRequest::m_ticketId));
+        }
+    }
+} // namespace AWSGameLift
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <AzCore/RTTI/BehaviorContext.h>
+#include <AzCore/Serialization/EditContext.h>
+#include <AzCore/Serialization/SerializeContext.h>
+
+#include <Request/AWSGameLiftStartMatchmakingRequest.h>
+
+namespace AWSGameLift
+{
+    void AWSGameLiftPlayerInformation::Reflect(AZ::ReflectContext* context)
+    {
+        if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
+        {
+            serializeContext->Class<AWSGameLiftPlayerInformation>()
+                ->Version(0)
+                ->Field("latencyInMs", &AWSGameLiftPlayerInformation::m_latencyInMs)
+                ->Field("playerAttributes", &AWSGameLiftPlayerInformation::m_playerAttributes)
+                ->Field("playerId", &AWSGameLiftPlayerInformation::m_playerId)
+                ->Field("team", &AWSGameLiftPlayerInformation::m_team);
+
+            if (AZ::EditContext* editContext = serializeContext->GetEditContext())
+            {
+                editContext->Class<AWSGameLiftPlayerInformation>("AWSGameLiftPlayerInformation", "")
+                    ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
+                    ->Attribute(AZ::Edit::Attributes::Visibility, AZ::Edit::PropertyVisibility::ShowChildrenOnly)
+                    ->DataElement(
+                        AZ::Edit::UIHandlers::Default, &AWSGameLiftPlayerInformation::m_latencyInMs, "LatencyInMs",
+                        "A set of values, expressed in milliseconds, that indicates the amount of latency that"
+                        "a player experiences when connected to AWS Regions")
+                    ->DataElement(
+                        AZ::Edit::UIHandlers::Default, &AWSGameLiftPlayerInformation::m_playerAttributes, "PlayerAttributes",
+                        "A collection of key:value pairs containing player information for use in matchmaking")
+                    ->DataElement(
+                        AZ::Edit::UIHandlers::Default, &AWSGameLiftPlayerInformation::m_playerId, "PlayerId",
+                        "A unique identifier for a player")
+                    ->DataElement(
+                        AZ::Edit::UIHandlers::Default, &AWSGameLiftPlayerInformation::m_team, "Team",
+                        "Name of the team that the player is assigned to in a match");
+            }
+        }
+
+        if (AZ::BehaviorContext* behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
+        {
+            behaviorContext->Class<AWSGameLiftPlayerInformation>("AWSGameLiftPlayerInformation")
+                ->Attribute(AZ::Script::Attributes::Storage, AZ::Script::Attributes::StorageType::Value)
+                ->Property("LatencyInMs", BehaviorValueProperty(&AWSGameLiftPlayerInformation::m_latencyInMs))
+                ->Property("PlayerAttributes", BehaviorValueProperty(&AWSGameLiftPlayerInformation::m_playerAttributes))
+                ->Property("PlayerId", BehaviorValueProperty(&AWSGameLiftPlayerInformation::m_playerId))
+                ->Property("Team", BehaviorValueProperty(&AWSGameLiftPlayerInformation::m_team));
+        }
+    }
+
+    void AWSGameLiftStartMatchmakingRequest::Reflect(AZ::ReflectContext* context)
+    {
+        AzFramework::StartMatchmakingRequest::Reflect(context);
+        AWSGameLiftPlayerInformation::Reflect(context);
+
+        if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
+        {
+            serializeContext->Class<AWSGameLiftStartMatchmakingRequest, AzFramework::StartMatchmakingRequest>()
+                ->Version(0)
+                ->Field("configurationName", &AWSGameLiftStartMatchmakingRequest::m_configurationName)
+                ->Field("players", &AWSGameLiftStartMatchmakingRequest::m_players);
+
+            if (AZ::EditContext* editContext = serializeContext->GetEditContext())
+            {
+                editContext->Class<AWSGameLiftStartMatchmakingRequest>("AWSGameLiftStartMatchmakingRequest", "")
+                    ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
+                    ->Attribute(AZ::Edit::Attributes::Visibility, AZ::Edit::PropertyVisibility::ShowChildrenOnly)
+                    ->DataElement(AZ::Edit::UIHandlers::Default, &AWSGameLiftStartMatchmakingRequest::m_configurationName, "ConfigurationName",
+                        "Name of the matchmaking configuration to use for this request")
+                    ->DataElement(AZ::Edit::UIHandlers::Default, &AWSGameLiftStartMatchmakingRequest::m_players, "Players",
+                        "Information on each player to be matched.");
+            }
+        }
+
+        if (AZ::BehaviorContext* behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
+        {
+            behaviorContext->Class<AWSGameLiftStartMatchmakingRequest>("AWSGameLiftStartMatchmakingRequest")
+                ->Attribute(AZ::Script::Attributes::Storage, AZ::Script::Attributes::StorageType::Value)
+                ->Property("TicketId", BehaviorValueProperty(&AWSGameLiftStartMatchmakingRequest::m_ticketId))
+                ->Property("ConfigurationName", BehaviorValueProperty(&AWSGameLiftStartMatchmakingRequest::m_configurationName))
+                ->Property("Players", BehaviorValueProperty(&AWSGameLiftStartMatchmakingRequest::m_players));
+        }
+    }
+} // namespace AWSGameLift
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <AzCore/RTTI/BehaviorContext.h>
+#include <AzCore/Serialization/EditContext.h>
+#include <AzCore/Serialization/SerializeContext.h>
+
+#include <Request/AWSGameLiftStopMatchmakingRequest.h>
+
+namespace AWSGameLift
+{
+    void AWSGameLiftStopMatchmakingRequest::Reflect(AZ::ReflectContext* context)
+    {
+        AzFramework::StopMatchmakingRequest::Reflect(context);
+
+        if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
+        {
+            serializeContext->Class<AWSGameLiftStopMatchmakingRequest, AzFramework::StopMatchmakingRequest>()
+                ->Version(0);
+
+            if (AZ::EditContext* editContext = serializeContext->GetEditContext())
+            {
+                editContext->Class<AWSGameLiftStopMatchmakingRequest>("AWSGameLiftStopMatchmakingRequest", "")
+                    ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
+                    ->Attribute(AZ::Edit::Attributes::Visibility, AZ::Edit::PropertyVisibility::ShowChildrenOnly);
+            }
+        }
+
+        if (AZ::BehaviorContext* behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
+        {
+            behaviorContext->Class<AWSGameLiftStopMatchmakingRequest>("AWSGameLiftStopMatchmakingRequest")
+                ->Attribute(AZ::Script::Attributes::Storage, AZ::Script::Attributes::StorageType::Value)
+                ->Property("TicketId", BehaviorValueProperty(&AWSGameLiftStopMatchmakingRequest::m_ticketId));
+        }
+    }
+} // namespace AWSGameLift