20 Eylül 2026 Pazar

MonoGame デスクトップゲームを Microsoft Store に公開する:完全な MSIX および WAP ガイド

MonoGame デスクトップゲームを Microsoft Store に公開する:完全な MSIX および WAP ガイド

Windows 10 および Windows 11 の Microsoft Store にインディーゲームを公開することは、世界中の何億人もの PC ゲーマーへの直接的なアクセス、バックグラウンドでの自動アップデート、Windows Game Bar との統合、コンテナ化されたインストール環境による安全性をもたらします。しかし、ゲームが MonoGame(.NET 8.0 または .NET 9.0 WindowsDX)で構築されている場合、ストアへの配信には伝統的な Win32 実行ファイル(.exe)を最新の MSIX / AppX アプリケーションモデルへ橋渡しするアーキテクチャが必要です。

Arar Games では、Paint Trek および Blocked: Pixel Panzer の開発を通じて、初期ビルドからストアでの本番公開に至るまでの全プロセスを確立しました。本ガイドでは、プロジェクトの構成、Visual Studio の Publish メニューオプションの理解、Package.appxmanifest の設定、タイルアセットの解像度スケーリング、Windows アプリ認定キット(WACK)の検証対応、そして Microsoft Partner Center への提出に至る実践的なノウハウを徹底解説します。


1. アーキテクチャの基礎:Win32 と MSIX の比較

MonoGame ゲームは通常、Win32 実行可能ファイル、ランタイムライブラリ(.dll)、およびコンパイル済みコンテンツ(.xnb テクスチャ、.ogg 音声、シェーダー)を含む Content/ フォルダとしてビルドされます。

Windows アプリケーション パッケージ化(WAP) プロジェクトを使用してゲームを MSIX bundle にカプセル化することで、以下のメリットが得られます:

  1. 分離された安全なライフサイクル: MSIX アプリケーションは分離されたコンテナ環境で実行されます。アンインストール時にはすべてのファイルとレジストリ項目が完全に削除され、OS 内にゴミを残しません。
  2. 動的なアーキテクチャとアセット配信: 1 つの .appxupload パッケージに x86x64 の両方のバイナリおよび各 DPI スケール(scale-100scale-400)が含まれます。ストアはユーザーの PC に必要なファイルのみをダウンロードさせるため、容量を大幅に節約できます。
  3. 自動クラッシュテレメトリ: Visual Studio はシンボルファイル(.appxsym)を自動的に同梱します。クラッシュ発生時には Partner Center 上で関数名や行番号を含むスタックトレースを確認できます。

2. プロジェクト構成と事前準備

メインゲームの .csproj でマルチプラットフォーム構成とアセットコピーを有効化します:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net9.0-windows</TargetFramework>
    <UseWindowsForms>true</UseWindowsForms>
    <Platforms>AnyCPU;x64;x86</Platforms>
  </PropertyGroup>
  <ItemGroup>
    <Content Include="Content\**\*.*">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
  </ItemGroup>
</Project>

NuGet パッケージの復元:

dotnet restore YourGame.Desktop.csproj -r win-x64
dotnet restore YourGame.Desktop.csproj -r win-x86

3. Visual Studio の Publish メニューの解説

WAP プロジェクトを右クリックして Publish を開くと、以下の 3 つの選択肢が表示されます:

  1. Associate App with the Store...(アプリをストアに関連付ける): パートナーセンターで予約したアプリ名を選択して公式 Publisher ID を取得し、Package.StoreAssociation.xml を自動生成します。
  2. Convert Content Group Map File(コンテンツグループ マップファイルの変換): 50GB を超える巨大ゲームのストリーミング分割インストール用です。インディーゲームでは不要です。
  3. Create App Packages...(アプリ パッケージの作成): ローカル実機テスト(Sideloading)やストア提出用アーカイブ(_bundle.appxupload)を出力するメインウィザードです。

4. パッケージ作成ウィザードの設定

  • 配布方法: ストア提出時は "Microsoft Store under a new or existing app name"、ローカルテスト時は "Sideloading" を選択します。
  • アーキテクチャ: ☑️ x86 と ☑️ x64 の両方にチェックを入れ、Release 構成を指定します。
  • バンドル設定: Generate app bundle: Always
  • バージョン管理規則: Major.Minor.Build.Revision(例: 1.0.0.0)。ストアにアップロードする新パッケージは、現在公開中のバージョン番号より必ず大きい必要がありますAutomatically increment を有効にするとリビジョンが自動加算されます。

5. Package.appxmanifest の要点

  • <rescap:Capability Name="runFullTrust" />: MonoGame は DirectX 11 やネイティブ API を使用するため、この設定でコンテナ内での完全なデスクトップ実行権限を付与します。
  • InitialRotationPreference="landscape": ROG Ally などのポータブル Windows ゲーミング端末向けに横画面を固定します。

Warning

