Guild Raid Coordination

This workflow orchestrates a multi-phase guild raid. It validates the guild roster for eligibility and minimum size, generates an AI-powered raid strategy briefing via Amazon Bedrock, then runs three concurrent combat phases using a Parallel state — each independently resolved with its own loot table. After all phases complete, a final loot distribution step splits rewards across eligible guild members.

{
  "Comment": "Guild raid coordination — validates guild roster, generates a Bedrock raid strategy briefing, runs 3 combat phases in parallel, then distributes loot to eligible members.",
  "StartAt": "ValidateGuildRoster",
  "States": {
    "ValidateGuildRoster": {
      "Type": "Task",
      "Resource": "arn:aws:states:::lambda:invoke",
      "Parameters": {
        "FunctionName": "${ValidateGuildRosterFunctionArn}",
        "Payload.$": "$"
      },
      "ResultSelector": {
        "isValid.$": "$.Payload.isValid",
        "guildId.$": "$.Payload.guildId",
        "eligibleMembers.$": "$.Payload.eligibleMembers",
        "ineligibleMembers.$": "$.Payload.ineligibleMembers",
        "eligibleCount.$": "$.Payload.eligibleCount",
        "reason.$": "$.Payload.reason"
      },
      "ResultPath": "$.rosterValidation",
      "Retry": [
        {
          "ErrorEquals": [
            "Lambda.ServiceException",
            "Lambda.AWSLambdaException",
            "Lambda.SdkClientException"
          ],
          "IntervalSeconds": 2,
          "MaxAttempts": 3,
          "BackoffRate": 2.0
        }
      ],
      "Catch": [
        {
          "ErrorEquals": ["States.ALL"],
          "ResultPath": "$.error",
          "Next": "RosterValidationFailed"
        }
      ],
      "Next": "IsRosterValid"
    },
    "IsRosterValid": {
      "Type": "Choice",
      "Choices": [
        {
          "Variable": "$.rosterValidation.isValid",
          "BooleanEquals": false,
          "Next": "RosterValidationFailed"
        }
      ],
      "Default": "GenerateRaidBriefing"
    },
    "RosterValidationFailed": {
      "Type": "Fail",
      "Error": "RosterValidationFailed",
      "Cause": "Guild roster failed validation — not enough eligible members or members are inactive/banned"
    },
    "GenerateRaidBriefing": {
      "Type": "Task",
      "Resource": "arn:aws:states:::bedrock:invokeModel",
      "Parameters": {
        "ModelId": "anthropic.claude-3-5-sonnet-20241022-v2:0",
        "Body": {
          "anthropic_version": "bedrock-2023-05-31",
          "max_tokens": 220,
          "messages": [
            {
              "role": "user",
              "content.$": "States.Format('You are a dungeon master AI. Write a short, dramatic raid briefing (3-4 sentences) for a guild of {} warriors about to enter a {} difficulty raid. Describe the dangers ahead and the glory that awaits. Keep it epic and motivating.', $.rosterValidation.eligibleCount, $.difficulty)"
            }
          ]
        }
      },
      "ResultSelector": {
        "briefing.$": "$.Body.content[0].text"
      },
      "ResultPath": "$.raidBriefing",
      "Catch": [
        {
          "ErrorEquals": ["States.ALL"],
          "ResultPath": "$.raidBriefing",
          "Next": "ExecuteCombatPhases"
        }
      ],
      "Next": "ExecuteCombatPhases"
    },
    "ExecuteCombatPhases": {
      "Type": "Parallel",
      "Branches": [
        {
          "StartAt": "CombatPhase1",
          "States": {
            "CombatPhase1": {
              "Type": "Task",
              "Resource": "arn:aws:states:::lambda:invoke",
              "Parameters": {
                "FunctionName": "${ResolveCombatPhaseFunctionArn}",
                "Payload": {
                  "guildId.$": "$.rosterValidation.guildId",
                  "phase": 1,
                  "bossName": "Guardian of the Outer Gate",
                  "eligibleCount.$": "$.rosterValidation.eligibleCount",
                  "difficulty.$": "$.difficulty"
                }
              },
              "ResultSelector": {
                "phase.$": "$.Payload.phase",
                "bossName.$": "$.Payload.bossName",
                "result.$": "$.Payload.result",
                "loot.$": "$.Payload.loot"
              },
              "Retry": [
                {
                  "ErrorEquals": [
                    "Lambda.ServiceException",
                    "Lambda.AWSLambdaException",
                    "Lambda.SdkClientException"
                  ],
                  "IntervalSeconds": 2,
                  "MaxAttempts": 3,
                  "BackoffRate": 2.0
                }
              ],
              "End": true
            }
          }
        },
        {
          "StartAt": "CombatPhase2",
          "States": {
            "CombatPhase2": {
              "Type": "Task",
              "Resource": "arn:aws:states:::lambda:invoke",
              "Parameters": {
                "FunctionName": "${ResolveCombatPhaseFunctionArn}",
                "Payload": {
                  "guildId.$": "$.rosterValidation.guildId",
                  "phase": 2,
                  "bossName": "The Infernal Warden",
                  "eligibleCount.$": "$.rosterValidation.eligibleCount",
                  "difficulty.$": "$.difficulty"
                }
              },
              "ResultSelector": {
                "phase.$": "$.Payload.phase",
                "bossName.$": "$.Payload.bossName",
                "result.$": "$.Payload.result",
                "loot.$": "$.Payload.loot"
              },
              "Retry": [
                {
                  "ErrorEquals": [
                    "Lambda.ServiceException",
                    "Lambda.AWSLambdaException",
                    "Lambda.SdkClientException"
                  ],
                  "IntervalSeconds": 2,
                  "MaxAttempts": 3,
                  "BackoffRate": 2.0
                }
              ],
              "End": true
            }
          }
        },
        {
          "StartAt": "CombatPhase3",
          "States": {
            "CombatPhase3": {
              "Type": "Task",
              "Resource": "arn:aws:states:::lambda:invoke",
              "Parameters": {
                "FunctionName": "${ResolveCombatPhaseFunctionArn}",
                "Payload": {
                  "guildId.$": "$.rosterValidation.guildId",
                  "phase": 3,
                  "bossName": "The Molten Tyrant",
                  "eligibleCount.$": "$.rosterValidation.eligibleCount",
                  "difficulty.$": "$.difficulty"
                }
              },
              "ResultSelector": {
                "phase.$": "$.Payload.phase",
                "bossName.$": "$.Payload.bossName",
                "result.$": "$.Payload.result",
                "loot.$": "$.Payload.loot"
              },
              "Retry": [
                {
                  "ErrorEquals": [
                    "Lambda.ServiceException",
                    "Lambda.AWSLambdaException",
                    "Lambda.SdkClientException"
                  ],
                  "IntervalSeconds": 2,
                  "MaxAttempts": 3,
                  "BackoffRate": 2.0
                }
              ],
              "End": true
            }
          }
        }
      ],
      "ResultPath": "$.phases",
      "Catch": [
        {
          "ErrorEquals": ["States.ALL"],
          "ResultPath": "$.error",
          "Next": "CombatFailed"
        }
      ],
      "Next": "DistributeLoot"
    },
    "CombatFailed": {
      "Type": "Fail",
      "Error": "CombatFailed",
      "Cause": "One or more combat phases failed to resolve"
    },
    "DistributeLoot": {
      "Type": "Task",
      "Resource": "arn:aws:states:::lambda:invoke",
      "Parameters": {
        "FunctionName": "${DistributeLootFunctionArn}",
        "Payload": {
          "guildId.$": "$.rosterValidation.guildId",
          "members.$": "$.rosterValidation.eligibleMembers",
          "phases.$": "$.phases"
        }
      },
      "ResultSelector": {
        "guildId.$": "$.Payload.guildId",
        "totalLootItems.$": "$.Payload.totalLootItems",
        "memberCount.$": "$.Payload.memberCount",
        "distribution.$": "$.Payload.distribution",
        "distributedAt.$": "$.Payload.distributedAt"
      },
      "ResultPath": "$.lootDistribution",
      "Retry": [
        {
          "ErrorEquals": [
            "Lambda.ServiceException",
            "Lambda.AWSLambdaException",
            "Lambda.SdkClientException"
          ],
          "IntervalSeconds": 2,
          "MaxAttempts": 3,
          "BackoffRate": 2.0
        }
      ],
      "Catch": [
        {
          "ErrorEquals": ["States.ALL"],
          "ResultPath": "$.error",
          "Next": "LootDistributionFailed"
        }
      ],
      "Next": "RaidComplete"
    },
    "LootDistributionFailed": {
      "Type": "Fail",
      "Error": "LootDistributionFailed",
      "Cause": "Failed to distribute loot to guild members"
    },
    "RaidComplete": {
      "Type": "Succeed"
    }
  }
}
JSON
Expand
100%

Gaming teams can use patterns like this to build reliable, compliant, and scalable automation for payment systems and can test and refine these flows locally with Thrubit to reduce cloud cost and speed up iteration.

Free Trial