Dyson Swarm : Comment j'ai créé un jeu de science-fiction dur avec les services AWS

Un jeu de clicker de science-fiction difficile : Dyson Swarm

Je suis un passionné de science-fiction, ayant même dirigé un magazine de science-fiction pendant cinq ans. Cet amour m'a amené à créer une série de jeux courts expliquant de manière engageante des concepts complexes de science-fiction. Ma première création, Dyson Swarm, a vu le jour lors de l'AWS Game Builder Challenge.

Dyson Swarm est un jeu incrémentiel (clicker) dans lequel les joueurs démantelent le système solaire pour construire un essaim de Dyson – une mégastructure englobant le soleil. En commençant en tant que développeur de jeux, vous accumulez progressivement des ressources et progressez à travers les étapes.

J'avais initialement estimé 10 à 20 heures de développement, mais le projet s'est considérablement développé, consommant finalement environ 70 heures (surtout tard dans la nuit !). Cela met en évidence le défi des estimations précises du développement de logiciels.

Vous pouvez jouer au jeu ici : Dyson Swarm

Architecture AWS

Le jeu utilise Javascript côté client et s'exécute entièrement dans le navigateur. L'hébergement est réalisé à l'aide d'un compartiment de site statique S3, amélioré par CloudFront CDN pour une livraison mondiale à haut débit. CloudFront gère la terminaison TLS, simplifiant ainsi le processus.

Les métriques de jeu anonymes (nombre de joueurs et progression) sont stockées dans une base de données RDS Postgres. La transmission des données utilise une API sans serveur construite avec API Gateway et Lambda. Même si j'utilisais une instance RDS existante, le RDS sans serveur conviendrait également.

Le déploiement a exploité la console AWS pour S3 et CloudFront, ainsi qu'une pile AWS CDK (Python) pour les métriques sans serveur Lambda.

La pile CDK

La pile CDK pour les métriques sans serveur Lambda est concise :

<code class="language-python">from aws_cdk import (
    aws_lambda as lambda_,
    aws_apigateway as apigw,
    aws_ecr as ecr,
    aws_certificatemanager as acm,
    aws_route53 as route53,
    Duration,
    Stack)
from constructs import Construct
import os

class DysonSwarmStack(Stack):
    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
        super().__init__(scope, construct_id, **kwargs)

        repo = ecr.Repository.from_repository_name(self, "dysonSwarmRepo", "gamesapi")

        dyson_swarm_lambda = lambda_.DockerImageFunction(self,
            "dysonSwarmLambda",
            code=lambda_.DockerImageCode.from_ecr(
                repository=repo,
                tag=os.environ["CDK_DOCKER_TAG"]
            ),
            memory_size=256,
            timeout=Duration.seconds(60),
            architecture=lambda_.Architecture.ARM_64
        )

        # do auth inside lambda
        api = apigw.LambdaRestApi(self,
            "dysonSwarm-endpoint",
            handler=dyson_swarm_lambda,
            default_cors_preflight_options=apigw.CorsOptions(allow_origins=["*"])
        )

        custom_domain = apigw.DomainName(
            self,
            "custom-domain",
            domain_name="gameapi.compellingsciencefiction.com",
            certificate=acm.Certificate.from_certificate_arn(self,'cert',"[cert ARN here]"),
            endpoint_type=apigw.EndpointType.EDGE
        )

        apigw.BasePathMapping(
            self,
            "base-path-mapping",
            domain_name=custom_domain,
            rest_api=api
        )

        hosted_zone = route53.HostedZone.from_hosted_zone_attributes(
            self,
            "hosted-zone",
            hosted_zone_id="[zone id here]",
            zone_name="compellingsciencefiction.com"
        )

        route53.CnameRecord(
            self,
            "cname",
            zone=hosted_zone,
            record_name="gameapi",
            domain_name=custom_domain.domain_name_alias_domain_name
        )</code>

Il exploite un référentiel ECR existant (contenant l'image du conteneur Lambda) et une zone hébergée Route 53 (pour le domaine personnalisé). Essentiellement, il crée un point de terminaison API Gateway soutenu par une fonction Lambda. Le code complet est disponible sur : dyson_swarm_stack.py

Le Code

Le code source complet du jeu est sur GitHub : Dyson Swarm GitHub Repo

La boucle principale du jeu, trouvée dans dysonswarm.html, utilise un intervalle de 100 millisecondes. Le stockage du navigateur local (localStorage) gère la persistance de l'état du jeu. Les fonctions des boutons (56 au total) sont gérées dans buttonFunctions.js. Les animations du jeu, initialement SVG, ont été migrées vers Canvas pour de meilleures performances avec un grand nombre d'éléments. Des tests approfondis et des améliorations itératives ont résolu divers cas extrêmes dans la logique du jeu.

Utilisation du développeur AWS Q

L'AWS Game Builder Challenge encourage l'utilisation d'AWS Q Developer. Je l'ai trouvé utile :

Avantages :

• Interface de chat intuitive pour des réponses rapides.
• /dev la fonctionnalité génère et applique des différences de code, rationalisant ainsi le développement.
• Efficace pour répliquer des modèles de code.

Inconvénients :

• /dev la fonctionnalité peut être lente en raison de plusieurs appels LLM.
• /dev crée parfois de nouveaux fichiers au lieu d'ajouts de code en ligne. Une ingénierie rapide et minutieuse est cruciale.
• Possibilité d'amélioration, mais montre un potentiel important.

Jeu Open Source

Le code source du jeu est disponible sous licence MIT. N'hésitez pas à l'utiliser comme base pour vos projets. Je suis heureux d'entendre parler de vos créations de jeux !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!