BadgeLogo の絶対規則: ロック画面用アイコン(BadgeLogo)は、純白(#FFFFFF)ピクセルと透明ピクセルのみで構成されている必要があります。カラーピクセルが含まれていると WACK のコントラスト検証で失格となります。


7. WACK 検証とトラブルシューティング

  • "AppCert.exe wasn't found" エラー: Visual Studio Installer の「個別のコンポーネント」から「Windows アプリ認定キット」をインストールしてください。なおローカルでの WACK 実行は任意であり、ストアへ提出時にマイクロソフトのクラウド上で自動検証されます。
  • MonoGame アセットの誤検知: 圧縮された .xnb.ogg のバイト配列が実行ヘッダーと誤認されることがありますが、コンテンツフォルダ内の静的ファイルとして正常に承認されます。

8. サイドローディングによるローカル検証

AppPackages/YourGame_Test/ にて PowerShell を管理者権限で起動し、以下を実行します:

Set-ExecutionPolicy RemoteSigned -Scope Process
.\Add-AppDevPackage.ps1

実機でのゲームパッド動作や 60FPS の描画安定性を確認できます。


9. Microsoft Partner Center 提出チェックリスト

  1. Pricing and availability: 全 240 市場を選択し、米ドルで基準価格を設定(現地通貨へ自動換算)。
  2. Properties: カテゴリを Games に指定し、プライバシーポリシー URL を入力。
  3. Age ratings: IARC 質問票に回答(アーケードゲームは通常 Everyone / PEGI 3 を即時取得)。
  4. Store listings: 1920x1080 の PC プレイ画面スクリーンショットを登録。
  5. Packages: _bundle.appxupload をアップロードして Submit to the Store をクリック。

MonoGame 데스크톱 게임을 Microsoft Store에 게시하기: 완전한 MSIX 및 WAP 가이드

MonoGame 데스크톱 게임을 Microsoft Store에 게시하기: 완전한 MSIX 및 WAP 가이드

인디 게임을 Windows 10 및 Windows 11의 Microsoft Store에 출시하면 전 세계 수억 명의 PC 게이머에게 직접 도달할 수 있으며, 백그라운드 자동 업데이트, Windows Game Bar 통합, 샌드박스형 컨테이너 설치의 보안성을 누릴 수 있습니다. 그러나 게임이 MonoGame(.NET 8.0 또는 .NET 9.0 WindowsDX)으로 제작된 경우, 기존 Win32 실행 파일(.exe)을 현대적인 MSIX / AppX 애플리케이션 모델과 연결하는 아키텍처 파이프라인이 필요합니다.

Arar GamesPaint TrekBlocked: Pixel Panzer 출시를 통해 초기 컴파일부터 스토어 라이브 배포까지의 모든 과정을 성공적으로 구축했습니다. 본 가이드에서는 프로젝트 구성, Visual Studio의 Publish 메뉴 옵션 분석, Package.appxmanifest 작성, 타일 그래픽 스케일링, WACK 인증 오류 해결 및 Microsoft Partner Center 최종 제출까지의 전체 프로세스를 상세히 다룹니다.


1. 아키텍처 기반: Win32 vs MSIX

전통적인 MonoGame 게임은 표준 Win32 .exe, 런타임 라이브러리(.dll) 및 컴파일된 바이너리 에셋(.xnb 텍스처, .ogg 오디오, 셰이더)이 포함된 Content/ 폴더로 빌드됩니다.

Windows 애플리케이션 패키징(WAP) 프로젝트를 통해 게임을 MSIX bundle로 캡슐화하면 다음과 같은 핵심 이점을 얻을 수 있습니다:

  1. 격리된 컨테이너 라이프사이클: MSIX 앱은 격리된 가상 환경에서 실행되므로, 프로그램 삭제 시 모든 파일과 가상 레지스트리가 시스템에 찌꺼기를 남기지 않고 완벽하게 제거됩니다.
  2. 동적 아키텍처 및 리소스 전달: 단일 .appxupload 패키지에 x86x64 바이너리와 다양한 화면 배율(scale-100~scale-400)이 함께 번들링되어, 사용자 PC 사양에 맞는 파일만 다운로드되므로 다운로드 크기가 획기적으로 줄어듭니다.
  3. 자동 크래시 텔레메트리: Visual Studio가 디버그 심볼(.appxsym)을 번들에 자동 포함하므로, 사용자 기기에서 예외가 발생할 경우 Partner Center 콘솔에서 정확한 라인 번호와 함수명이 포함된 스택 추적을 즉시 확인할 수 있습니다.

2. 프로젝트 구성 및 빌드 설정

메인 게임 프로젝트의 .csproj에서 다중 플랫폼 및 콘텐츠 복사를 설정합니다:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net9.0-windows</TargetFramework>
    <UseWindowsForms>true</UseWindowsForms>
    <Platforms>AnyCPU;x64;x86</Platforms>
  </PropertyGroup>
  <ItemGroup>
    <Content Include="Content\**\*.*">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
  </ItemGroup>
</Project>

NuGet 패키지 복원:

dotnet restore YourGame.Desktop.csproj -r win-x64
dotnet restore YourGame.Desktop.csproj -r win-x86

3. Visual Studio Publish 메뉴 상세 분석

WAP 프로젝트 우클릭 후 Publish 선택 시 제공되는 3가지 옵션:

  1. Associate App with the Store... (스토어와 앱 연결): 파트너 센터에 예약된 게임명을 선택하여 공식 Publisher ID와 패밀리 네임을 가져오고 Package.StoreAssociation.xml을 자동 생성합니다.
  2. Convert Content Group Map File (콘텐츠 그룹 맵 파일 변환): 대용량 게임(50GB 이상)의 스트리밍 분할 설치용 기능입니다. 인디 게임은 안전하게 건너뛰어도 됩니다.
  3. Create App Packages... (앱 패키지 만들기): 로컬 QA 테스트(Sideloading) 또는 스토어 업로드용 패키지(_bundle.appxupload)를 빌드하는 핵심 도구입니다.

4. 패키지 생성 마법사 설정

  • 배포 방식: 스토어 제출은 "Microsoft Store under a new or existing app name", 로컬 테스트는 "Sideloading" 선택.
  • 아키텍처: ☑️ x86 및 ☑️ x64 모두 선택 (Release 구성).
  • 앱 번들 생성: Generate app bundle: Always.
  • 버전 관리 규칙: Major.Minor.Build.Revision(예: 1.0.0.0). 스토어에 새로 업로드하는 패키지 버전은 스토어의 기존 버전보다 반드시 높아야 합니다. Automatically increment를 켜두면 매 빌드 시 리비전 번호가 자동 증가합니다.

5. Package.appxmanifest 핵심 설정

  • <rescap:Capability Name="runFullTrust" />: MonoGame은 DirectX 11 및 네이티브 하드웨어 후킹을 사용하므로, 샌드박스 제한 없이 실행될 수 있도록 데스크톱 전체 권한을 부여합니다.
  • InitialRotationPreference="landscape": ASUS ROG Ally, Lenovo Legion Go 등 휴대용 Windows 게이밍 UMPC를 위해 가로 모드로 화면을 고정합니다.

Warning

BadgeLogo 엄격 규칙: 잠금 화면 뱃지 아이콘(BadgeLogo)은 반드시 순백색(#FFFFFF) 픽셀과 투명 배경으로만 구성되어야 합니다. 색상 픽셀이 포함되면 WACK 명암비 검사에서 거부됩니다.


7. WACK 검증 및 문제 해결

  • "AppCert.exe wasn't found" 오류: Visual Studio Installer의 개별 구성 요소 탭에서 "Windows App Certification Kit"을 설치하십시오. 로컬 검사는 선택 사항이며, 스토어 업로드 시 마이크로소프트 클라우드에서 자동으로 전체 검사를 수행합니다.
  • MonoGame 바이너리 오탐 (Blocked Executable): 압축된 .xnb.ogg 데이터가 실행 파일 시그니처와 우연히 일치하여 경고가 뜰 수 있으나, 정적 게임 콘텐츠로 정상 승인됩니다.

8. 로컬 사이드로딩 테스트

AppPackages/YourGame_Test/ 폴더에서 PowerShell을 관리자 권한으로 실행:

Set-ExecutionPolicy RemoteSigned -Scope Process
.\Add-AppDevPackage.ps1

컨테이너 환경에서 게임패드 지원과 60FPS 구동 상태를 사전 검증할 수 있습니다.


9. Microsoft Partner Center 제출 체크리스트

  1. Pricing and availability: 전 세계 240개 시장 선택 및 달러 기준가 설정.
  2. Properties: 카테고리 Games 지정 및 개인정보 처리방침(Privacy Policy) URL 등록.
  3. Age ratings: IARC 설문 완료 (아케이드 게임은 대개 Everyone / PEGI 3 등급 부여).
  4. Store listings: 1920x1080 순수 PC 게임플레이 스크린샷 업로드.
  5. Packages: _bundle.appxupload 업로드 후 Submit to the Store 클릭.

将 MonoGame 桌面游戏发布至 Microsoft Store:完整的 MSIX 与 WAP 指南

将 MonoGame 桌面游戏发布至 Microsoft Store:完整的 MSIX 与 WAP 指南

将独立游戏带到 Windows 10 和 Windows 11 的 Microsoft Store,使开发者能够直接触达数以亿计的 PC 玩家,享受系统级自动更新、Windows Game Bar 集成以及容器化安装的安全优势。然而,如果您的游戏是基于 MonoGame(.NET 8.0 或 .NET 9.0 WindowsDX)构建的,将其引入商店需要一座架构桥梁:将传统的 Win32 可执行文件(.exe)与现代化的 MSIX / AppX 应用模型连接起来。

Arar Games,我们凭借 Paint TrekBlocked: Pixel Panzer 两款作品走通了从代码编译到商店上线的全流程。本指南将全面拆解该工程管线:项目配置、Visual Studio 的 Publish 菜单选项解析、Package.appxmanifest 配置、磁贴图标尺寸缩放、解决 WACK 验证问题以及提交到 Microsoft Partner Center 的实战经验。


1. 架构基石:Win32 与 MSIX 对比

传统 MonoGame 游戏编译为标准的 Win32 应用程序,包含运行时 .dll 和存放已编译二进制资产(.xnb 纹理、.ogg 音频与着色器)的 Content/ 文件夹。

通过 Windows 应用打包 (WAP) 项目将其封装为 MSIX bundle 具有极高的技术价值:

flowchart TD
    subgraph Solution
        Shared["Shared Library"]
        Desktop["Desktop Project (.NET 9.0 WindowsDX)"]
        Shared --> Desktop
    end

    subgraph Packaging
        WAP["Windows App Packaging (.wapproj)"]
        Manifest["Package.appxmanifest"]
        StoreAssoc["Package.StoreAssociation.xml"]
        Desktop --> WAP
        Manifest --> WAP
        StoreAssoc --> WAP
    end

    subgraph Distribution
        WAP --> Sideload["Sideloading Package (*.appxbundle)"]
        WAP --> UploadBundle["Store Bundle (*_bundle.appxupload)"]
        UploadBundle --> MSStore["Microsoft Partner Center"]
    end

为什么选择 WAP 打包 MonoGame?

  1. 隔离的容器化生命周期: MSIX 应用在沙盒虚拟环境中运行。卸载时会干净彻底地删除所有文件和虚拟注册表项,不留系统垃圾。
  2. 动态架构与资源分发: 单个 .appxupload 包整合了 x86x64 双架构及多种 DPI 缩放资源(scale-100scale-400)。玩家仅下载适配自身设备的文件,大幅精简下载体积。
  3. 自动化崩溃遥测: Visual Studio 会将调试符号(.appxsym)自动打包。当游戏在玩家设备上发生崩溃时,Partner Center 控制台能呈现包含具体行号的完整调用堆栈。

2. 项目组织与配置

在主游戏项目的 .csproj 中配置多架构和内容输出:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net9.0-windows</TargetFramework>
    <UseWindowsForms>true</UseWindowsForms>
    <Platforms>AnyCPU;x64;x86</Platforms>
  </PropertyGroup>
  <ItemGroup>
    <Content Include="Content\**\*.*">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
  </ItemGroup>
</Project>

还原 NuGet 包:

dotnet restore YourGame.Desktop.csproj -r win-x64
dotnet restore YourGame.Desktop.csproj -r win-x86

3. Visual Studio Publish 菜单详解

右键点击 WAP 项目选择 Publish 时可见三个功能:

  1. Associate App with the Store...(将应用与商店关联): 登录开发者账号并选择已保留的应用名称,自动拉取正式的 Publisher ID、Package Family Name 并生成 Package.StoreAssociation.xml
  2. Convert Content Group Map File(转换内容组映射文件): 用于支持超大型游戏(50GB 以上)的流式渐进安装(Streaming Install)。独立游戏无需使用,可直接忽略。
  3. Create App Packages...(创建应用程序包): 主打包向导,用于生成本地测试安装包(Sideloading)或商店上架用的 _bundle.appxupload 包。

4. 打包向导配置实战

  • 分发方式: 提交商店选择 "Microsoft Store under a new or existing app name";本地 QA 测试选择 "Sideloading"
  • 架构选择: 勾选 ☑️ x86 与 ☑️ x64(Release 配置)。
  • 捆绑包设置: Generate app bundle: Always
  • 版本号硬性规则: 遵循 Major.Minor.Build.Revision(如 1.0.0.0)。提交到 Partner Center 的新包版本号必须严格高于商店当前生效的版本。勾选 Automatically increment 可以在每次编译时自动递增最后一位修订号。

5. Package.appxmanifest 关键配置

  • <rescap:Capability Name="runFullTrust" />:MonoGame 深度依赖 DirectX 11 和原生 Win32 调用,此受限功能赋予其完全桌面执行权限,同时兼具容器安装优势。
  • InitialRotationPreference="landscape":将屏幕锁定为横屏,适配 ASUS ROG Ally、联想 Legion Go 等 Windows 掌机。

Warning

锁屏角标 (BadgeLogo) 必须纯白: 锁屏图标必须仅由纯白像素 (#FFFFFF) 和透明通道组成。包含任何彩色像素都会导致 WACK 对比度合规检测失败。


7. WACK 验证与问题排查

  • "AppCert.exe wasn't found" 报错: 在 Visual Studio Installer 的独立组件中搜索并安装 "Windows App Certification Kit"。本地运行 WACK 是可选的,上传至商店后台后微软云端会自动执行验证。
  • MonoGame 资源误报 Blocked Executable: .xnb.ogg 二进制可能随机匹配可执行特征。微软商店审核系统能识别其为合法静态游戏数据,不影响审核通过。

8. 本地侧载测试 (Sideloading)

AppPackages/YourGame_Test/ 目录下,以管理员身份运行 PowerShell:

Set-ExecutionPolicy RemoteSigned -Scope Process
.\Add-AppDevPackage.ps1

验证手柄控制、音频播放和 60 帧流畅度。


9. Microsoft Partner Center 提交流程

  1. Pricing and availability: 选择全球 240 个市场,以美元设置基准价格。
  2. Properties: 选择 Games 分类并提供有效的隐私政策网址(Privacy Policy URL)。
  3. Age ratings: 完成 IARC 问卷评级(街机游戏通常获得 Everyone / PEGI 3)。
  4. Store listings: 上传 1920x1080 纯 PC 实机截图(不可带有移动端触摸摇杆)。
  5. Packages: 拖拽上传 _bundle.appxupload 文件,核对通过后点击 Submit to the Store

结语

通过 WAP 项目封装、配置 runFullTrust 与 x86/x64 混合打包,MonoGame 开发者无需重写 UWP 即可将原生 .NET 9 桌面游戏推向全球 Windows 玩家!

Publier des jeux de bureau MonoGame sur le Microsoft Store : Le guide complet MSIX et WAP

Publier des jeux de bureau MonoGame sur le Microsoft Store : Le guide complet MSIX et WAP

Publier un jeu indépendant sur le Microsoft Store sous Windows 10 et Windows 11 offre aux développeurs un accès direct à des centaines de millions de joueurs PC, des mises à jour automatiques en arrière-plan, l'intégration de la Windows Game Bar et la sécurité d'une installation conteneurisée. Cependant, si votre jeu est conçu avec MonoGame (.NET 8.0 ou .NET 9.0 WindowsDX), son déploiement sur le Store nécessite une passerelle architecturale : faire le lien entre un exécutable Win32 classique (.exe) et le modèle d'application moderne MSIX / AppX.

Chez Arar Games, nous avons validé l'ensemble de ce pipeline avec nos titres Paint Trek et Blocked: Pixel Panzer, de la compilation initiale à la publication finale. Dans ce guide technique, nous détaillons chaque étape : configuration des projets, maîtrise des options du menu Publish de Visual Studio, paramétrage du Package.appxmanifest, dimensionnement des tuiles graphiques, résolution des erreurs WACK et soumission sur le Microsoft Partner Center.


1. Fondations architecturales : Win32 vs MSIX

Les jeux MonoGame traditionnels se compilent en un binaire Win32 classique accompagné de bibliothèques d'exécution (.dll) et d'un dossier Content/ contenant les ressources compilées (textures .xnb, fichiers audio .ogg, shaders HLSL).

L'intégration du jeu dans un projet Windows Application Packaging (WAP) pour produire un MSIX bundle apporte des bénéfices déterminants :

  1. Cycle de vie conteneurisé et propre : Les applications MSIX s'exécutent dans un environnement isolé. Lors de la désinstallation, tous les fichiers et clés de registre virtualisées sont supprimés sans laisser aucun résidu.
  2. Distribution dynamique et taille réduite : Une archive unique .appxupload regroupe les binaires x86 et x64 ainsi que les packs de mise à l'échelle DPI (scale-100 à scale-400). Les joueurs ne téléchargent que les données adaptées à leur matériel.
  3. Télémétrie de crash automatisée : Visual Studio intègre les symboles de débogage (.appxsym). En cas d'erreur, le tableau de bord du Partner Center affiche la trace complète de la pile d'appels avec les numéros de ligne.

2. Hiérarchie et configuration du projet

Dans le fichier .csproj principal, configurez la prise en charge multiplateforme et la copie du contenu :

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net9.0-windows</TargetFramework>
    <UseWindowsForms>true</UseWindowsForms>
    <Platforms>AnyCPU;x64;x86</Platforms>
  </PropertyGroup>
  <ItemGroup>
    <Content Include="Content\**\*.*">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
  </ItemGroup>
</Project>

Restauration des packages NuGet :

dotnet restore YourGame.Desktop.csproj -r win-x64
dotnet restore YourGame.Desktop.csproj -r win-x86

3. Comprendre le menu Publish de Visual Studio

En faisant un clic droit sur le projet WAP puis en sélectionnant Publish, trois options apparaissent :

  1. Associate App with the Store... (Associer l'application au Store) : Connecte le projet à votre compte développeur, extrait les identifiants officiels et génère Package.StoreAssociation.xml.
  2. Convert Content Group Map File : Outil dédié à l'installation en streaming pour les jeux colossaux (+50 Go). Non requis pour les jeux indépendants.
  3. Create App Packages... (Créer les packages d'application) : L'assistant principal pour concevoir les paquets de test local (Sideloading) ou l'archive pour le Store (_bundle.appxupload).

4. Configuration de l'assistant de création de package

  • Méthode de distribution : Choisissez "Microsoft Store under a new or existing app name" pour le Store ou "Sideloading" pour vos tests internes.
  • Architectures : Cochez ☑️ x86 et ☑️ x64 en configuration Release.
  • Génération de bundle : Generate app bundle: Always.
  • Règle absolue de versioning : Format Major.Minor.Build.Revision (ex. 1.0.0.0). Tout nouveau paquet envoyé sur le Partner Center doit impérativement posséder un numéro de version supérieur au paquet actuellement publié. L'option Automatically increment incrémente automatiquement le numéro de révision à chaque build.

5. Maîtriser le fichier Package.appxmanifest

  • <rescap:Capability Name="runFullTrust" /> : MonoGame s'appuyant sur DirectX 11 et des appels natifs via SharpDX/SDL, cette autorisation accorde les privilèges complets d'exécution de bureau tout en préservant l'isolation MSIX.
  • InitialRotationPreference="landscape" : Verrouille l'orientation en mode paysage, indispensable pour les consoles PC portables (ASUS ROG Ally, Lenovo Legion Go).

Warning

Règle stricte du BadgeLogo : L'icône de l'écran de verrouillage (BadgeLogo) doit être exclusivement composée de pixels blancs purs (#FFFFFF) et de transparence. L'utilisation de couleurs ou de dégradés provoquera un échec au test de contraste WACK.


7. Validation WACK et résolution d'incidents

  • Erreur "AppCert.exe wasn't found" : Installez le composant Windows App Certification Kit depuis Visual Studio Installer. Le test local est facultatif : l'infrastructure cloud de Microsoft procède automatiquement à ces contrôles lors du téléversement.
  • Faux positifs sur les fichiers MonoGame : Les fichiers compressés .xnb ou .ogg peuvent fortuitement présenter des séquences d'octets proches d'en-têtes exécutables. La certification Microsoft les reconnaît comme du contenu statique de jeu et valide la publication.

8. Test local via Sideloading

Dans le répertoire AppPackages/YourGame_Test/, exécutez PowerShell en tant qu'administrateur :

Set-ExecutionPolicy RemoteSigned -Scope Process
.\Add-AppDevPackage.ps1

9. Liste de contrôle Microsoft Partner Center

  1. Tarification et disponibilité : Sélectionnez l'ensemble des 240 marchés mondiaux et définissez le prix de base en USD.
  2. Propriétés : Catégorie Games et lien vers votre politique de confidentialité (Privacy Policy URL).
  3. Classification d'âge (IARC) : Remplissez le formulaire (les jeux d'arcade obtiennent généralement Everyone / PEGI 3).
  4. Fiche du Store : Téléversez des captures d'écran PC en 1920x1080 (sans boutons tactiles mobiles).
  5. Packages : Glissez-déposez le fichier _bundle.appxupload et cliquez sur Submit to the Store.

MonoGame Masaüstü Oyunlarını Microsoft Store'da Yayınlama: Eksiksiz MSIX ve WAP Rehberi

MonoGame Masaüstü Oyunlarını Microsoft Store'da Yayınlama: Eksiksiz MSIX ve WAP Rehberi

Bağımsız bir oyunu Windows 10 ve Windows 11'deki Microsoft Store platformuna taşımak; geliştiricilere yüz milyonlarca PC oyuncusuna doğrudan erişim, arka planda otomatik güncellemeler, Windows Game Bar entegrasyonu ve güvenli yalıtılmış kurulum imkanı sağlar. Ancak oyununuz MonoGame (.NET 8.0 veya .NET 9.0 WindowsDX) ile geliştirilmişse, oyunu mağazaya sokmak özel bir mimari köprü gerektirir: standart bir Win32 masaüstü çalıştırılabilir dosyasını (.exe) modern MSIX / AppX uygulama modeline bağlamak.

Arar Games olarak Paint Trek ve Blocked: Pixel Panzer yapımlarımızla ilk derlemeden canlı mağaza dağıtımına kadar bu sürecin tüm aşamalarını bizzat deneyimledik. Bu rehberde; proje yapılandırmasından Visual Studio Publish seçeneklerine, Package.appxmanifest ayarlarından görsel kutucuk (tile) ölçeklemelerine, Windows Uygulama Sertifikasyon Kiti (WACK) doğrulamasından Microsoft Partner Center gönderimine kadar uçtan uca tüm teknik adımları ele alıyoruz.


1. Mimari Temel: Win32 ve MSIX Karşılaştırması

Geleneksel MonoGame oyunları; standart bir Win32 çalıştırılabilir dosyası (.exe), çalışma zamanı kütüphaneleri (.dll) ve derlenmiş ikili varlıkları içeren bir Content/ klasörü (.xnb dokuları, .ogg sesleri, sprite atlasları ve HLSL gölgelendiricileri) şeklinde derlenir.

Microsoft Store artık paketlenmemiş ham Win32 çalıştırılabilir dosyalarını da desteklese de, oyununuzu bir Windows Uygulama Paketleme (WAP) projesiyle sarmalayarak bir MSIX paketi (bundle) oluşturmak çok önemli avantajlar sunar:

flowchart TD
    subgraph "Oyun Kod Tabanı"
        Shared["Ortak Kütüphane (Shared)\n(Varlıklar, Sistemler, Oyun Durumu, Matematik)"]
        Desktop["Masaüstü Projesi (.NET 9.0 WindowsDX)\n(Win32 Executable Giriş Noktası)"]
        Shared --> Desktop
    end

    subgraph "Paketleme Katmanı (WAP Projesi)"
        WAP["Windows Uygulama Paketleme (.wapproj)\n(Microsoft Desktop Bridge)"]
        Manifest["Package.appxmanifest\n(Kimlik, İzinler, Görsel Varlıklar)"]
        StoreAssoc["Package.StoreAssociation.xml\n(Partner Center Eşleştirmesi)"]
        Desktop --> WAP
        Manifest --> WAP
        StoreAssoc --> WAP
    end

    subgraph "Çıktı ve Dağıtım"
        WAP -->|Create App Packages| Sideload["Sideloading Paketi\n(*.appxbundle + Add-AppDevPackage.ps1)"]
        WAP -->|Store Upload Modu| UploadBundle["Mağaza Yükleme Paketi\n(*_bundle.appxupload / *.msixupload)"]
        UploadBundle --> MSStore["Microsoft Partner Center\n(Canlı Mağaza Yayını)"]
    end

Neden MonoGame Projesini WAP ile Sarmalamalıyız?

  1. Yalıtılmış Konteyner Yaşam Döngüsü: MSIX uygulamaları izole bir sanal ortamda çalışır. Uygulama kaldırıldığında tüm dosyalar ve sanallaştırılmış kayıt defteri girdileri sistemde hiçbir çöp bırakmadan temizlenir.
  2. Dinamik Mimari ve Varlık Dağıtımı: Tek bir .appxupload paketi hem x86 hem de x64 ikililerini ve farklı ekran DPI ölçeklerini (scale-100 ile scale-400 arası) bir arada barındırır. Mağaza, kullanıcının bilgisayarına yalnızca gereken mimariyi ve ekran varlıklarını indirerek dosya boyutunu düşürür.
  3. Otomatik Çökme Analitiği: Visual Studio, genel hata ayıklama sembollerini (.appxsym) otomatik olarak yükleme arşivine ekler. Oyun bir oyuncunun cihazında çöktüğünde, Partner Center kontrol panelinde fonksiyon adları ve satır numaralarıyla tam çağrı yığınını (stack trace) görebilirsiniz.

2. Proje Hiyerarşisi ve Yapılandırması

Temiz bir MonoGame çözümü, oyun mantığı ile platform paketlemesini birbirinden ayırmalıdır:

SolutionDir/
│
├── YourGame.Shared/               # Çekirdek mekanikler, sistemler, seviyeler (Shared Library)
│   └── YourGame.Shared.csproj
│
├── YourGame.Desktop/              # Masaüstü giriş noktası (WinExe)
│   ├── Content/                   # MonoGame Content Pipeline varlıkları (.mgcb -> .xnb)
│   ├── Program.cs
│   └── YourGame.Desktop.csproj
│
└── YourGame.Package/              # Windows Uygulama Paketleme Projesi (.wapproj)
    ├── Images/                    # Ölçekli logolar, kutucuklar, açılış ekranı
    ├── Package.appxmanifest       # Kimlik, izinler, görsel öğeler
    ├── Package.StoreAssociation.xml
    └── YourGame.Package.wapproj

Adım 1: Ana Oyun Projesinin Yapılandırılması (.csproj)

Masaüstü projenizin çoklu mimari derlemeyi desteklediğinden emin olun:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net9.0-windows</TargetFramework>
    <UseWindowsForms>true</UseWindowsForms>
    <ApplicationHighDpiMode>PerMonitorV2</ApplicationHighDpiMode>
    <Platforms>AnyCPU;x64;x86</Platforms>
  </PropertyGroup>

  <!-- Paketleme sırasında oyun içeriğinin kopyalanmasını garantiye alın -->
  <ItemGroup>
    <Content Include="Content\**\*.*">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
  </ItemGroup>

  <ItemGroup>
    <PackageReference Include="MonoGame.Framework.WindowsDX" Version="3.8.*" />
    <PackageReference Include="MonoGame.Content.Builder.Task" Version="3.8.*" />
  </ItemGroup>
</Project>

Adım 2: Çoklu Platform NuGet Paketlerini Geri Yükleme

Paketleme öncesinde paketleri 64-bit ve 32-bit çalışma zamanları için açıkça geri yükleyin:

dotnet restore YourGame.Desktop.csproj -r win-x64
dotnet restore YourGame.Desktop.csproj -r win-x86

3. Visual Studio Publish Menüsü Seçenekleri

Visual Studio'da Windows Uygulama Paketleme projesine sağ tıklayıp Publish alt menüsünü açtığınızda üç ana seçenek görürsünüz:

graph TD
    Menu["WAP Projesine Sağ Tık > Publish"]
    Menu --> Opt1["1. Associate App with the Store..."]
    Menu --> Opt2["2. Convert Content Group Map File"]
    Menu --> Opt3["3. Create App Packages... (Ana İş Akışı)"]
    
    Opt1 --> Sync["Buluttaki Mağaza Kimliğini Yerel Manifest ile Senkronize Eder\n(Package.StoreAssociation.xml üretir)"]
    Opt2 --> Streaming["Akışlı Kurulum Harita Dosyasını Dönüştürür\n(Aşamalı indirme gerektiren devasa oyunlar için)"]
    Opt3 --> Wizards["Paket Üretim Sihirbazı:\n- Sideloading (Yerel QA Testleri)\n- Microsoft Store Yükleme Paketi (_bundle.appxupload)"]

1. Associate App with the Store... (Uygulamayı Mağaza ile İlişkilendir)

  • Amacı: Yerel Visual Studio çözümünüzü Microsoft Partner Center geliştirici hesabınızla doğrudan bağlar.
  • Ne Yapar: Geliştirici hesabınızla giriş yapıp rezerve ettiğiniz oyun adını seçersiniz. Visual Studio, Partner Center API'sine bağlanarak resmi Publisher ID, Package Name, Publisher Display Name ve Package Family Name (PFN) bilgilerini çeker ve Package.StoreAssociation.xml dosyasını oluşturur.
  • Neden Önemli: Bu ilişkilendirme yapılmazsa paketiniz geçici bir yerel sertifikayla imzalanır ve Partner Center yükleme sırasında kimlik uyuşmazlığı nedeniyle paketi reddeder.

2. Convert Content Group Map File (İçerik Grubu Harita Dosyası Dönüştürme)

  • Amacı: Microsoft'un Streaming Installation (Akışlı Yükleme) mimarisini destekler.
  • Ne Yapar: Devasa oyunlarda (örneğin 50+ GB AAA yapımlarda), oyuncunun oyunun ilk bölümünü oynarken kalan bölümlerin arka planda indirilmesine olanak tanır. Geliştiricinin yazdığı SourceAppxContentGroupMap.xml dosyasını derleme hattının anlayacağı nihai AppxContentGroupMap.xml dosyasına dönüştürür.
  • Bağımsız Oyunlar İçin Durumu: Tipik indie oyunlar için akışlı kurulum gereksizdir; bu seçeneği güvenle atlayabilirsiniz.

3. Create App Packages... (Uygulama Paketleri Oluştur - Ana Sihirbaz)

Oyununuzu yerel testler veya mağazaya yükleme amacıyla derlemek, imzalamak ve paketlemek için kullanılan ana araçtır.


4. Paket Oluşturma Sihirbazının Yapılandırılması

Publish \(\rightarrow\) Create App Packages... seçeneğine tıkladığınızda şu adımları izleyin:

Adım 1: Dağıtım Yöntemi Seçimi

  • Mağazaya Gönderim İçin: "Microsoft Store under a new or existing app name" seçeneğini işaretleyin. Bu seçenek paketi doğrulanmış bulut kimliğinize bağlar.
  • Yerel Test (Sideloading) İçin: "Sideloading" seçeneğini işaretleyin. Bu mod, geçici bir test sertifikası (.cer) ve PowerShell yükleme betiği (Add-AppDevPackage.ps1) ile başka bilgisayarlarda test edebileceğiniz bir paket üretir.

Adım 2: Paket Ayarları ve Mimari Yapılandırması

Yapılandırma penceresinde parametreleri belirleyin:

┌─────────────────────────────────────────────────────────────┐
│ Output location: .\AppPackages\                             │
│ Version: 1.0.0.0      [☑ Automatically increment]           │
│                                                             │
│ Generate app bundle: Always                                 │
│                                                             │
│ Mimariler:                                                  │
│   ☑ x86       Yapılandırma: Release (x86)                   │
│   ☑ x64       Yapılandırma: Release (x64)                   │
│   ☐ ARM       (Masaüstü Win32 oyunları için önerilmez)      │
│   ☐ ARM64     (Masaüstü Win32 oyunları için önerilmez)      │
│                                                             │
│ Seçenekler:                                                 │
│   ☑ Include public symbol files                             │
│   ☑ Generate artifacts to validate app with WACK            │
└─────────────────────────────────────────────────────────────┘

Sürüm Numaralandırma Mantığı:

Windows paketleri standart Semantik Sürümleme formatını izler: Major.Minor.Build.Revision.

  • İlk yayın genellikle 1.0.0.0 olarak başlar.
  • Küçük yamalarda revizyon artırılır (1.0.1.0), büyük özelliklerde ikincil veya birincil hane büyütülür (1.1.0.0, 2.0.0.0).
  • Katı Mağaza Kuralı: Partner Center'a yüklenen her yeni paketin sürüm numarası, mağazadaki aktif sürümden kesinlikle daha yüksek olmak zorundadır.
  • Automatically increment: Bu kutuyu işaretli bırakmak, her paket derlemesinde revizyon hanesini otomatik artırarak sürüm çakışmalarını engeller.

Neden x64 + x86 ve Generate app bundle: Always?

  • x64: Modern 64-bit Windows sistemlerini hedefler (PC oyuncularının %98'inden fazlası).
  • x86: Eski donanımlara sahip sistemler için geriye dönük uyumluluk sağlar.
  • Always Paketi: Visual Studio her iki mimariyi tek bir arşive (_bundle.appxupload) toplar; kullanıcılar yalnızca kendi sistemlerine uygun olan dosyaları indirir.

5. Package.appxmanifest Dosyasında Uzmanlaşma

Uygulama bildirimi; kimlik, çalışma yetkileri, görsel varlıklar ve ekran yönünü belirler:

<?xml version="1.0" encoding="utf-8"?>
<Package
  xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10"
  xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10"
  xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
  IgnorableNamespaces="uap rescap">

  <Identity
    Name="YourPublisher.YourGame"
    Publisher="CN=YOUR-OFFICIAL-PUBLISHER-ID"
    Version="1.0.0.0" />

  <Properties>
    <DisplayName>Oyununuzun Adı</DisplayName>
    <PublisherDisplayName>Stüdyo Adınız</PublisherDisplayName>
    <Logo>Images\StoreLogo.png</Logo>
  </Properties>

  <Dependencies>
    <TargetDeviceFamily Name="Windows.Universal" MinVersion="10.0.0.0" MaxVersionTested="10.0.0.0" />
    <TargetDeviceFamily Name="Windows.Desktop" MinVersion="10.0.17763.0" MaxVersionTested="10.0.26100.0" />
  </Dependencies>

  <Applications>
    <Application Id="App"
      Executable="$targetnametoken$.exe"
      EntryPoint="$targetentrypoint$">
      <uap:VisualElements
        DisplayName="Oyununuzun Adı"
        Description="MonoGame ile geliştirilmiş retro arcade nişancı oyunu."
        BackgroundColor="transparent"
        Square150x150Logo="Images\Square150x150Logo.png"
        Square44x44Logo="Images\Square44x44Logo.png">
        <uap:DefaultTile 
          Wide310x150Logo="Images\Wide310x150Logo.png"  
          Square71x71Logo="Images\SmallTile.png" 
          Square310x310Logo="Images\LargeTile.png" />
        <uap:SplashScreen Image="Images\SplashScreen.png" />
        <uap:LockScreen BadgeLogo="Images\BadgeLogo.png" Notification="badgeAndTileText"/>
        <uap:InitialRotationPreference>
          <uap:Rotation Preference="landscape"/>
        </uap:InitialRotationPreference>
      </uap:VisualElements>
    </Application>
  </Applications>

  <Capabilities>
    <Capability Name="internetClient" />
    <rescap:Capability Name="runFullTrust" />
  </Capabilities>
</Package>

Kritik Ayarlar:

  1. <rescap:Capability Name="runFullTrust" />: MonoGame WindowsDX; DirectX 11, donanım sürücüleri ve SharpDX/SDL üzerinden yerel Win32 çağrıları kullandığı için kısıtlı UWP sandbox'ında çalışamaz. runFullTrust izni, dosya yalıtımını korurken oyuna tam masaüstü çalıştırma yetkisi verir.
  2. InitialRotationPreference (landscape): Windows taşınabilir el konsolları (ASUS ROG Ally, Lenovo Legion Go vb.) dikey panellerle donatılmıştır. Ekran yönünün landscape olarak kilitlenmesi, oyunun yan veya ters açılmasını önler.

6. Görsel Varlık Ölçekleri ve BadgeLogo Kuralı

Windows Başlat Menüsü ve Görev Çubuğu farklı DPI çözünürlükleri (scale-100, scale-125, scale-150, scale-200, scale-400) kullanır. Eksik ölçekler bulanık simgelere veya doğrulama uyarılarına yol açar.

Varlık Türü Temel Boyut (scale-100) scale-200 scale-400 Açıklama
Square44x44Logo 44 x 44 px 88 x 88 px 176 x 176 px Görev çubuğu ve uygulama listesi simgesi
Square150x150Logo 150 x 150 px 300 x 300 px 600 x 600 px Orta boy Başlat Menüsü kutucuğu
Wide310x150Logo 310 x 150 px 620 x 300 px 1240 x 600 px Geniş Başlat Menüsü kutucuğu
LargeTile 310 x 310 px 620 x 620 px 1240 x 1240 px Büyük Başlat Menüsü kutucuğu
SmallTile 71 x 71 px 142 x 142 px 284 x 284 px Küçük Başlat Menüsü kutucuğu
SplashScreen 620 x 300 px 1240 x 600 px 2480 x 1200 px Başlangıç yükleme ekranı afişi
StoreLogo 50 x 50 px 100 x 100 px 200 x 200 px Mağaza kataloğu logo simgesi
BadgeLogo 24 x 24 px 48 x 48 px 96 x 96 px Kilit ekranı bildirim rozeti

Warning

Kilit Ekranı Rozeti (BadgeLogo) Kuralı: Kilit ekranı simgesi (BadgeLogo) kesinlikle yalnızca saf beyaz (#FFFFFF) ve şeffaf piksellerden oluşmalıdır. İçerisinde renkli pikseller veya ton geçişleri bulunursa, Windows Uygulama Sertifikasyon Kiti (WACK) kontrast uyumsuzluğu hatası vererek sertifikasyonu başarısız sayar.


7. Paket Doğrulama: WACK ve Sorun Giderme

Visual Studio derlemeyi tamamladığında Finished creating package ekranı açılır.

Yaygın Engel: "The tool AppCert.exe wasn't found" Hatası

Launch Windows App Certification Kit butonuna tıkladığınızda şu hata penceresiyle karşılaşabilirsiniz:

Microsoft Visual Studio:
The tool AppCert.exe wasn't found. Please ensure that the most recent 
installation of the Windows Software Development Kit includes the 
Windows App Certification Kit feature.

Neden Oluşur ve Nasıl Çözülür?

  • Visual Studio kurulumunda bazen WACK bileşeni seçilmemiş olabilir.
  • Çözüm: Visual Studio Installer \(\rightarrow\) Değiştir (Modify) \(\rightarrow\) Bağımsız Bileşenler (Individual components) sekmesine gidin \(\rightarrow\) "Windows App Certification Kit" araması yapıp kutuyu işaretleyin ve güncelleyin.
  • Alternatif: WACK testini yerel olarak çalıştırmak zorunlu değildir. Manifestiniz ve görselleriniz doğru yapılandırılmışsa, paketinizi doğrudan Microsoft Partner Center'a yükleyebilirsiniz; Microsoft'un bulut altyapısı bu sertifikasyon testlerini arka planda otomatik olarak yürütür.

MonoGame İkili Dosyalarında "Engellenen Yürütülebilir Dosya" Yanılgısı

WACK yerel testinde derlenmiş doku (.xnb) veya ses (.ogg) dosyalarınızın "Blocked Executables" başlığı altında listelendiğini görebilirsiniz.

Bu Neden Olur? Sıkıştırılmış oyun varlıklarındaki bayt dizilimleri tesadüfen çalıştırılabilir PE başlıklarına benzeyebilir. Bu dosyalar oyunun Content/ klasöründe statik varlık olarak bulunduğu ve doğrudan yürütülmediği sürece, Microsoft sertifikasyon ekibi bunları zararsız oyun içeriği olarak tanır ve mağaza onayını etkilemez.


8. Sideloading: Mağaza Öncesi Yerel Cihaz Testi

Paketi mağazaya göndermeden önce temiz bir bilgisayarda test edin:

  1. Üretilen test klasörüne gidin:
    AppPackages/YourGame_1.0.0.0_Test/
    
  2. Bu klasörde şunlar yer alır:
    • YourGame_1.0.0.0_x86_x64.appxbundle (veya .msixbundle)
    • YourGame_1.0.0.0_x86_x64.cer (Yerel geliştirici test sertifikası)
    • Add-AppDevPackage.ps1 (PowerShell kurulum betiği)
  3. PowerShell'i Yönetici Olarak Çalıştırın ve komutu yürütün:
    Set-ExecutionPolicy RemoteSigned -Scope Process
    .\Add-AppDevPackage.ps1
    
  4. Geliştirici sertifikasını güvenli kılmak için ekrandaki adımları onaylayın.
  5. Oyunu Başlat Menüsü'nden açarak kumanda kontrollerini, sesleri ve performansı konteyner ortamında doğrulayın.

9. Microsoft Partner Center Gönderim Kontrol Listesi

Hazırladığınız _bundle.appxupload dosyası ile Microsoft Partner Center paneline gidin:

Dashboard > Apps & Games > [Oyununuzun Adı] > Start submission
  1. Pricing and Availability (Fiyatlandırma ve Kullanılabilirlik): Pazar seçimini All worldwide markets (240 bölge) olarak belirleyin ve USD cinsinden taban fiyatı girin. Yerel para birimleri otomatik çevrilir.
  2. Properties & Privacy Policy: Kategoriyi Games yapıp alt türleri seçin. Manifest'te internetClient izni bulunduğu için çalışan bir Gizlilik Politikası URL'si (GitHub sayfası vb.) girin.
  3. Age Ratings (IARC Yaş Derecelendirmesi): Anketi gerçekçi doldurun. Arcade oyunlar genellikle doğrudan Everyone / PEGI 3 derecesi alır.
  4. Store Listings: 1920x1080 çözünürlükte PC oynanış ekran görüntüleri yükleyin (üzerinde mobil dokunmatik kontroller olmamalıdır).
  5. Packages: ..._bundle.appxupload dosyasını sürükleyip bırakın. Yeşil onayları aldıktan sonra Submit to the Store butonuna basarak incelemeyi başlatın.

10. MSBuild ile CI/CD Otomasyonu

GitHub Actions veya yerel betiklerle Visual Studio arayüzünü açmadan komut satırından paket üretmek için:

msbuild YourGame.Package\YourGame.Package.wapproj `
  /p:Configuration=Release `
  /p:Platform=x64 `
  /p:AppxBundlePlatforms="x86|x64" `
  /p:AppxBundle=Always `
  /p:UapAppxPackageBuildMode=StoreUpload `
  /p:AppxPackageDir=".\AppPackages\"

Bu komutu Microsoft Store Submission API ile birleştirerek, Git etiketleriniz üzerinden mağazaya otomatik güncelleme gönderebilirsiniz.


Sonuç

Bir MonoGame masaüstü oyununu Microsoft Store'da yayınlamak, kod tabanını UWP için yeniden yazmayı gerektirmez. Windows Uygulama Paketleme (WAP) projesi, tam güven (runFullTrust) yetkisi, standart ölçekli varlıklar ve hibrit x86|x64 paketleri ile modern, güvenilir ve küresel bir mağaza varlığı elde edebilirsiniz!

Publishing MonoGame Desktop Games to Microsoft Store: The Complete MSIX & WAP Guide

Publishing MonoGame Desktop Games to Microsoft Store: The Complete MSIX & WAP Guide

Bringing an indie game to the Microsoft Store on Windows 10 and Windows 11 gives developers direct access to hundreds of millions of PC players, seamless updates, Windows Game Bar integration, and containerized installation safety. However, if your game is built with MonoGame (.NET 8.0 or .NET 9.0 WindowsDX), getting it into the store presents a unique architectural challenge: bridging a standard Win32 desktop executable (.exe) with the modern MSIX / AppX application model.

At Arar Games, we have walked this road from initial compilation to live store distribution with titles like Paint Trek and Blocked: Pixel Panzer. In this battle-tested guide, we break down the end-to-end technical pipeline: configuring your projects, navigating Visual Studio's Publish options, mastering the Package.appxmanifest, scaling visual tile assets, resolving Windows App Certification Kit (WACK) errors, and submitting your production bundle to the Microsoft Partner Center.


1. Architectural Foundation: Win32 vs. MSIX

Traditional MonoGame games compile into a standard Win32 executable accompanied by framework runtime .dll files and a Content/ directory containing compiled binary assets (.xnb textures, .ogg audio, sprite sheets, and compiled HLSL shaders).

While Microsoft Store supports distributing loose unpackaged Win32 executables, wrapping your game inside a Windows Application Packaging (WAP) project to produce an MSIX bundle provides substantial technical and operational benefits:

flowchart TD
    subgraph "Game Codebase"
        Shared["Shared Library\n(Entities, Systems, Game State, Math)"]
        Desktop["Desktop Project (.NET 9.0 WindowsDX)\n(Win32 Executable Entry Point)"]
        Shared --> Desktop
    end

    subgraph "Packaging Layer (WAP Project)"
        WAP["Windows App Packaging (.wapproj)\n(Microsoft Desktop Bridge)"]
        Manifest["Package.appxmanifest\n(Identity, Capabilities, Tile Assets)"]
        StoreAssoc["Package.StoreAssociation.xml\n(Partner Center Binding)"]
        Desktop --> WAP
        Manifest --> WAP
        StoreAssoc --> WAP
    end

    subgraph "Output & Distribution"
        WAP -->|Create App Packages| Sideload["Sideloading Package\n(*.appxbundle + Add-AppDevPackage.ps1)"]
        WAP -->|Store Upload Mode| UploadBundle["Store Upload Bundle\n(*_bundle.appxupload / *.msixupload)"]
        UploadBundle --> MSStore["Microsoft Partner Center\n(Live Store Ingestion)"]
    end

Why Wrap MonoGame in a WAP Project?

  1. Isolated Containerized Lifecycle: MSIX applications run in an isolated environment. Files, virtualized registry entries, and runtime states are cleanly removed upon uninstallation, leaving zero system clutter.
  2. Dynamic Architecture & Asset Streaming: A single .appxupload bundle packages x86 and x64 binaries together with multiple DPI scale packs (scale-100 through scale-400). Windows Store delivers only the required architecture and screen assets for each player's device, significantly reducing download sizes.
  3. Automated Crash Telemetry: Visual Studio packages your debugging symbols (.appxsym) into the upload bundle. If your game encounters an unhandled exception on a player's machine, the Microsoft Partner Center analytics dashboard displays the exact stack trace with function names and line numbers.

2. Project Hierarchy & Configuration

A clean MonoGame solution should maintain strict separation between platform-agnostic game logic and platform packaging:

SolutionDir/
│
├── YourGame.Shared/               # Core game mechanics, systems, levels, entities
│   └── YourGame.Shared.csproj
│
├── YourGame.Desktop/              # Main desktop entry point (WinExe)
│   ├── Content/                   # MonoGame Content Pipeline assets (.mgcb -> .xnb)
│   ├── Program.cs
│   └── YourGame.Desktop.csproj
│
└── YourGame.Package/              # Windows App Packaging Project (.wapproj)
    ├── Images/                    # Scaled logos, tiles, splash screen
    ├── Package.appxmanifest       # Identity, capabilities, visual elements
    ├── Package.StoreAssociation.xml
    └── YourGame.Package.wapproj

Step 1: Main Game Project Configuration (.csproj)

Ensure your desktop project is configured for multi-architecture building:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net9.0-windows</TargetFramework>
    <UseWindowsForms>true</UseWindowsForms>
    <ApplicationHighDpiMode>PerMonitorV2</ApplicationHighDpiMode>
    <Platforms>AnyCPU;x64;x86</Platforms>
  </PropertyGroup>

  <!-- Ensure game content is copied during packaging -->
  <ItemGroup>
    <Content Include="Content\**\*.*">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
  </ItemGroup>

  <ItemGroup>
    <PackageReference Include="MonoGame.Framework.WindowsDX" Version="3.8.*" />
    <PackageReference Include="MonoGame.Content.Builder.Task" Version="3.8.*" />
  </ItemGroup>
</Project>

Step 2: Multi-Platform NuGet Restoration

Before compiling a multi-architecture bundle, restore packages explicitly for both 64-bit and 32-bit runtimes:

dotnet restore YourGame.Desktop.csproj -r win-x64
dotnet restore YourGame.Desktop.csproj -r win-x86

3. Demystifying Visual Studio's Publish Menu

When you right-click your Windows Application Packaging project in Visual Studio and expand the Publish submenu, you are presented with three distinct options:

graph TD
    Menu["Right Click WAP Project > Publish"]
    Menu --> Opt1["1. Associate App with the Store..."]
    Menu --> Opt2["2. Convert Content Group Map File"]
    Menu --> Opt3["3. Create App Packages... (Primary Workflow)"]
    
    Opt1 --> Sync["Synchronizes Cloud App Identity with Local Manifest\n(Generates Package.StoreAssociation.xml)"]
    Opt2 --> Streaming["Streaming Install Asset Conversion\n(For massive games with staged downloads)"]
    Opt3 --> Wizards["Package Wizard:\n- Sideloading (Local QA Testing)\n- Microsoft Store Upload (_bundle.appxupload)"]

1. Associate App with the Store...

  • Purpose: Connects your local Visual Studio solution with your Microsoft Partner Center developer account.
  • What It Does: You sign in with your developer credentials and select your reserved app name. Visual Studio queries the Partner Center API, retrieves your official Publisher ID, Package Name, Publisher Display Name, and Package Family Name (PFN), and generates Package.StoreAssociation.xml.
  • Why It Matters: Without this association, your package will be signed with a temporary local certificate that Microsoft Partner Center will immediately reject upon upload due to identity mismatches.

2. Convert Content Group Map File

  • Purpose: Supports Microsoft's Streaming Installation architecture.
  • What It Does: In massive games (e.g., 50+ GB AAA titles), streaming install allows users to launch the first level while subsequent game content downloads in the background. Developers write a SourceAppxContentGroupMap.xml (which supports wildcards), and this menu command transforms it into the final AppxContentGroupMap.xml required by the Windows packaging pipeline.
  • Relevance for Indie Titles: For standard indie games (under a few gigabytes), streaming installation is unnecessary. You can safely ignore this option.

3. Create App Packages... (The Main Production Wizard)

This is the core tool you will use to build, sign, and package your game for QA testing and store submission.


4. Configuring the Package Creation Wizard

When you click Publish \(\rightarrow\) Create App Packages..., follow this exact production workflow:

Step 1: Select Distribution Method

  • For Store Submission: Select "Microsoft Store under a new or existing app name". This links the build to your verified cloud identity and optimizes the archive for Microsoft Store signing.
  • For Local QA / Sideloading: Select "Sideloading". This creates a .msixbundle or .appxbundle signed with a generated test certificate (.cer) along with installation scripts (Add-AppDevPackage.ps1), allowing you to test on other PCs without publishing.

Step 2: Select and Configure Packages

On the configuration screen, adjust the parameters:

┌─────────────────────────────────────────────────────────────┐
│ Output location: .\AppPackages\                             │
│ Version: 1.0.0.0      [☑ Automatically increment]           │
│                                                             │
│ Generate app bundle: Always                                 │
│                                                             │
│ Architectures:                                              │
│   ☑ x86       Configuration: Release (x86)                  │
│   ☑ x64       Configuration: Release (x64)                  │
│   ☐ ARM       (Not recommended for desktop Win32 games)     │
│   ☐ ARM64     (Not recommended for desktop Win32 games)     │
│                                                             │
│ Options:                                                    │
│   ☑ Include public symbol files                             │
│   ☑ Generate artifacts to validate app with WACK            │
└─────────────────────────────────────────────────────────────┘

Understanding Version Numbering:

Windows packaging follows standard Semantic Versioning: Major.Minor.Build.Revision.

  • Initial release starts at 1.0.0.0.
  • Minor patches increment revision (1.0.1.0), while major releases increment the minor or major digits (1.1.0.0, 2.0.0.0).
  • The Absolute Store Rule: Every new package uploaded to Microsoft Partner Center must have a higher version number than the currently active package.
  • Automatically increment: Keeping this checked increments the Revision digit with every build, preventing accidental upload rejections due to duplicate version numbers.

Why x64 + x86 with Generate app bundle: Always?

  • x64: Targets modern 64-bit Windows installations (98%+ of desktop PC gamers).
  • x86: Provides fallback compatibility for older 32-bit hardware.
  • Always Bundle: Visual Studio bundles both architectures into a single archive (_bundle.appxupload). Players only download the specific binary for their processor architecture.

5. Mastering Package.appxmanifest

The manifest defines runtime requirements, visual assets, display orientation, and permissions:

<?xml version="1.0" encoding="utf-8"?>
<Package
  xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10"
  xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10"
  xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
  IgnorableNamespaces="uap rescap">

  <Identity
    Name="YourPublisher.YourGame"
    Publisher="CN=YOUR-OFFICIAL-PUBLISHER-ID"
    Version="1.0.0.0" />

  <Properties>
    <DisplayName>Your Game Title</DisplayName>
    <PublisherDisplayName>Your Studio Name</PublisherDisplayName>
    <Logo>Images\StoreLogo.png</Logo>
  </Properties>

  <Dependencies>
    <TargetDeviceFamily Name="Windows.Universal" MinVersion="10.0.0.0" MaxVersionTested="10.0.0.0" />
    <TargetDeviceFamily Name="Windows.Desktop" MinVersion="10.0.17763.0" MaxVersionTested="10.0.26100.0" />
  </Dependencies>

  <Applications>
    <Application Id="App"
      Executable="$targetnametoken$.exe"
      EntryPoint="$targetentrypoint$">
      <uap:VisualElements
        DisplayName="Your Game Title"
        Description="An action-packed 2D arcade shooter built with MonoGame."
        BackgroundColor="transparent"
        Square150x150Logo="Images\Square150x150Logo.png"
        Square44x44Logo="Images\Square44x44Logo.png">
        <uap:DefaultTile 
          Wide310x150Logo="Images\Wide310x150Logo.png"  
          Square71x71Logo="Images\SmallTile.png" 
          Square310x310Logo="Images\LargeTile.png" />
        <uap:SplashScreen Image="Images\SplashScreen.png" />
        <uap:LockScreen BadgeLogo="Images\BadgeLogo.png" Notification="badgeAndTileText"/>
        <uap:InitialRotationPreference>
          <uap:Rotation Preference="landscape"/>
        </uap:InitialRotationPreference>
      </uap:VisualElements>
    </Application>
  </Applications>

  <Capabilities>
    <Capability Name="internetClient" />
    <rescap:Capability Name="runFullTrust" />
  </Capabilities>
</Package>

Essential Settings:

  1. <rescap:Capability Name="runFullTrust" />: Because MonoGame relies on DirectX 11, unmanaged hardware drivers, and raw Win32 message handling via SharpDX or SDL, it cannot execute inside a sandbox app-container. runFullTrust grants desktop privileges while retaining containerized file safety.
  2. InitialRotationPreference set to landscape: Windows gaming handhelds (e.g., ASUS ROG Ally, Lenovo Legion Go, GPD Win) run portrait-native displays with hardware rotation. Explicitly setting landscape prevents the game from opening sideways or flipped.

6. The Visual Asset Scaling Grid & The BadgeLogo Trap

Windows displays application icons across varying desktop DPI settings (scale-100, scale-125, scale-150, scale-200, scale-400). Missing scale variations cause blurry rendering or validation warnings.

Asset Type Base Size (scale-100) scale-200 scale-400 Purpose
Square44x44Logo 44 x 44 px 88 x 88 px 176 x 176 px Taskbar and Start app list
Square150x150Logo 150 x 150 px 300 x 300 px 600 x 600 px Medium Start Menu tile
Wide310x150Logo 310 x 150 px 620 x 300 px 1240 x 600 px Wide Start Menu tile
LargeTile 310 x 310 px 620 x 620 px 1240 x 1240 px Large Start Menu tile
SmallTile 71 x 71 px 142 x 142 px 284 x 284 px Small Start Menu tile
SplashScreen 620 x 300 px 1240 x 600 px 2480 x 1200 px Initial launch window banner
StoreLogo 50 x 50 px 100 x 100 px 200 x 200 px Store catalog tile
BadgeLogo 24 x 24 px 48 x 48 px 96 x 96 px Lock screen notification badge

Warning

The Monochrome BadgeLogo Requirement: The lock screen badge (BadgeLogo) must consist strictly of pure white (#FFFFFF) pixels and alpha transparency. If you include colored pixels or gradients in your BadgeLogo assets, Windows App Certification Kit (WACK) will flag a contrast violation and fail certification.


7. Package Verification: WACK & Troubleshooting

Once Visual Studio finishes building, the Finished creating package screen appears:

Output location: [Your Solution Dir]\AppPackages\
Package that will be validated: ...\YourApp_1.0.0.0_x86_x64.appxbundle

Common Obstacle: "The tool AppCert.exe wasn't found"

Clicking Launch Windows App Certification Kit might trigger this error:

Microsoft Visual Studio:
The tool AppCert.exe wasn't found. Please ensure that the most recent 
installation of the Windows Software Development Kit includes the 
Windows App Certification Kit feature.

Why This Occurs & How to Resolve It:

  • Visual Studio's default workload installation sometimes omits the standalone WACK binary.
  • Resolution: Open Visual Studio Installer \(\rightarrow\) Modify \(\rightarrow\) Navigate to Individual components \(\rightarrow\) Search for "Windows App Certification Kit" \(\rightarrow\) Check the box and complete the installation.
  • Alternative: Running WACK locally is optional. If your manifest and assets are properly configured, you can proceed directly to uploading your package to Microsoft Partner Center. Microsoft's cloud ingestion pipeline runs comprehensive automated certification tests automatically upon submission.

The MonoGame "Blocked Executable" False Positive

When running WACK against a MonoGame application, you might observe a warning listing compiled texture files (.xnb) or audio streams (.ogg) as potential unverified executables.

Why does this happen? Compressed binary data inside .xnb or .ogg files can coincidentally match byte patterns of portable executable (PE) headers. As long as these files reside strictly inside your game's Content/ directory and are not executed via system calls, Microsoft's certification team acknowledges them as static game assets and approves the submission without issue.


8. Sideloading: Testing Before Store Submission

Before submitting to the store, verify your packaged build on a clean machine:

  1. Locate the test output folder:
    AppPackages/YourGame_1.0.0.0_Test/
    
  2. In this folder, you will find:
    • YourGame_1.0.0.0_x86_x64.appxbundle (or .msixbundle)
    • YourGame_1.0.0.0_x86_x64.cer (Local test signing certificate)
    • Add-AppDevPackage.ps1 (PowerShell installer)
  3. Right-click PowerShell and select Run as Administrator, then execute:
    Set-ExecutionPolicy RemoteSigned -Scope Process
    .\Add-AppDevPackage.ps1
    
  4. Follow the interactive prompts to trust the development certificate and install the app.
  5. Launch the game directly from the Windows Start Menu to confirm that gamepad controls, high-DPI scaling, audio playback, and graphics rendering perform smoothly in the containerized environment.

9. Microsoft Partner Center Submission Checklist

With your verified _bundle.appxupload file ready, log in to Microsoft Partner Center:

Dashboard > Apps & Games > [Your Game Title] > Start submission

1. Pricing and Availability

  • Markets: Select All worldwide markets (240 territories).
  • Base Price: Set your price in USD (e.g., $0.99 or Free). Microsoft automatically converts regional prices into local currencies.

2. Properties & Privacy Policy

  • Category: Set to Games \(\rightarrow\) Select up to 3 relevant subgenres (e.g., Action + adventure, Shooter, Arcade).
  • Privacy Policy URL: Because the manifest declares <Capability Name="internetClient" />, Microsoft mandates an active privacy policy URL (a GitHub repository page or website link is sufficient).
  • Game Settings: Check Single player \(\rightarrow\) PC.

3. Age Ratings (IARC Questionnaire)

  • Complete the International Age Rating Coalition (IARC) questionnaire.
  • Accurately declare that your arcade game does not feature graphic gore, profanity, or real-money gambling. Arcade titles like Paint Trek or Blocked typically receive an Everyone / PEGI 3 rating immediately.

4. Store Listings & ASO (App Store Optimization)

  • Description: Detail your game mechanics, weapon systems, level progression, and controller support.
  • Screenshots: Upload 1920x1080 (16:9) PC screenshots showing actual gameplay. Ensure your desktop screenshots do not show mobile on-screen touch joysticks!
  • Keywords: Add relevant search tags (e.g., monogame, pixel, arcade, retro, shooter).

5. Package Upload & Ingestion

  • Navigate to Packages and drag-and-drop your ..._bundle.appxupload file.
  • Partner Center will parse the archive, verify x86 and x64 architectures, extract symbol files, and confirm capabilities.
  • Once all sections display green checkmarks, click Submit to the Store. Certification typically completes within 24 to 72 hours.

10. Automation: Headless MSBuild Pipeline

For automated CI/CD pipelines (GitHub Actions, Azure DevOps, or local automation scripts), you can compile your WAP project directly via MSBuild without opening Visual Studio:

msbuild YourGame.Package\YourGame.Package.wapproj `
  /p:Configuration=Release `
  /p:Platform=x64 `
  /p:AppxBundlePlatforms="x86|x64" `
  /p:AppxBundle=Always `
  /p:UapAppxPackageBuildMode=StoreUpload `
  /p:AppxPackageDir=".\AppPackages\"

Combining this command with the Microsoft Store Submission API allows you to push game updates directly to the store upon tagging a new release in Git.


Conclusion

Publishing a MonoGame desktop application to the Microsoft Store does not require refactoring your codebase for UWP or compromising on .NET 9 performance. By encapsulating your desktop build within a Windows Application Packaging (WAP) project, configuring runFullTrust, standardizing your asset scale grid, and packaging hybrid x86|x64 bundles, you gain a modern, trusted presence on Windows 10 and Windows 11.

With this pipeline in place, you can focus on what matters most: delivering fantastic gameplay experiences to PC gamers across the globe!

11 Eylül 2026 Cuma

MonoGame: Das Open-Source-Framework hinter Arar Games

MonoGame: Das Open-Source-Framework hinter Arar Games

Moderne Spieleentwicklung wird häufig mit riesigen Engines, visuellen Editoren und komplexen Ökosystemen in Verbindung gebracht. Viele unabhängige Entwickler bevorzugen jedoch eine direktere Beziehung zu ihrem Code. MonoGame bietet genau das: ein ausgereiftes, quelloffenes Framework für die Entwicklung von Spielen in C#, das Entwicklern die volle Kontrolle über Rendering, Gameplay-Architektur, Content-Pipeline, Performance und plattformspezifisches Verhalten gibt.

Bei Arar Games nutzen wir MonoGame zur Entwicklung unserer Spiele, darunter Paint Trek und Blocked: Pixel Panzer. Sein codeorientiertes Design ermöglicht es uns, maßgeschneiderte Gameplay-Systeme zu erstellen, ohne durch die starre Struktur einer herkömmlichen Game-Engine eingeschränkt zu werden.


Was ist MonoGame?

MonoGame ist ein kostenloses, quelloffenes und plattformübergreifendes Framework für die Spieleentwicklung. Es stellt die grundlegenden Bausteine bereit, die Entwickler zur Erstellung von Spielen benötigen:

  • Grafik-Rendering
  • Audiowiedergabe und Soundmanagement
  • Eingabeverarbeitung für Tastatur, Maus, Touchscreens und Gamepads
  • Spielzeitschleifen und Update-Zyklen
  • Content-Verarbeitung und Asset-Kompilierung
  • Mathematische Strukturen für die 2D- und 3D-Entwicklung
  • Plattformabstraktion

MonoGame ist eher ein Framework als eine visuelle Komplett-Engine. Es zwingt Entwickler nicht zur Verwendung eines bestimmten Szeneneditors, Komponentenmodells (ECS), einer vorgegebenen Physik-Engine oder UI-Architektur. Stattdessen können Entwickler bestehende Bibliotheken einbinden oder Systeme programmieren, die exakt auf die individuellen Anforderungen ihres Spiels zugeschnitten sind.

Dieser Ansatz erfordert mehr Programmierarbeit, bietet dafür aber eine unvergleichliche Kontrolle über das Endprodukt.


Von Microsoft XNA zu MonoGame

MonoGame hat eine bedeutende Verbindung zu Microsoft XNA.

Microsoft führte XNA als Sammlung von Tools und Managed-Code-Bibliotheken ein. Es ermöglichte C#-Entwicklern, Spiele für Windows, die Xbox 360 und Windows Phone über ein einheitliches Programmiermodell zu entwickeln.

XNA erfreute sich bei Indie-Entwicklern großer Beliebtheit, da es die Spieleprogrammierung zugänglich machte und gleichzeitig einen code-first Workflow bewahrte. Entwickler arbeiteten mit vertrauten Konzepten wie:

  • Game
  • GameTime
  • GraphicsDevice
  • SpriteBatch
  • Texture2D
  • ContentManager
  • SoundEffect

Obwohl Microsoft die aktive Weiterentwicklung von XNA schließlich einstellte, blieb das Programmiermodell dank einer engagierten Entwickler-Community lebendig.

MonoGame entstand als quelloffene Reimplementierung des Microsoft XNA 4-Frameworks. Seine erste offizielle Version erschien 2011. Es bewahrte die bekannte XNA-API und erweiterte das Entwicklungsmodell gleichzeitig auf moderne Betriebssysteme und mobile Plattformen.

Dieses Erbe spiegelt sich bis heute in Namespaces wie folgenden wider:

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;

Die Namespaces behalten die XNA-Namenskonvention bei, um eine vollständige Kompatibilität mit vorhandenem XNA-Code und Entwickler-Know-how zu gewährleisten.


MonoGame ist keine Drag-and-Drop-Engine

MonoGame unterscheidet sich grundlegend von editorbasierten Engines. Es gibt keine obligatorische Szenenhierarchie, keine visuelle Skriptumgebung und keine feste Komponentenarchitektur.

Ein typisches MonoGame-Projekt basiert auf einer Game-Loop mit zwei zentralen Phasen:

protected override void Update(GameTime gameTime)
{
    // Aktualisierung von Eingaben, Gameplay, Gegnern, Physik und Spielzustand.
}

protected override void Draw(GameTime gameTime)
{
    GraphicsDevice.Clear(Color.Black);
    // Rendern des aktuellen Frames.
}

Der Entwickler entscheidet selbst, wie Spielobjekte strukturiert sind, wie Level geladen werden, wie Kollisionen berechnet werden, wie Menüs reagieren und wie das Rendering optimiert wird.

Das macht MonoGame besonders attraktiv für Entwickler, die:

  • C# und das .NET-Ökosystem bevorzugen
  • Vollständige Kontrolle über die Spielarchitektur verlangen
  • Gerne maßgeschneiderte Systeme entwickeln
  • Ein schlankes, leichtgewichtiges Framework suchen
  • Gameplay-Code über mehrere Plattformen hinweg teilen möchten
  • Ein älteres XNA-Projekt modernisieren oder pflegen
  • Genau verstehen möchten, was innerhalb der Game-Loop geschieht

MonoGame nimmt Entwicklern die anspruchsvollen Aufgaben der Programmierung nicht ab – es gibt ihnen vielmehr ein stabiles Fundament, auf dem sie diese Aufgaben zielgerichtet und ohne Ballast lösen können.


Plattformübergreifende Entwicklung (Cross-Platform)

MonoGame unterstützt Desktop-, Mobil- und Konsolenplattformen. Zu den offiziell dokumentierten Zielen gehören:

  • Windows
  • macOS
  • Linux
  • Android
  • iOS
  • iPadOS

Für Entwickler mit entsprechenden Entwicklervereinbarungen steht zudem Konsolenunterstützung bereit. Die offizielle Dokumentation finden Sie auf der MonoGame Platforms Seite.

Unterschiedliche MonoGame-Ziele nutzen die für das jeweilige Betriebssystem optimalen Grafiktechnologien. Beispielsweise ermöglicht DesktopGL eine gemeinsame Codebasis für Windows, macOS und Linux, während dedizierte Projekte für Android und iOS optimiert werden.

Eine bewährte Projektstruktur trennt die wiederverwendbare Spiellogik (Core Gameplay) strikt von plattformspezifischen Initialisierungen, Store-Anbindungen, Werbung, In-App-Käufen und Lifecycle-Events.


Die MonoGame Content Pipeline

Videospiele basieren auf Texturen, Sounds, Schriftarten, Shadern und weiteren Assets. MonoGame enthält eine leistungsfähige Content Pipeline, die Quelldateien zur Laufzeit in hochgradig optimierte Binärformate kompiliert.

Die Pipeline verarbeitet typischerweise:

  • PNG-Texturen
  • SpriteFonts
  • Soundeffekte
  • Musikdateien
  • Shader-Effekte
  • 3D-Modelle
  • Benutzerdefinierte Inhaltsformate

Dies garantiert einen einheitlichen Workflow zur Asset-Vorbereitung und erlaubt es fortgeschrittenen Projekten, eigene Lade- und Optimierungsroutinen zu implementieren.

Gerade für mobile Geräte ist Asset-Management entscheidend. Texturgrößen, Ladezeiten, Speicherverbrauch, Audio-Initialisierung und App-Pausenzyklen beeinflussen das Spielerlebnis maßgeblich. MonoGame ermöglicht den direkten Zugriff auf diese Parameter, sodass wir sie für jedes Spiel gezielt optimieren können.


Warum Arar Games auf MonoGame setzt

Arar Games ist ein unabhängiges Spielestudio mit Sitz in Bursa, Türkei. Unsere Projekte zeichnen sich durch maßgeschneidertes Gameplay, technische Experimentierfreude, Spitzenleistung und langfristige Kontrolle über unsere Codebasis aus.

MonoGame passt perfekt zu dieser Philosophie, da es keine starren Schemata vorschreibt.

Wir entwickeln völlig frei:

  • Maßgeschneiderte Gameplay-Architekturen
  • Menü- und Interface-Systeme
  • Eigene Kollisionslogik
  • Gegnerverhalten und KI-Muster
  • Fähigkeiten- und Waffensysteme
  • Rendering- und visuelle Effekte
  • Asset-Management-Tools
  • Performance-Telemetrie
  • Android-Lebenszyklus-Optimierungen
  • Store- und Monetarisierungsintegrationen
  • Lokalisierungsinfrastruktur für über 60 Sprachen

Der Kern-Gameplay-Code bleibt plattformübergreifend identisch, während plattformspezifische Projekte Dienste wie Google Play, Microsoft Store, Errungenschaften, Touch-Steuerung oder Tastatur-/Maus-Support handhaben.


Paint Trek und MonoGame

Paint Trek ist ein handgezeichneter 2D-Weltraum-Shooter von Arar Games.

Das Projekt blickt auf eine lange Geschichte zurück, die bis in die Ära von Windows Phone reicht. Sein visuelles Design ist inspiriert von Kindheitszeichnungen, Skizzenbuch-Raumschiffen, fantasievollen Gegnern und handgemalten kosmischen Welten.

MonoGames Verbindung zu XNA war für Paint Trek ein unschätzbarer Vorteil. Das Framework ermöglichte es uns, die bewährte Spiellogik und Erfahrung eines früheren Microsoft-Projekts direkt in moderne Android- und Windows-Versionen zu überführen.

In Paint Trek steuert MonoGame zentrale Systeme wie:

  • Den Render- und Update-Zyklus
  • Das Zeichnen von Sprites und Ebenen
  • Das Verhalten von Gegnern und Endgegnern
  • Präzise Kollisionserkennung
  • Projektil- und Waffensysteme
  • Den Level-Fortschritt
  • Musik- und Soundeffektwiedergabe
  • Menüführung und UI
  • Touch- und Desktop-Steuerung
  • Plattformspezifische Store-Integrationen

Das Ergebnis ist ein Spiel, das seine ursprüngliche Seele bewahrt hat und auf aktuellen Plattformen auf Mobilgeräten und PCs kontinuierlich weiterentwickelt wird.


Blocked: Pixel Panzer und MonoGame

Blocked: Pixel Panzer ist ein hochdynamisches Pixel-Panzer-Survivalspiel im Hochformat.

Der Spieler steuert einen Panzer am unteren Bildschirmrand, während von oben Blockformationen herabfallen. Das Überleben erfordert schnelles Zerstören von Hindernissen, Munitionstausch über das ColorWheel, gezielte Fähigkeiten-Upgrades und Reaktionen auf gegnerische Angriffe und Bosskämpfe.

MonoGame treibt die wichtigsten Spielsysteme an:

  • Simulation herabfallender Blöcke
  • Panzer- und Geschossdynamik
  • Nachschub- und Munitionslogik
  • Fertigkeitenbäume und Upgrades
  • Farbcodierte Munitionsmechanik
  • Gegnerische Geschütze und Bosskämpfe
  • Wettereffekte und Retro-CRT-Filter
  • Pixel-Art-Renderoptimierungen
  • Touch- und Controller-Steuerung
  • Audiomanagement und Soundeffekte
  • Framerate-Stabilität und Telemetrie
  • Android- und Windows-Builds

Da das Spiel eine unkonventionelle Kombination aus Block-Breaking, Shoot ’em up und Rogue-lite-Progression bietet, ist ein flexibles Framework unerlässlich. MonoGame ermöglicht es, diese Spielsysteme direkt im Code zu realisieren, ohne sie an eine unflexible Engine anpassen zu müssen.

Zudem behalten wir die volle Kontrolle über die mobile Performance: Wir können Texturspeicher minimieren, Ladezeiten reduzieren und flüssige Bildraten auf unterschiedlichster Hardware sicherstellen.


Die Vorteile von MonoGame im Überblick

MonoGame bietet unabhängigen Entwicklern greifbare Stärken:

C# und das .NET-Ökosystem

Entwickler profitieren von der modernen C#-Syntax und den umfangreichen Bibliotheken von .NET.

Architekturfreiheit

MonoGame liefert das Fundament, überlässt die Spielarchitektur aber vollständig dem Entwickler.

XNA-Kompatibilität

Kenntnisse und Code aus früheren XNA-Projekten können direkt wiederverwendet werden.

Plattformübergreifendes Potenzial

Eine saubere Code-Struktur ermöglicht das Teilen riesiger Teile des Gameplay-Codes zwischen Desktop und Mobilgeräten.

Open-Source-Community

Der Quellcode ist im offiziellen MonoGame GitHub-Repository vollständig einsehbar und erweiterbar.

Langfristige Kontrolle

Ein MonoGame-Projekt ist purer C#-Code. Entwickler behalten jahrzehntelang die Kontrolle über ihre Software.


Herausforderungen bei der Nutzung von MonoGame

MonoGame ist nicht automatisch für jedes Team die Universallösung. Entwickler müssen Systeme, die andere Engines out-of-the-box mitbringen, oft selbst implementieren:

  • Szeneneditoren
  • Animationswerkzeuge
  • Physiksimulationen
  • Komplexe UI-Bibliotheken
  • Partikel-Editoren
  • Wegfindungs- und Navigationssysteme
  • Visuelle Profiling-Tools
  • Erweiterte Asset-Workflows

Dies erfordert Entwicklungszeit und fundiertes Programmierwissen. Wer einen visuellen Drag-and-Drop-Workflow bevorzugt, ist mit einer vollwertigen Game-Engine meist besser bedient.

Für Entwickler, die jedoch die volle Kontrolle über jede Codezeile schätzen, ist genau diese Herausforderung der größte Trumpf von MonoGame.


Ein Framework mit lebendigem Vermächtnis

MonoGame schlägt eine Brücke zwischen der Ära von Microsoft XNA und der modernen Indie-Spieleentwicklung.

Es bewahrt ein vertrautes Programmiermodell und führt es auf aktuellen Systemen erfolgreich weiter. Als Open-Source-Projekt wächst es stetig, ohne die geschätzten Prinzipien der XNA-Architektur aufzugeben.

Für Arar Games ist MonoGame das technische Fundament, das uns erlaubt, kreative Ideen generationenübergreifend auf Android und Windows zu verwirklichen.


Erfahren Sie mehr und spielen Sie unsere Spiele

Entdecken Sie MonoGame-Dokumentationen und unsere Titel auf Google Play und im Microsoft Store: