Search Results for

    Show / Hide Table of Contents

    Official Art Assets

    中文 | English

    Official production assets such as vehicles and maps live in the private repository WindyVerse/Panzer-War-Mods. The old GitLab community, sound, and map repositories are frozen and are kept for reference only. This page describes how authorized contributors work. Downloading and trying the SDK does not need repository access; see "Public SDK and official resources" below.

    Access

    Access to the official asset repository requires authorization. Send your GitHub account to the developers, have them grant repository access, and sign in to Git with the account that received the invitation.

    The public mod SDK needs no application; download it directly.

    Public SDK and official resources

    Download the public SDK from GitHub Releases and follow project setup to open UnityProject. For a Git checkout, use the download and clone guide. Public SDK releases

    The SDK and the official resources are two different repositories: the SDK is for setting up a project, testing, and packaging, while the official production resources are in the private repository. Being able to download from the SDK release page does not mean the official asset repository is public as well.

    Prepare the project

    1. Set up Git and Git LFS, see install Git, and add TortoiseGit if you prefer a graphical client.

    2. When you work on one package, use Git Bash in a clean checkout to fetch the package and its dependencies. This example uses Vehicles/German.

      GIT_LFS_SKIP_SMUDGE=1 git clone https://github.com/WindyVerse/Panzer-War-Mods.git
      cd Panzer-War-Mods
      python Tools/ci.py prepare Vehicles/German
      git lfs pull --include="<the lfs paths printed above>"
      

      prepare rewrites the package's project manifest. Before committing, use git diff -- Projects/Vehicles/Packages/manifest.json to confirm the only changes are from that command, then restore that one file.

      git restore -- Projects/Vehicles/Packages/manifest.json
      
    3. Open Projects/<Group> with Unity 2022.3.62f1, then edit and test-build locally as usual.

    4. Asset locations: one modpack corresponds to one local UPM package under Packages/<Group>/<Pack>, which holds the BuildPipeline and the resources unique to that package; assets shared by several packages go to Packages/<Group>/Shared. The SDK creation tools still generate new files into the project shell under Assets/Res/... and Assets/ModManager/. After creating them, drag those folders into the owning package in the Unity Project window; moving preserves their GUIDs.

    5. Personal editor settings such as the Steam game path live in Assets/EditorStorage.json, which is not committed. When the file is absent, start from Projects/<Group>/EditorStorage.template.json.

    Keep existing paths and .meta files when moving or re-exporting assets so GUIDs and references survive. Naming and export requirements are in art asset naming and upload standards.

    Make one coherent change

    Keep one related change per branch so the developers can review and merge it. Do not mix unrelated cleanup, formatting, or re-exports into the same branch.

    A local test build rewrites the build records in the ModPackage asset (file list, createdTime). If you only tested a build locally, do not commit those changes.

    Create a branch, commit, and push

    The full command-line flow:

    git switch main
    git pull
    git switch -c <topic>-mod
    git status
    git add <the files you changed>
    git commit -m "<what you changed>"
    git push -u origin <topic>-mod
    

    Then open a pull request from that branch to main on GitHub and state which package you changed, what you changed, and how you verified it.

    With TortoiseGit, do the same steps from the context menu of the project folder:

    1. TortoiseGit → Create branch to create the branch. Name it <topic>-mod, for example the tank you changed and what you changed on it.
    2. Switch to that branch before making your edits.
    3. Right-click TortoiseGit → Commit. In the commit dialog, tick only the files you changed. If a file is not yours, leave it unticked instead of adding everything.
    4. Right-click TortoiseGit → Push, confirm the branch name, push, and then open the pull request on GitHub.

    You can keep adding commits to your branch. Including only your own files in the commit is what keeps other people's uncommitted work in the same working tree out of it.

    Verification

    Run the static check before committing. It fills in undeclared package dependencies and reports the remaining problems:

    python Tools/check.py --fix
    

    If you changed package contents, build and verify the current platform locally through the same entry CI uses. The artifact lands in Artifacts/local/:

    python Tools/ci.py build Vehicles/German
    

    Once that passes, run Build modpack in the mod repository's GitHub Actions, fill in the affected packs and target platform, and set publish=none for a verification build. The workflow trims dependencies, pulls the matching LFS content, builds, and verifies. See continuous mod builds for the flow and artifact checks, and multi-platform build for platform differences.

    After downloading the artifact, check the target platform, GUID, modVersion, manifest files, and the .modpack.json sidecar with the same name, then load the initial vehicles, maps, sounds, materials, and config in the game on that platform. A successful CI build only means the artifact passed its checks; it does not mean it has run in the actual game.

    Publishing to the workshop is a separate flow: publish=sandbox publishes a test build, and publish=production is allowed only from main. Increment modVersion first when the contents of an already published package change.

    Update after merge

    Once your branch is merged into main, switch back to main and pull the latest project, which now contains your changes and everyone else's:

    git switch main
    git pull
    

    For further work, create a new branch from the updated main.

    If the pull fails, stash only your own changes, pull, then restore them:

    git stash push -m "uncommitted work on my branch" -- <your files>
    git pull
    git stash pop
    

    Stash only your files so other people's work in the same tree is not swept in. Run git status again afterwards and confirm nothing is left with conflict markers.

    When an asset shows as Missing, record the exact path or GUID and report it to the developers; do not delete or recreate the asset yourself. Report missing paths from check.py the same way.

    Historical material

    The following comes from the older page. Interface wording, repository addresses, and screenshots may differ from the current version; treat the text above as authoritative.

    Old GitLab repositories (the map ones had to sit under the same parent directory as the community repository):

    • Community repository: https://lab.windyverse.net/modder/panzer-war-community-mods
    • Sound repository: https://lab.windyverse.net/modder/Panzer-War-Fmod
    • Map repository: https://lab.windyverse.net/modder/ShanghaiWindyMaps
    • Public resources: https://lab.windyverse.net/modder/ShanghaiWindyPublicResources

    Older video tutorials (recorded against the old interface, background only):

    • Downloading, using, and contributing to the mod project (Chinese)
    • Writing custom scripts and tuning vehicle values in the mod project (Chinese)

    The older page described "the main project files under Assets/Res/Vehicles/Ground/Data" with screenshots; that path refers to assets in the project shell, while package assets now live under Packages/<Group>/<Pack>. The older in-editor Git workflow of creating a branch, committing, and pulling matches the TortoiseGit steps above.

    In this article
    Back to top Panzer War Document