PMDOWiki - User contributions [en]

Class:BattleContext

2026-07-30T06:22:15Z

IDK: Autogenerated update

This page shows all properties of BattleContext that can be manipulated from Lua

== BattleContext.StrikeStartTile ==

the tile of the user before it started a strike (used for tipper effects)
wrapped; it can't go out of bounds anyway

== BattleContext.StrikeEndTile ==

the tile of the user JUST AFTER it started a strike (used for updating position)
wrapped; it can't go out of bounds anyway

== BattleContext.StartDir ==

the direcion of the user before it started a strike (used for multistrike confusion)
unwrapped

== BattleContext.ExplosionTile ==

the origin tile for the explosion
unwrapped

== BattleContext.TargetTile ==

the location of the tile being targeted
unwrapped

== BattleContext.StrikeLandTiles ==

all tiles in which a strike's hitbox ended (used for item landing)
unwrapped

== BattleContext.ActionType ==

The ActionType: Skill, Item, Throw or Trap

== BattleContext.UsageSlot ==

For skills, the skill slot
For items, the item slot

== BattleContext.StrikesMade ==

Strikes that have currently been made in the BattleContext.

== BattleContext.Strikes ==

The total strikes that should be made in the BattleContext.

== BattleContext.HitboxAction ==

Determines the range and type of hitbox.

== BattleContext.Explosion ==

Determiens the size of splash effect.

== BattleContext.Data ==

The effect of the skill, item, trap, etc. on the target.

== BattleContext.Item ==

The item that is used, and most likely dropped

== BattleContext.SkillUsedUp ==

The skill whose last charge was used up

== BattleContext.TurnCancel ==

Determines if this action should trigger end-of-turn.

== BattleContext.Hit ==

Denotes whether the action hit its target.

== BattleContext.RangeMod ==

A number of be added to the Range argument for the hitbox, when it comes out.

== BattleContext.GlobalContextStates ==

Context states that remain on the main battlecontext even after iterating over different targets.
Ordinarily, context states are left behind when switching to a new target (in multi-target contexts)

== UserTargetGameContext.Target ==

The character that the action is targeted at

== GameContext.ContextStates ==

Contains contextual info to be passed along the GameContext, used by GameEvents

== GameContext.User ==

The character that is performing the action

== GameContext.CancelState ==

Whether the action should be canceled or not.

[[Category:Data Class Documentation]]

Class:BattleContext

2026-07-30T06:17:30Z

IDK: Autogenerated update

== BattleContext.StrikeStartTile ==

the tile of the user before it started a strike (used for tipper effects)
wrapped; it can't go out of bounds anyway

== BattleContext.StrikeEndTile ==

the tile of the user JUST AFTER it started a strike (used for updating position)
wrapped; it can't go out of bounds anyway

== BattleContext.StartDir ==

the direcion of the user before it started a strike (used for multistrike confusion)
unwrapped

== BattleContext.ExplosionTile ==

the origin tile for the explosion
unwrapped

== BattleContext.TargetTile ==

the location of the tile being targeted
unwrapped

== BattleContext.StrikeLandTiles ==

all tiles in which a strike's hitbox ended (used for item landing)
unwrapped

== BattleContext.ActionType ==

The ActionType: Skill, Item, Throw or Trap

== BattleContext.UsageSlot ==

For skills, the skill slot
For items, the item slot

== BattleContext.StrikesMade ==

Strikes that have currently been made in the BattleContext.

== BattleContext.Strikes ==

The total strikes that should be made in the BattleContext.

== BattleContext.HitboxAction ==

Determines the range and type of hitbox.

== BattleContext.Explosion ==

Determiens the size of splash effect.

== BattleContext.Data ==

The effect of the skill, item, trap, etc. on the target.

== BattleContext.Item ==

The item that is used, and most likely dropped

== BattleContext.SkillUsedUp ==

The skill whose last charge was used up

== BattleContext.TurnCancel ==

Determines if this action should trigger end-of-turn.

== BattleContext.Hit ==

Denotes whether the action hit its target.

== BattleContext.RangeMod ==

A number of be added to the Range argument for the hitbox, when it comes out.

== BattleContext.GlobalContextStates ==

Context states that remain on the main battlecontext even after iterating over different targets.
Ordinarily, context states are left behind when switching to a new target (in multi-target contexts)

== UserTargetGameContext.Target ==

The character that the action is targeted at

== GameContext.ContextStates ==

Contains contextual info to be passed along the GameContext, used by GameEvents

== GameContext.User ==

The character that is performing the action

== GameContext.CancelState ==

Whether the action should be canceled or not.

[[Category:Data Class Documentation]]

Tutorial:Maintaining Documentation

2026-07-30T02:37:16Z

IDK: fix outgoing link

The documentation for all classes in PMDC, RogueEssence, and RogueElements can be found in [https://github.com/audinowho/DumpAsset/tree/master/Editor/Docs Editor/Docs]. They are updated manually by building the projects in debug mode and copying the XMLs from their output directory to the target location. They are used in the editor as the source of its tooltips.

Documents are generated using the <code><DocumentationFile></code> MSBuild Tag in debug mode
https://learn.microsoft.com/en-us/dotnet/core/project-sdk/msbuild-props

It extracts the following tags from the C# documentation:
https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/xmldoc/recommended-tags

== Wiki Maintenance ==

Run the [https://github.com/audinowho/PMDODump/blob/master/Scripts/doc_sync.py Doc Sync] script to generate wiki-ready pages of common functions used for lua scripting. They are output to https://github.com/audinowho/PMDODump/tree/master/DataAsset/Docs DataAsset/Docs]

[[Category: Maintenance]]
[[Category: Tutorial]]

Controller Support

2026-07-28T04:23:10Z

IDK: API update

PMDO supports gamepads for the major Nintendo, Playstation, and Xbox controllers. They all come with default button mappings that are best fit for their controllers, but can still be modified in the settings.

== Supporting New Controllers ==

Unrecognized controllers will default to Xbox-style control schemes. If the labeling is incorrect, it is possible to add support for your controller by following these steps:

Run PMDO with your controller plugged in. In the logs (found in the <code>LOG</code> subfolder), search for a debug line that mentions your controller. For example:
<pre>
[2023/03/04 22:14:21.947] Controller 0: (8BitDo Ultimate Controller), GUID: c82d0631, Mapping: 03000000c82d00000631000000007200,*,a:b0,b:b1,x:b2,y:b3,back:b6,guide:b10,start:b7,leftstick:b8,rightstick:b9,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:a4,righttrigger:a5,platform:Windows
</pre>

Copy the GUID, and navigate to the <code>Controls/Label</code> subfolder in your PMDO installation. Create a new XML file with your guid as the name. Inside it, map each controller input to a button texture (look at the existing XMLs for reference). All possible controller inputs are specified [https://github.com/FNA-XNA/FNA/blob/master/src/Input/Buttons.cs#L20 here]. All button textures are [[Text Guide#Special Characters|special characters]].

Now with the inputs properly mapped to textures, it is time to map them to in-game inputs. Navigate to the <code>Controls/Default</code> subfolder in your PMDO installation and reate a new XML file with your guid as the name. Specify the default controls for this controller in the XML, as well as its name (look at the existing XMLs for reference).

Support for the controller should now be functional the next time the game is started up. These XML files can be sent to a developer to request out-of-the-box support for the controller.
[[Category:PMDO Technical]]

Food

2026-07-28T02:46:12Z

IDK: Undo revision 8185 by IDK (talk)

'''Food items''', typically known as '''food''', are a category of [[item]] in PMDO whose primary purpose is to fill the [[belly]] in dungeons.

== Use ==
Food is used to manage the [[belly]], since running out of belly gradually leads to fainting. Due to the presence of [[leader switching]], food management is generally less of a factor in PMDO. It tends to come up primarily when exploring dungeons with large floors or a lot of floors.

Different food items tend to fill the belly by different amounts, or restore the belly of the entire party.

== Obtaining ==
Food can be found sold in the [[base town]] Kecleon shop. It is also often found within [[dungeons]].

== List of Food ==
{{TableOfFood}}

== Related Articles ==
{{Item Categories}}{{PMDO Food}}
[[Category:Item]]

Food

2026-07-28T02:45:38Z

IDK: API update

Food items, typically known as food, are a category of [[item]] in PMDO whose primary purpose is to fill the [[belly]] in dungeons.

== Use ==
Food is used to manage the [[belly]], since running out of belly gradually leads to fainting. Due to the presence of [[leader switching]], food management is generally less of a factor in PMDO. It tends to come up primarily when exploring dungeons with large floors or a lot of floors.

Different food items tend to fill the belly by different amounts, or restore the belly of the entire party.

== Obtaining ==
Food can be found sold in the [[base town]] Kecleon shop. It is also often found within [[dungeons]].

== List of Food ==
{{TableOfFood}}

== Related Articles ==
{{Item Categories}}{{PMDO Food}}
[[Category:Item]]

Main Page

2026-07-28T02:00:24Z

IDK:

{{DISPLAYTITLE:<span style="position: absolute; clip: rect(1px 1px 1px 1px); clip: rect(1px, 1px, 1px, 1px);">{{FULLPAGENAME}}</span>}}
= Pokémon Mystery Dungeon: Origins =

[[Pokémon Mystery Dungeon: Origins]] is a fanmade Pokémon Mystery Dungeon game programmed in C# and playable on Windows, Mac, and Linux.

To play, click here to download the installer for your operating system: [https://github.com/audinowho/PMDODump/releases PMDO Github: Releases]<br>
If you're on Steam Deck, please see the [[Linux Flatpak | Linux Flatpak instructions]].

PMDO is open source ([https://opensource.org/licenses/MIT MIT license]) and has full mod support and features a set of tools for enabling fans to create make their own PMD fangames. Visit the [[Modding Hub]] to get started, or join our [https://discord.gg/gavVZj8B9A Discord] community for help from other modders.

PMDO serves as the fangame counterpart to ROMhacking with [https://skytemple.org SkyTemple], and is specifically a part of its [https://pmdcollab.org PMDCollab] project.

Main Page

2025-11-19T03:00:42Z

IDK: update discord invite

{{DISPLAYTITLE:<span style="position: absolute; clip: rect(1px 1px 1px 1px); clip: rect(1px, 1px, 1px, 1px);">{{FULLPAGENAME}}</span>}}
= Pokémon Mystery Dungeon: Origins =

[[Pokémon Mystery Dungeon: Origins]] is a fanmade Pokémon Mystery Dungeon game programmed in C# and playable on Windows, Mac, and Linux.

To download and play, click here and download the installer for your operating system: [https://github.com/audinowho/PMDODump/releases PMDO Github: Releases]<br>
If you're on Steam Deck, please see the [[Linux Flatpak | Linux Flatpak instructions]].

PMDO is open source ([https://opensource.org/licenses/MIT MIT license]) and has full mod support and features a set of tools for enabling fans to create make their own PMD fangames. Visit the [[Modding Hub]] to get started, or join our [https://discord.gg/gavVZj8B9A Discord] community for help from other modders.

PMDO serves as the fangame counterpart to ROMhacking with [https://skytemple.org SkyTemple], and is specifically a part of its [https://pmdcollab.org PMDCollab] project.

Tutorial:Navigating PMDO's Repository

2025-11-17T00:59:27Z

IDK: clarification of dumpasset subfolders

The repository for PMDO, [https://github.com/audinowho/PMDODump PMDODump], consists of several different modules and sub-repositories that contain different pieces of the game and its engine. Knowing where different parts of the game can be found is important for the purposes of [[mod|modding]].

This tutorial contains some information on what pieces of the engine can be found where, and what parts of the overall repository to navigate in order to find how the code works.

== PMDODump ==
PMDODump is the master repository for PMDO. It is used to build the game and include all of the information relevant to it.

It has the following subfolders.

=== DataAsset ===
Contains output of some of PMDO's data.

=== DataGenerator ===
Files that are used to generate the data that PMDO has.

=== PMDOSetup ===
Files related to initializing the <code>PMDOSetup</code> program, which is used to manage the game.

=== Scripts ===
Various python scripts for automating some development processes.

== RawAsset ==
{{SectStub}}
Visual assets for PMDO, such as sprites. These are converted to the Content subfolder in DumpAsset.

== DumpAsset ==
{{SectStub}}
Contains all data generated for PMDO, such as Pokemon, base game mods, ground map scripts, and the editor.

The files in the Data subfolder is created by running PMDODump's DataGenerator project, plus changes made manually.

The Content subfolder is created by running PMDC with the <code>-convert</code> flag, which packages all files in the RawAsset repository into Content.

== PMDC ==
{{SectStub}}
Contains the overall engine that is used to run PMDO, without any game data (such as individual dungeons or Pokemon).

=== RogueEssence ===
{{Main|RougeEssence}}
The underlying engine that forms PMDO, for creating roguelikes.
[[Category:Tutorial]]

MapGenTest

2025-10-03T06:11:55Z

IDK: mods

MapGenTest is a standalone program that can be used to test floor generators made in PMDO's editor. It has stress test capabilities that can help you find that elusive 1/8192 floor generation that results in an error.

It can be found in the PMDC repo, under MapGenTest https://github.com/PMDCollab/PMDC/tree/master/MapGenTest

In order for it to work properly, it must be run with the <code>-asset</code> command line argument, followed by the path to the folder containing PMDO's <code>Content</code> and <code>Data folders</code>. This typically means the folder named "PMDO" for a regular installation. This path MUST be a '''relative path''', and you must be sure to include the trailing slash to signify it as a folder. The <code>launchsettings.json</code> for MapGenTest in the repo has it point to the DumpAsset folder of the parent PMDODump project.

In order to test mods, you will need to move the MODS/ folder to the same location as the MapGenTest exe. Additionally, you must supply the <code>-mod</code> command line argument, followed by the name of the mod folder to load.

As a debug tool, expect things to break if these instructions are not followed perfectly.

MapGenTest

2025-10-03T05:32:04Z

IDK: initial commit

MapGenTest is a standalone program that can be used to test floor generators made in PMDO's editor. It has stress test capabilities that can help you find those elusive 1/8192 erroring floors.

It can be found in the PMDC repo, under MapGenTest https://github.com/PMDCollab/PMDC/tree/master/MapGenTest

In order for it to work properly, it must be run with the <code>-asset</code> command line argument, followed by the path to the folder containing PMDO's <code>Content</code> and <code>Data folders</code>. This typically means the folder named "PMDO" for a regular installation. This path MUST be a '''relative path''', and you must be sure to include the trailing slash to signify it as a folder. The <code>launchsettings.json</code> for MapGenTest in the repo has it point to the DumpAsset folder of the parent PMDODump project.

As a debug tool, expect things to break if these instructions are not followed perfectly.

Status Conditions

2025-08-25T02:46:32Z

IDK: non-damaging move effects on sleep

'''Status conditions''', or '''statuses''', are abnormal effects that may affect a Pokémon in battle. Status conditions can have either positive or negative effects.

== Major status conditions ==
A Pokémon can only have one major status condition at a time. Pokémon inflicted with major status conditions will take additional damage from moves like [[Hex]].

=== Poisoned ===
[[File:Status_Poisoned.gif|thumb|A poisoned [[Pikachu]] taking damage every turn.]]

A '''poisoned''' Pokémon will take damage every turn for 6 turns. The Pokémon will take less damage if it waits in place on that turn, taking damage equivalent to <sup>1</sup>/<sub>16</sub> of its max HP while waiting, and <sup>1</sup>/<sub>8</sub> of its max HP while moving or attacking. {{TypeIcon|type=Poison}}Poison- and {{TypeIcon|type=Steel}}Steel-type Pokémon cannot be poisoned or badly poisoned.

Healing items and effects will only recover half as much HP, and the Pokémon will not recover HP naturally.


<div style="clear: both"></div>
==== Badly Poisoned ====
[[File:Status_BadlyPoisoned.gif|thumb|A badly poisoned [[Deerling]] taking increasingly more damage after attacking.]]

'''Badly poisoned''' Pokémon will increase the amount of damage taken by the poison every time they use a move. As before, the damage will start at <sup>1</sup>/<sub>16</sub> for standing still and <sup>1</sup>/<sub>8</sub> for moving, but increases by an additional <sup>1</sup>/<sub>16</sub> anytime the Pokémon uses a move.

<div style="clear: both"></div>
=== Paralyzed ===
[[File:Status_Paralyzed.gif|thumb|A paralyzed [[Spheal]] being unable to move every other turn.]]

A '''paralyzed''' Pokémon will be unable to act every other turn. Paralysis lasts for 6 turns. {{TypeIcon|type=Electric}}Electric-type Pokémon cannot be paralyzed.

Paralysis will last for 10 turns when inflicted by the [[Petrify Orb]].

<div style="clear: both"></div>
=== Burned ===
[[File:Status_Burned.gif|thumb|A burned [[Whismur]] taking damage after attacking.]]

A '''burned''' Pokémon will have its Attack stat reduced by <sup>1</sup>/<sub>3</sub>, and will take <sup>1</sup>/<sub>8</sub> of its max HP as damage every time it attacks. This status condition lasts for the entire floor, or until being removed. {{TypeIcon|type=Fire}}Fire-type Pokémon cannot be burned.

Burns can be cured by stepping onto [[Terrain|water tiles]].

<div style="clear: both"></div>
=== Asleep ===
[[File:Status_Asleep.gif|thumb|A sleeping [[Metang]].]]

A '''sleeping''' Pokémon will be unable to act until it takes damage from an attack, or after 5 turns. Non-damaging attacks will take 1 turn off the countdown.

Sleep will last for 15 turns when inflicted by the [[Slumber Orb]].

Sleep will last for 20 turns when inflicted by the [[Sleep Seed]].

Sleep will last an unlimited number of turns when the [[Stayaway Orb]] is used, and certain Pokémon can sometimes spawn in a dungeon sleeping for an unlimited number of turns.

<div style="clear: both"></div>
=== Frozen ===
[[File:Status_Frozen.gif|thumb|A frozen [[Tepig]] freeing itself by using [[Flame Charge]].]]

A '''frozen''' Pokémon will be unable to act or take damage until 10 turns have passed. The Pokémon may be thawed early by having a {{TypeIcon|type=Fire}}Fire-type move used on it, or by using a Fire-type move of its own. {{TypeIcon|type=Ice}}Ice-type Pokémon cannot be frozen.

Freezing will last for 30 turns when inflicted by the [[Ice Seed]].

Freezing will last for 20 turns when inflicted by the [[Freeze Orb]].

<div style="clear: both"></div>
== Minor status conditions ==
{{sectstub}}

A Pokémon can be inflicted with any number of minor status conditions.

=== Confused ===
[[File:Status_Confused.gif|thumb|A confused [[Spinda]] and [[Psyduck]] having trouble aiming while battling.]]

A '''confused''' Pokémon may randomly turn to the left or right before acting for 10 turns. There is an equal chance for each the intended direction, one turn to the left, and one turn to the right, effectively cutting the accuracy of single-target moves to 33.3%.

Additionally, the moves and items of confused Pokémon will affect both allies and enemies equally, regardless of whether they normally affect either only allies or only enemies.

Confusion will last for 15 turns when inflicted by the [[Totter Orb]].

<div style="clear: both"></div>
=== Immobilized ===
[[File:Status_Immobilized.gif|thumb|An immobilized [[Raboot]] returning to its original position after using [[Quick Attack]].]]

An '''immobilized''' Pokémon is unable to move for 5 turns, though it may still attack and use items freely. While immobilized, moves that would normally bring the user forward, such as [[Quick Attack]], will instead return the Pokémon to its original location.

Immobilization will last for 20 turns when inflicted by the [[Foe-Hold Orb]].

<div style="clear: both"></div>
=== Cringe ===
[[File:Status_Cringe.gif|thumb|[[Nickit]] cringing due to [[Tyrogue]]'s [[Fake Out]].]]

A '''cringing''' (or "flinching") Pokémon is unable to use moves or items for one turn, but can still move. This status effect cannot be inflicted if the target cringed on the previous turn.

Cringe will last for 3 turns if inflicted by the [[Fear Wand]].

<div style="clear: both"></div>
=== In Love ===
[[File:Status_InLove.gif|thumb|[[Poochyena]] in love with [[Skitty]] due to [[Cute Charm]].]]

A Pokémon who is '''in love''' (or "infatuated") cannot use moves or items on the Pokémon who inflicted the status for 10 turns. If it does, the attack will [[forced miss|automatically miss]]. This status can normally only be inflicted on Pokémon of the opposite gender, unless the [[Gender Unlock]] mod is enabled.

[[Category: Game Mechanics]]

Taking Turns

2025-08-21T01:36:05Z

IDK: speed rework revert

PMDO is a turn-based roguelike dungeon crawler. Every time you move, the enemies move.
When all player and enemy turns completes, this is called a Round.

== The Turn Cycle ==

Under normal circumstances, a single Round consists of one full Cycle of player+enemy movements, ordered as such:

* The player's team moves
** Members: Leader first, then everyone moves in list order
** Guests: Everyone moves in list order
* Neutral NPC teams move
** Members: Leader first, then everyone moves in list order
** Guests: Everyone moves in list order
* Enemy teams move
** Members: Leader first, then everyone moves in list order
** Guests: Everyone moves in list order

It's possible for a player to rearrange their team order and change leaders before making a move, allowing them to choose the order in which their units move. Enemies also invisibly reorder their team order to mitigate chokepoint situations.

An example of a chokepoint situation is where an enemy team has a lower ranking member in front of a higher ranking member in a hallway. The higher ranking member goes first, but cannot, while the lower rank can, but moves after the higher rank member. This leads to a turn where one enemy moves forward, but the other one doesn't. Very unintuitive, so the enemies quietly reorder their turns to make this behavior more natural. This also happens with player allies.

== Speed Changes and Turn Tiers ==

Under normal speed conditions, everyone gets to move exactly once. However, speed can be increased in this game. Specifically, Movement Speed. Rounds are actually broken up into 6 Turn Tiers, each of them having a turn Cycle detailed in the previous section. A character can only move in that tier if they have a Movement Speed that the tier permits.

The 6 turn tiers are as follows:

* Tier 0: All movement Speeds
* Tier 1/4: Quadruple Speed
* Tier 1/3: Triple Speed
* Tier 1/2: Double Speed, Quadruple Speed
* Tier 2/3: Triple Speed
* Tier 3/4: Quadruple Speed

Under normal circumstances, everyone would move at the turn cycle on tier 0 and the other tiers would not be used. But when someone speeds up, they can use the other tiers.

For example:

So if a player team consists of the following:
* Leader: Double Speed
* Partner 1: Normal Speed
* Partner 2: Normal Speed

And an enemy team consists of the following:
* Leader: Quadruple Speed
* Partner 1: Normal Speed

The turn order would look like this:

* Tier 0:
** Player Team:
*** Player Moves
*** Partner 1 Moves
*** Partner 2 Moves
** Enemy Team:
*** Leader Moves
*** Partner 1 Moves
* Tier 1/4:
** Player Team:
** Enemy Team:
*** Leader Moves
* Tier 1/3:
** Player Team:
** Enemy Team:
* Tier 1/2:
** Player Team:
*** Player Moves
** Enemy Team:
*** Leader Moves
* Tier 2/3:
** Player Team:
** Enemy Team:
* Tier 3/4:
** Player Team:
** Enemy Team:
*** Leader Moves
* The Round ends

When a character's movement speed is decreased, they will still always perform movements at turn tier 0. However, every time they do, they incur a cooldown of X turns reliant on how much they've slowed down. A Half Speed character will have to wait 1 turn after moving. A 1/3 Speed character will have to wait 2. A 1/4 Speed character will have to wait 3.

== Attacking ==

All movement speed changes only come into effect if the player moves. They do not apply to attacking or using items. If a player at slowed movement speed attacks, they do not skip subsequent turns. If a player at boosted speed attacks, they can no longer participate in higher Turn Tiers for that round. This can be exploited slightly:

Let's say a player is moving at double speed against an enemy at normal speed.
On the player's turn at Tier 0, if they move, the enemy moves. Then on tier 1/2, the player can perform an attack. The round then ends, and the player can act again.

However, if the player chooses to attack, they will not be able to move until they have passed the turn border. It would simply play out as if both entities were moving/attacking at normal speed.

The turn border happens before the leader of the player team's Tier 0 turn. Various attempts have been made to improve on this, but they've had unacceptable consequences. [[User:IDK/Speed_Rework|More information]]

[[Category:Game Mechanics]]

User:IDK/Speed Rework

2025-08-21T01:34:37Z

IDK: revert the speed system

The current speed system that everyone moves on is:

<pre>
0: All movement Speeds
1/4: Quad Speed
1/3: Triple Speed
1/2: Double, Quad Speed
2/3: Triple Speed
3/4: Quad Speed
-- End Turn. Clear all used-move flags --
</pre>
I tried changing it to

<pre>
1/4: Quad Speed
1/3: Triple Speed
1/2: Double, Quad Speed
2/3: Triple Speed
3/4: Quad Speed
0: All movement Speeds
-- End Turn. Clear all used-move flags --
</pre>

this would in theory solve the speed-up delay

because previously it was:
<pre>
0: Use speed-up move, player is marked as used-move
0: Enemy moves
1/2: Player is at double speed and would be able to move again, but is marked as used-move so they can't
-- Next Turn. Clear all used-move flags. --
0: Player walks
0: Enemy walks
1/2: Player can walk again
</pre>

Now it would be:
<pre>
1: Use speed-up move, player is marked as used-move
1: Enemy moves
-- Next Turn. Clear all used-move flags. --
1/2: Player walks
1: Player can walk again
1: Enemy gets to move
</pre>

HOWEVER

this design would reveal a favoritism to enemy:
<pre>
1: Player attacks
1: Enemy used Silver wind! Enemy is at double speed! (Marked as move-used)
-- Next turn. All used-move flags cleared. --
1/2: Enemy used Silver Wind! Enemy is at triple speed! (Marked as move-used)
2/3: Enemy would normally be able to move AGAIN, but is marked as used-move so they can't (thank god)
1: Player can respond
</pre>

technically, this issue also occurs in the current system, just with a one-turn delay. But our current system slightly favors enemies too. But what if...

<pre>
-- All used-move flags for ENEMIES cleared --
0: All movement Speeds
-- All used-move flags for PLAYERS cleared --
1/4: Quad Speed
1/3: Triple Speed
1/2: Double, Quad Speed
2/3: Triple Speed
3/4: Quad Speed
</pre>

or rather

<pre>
0: All movement Speeds (Player)
-- All used-move flags cleared --
0: All movement Speeds (Enemies)
1/4: Quad Speed
1/3: Triple Speed
1/2: Double, Quad Speed
2/3: Triple Speed
3/4: Quad Speed
</pre>

This doesn't look very clean, but it would result in fairness:

<pre>
0: Player: Agility. Used-Move set
-- Used-move flags cleared --
0: Enemy: Move.
1/2: Player: Move
-- Next turn --
0: Player: Move
0: Enemy Move
1/2: Player: Move
-- Next turn --
0: Player: Move
etc.
</pre>

and

<pre>
0: Player: Move
-- Used Move flags cleared --
0: Enemy: Silver Wind. Used-Move set.
1/2: Enemy: Used-move, not allowed to move.
-- Next Turn --
0: Player: Move
0: Enemy: Move
1/2: Enemy: Move
-- Next Turn --
0: Player: Move
0: Enemy: Move
1/2: Enemy: Move
</pre>

also...

<pre>
0: Player: Move
-- Used Move flags cleared --
0: Enemy: Silver Wind (Double speed). Used-Move set.
1/2: Enemy: Used-move, not allowed to move.
-- Next Turn --
0: Player: Move
-- Used Move flags cleared --
0: Enemy: Silver Wind (Triple speed). Used-move set.
1/3: Enemy: Used-move, not allowed to move.
2/3: Enemy: Used-move, not allowed to move.
-- Next Turn --
0: Player: Move
</pre>

if both the player and the enemy get to move on a sub-turn like 1/2, the player gets to move first and then the enemy moves right after

<pre>
0: Player: Agility. Used-Move set
-- Used-move flags cleared --
0: Enemy: (Already at 2x speed) Move.
1/2: Player: Move
1/2: Enemy: Move
-- Next turn --
0: Player: Move
0: Enemy Move
1/2: Player: Move
1/2: Enemy: Move
-- Next turn --
0: Player: Move
etc.
</pre>

This scenario is slightly in favor of the player, but only within the player's frame of reference, so it should be fine:
<pre>
0: Player: (already at 2x speed) Move.
-- Used-move flags cleared --
0: Enemy: Agility. Used-Move set
1/2: Player: Move
1/2: Enemy: Can't Move
-- Next turn --
0: Player: Move
0: Enemy Move
1/2: Player: Move
1/2: Enemy: Move
-- Next turn --
</pre>

Additional scenarios:
<pre>
0:Player used Agility! <Move used>
0:Ally moves
-- Move use clears --
0:Enemy moves
1/2:Player moves
1/2:Ally moves
--- End Turn --
0:Player moves
0:Ally moves
-- Move use clears --
0:Enemy moves
1/2:Player moves
1/2:Ally moves
</pre>

<pre>
0:Player is already at double speed, moves.
0:Enemy moves
1/2:Player used agility! <move use set>
2/3:Player qualifies for this tier but skips. already used move
--- End Turn --
0:Player skips. already used move
-- Move use clears --
0:Enemy moves
1/3:Player moves
2/3:Player moves
--- End Turn --
0:Player moves
-- Move use clears --
0:Enemy moves
</pre>

this only works because there are two sides: player and enemy.

which is exactly the same as the number of directions in the flow of time itself: forwards and backwards.

This causes regression in another problem: Normally, Summon Trap turns on the Move Use flag to prevent the summoned enemies from immediately attacking (only for enemies).

<pre>
0:Player steps on a summon Trap. Move Use flags are set for the newly summoned enemies.
0:Allies take their turn
0:Enemies skip due to Move Use flag
1/4: Player/allies can move, Enemies skip
1/3: Player/allies can move, Enemies skip
1/2: Player/allies can move, Enemies skip
2/3: Player/allies can move, Enemies skip
3/4: Player/allies can move, Enemies skip
--- End Turn, Move Use clears --
0:Player reacts to the new summons
0:Enemies (including the new summons) move or attack
</pre>

And Orb/Chest-activated Monster Houses turn on the Move Use flag to prevent everyone from immediately attacking or reacting, until it's the leader's next turn:

<pre>
0:Player opens a chest, triggers a monster house. Move Use flags are set for everyone on the floor.
0:Allies skip due to Move Use flag
0:Enemies skip due to Move Use flag
1/4: Allies skip, Enemies skip
1/3: Allies skip, Enemies skip
1/2: Allies skip, Enemies skip
2/3: Allies skip, Enemies skip
3/4: Allies skip, Enemies skip
--- End Turn, Move Use clears --
0:Player reacts to the Monster House
0:Allies react to new summons
0:Enemies can move
</pre>

Because of the new move use flag mechanics, enemies are able to attack immediately in both scenarios, respectively:

<pre>
0:Player steps on a summon Trap. Move Use flags are set for the newly summoned enemies.
0:Allies take their turn
-- Move Use Clear --
0:Enemies can move or attack!
1/4: Player/allies can move, Enemies can move
1/3: Player/allies can move, Enemies can move
1/2: Player/allies can move, Enemies can move
2/3: Player/allies can move, Enemies can move
3/4: Player/allies can move, Enemies can move
--- End Turn --
0:Player reacts to the new summons
0:Allies react to new summons
0:Enemies can move
</pre>

And Orb/Chest-activated Monster Houses turn on the Move Use flag to prevent everyone from immediately attacking or reacting, until it's the leader's next turn:

<pre>
0:Player opens a chest, triggers a monster house. Move Use flags are set for everyone on the floor.
0:Allies skip due to Move Use flag
-- Move Use Clear --
0:Enemies can move or attack!
1/4: Player/allies can move, Enemies can move
1/3: Player/allies can move, Enemies can move
1/2: Player/allies can move, Enemies can move
2/3: Player/allies can move, Enemies can move
3/4: Player/allies can move, Enemies can move
--- End Turn, Move Use clears --
0:Player reacts to the Monster House
</pre>

We must still have a variable that prevents movement or attacking that gets cleared at the end of a round/beginning of a round, like the original Move Use flag. We will call it the End Turn Lock. As long as Move Use OR End Turn Lock are on, the character cannot act. For example, with summons:

<pre>
0:Player steps on a summon Trap. End Turn Lock are set for the newly summoned enemies.
0:Allies take their turn
-- Move Use Clear --
0:Enemies skip due to End Turn Lock
1/4: Player/allies can move, Enemies skip
1/3: Player/allies can move, Enemies skip
1/2: Player/allies can move, Enemies skip
2/3: Player/allies can move, Enemies skip
3/4: Player/allies can move, Enemies skip
-- End Turn, End Turn Lock cleared --
0:Player reacts to the new summons
0:Allies react to new summons
-- Move Use Clear --
0:Enemies can move
</pre>

Chest/Orb Monster Houses:

<pre>
0:Player opens a chest, triggers a monster house. End Turn Locks are set for everyone on the floor.
-- Move Use Clear --
0:Allies skip due to End Turn Lock
0:Enemies skip due to End Turn Lock
1/4: Allies skip, Enemies skip
1/3: Allies skip, Enemies skip
1/2: Allies skip, Enemies skip
2/3: Allies skip, Enemies skip
3/4: Allies skip, Enemies skip
-- End Turn, End Turn Lock cleared --
0:Player reacts to the Monster House
0:Allies react to new summons
-- Move Use Clear --
0:Enemies can move
</pre>

If the player activates a chest house while at double speed, they may lose their first reacting turn:

<pre>
1/2:Player opens a chest, triggers a monster house. End Turn Locks are set for everyone on the floor. Player's Move Use is set.
1/2: Allies skip, Enemies skip
-- End Turn, End Turn Lock cleared --
0:Player cannot act due to Move Use flag set
0:Allies react to new summons
-- Move Use Clear --
0:Enemies move/attack
</pre>

Removing End Turn Lock must also remove Move Use flag, but ONLY if they have End Turn Lock to begin with:

<pre>
1/2:Player opens a chest, triggers a monster house. End Turn Locks are set for everyone on the floor. Player's Move Use is set.
1/2: Allies skip, Enemies skip
-- End Turn, End Turn Lock cleared, Move Use flag cleared --
0:Player reacts to new summons
0:Allies react to new summons
-- Move Use Clear --
0:Enemies move/attack
</pre>

for summon trap:

<pre>
1/2:Player steps on a summon tile. End Turn Locks are set for the newly spawned enemies. Player's Move Use is set.
1/2: Allies can act, Enemies skip
-- End Turn, End Turn Lock and Move Use flag cleared for enemies --
0:Player reacts to new summons
0:Allies react to new summons
-- Move Use Clear --
0:Enemies move/attack
</pre>

HOWEVER, the new speed system introduces the issue that it becomes impossible to kite enemies when moving faster than them:

<pre>
0:Player used Agility! <Move used>
-- Move use clears --
0:Enemy attacks
1/2:Player moves one tile away
--- End Turn --
0:Player attacks
-- Move use clears --
0:Enemy attacks
1/2:Player moves one tile away
</pre>

No matter what order you perform attacks or movements, enemies will always be able to respond to your attack. This is unwanted behavior, and a far worse consequence than the issue of gained speed appearing on the next turn. Thus, the change needs to be rolled back.

Room

2025-08-13T23:44:32Z

IDK: DEPRECATED ROOMS

A '''room''' is the core primary structure generated in [[maps]]. They are generated using [[FloorSteps]], and belong in the RoomGen class of RogueElements.

Many different structures are considered rooms in PMDO, such as halls.

== Room Overview ==
Below is a table summary of rooms that can be generated.
{| class="wikitable"
|-
! Image !! Name !! Description
|-
| [[File:RoomGen_Angled_Hall.png|frameless]]|| Angled Hall || A room connecting its exists with a narrow hallway. It can handle all combinations of exists from all combination of directions.
|-
| [[File:RoomGen_Block.png|frameless]] || Block || A rectangular room generated with the specific terrain blocking it.
|-
| [[File:RoomGen_Bump.png|frameless]] || Bump || A rectangular room with tiles at the perimeter randomly blocked.
|-
| [[File:RoomGen_Cave.png|frameless]] || Cave || A cave-like room generated using cellular automata.<br>If it tries to generate a blob but a valid size is not proposed, it will generate as a rectangle.
|-
| [[File:RoomGen_Cross.png|frameless]] || Cross || A room composing of one vertical and one horizontal rectange.
|-
| [[File:RoomGen_Default.png|frameless]] || Default || A 1x1 tile room.
|-
| [[File:RoomGen_Diamond.png|frameless]] || Diamond || A diamond shaped room.
|-
| [[File:RoomGen_Oasis.png|frameless]] || Oasis || A cave-like room filled completely by the specified terrain, with its border being floor terrain.
|-
| [[File:RoomGen_Plus.png|frameless]] || Plus || A rectangular room with tiles from the edges blocked off.<br>'''May cause errors on generation if the corner field is too big.'''
|-
| [[File:RoomGen_Round.png|frameless]] || Round || A circular or capsule-like room.
|-
| [[File:RoomGen_Square.png|frameless]] || Square || A rectangular or square room.
|-
| [[File:RoomGen_Triangle.png|frameless]] || Triangle || A right triangle room.
|-
| [[File:RoomGen_Water_Ring.png|frameless]] || Water Ring || A room with a terrain type encircling treasure.
|-
|}

=== Custom Rooms ===
These rooms are loaded from pre-existing map assets. They are primarily custom, with appearances that vary greatly depending on how they are built.
{| class="wikitable"
|-
! Name !! Description
|-
| Coated || A room coated in additional tiles, which can be of any other generation. '''Currently incomplete.'''
|-
| Load Boss || Used to load a boss room.
|-
| Load Evo || Used to load an evolution room.
|-
| Load Map Bordered|| Used to load a map as a room with the specified terrain as borders.
|-
| Load Map || Used to load a map as a room.
|-
| Post Proc Specific || Generates a room with a specified mask.
|-
| Specific Boss || Generates a boss room with the specified tiles.
|-
| Specific || Generates a room with the specified tiles.
|-
|}

=== Hardcoded Rooms ===
These rooms are hardcoded to always appear a certain way, and have no customization options.
'''THEY ARE SCHEDULED FOR DEPRECATION AND USE IS DISCOURAGED.'''
{| class="wikitable"
|-
! Image !! Name !! Description
|-
| [[File:RoomGen_Evo_Small.png|frameless]] || Evo Small || A hardcoded 5x6 tile evolution room. To be replaced by Load Map: room_evo_altar_small
|-
| [[File:RoomGen_Evo.png|frameless]] || Evo || A hardcoded 7x6 tile evolution room. To be replaced by Load Map: room_evo_altar_normal
|-
| [[File:RoomGen_Guarded_Cave.png|frameless]] || Guarded Cave || A cave that generates with a mob guarding its entrance.
|-
|}

[[Category:Dungeon Generation]]

Mass Importing Assets

2025-08-12T21:18:28Z

IDK: added table

PMDO can be run with the <code>-convert</code> flag to convert raw assets (such as pokemon sprites, portraits, or font) into game-usable form.

For example:
<pre>
PMDO.exe -raw RawAsset/ -convert all
</pre>

This command will convert all assets found in the RawAsset subfolder relative to the current directory.

* The <code>-raw</code> is used to specify the location of the raw asset folder. It must have a file structure like that of [https://github.com/PMDCollab/RawAsset/tree/master RawAsset], where each asset type is saved in its own subfolder.
* The <code>-convert</code> flag can be used with a list of arguments specifying which type of asset to convert, or to convert all assets with <code>all</code>

Below is a list of possible arguments, what they convert, and what subfolder they read from:

{| class="wikitable" style="margin:auto"
|-
! Arg !! Folder !! Description
|-
| font || Font || The [[Modding_Font|font]] used for textboxes, dungeon titles, and damage numbers.
|-
| chara || Sprite || [[Modding_Portraits_and_Sprites|Pokemon sprites]]
|-
| portrait || Portrait || [[Modding_Portraits_and_Sprites|Pokemon portraits]]
|-
| tile || Tile || [[Modding_Tilesets|Static map tilesets]]
|-
| item || Item || Item sprites. Uses the same naming convention as [[Modding_Objects_and_VFX|VFX]]
|-
| particle || Particle || [[Modding_Objects_and_VFX|Particle VFX for attacks]]
|-
| beam || Beam || [[Modding_Beam_VFX|Beam and column-type VFX for attacks]]
|-
| icon || Icon || Status condition icons and emotes. Uses the same naming convention as [[Modding_Objects_and_VFX|VFX]]
|-
| object || Object || [[Modding_Objects_and_VFX|Map objects and traps]]
|-
| bg || BG || Backgrounds for maps and attack animations. Uses the same naming convention as [[Modding_Objects_and_VFX|VFX]]
|-
| autotile || Dtef|| Imports all dtef files into their own tileset sheets, and automatically creates dungeon autotiles for them.
|-
| all || -- || Loops through all above folders and converts them.
|}

[[Category:Modding Assets]]

Tutorial:Mass Sprite Import

2025-08-12T20:56:45Z

IDK: link conversion flags

PMDO's sprites and portraits are found in the <code>sprite/</code> and <code>portrait/</code> subdirectories of the https://github.com/PMDCollab/RawAsset repository.

PMDO gets its sprites and portraits from two repositories:

# https://github.com/PMDCollab/SpriteCollab , which is the repo of the PMD Sprite Repository. This contains all canon sprites and portraits from PMD2 plus custom ones by fans.
# https://github.com/audinowho/CustomSpriteCollab , which is a custom repo of sprites and portraits meant to serve as an override to the sprites in the above repository. It consists of exceptional cases or textures that weren't accepted in the repo but still preferred for PMDO.

Every so often, the RawAsset repo is updated with textures from these two repos in a mass import action.

This page outlines the workflow used to import all of these textures into PMDO.

== Filesystem Setup ==

These are all of the relevant folders and files needed to do a mass update of sprites and portraits.

<pre>
./PMDODump
./PMDODump/RawAsset
./PMDODump/RawAsset/added_nodes.txt
./PMDODump/RawAsset/transfer.json
./PMDODump/RawAsset/custom_transfer.json
./PMDODump/RawAsset/portrait_diff.csv
./PMDODump/RawAsset/sprite_diff.csv
./PMDODump/Scripts
./PMDODump/Scripts/sprite_sync.py
./SpriteBot/SpriteCollab
./SpriteBot/SpriteCollab/portrait
./SpriteBot/SpriteCollab/sprite
./SpriteBot/Custom
./SpriteBot/Custom/portrait
./SpriteBot/Custom/sprite
</pre>

You will need to set up your directory structure such that it looks like this.

This will involve cloning 4 repositories from github.

First, you will need to find a suitable folder to begin in, and clone https://github.com/audinowho/PMDODump into it.

<pre>git clone https://github.com/audinowho/PMDODump.git</pre>

Then, update its submodule https://github.com/PMDCollab/RawAsset within PMDODump:

<pre>git submodule update --init --remote -- RawAsset</pre>

This will result in the following file structure:

<pre>
./PMDODump
./PMDODump/RawAsset
</pre>

Then, you must create a <code>SpriteBot/</code> folder on the same level as the PMDODump folder.

Then, clone both https://github.com/PMDCollab/SpriteCollab and https://github.com/audinowho/CustomSpriteCollab to this location.

<pre>
git clone https://github.com/PMDCollab/SpriteCollab.git
git clone https://github.com/audinowho/CustomSpriteCollab.git
</pre>

This will result in the following file structure:

<pre>
./PMDODump
./PMDODump/RawAsset
./SpriteBot/SpriteCollab
./SpriteBot/Custom
</pre>

You've now set up all the needed repositories.

== Importing to RawAsset ==

Locate the file <code>./PMDODump/Scripts/sprite_sync.py</code> and run the file using python. You may need to install the requirements from <code>./PMDODump/Scripts/requirements.txt</code>

You will arrive at this message:

<pre>
Updating Transfer Map
Transfer json updated. Review the added_nodes.txt and make your changes before proceeding.
</pre>

Open <code>./PMDODump/RawAsset/added_nodes.txt</code>. This is a generated file showing what new nodes have been added to the pokemon list compared to the current repository. This will include all manner of new species/forms due to a new game coming out, or new alternate portraits created by fans.

[[File:Maintenance_Added_Nodes.png|frameless]]

The script automatically sets Alternates and AltColors to be ignored, as seen with the asterisk preceding their names. However, some forms that we don't want in PMDO might still slip through the cracks. PMDO sticks to only canon Pokemon that are not barred from inter-generational transfer. The "baseline pokedex" so to speak. We see here that Pikachu has a number of hat forms that must be manually excluded from transfer.

To do this, open up <code>./PMDODump/RawAsset/transfer.json</code> which contains the node structure for transferring portraits and sprites.

[[File:Maintenance_Transfer_Json.png|frameless]]

When <code>portrait_dest</code> is set to -1, it means to import the portrait from the source to the same slot as in the destination. If it's set to 0 or above, it gets imported to that specific numbered slot. If it's set to -2, it is not imported at all. The same policy goes for sprites.

[[File:Maintenance_Transfer_Json_Ignored.png|frameless]]

In this case, we have set all of the pikachu forms' <code>portrait_dest</code> and <code>sprite_dest</code> to -2, preventing them from being imported.

This node system also applies to <code>./PMDODump/RawAsset/custom_transfer.json</code>. However, given that repo is specific to PMDO there is no need to review it for unexpected changes.

The process of reviewing the nodes needs to be done every time an import happens to ensure a consistent PMDO sprite repo.

Once this is completed, save the transfer file and press enter to continue the python script. It will begin the hours-long process of copying the desired files over and examining the contents for changes.

== Converting from RawAsset ==

Once the import is complete, you can confirm there are changed files in your repository by viewing RawAsset in git.

<pre>git status</pre>

You will also see that <code>./PMDODump/RawAsset/portrait_diff.csv</code> <code>./PMDODump/RawAsset/sprite_diff.csv</code> have been changed. These lists offer a comprehensive breakdown of which files changed and where.

Now, you must run PMDO with the [[Mass_Importing_Assets|conversion flags]] turned on to convert the sprites to PMDO's format. In windows, it would be like this:

<pre>PMDO.exe -raw ../../RawAsset/ -convert chara portrait</pre>

Replace the <code>../../RawAsset/</code> argument with the path of RawAsset relative to your own installation. This will import character and portrait textures to the <code>Content/Chara</code> and <code>Content/Portrait</code> folders in your PMDO installation.

Alternatively, if you are running PMDO from source, you can do this conversion just by adding <code>-convert chara portrait</code> to your debug arguments.

Wait for the conversion to finish. It takes hours.

Run the game in debug mode and change sprites to confirm everything imported okay. Use the <code>./PMDODump/RawAsset/portrait_diff.csv</code> <code>./PMDODump/RawAsset/sprite_diff.csv</code> as a guide to see which sprites/portraits deserve more attention in inspection.

== Contributing ==

Sprite and portrait updates are an occasional occurrence because of how long the conversion steps take. If you want to contribute an update to PMDO's sprite repo yourself, you will need to provide the converted files in <code>Content/Chara</code> and <code>Content/Portrait</code>, as well as the changes in <code>./PMDODump/RawAsset</code>.

This can be done either by sending a zip, or making a [[Contributing_Code| pull request]].

[[Category:Maintenance]]

Mass Importing Assets

2025-08-12T20:55:21Z

IDK: created page

Tutorial:Modding Font

2025-08-12T19:44:49Z

IDK:

Currently, there's no UI panel for modding the font in PMDO. However, it can still be imported to the base game as a part of [[Mass Importing Assets|Mass Import]].

== Data ==

Letters of the font, or glyphs, are stored as individual files, named after the hexadecimal code point of the glyph in [https://home.unicode.org/ Unicode]. They are full textures, with the PMD font containing the drop down shadow.

The font in the <code>banner</code> subfolder contains the font for title drops at the beginning of maps. It supports the western latin alphabet, Japanese, Chinese, and Korean. It does not have Cyrillic letters.

The font in the <code>text</code> subfolder contains the main textboxfont. It supports the western latin alphabet, Japanese, Chinese, and Korean. It does not have Cyrillic letters. The Unicode block for the [https://en.wikipedia.org/wiki/Private_Use_Areas Private Use Area] is used for [[Text Guide#Special Characters|special characters]].

The PMD Font is rendered in-game from the top-left corner. Every letter rendered to the screen advances the caret by exactly the letter's width in pixels. Further spacing is specified in the FontData.xml:

* SpaceWidth: The number of pixels to advance the caret with a whitespace character.
* CharHeight: The max height of the font, used for newlines.
* CharSpace: The number of pixels to advance the caret after rendering a non-whitespace character.
* LineSpace: The amount of space between lines in pixels, used for newlines.

Additionally, FontData.xml specifies a list of Colorless glyphs that will not change color in-game even if commanded to. This is mostly special characters that contain an icon image.

== Reference ==

The existing textures used to import the PMD font is found in the [https://github.com/PMDCollab/RawAsset/tree/master/font RawAsset] repository.

[[Category:Modding Assets]]

Tutorial:Modding Font

2025-08-12T19:43:37Z

IDK: clarify modding font possibility

Currently, there's no UI panel for modding the font in PMDO. However, it can still be imported to the base game as a part of [[Mass Importing Assets|Mass Import]].

== Data ==

Letters of the font, or glyphs, are stored as individual files, named after the hexadecimal code point of the glyph in [https://home.unicode.org/ Unicode]. They are full textures, with the PMD font containing the drop down shadow.

The font in the banner subfolder contains the dungeon font. It supports the western latin alphabet, Japanese, Chinese, and Korean. It does not have Cyrillic letters.

The font in the text subfolder contains the main PMD font. It supports the western latin alphabet, Japanese, Chinese, and Korean. It does not have Cyrillic letters. The Unicode block for the [https://en.wikipedia.org/wiki/Private_Use_Areas Private Use Area] is used for [[Text Guide#Special Characters|special characters]].

The PMD Font is rendered in-game from the top-left corner. Every letter rendered to the screen advances the caret by exactly the letter's width in pixels. Further spacing is specified in the FontData.xml:

* SpaceWidth: The number of pixels to advance the caret with a whitespace character.
* CharHeight: The max height of the font, used for newlines.
* CharSpace: The number of pixels to advance the caret after rendering a non-whitespace character.
* LineSpace: The amount of space between lines in pixels, used for newlines.

Additionally, FontData.xml specifies a list of Colorless glyphs that will not change color in-game even if commanded to. This is mostly special characters that contain an icon image.

== Reference ==

The existing textures used to import the PMD font is found in the [https://github.com/PMDCollab/RawAsset/tree/master/font RawAsset] repository.

[[Category:Modding Assets]]

Tutorial:Mass Sprite Import

2025-07-20T19:01:17Z

IDK:

PMDO's sprites and portraits are found in the <code>sprite/</code> and <code>portrait/</code> subdirectories of the https://github.com/PMDCollab/RawAsset repository.

PMDO gets its sprites and portraits from two repositories:

# https://github.com/PMDCollab/SpriteCollab , which is the repo of the PMD Sprite Repository. This contains all canon sprites and portraits from PMD2 plus custom ones by fans.
# https://github.com/audinowho/CustomSpriteCollab , which is a custom repo of sprites and portraits meant to serve as an override to the sprites in the above repository. It consists of exceptional cases or textures that weren't accepted in the repo but still preferred for PMDO.

Every so often, the RawAsset repo is updated with textures from these two repos in a mass import action.

This page outlines the workflow used to import all of these textures into PMDO.

== Filesystem Setup ==

These are all of the relevant folders and files needed to do a mass update of sprites and portraits.

<pre>
./PMDODump
./PMDODump/RawAsset
./PMDODump/RawAsset/added_nodes.txt
./PMDODump/RawAsset/transfer.json
./PMDODump/RawAsset/custom_transfer.json
./PMDODump/RawAsset/portrait_diff.csv
./PMDODump/RawAsset/sprite_diff.csv
./PMDODump/Scripts
./PMDODump/Scripts/sprite_sync.py
./SpriteBot/SpriteCollab
./SpriteBot/SpriteCollab/portrait
./SpriteBot/SpriteCollab/sprite
./SpriteBot/Custom
./SpriteBot/Custom/portrait
./SpriteBot/Custom/sprite
</pre>

You will need to set up your directory structure such that it looks like this.

This will involve cloning 4 repositories from github.

First, you will need to find a suitable folder to begin in, and clone https://github.com/audinowho/PMDODump into it.

<pre>git clone https://github.com/audinowho/PMDODump.git</pre>

Then, update its submodule https://github.com/PMDCollab/RawAsset within PMDODump:

<pre>git submodule update --init --remote -- RawAsset</pre>

This will result in the following file structure:

<pre>
./PMDODump
./PMDODump/RawAsset
</pre>

Then, you must create a <code>SpriteBot/</code> folder on the same level as the PMDODump folder.

Then, clone both https://github.com/PMDCollab/SpriteCollab and https://github.com/audinowho/CustomSpriteCollab to this location.

<pre>
git clone https://github.com/PMDCollab/SpriteCollab.git
git clone https://github.com/audinowho/CustomSpriteCollab.git
</pre>

This will result in the following file structure:

<pre>
./PMDODump
./PMDODump/RawAsset
./SpriteBot/SpriteCollab
./SpriteBot/Custom
</pre>

You've now set up all the needed repositories.

== Importing to RawAsset ==

Locate the file <code>./PMDODump/Scripts/sprite_sync.py</code> and run the file using python. You may need to install the requirements from <code>./PMDODump/Scripts/requirements.txt</code>

You will arrive at this message:

<pre>
Updating Transfer Map
Transfer json updated. Review the added_nodes.txt and make your changes before proceeding.
</pre>

Open <code>./PMDODump/RawAsset/added_nodes.txt</code>. This is a generated file showing what new nodes have been added to the pokemon list compared to the current repository. This will include all manner of new species/forms due to a new game coming out, or new alternate portraits created by fans.

[[File:Maintenance_Added_Nodes.png|frameless]]

The script automatically sets Alternates and AltColors to be ignored, as seen with the asterisk preceding their names. However, some forms that we don't want in PMDO might still slip through the cracks. PMDO sticks to only canon Pokemon that are not barred from inter-generational transfer. The "baseline pokedex" so to speak. We see here that Pikachu has a number of hat forms that must be manually excluded from transfer.

To do this, open up <code>./PMDODump/RawAsset/transfer.json</code> which contains the node structure for transferring portraits and sprites.

[[File:Maintenance_Transfer_Json.png|frameless]]

When <code>portrait_dest</code> is set to -1, it means to import the portrait from the source to the same slot as in the destination. If it's set to 0 or above, it gets imported to that specific numbered slot. If it's set to -2, it is not imported at all. The same policy goes for sprites.

[[File:Maintenance_Transfer_Json_Ignored.png|frameless]]

In this case, we have set all of the pikachu forms' <code>portrait_dest</code> and <code>sprite_dest</code> to -2, preventing them from being imported.

This node system also applies to <code>./PMDODump/RawAsset/custom_transfer.json</code>. However, given that repo is specific to PMDO there is no need to review it for unexpected changes.

The process of reviewing the nodes needs to be done every time an import happens to ensure a consistent PMDO sprite repo.

Once this is completed, save the transfer file and press enter to continue the python script. It will begin the hours-long process of copying the desired files over and examining the contents for changes.

== Converting from RawAsset ==

Once the import is complete, you can confirm there are changed files in your repository by viewing RawAsset in git.

<pre>git status</pre>

You will also see that <code>./PMDODump/RawAsset/portrait_diff.csv</code> <code>./PMDODump/RawAsset/sprite_diff.csv</code> have been changed. These lists offer a comprehensive breakdown of which files changed and where.

Now, you must run PMDO with the conversion flags turned on to convert the sprites to PMDO's format. In windows, it would be like this:

<pre>PMDO.exe -raw ../../RawAsset/ -convert chara portrait</pre>

Replace the <code>../../RawAsset/</code> argument with the path of RawAsset relative to your own installation. This will import character and portrait textures to the <code>Content/Chara</code> and <code>Content/Portrait</code> folders in your PMDO installation.

Alternatively, if you are running PMDO from source, you can do this conversion just by adding <code>-convert chara portrait</code> to your debug arguments.

Wait for the conversion to finish. It takes hours.

Run the game in debug mode and change sprites to confirm everything imported okay. Use the <code>./PMDODump/RawAsset/portrait_diff.csv</code> <code>./PMDODump/RawAsset/sprite_diff.csv</code> as a guide to see which sprites/portraits deserve more attention in inspection.

== Contributing ==

Sprite and portrait updates are an occasional occurrence because of how long the conversion steps take. If you want to contribute an update to PMDO's sprite repo yourself, you will need to provide the converted files in <code>Content/Chara</code> and <code>Content/Portrait</code>, as well as the changes in <code>./PMDODump/RawAsset</code>.

This can be done either by sending a zip, or making a [[Contributing_Code| pull request]].

[[Category:Maintenance]]

User:IDK/Speed Rework

2025-07-20T00:09:14Z

IDK:

User:IDK/Speed Rework

2025-07-20T00:07:18Z

IDK: player Move use reaction

The current speed system that everyone moves on is:

<pre>
0: All movement Speeds
1/4: Quad Speed
1/3: Triple Speed
1/2: Double, Quad Speed
2/3: Triple Speed
3/4: Quad Speed
-- End Turn. Clear all used-move flags --
</pre>
I tried changing it to

<pre>
1/4: Quad Speed
1/3: Triple Speed
1/2: Double, Quad Speed
2/3: Triple Speed
3/4: Quad Speed
0: All movement Speeds
-- End Turn. Clear all used-move flags --
</pre>

this would in theory solve the speed-up delay

because previously it was:
<pre>
0: Use speed-up move, player is marked as used-move
0: Enemy moves
1/2: Player is at double speed and would be able to move again, but is marked as used-move so they can't
-- Next Turn. Clear all used-move flags. --
0: Player walks
0: Enemy walks
1/2: Player can walk again
</pre>

Now it would be:
<pre>
1: Use speed-up move, player is marked as used-move
1: Enemy moves
-- Next Turn. Clear all used-move flags. --
1/2: Player walks
1: Player can walk again
1: Enemy gets to move
</pre>

HOWEVER

this design would reveal a favoritism to enemy:
<pre>
1: Player attacks
1: Enemy used Silver wind! Enemy is at double speed! (Marked as move-used)
-- Next turn. All used-move flags cleared. --
1/2: Enemy used Silver Wind! Enemy is at triple speed! (Marked as move-used)
2/3: Enemy would normally be able to move AGAIN, but is marked as used-move so they can't (thank god)
1: Player can respond
</pre>

technically, this issue also occurs in the current system, just with a one-turn delay. But our current system slightly favors enemies too. But what if...

<pre>
-- All used-move flags for ENEMIES cleared --
0: All movement Speeds
-- All used-move flags for PLAYERS cleared --
1/4: Quad Speed
1/3: Triple Speed
1/2: Double, Quad Speed
2/3: Triple Speed
3/4: Quad Speed
</pre>

or rather

<pre>
0: All movement Speeds (Player)
-- All used-move flags cleared --
0: All movement Speeds (Enemies)
1/4: Quad Speed
1/3: Triple Speed
1/2: Double, Quad Speed
2/3: Triple Speed
3/4: Quad Speed
</pre>

This doesn't look very clean, but it would result in fairness:

<pre>
0: Player: Agility. Used-Move set
-- Used-move flags cleared --
0: Enemy: Move.
1/2: Player: Move
-- Next turn --
0: Player: Move
0: Enemy Move
1/2: Player: Move
-- Next turn --
0: Player: Move
etc.
</pre>

and

<pre>
0: Player: Move
-- Used Move flags cleared --
0: Enemy: Silver Wind. Used-Move set.
1/2: Enemy: Used-move, not allowed to move.
-- Next Turn --
0: Player: Move
0: Enemy: Move
1/2: Enemy: Move
-- Next Turn --
0: Player: Move
0: Enemy: Move
1/2: Enemy: Move
</pre>

also...

<pre>
0: Player: Move
-- Used Move flags cleared --
0: Enemy: Silver Wind (Double speed). Used-Move set.
1/2: Enemy: Used-move, not allowed to move.
-- Next Turn --
0: Player: Move
-- Used Move flags cleared --
0: Enemy: Silver Wind (Triple speed). Used-move set.
1/3: Enemy: Used-move, not allowed to move.
2/3: Enemy: Used-move, not allowed to move.
-- Next Turn --
0: Player: Move
</pre>

if both the player and the enemy get to move on a sub-turn like 1/2, the player gets to move first and then the enemy moves right after

<pre>
0: Player: Agility. Used-Move set
-- Used-move flags cleared --
0: Enemy: (Already at 2x speed) Move.
1/2: Player: Move
1/2: Enemy: Move
-- Next turn --
0: Player: Move
0: Enemy Move
1/2: Player: Move
1/2: Enemy: Move
-- Next turn --
0: Player: Move
etc.
</pre>

This scenario is slightly in favor of the player, but only within the player's frame of reference, so it should be fine:
<pre>
0: Player: (already at 2x speed) Move.
-- Used-move flags cleared --
0: Enemy: Agility. Used-Move set
1/2: Player: Move
1/2: Enemy: Can't Move
-- Next turn --
0: Player: Move
0: Enemy Move
1/2: Player: Move
1/2: Enemy: Move
-- Next turn --
</pre>

Additional scenarios:
<pre>
0:Player used Agility! <Move used>
0:Ally moves
-- Move use clears --
0:Enemy moves
1/2:Player moves
1/2:Ally moves
--- End Turn --
0:Player moves
0:Ally moves
-- Move use clears --
0:Enemy moves
1/2:Player moves
1/2:Ally moves
</pre>

<pre>
0:Player is already at double speed, moves.
0:Enemy moves
1/2:Player used agility! <move use set>
2/3:Player qualifies for this tier but skips. already used move
--- End Turn --
0:Player skips. already used move
-- Move use clears --
0:Enemy moves
1/3:Player moves
2/3:Player moves
--- End Turn --
0:Player moves
-- Move use clears --
0:Enemy moves
</pre>

this only works because there are two sides: player and enemy.

which is exactly the same as the number of directions in the flow of time itself: forwards and backwards.

This causes regression in another problem: Normally, Summon Trap turns on the Move Use flag to prevent the summoned enemies from immediately attacking (only for enemies).

<pre>
0:Player steps on a summon Trap. Move Use flags are set for the newly summoned enemies.
0:Allies take their turn
0:Enemies skip due to Move Use flag
1/4: Player/allies can move, Enemies skip
1/3: Player/allies can move, Enemies skip
1/2: Player/allies can move, Enemies skip
2/3: Player/allies can move, Enemies skip
3/4: Player/allies can move, Enemies skip
--- End Turn, Move Use clears --
0:Player reacts to the new summons
0:Enemies (including the new summons) move or attack
</pre>

And Orb/Chest-activated Monster Houses turn on the Move Use flag to prevent everyone from immediately attacking or reacting, until it's the leader's next turn:

<pre>
0:Player opens a chest, triggers a monster house. Move Use flags are set for everyone on the floor.
0:Allies skip due to Move Use flag
0:Enemies skip due to Move Use flag
1/4: Allies skip, Enemies skip
1/3: Allies skip, Enemies skip
1/2: Allies skip, Enemies skip
2/3: Allies skip, Enemies skip
3/4: Allies skip, Enemies skip
--- End Turn, Move Use clears --
0:Player reacts to the Monster House
0:Allies react to new summons
0:Enemies can move
</pre>

Because of the new move use flag mechanics, enemies are able to attack immediately in both scenarios, respectively:

<pre>
0:Player steps on a summon Trap. Move Use flags are set for the newly summoned enemies.
0:Allies take their turn
-- Move Use Clear --
0:Enemies can move or attack!
1/4: Player/allies can move, Enemies can move
1/3: Player/allies can move, Enemies can move
1/2: Player/allies can move, Enemies can move
2/3: Player/allies can move, Enemies can move
3/4: Player/allies can move, Enemies can move
--- End Turn --
0:Player reacts to the new summons
0:Allies react to new summons
0:Enemies can move
</pre>

And Orb/Chest-activated Monster Houses turn on the Move Use flag to prevent everyone from immediately attacking or reacting, until it's the leader's next turn:

<pre>
0:Player opens a chest, triggers a monster house. Move Use flags are set for everyone on the floor.
0:Allies skip due to Move Use flag
-- Move Use Clear --
0:Enemies can move or attack!
1/4: Player/allies can move, Enemies can move
1/3: Player/allies can move, Enemies can move
1/2: Player/allies can move, Enemies can move
2/3: Player/allies can move, Enemies can move
3/4: Player/allies can move, Enemies can move
--- End Turn, Move Use clears --
0:Player reacts to the Monster House
</pre>

We must still have a variable that prevents movement or attacking that gets cleared at the end of a round/beginning of a round, like the original Move Use flag. We will call it the End Turn Lock. As long as Move Use OR End Turn Lock are on, the character cannot act. For example, with summons:

<pre>
0:Player steps on a summon Trap. End Turn Lock are set for the newly summoned enemies.
0:Allies take their turn
-- Move Use Clear --
0:Enemies skip due to End Turn Lock
1/4: Player/allies can move, Enemies skip
1/3: Player/allies can move, Enemies skip
1/2: Player/allies can move, Enemies skip
2/3: Player/allies can move, Enemies skip
3/4: Player/allies can move, Enemies skip
-- End Turn, End Turn Lock cleared --
0:Player reacts to the new summons
0:Allies react to new summons
-- Move Use Clear --
0:Enemies can move
</pre>

Chest/Orb Monster Houses:

<pre>
0:Player opens a chest, triggers a monster house. End Turn Locks are set for everyone on the floor.
-- Move Use Clear --
0:Allies skip due to End Turn Lock
0:Enemies skip due to End Turn Lock
1/4: Allies skip, Enemies skip
1/3: Allies skip, Enemies skip
1/2: Allies skip, Enemies skip
2/3: Allies skip, Enemies skip
3/4: Allies skip, Enemies skip
-- End Turn, End Turn Lock cleared --
0:Player reacts to the Monster House
0:Allies react to new summons
-- Move Use Clear --
0:Enemies can move
</pre>

If the player activates a chest house while at double speed, they may lose their first reacting turn:

<pre>
1/2:Player opens a chest, triggers a monster house. End Turn Locks are set for everyone on the floor. Player's Move Use is set.
1/2: Allies skip, Enemies skip
-- End Turn, End Turn Lock cleared --
0:Player cannot act due to Move Use flag set
0:Allies react to new summons
-- Move Use Clear --
0:Enemies move/attack
</pre>

Removing End Turn Lock must also remove Move Use flag:

<pre>
1/2:Player opens a chest, triggers a monster house. End Turn Locks are set for everyone on the floor. Player's Move Use is set.
1/2: Allies skip, Enemies skip
-- End Turn, End Turn Lock cleared, Move Use flag cleared --
0:Player reacts to new summons
0:Allies react to new summons
-- Move Use Clear --
0:Enemies move/attack
</pre>

User:IDK/Speed Rework

2025-07-19T03:46:04Z

IDK:

User:IDK/Speed Rework

2025-07-19T01:05:22Z

IDK: End Turn Lock

The current speed system that everyone moves on is:

<pre>
0: All movement Speeds
1/4: Quad Speed
1/3: Triple Speed
1/2: Double, Quad Speed
2/3: Triple Speed
3/4: Quad Speed
-- End Turn. Clear all used-move flags --
</pre>
I tried changing it to

<pre>
1/4: Quad Speed
1/3: Triple Speed
1/2: Double, Quad Speed
2/3: Triple Speed
3/4: Quad Speed
0: All movement Speeds
-- End Turn. Clear all used-move flags --
</pre>

this would in theory solve the speed-up delay

because previously it was:
<pre>
0: Use speed-up move, player is marked as used-move
0: Enemy moves
1/2: Player is at double speed and would be able to move again, but is marked as used-move so they can't
-- Next Turn. Clear all used-move flags. --
0: Player walks
0: Enemy walks
1/2: Player can walk again
</pre>

Now it would be:
<pre>
1: Use speed-up move, player is marked as used-move
1: Enemy moves
-- Next Turn. Clear all used-move flags. --
1/2: Player walks
1: Player can walk again
1: Enemy gets to move
</pre>

HOWEVER

this design would reveal a favoritism to enemy:
<pre>
1: Player attacks
1: Enemy used Silver wind! Enemy is at double speed! (Marked as move-used)
-- Next turn. All used-move flags cleared. --
1/2: Enemy used Silver Wind! Enemy is at triple speed! (Marked as move-used)
2/3: Enemy would normally be able to move AGAIN, but is marked as used-move so they can't (thank god)
1: Player can respond
</pre>

technically, this issue also occurs in the current system, just with a one-turn delay. But our current system slightly favors enemies too. But what if...

<pre>
-- All used-move flags for ENEMIES cleared --
0: All movement Speeds
-- All used-move flags for PLAYERS cleared --
1/4: Quad Speed
1/3: Triple Speed
1/2: Double, Quad Speed
2/3: Triple Speed
3/4: Quad Speed
</pre>

or rather

<pre>
0: All movement Speeds (Player)
-- All used-move flags cleared --
0: All movement Speeds (Enemies)
1/4: Quad Speed
1/3: Triple Speed
1/2: Double, Quad Speed
2/3: Triple Speed
3/4: Quad Speed
</pre>

This doesn't look very clean, but it would result in fairness:

<pre>
0: Player: Agility. Used-Move set
-- Used-move flags cleared --
0: Enemy: Move.
1/2: Player: Move
-- Next turn --
0: Player: Move
0: Enemy Move
1/2: Player: Move
-- Next turn --
0: Player: Move
etc.
</pre>

and

<pre>
0: Player: Move
-- Used Move flags cleared --
0: Enemy: Silver Wind. Used-Move set.
1/2: Enemy: Used-move, not allowed to move.
-- Next Turn --
0: Player: Move
0: Enemy: Move
1/2: Enemy: Move
-- Next Turn --
0: Player: Move
0: Enemy: Move
1/2: Enemy: Move
</pre>

also...

<pre>
0: Player: Move
-- Used Move flags cleared --
0: Enemy: Silver Wind (Double speed). Used-Move set.
1/2: Enemy: Used-move, not allowed to move.
-- Next Turn --
0: Player: Move
-- Used Move flags cleared --
0: Enemy: Silver Wind (Triple speed). Used-move set.
1/3: Enemy: Used-move, not allowed to move.
2/3: Enemy: Used-move, not allowed to move.
-- Next Turn --
0: Player: Move
</pre>

if both the player and the enemy get to move on a sub-turn like 1/2, the player gets to move first and then the enemy moves right after

<pre>
0: Player: Agility. Used-Move set
-- Used-move flags cleared --
0: Enemy: (Already at 2x speed) Move.
1/2: Player: Move
1/2: Enemy: Move
-- Next turn --
0: Player: Move
0: Enemy Move
1/2: Player: Move
1/2: Enemy: Move
-- Next turn --
0: Player: Move
etc.
</pre>

This scenario is slightly in favor of the player, but only within the player's frame of reference, so it should be fine:
<pre>
0: Player: (already at 2x speed) Move.
-- Used-move flags cleared --
0: Enemy: Agility. Used-Move set
1/2: Player: Move
1/2: Enemy: Can't Move
-- Next turn --
0: Player: Move
0: Enemy Move
1/2: Player: Move
1/2: Enemy: Move
-- Next turn --
</pre>

Additional scenarios:
<pre>
0:Player used Agility! <Move used>
0:Ally moves
-- Move use clears --
0:Enemy moves
1/2:Player moves
1/2:Ally moves
--- End Turn --
0:Player moves
0:Ally moves
-- Move use clears --
0:Enemy moves
1/2:Player moves
1/2:Ally moves
</pre>

<pre>
0:Player is already at double speed, moves.
0:Enemy moves
1/2:Player used agility! <move use set>
2/3:Player qualifies for this tier but skips. already used move
--- End Turn --
0:Player skips. already used move
-- Move use clears --
0:Enemy moves
1/3:Player moves
2/3:Player moves
--- End Turn --
0:Player moves
-- Move use clears --
0:Enemy moves
</pre>

this only works because there are two sides: player and enemy.

which is exactly the same as the number of directions in the flow of time itself: forwards and backwards.

This causes regression in another problem: Normally, Summon Trap turns on the Move Use flag to prevent the summoned enemies from immediately attacking (only for enemies).

<pre>
0:Player steps on a summon Trap. Move Use flags are set for the newly summoned enemies.
0:Allies take their turn
0:Enemies skip due to Move Use flag
1/4: Player/allies can move, Enemies skip
1/3: Player/allies can move, Enemies skip
1/2: Player/allies can move, Enemies skip
2/3: Player/allies can move, Enemies skip
3/4: Player/allies can move, Enemies skip
--- End Turn, Move Use clears --
0:Player reacts to the new summons
0:Enemies (including the new summons) move or attack
</pre>

And Orb/Chest-activated Monster Houses turn on the Move Use flag to prevent everyone from immediately attacking or reacting, until it's the leader's next turn:

<pre>
0:Player opens a chest, triggers a monster house. Move Use flags are set for everyone on the floor.
0:Allies skip due to Move Use flag
0:Enemies skip due to Move Use flag
1/4: Allies skip, Enemies skip
1/3: Allies skip, Enemies skip
1/2: Allies skip, Enemies skip
2/3: Allies skip, Enemies skip
3/4: Allies skip, Enemies skip
--- End Turn, Move Use clears --
0:Player reacts to the Monster House
0:Allies react to new summons
0:Enemies can move
</pre>

Because of the new move use flag mechanics, enemies are able to attack immediately in both scenarios, respectively:

<pre>
0:Player steps on a summon Trap. Move Use flags are set for the newly summoned enemies.
0:Allies take their turn
-- Move Use Clear --
0:Enemies can move or attack!
1/4: Player/allies can move, Enemies can move
1/3: Player/allies can move, Enemies can move
1/2: Player/allies can move, Enemies can move
2/3: Player/allies can move, Enemies can move
3/4: Player/allies can move, Enemies can move
--- End Turn --
0:Player reacts to the new summons
0:Allies react to new summons
0:Enemies can move
</pre>

And Orb/Chest-activated Monster Houses turn on the Move Use flag to prevent everyone from immediately attacking or reacting, until it's the leader's next turn:

<pre>
0:Player opens a chest, triggers a monster house. Move Use flags are set for everyone on the floor.
0:Allies skip due to Move Use flag
-- Move Use Clear --
0:Enemies can move or attack!
1/4: Player/allies can move, Enemies can move
1/3: Player/allies can move, Enemies can move
1/2: Player/allies can move, Enemies can move
2/3: Player/allies can move, Enemies can move
3/4: Player/allies can move, Enemies can move
--- End Turn, Move Use clears --
0:Player reacts to the Monster House
</pre>

We must still have a variable that prevents movement or attacking that gets cleared at the end of a round/beginning of a round, like the original Move Use flag. We will call it the End Turn Lock. As long as Move Use OR End Turn Lock are on, the character cannot act. For example, with summons:

<pre>
0:Player steps on a summon Trap. End Turn Lock are set for the newly summoned enemies.
0:Allies take their turn
-- Move Use Clear --
0:Enemies skip due to End Turn Lock
1/4: Player/allies can move, Enemies skip
1/3: Player/allies can move, Enemies skip
1/2: Player/allies can move, Enemies skip
2/3: Player/allies can move, Enemies skip
3/4: Player/allies can move, Enemies skip
-- End Turn, End Turn Lock cleared --
0:Player reacts to the new summons
0:Allies react to new summons
-- Move Use Clear --
0:Enemies can move
</pre>

Chest/Orb Monster Houses:

<pre>
0:Player opens a chest, triggers a monster house. End Turn Locks are set for everyone on the floor.
-- Move Use Clear --
0:Allies skip due to End Turn Lock
0:Enemies skip due to End Turn Lock
1/4: Allies skip, Enemies skip
1/3: Allies skip, Enemies skip
1/2: Allies skip, Enemies skip
2/3: Allies skip, Enemies skip
3/4: Allies skip, Enemies skip
-- End Turn, End Turn Lock cleared --
0:Player reacts to the Monster House
-- Move Use Clear --
0:Allies react to new summons
0:Enemies can move
</pre>

User:IDK/RNG

2025-04-30T00:16:20Z

IDK: rng article

Some folks on the discord have pointed out how various changes in PMDO have made RNG more enjoyable or easier to deal compared to other roguelikes or main series Pokemon.

* Critical Hits have a base chance of 0.
* Additional effects never have less than a 25% chance of triggering
* Sleep ticks down with every hit, and expires immediately if from a damaging hit
* Paralysis causes inaction every other turn, for 3 turns
* Confusion randomizes your direction to front and sides
* Poisoning ends after 5 turns, always taking 5/8 HP (5/16 if the player stands completely still)
* Statuses in general always end on your turn, guaranteeing your turn to act.
* Traps are visible, but not always revealed.
* You can never miss twice.

These design choices arose from my experimentation and playtesting of PMDO over the years and the formation of my own philosophy with how to handle luck factors. The factors I keep in mind for my personal RNG design roughly comes down to three things:

== Boundedness of Outcome ==

What's the worst thing that could happen? Is it possible for a truly demonic RNG to carry a player into disaster from the start to finish? I came to look at these random outcomes as bounded or unbounded.

* An RPG where every single attack could miss, from the weak starting attack to the emergency nuke, could result in you missing all 5 turns against an enemy that 5HKOs you. The number of misses you could get is **unbounded**.
* A roguelike that consists of only straight consecutive rooms, each with either an enemy or a healing item, could give the player nothing but enemies until they collapsed from attrition. The number of enemies they could face before obtaining necessary resources is **unbounded**.
* Tetris, implemented with naive RNG of piece spawning, could theoretically give the player [https://en.wikipedia.org/wiki/Tetris#Infinite_game_question all snake pieces], which will cause a player to top out as they have no way to put them all together in rows. The number of bad pieces the game could hand them is **unbounded**.
* A more conceptual example: an infinite deck of playing cards has infinity of every card. The number of unwanted cards a player could consecutively get is **unbounded**.

In earlier days of PMDO development, I approached RNG from the lens of [https://www.youtube.com/watch?v=dwI5b-wRLic input vs output randomness]. I experimented with [https://www.gamedeveloper.com/design/randomness-and-game-design purist views] and removed factors like missing or additional effects entirely. But with testing these things on and off I found that this model broke down in increasingly noticeable ways. The above examples feature both inputs and outputs, but their chance of dealing catastrophe to the player were equal. Output randomness is just input randomness delayed to the next turn, and it seemed better to view the role of luck in a continuum than fixating on single instances. And what seemed to matter here is the capability for the RNG to be *continuously* adversarial from start to finish.

* A finite deck will guarantee odds of cards that werent yet drawn, with more reliability the smaller the deck. This RNG is **bounded to the number of cards in the deck**. Modern cardlikes tend to have significantly smaller decks than traditional card games, and often benefit from this smaller possibility space.
* The standard Tetris RNG enforced by the Tetris Guidelines generates one of every piece in grouped bags. It is **bounded to [https://tetris.wiki/Random_Generator once per 7 drops]**. This provision was made specifically to allow the player a manageable even-ness of probability to play with.
* A roguelike that consists of only straight consecutive rooms, with healing items placed at every 4 or 5th room, is guaranteed to allow the player to keep going assuming the monsters in between are a survivable gauntlet up to that point. It's **bounded to a mnimum of 1 item per 5 rooms**. This is used in practice: Brogue and numerous other roguelikes use this to properly pace out their food spawns to ensure the player doesn't starve. PMDO follows this in its apple and leppa spawn.
* An RPG where the player can never miss twice is **bounded to 1/2 their average attack effectiveness**. If the player missed their first swing, they are now in a situations where it's better to use the strongest attack on the next turn to make up the DPS. If they landed their first swing, maybe it's better to conserve resources.

PMDO can never miss twice. If I wind up in a situation where I have to gamble life and death on an un-guaranteed attack, there's usually something in my last 4 turns that tells me I messed up somewhere. Additionally, chained applications of crowd-controlling status effects such as flinch simply cannot work: since players recover from the status on their turn, they always have a window of time to respond. From my journey in iterating this game, I've found bounded/unbounded categorization to serve me better than input/output in quantifying satisfying risk management and adaptation.

== Severity of Consequence vs Warning ==

How random an outcome can be is only part of the equation to making a player upset or satisfied. The other part is what's at stake.

* Getting hit with an instant death that sends you back to the beginning of an 8 hour endeavor is severe. Getting hit with instant death that costs you 5 seconds to next respawn less so.
* Losing a long 6v6 ladder game of Pokemon Showdown is severe, at least compared to losing the RPS-like 1v1 ladder.
* A status condition where you cant do anything but take damage is severe, but status condition where you cant do anything until you take damage is less severe. And this is even less severe when your ability to act is spread across multiple units on the field instead of one (Singles, Doubles, PMD's 4-team simultaneity).

Games can be enjoyable tests of skill with immense amounts of luck intertwined so long as it's [https://www.gamedeveloper.com/design/video-games-luck-and-orange-juice-100-relevant easy to recover and try again]. This can apply to recovering between sessions, or recovering between events occurring in the same game session.

The more severe a consequence or outcome I introduce, the more I make the game warn the player about it, the more opportunities I give to the player to avoid it. This also bleeds into the practice of telegraphing threats ahead of time in completely RNG-less settings.

* In PMDO, status effects are much easier to deal with, and so their chance of occurrence is much higher. There will always be a chance of burn with Ember. Always a chance of poisoning with poison sting. These are things the player must always keep in mind, but this demand is made more reasonable by the larger amount of backup plans available to deal with them. The awkward situations that enemy procs *could* land the player in create the varied challenges to serve as the input randomness of any given turn thereafter. Factor in their own team's likelyhood of scoring these effects on opponents, and you have a setup that breeds surprise and encourages adaptation. This is also a strong point of battles of main series Pokemon's ingame campaigns- the inconsistency of additional effects drives much of the situational variety seen in battling.
* This also affects trap philosophy: Traps that are guaranteed to hit up to 1 tile away for a recoverable status effect or damage are unidentified, while autotargeting traps with severe or long-term consequences (item destruction, PP-zero) are all revealed.

== The Demand for Presence of Mind ==

I often try to keep the rng outcome tree relatively tame within a round of the game. In my playthroughs, thinking several turns ahead has proved satisfying when each of those turns results in two or three possible outcomes. Thinking several turns ahead when each of those turns can lead to seven leads to multiplicative game trees that demand a presence of mind beyond my grasp. [https://keithburgun.net/uncapped-look-ahead-and-the-information-horizon/ This is also something that can happen with purely RNG-less games].

It *is* possible to take a step back and analyze every possible outcome [https://www.youtube.com/watch?v=tTaj5wCFvQM on every possible set]. Moments like these are intense in their own right even when spending 10 minutes on attack selection. However, I chose not to design for this pace of gameplay.

* This is why the base crit rate is 0, and also why your heart rate spikes when super luck absol enters your screen to temporarily reintroduce that demand for playing around the crit range.
* It's also why moves with additional effects often have high accuracy, as their ability to miss can add an extra layer of complication to the effects that already need consideration. Moves that have multiple possible effects- such as Fire Fang- also make their effects mutually exclusive: Flinch *or* Burn *or* nothing. Not Flinch, Burn, Flinch+Burn, or nothing.
* Enemies' movesets to begin with are also limited often to 2, to moderate the preparation demand on what attack they might choose (and also helps give them their own identity).
* Pertaining to trap detection, this demand for presence of mind was something I experienced in other roguelikes. In Zero Isle South and some of the more stressful Shiren dungeons, the optimal approach for such trap laden torture chambers was really to move forward, swipe to reveal trap, move forward, swipe to reveal trap, etc. The alternative was to simply move forward and accept a lingering paranoia. When I played these dungeons, I swiped paths through all rooms, all the way through. For Destiny Tower, which prevented swipe reveals, I even threw rocks to test the tile 2 spaces ahead (if it's a trap, the rock will bounce off). This was simply not something I wanted my own players to experience.

Hope this helps for aspiring modders to understand the idea behind the mechanics they're working with, and also to inform decision of their own changes.

Taking Turns

2025-04-23T04:23:37Z

IDK: link to rambles

PMDO is a turn-based roguelike dungeon crawler. Every time you move, the enemies move.
When all player and enemy turns completes, this is called a Round.

== The Turn Cycle ==

Under normal circumstances, a single Round consists of one full Cycle of player+enemy movements, ordered as such:

* The player's team moves
** Members: Leader first, then everyone moves in list order
** Guests: Everyone moves in list order
* Neutral NPC teams move
** Members: Leader first, then everyone moves in list order
** Guests: Everyone moves in list order
* Enemy teams move
** Members: Leader first, then everyone moves in list order
** Guests: Everyone moves in list order

It's possible for a player to rearrange their team order and change leaders before making a move, allowing them to choose the order in which their units move. Enemies also invisibly reorder their team order to mitigate chokepoint situations.

An example of a chokepoint situation is where an enemy team has a lower ranking member in front of a higher ranking member in a hallway. The higher ranking member goes first, but cannot, while the lower rank can, but moves after the higher rank member. This leads to a turn where one enemy moves forward, but the other one doesn't. Very unintuitive, so the enemies quietly reorder their turns to make this behavior more natural. This also happens with player allies.

== Speed Changes and Turn Tiers ==

Under normal speed conditions, everyone gets to move exactly once. However, speed can be increased in this game. Specifically, Movement Speed. Rounds are actually broken up into 6 Turn Tiers, each of them having a turn Cycle detailed in the previous section. A character can only move in that tier if they have a Movement Speed that the tier permits.

The 6 turn tiers are as follows:

* Tier 0: All movement Speeds
* Tier 1/4: Quadruple Speed
* Tier 1/3: Triple Speed
* Tier 1/2: Double Speed, Quadruple Speed
* Tier 2/3: Triple Speed
* Tier 3/4: Quadruple Speed

Under normal circumstances, everyone would move at the turn cycle on tier 0 and the other tiers would not be used. But when someone speeds up, they can use the other tiers.

For example:

So if a player team consists of the following:
* Leader: Double Speed
* Partner 1: Normal Speed
* Partner 2: Normal Speed

And an enemy team consists of the following:
* Leader: Quadruple Speed
* Partner 1: Normal Speed

The turn order would look like this:

* Tier 0:
** Player Team:
*** Player Moves
*** Partner 1 Moves
*** Partner 2 Moves
** Enemy Team:
*** Leader Moves
*** Partner 1 Moves
* Tier 1/4:
** Player Team:
** Enemy Team:
*** Leader Moves
* Tier 1/3:
** Player Team:
** Enemy Team:
* Tier 1/2:
** Player Team:
*** Player Moves
** Enemy Team:
*** Leader Moves
* Tier 2/3:
** Player Team:
** Enemy Team:
* Tier 3/4:
** Player Team:
** Enemy Team:
*** Leader Moves
* The Round ends

When a character's movement speed is decreased, they will still always perform movements at turn tier 0. However, every time they do, they incur a cooldown of X turns reliant on how much they've slowed down. A Half Speed character will have to wait 1 turn after moving. A 1/3 Speed character will have to wait 2. A 1/4 Speed character will have to wait 3.

== Attacking ==

All movement speed changes only come into effect if the player moves. They do not apply to attacking or using items. If a player at slowed movement speed attacks, they do not skip subsequent turns. If a player at boosted speed attacks, they can no longer participate in higher Turn Tiers for that round. This can be exploited slightly:

Let's say a player is moving at double speed against an enemy at normal speed.
On the player's turn at Tier 0, if they move, the enemy moves. Then on tier 1/2, the player can perform an attack. The round then ends, and the player can act again.

However, if the player chooses to attack, they will not be able to move until they have passed the turn border. It would simply play out as if both entities were moving/attacking at normal speed.

The "turn border" sits on Tier 0, right between the player and the enemy factions. The unintuitive place to put the turn border is chosen due to its surprisingly intuitive results for speed boosts and drops. [[User:IDK/Speed_Rework|More information]]

[[Category:Game Mechanics]]

User:IDK/Speed Rework

2025-04-23T04:21:54Z

IDK: speed rambles

User:IDK

2025-04-23T04:11:22Z

IDK: create

Links go here.

Dev Mode

2025-03-06T04:38:28Z

IDK: CTRL+Cancel

PMDO has a secret developer mode that can be used to cheat, examine, and mod the game.
Start PMDO in this mode using the following command:

Windows:
<pre>
PMDO.exe -dev
</pre>

Unix:
<pre>
./PMDO -dev
</pre>

You can also run the <code>dev.bat</code> file to start without the command line.

== Hotkeys ==

* F1 shows diagnostic information. This will show FPS, version number, current position, animation, and hitboxes. This is also usable outside of dev mode but will only show FPS and version number.
* Shift+Up/Down warps to the next and previous floors of the dungeon, respectively.
* Shift+Left/Right warps to the next and previous segments of the dungeon. A dungeon may be split up into segments such as Magma Cavern and Deep Magma Cavern.
* Shift+Right Click will warp the player to the location clicked.
* F2 pauses the game.
* F3 advances the frame when the game is paused.
* F4 is a test button used by programmers to quickly test a feature. Don’t worry about this.
* F5 slows down the game.
* F6 speeds up the game.
* F8 mutes the music, and unmutes it when muted.
* F9 turns on FreeCam mode, where the camera can be moved. In dungeons, it turns on SeeAll mode.
* F11 takes a screenshot of the ENTIRE map, useful for showcasing maps. All characters, objects, and currently active VFX are included. The screenshot is saved to the SCREENSHOT/ subfolder.
* F12 warps the player to the debug ground map using their current save file. If no save file exists, a debug file is created (but not saved)
* F1+F12 warps the player to the debug room. Unlike F12, it send the player to the debug dungeon map.
* CTRL+F12 soft resets to the title screen.
* CTRL+Cancel clears textboxes and menus to skip text. Cancel is the Z key by default.

== Dev Panel ==

This contains the main controls to modify the game. They are separated into tabs.

=== Game ===
Often used to cheat and test in dungeons.

[[File:DevPanel_Game.png|frameless]]

* Hide Objects: Hides items and traps. In ground maps, objects are hidden.
* Hide Sprites: Hides Pokemon. Often used for screenshots.
* Create Clone: Creates a (Hostile) clone of your current character in your current location.
* Clear All Foes: Removes all enemies from the map.
* Skill List: Allows you to learn a move, or give it to foes.
* Ability list: Allows you to gain an ability, or give it to foes.
* Status List: Allows you to take on a status effect.
* Item List: Allows you to spawn items in dungeons.

=== Player ===
Often used to cheat in dungeons, or test animations.

[[File:DevPanel_Player.png|frameless]]

* Lv.: Sets the current player’s level. Updates in real time.
* Reroll: Updates the current player’s moveset to the latest naturally learned moves at the current level.
* Species/Form/Skin/Gender: Change the player’s current species/form/shininess/gender.
* Animation: Change the player’s current animation.

=== Travel ===
Used to instantly warp to needed locations.

[[File:DevPanel_Travel.png|frameless]]

* Areas are organized into Zones.
* Each zone has a list of Structures, plus a list of Ground Maps.
* Ground Maps are the hub maps with free movement.
* Each Structure contains a list of floors.
* You can choose to enter either a a Ground map using Enter Ground, or a dungeon floor using Enter Map.

=== Data ===
Used to edit maps, items, Pokemon, etc.

[[File:DevPanel_Data.png|frameless]]

=== Sprites ===
Used to the graphics of the game.

[[File:DevPanel_Sprites.png|frameless]]

* Char Sprites: Pokemon sprites in dungeons/overworld.
* Portraits: Character portraits in dialogue.
* Particles: Most attack graphics.
* Beams: Used in attacks that shoot continuous beams, plus columns of light used for sending home.
* Backgrounds: Used in the title screen, and maps with parallax backgrounds.
* Emotes: Emote animations. Includes status effect icons.
* Tiles: All tilesets. Does not include autotiles (which are in the Data tab).
* Items: Item Sprites
* Objects: Tree stumps, signs, traps, etc.

=== Script ===
A lua command prompt to enter custom commands.

[[File:DevPanel_Script.png|frameless]]

* Reload Scripts: Reloads all lua scripts with your edits without needing to restart the game.
* Text Test: Allows you to test a dialogue box with sample text. For translators.

Command box controls:
* Type in a lua script command to run it directly on the game.
* Use TASK:BranchCoroutine(<your function here>) to call coroutines.
* SHIFT+Up/Down to scroll past commands.
* SHIFT+Enter to enter a multiline command.

=== Mods ===
Controls which mod the game currently has loaded. Can create, delete, and switch between mods. Only one may be loaded at a time. If you want to work on a mod, make sure the game is set to that mod before doing work.

[[File:DevPanel_Mod.png|frameless]]

=== Constants ===
Starter data, special game events, and VFX that are used in hardcoded portions of the game.

[[File:DevPanel_Constants.png|frameless]]

=== The Debug Room ===
This room contains a crowd of Pokemon at the top left corner for east move/ability/item testing.

[[File:DebugRoom.png|frameless]]

[[Category:Modding]]
[[Category:Quick Reference]]

Services

2025-01-22T01:49:46Z

IDK: add category tags

Services are special files whose purpose is to listen to specific actions the game can perform and then run some code whenever they occur.<br>
The base game already has a few built-in services that can be used for reference, but this page will go over how to make a new service from scratch and how to register new callbacks.

=== How to make a service ===
First, navigate to your mod's <code>Data>Script>[namespace]</code> folder. Once there, add a <code>services</code> folder if there isn't one already and, inside of it, create yet another folder. This final folder can have any name you want as long as it has no special characters in it, but it's best to stick to something that is as close as possible to the name you want to give to your service. For Example, the base game's DebugTools service is inside the debug_tools folder.
Finally, create a text file inside of this folder and call it init.lua. Make sure that .lua is part of the file's extension and not still a portion of its name.

Once you're done, open this file with your text editor of choice. You will want to copy and paste this whole block inside of it:
<pre>
require 'origin.services.baseservice'

local MyService = Class('MyService', BaseService)

function MyService:initialize()
end

function BaseService:Subscribe(med)
end

SCRIPT:AddService("MyService", MyService:new())
return MyService
</pre>

This is the smallest possible service you can make. It simply creates the class, registers it, and then returns it. You can change "MyService" into whatever name you want, of course.<br>
Right now, though, this service of ours literally does nothing. Let's change that.<br>
You can use the initialize function to define starting parameters or other global data related to your service. Keep in mind, however, that these values are not kept in between game sessions. Always remember to store your save data inside your SV structure if you want to be able to retrieve it after closing the game.<br>
What we need to use to make a service work, however, is the Subscribe function. This is the function responsible for registering callbacks so that the game knows to call them whenever a specific event takes place. You can find a list of all Engine Events present in the game and their parameters [[Service Events|here]].

==== Creating a Callback ====
The first thing we need is the function we want to call. This can have any name you like, but it's best if its name references the event it is subscribed to in some way.<br>
We will use this simple print function as an example. Make sure to put it below your service's declaration but before its Subscribe function:
<pre>
function MyService:OnInit()
assert(self, 'MyService:OnInit() : self is null!')
PrintInfo("\n<!> MyService: Init..")
end
</pre>
All this function does is print whether or not our service has been registered correctly when the service engine is loaded. To make it run, all we need to do is to add this line inside the service's Subscribe function:
<pre>
med:Subscribe("MyService", EngineServiceEvents.Init, function() self:OnInit() end)
</pre>

If you run the game now, you will notice that nothing happens still. This is because this file has never been loaded by the game. To make it load, create a <code>main.lua</code> file in your mod's <code>Data>Script>[namespace]</code> folder and write <code>require "[namespace].services.[service_folder]"</code> in it. Now the game will know it needs to load your service and you will see its OnInit function being called as expected.

==== Callbacks with parameters ====
Many events contain parameters that get sent alongside their service messages so that services can reference and interact with them. These parameters are packaged into an argument array with starting index 0. An example of this is LossPenalty, whose argument 0 is the current GameProgress instance, which is to say, the save data itself. We need to pass this parameter along if we want to make use of it.<br>
If you're wondering what that discaded parameter is, it's your service's class. At no point you'll ever need this, since you're already working with it anyway.
<pre>
function MyService:OnLossPenalty(save)
[...]
end

function MyService:Subscribe(med)
med:Subscribe("MyService", EngineServiceEvents.LossPenalty, function(_, args) self:OnLossPenalty(args[0]) end )
end
</pre>
And that's all there is to it! Every service callback can be reduced to these simple steps!

[[Category:Scripting]]
[[Category:Quick Reference]]

Linux Flatpak

2024-11-16T22:13:04Z

IDK: link to github repo

PMDO can be installed via [https://en.wikipedia.org/wiki/Flatpak Flatpak]. This allows you to install PMDO on any Linux distribution (ideally) without needing to use the terminal. It also gives you a convenient way to update.

== Setting up Flatpak ==
Flatpak must be installed on your distribution. This is the default on most, but not all distributions (notably not on Ubuntu). On the Steam Deck / SteamOS Flatpak is already setup. For other distributions, check the [https://flathub.org/setup Flathub setup] instructions. By following these you will also install the Flathub repository which allows you to install even more Linux apps.

== Adding the SkyTemple / PMDCollab Repo ==
Currently PMDO is not distributed via Flathub but via the SkyTemple Flatpak repository. To set it up download and open the following file:

[https://skytemple.org/build_deps/skytemple-stable.flatpakrepo Download Flatpak Repo]

This should open a software app and ask you to add the repository.

== Installing PMDO ==
Once the repository is installed, you can find PMDO by searching "PMDO" in your software app. Alternatively you can install it using this file (this still requires the repository to be set up):

[https://skytemple.org/build_deps/org.pmdcollab.pmdo.flatpakref Download Flatpak Appref]

== Using the software center ==
Now that you have setup Flatpak and PMDO you will be able to use the software center of your distribution to manage, update or uninstall PMDO. It might also auto-update it, or you can configure it to do so. The software center application is named differently based on your repo. It is the one that opened when you opened the file in the previous step. It may be named "Software", "Discover" or something similar.

== Accessing Files ==
Game files, such as saves and mods, are stored at "/home/<your name>/.var/app/org.pmdcollab.pmdo/config/org.pmdcollab/".

=== Installing mods ===
You can place mod files at "/home/<your name>/.var/app/org.pmdcollab.pmdo/config/org.pmdcollab/PMDC/MODS/".

== Downgrading ==
Downgrading is usually a bit more involved. Software centers usually offer no direct way to downgrade, but it is still possible using the terminal.

You can use the following command to list all versions of PMDO:<syntaxhighlight lang="bash">
flatpak remote-info skytemple-stable org.pmdcollab.pmdo --log
</syntaxhighlight>Then, note the commit hash matching the version you need. The versions may not be named, use the date instead to find the release you need. Then to install an older version, run:<syntaxhighlight lang="bash">
flatpak update --commit=COMMIT org.pmdcollab.pmdo
</syntaxhighlight>Replace "COMMIT" with the commit you noted down previously.

== Full manual installation ==
If all else fails, you can download the [https://nightly.link/PMDCollab/PMDO-Flatpak/workflows/publish/main/org.pmdcollab.pmdo-x86_64.zip pure Flatpak files] directly. This does not require any prior setup of repositories, but also doesn't support automatic updates, etc.

The repo source can be found in [https://github.com/PMDCollab/PMDO-Flatpak]

Lua Script Migration

2024-11-13T02:39:56Z

IDK: services clarification

Between 0.8.1 and 0.8.2, the lua scripting system has changed. This page explains all of the changes to the lua scripting system. There are many breaking changes, but when you reserialize mods between these versions, the lua scripts will go through an automatic conversion.

While PMDO tries to automatically convert as many things as it can, there are still a few points that must be handled by the mod developer. Consult the automatic conversion section at the bottom of this page for a general summary.

== Diff Modding ==

=== Main Case ===

In the new system, lua scripts are diff modded. This means that instead of having to replace the entire file in the base game, you can chose to just add or redefine functions that you want.

For example, the script [https://github.com/audinowho/DumpAsset/blob/master/Data/Script/origin/event_misc.lua event_misc.lua] contains the following methods:

<pre>
function STATUS_SCRIPT.Test(owner, ownerChar, context, args)
function MAP_STATUS_SCRIPT.Test(owner, ownerChar, character, status, msg, args)
function MAP_STATUS_SCRIPT.ShopGreeting(owner, ownerChar, character, status, msg, args)
function MAP_STATUS_SCRIPT.SetShopkeeperHostile(owner, ownerChar, character, status, msg, args)
function ITEM_SCRIPT.Test(owner, ownerChar, context, args)
function ITEM_SCRIPT.CastawayCaveShift(owner, ownerChar, context, args)
function ITEM_SCRIPT.SleepingCalderaShift(owner, ownerChar, context, args)
function REFRESH_SCRIPT.Test(owner, ownerChar, character, args)
function SKILL_CHANGE_SCRIPT.Test(owner, character, skillIndices, args)
</pre>

In the old system, if you wanted to mod just the <code>MAP_STATUS_SCRIPT.ShopGreeting</code> event, you would need to copy the entire event_misc.lua from the base game, modify <code>MAP_STATUS_SCRIPT.ShopGreeting</code>, and save it to your mod.

In the new system, all you need to do is create an event.lua with your custom <code>MAP_STATUS_SCRIPT.ShopGreeting</code> in it, and nothing else.

This makes it easy to maintain scripts, as the base game scripts can change. In the old system, if <code>MAP_STATUS_SCRIPT.SetShopkeeperHostile</code> in the base game changed after you copied over event_misc.lua, you would have had to copy the changed version of that method to your own mod to stay updated. Now in the new system, if you don't redefine the method in your mod, you won't have to worry about it.

This works on all scripts found in the <code>Data/Script</code> folder, and all subfolders except <code>Data/Script/services</code>.

=== Services ===

Services behave slightly differently. Originally, creating a new service with the same name as an existing base game service would add its events on top of the base game's events. However, it now replaces the original service and removes the base game's event triggers in favor of your new ones.

== Breaking Changes ==

=== Namespace Folders ===

With the diff modding changes, a caveat is that all lua scripts are namespaced. This way, you can reference methods from the base game specifically. However, it means that all scripts need to be moved to a subfolder in the name of your mod's namespace.

For example, your mod has the namespace <code>my_mod</code>, and your scripts are currently in the <code>Data/Script</code> folder of your mod (You can find/specify your mod's namespace in the <code>Mod.xml</code>). In this situation, you should move all your code to a new folder, <code>Data/Script/my_mod</code>

★ This is done as a part of auto-conversion.

=== Namespace References ===

Additionally, your <code>require</code> calls must be updated to specify whether you're importing code from the <code>origin</code> namespace or your own namespace. And meanwhile, if you made custom scripts on your own mod, you need to instead change the require to reflect your namespace, because the code is in your namespace of mod. For example, the header of a ground map script you created may look like this:

<pre>
require 'common'
require 'GeneralFunctions'
require 'PartnerEssentials'
require 'ground.my_town.my_town_ch_1'
require 'ground.my_town.my_town_ch_2'
</pre>

Let's assume in this example, your mod has namespace <code>my_mod</code>. You created this ground script in <code>Data/Script/ground/my_town/init.lua</code>.
You referred to <code>common</code> from the base code, but are referring to your own script for the rest of the includes.
You will need to change it to this:

<pre>
require 'origin.common'
require 'my_mod.GeneralFunctions'
require 'my_mod.PartnerEssentials'
require 'my_mod.ground.my_town.my_town_ch_1'
require 'my_mod.ground.my_town.my_town_ch_2'
</pre>

If this isn't done, the mod will complain about being unable to load modules that aren't there.

References to these packages also need to be updated in places where they're used without require. Most notably, AI initialization. Ex: <code>AI:SetCharacterAI(partner, "ai.ground_partner", CH('PLAYER'), partner.Position)</code> should be changed to <code>AI:SetCharacterAI(partner, "origin.ai.ground_partner", CH('PLAYER'), partner.Position)</code> or <code>AI:SetCharacterAI(partner, "my_mod.ai.ground_partner", CH('PLAYER'), partner.Position)</code>, if your mod is overriding the original ai.

If this isn't done, you will get AI errors on maps where ground character AI is supposed to work.

★ This section is done as a part of auto-conversion.

=== Starting Scripts ===

In the base game, PMDO calls the following scripts directly from the game on startup, which in turn make a <code>require</code> call to additional scripts:

* <code>main.lua</code>
* <code>common.lua</code>
** <code>common_talk.lua</code>
** <code>common_shop.lua</code>
** <code>common_vars.lua</code>
** <code>common_tutor.lua</code>
* <code>event.lua</code>
** <code>event_single.lua</code>
** <code>event_battle.lua</code>
** <code>event_misc.lua</code>
** <code>event_mapgen.lua</code>
* <code>include.lua</code>

<code>common.lua</code> and <code>event.lua</code> both make <code>require</code> calls to load their child scripts. If you have modded versions of the the child scripts, you will need to add the parent script with a single <code>require</code> call to the child. For example, if you modded <code>event_mapgen</code>, you will need to make sure you have an <code>event.lua</code> that has <code>require 'my_mod.event_mapgen</code> in it.

★ This section is done as a part of auto-conversion.

=== Automatic Tables ===

The tables for common scripts and event scripts, such as <code>SINGLE_CHAR_SCRIPT</code>, <code>BATTLE_SCRIPT</code>, and so on, are now declared by the game's code, so you don't need to declare them as empty tables anymore. You shouldn't, because the modding system stacks the base game's methods with your mod's on top, and redefining the variable would result in your mod removing the base game's functions.

You will need to remove these lines from the event scripts:

* <code>common.lua</code>:
** <code>COMMON = {}</code>
* <code>event_single.lua</code>:
** <code>SINGLE_CHAR_SCRIPT = {}</code>
* <code>event_battle.lua</code>:
** <code>BATTLE_SCRIPT= {}</code>
* <code>event_misc.lua</code>:
** <code>STATUS_SCRIPT = {}</code>
** <code>MAP_STATUS_SCRIPT = {}</code>
** <code>ITEM_SCRIPT = {}</code>
** <code>REFRESH_SCRIPT = {}</code>
** <code>SKILL_CHANGE_SCRIPT = {}</code>
** <code>GROUND_ITEM_EVENT_SCRIPT = {}</code>
* <code>event_mapgen.lua</code>:
** <code>ZONE_GEN_SCRIPT = {}</code>
** <code>FLOOR_GEN_SCRIPT = {}</code>

★ This section is done as a part of auto-conversion.

=== Services ===

Due to the change in services, several things must be accounted for:

* If you have services with the same name as those of the base game (<code>debug_tools</code>, <code>menu_tools</code>, <code>upgrade_tools</code>), your service now overwrites the original instead of adding onto it. If you want to add new functionality without overwriting the old, make a new service with a new name.
* The base game's <code>debug_tools</code> service used to have an event for <code>OnMenuButtonPressed</code>. That event has been moved out of the service and into its own service, <code>menu_tools</code>. If you are overriding OnMenuPressed in any services and do not replace menu_tools, you will have the main menu opened twice when menu button is pressed!

== Non-Breaking Changes ==

These changes are not mandatory to get your mod working, but are good to have.

=== Deprecated MapStrings ===

The use of the <code>MapStrings</code> variable to obtain the text strings for ground maps is no longer needed. You no longer need to declare them, you no longer need to initialize them, and you no longer need to reference them. Instead, strings for a ground map are automatically loaded and stored in the game for you to call on. You should remove these statements from your ground map scripts:

<pre>
local MapStrings = {}

MapStrings = COMMON.AutoLoadLocalizedStrings()
</pre>

Then, you should change all references to <code>MapStrings</code> to <code>STRINGS.MapStrings</code>

★ This section is done as a part of auto-conversion.

=== Redundant Functions ===

As mentioned in the Diff Modding section, if you don't redefine the method in your mod, you won't have to worry about it. If you have any files where you copied over the base game's scripts and edited just a single method, you can delete the other methods from that modded lua file. This will make your code more resilient to base game lua changes.

=== Un-Needed Files ===

The following files are no longer needed in your mod and will have no effect:

* The file <code>Data/Script/debugger.lua</code>
* The folder <code>Data/Script/bin</code>
* The folder <code>Data/Script/lib</code>

You can safely delete them. Their require statements in <code>common.lua</code> are also no longer needed:

<pre>
Class = require 'lib.middleclass'
Mediator = require 'lib.mediator'
Serpent = require 'lib.serpent'
</pre>

★ This section is done as a part of auto-conversion.

== Migration Checklist ==

You can reserialize your mod by running the command:

<pre>
PMDO.exe -quest My_Mod_Folder -reserialize all
</pre>

When you reserialize mods between these versions, the lua scripts will go through an automatic conversion. Some breaking changes detailed in the above section are automatically fixed. Some will not.

Items marked with ★ are automatically converted on reserialization from versions <=0.8.1 to >=0.8.2

* ★ Lua scripts are moved to a subfolder based on the mod's namespace.
* ★ References to <code>require "common"</code> become <code>require "origin.common"</code>
* ★ References to your own scripts <code>require "yourscript"</code> changed to include your namespace <code>require "yournamespace.yourscript"</code>
* ★ common and event scripts need their empty table declarations removed.
* ★ Scripts modded from children of <code>common.lua</code> or <code>event.lua</code> must have a modded version of their parent with an include to the child.
* Services that have the same name as the base game's service need to be renamed, IF you don't want to overwrite the base logic.

These are optional changes that you don't have to make, but is good to clean up files or code no longer needed:

* ★ MapStrings is deprecated.
** ★ Remove variable declaration and initialization statements.
** ★ Replace references to <code>MapStrings</code> with <code>STRINGS.MapStrings</code>
* ★ Deleted <code>Data/Script/bin</code> and <code>Data/Script/lib</code> subfolders
* ★ Deleted <code>Data/Script/services/baseservice.lua</code> file
* Functions identical to the base game are removed in the mod, for the files of common.lua and event.lua
* Functions identical to the base game are removed in the mod, for the files in ground and zone

Lua Function Reference

2024-11-13T02:35:06Z

IDK: import from most recent docs

This page shows all script functions that can be called from Lua

== AI:SetCharacterAI(RogueEssence.Ground.GroundChar,System.String,System.Object[]) ==

Assign the given scripted AI class to the specified GroundChar.

=== Arguments ===

* <code>ch</code>: None
* <code>classpath</code>: None

== AI:DisableCharacterAI(RogueEssence.Ground.GroundChar) ==

Disable a given groundchar's AI processing until its enabled again.

=== Arguments ===

* <code>ch</code>: None

== AI:EnableCharacterAI(RogueEssence.Ground.GroundChar) ==

Enable a given groundchar's AI processing if its currently disabled

=== Arguments ===

* <code>ch</code>: None

== AI:SetAIState(RogueEssence.Ground.GroundChar,System.String) ==

Enable a given groundchar's AI processing if its currently disabled

=== Arguments ===

* <code>ch</code>: None

== DUNGEON:CharTurnToChar(RogueEssence.Dungeon.Character,RogueEssence.Dungeon.Character) ==

Makes a character turn to face another

=== Arguments ===

* <code>curch</code>: None
* <code>turnto</code>: None

== DUNGEON:LastDungeonResult ==

Gets the result of the last dungeon adventure.

== DUNGEON:DungeonCurrentFloor ==

Returns the floor number of the current dungeon.

== DUNGEON:DungeonAssetName ==

Returns the internal name for the current dungeon.

== DUNGEON:DungeonDisplayName ==

Returns the localized name of the current dungeon.

== DUNGEON:CharSetEmote(RogueEssence.Dungeon.Character,System.String,System.Int32) ==

Set a character's emote in a dungeon map.

=== Arguments ===

* <code>chara</code>: Character to emote
* <code>emoteid</code>: ID of the emote
* <code>cycles</code>: The number of times to play the emote.

== DUNGEON:CharStartAnim ==

Set a character's animation.

=== Arguments ===

* <code>chara</code>: Character to animate
* <code>anim</code>: Name of the animation
* <code>loop</code>: Whether to loop the animation

=== Example ===

<pre>

DUNGEON:CharStartAnim(player, anim, false)

</pre>

== DUNGEON:CharEndAnim ==

Stops a character's current animation, reverting them to default idle.

=== Arguments ===

* <code>chara</code>: Character to stop animating

=== Example ===

<pre>

DUNGEON:CharEndAnim(player)

</pre>

== DUNGEON:CharWaitAnim ==

Set a character's animation, and waits until it completed before continue.

=== Arguments ===

* <code>chara</code>: Character to animate
* <code>anim</code>: Name of the animation

=== Example ===

<pre>

DUNGEON:CharStartAnim(player, anim)

</pre>

== DUNGEON:PlayVFX(RogueEssence.Content.FiniteEmitter,System.Int32,System.Int32,RogueElements.Dir8) ==

Plays a VFX in the dungeon map

=== Arguments ===

* <code>emitter</code>: The VFX emitter
* <code>x</code>: X position in pixels
* <code>y</code>: Y Position in pixels
* <code>dir</code>: Direction to orient the VFX, defaults to Down

== DUNGEON:PlayVFX(RogueEssence.Content.FiniteEmitter,System.Int32,System.Int32,RogueElements.Dir8,System.Int32,System.Int32) ==

Plays a VFX that has a start position and an end position. It uses a finite emitter that generates BaseAnims.

=== Arguments ===

* <code>emitter</code>: The VFX emitter
* <code>x</code>: Start X position in pixels
* <code>y</code>: Start Y Position in pixels
* <code>dir</code>: Direction to orient the VFX, defaults to Down.
* <code>xTo</code>: End X position in pixels
* <code>yTo</code>: End Y position in pixels

== DUNGEON:PlayVFXAnim(RogueEssence.Content.BaseAnim,RogueEssence.Content.DrawLayer) ==

Plays a VFX using just a BaseAnim

=== Arguments ===

* <code>anim</code>: The animation to play
* <code>layer</code>: The layer to put it on

== DUNGEON:MoveScreen(RogueEssence.Content.ScreenMover) ==

Plays a screen-moving effect.

=== Arguments ===

* <code>mover</code>: The screen mover.

== GAME:GroundSave ==

Saves the game while in ground mode.

=== Example ===

<pre>

GAME:GroundSave()

</pre>

== GAME:GetModDiff(System.String) ==

TODO

=== Arguments ===

* <code>uuidStr</code>: None

== GAME:GetCurrentGround ==

Gets the current ground map.

== GAME:GetCurrentFloor ==

Gets the current dungeon map.

== GAME:GetCurrentDungeon ==

Gets the current zone, also known as dungeon.

== GAME:EnterGroundMap(System.Int32,System.Int32,System.Boolean) ==

Leave current map, and enter specified ground map within the current zone

=== Arguments ===

* <code>id</code>: The index of the ground map in the zone
* <code>idxentrypoint</code>: The index of the entry point in the ground map
* <code>preserveMusic</code>: If set to true, does not change the music when moving to the new ground map.

== GAME:EnterGroundMap(System.String,System.String,System.Boolean) ==

Leave current map, and enter specified ground map within the current zone

=== Arguments ===

* <code>name</code>: The name of the ground map. It must exist within in the zone.
* <code>entrypoint</code>: The name of the entry point in the ground map
* <code>preserveMusic</code>: If set to true, does not change the music when moving to the new ground map.

== GAME:EnterGroundMap(System.String,System.String,System.String,System.Boolean) ==

Leave current map, and enter specified ground map within a new zone.

=== Arguments ===

* <code>zone</code>: The name of the destination zone.
* <code>name</code>: The name of the ground map. It must exist within in the zone.
* <code>entrypoint</code>: The name of the entry point in the ground map
* <code>preserveMusic</code>: If set to true, does not change the music when moving to the new ground map.

== GAME:EnterDungeon ==

Enters a zone and begins a new adventure.

=== Arguments ===

* <code>dungeonid</code>: The id of the dungeon to travel to.
* <code>structureid</code>: The segment within the dungeon to start in. -1 represents ground maps.
* <code>mapid</code>: The id of the ground map or dungeon map within the dungeon segment.
* <code>entry</code>: The entry point on the resulting map
* <code>stakes</code>: Decides what happens when the adventure fails/succeeds.
* <code>recorded</code>: Record the adventure in a replay
* <code>silentRestrict</code>: Make the dungeon restrictions silently

=== Example ===

<pre>

GAME:EnterDungeon(1, 0, 0, 0, RogueEssence.Data.GameProgress.DungeonStakes.Risk, true, false)

</pre>

== GAME:ContinueDungeon ==

Enters a zone and continues the current adventure.

=== Arguments ===

* <code>dungeonid</code>: The id of the dungeon to travel to.
* <code>structureid</code>: The segment within the dungeon to start in. -1 represents ground maps.
* <code>mapid</code>: The id of the ground map or dungeon map within the dungeon segment.
* <code>entry</code>: The entry point on the resulting map

=== Example ===

<pre>

GAME:ContinueDungeon(1, 1, 0, 0)

</pre>

== GAME:EndDungeonRun ==

Ends the current adventure, sending the player to a specified destination.

=== Arguments ===

* <code>result</code>: The result of the adventure.
* <code>destzoneid</code>: The id of the dungeon to travel to.
* <code>structureid</code>: The segment within the dungeon to start in. -1 represents ground maps.
* <code>mapid</code>: The id of the ground map or dungeon map within the dungeon segment.
* <code>entryid</code>: The entry point on the resulting map
* <code>display</code>: Display an epitaph marking the end of the adventure.
* <code>fanfare</code>: Play a fanfare.
* <code>completedZone</code>: Zone to mark as completed. Defaults to current zone.

=== Example ===

<pre>

GAME:EndDungeonRun(GameProgress.ResultType.Cleared, 0, -1, 1, 0, true, true)

</pre>

== GAME:EnterRescue ==

Enters a zone and begins a rescue adventure.

=== Arguments ===

* <code>sosPath</code>: The path of the sos mail.

=== Example ===

<pre>

GAME:EnterRescue("RESCUE/INBOX/SOS/example.sosmail")

</pre>

== GAME:AddAOKRemark(System.Int32) ==

TODO: WIP

=== Arguments ===

* <code>remarkIndex</code>: None

== GAME:RestartToTitle ==

Leave current map and load up the title screen.

== GAME:RestartRogue(RogueEssence.Data.RogueConfig) ==

Restarts a Roguelocke run based on the configuration

=== Arguments ===

* <code>config</code>: The configuration of the roguelocke run

== GAME:EnterZone(System.String,System.Int32,System.Int32,System.Int32) ==

Enters a zone and begins a new adventure.

=== Arguments ===

* <code>dungeonid</code>: The id of the dungeon to travel to.
* <code>structureid</code>: The segment within the dungeon to start in. -1 represents ground maps.
* <code>mapid</code>: The id of the ground map or dungeon map within the dungeon segment.
* <code>entry</code>: The entry point on the resulting map

== GAME:FadeOut ==

Fade out the screen. Waits to complete before continuing.

=== Arguments ===

* <code>white</code>: Fade to white if set to true. Fades to black otherwise.
* <code>duration</code>: The amount of time to fade in frames.

=== Example ===

<pre>

GAME:FadeOut(false, 60)

</pre>

== GAME:FadeIn ==

Fade into the screen. Waits to complete before continuing.

=== Arguments ===

* <code>duration</code>: The amount of time to fade in frames.

=== Example ===

<pre>

GAME:FadeIn(false, 60)

</pre>

== GAME:MoveCamera ==

Centers the camera on a position.

=== Arguments ===

* <code>x</code>: X coordinate of the camera center
* <code>y</code>: Y coordinate of the camera center
* <code>duration</code>: The amount of time it takes ot move to the destination
* <code>toPlayer</code>: Destination is in absolute coordinates if false, and relative to the player character if set to true.

=== Example ===

<pre>

GAME:MoveCamera(200, 240, 60, false)

</pre>

== GAME:MoveCameraToChara ==

Centers the camera on a character.

As we are simply moving the camera to a character, this will simply set ViewCenter and not ViewOffset.

=== Arguments ===

* <code>x</code>: X coordinate of the camera center, as an offset for the chara
* <code>y</code>: Y coordinate of the camera center, as an offset for the chara
* <code>duration</code>: The amount of time it takes ot move to the destination
* <code>chara</code>: The character to center on.

=== Example ===

<pre>

GAME:MoveCameraToChara(200, 240, 60, false)

</pre>

== GAME:GetCameraCenter ==

Gets the current center of the camera.

=== Returns ===

A Loc object representing the center of the camera.

== GAME:IsCameraOnChar ==

Determines whether the camera is centered relative to the player.

=== Returns ===

Returns true if the camera is relative to the player, false otherwise.

== GAME:HasSOSMail ==

TODO

== GAME:HasAOKMail ==

TODO

== GAME:GetTeamLeaderIndex ==

Returns the index of the currently player controlled entity in the party.

=== Returns ===

Index of the currently player controlled entity in the party.

== GAME:SetTeamLeaderIndex(System.Int32) ==

Sets the leader to the chosen index within the party.

=== Arguments ===

* <code>idx</code>: The index of the team member within the team.

== GAME:SetCanSwitch(System.Boolean) ==

Prevents or allows the switching of leaders for the save file.

=== Arguments ===

* <code>canSwitch</code>: Set to true to allow switching, set to false to prevent it.

== GAME:SetCanRecruit(System.Boolean) ==

Prevents or allows the joining of recruits for the save file.

=== Arguments ===

* <code>canRecruit</code>: Set to true to allow recruit joins, set to false to prevent it.

== GAME:GetPlayerPartyCount ==

Returns the player party count. Does not include guests.

=== Returns ===

The count of players

== GAME:GetPlayerPartyTable ==

Return the party as a LuaTable. Does not include guests.

=== Returns ===

A Lua Table of Characters

== GAME:GetPlayerPartyMember(System.Int32) ==

Gets the character at the specified index within the player's team.

=== Arguments ===

* <code>index</code>: The specified index

=== Returns ===

The team member retrieved.

== GAME:GetPlayerGuestCount ==

Gets the number of guests currently in the player's party.

=== Returns ===

The number of guests

== GAME:GetPlayerGuestTable ==

Return the guests as a LuaTable

=== Returns ===

A Lua Table of Characters

== GAME:GetPlayerGuestMember(System.Int32) ==

Gets the character at the specified index within the player's guests.

=== Arguments ===

* <code>index</code>: The specified index

=== Returns ===

The team member retrieved.

== GAME:GetPlayerAssemblyCount ==

Gets the number of characters currently in the player's assembly.

=== Returns ===

The number of characters

== GAME:GetPlayerAssemblyTable ==

Return the assembly as a LuaTable

=== Returns ===

A Lua Table of Characters

== GAME:GetPlayerAssemblyMember(System.Int32) ==

Gets the character at the specified index within the player's assembly.

=== Arguments ===

* <code>index</code>: The specified index

=== Returns ===

The assembly member retrieved.

== GAME:AddPlayerTeam(RogueEssence.Dungeon.Character) ==

Adds a character to the player's team.

=== Arguments ===

* <code>character</code>: The character to add.

== GAME:RemovePlayerTeam(System.Int32) ==

Removes the character from the team, placing its item back in the inventory.

=== Arguments ===

* <code>slot</code>: The slot of the player to remove.

== GAME:AddPlayerGuest(RogueEssence.Dungeon.Character) ==

Adds a character to the player's guests.

=== Arguments ===

* <code>character</code>: The character to add.

== GAME:RemovePlayerGuest(System.Int32) ==

Removes the character from the team's guests, placing its item back in the inventory.

=== Arguments ===

* <code>slot</code>: The slot of the player to remove.

== GAME:AddPlayerAssembly(RogueEssence.Dungeon.Character) ==

Adds a character to the player's assembly.

=== Arguments ===

* <code>character</code>: The character to add.

== GAME:RemovePlayerAssembly(System.Int32) ==

Removes the character from the assembly, placing its item back in the inventory.

=== Arguments ===

* <code>slot</code>: The slot of the player to remove.

== GAME:SetCharacterNickname(RogueEssence.Dungeon.Character,System.String) ==

Sets a character's nickname

=== Arguments ===

* <code>character</code>: The character to rename
* <code>nickname</code>: The new name

== GAME:GetCharacterNickname(RogueEssence.Dungeon.Character) ==

Gets the character nickname

=== Arguments ===

* <code>character</code>: The character to get the nickname from

=== Returns ===

The character's nickname

== GAME:SetTeamName(System.String) ==

Sets the name of the player's team

=== Arguments ===

* <code>teamname</code>: The new team name

== GAME:GetTeamName ==

Gets the name of the player's team

=== Returns ===

The team's name

== GAME:CanRelearn(RogueEssence.Dungeon.Character) ==

Checks if the character can relearn any skills.

=== Arguments ===

* <code>character</code>: The character to check

== GAME:CanForget(RogueEssence.Dungeon.Character) ==

Checks if the character can forget any skills.

=== Arguments ===

* <code>character</code>: The character to check

== GAME:CanLearn(RogueEssence.Dungeon.Character) ==

Checks if the character can learn any skills.

=== Arguments ===

* <code>character</code>: The character to check

== GAME:CheckLevelSkills ==

Checks the levels gained by a character and prompts to learn all skills along the levels.
Waits until all skills have been accepted or declined before continuing.

=== Arguments ===

* <code>chara</code>: The character to prompt for learning.
* <code>oldLevel</code>: The level that the character leveled up from.

=== Example ===

<pre>

GAME:CheckLevelSkills(player, 5)

</pre>

== GAME:TryLearnSkill ==

Attempts to give a new skill to the specified character, prompting to replace an old one if they are full.
Waits until all the skill has been accepted or declined before continuing.

=== Arguments ===

* <code>chara</code>: The character to learn the skill
* <code>skill</code>: The skill to learn

=== Example ===

<pre>

GAME:TryLearnSkill(player, "thunder")

</pre>

== GAME:LearnSkill(RogueEssence.Dungeon.Character,System.String) ==

Gives a new skill to a specified character.
Fails if the character's skills are full.

=== Arguments ===

* <code>chara</code>: The character to learn the skill
* <code>skill</code>: The skill to learn

== GAME:ForgetSkill(RogueEssence.Dungeon.Character,System.Int32) ==

Removed a skill from the specified character.

=== Arguments ===

* <code>chara</code>: The character to forget the skill
* <code>slot</code>: The slot of the skill to forget

== GAME:LockSkill(RogueEssence.Dungeon.Character,System.Int32) ==

Makes a skill impossible to forget or replace for the specified character.
Note that this only affects normal gameplay. Scripts can still freely get rid of the skill.

=== Arguments ===

* <code>chara</code>: The character to lock the skill
* <code>slot</code>: The slot of the skill to lock

== GAME:UnlockSkill(RogueEssence.Dungeon.Character,System.Int32) ==

Unlocks a previously locked skill for the specified character, making it possible to be forgotten or replaced during normal gameplay.

=== Arguments ===

* <code>chara</code>: The character to unlock the skill
* <code>slot</code>: The slot of the skill to unlock

== GAME:SetCharacterSkill(RogueEssence.Dungeon.Character,System.String,System.Int32,System.Boolean) ==

Gives a new skill to a specified character, replacing a specifically chosen slot.

=== Arguments ===

* <code>character</code>: The character to learn the skill
* <code>skillId</code>: The skill to learn
* <code>slot</code>: The slot to replace

== GAME:GetCharacterSkill(RogueEssence.Dungeon.Character,System.Int32) ==

Gets the skill from a specified character and specified slot.

=== Arguments ===

* <code>chara</code>: The character to get the skill from.
* <code>slot</code>: The slot to get the skill from.

=== Returns ===

The ID of the skill in the slot

== GAME:CanPromote(RogueEssence.Dungeon.Character) ==

Checks if the character can be promoted to a new class.

=== Arguments ===

* <code>character</code>: The character to check

=== Returns ===

True if the character can be promoted, false otherwise.

== GAME:GetAvailablePromotions(RogueEssence.Dungeon.Character,System.String) ==

Gets a list of possible classes that the character can prmote to.

=== Arguments ===

* <code>character</code>: The character to check
* <code>bypassItem</code>: An exception item that can bypass checks for promotion

=== Returns ===

A lua table of PromoteBranch objects

== GAME:PromoteCharacter(RogueEssence.Dungeon.Character,RogueEssence.Data.PromoteBranch,System.String) ==

Promotes a character ot a new class.

=== Arguments ===

* <code>character</code>: The character to promote
* <code>branch</code>: The PromoteBranch to promote with
* <code>bypassItem</code>: An exception item that can bypass checks for promotion

== GAME:FindPlayerItem(System.String,System.Boolean,System.Boolean) ==

Finds an item in the player's team and returns its slot within the inventory or among its team's equips.

=== Arguments ===

* <code>id</code>: The item ID to search for.
* <code>held</code>: Check equipped items.
* <code>inv</code>: Check inventory items.

=== Returns ===

The InvSlot of the item. Invalid if the item could not be found.

== GAME:GetPlayerEquippedCount ==

Get the number of items equipped by players. Does not include guests.

=== Returns ===

The number of items.

== GAME:GetPlayerBagCount ==

Get the number of items in the bag.

=== Returns ===

The number of items.

== GAME:GetPlayerBagLimit ==

Gets the maximum amount of item the player's team can carry.

=== Returns ===

The number of items.

== GAME:GetPlayerEquippedItem(System.Int32) ==

Gets the equipped item for the character in the specified slot.

=== Arguments ===

* <code>slot</code>: The team slot of the character to check

=== Returns ===

The character's equipped item

== GAME:GetGuestEquippedItem(System.Int32) ==

Gets the equipped item for the character in the specified guest slot.

=== Arguments ===

* <code>slot</code>: The guest slot of the character to check

=== Returns ===

The character's equipped item

== GAME:GivePlayerItem(RogueEssence.Dungeon.InvItem) ==

Gives an item and adds it to the player team's bag.

=== Arguments ===

* <code>item</code>: The item to give

== GAME:GivePlayerItem(System.String,System.Int32,System.Boolean,System.String) ==

Gives an item and adds it to the player team's bag.

=== Arguments ===

* <code>id</code>: The ID of the item
* <code>count</code>: The amount to give. Default 1
* <code>cursed</code>: Whether the item is cursed. Default false.
* <code>hiddenval</code>: The hidden value of the item. Default empty string.

== GAME:GetPlayerBagItem(System.Int32) ==

Gets the item found at the specified slot of the player's bag.

=== Arguments ===

* <code>slot</code>: The slot to check

=== Returns ===

The item found in the slot

== GAME:TakePlayerBagItem(System.Int32,System.Boolean) ==

Remove an item from player inventory

=== Arguments ===

* <code>slot</code>: The slot from which to remove the item
* <code>takeAll</code>: None

== GAME:TakePlayerEquippedItem(System.Int32,System.Boolean) ==

Remove the equipped item from a chosen member of the team

=== Arguments ===

* <code>slot</code>: The slot of the character on the team from which to remove the item
* <code>takeAll</code>: None

== GAME:TakeGuestEquippedItem(System.Int32,System.Boolean) ==

Remove the equipped item from a chosen guest of the team

=== Arguments ===

* <code>slot</code>: The slot of the character on the team's guest list from which to remove the item
* <code>takeAll</code>: None

== GAME:GetPlayerStorageCount ==

Get the amount of items in the player's storage

== GAME:GetPlayerStorageItemCount(System.String) ==

Get the amount of a specific item in the player's storage

=== Arguments ===

* <code>id</code>: ID of the item ot check

=== Returns ===

The amount of copies currently in storage

== GAME:GivePlayerStorageItem(RogueEssence.Dungeon.InvItem) ==

Gives an item and adds it to the player team's storage.

=== Arguments ===

* <code>item</code>: The item to give

== GAME:GivePlayerStorageItem(System.String,System.Int32,System.Boolean,System.String) ==

Gives an item and adds it to the player team's storage.

=== Arguments ===

* <code>id</code>: The ID of the item
* <code>count</code>: The amount to give. Default 1
* <code>cursed</code>: Whether the item is cursed. Default false.
* <code>hiddenval</code>: The hidden value of the item. Default empty string.

== GAME:TakePlayerStorageItem(System.String) ==

Takes an item from the storage

=== Arguments ===

* <code>id</code>: The ID of the item to take

== GAME:DepositAll ==

Takes all items in the player team's bag and equipped items, and deposits them in storage.

== GAME:GetPlayerMoney ==

Gets the amount of money the player currently has on hand.

=== Returns ===

The amount of money.

== GAME:AddToPlayerMoney(System.Int32) ==

Adds money to the player's wallet.

=== Arguments ===

* <code>toadd</code>: The amount of money to add.

== GAME:RemoveFromPlayerMoney(System.Int32) ==

Removes money from the player's wallet.

=== Arguments ===

* <code>toremove</code>: The amount of money to remove.

== GAME:GetPlayerMoneyBank ==

Gets the amount of money in the player's bank

=== Returns ===

The amount of money.

== GAME:AddToPlayerMoneyBank(System.Int32) ==

Adds money to the player's bank.

=== Arguments ===

* <code>toadd</code>: The amount of money to add.

== GAME:RemoveFromPlayerMoneyBank(System.Int32) ==

Removes money from the player's bank.

=== Arguments ===

* <code>toremove</code>: The amount of money to remove.

== GAME:IsKeyDown(System.Int32) ==

Checks if a player is making a certain physical keyboard input.

=== Arguments ===

* <code>keyid</code>: The ID of the input

=== Returns ===

True if the button is currently pressed. False otherwise.

== GAME:IsInputDown(System.Int32) ==

Checks if a player is making a certain game input.

=== Arguments ===

* <code>inputid</code>: None

=== Returns ===

True if the input is currently pressed. False otherwise.

== GAME:CutsceneMode(System.Boolean) ==

Sets the game in cutscene mode. This prevents characters from taking idle action and hides certain UI.

=== Arguments ===

* <code>bon</code>: If set to true, turns cutscene mode on. If set to false, turns it off.

== GAME:GetDailySeed ==

Gets the random seed for the current adventure.

=== Returns ===

The current adventure's seed.

== GAME:UnlockDungeon(System.String) ==

Unlocks a specified dungeon.

=== Arguments ===

* <code>dungeonid</code>: ID of the dungeon to unlock.

== GAME:DungeonUnlocked(System.String) ==

Checks if a dungeon is unlocked.

=== Arguments ===

* <code>dungeonid</code>: ID of the dungeon to check

=== Returns ===

True if unlocked, false otherwise.

== GAME:InRogueMode ==

Checks if the current game is in rogue mode.

=== Returns ===

True if in rogue mode, false otherwise.

== GAME:HasServerSet ==

TODO: WIP

== GAME:GetRescueAllowed ==

Checks to see if rescue is allowed.

=== Returns ===

True if rescues are allowed, false otherwise.

== GAME:SetRescueAllowed(System.Boolean) ==

Sets the value in the player's save file to determine if they can be rescued or not.
If rescue is possible on the Save File level, it can still be prevented by the map.

=== Arguments ===

* <code>allowed</code>: Set to true to allow the player to be rescued. False otherwise.

== GAME:QueueLeaderEvent(System.Object) ==

Prepares an event to execute on the next frame.

=== Arguments ===

* <code>obj</code>: None

== GAME:WaitFrames ==

Waits for a specified number of frames before continuing.

=== Arguments ===

* <code>frames</code>: The number of frames ot wait. Each frame is 1/60th of a second.

=== Example ===

<pre>

GAME:WaitFrames(60)

</pre>

== GAME:VectorToDirection(RogueElements.Loc) ==

Turns a vector (preferably a unit vector) into a cardinal or diagonal direction.

=== Arguments ===

* <code>v</code>: The vector.

=== Returns ===

The direction as one of 8 values.

== GAME:VectorToDirection(System.Double,System.Double) ==

Convenience function to get a vector's components from lua numbers(doubles)

=== Arguments ===

* <code>X</code>: The X value of the vector
* <code>Y</code>: The Y value of the vector

=== Returns ===

The direction the vector points to as one of 8 values.

== GAME:RandomDirection ==

Generates a random direction.

=== Returns ===

An 8-directional direction.

== GAME:SetupLuaFunctions(RogueEssence.Script.LuaEngine) ==

Setups any extra functionalities for this object written on the lua side.

== GROUND:Hide(System.String) ==

Hides an entity.

=== Arguments ===

* <code>entityname</code>: The name of the entity to hide.

== GROUND:Unhide(System.String) ==

Unhides an entity.

=== Arguments ===

* <code>entityname</code>: The name of the entity to unhide.

== GROUND:CreateObject(System.String,System.String,System.Int32,System.Int32,System.Int32,System.Int32) ==

TODO: WIP

=== Arguments ===

* <code>objtype</code>: None
* <code>instancename</code>: None
* <code>x</code>: None
* <code>y</code>: None
* <code>w</code>: None
* <code>h</code>: None

== GROUND:CreateCharacter(System.String,System.String,System.Int32,System.Int32,System.String,System.String) ==

TODO: WIP

=== Arguments ===

* <code>chartype</code>: None
* <code>instancename</code>: None
* <code>x</code>: None
* <code>y</code>: None
* <code>actionfun</code>: None
* <code>thinkfun</code>: None

== GROUND:RemoveObject(System.String) ==

Deletes an object from the ground map, identified by its instance name.

=== Arguments ===

* <code>instancename</code>: The instance name of the object.

=== Returns ===

Returns true if succeeded, false otherwise.

== GROUND:RemoveCharacter(System.String) ==

Deletes a character from the ground map, identified by its instance name.

=== Arguments ===

* <code>instancename</code>: The instance name of the object.

=== Returns ===

Returns true if succeeded, false otherwise.

== GROUND:CreateCharacterFromCharData(System.String,RogueEssence.Dungeon.Character,System.Int32,System.Int32,RogueElements.Dir8) ==

Creates a ground character, given a dungeon character.

=== Arguments ===

* <code>instancename</code>: The instance name to give the character
* <code>data</code>: Character data to create from
* <code>x</code>: X coordinate of the character
* <code>y</code>: Y coordinate of the character
* <code>direction</code>: Direction the character will face, defaults to Dir8.Down

== GROUND:RefreshPlayer ==

Reloads the controllable player's character data to be the current team's leader.

== GROUND:SetPlayer(RogueEssence.Dungeon.CharData) ==

Sets the controllable player to use new character data

=== Arguments ===

* <code>charData</code>: The new character data

== GROUND:SpawnerDoSpawn(System.String) ==

Make the specified spawner run its spawn method.

=== Arguments ===

* <code>spawnername</code>: None

=== Returns ===

The ground character spawned.

== GROUND:SpawnerSetSpawn(System.String,RogueEssence.Dungeon.CharData) ==

Sets the character to the specified spawner

=== Arguments ===

* <code>spawnername</code>: The spawner to set the character to, by name
* <code>spawnChar</code>: The character to spawn.

== GROUND:CharTurnToChar(RogueEssence.Ground.GroundChar,RogueEssence.Ground.GroundChar) ==

Makes a character turn to face another character instantly.

=== Arguments ===

* <code>turnchar</code>: The character that is turning.
* <code>turnto</code>: The character to turn to.

== GROUND:CharTurnToCharAnimated ==

Makes a character do an animated turn to face another character over the specified time.
Clockwise or counter-clockwise are chosen based on the closest direction.
Waits until the operation is completed.

=== Arguments ===

* <code>curch</code>: Character that is turning
* <code>turnto</code>: Character to turn to
* <code>framedur</code>: Time spent on each direction, in frames

=== Example ===

<pre>

CharTurnToCharAnimated(charFrom, charTo, 3)

</pre>

== GROUND:EntTurn(RogueEssence.Ground.GroundEntity,RogueElements.Dir8) ==

Makes a ground entity turn to face a direction.

=== Arguments ===

* <code>ent</code>: The ground entity. Can be a character or object.
* <code>direction</code>: The direction to face.

== GROUND:CharAnimateTurn ==

Makes a character do an animated turn to face a chosen direction over the specified time.
Must specify clockwise or counter-clockwise.
Waits until the operation is completed.

=== Arguments ===

* <code>ch</code>: The character to turn
* <code>direction</code>: The direction to turn to
* <code>framedur</code>: The time spent in each intermediate direction, in frames
* <code>ccw</code>: false if clockwise, true if counter-clockwise

=== Example ===

<pre>

CharTurnToCharAnimated(charFrom, Dir8.Left, 3, true)

</pre>

== GROUND:CharAnimateTurnTo ==

Makes a character do an animated turn to face a chosen direction over the specified time.
Waits until the operation is completed.

=== Arguments ===

* <code>ch</code>: The character to turn
* <code>direction</code>: The direction to turn to
* <code>framedur</code>: The time spent in each intermediate direction, in frames

=== Example ===

<pre>

CharTurnToCharAnimated(charFrom, Dir8.Left, 3)

</pre>

== GROUND:TeleportTo(RogueEssence.Ground.GroundEntity,System.Int32,System.Int32,RogueElements.Dir8,System.Int32) ==

Repositions the ground entity in a specified location.

=== Arguments ===

* <code>ent</code>: The ground entity to reposition
* <code>x</code>: The X coordinate of the destination
* <code>y</code>: The Y coordinate of the destination
* <code>direction</code>: The direction to point the entity. Defaults to Dir8.None, which leaves it untouched.
* <code>height</code>: None

== GROUND:MoveInDirection ==

Make ground character move in a direction.

=== Arguments ===

* <code>chara</code>: Character to move
* <code>direction</code>: Direction to move in
* <code>duration</code>: Duration of movement, in frames
* <code>run</code>: True if using a running animation, false otherwise
* <code>speed</code>: Speed in pixels per frame

=== Example ===

<pre>

GROUND:MoveInDirection(player, Dir8.Down, 24, false, 2)

</pre>

== GROUND:MoveToPosition ==

Make ground character move to a position.

=== Arguments ===

* <code>chara</code>: Character to move
* <code>x</code>: X coordinate of destination
* <code>y</code>: Y coordinate of destination
* <code>run</code>: True if using a running animation, false otherwise
* <code>speed</code>: Speed in pixels per frame

=== Example ===

<pre>

GROUND:MoveInDirection(player, 200, 240, false, 2)

</pre>

== GROUND:MoveToMarker ==

Make ground character move to a ground marker.

=== Arguments ===

* <code>chara</code>: Character to move
* <code>mark</code>: GroundMarker object ot move to
* <code>run</code>: True if using a running animation, false otherwise
* <code>speed</code>: Speed in pixels per frame

=== Example ===

<pre>

GROUND:MoveInDirection(player, marker, false, 2)

</pre>

== GROUND:MoveObjectToPosition ==

Make ground object move to a position.

=== Arguments ===

* <code>ent</code>: Ground Entity to move
* <code>x</code>: X coordinate of destination
* <code>y</code>: Y coordinate of destination
* <code>speed</code>: Speed in pixels per frame

=== Example ===

<pre>

GROUND:MoveInDirection(player, 200, 240, 2)

</pre>

== GROUND:AnimateInDirection ==

Make a ground character move in a direction with custom animation

=== Arguments ===

* <code>chara</code>: Character to move
* <code>anim</code>: Name of the animation
* <code>animDir</code>: Direction of animation
* <code>direction</code>: Direction to move in
* <code>duration</code>: Duration of movement, in frames
* <code>animSpeed</code>: Speed of animation, where 1.0 represents normal speed
* <code>speed</code>: Speed movement, in pixels per frame

=== Example ===

<pre>

GROUND:AnimateInDirection(player, "Hurt", Dir8.Down, 24, 0.5, 2)

</pre>

== GROUND:AnimateToPosition ==

Make a ground entity move to a position with custom animation

=== Arguments ===

* <code>ent</code>: Entity to move
* <code>anim</code>: Name of the animation
* <code>animDir</code>: Direction of animation
* <code>x</code>: X coordinate of the destination
* <code>y</code>: Y coordinate of the destination
* <code>animSpeed</code>: Speed of animation, where 1.0 represents normal speed
* <code>speed</code>: Speed movement, in pixels per frame
* <code>height</code>: Height of the destination

=== Example ===

<pre>

GROUND:AnimateToPosition(player, "Hurt", Dir8.Down, 200, 240, 0.5, 2)

</pre>

== GROUND:CharSetEmote(RogueEssence.Ground.GroundChar,System.String,System.Int32) ==

Make a character emote on the ground map.

=== Arguments ===

* <code>chara</code>: Character to emote
* <code>emoteid</code>: ID of the emote
* <code>cycles</code>: The number of times to play the emote.

== GROUND:CharSetDrawEffect(RogueEssence.Ground.GroundChar,RogueEssence.Dungeon.DrawEffect) ==

Sets the ground character's draw effect to become invisible, shaking, still, etc.

=== Arguments ===

* <code>chara</code>: Target ground character.
* <code>effect</code>: The draw effect.

== GROUND:CharEndDrawEffect(RogueEssence.Ground.GroundChar,RogueEssence.Dungeon.DrawEffect) ==

Sets the ground character's draw effect to become invisible, shaking, still, etc.

=== Arguments ===

* <code>chara</code>: Target ground character.
* <code>effect</code>: The draw effect.

== GROUND:CharGetAnimFallback(RogueEssence.Ground.GroundChar,System.String) ==

Gets the fallback animation for the character.

=== Arguments ===

* <code>chara</code>: None
* <code>anim</code>: The anim to get the fallback anim of.

=== Returns ===

The fallback animation, as a string. Blank if there is none. Will return anim if anim already exists.

== GROUND:CharGetAnim(RogueEssence.Ground.GroundChar) ==

Gets a character's current animation as a string.

=== Arguments ===

* <code>chara</code>: None

== GROUND:CharGetAnimPoint(RogueEssence.Ground.GroundChar,RogueEssence.Content.ActionPointType) ==

Gets the chosen action point of the character at this specific frame.

=== Arguments ===

* <code>chara</code>: None
* <code>actionPoint</code>: The ype of action point to retrieve the coordinates for.

=== Returns ===

The location of the action point in absolute coordinates on the map.

== GROUND:CharSetAnim(RogueEssence.Ground.GroundChar,System.String,System.Boolean) ==

Set a character's animation.

=== Arguments ===

* <code>chara</code>: Character to animate
* <code>anim</code>: Name of the animation
* <code>loop</code>: Whether to loop the animation

== GROUND:CharEndAnim(RogueEssence.Ground.GroundChar) ==

Stops a character's current animation, reverting them to default idle.

=== Arguments ===

* <code>chara</code>: Character to stop animating

== GROUND:CharWaitAnim ==

Makes the character perform an animation and waits until it's over.

=== Arguments ===

* <code>ent</code>: Character to animate
* <code>anim</code>: Animation to play

=== Example ===

<pre>

GROUND:CharWaitAnim(player, "Hurt")

</pre>

== GROUND:CharSetAction(RogueEssence.Ground.GroundChar,RogueEssence.Ground.GroundAction) ==

Set a character's action.

=== Arguments ===

* <code>chara</code>: Character to perfom the action
* <code>action</code>: The action to perform

== GROUND:CharWaitAction ==

Makes the character perform an action and waits until it's over.

=== Arguments ===

* <code>ent</code>: Character to animate
* <code>action</code>: Action to perform

=== Example ===

<pre>

GROUND:CharWaitAction(player, action)

</pre>

== GROUND:ObjectSetAnim(RogueEssence.Ground.GroundObject,System.Int32,System.Int32,System.Int32,RogueElements.Dir8,System.Int32) ==

Sets a ground object's animation. After it finishes, it will return to the default animation.

=== Arguments ===

* <code>obj</code>: The object to animate
* <code>frameTime</code>: The duration of each frame of animation
* <code>startFrame</code>: The start frame of animation
* <code>endFrame</code>: The end frame of animation
* <code>dir</code>: The direction of the animation
* <code>cycles</code>: The number of times to repeat the animation

== GROUND:ObjectSetDefaultAnim(RogueEssence.Ground.GroundObject,System.String,System.Int32,System.Int32,System.Int32,RogueElements.Dir8) ==

Sets a ground object's default animation.

=== Arguments ===

* <code>obj</code>: The object to animate
* <code>animName</code>: The name of the animation
* <code>frameTime</code>: The duration of each frame of animation
* <code>startFrame</code>: The start frame of animation
* <code>endFrame</code>: The end frame of animation
* <code>dir</code>: The direction of the animation

== GROUND:ObjectWaitAnimFrame ==

Waits for the object to reach a specific frame before continuing.

=== Arguments ===

* <code>obj</code>: The object ot wait on
* <code>frame</code>: The frame of animation to wait on.

=== Example ===

<pre>

GROUND:WaitObjectAnim(fountain, 3)

</pre>

== GROUND:PlayVFX(RogueEssence.Content.FiniteEmitter,System.Int32,System.Int32,RogueElements.Dir8) ==

Plays a VFX using a finite emitter that generates BaseAnims.

=== Arguments ===

* <code>emitter</code>: The VFX emitter
* <code>x</code>: X position
* <code>y</code>: Y Position
* <code>dir</code>: Direction to orient the VFX, defaults to Down

== GROUND:PlayVFX(RogueEssence.Content.FiniteEmitter,System.Int32,System.Int32,RogueElements.Dir8,System.Int32,System.Int32) ==

Plays a VFX that has a start position and an end position. It uses a finite emitter that generates BaseAnims.

=== Arguments ===

* <code>emitter</code>: The VFX emitter
* <code>x</code>: Start X position
* <code>y</code>: Start Y Position
* <code>dir</code>: Direction to orient the VFX, defaults to Down.
* <code>xTo</code>: End X position
* <code>yTo</code>: End Y position

== GROUND:PlayVFXAnim(RogueEssence.Content.BaseAnim,RogueEssence.Content.DrawLayer) ==

Plays a VFX using just a BaseAnim

=== Arguments ===

* <code>anim</code>: The animation to play
* <code>layer</code>: The layer to put it on

== GROUND:MoveScreen(RogueEssence.Content.ScreenMover) ==

Plays a screen-moving effect.

=== Arguments ===

* <code>mover</code>: The screen mover.

== GROUND:HandoutEXP ==

Gives a character a set amount of EXP.
Also handles leveling up and learning new moves.

=== Arguments ===

* <code>character</code>: The characters to level up.
* <code>experience</code>: The amount of EXP to gain.

== GROUND:LevelUpChar ==

Levels up a character a certain amount of times all at once.
Also handles learning new moves.

=== Arguments ===

* <code>character</code>: The characters to level up.
* <code>numLevelUps</code>: The number of level ups.

== GROUND:AddMapStatus(System.String) ==

Adds a mapstatus to the ground map. Map statuses only have an aesthetic effect in ground maps.

=== Arguments ===

* <code>statusIdx</code>: The ID of the Map Status

== GROUND:RemoveMapStatus(System.String) ==

Removes a map status from the ground map.

=== Arguments ===

* <code>statusIdx</code>: The ID of the Map Status to remove.

== SOUND:PlaySE(System.String) ==

Plays a sound effect

=== Arguments ===

* <code>name</code>: Sound file name, relative to the Content/SE folder

== SOUND:PlayBattleSE(System.String) ==

Plays a sound effect specifically from the Battle/ subdirectory

=== Arguments ===

* <code>name</code>: Sound file name, relative to the Content/SE/Battle folder

== SOUND:WaitSE ==

Plays a sound effect, and waits for it to complete before continuing.

=== Example ===

<pre>

SOUND:WaitSE("Battle/Hit")

</pre>

== SOUND:LoopSE(System.String) ==

Plays a continuous sound effect

=== Arguments ===

* <code>name</code>: Sound file name, relative to the Content/SE folder

== SOUND:LoopBattleSE(System.String) ==

Plays a continuous sound effect

=== Arguments ===

* <code>name</code>: Sound file name, relative to the Content/SE/Battle folder

== SOUND:StopSE(System.String) ==

Stops a continuous sound effect

=== Arguments ===

* <code>name</code>: Sound file name, relative to the Content/SE folder

== SOUND:StopBattleSE(System.String) ==

Stops a continuous sound effect

=== Arguments ===

* <code>name</code>: Sound file name, relative to the Content/SE/Battle folder

== SOUND:FadeInSE(System.String,System.Int32) ==

Plays a continuous sound effect, fading in over a specified amount of time

=== Arguments ===

* <code>name</code>: Sound file name, relative to the Content/SE folder
* <code>fadeTime</code>: Time in frames for the sound to fade in

== SOUND:FadeInBattleSE(System.String,System.Int32) ==

Plays a continuous sound effect, fading in over a specified amount of time

=== Arguments ===

* <code>name</code>: Sound file name, relative to the Content/SE/Battle folder
* <code>fadeTime</code>: Time in frames for the sound to fade in

== SOUND:FadeOutSE(System.String,System.Int32) ==

Stops a continuous sound effect, fading out over a specified amount of time

=== Arguments ===

* <code>name</code>: Sound file name, relative to the Content/SE folder
* <code>fadeTime</code>: Time in frames for the sound to fade out

== SOUND:FadeOutBattleSE(System.String,System.Int32) ==

Stops a continuous sound effect, fading out over a specified amount of time

=== Arguments ===

* <code>name</code>: Sound file name, relative to the Content/SE/Battle folder
* <code>fadeTime</code>: Time in frames for the sound to fade out

== SOUND:PlayFanfare(System.String) ==

Plays a sound effect that temporarily mutes the music for its duration

=== Arguments ===

* <code>name</code>: Sound file name, relative to the Content/SE folder

== SOUND:WaitFanfare ==

Plays a sound effect that temporarily mutes the music for its duration.
This function waits for the sound to complete before continuing.

=== Example ===

<pre>

SOUND:WaitFanfare("Battle/LevelUp")

</pre>

== SOUND:PlayBGM(System.String,System.Boolean,System.Int32) ==

Plays a song, replacing the current one.

=== Arguments ===

* <code>name</code>: The file name of the song, relative to the Content/Music folder.
* <code>fade</code>: Whether to fade the old song out, or start a new one.
* <code>fadeTime</code>: The amount of time, in frames, to fade out the old song.

== SOUND:StopBGM ==

Stops playing the current song.

== SOUND:FadeOutBGM(System.Int32) ==

Fades out the current song.

=== Arguments ===

* <code>fadeTime</code>: The amount of time, in frames, to fade out the song.

== SOUND:SetBGMVolume(System.Single) ==

Sets the current volume of the song.

=== Arguments ===

* <code>val</code>: A float value between 0 and 1

== SOUND:GetCurrentSong ==

Gets the currently playing song. If the current song is fading out, gets the next song to be played.

=== Returns ===

The filename of the song, relative to the Content/Music folder

== STRINGS:LocaleCode ==

Gets the current language setting of the game.

=== Returns ===

The current language, represented by a locale code.

== STRINGS:Format(System.String,System.Object[]) ==

Formats a string. Will unescape escaped characters and process grammar tags.

=== Arguments ===

* <code>fmt</code>: String to format.
* <code>para</code>: Arguments

=== Returns ===

The formatted string.

== STRINGS:FormatKey(System.String,System.Object[]) ==

Formats a string given a string key. Will unescape escaped characters.

=== Arguments ===

* <code>fmt</code>: The string key to format
* <code>para</code>: string arguments

== STRINGS:LocalKeyString(System.Int32) ==

Gets the string representing a button or key.

=== Arguments ===

* <code>index</code>: The input type of the input.

=== Returns ===

The string representing the button o key the input maps to.

== STRINGS:CreateList(NLua.LuaTable) ==

Builds a single string of comma separated elements.

=== Arguments ===

* <code>listStrings</code>: LuaTable of strings containing the elements to build the list from.

=== Returns ===

The combined string containing all elements.

== TASK:StartEntityTask(RogueEssence.Ground.GroundEntity,NLua.LuaFunction) ==

Helper function to make an entity run the specified task.
Will not replace a running task!
Tasks are run interlocked with the script processing and game processing, and characters cannot run multiple tasks at the same time.

=== Arguments ===

* <code>ent</code>: Entity which will run the task.
* <code>fn</code>: Task coroutine.

== TASK:StopEntityTask(RogueEssence.Ground.GroundEntity) ==

Helper function to force stop an entity's current task.

=== Arguments ===

* <code>ent</code>: Entity running the task to stop.

== TASK:WaitStartEntityTask ==

Makes an entity run a specified task, and waits for it to complete.

=== Arguments ===

* <code>ent</code>: Entity which will run the task.
* <code>fn</code>: Task coroutine.

=== Example ===

<pre>

TODO

</pre>

== TASK:WaitEntityTask ==

Waits for the specified entity to finish its task.

=== Arguments ===

* <code>ent</code>: Entity which task we'll wait on.

=== Example ===

<pre>

TASK:WaitEntityTask(player)

</pre>

== TASK:WaitTask ==

Runs a task and waits for it to complete.
Most methods that do not expose themselves to script need to be wrapped with this.

=== Arguments ===

* <code>obj</code>: The task to wait on.

=== Example ===

<pre>

TASK:WaitTask(_DUNGEON:DropMoney(100, RogueElements.Loc(10, 10), RogueElements.Loc(10, 10)))

</pre>

== TASK:StartScriptLocalCoroutine(NLua.LuaFunction,System.Object[]) ==

A wrapper around the StartCoroutine method of the GameManager, so lua coroutines can be executed locally to the script context.
AKA, it will block the script execution while its executed.

=== Arguments ===

* <code>fn</code>: None
* <code>args</code>: None

== TASK:BranchCoroutine(System.Object) ==

Starts a new coroutine to run parallel to the current execution.
Useful for performing multiple actions at once.

=== Arguments ===

* <code>obj</code>: The task to run in parallel

=== Example ===

<pre>

local coro1 = TASK:BranchCoroutine(GAME:_FadeIn(60))

</pre>

== TASK:JoinCoroutines ==

Waits for all specified coroutines to finish before continuing execution.
Often used for coroutines created using TASK:BranchCoroutine()

=== Arguments ===

* <code>coroTable</code>: A table of coroutines to wait on.

=== Example ===

<pre>

TASK:JoinCoroutines({coro1})

</pre>

== UI:WaitInput ==

Waits for the player to press a button before continuing.

== UI:WaitShowDialogue ==

Displays a dialogue box with text, waiting until the player completes it.
Takes a string as an argument.

=== Arguments ===

* <code>text</code>: The text to display.
* <code>callbacks</code>: The Lua table of callbacks for the textbox to call.

=== Example ===

<pre>

UI:WaitShowDialogue("Hello World!")

</pre>

== UI:WaitShowTimedDialogue ==

Displays a dialogue box with text, waiting until the specified time has expired.

=== Arguments ===

* <code>text</code>: The text to display.
* <code>waitTime</code>: The time for the textbox to remain on screen. Pass -1 to wait for layer input.
* <code>callbacks</code>: The Lua table of callbacks for the textbox to call.

=== Example ===

<pre>

UI:WaitShowTimedDialogue("Hello World!", 120)

</pre>

== UI:TextDialogue(System.String,System.Int32,NLua.LuaTable) ==

Sets the current dialogue text to be shown. Requires WaitDialog to actually display.

=== Arguments ===

* <code>text</code>: The text to display.
* <code>waitTime</code>: The time for the textbox to remain on screen. Pass -1 to wait for layer input.
* <code>callbacks</code>: The Lua table of callbacks for the textbox to call.

== UI:WaitShowVoiceOver ==

Displays a voice over, waiting until the player completes it.

=== Arguments ===

* <code>text</code>: The text to display.
* <code>expireTime</code>: The time for the textbox to remain on screen. Pass -1 to wait for layer input.
* <code>x</code>: The X position of the box
* <code>y</code>: The Y position of the box
* <code>width</code>: Width of the box
* <code>height</code>: Height of the box
* <code>callbacks</code>: The Lua table of callbacks for the textbox to call.

=== Example ===

<pre>

UI:WaitShowVoiceOver("Hello World!", 120)

</pre>

== UI:TextVoiceOver(System.String,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,NLua.LuaTable) ==

Sets the current voice-over text to be shown. Requires WaitDialog to actually display.

=== Arguments ===

* <code>text</code>: The text to display.
* <code>expireTime</code>: The time for the textbox to remain on screen. Pass -1 to wait for layer input.
* <code>x</code>: The X position of the box
* <code>y</code>: The Y position of the box
* <code>width</code>: Width of the box
* <code>height</code>: Height of the box
* <code>callbacks</code>: The Lua table of callbacks for the textbox to call.

== UI:TextPopUp(System.String,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Boolean,System.Boolean) ==

Makes text pop up in the bottom-left corner by default. Displays concurrently with any other process.

=== Arguments ===

* <code>text</code>: The text to display.
* <code>expireTime</code>: The time for the textbox to remain on screen.
* <code>x</code>: The X position of the box
* <code>y</code>: The Y position of the box
* <code>width</code>: Width of the box
* <code>height</code>: Height of the box
* <code>centerH</code>: Horizontal centering
* <code>centerV</code>: Vertical centering

== UI:WaitShowTitle ==

Fades in a title text, waiting until the fade-in is complete.

=== Arguments ===

* <code>text</code>: The text to display.
* <code>time</code>: The time for the text to fade in.

=== Example ===

<pre>

UI:WaitShowTitle("Hello World!", 60)

</pre>

== UI:TextShowTitle(System.String,System.Int32) ==

Shows text in the format of a title drop. Requires WaitDialog to actually display.

=== Arguments ===

* <code>text</code>: The text to display.
* <code>time</code>: The time for the text to fade in.

== UI:WaitHideTitle ==

Fades out the currently displayed title, waiting until the fade-out is complete.

=== Arguments ===

* <code>time</code>: The time for the text to fade in.

=== Example ===

<pre>

UI:WaitHideTitle(60)

</pre>

== UI:TextFadeTitle(System.Int32) ==

Fades out the text set in a title drop. Requires WaitDialog to actually fade.

=== Arguments ===

* <code>time</code>: The time for the text to fade in.

== UI:WaitShowBG ==

Fades in a chosen background image, with a chosen framerate, at a certain fade time, waiting until the fade-in is complete.

=== Arguments ===

* <code>bg</code>: The background to show, from the list of BG textures.
* <code>frameTime</code>: Framerate of the image animation.
* <code>fadeInTime</code>: Time taken to fade in the image.

=== Example ===

<pre>

UI:WaitShowBG("TestBG", 3, 60)

</pre>

== UI:ShowBG(System.String,System.Int32,System.Int32) ==

Sets an image to display. Requires WaitDialog to actually display.

=== Arguments ===

* <code>bg</code>: The background to show, from the list of BG textures.
* <code>frameTime</code>: Framerate of the image animation.
* <code>fadeInTime</code>: Time taken to fade in the image.

== UI:WaitHideBG ==

Fades out the current background image, waiting until the fade-out is complete.

=== Arguments ===

* <code>time</code>: Time taken to fade out the image.

=== Example ===

<pre>

UI:WaitHideBG(60)

</pre>

== UI:FadeBG(System.Int32) ==

Prepares a fade-out of the current image. Requires WaitDialog to actually display.

=== Arguments ===

* <code>time</code>: Time taken to fade out the image.

== UI:ResetSpeaker(System.Boolean) ==

Clears the current speaker, so none is displayed the next time TextDialogue is called.
This also resets any custom dialogue box positions, portrait positions, and choice positions.

=== Arguments ===

* <code>keysound</code>: If turned on, the text from the dialogue boxes make sounds. Default is on.

== UI:SetSpeaker(System.String,System.Boolean,System.String,System.Int32,System.String,RogueEssence.Data.Gender) ==

Sets the speaker to be displayed during the following calls to the TextDialogue functions. It resets speaker emotion.

=== Arguments ===

* <code>name</code>: Speaker name.
* <code>keysound</code>: Plays sounds when text appears.
* <code>specie</code>: Species of the speaker
* <code>form</code>: Form of the speaker
* <code>skin</code>: Skin of the speaker
* <code>gender</code>: Gender of the speaker

== UI:SetSpeaker(RogueEssence.Ground.GroundChar,System.Boolean) ==

Sets the speaker to be displayed during the following calls to the TextDialogue functions. It resets speaker emotion.

=== Arguments ===

* <code>chara</code>: Character to set as speaker. This is a character in a ground map.
* <code>keysound</code>: Plays sounds when text appears.

== UI:SetSpeaker(RogueEssence.Dungeon.Character,System.Boolean) ==

Sets the speaker to be displayed during the following calls to the TextDialogue functions. It resets speaker emotion.

=== Arguments ===

* <code>chara</code>: Character to set as speaker. This is a character in a dungeon map.
* <code>keysound</code>: Plays sounds when text appears.

== UI:SetSpeakerReverse(System.Boolean) ==

Reverses the speaker orientation to face left instead of right. This depends on the boolean passed in.

=== Arguments ===

* <code>reverse</code>: Faces right if false, left if true.

== UI:SetChoiceLoc(System.Int32,System.Int32) ==

Sets the position of the choices for a question dialog.

=== Arguments ===

* <code>x</code>: The X position
* <code>y</code>: The Y position

== UI:ResetChoiceLoc ==

Sets the position of the choices for a question dialog back to default.

== UI:SetBounds(System.Int32,System.Int32,System.Int32,System.Int32) ==

Sets the position and size of the dialogue box.

=== Arguments ===

* <code>x</code>: The X position of the box
* <code>y</code>: The Y position of the box
* <code>width</code>: Width of the box
* <code>height</code>: Height of the box

== UI:SetSe(System.String,System.Int32) ==

Sets the speaker sound effect and speak frames played in the TextDialogue functions.

=== Arguments ===

* <code>newSe</code>: The sound effect of the box
* <code>speakTime</code>: The amount of frames to wait between each sound effect

=== Example ===

<pre>

UI:SetSe("Battle/_UNK_DUN_Water_Drop", 3)

</pre>

== UI:SetSe(System.String) ==

Sets the speaker sound effect played in the TextDialogue functions.

=== Arguments ===

* <code>newSe</code>: The sound effect of the box

=== Example ===

<pre>

UI:SetSe("Menu/Unknown-3")

</pre>

== UI:SetSpeakTime(System.Int32) ==

Sets the speak frames played in the TextDialogue functions.

=== Arguments ===

* <code>speakTime</code>: The amount of frames to wait between each sound effect

=== Example ===

<pre>

UI:SetSpeakTime(10)

</pre>

== UI:ResetSe ==

Resets to the default speaker sound effect and speaker frames.

== UI:ResetBounds ==

Resets the position and size of the dialogue box.

== UI:SetSpeakerLoc(System.Int32,System.Int32) ==

Sets the position of the speaker in a dialogue box.

=== Arguments ===

* <code>x</code>: The X position
* <code>y</code>: The Y position

== UI:ResetSpeakerLoc ==

Resets the position of the speaker in a dialogue box.

== UI:SetSpeakerEmotion(System.String,System.Boolean) ==

Sets the emotion of the speaker in the dialogue box.

=== Arguments ===

* <code>emo</code>: Emotion to display
* <code>reverse</code>: Faces right if false, left if true.

== UI:SetCenter(System.Boolean,System.Boolean) ==

Sets the centering of the text in the textbox.

=== Arguments ===

* <code>centerH</code>: Horizontal centering
* <code>centerV</code>: Vertical centering

== UI:SetAutoFinish(System.Boolean) ==

Makes the text automatically finish when it shows up.

=== Arguments ===

* <code>autoFinish</code>: Auto-finishes text if true.

== UI:WaitDialog ==

Displays the currently set dialogue box and waits for the player to complete it.

=== Example ===

<pre>

UI:WaitDialog()

</pre>

== UI:_DummyWait ==

Instantly break. Used as default/invalid value when returning a yieldable value.

== UI:ChoiceMenuYesNo(System.String,System.Boolean,NLua.LuaTable) ==

Ask a question answered by yes or no via character dialogue to the player.
UI:WaitForChoice() must be called afterwards for the menu to be actually displayed,
and for execution to suspend until the choice is returned.
Then to recover the integer value indicating the result of the menu, UI:ChoiceResult() must be called.

The Yes/No menu returns 1 for yes, and 0 for no.

=== Arguments ===

* <code>message</code>: Question to be asked to the user.
* <code>bdefaultstono</code>: Whether the cursor starts on no by default
* <code>callbacks</code>: The Lua table of callbacks for the textbox to call.

== UI:NameMenu(System.String,System.String,System.Int32,System.String) ==

Displays the name input box.

UI:WaitForChoice() must be called afterwards for the menu to be actually displayed,
and for execution to suspend until the choice is returned.
Then to recover the string value indicating the result of the menu, UI:ChoiceResult() must be called.

=== Arguments ===

* <code>title</code>: The text to show above the input line.
* <code>desc</code>: The text to show below the input line.
* <code>maxLength</code>: The length of the text in pixels.
* <code>defaultName</code>: Name to start the textbox with.

== UI:AssemblyMenu ==

Displays a menu for replacing party members with the assembly.

UI:WaitForChoice() must be called afterwards for the menu to be actually displayed,
and for execution to suspend until the choice is returned.
Then to recover the boolean value indicating whether the team composition was changed or not, UI:ChoiceResult() must be called.

== UI:ShopMenu(NLua.LuaTable) ==

Displays the Shop menu.

UI:WaitForChoice() must be called afterwards for the menu to be actually displayed,
and for execution to suspend until the choice is returned.
Then to recover the table indicating the indices of items chosen, UI:ChoiceResult() must be called.

=== Arguments ===

* <code>goods</code>: A table of items to be sold. The format is { Item=InvItem, Price=int } for each item.

== UI:SellMenu ==

Displays the Sell menu.

UI:WaitForChoice() must be called afterwards for the menu to be actually displayed,
and for execution to suspend until the choice is returned.
Then to recover the table indicating the indices of items to sell, UI:ChoiceResult() must be called.

== UI:StorageMenu ==

Displays the Storage menu for which to exchange items in the inventory with.

UI:WaitForChoice() must be called afterwards for the menu to be actually displayed,
and for execution to suspend until the menu is exited.

== UI:WithdrawMenu ==

Displays the Storage menu for which to withdraw from.

UI:WaitForChoice() must be called afterwards for the menu to be actually displayed,
and for execution to suspend until the menu is exited.

== UI:BankMenu ==

Displays the Bank menu.

UI:WaitForChoice() must be called afterwards for the menu to be actually displayed,
and for execution to suspend until the menu is exited.

== UI:SpoilsMenu(NLua.LuaTable) ==

Displays the Spoils menu.

UI:WaitForChoice() must be called afterwards for the menu to be actually displayed,
and for execution to suspend until the menu is exited.

=== Arguments ===

* <code>appraisalMap</code>: A table of mappings from containers to items, in the format of { Box=InvItem , Item=InvItem }

== UI:AppraiseMenu ==

Displays the Appraisal menu.

UI:WaitForChoice() must be called afterwards for the menu to be actually displayed,
and for execution to suspend until the choice is returned.
Then to recover the table indicating the indices of items chosen, UI:ChoiceResult() must be called.

== UI:TutorTeamMenu(NLua.LuaFunction) ==

Displays the Tutor Team menu.

UI:WaitForChoice() must be called afterwards for the menu to be actually displayed,
and for execution to suspend until the choice is returned.
Then to recover the integer representing the chosen team member, UI:ChoiceResult() must be called.

== UI:RelearnMenu(RogueEssence.Dungeon.Character) ==

Displays the Relearn menu for a character.

UI:WaitForChoice() must be called afterwards for the menu to be actually displayed,
and for execution to suspend until the choice is returned.
Then to recover the integer representing the chosen skill, UI:ChoiceResult() must be called.

=== Arguments ===

* <code>chara</code>: The character to relearn skills

== UI:LearnMenu(RogueEssence.Dungeon.Character,System.String) ==

Displays the Learn menu for a character to replace an existing skill with a new one.

UI:WaitForChoice() must be called afterwards for the menu to be actually displayed,
and for execution to suspend until the choice is returned.
Then to recover the integer representing the chosen skill, UI:ChoiceResult() must be called.

=== Arguments ===

* <code>chara</code>: The character to relearn skills
* <code>skillNum</code>: The new skill

== UI:ForgetMenu(RogueEssence.Dungeon.Character) ==

Displays the Forget menu for a character to forget a skill.

UI:WaitForChoice() must be called afterwards for the menu to be actually displayed,
and for execution to suspend until the choice is returned.
Then to recover the integer representing the chosen skill, UI:ChoiceResult() must be called.

=== Arguments ===

* <code>chara</code>: The character to relearn skills

== UI:ShowPromoteMenu ==

Displays the Promote menu to choose a team member to promote.

UI:WaitForChoice() must be called afterwards for the menu to be actually displayed,
and for execution to suspend until the choice is returned.
Then to recover the integer representing the chosen team slot, UI:ChoiceResult() must be called.

== UI:CanSwapMenu(NLua.LuaTable) ==

TODO

== UI:SwapMenu(NLua.LuaTable,NLua.LuaTable) ==

TODO

== UI:TributeMenu(System.Int32) ==

TODO

== UI:ShowMusicMenu(NLua.LuaTable) ==

Displays the Music menu to browse music for the game.

UI:WaitForChoice() must be called afterwards for the menu to be actually displayed,
and for execution to suspend until the choice is returned.
Then to recover the string representing the chosen song, UI:ChoiceResult() must be called.

=== Arguments ===

* <code>spoilerUnlocks</code>: A lua table of strings representing progression flags that have been completed.
Any ogg file that uses this tag as a spoiler tag will display in the menu only if the flag has been passed.

== UI:DungeonChoice(System.String,RogueEssence.Dungeon.ZoneLoc) ==

Ask to enter a destintion via character dialogue to the player.
UI:WaitForChoice() must be called afterwards for the menu to be actually displayed,
and for execution to suspend until the choice is returned.
Then to recover the integer value indicating the result of the menu, UI:ChoiceResult() must be called.

The Yes/No menu returns 1 for yes, and 0 for no.

=== Arguments ===

* <code>name</code>: Name of the destination
* <code>dest</code>: The ZoneLoc location of the destination.

== UI:DestinationMenu(NLua.LuaTable,System.Object) ==

Marks the start of a choice menu for choosing destinations, showing a preview of restrictions and requirements for dungeons.
UI:WaitForChoice() must be called afterwards for the menu to be actually displayed,
and for execution to suspend until the choice is returned.
Then to recover the ZoneLoc indicating the chosen destination, UI:ChoiceResult() must be called.

=== Arguments ===

* <code>destinations</code>: A lua table representing the list of destinations with each element in the format of { Name=string, Dest=ZoneLoc }

== UI:ServersMenu ==

TODO

== UI:ContactsMenu ==

TODO

== UI:SOSMenu ==

TODO

== UI:AOKMenu ==

TODO

== UI:PeersMenu ==

TODO

== UI:ShowConnectMenu ==

TODO

== UI:CurrentActivityMenu ==

TODO

== UI:ChooseMonsterMenu(System.String,NLua.LuaTable,System.Boolean,System.Boolean,System.Int32) ==

Marks the start of a choice menu for choosing monsters, showing a preview of their appearances via portrait.
UI:WaitForChoice() must be called afterwards for the menu to be actually displayed,
and for execution to suspend until the choice is returned.
Then to recover the string indicating the chosen species, UI:ChoiceResult() must be called.

=== Arguments ===

* <code>title</code>: The title of the menu
* <code>choices</code>: A lua table of choices with each element being a MonsterID.
* <code>canMenu</code>: If set to true, the Menu Button exits the menu if pressed.
* <code>canCancel</code>: If set to true, the Cancel Button exits the menu if pressed.
* <code>slotsPerPage</code>: Slots to display per page

== UI:SetCustomMenu(RogueEssence.Menu.InteractableMenu) ==

Displays a custom menu of the caller's choice.

UI:WaitForChoice() must be called afterwards for the menu to be actually displayed,
and for execution to suspend until the menu is exited.

== UI:BeginChoiceMenu(System.String,NLua.LuaTable,System.Object,System.Object,NLua.LuaTable) ==

Marks the start of a multi-choice menu.
UI:WaitForChoice() must be called afterwards for the menu to be actually displayed,
and for execution to suspend until the choice is returned.
Then to recover the integer value indicating the result of the menu, UI:ChoiceResult() must be called.

=== Arguments ===

* <code>message</code>: The question to ask the user.
* <code>choicesPairs</code>: A table of choices. Each choice can be either a string, or { string, bool } representing the text and enabled status.
* <code>defaultChoice</code>: The cursor starts on this choice.
* <code>cancelChoice</code>: This choice is chosen if the player presses the cancel button.
* <code>callbacks</code>: The Lua table of callbacks for the textbox to call.

== UI:BeginMultiPageMenu(System.Int32,System.Int32,System.Int32,System.String,NLua.LuaTable,System.Int32,System.Object,System.Object) ==

Marks the start of a multi-paged choice menu.
UI:WaitForChoice() must be called afterwards for the menu to be actually displayed,
and for execution to suspend until the choice is returned.
Then to recover the integer value indicating the result of the menu, UI:ChoiceResult() must be called.

=== Arguments ===

* <code>x</code>: X position of the menu
* <code>y</code>: Y position of the menu
* <code>width</code>: Width of the menu
* <code>title</code>: Height of the menu
* <code>choicesPairs</code>: A table of choices. Each choice can be either a string, or { string, bool } representing the text and enabled status.
* <code>linesPerPage</code>: Number of choices per page
* <code>defaultChoice</code>: The cursor starts on this choice.
* <code>cancelChoice</code>: This choice is chosen if the player presses the cancel button.

== UI:ChoiceResult ==

Get the result of the last choice menu

=== Returns ===

The result of the choice

== UI:GetChoiceAction(System.Object) ==

It's complicated.

=== Arguments ===

* <code>obj</code>: None

== UI:WaitForChoice ==

Displays the currently set choice menu and waits for the player's selection to complete.

=== Example ===

<pre>

UI:WaitForChoice()

</pre>

== UI:__WaitForChoice ==

Wait for choice and then CLEAN UP m_curchoice

[[Category:Scripting]]
[[Category:Quick Reference]]

__NOTOC__

Class:DataManager

2024-11-13T02:34:20Z

IDK: copy paste from most recent doc

{{stub}}

This page shows all properties of DataManager that can be manipulated from Lua.

It is referenced in lua with the shorthand <code>_DATA</code>

== _DATA.Start ==

The parameters governing the start of the game.
Such as starting character, map, level, etc.

== _DATA.DefaultMonster ==

The monster ID consiered default for purposes of initialization

== _DATA.DefaultSkill ==

The skill ID considered default for purposes of initialization and comparing to "nothing"

== _DATA.DefaultIntrinsic ==

The skill ID considered default for purposes of initialization and comparing to "nothing"

== _DATA.DefaultMapStatus ==

The skill ID considered default for purposes of initialization and comparing to "nothing"

== _DATA.DefaultElement ==

The skill ID considered default for purposes of initialization and comparing to "nothing"

== _DATA.DefaultTile ==

The skill ID considered default for purposes of initialization and comparing to "nothing"

== _DATA.DefaultZone ==

The skill ID considered default for purposes of initialization.

== _DATA.DefaultRank ==

The skill ID considered default for purposes of initialization.

== _DATA.DefaultAI ==

The skill ID considered default for purposes of initialization.

== _DATA.DefaultSkin ==

The skill ID considered default for purposes of initialization.

== _DATA.GenFloor ==

The terrain ID considered to be universally "floor" in random dungeon generation

== _DATA.GenWall ==

The terrain ID considered to be universally "wall" in random dungeon generation

== _DATA.GenUnbreakable ==

The terrain ID considered to be universally "unbreakable" in random dungeon generation

== _DATA.Save ==

The current save file, loaded into memory

== _DATA:GetIndex(RogueEssence.Data.DataManager.DataType) ==

Index paths are modified like mods. However, if multiple mods have conflicting indices, a combined index must be generated.

=== Arguments ===

* <code>type</code>: None

== _DATA:LoadModData``1(RogueEssence.ModHeader,System.String,System.String,System.String) ==

Loads the data of the specified mod, and does not fall back to base if there is no mod.
Used for reserializing/resaving where either the base or the mod's files ONLY need to be resaved.

=== Arguments ===

* <code>mod</code>: None
* <code>subpath</code>: None
* <code>file</code>: None
* <code>ext</code>: None

== _DATA:GetDataModStatus(System.String,System.String,System.String) ==

Returns information of how a file has been modded, if at all.

=== Arguments ===

* <code>subpath</code>: None
* <code>file</code>: None
* <code>ext</code>: None

== _DATA:SaveData(System.Object,System.String,System.String,System.String,RogueEssence.Data.DataManager.SavePolicy) ==

Provides the ability to save it as a file or a mod based on whether it was loaded as a diff or not... aka whether it was a diff as a file or not.
Can also save explicitly as a file or diff.

=== Arguments ===

* <code>entry</code>: None
* <code>subpath</code>: None
* <code>file</code>: None
* <code>ext</code>: None
* <code>savePolicy</code>: None

== _DATA:SaveObject(System.Object,System.String,System.String) ==

=== Arguments ===

* <code>entry</code>: None
* <code>path</code>: The location to save the file if not as a patch.
* <code>basePath</code>: The base file to diff the json against. Do not save as a patch if left blank.

== _DATA:GetZone(System.String) ==

Gets a zone based on its ID

=== Arguments ===

* <code>index</code>: None

== _DATA:GetMap(System.String) ==

Gets a map based on its ID

=== Arguments ===

* <code>name</code>: None

== _DATA:GetGround(System.String) ==

Gets a ground map based on its ID

=== Arguments ===

* <code>name</code>: None

== _DATA:GetSkill(System.String) ==

Gets the data for a skill based on its ID

=== Arguments ===

* <code>index</code>: None

== _DATA:GetItem(System.String) ==

Gets the data for an item based on its ID

=== Arguments ===

* <code>index</code>: None

== _DATA:GetAutoTile(System.String) ==

Gets the data for an autotile based on its ID

=== Arguments ===

* <code>index</code>: None

== _DATA:GetMonster(System.String) ==

Gets the data for a monster based on its ID

=== Arguments ===

* <code>index</code>: None

== _DATA:GetStatus(System.String) ==

Gets the data for a status effect based on its ID

=== Arguments ===

* <code>index</code>: None

== _DATA:GetIntrinsic(System.String) ==

Gets the data for an intrinsic (passive ability) based on its ID

=== Arguments ===

* <code>index</code>: None

== _DATA:GetMapStatus(System.String) ==

Gets the data for a map-wide status effect based on its ID

=== Arguments ===

* <code>index</code>: None

== _DATA:GetTile(System.String) ==

Gets the data for a tile, such as stairs or traps, based on its ID

=== Arguments ===

* <code>index</code>: None

== _DATA:GetTerrain(System.String) ==

Gets the data for a terrain type based on its ID

=== Arguments ===

* <code>index</code>: None

== _DATA:GetEmote(System.String) ==

Gets the data for an emote based on its ID

=== Arguments ===

* <code>index</code>: None

== _DATA:GetElement(System.String) ==

Gets the data for an elemental type based on its ID

=== Arguments ===

* <code>index</code>: None

== _DATA:GetGrowth(System.String) ==

Gets the data for a growth group based on its ID

=== Arguments ===

* <code>index</code>: None

== _DATA:GetSkillGroup(System.String) ==

Gets the data for a skill-sharing group based on its ID

=== Arguments ===

* <code>index</code>: None

== _DATA:GetAITactic(System.String) ==

Gets the data for an ai tactic based on its ID

=== Arguments ===

* <code>index</code>: None

== _DATA:GetRank(System.String) ==

Gets the data for a team rank based on its ID

=== Arguments ===

* <code>index</code>: None

== _DATA:GetSkin(System.String) ==

Gets the data for a skin based on its ID

=== Arguments ===

* <code>index</code>: None

== _DATA:BeginPlay(System.String,System.String,System.Boolean,System.Boolean,System.DateTime) ==

Starts recording the quicksave for a new adventure.
From here on, the replayWriter will remain open as a way to continue writing game states and player inputs.

=== Arguments ===

* <code>filePath</code>: None
* <code>zoneId</code>: None
* <code>rogue</code>: None
* <code>seeded</code>: None
* <code>sessionStart</code>: None

== _DATA:ResumePlay(RogueEssence.Data.ReplayData,System.DateTime) ==

Called when resuming an adventure from a quicksave.
The quicksave file is loaded and the stream position is set to the end, so that it can continue writing the replay.

=== Arguments ===

* <code>replay</code>: The quicksave replay to resume from.
* <code>sessionResumeTime</code>: None

== _DATA:LogState ==

Writes the game state to the current replay. The player must be in dungeon mode.
This is used when the player begins a new dungeon in their adventure. (One adventure can contain a trek through multiple dungeons)

== _DATA:LogGroundSave ==

Writes the game state to the current replay. The player must be in ground mode.
This is used when a player saves in the middle of an adventure in a ground mode rest area.

== _DATA:LogQuicksave ==

Writes the entire game state for faster loading of quicksaves.
Currently not used due to quicksaves still loading from the start of the dungeon and replaying every step up to the current point.

== _DATA:LogPlay(RogueEssence.Dungeon.GameAction) ==

Logs a player action to the current quicksave replay.

=== Arguments ===

* <code>play</code>: None

== _DATA:LogUIPlay(System.Int32[]) ==

Logs a player UI action to the current quicksave replay.

== _DATA:LogUIStringPlay(System.String) ==

Logs a string to the current quicksave replay. Used for name inputs.

== _DATA:QueueLogUI ==

Starts queueing UI commands to the current replay quicksave.
UI commands need to be queued sometimes, because they may happen mid-action for an action that may fail later.
If a player action fails, it is not logged. Thus, if queues didn't exist, UI actions would be logged for actions that didn't actually happen.

== _DATA:DequeueLogUI ==

Stops queueing UI commands to the current replay quicksave and writes the current queue to the replay.

== _DATA:EndPlay(RogueEssence.Data.GameProgress,System.String) ==

Called when an adventure is ended. Closes the replay writing stream and saves the quicksave into a replay.

=== Arguments ===

* <code>epitaph</code>: None
* <code>outFile</code>: None

== _DATA:SaveSessionTime(System.TimeSpan) ==

Saves the current session time

=== Arguments ===

* <code>sessionTime</code>: None

== _DATA:SuspendPlay ==

Called when an adventure is suspended. Closes the replay writing stream to allow for clean exit.
Note how nothing else is done aside form closing the stream.
Quicksaves already save every action from the player as it happens, so even if they closed the game there is no lost data.

== _DATA:LoadMainGameState(System.Boolean) ==

Returns game progress loaded from the save folder and current zone.

== _DATA:DeleteReplayData(System.Boolean) ==

Deletes replays from the replay folder corresponding to the current mod.

=== Arguments ===

* <code>includeFav</code>: Favorites will be deleted too.

[[Category:Data Class Documentation]]

Debugging PMDO

2024-11-11T20:19:37Z

IDK: remove gitignore considerations: implemented in repo's own gitignore

See also: [[Contributing Code]], [[Building PMDO]]

= Windows Setup =
# Recursively clone the PMDO repository using <code>git clone --recurse-submodules -j8 https://github.com/audinowho/PMDODump.git</code>.
# Download the [https://dotnet.microsoft.com/en-us/download/dotnet/8.0 .NET 8.0 SDK]. You want to download the x64 version for windows. Confirm that it is installed using the command <code>dotnet --list-runtimes</code>.
# Download [https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=Community&channel=Release&version=VS2022&source=VSLandingPage&cid=2030&passive=false Visual Studio 2022] or later.
# Open PMDOData.sln using Visual Studio 2022.
# Set your configuration to Debug, Any CPU. Build the entire solution
# Set PMDC as the startup project and hit Debug.

= Linux Setup =
Currently, only x64 architecture is supported for Linux.

# Recursively clone the PMDO repository using <code>git clone --recurse-submodules -j8 https://github.com/audinowho/PMDODump.git</code>.
# Download the [https://dotnet.microsoft.com/en-us/download/dotnet/8.0 .NET 8.0 SDK]. You want to download the x64 version for Linux. Confirm that it is installed using the command <code>dotnet --list-runtimes</code>.
# Download and install [https://code.visualstudio.com/download Visual Studio Code] for Linux. We recommend using the .deb installer.
# Install the [https://code.visualstudio.com/docs/csharp/debugging C# Dev Kit]. This can be found in the Extensions tab.
# Open the PMDOData folder with VSCode. You can do this by starting with a blank VSCode window, open a folder, select the PMDODump folder.
# With the C# Dev Kit installed, you now have the option to open the PMDOData.sln: check the Solution Explorer tab, then right click PMDOData.sln and choose "Open Solution".
# With the C# Dev Kit installed, you also have the option to open the Command Palette <code>Ctrl+Shift+P</code>. In the command palette, type/choose <code>Debug: Select and Start Debugging</code>.
## Choose "C#" from the dropdown. If you've properly opened the PMDOData.sln solution, you should have several Launch Configurations available. Choose "C#: PMDC".
# Debug will start.
## If the console complains about not being able to find the correct file from path, you may need to change the relative paths specified for the <code>-asset</code> argument in the <code>PMDC/PMDC/Properties/launchSettings.json</code> file.
# Once this debug configuration is chosen, you can start debugging quickly by going to the Debug tab and selecting the green button next to "Run and Debug".

= Mac Setup =

Apple machines made a transition from x64 to ARM64 with [https://en.wikipedia.org/wiki/Mac_transition_to_Apple_silicon Apple Silicon] in 2020-2024, with any Macs running on M1 Chips or later using ARM64. PMDO runs and deploys on x64 only; this normally means that PMDO entirely would not be able to run on M1+ Macs, but [https://en.wikipedia.org/wiki/Rosetta_(software) Rosetta 2] translates applications meant for x64 to run on ARM64. This works normally when attempting to play published versions of PMDO, but makes things tricky for debugging.

== Visual Studio Code ==

If your machine predates the ARM64 transition (IE, predates M1 Macs), it uses x64 architecture, and there should be no issues debugging. The setup for Visual Studio Code should work exactly as it did for Linux. Use the instructions there if so. Otherwise, you have two options:
# Use x64 Installation of VS Code on your Arm64 Mac
# Use Arm64 Installation of VS code and Attach Debugger on a separately built PMDO

=== x64 Install on Arm64 Mac ===

# Recursively clone the PMDO repository using <code>git clone --recurse-submodules -j8 https://github.com/audinowho/PMDODump.git</code>.
# Download the [https://dotnet.microsoft.com/en-us/download/dotnet/8.0 .NET 8.0 SDK]. You want to download the x64 (Not Arm64!) version for MacOS. Confirm that it is installed using the command <code>dotnet --list-runtimes</code>.
## Check if your dotnet installation is pointing to the x64 version. Do this with <code>type dotnet</code> and see if it points to <code>/usr/local/share/dotnet/x64/dotnet</code>. If not, you will need to specify the path of dotnet to point to the x64 installation of dotnet: check <code>/etc/paths.d/dotnet</code> and make sure it points to <code>/usr/local/share/dotnet/x64</code>.
# Download and install [https://code.visualstudio.com/download Visual Studio Code] for MacOS. Specifically choose the zip for Intel Chip.
## If you have an existing VSCode installation under Arm64, it must be uninstalled. You should be able to do this by sending the VSCode app to the trash.
# Install the [https://code.visualstudio.com/docs/csharp/debugging C# Dev Kit]. This can be found in the Extensions tab.
## If you had a previous installation of VSCode under Arm64, it's likely that the extension was also installed as an arm64 version. You will need to uninstall it and reinstall to get the x64 version. Do this for both the C# Dev Kit as well as the C# extension it depends on.
# Open the PMDOData folder with VSCode. You can do this by starting with a blank VSCode window, open a folder, select the PMDODump folder.
# With the C# Dev Kit installed, you now have the option to open the PMDOData.sln: check the Solution Explorer tab, then right click PMDOData.sln and choose "Open Solution".
# With the C# Dev Kit installed, you also have the option to open the Command Palette <code>Ctrl+Shift+P</code>. In the command palette, type/choose <code>Debug: Select and Start Debugging</code>.
## Choose "C#" from the dropdown. If you've properly opened the PMDOData.sln solution, you should have several Launch Configurations available. Choose "C#: PMDC".
# Debug will start.
## If the console complains about not being able to find the correct file from path, you may need to change the relative paths specified for the <code>-asset</code> argument in the <code>PMDC/PMDC/Properties/launchSettings.json</code> file.
## If the console complains about missing FNA libs such as SDL2, copy all of the <code>.dylib</code> files in <code>PMDC/PMDC/runtimes/osx-x64/native</code> to <code>PMDC/PMDC/bin/Debug/net8.0</code>, the build output location.
# Once this debug configuration is chosen, you can start debugging quickly by going to the Debug tab and selecting the green button next to "Run and Debug".

=== Arm64 Install with Attach Debugger ===

There is currently no known way to change the build settings in VSCode. If you install the Arm64 version of VS Code, you cannot build the x64 version. Instead, you will need to build PMDO in the command line, run PMDO, and then attach the debugger from VS Code.

# Recursively clone the PMDO repository using <code>git clone --recurse-submodules -j8 https://github.com/audinowho/PMDODump.git</code>.
# Download the [https://dotnet.microsoft.com/en-us/download/dotnet/8.0 .NET 8.0 SDK]. You want to download the Arm64 version for MacOS. Confirm that it is installed using the command <code>dotnet --list-runtimes</code>.
## Check if your dotnet installation is pointing to the arm64 version. Do this with <code>type dotnet</code> and see if it points to <code>/usr/local/share/dotnet/dotnet</code>. If not, you will need to specify the path of dotnet to point to the arm64 installation of dotnet: check <code>/etc/paths.d/dotnet</code> and make sure it points to <code>/usr/local/share/dotnet</code>.
# Download and install [https://code.visualstudio.com/download Visual Studio Code] for MacOS. Specifically choose the zip for Apple Silicon.
## If you have an existing VSCode installation under x64, it must be uninstalled. You should be able to do this by sending the VSCode app to the trash.
# Install the [https://code.visualstudio.com/docs/csharp/debugging C# Dev Kit]. This can be found in the Extensions tab.
## If you had a previous installation of VSCode under x64, it's likely that the extension was also installed as an x64 version. You will need to uninstall it and reinstall to get the arm64 version. Do this for both the C# Dev Kit as well as the C# extension it depends on.
# Open the PMDOData folder with VSCode. You can do this by starting with a blank VSCode window, open a folder, select the PMDODump folder.
# With the C# Dev Kit installed, you now have the option to open the PMDOData.sln: check the Solution Explorer tab, then right click PMDOData.sln and choose "Open Solution".
# In the command line, cd to <code>PMDC/PMDC</code> and run <code>dotnet build -c Debug -r osx-x64</code>. This should output an x64 debug build of PMDO to <code>PMDC/PMDC/bin/Debug/net8.0/osx-x64</code>.
## Copy all of the <code>.dylib</code> files in <code>PMDC/PMDC/runtimes/osx-x64/native</code> to the output directory <code>PMDC/PMDC/bin/Debug/net8.0/osx-x64</code>. This will prevent the program from complaining about missing SDL2 dependencies.
# cd to <code>PMDC/PMDC/bin/Debug/net8.0/osx-x64</code> and run <code>./PMDC -dev -asset ../../../../../DumpAsset/</code>. The program should run successfully.
# With the C# Dev Kit installed, you also have the option to open the Command Palette <code>Ctrl+Shift+P</code>. In the Command Palette Ctrl+Shift+P and running the <code>Debug: Attach to a .NET 5+ or .NET Core process</code>. In the command palette, type/choose <code>Debug: Select and Start Debugging</code>. Find the process of your currently running PMDO instance and choose it in the dropdown. Once selected, the UI will enter debug and you can set breakpoints as normal.
# Each time you want to debug a change, you must rebuild the project using <code>dotnet build -c Debug -r osx-x64</code>, run the resulting program, and then attach the debugger.

Further research: It may be possible to start and attach in a single step using launch configurations:

https://stackoverflow.com/questions/60440765/how-can-i-attach-to-a-specific-process-in-visual-studio-code

=== Visual Studio Code Issues ===

Various issues arise when attempting to use the ARM64 version of dotnet with the ARM64 version VS Code.

Whenever the user clicks "debug", the IDE will build PMDO using the Any CPU setting. If the x64 dotnet is installed, this defaults to an x64 build. But if the Arm64 dotnet is installed, the Arm64 version is built. (Note: check if this is just the responsibility of dotnet installation itself, as opposed to both it and the IDE)

THE ARM64 VERSION OF PMDO DOES NOT WORK. IT IS MISSING ARM64 DEPENDENCIES FOR LUA, SKIASHARP.

We must avoid building the Arm64 version and only build for x64.

It's unknown if there is a way to configure the build step such that it uses the x64 dotnet to build PMDO under x64. Can this be specified in <code>launchSettings.json</code>? In <code>tasks.json</code>?

Resources:

* https://code.visualstudio.com/docs/csharp/debugging
* https://code.visualstudio.com/docs/csharp/debugger-settings
* https://learn.microsoft.com/en-us/dotnet/core/tools/dotnet-build
* https://code.visualstudio.com/Docs/editor/tasks
* https://code.visualstudio.com/docs/editor/variables-reference
* https://github.com/dotnet/docs/issues/34726
* https://code.visualstudio.com/docs/csharp/build-tools

== Jetbrains Rider ==

Jetbrains Rider requires a paid subscription.

=== Jetbrains Rider on x64 ===

This option works for Macs running on x64. However, [[Troubleshooting_Debug_on_OSX_ARM64|issues]] have been seen when running on Arm64.

# Download [https://dotnet.microsoft.com/en-us/download/dotnet/8.0 .NET 8.0]. You want to download the x64 version. Confirm that it is installed using the command <code>dotnet --list-runtimes</code>.
# Recursively clone the PMDO repository using <code>git clone --recurse-submodules -j8 https://github.com/audinowho/PMDODump.git</code>.
# Copy all of the <code>.dylib</code> files in <code>PMDC/PMDC/runtimes</code> folders to <code>PMDC/PMDC</code>. Here’s what your file structure should look like: [[File:Debug_Mac_FolderStructure.png|frameless]]
# Debug should run out of the box. Set the configuration to PMDC and click "Debug", and you should be all ready to go!</br>[[File:Debug_Mac_Rider.png|frameless]]

=== Jetbrains Rider on arm64 ===

# Recursively clone the PMDO repository using <code>git clone --recurse-submodules -j8 https://github.com/audinowho/PMDODump.git</code>.
# Download the [https://dotnet.microsoft.com/en-us/download/dotnet/8.0 .NET 8.0 SDK]. You want to download the Arm64 version for MacOS. Confirm that it is installed using the command <code>dotnet --list-runtimes</code>.
# In the command line, cd to <code>PMDC/PMDC</code> and run <code>dotnet build -c Debug -r osx-x64</code>. This should output an x64 debug build of PMDO to <code>PMDC/PMDC/bin/Debug/net8.0/osx-x64</code>.
## Copy all of the <code>.dylib</code> files in <code>PMDC/PMDC/runtimes/osx-x64/native</code> to the output directory <code>PMDC/PMDC/bin/Debug/net8.0/osx-x64</code>. This will prevent the program from complaining about missing SDL2 dependencies.
# cd to <code>PMDC/PMDC/bin/Debug/net8.0/osx-x64</code> and run <code>./PMDC -dev -asset ../../../../../DumpAsset/</code>. The program should run successfully.
# With Rider installed, [https://www.jetbrains.com/help/rider/attach-to-process.html attach a debugger to the currently running PMDO process].
# Each time you want to debug a change, you must rebuild the project using <code>dotnet build -c Debug -r osx-x64</code>, run the resulting program, and then attach the debugger.

[[Category: Engine]]

Tutorial:Troubleshooting Debug on OSX ARM64

2024-11-11T19:38:49Z

IDK:

Starting with apple M1, all mac OSes run on ARM64. Existing x64 programs can still work on it thanks to rosetta, and indeed published versions of PMDO for oxs-x64 work just fine.

However, building and debugging PMDO becomes confusing, as the build toolchain and the IDE may try to use the arm64 version instead of x64. It may build the arm64 version, or debug an x64 build as if it were arm64. Additionally, arm64 libraries are missing and thus cannot be run (at least not without building every dependency for arm64).

This page goes over the troubleshooting process for getting PMDO to debug on OSX-ARM64 using Rider. It is currently unresolved.

== Sanity Checks ==

These steps were taken to ensure the setup was correct.

=== Other Projects ===

Attempting to debug on other projects using Rider worked.

=== Clearing Rider Cache ===

File -> Invalidate Cache -> Choose all

This did not resolve the issue.

=== Clearing Nuget Cache ===

Delete <code>~/.nuget</code> to remove all nuget packages so that they'll be redownloaded cleanly on next build.

It deletes gigabytes of data. Build works and regenerated them cleanly.

This did not resolve the issue.

=== Clean Clone from Repository ===

We are trying the basic Example program that contains the bare minimum in dependencies.

Do a fresh clone+submodules of RogueEssence in this branch: https://github.com/RogueCollab/RogueEssence/tree/Example

This did not resolve the issue, but this provides a good base to start isolating the problem in.

=== Factors to Consider ===

We have two runtimes of dotnet: <code>/usr/local/share/dotnet/x64/dotnet</code> and <code>/usr/local/share/dotnet/dotnet</code>. Which runtime do we use in Rider?

What are the possible configurations when building/debugging?

=== Configuration Attempts and Their Results ===

A series of experiments were performed in running the command line <code>dotnet build</code> and running the outputted executable. Before each experiment, the bin/ and obj/ subfolders were completely deleted.

These are the results you get when you perform the following actions with a wiped bin/obj:
* dotnet build: Fails. It builds out to bin/Debug/net8.0. Complains about libskia.dylib and requires it to be arm64. Ran using ./PMDC
* dotnet build -c Debug -r osx-x64: Successful. It builds out to bin/Debug/net8.0/osx-x64 but does not copy fnalibs. Once they are copied manually, running ./PMDC -dev -asset ../../../../../DumpAsset/ succeeds.
* Debugging in Rider with PMDC configured to Any CPU: Exact same result as dotnet build.
* Debugging in Rider with PMDC configured to x64: Fails. It builds out to bin/Debug/net8.0. Complains with System.IO.FileLoadException: Could not load file or assembly 'PMDC'. This error also shows up if ran using ./PMDC

=== Backup Plans ===

* Plan A was to clear all the caches and ensure no remnant dependencies...
* Plan B was to look into configuration to see if anything could be set right there.
* Plan C will be an attempt to attach a debugger to the x64 build that does work, and come up with some patch solution on that.
* Plan D is to do it all the hard way and build PMDO with arm64 skiasharp off an example avalonia project plus [[Upgrading_FNA_Dependencies|Xcode building fnalibs]] plus additional building for [[Upgrading_Lua_Debug|lualibs and core.so]]

[[Category: Troubleshooting]]

Tutorial:Troubleshooting Debug on OSX ARM64

2024-11-11T19:38:02Z

IDK: reformatting and links

Starting with apple M1, all mac OSes run on ARM64. Existing x64 programs can still work on it thanks to rosetta, and indeed published versions of PMDO for oxs-x64 work just fine.

However, building and debugging PMDO becomes confusing, as the build toolchain and the IDE may try to use the arm64 version instead of x64. It may build the arm64 version, or debug an x64 build as if it were arm64. Additionally, arm64 libraries are missing and thus cannot be run (at least not without building every dependency for arm64).

This page goes over the troubleshooting process for getting PMDO to debug on OSX-ARM64 using Rider. It is currently unresolved.

== Sanity Checks ==

These steps were taken to ensure the setup was correct.

=== Other Projects ===

Attempting to debug on other projects using Rider worked.

=== Clearing Rider Cache ===

File -> Invalidate Cache -> Choose all

This did not resolve the issue.

=== Clearing Nuget Cache ===

Delete <code>~/.nuget</code> to remove all nuget packages so that they'll be redownloaded cleanly on next build.

It deletes gigabytes of data. Build works and regenerated them cleanly.

This did not resolve the issue.

=== Clean Clone from Repository ===

We are trying the basic Example program that contains the bare minimum in dependencies.

Do a fresh clone+submodules of RogueEssence in this branch: https://github.com/RogueCollab/RogueEssence/tree/Example

This did not resolve the issue, but this provides a good base to start isolating the problem in.

=== Factors to Consider ===

We have two runtimes of dotnet: <code>/usr/local/share/dotnet/x64/dotnet</code> and <code>/usr/local/share/dotnet/dotnet</code>. Which runtime do we use in Rider?

What are the possible configurations when building/debugging?

=== Configuration Attempts and Their Results ===

A series of experiments were performed in running the command line <code>dotnet build</code> and running the outputted executable. Before each experiment, the bin/ and obj/ subfolders were completely deleted.

These are the results you get when you perform the following actions with a wiped bin/obj:
* dotnet build: Fails. It builds out to bin/Debug/net8.0. Complains about libskia.dylib and requires it to be arm64. Ran using ./PMDC
* dotnet build -c Debug -r osx-x64: Successful. It builds out to bin/Debug/net8.0/osx-x64 but does not copy fnalibs. Once they are copied manually, running ./PMDC -dev -asset ../../../../../DumpAsset/ succeeds.
* Debugging in Rider with PMDC configured to Any CPU: Exact same result as dotnet build.
* Debugging in Rider with PMDC configured to x64: Fails. It builds out to bin/Debug/net8.0. Complains with System.IO.FileLoadException: Could not load file or assembly 'PMDC'. This error also shows up if ran using ./PMDC

=== Backup Plans ===

* Plan A was to clear all the caches and ensure no remnant dependencies...
* Plan B was to look into configuration to see if anything could be set right there.
* Plan C will be an attempt to attach a debugger to the x64 build that does work, and come up with some patch solution on that.
* Plan D is to do it all the hard way and build PMDO with arm64 skiasharp off an example avalonia project plus [[https://wiki.pmdo.pmdcollab.org/Upgrading_FNA_Dependencies|Xcode building fnalibs]] plus additional building for [[https://wiki.pmdo.pmdcollab.org/Upgrading_Lua_Debug|lualibs and core.so]]

[[Category: Troubleshooting]]

Debugging PMDO

2024-11-11T19:35:18Z

IDK: attach debugger instructions

File:Troubleshooting IntelAtom DX11.jpg

2024-11-11T18:50:54Z

IDK: Category:Troubleshooting Images

== Summary ==
[[Category:Troubleshooting Images]]

File:Troubleshooting IntelAtom Features.jpg

2024-11-11T18:50:42Z

IDK: Category:Troubleshooting Images

== Summary ==
[[Category:Troubleshooting Images]]

File:Troubleshooting IntelAtom UpdateDrivers.png

2024-11-11T18:50:30Z

IDK: Category:Troubleshooting Images

== Summary ==
[[Category:Troubleshooting Images]]

Tutorial:Troubleshooting Startup on Intel Atom

2024-11-11T18:49:47Z

IDK: troubleshooting images

Troubleshooting for running PMDO on the following specs:

Operating System: Windows 7 Ultimate, Service Pack 1
Processor: Intel Atom D510 @ 1.66GHz
Memory (RAM): 1.00 GB
System Type: 32-bit operating system

Program fails like this:
<pre>
[2024/09/16 08:33:22.1] Creating device with feature level 11_1 failed. Lowering feature level.

[2024/09/16 08:33:22.106] D3D11 is unsupported! Error Code: 887A0004

[2024/09/16 08:33:22.916] FNA3D Driver: OpenGL

[2024/09/16 08:33:22.917] OpenGL Renderer: Intel Pineview Platform

[2024/09/16 08:33:22.917] OpenGL Driver: 1.4.0 - Build 8.14.10.1929

[2024/09/16 08:33:22.918] OpenGL Vendor: Intel
</pre>
+ Program stopped working

This issue has been unresolved.

== Install DirectX ==

Tried installing directX: https://support.microsoft.com/en-us/topic/how-to-install-the-latest-version-of-directx-d1f5ffa5-dae2-246c-91b1-ee1e973ed8c2

in order to resolve this error:

<code>D3D11 is unsupported! Error Code: 887A0004</code>

=== Response ===

It says it already has this installed.

== OS update ==

was this OS updated as well?

=== Response ===

Windows Standalone Installer
The Windows Update (KB2670838) is already installed on this computer.

== DxDiag ==

can you run dxdiag? you should be able to search for it on the start menu
we're going to try and find out more about your current directx installation.
PMDO needs Direct3D 11
I think that's part of DirectX 11

=== Response ===

[[File:Troubleshooting_IntelAtom_DX11.jpg|frameless]]

On the Display tab, under DirectX Features, verify Direct3D Acceleration are selected.
can you check this?

=== Response ===

All selected.

== DxDiag Render ==

what about the Render tab? what's on there?
specifically the "Device" and "Drivers" sections
oh it might still be on Display tab

=== Response ===

[[File:Troubleshooting_IntelAtom_Features.jpg|frameless]]

=== Support ===

DDI needs to be 11 or higher
you need to download the right display driver...
download/update
hmmmm
I think it's possible to do this from the device manager.

== Update to Right display driver ==

Type in Device Manager from the start search, and then do this:

[[File:Troubleshooting_IntelAtom_UpdateDrivers.png|frameless]]

=== Response ===

The best driver software for the device is installed
Windows has determined that the driver software for the device is up to date.

=== Support ===

even if this window says your drivers are up to date
there is still a specific dll you're missing
the easy way is through automatic updaters
but manual will still be possible...

== Manual Update to right display Driver ==

can you check if you have this already installed? https://www.intel.com/content/www/us/en/download/19536/intel-graphics-media-accelerator-3150-for-windows-7-32-bit.html

=== Response ===

After installation, this computer went black screen hmm（To solve this, I reinstalled the original driver and the black screen no longer appeared）.
So installing this driver doesn't seem to work.

== Additional Articles ==

https://www.reddit.com/r/24hoursupport/comments/115faah/direct3d_ddi_stuck_on_111_but_system_is_running/
https://www.reddit.com/r/24hoursupport/comments/2ni5ri/ddi_stuck_at_9ex_even_though_my_card_is_dx11_ready/

[[Category: Troubleshooting]]

Dev Mode

2024-11-11T06:41:30Z

IDK: Soft reset

PMDO has a secret developer mode that can be used to cheat, examine, and mod the game.
Start PMDO in this mode using the following command:

Windows:
<pre>
PMDO.exe -dev
</pre>

Unix:
<pre>
./PMDO -dev
</pre>

You can also run the <code>dev.bat</code> file to start without the command line.

== Hotkeys ==

* F1 shows diagnostic information. This will show FPS, version number, current position, animation, and hitboxes. This is also usable outside of dev mode but will only show FPS and version number.
* Shift+Up/Down warps to the next and previous floors of the dungeon, respectively.
* Shift+Left/Right warps to the next and previous segments of the dungeon. A dungeon may be split up into segments such as Magma Cavern and Deep Magma Cavern.
* Shift+Right Click will warp the player to the location clicked.
* F2 pauses the game.
* F3 advances the frame when the game is paused.
* F4 is a test button used by programmers to quickly test a feature. Don’t worry about this.
* F5 slows down the game.
* F6 speeds up the game.
* F8 mutes the music, and unmutes it when muted.
* F9 turns on FreeCam mode, where the camera can be moved. In dungeons, it turns on SeeAll mode.
* F11 takes a screenshot of the ENTIRE map, useful for showcasing maps. All characters, objects, and currently active VFX are included. The screenshot is saved to the SCREENSHOT/ subfolder.
* F12 warps the player to the debug ground map using their current save file. If no save file exists, a debug file is created (but not saved)
* F1+F12 warps the player to the debug room. Unlike F12, it send the player to the debug dungeon map.
* CTRL+F12 soft resets to the title screen.

== Dev Panel ==

This contains the main controls to modify the game. They are separated into tabs.

=== Game ===
Often used to cheat and test in dungeons.

[[File:DevPanel_Game.png|frameless]]

* Hide Objects: Hides items and traps. In ground maps, objects are hidden.
* Hide Sprites: Hides Pokemon. Often used for screenshots.
* Create Clone: Creates a (Hostile) clone of your current character in your current location.
* Clear All Foes: Removes all enemies from the map.
* Skill List: Allows you to learn a move, or give it to foes.
* Ability list: Allows you to gain an ability, or give it to foes.
* Status List: Allows you to take on a status effect.
* Item List: Allows you to spawn items in dungeons.

=== Player ===
Often used to cheat in dungeons, or test animations.

[[File:DevPanel_Player.png|frameless]]

* Lv.: Sets the current player’s level. Updates in real time.
* Reroll: Updates the current player’s moveset to the latest naturally learned moves at the current level.
* Species/Form/Skin/Gender: Change the player’s current species/form/shininess/gender.
* Animation: Change the player’s current animation.

=== Travel ===
Used to instantly warp to needed locations.

[[File:DevPanel_Travel.png|frameless]]

* Areas are organized into Zones.
* Each zone has a list of Structures, plus a list of Ground Maps.
* Ground Maps are the hub maps with free movement.
* Each Structure contains a list of floors.
* You can choose to enter either a a Ground map using Enter Ground, or a dungeon floor using Enter Map.

=== Data ===
Used to edit maps, items, Pokemon, etc.

[[File:DevPanel_Data.png|frameless]]

=== Sprites ===
Used to the graphics of the game.

[[File:DevPanel_Sprites.png|frameless]]

* Char Sprites: Pokemon sprites in dungeons/overworld.
* Portraits: Character portraits in dialogue.
* Particles: Most attack graphics.
* Beams: Used in attacks that shoot continuous beams, plus columns of light used for sending home.
* Backgrounds: Used in the title screen, and maps with parallax backgrounds.
* Emotes: Emote animations. Includes status effect icons.
* Tiles: All tilesets. Does not include autotiles (which are in the Data tab).
* Items: Item Sprites
* Objects: Tree stumps, signs, traps, etc.

=== Script ===
A lua command prompt to enter custom commands.

[[File:DevPanel_Script.png|frameless]]

* Reload Scripts: Reloads all lua scripts with your edits without needing to restart the game.
* Text Test: Allows you to test a dialogue box with sample text. For translators.

Command box controls:
* Type in a lua script command to run it directly on the game.
* Use TASK:BranchCoroutine(<your function here>) to call coroutines.
* SHIFT+Up/Down to scroll past commands.
* SHIFT+Enter to enter a multiline command.

=== Mods ===
Controls which mod the game currently has loaded. Can create, delete, and switch between mods. Only one may be loaded at a time. If you want to work on a mod, make sure the game is set to that mod before doing work.

[[File:DevPanel_Mod.png|frameless]]

=== Constants ===
Starter data, special game events, and VFX that are used in hardcoded portions of the game.

[[File:DevPanel_Constants.png|frameless]]

=== The Debug Room ===
This room contains a crowd of Pokemon at the top left corner for east move/ability/item testing.

[[File:DebugRoom.png|frameless]]

[[Category:Modding]]
[[Category:Quick Reference]]

Debugging PMDO

2024-11-09T23:18:23Z

IDK: Issues and further research

Debugging PMDO

2024-11-09T21:06:07Z

IDK: refactor steps to debug

Debugging PMDO

2024-11-09T05:10:14Z

IDK:

See also: [[Contributing Code]], [[Building PMDO]]

= Windows Setup =
# Download [https://dotnet.microsoft.com/en-us/download/dotnet/8.0 .NET 8.0]. You want to download the x64 version. Confirm that it is installed using the command <code>dotnet --list-runtimes</code>.
# Recursively clone the PMDO repository using <code>git clone --recurse-submodules -j8 https://github.com/audinowho/PMDODump.git</code>.
# Open PMDOData.sln using [https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=Community&channel=Release&version=VS2022&source=VSLandingPage&cid=2030&passive=false Visual Studio 2022] or later.
# Set your configuration to Debug, Any CPU. Build the entire solution
# Set PMDC as the startup project and hit Debug.

= Linux Setup =

# Download [https://dotnet.microsoft.com/en-us/download/dotnet/8.0 .NET 8.0]. You want to download the x64 version. Confirm that it is installed using the command <code>dotnet --list-runtimes</code>.
# Recursively clone the PMDO repository using <code>git clone --recurse-submodules -j8 https://github.com/audinowho/PMDODump.git</code>.
# Open PMDOData.sln using [https://code.visualstudio.com/download Visual Studio Code]. You can do this by opening the PMDODump folder, then right clicking PMDOData.sln and choosing "Open Solution".
# Install the [https://code.visualstudio.com/docs/csharp/debugging C# Dev Kit] if you haven't already. This can be found in the Extensions tab.
# After the C# Dev Kit is installed, you can open the Command Palette <code>Ctrl+Shift+P</code> and typing/choosing <code>Debug: Select and Start Debugging</code>.
## Choose C#.
### If you've properly opened the PMDOData.sln solution, you should have several Launch Configurations available. Choose "C#: PMDC".
# Debug will start. If the console complains about not being able to find the correct file from path, you may need to change the relative paths specified for the <code>-asset</code> argument in the <code>PMDC/PMDC/Properties/launchSettings.json</code> file.
# Once this debug configuration is chosen, you can start debugging quickly by going to the Debug tab and selecting the green button next to "Run and Debug".

= Mac Setup =

Note: This has only been tested with Jetbrains Rider and Visual Studio Code

Made by: Trio-#4442

# Download [https://dotnet.microsoft.com/en-us/download/dotnet/8.0 .NET 8.0]. You want to download the x64 version. Confirm that it is installed using the command <code>dotnet --list-runtimes</code>.
# Recursively clone the PMDO repository using <code>git clone --recurse-submodules -j8 https://github.com/audinowho/PMDODump.git</code>.
# Copy all of the <code>.dylib</code> files in <code>PMDC/PMDC/runtimes</code> folders to <code>PMDC/PMDC</code>. Here’s what your file structure should look like: [[File:Debug_Mac_FolderStructure.png|frameless]]
# In your <code>~/.gitignore_global</code> file, add the following files for git to ignore:
<pre>
# Debug logs (npm, yarn)
*.log

# Editor artifacts
.*.sw[a-z]
*~
.#*
.vscode
.idea

# OS files
Thumbs.db
.DS_Store
</pre>
You may want to include more. Modified from [https://www.mashupgarage.com/playbook/git/gitignore.html here].

The following steps below depend on your IDE of choice. See each section below.

== Jetbrains Rider ==
Jetbrains Rider requires a paid subscription.

# Debug should run out of the box. Set the configuration to PMDC and click "Debug", and you should be all ready to go!</br>[[File:Debug_Mac_Rider.png|frameless]]

== Visual Studio Code ==
# Install the C# extension. There is a possibility that you have to downgrade to an older version like <code>v1.24.4</code> or modify the settings in Omnisharp settings discussed here? But I personally wasn’t able to figure out how to make it work.
# Create <code>.vscode/launch.json</code> in the root folder of <code>PMDODump</code> In launch.json, copy everything from here to the file.</br>[[File:Debug_Mac_VSCode_Launch.png|frameless]]
# In the <code>Run and Debug</code> tab in VSCode, you can click on the green arrow to begin debugging.</br>[[File:Debug_Mac_VSCode_Debug.png|frameless]]

[[Category: Engine]]

Debugging PMDO

2024-11-09T04:22:38Z

IDK: Linux Debugging

See also: [[Contributing Code]], [[Building PMDO]]

= Windows Setup =
# Download [https://dotnet.microsoft.com/en-us/download/dotnet/8.0 .NET 8.0]. You want to download the x64 version Confirm that it is installed using the command <code>dotnet --list-runtimes</code>.
# Recursively clone the PMDO repository using <code>git clone --recurse-submodules -j8 https://github.com/audinowho/PMDODump.git</code>.
# Open PMDOData.sln using [https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=Community&channel=Release&version=VS2022&source=VSLandingPage&cid=2030&passive=false Visual Studio 2022] or later.
# Set your configuration to Debug, Any CPU. Build the entire solution
# Set PMDC as the startup project and hit Debug.

= Linux Setup =

# Download [https://dotnet.microsoft.com/en-us/download/dotnet/8.0 .NET 8.0]. You want to download the x64 version Confirm that it is installed using the command <code>dotnet --list-runtimes</code>.
# Recursively clone the PMDO repository using <code>git clone --recurse-submodules -j8 https://github.com/audinowho/PMDODump.git</code>.
# Open PMDOData.sln using [https://code.visualstudio.com/download Visual Studio Code]. You can do this by opening the PMDODump folder, then right clicking PMDOData.sln and choosing "Open Solution".
# Install the [https://code.visualstudio.com/docs/csharp/debugging C# Dev Kit] if you haven't already. This can be found in the Extensions tab.
# After the C# Dev Kit is installed, you can open the Command Palette <code>Ctrl+Shift+P</code> and typing/choosing <code>Debug: Select and Start Debugging</code>.
## Choose C#.
### If you've properly opened the PMDOData.sln solution, you should have several Launch Configurations available. Choose "C#: PMDC".
# Debug will start. If the console complains about not being able to find the correct file from path, you may need to change the relative paths specified for the <code>-asset</code> argument in the <code>PMDC/PMDC/Properties/launchSettings.json</code> file.
# Once this debug configuration is chosen, you can start debugging quickly by going to the Debug tab and selecting the green button next to "Run and Debug".

= Mac Setup =

Note: This has only been tested with Jetbrains Rider and Visual Studio Code

Made by: Trio-#4442

# Download [https://dotnet.microsoft.com/en-us/download/dotnet/8.0 .NET 8.0]. You want to download the x64 version Confirm that it is installed using the command <code>dotnet --list-runtimes</code>.
# Recursively clone the PMDO repository using <code>git clone --recurse-submodules -j8 https://github.com/audinowho/PMDODump.git</code>.
# Copy all of the <code>.dylib</code> files in <code>PMDC/PMDC/runtimes</code> folders to <code>PMDC/PMDC</code>. Here’s what your file structure should look like: [[File:Debug_Mac_FolderStructure.png|frameless]]
# In your <code>~/.gitignore_global</code> file, add the following files for git to ignore:
<pre>
# Debug logs (npm, yarn)
*.log

# Editor artifacts
.*.sw[a-z]
*~
.#*
.vscode
.idea

# OS files
Thumbs.db
.DS_Store
</pre>
You may want to include more. Modified from [https://www.mashupgarage.com/playbook/git/gitignore.html here].

The following steps below depend on your IDE of choice. See each section below.

== Jetbrains Rider ==
Jetbrains Rider requires a paid subscription.

# Debug should run out of the box. Set the configuration to PMDC and click "Debug", and you should be all ready to go!</br>[[File:Debug_Mac_Rider.png|frameless]]

== Visual Studio Code ==
# Install the C# extension. There is a possibility that you have to downgrade to an older version like <code>v1.24.4</code> or modify the settings in Omnisharp settings discussed here? But I personally wasn’t able to figure out how to make it work.
# Create <code>.vscode/launch.json</code> in the root folder of <code>PMDODump</code> In launch.json, copy everything from here to the file.</br>[[File:Debug_Mac_VSCode_Launch.png|frameless]]
# In the <code>Run and Debug</code> tab in VSCode, you can click on the green arrow to begin debugging.</br>[[File:Debug_Mac_VSCode_Debug.png|frameless]]

[[Category: Engine]]

Debugging PMDO

2024-11-09T02:53:39Z

IDK: Linux VSCode WIP

See also: [[Contributing Code]], [[Building PMDO]]

= Windows Setup =
# Download [https://dotnet.microsoft.com/en-us/download/dotnet/8.0 .NET 8.0]. You want to download the x64 version Confirm that it is installed using the command <code>dotnet --list-runtimes</code>.
# Recursively clone the PMDO repository using <code>git clone --recurse-submodules -j8 https://github.com/audinowho/PMDODump.git</code>.
# Open PMDOData.sln using [https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=Community&channel=Release&version=VS2022&source=VSLandingPage&cid=2030&passive=false Visual Studio 2022] or later.
# Set your configuration to Debug, Any CPU. Build the entire solution
# Set PMDC as the startup project and hit Debug.

= Linux Setup =

# Download [https://dotnet.microsoft.com/en-us/download/dotnet/8.0 .NET 8.0]. You want to download the x64 version Confirm that it is installed using the command <code>dotnet --list-runtimes</code>.
# Recursively clone the PMDO repository using <code>git clone --recurse-submodules -j8 https://github.com/audinowho/PMDODump.git</code>.
# Open PMDOData.sln using [https://code.visualstudio.com/download Visual Studio Code].
# Install the [https://code.visualstudio.com/docs/csharp/debugging C# Dev Kit] if you haven't already.

= Mac Setup =

Note: This has only been tested with Jetbrains Rider and Visual Studio Code

Made by: Trio-#4442

# Download [https://dotnet.microsoft.com/en-us/download/dotnet/8.0 .NET 8.0]. You want to download the x64 version Confirm that it is installed using the command <code>dotnet --list-runtimes</code>.
# Recursively clone the PMDO repository using <code>git clone --recurse-submodules -j8 https://github.com/audinowho/PMDODump.git</code>.
# Copy all of the <code>.dylib</code> files in <code>PMDC/PMDC/runtimes</code> folders to <code>PMDC/PMDC</code>. Here’s what your file structure should look like: [[File:Debug_Mac_FolderStructure.png|frameless]]
# In your <code>~/.gitignore_global</code> file, add the following files for git to ignore:
<pre>
# Debug logs (npm, yarn)
*.log

# Editor artifacts
.*.sw[a-z]
*~
.#*
.vscode
.idea

# OS files
Thumbs.db
.DS_Store
</pre>
You may want to include more. Modified from [https://www.mashupgarage.com/playbook/git/gitignore.html here].

The following steps below depend on your IDE of choice. See each section below.

== Jetbrains Rider ==
Jetbrains Rider requires a paid subscription.

# Debug should run out of the box. Set the configuration to PMDC and click "Debug", and you should be all ready to go!</br>[[File:Debug_Mac_Rider.png|frameless]]

== Visual Studio Code ==
# Install the C# extension. There is a possibility that you have to downgrade to an older version like <code>v1.24.4</code> or modify the settings in Omnisharp settings discussed here? But I personally wasn’t able to figure out how to make it work.
# Create <code>.vscode/launch.json</code> in the root folder of <code>PMDODump</code> In launch.json, copy everything from here to the file.</br>[[File:Debug_Mac_VSCode_Launch.png|frameless]]
# In the <code>Run and Debug</code> tab in VSCode, you can click on the green arrow to begin debugging.</br>[[File:Debug_Mac_VSCode_Debug.png|frameless]]

[[Category: Engine]]

Tutorial:Troubleshooting Debug on OSX ARM64

2024-11-09T02:13:47Z

IDK:

Starting with apple M1, all mac OSes run on ARM64. Existing x64 programs can still work on it thanks to rosetta, and indeed published versions of PMDO for oxs-x64 work just fine.

However, building and debugging PMDO becomes confusing, as the build toolchain and the IDE may try to use the arm64 version instead of x64. It may build the arm64 version, or debug an x64 build as if it were arm64. Additionally, arm64 libraries are missing and thus cannot be run (at least not without building every dependency for arm64).

This page goes over the troubleshooting process for getting PMDO to debug on OSX-ARM64. It is currently unresolved.

== Command Line ==

* <code>dotnet build</code>: Fails. It builds out to bin/Debug/net8.0. Complains about libskia.dylib and requires it to be arm64. Ran using ./PMDC
* <code>dotnet build -c Debug -r osx-x64</code>: Successful. It builds out to bin/Debug/net8.0/osx-x64 but does not copy fnalibs. Once they are copied manually, running ./PMDC -dev -asset ../../../../../DumpAsset/ succeeds.

== VS Code ==

== Rider ==

=== Sanity Checks ===

These steps were taken to ensure the setup was correct.

==== Other Projects ====

Attempting to debug on other projects using Rider worked.

==== Clearing Rider Cache ====

File -> Invalidate Cache -> Choose all

This did not resolve the issue.

==== Clearing Nuget Cache ====

Delete <code>~/.nuget</code> to remove all nuget packages so that they'll be redownloaded cleanly on next build.

It deletes gigabytes of data. Build works and regenerated them cleanly.

This did not resolve the issue.

==== Clean Clone from Repository ====

We are trying the basic Example program that contains the bare minimum in dependencies.

Do a fresh clone+submodules of RogueEssence in this branch: https://github.com/RogueCollab/RogueEssence/tree/Example

This did not resolve the issue, but this provides a good base to start isolating the problem in.

=== Factors to Consider ===

DotNet installations: Do we have more than one NetCore installation?

A:

We have two runtimes of dotnet: <code>/usr/local/share/dotnet/x64/dotnet</code> and <code>/usr/local/share/dotnet/dotnet</code>. Which runtime do we use in Rider?

A:

What are the possible configurations when building/debugging?

A:

=== Configuration Attempts and Their Results ===

A series of experiments were performed in running the command line <code>dotnet build</code> and running the outputted executable. Before each experiment, the bin/ and obj/ subfolders were completely deleted.

These are the results you get when you perform the following actions with a wiped bin/obj:
* dotnet build: Fails. It builds out to bin/Debug/net8.0. Complains about libskia.dylib and requires it to be arm64. Ran using ./PMDC
* dotnet build -c Debug -r osx-x64: Successful. It builds out to bin/Debug/net8.0/osx-x64 but does not copy fnalibs. Once they are copied manually, running ./PMDC -dev -asset ../../../../../DumpAsset/ succeeds.
* Debugging in Rider with PMDC configured to Any CPU: Exact same result as dotnet build.
* Debugging in Rider with PMDC configured to x64: Fails. It builds out to bin/Debug/net8.0. Complains with System.IO.FileLoadException: Could not load file or assembly 'PMDC'. This error also shows up if ran using ./PMDC

=== Backup Plans ===

* Plan A was to clear all the caches and ensure no remnant dependencies...
* Plan B was to look into configuration to see if anything could be set right there.
* Plan C will be an attempt to attach a debugger to the x64 build that does work, and come up with some patch solution on that.
* Plan D is to do it all the hard way and build PMDO with arm64 skiasharp off an example avalonia project plus Xcode building fnalibs plus additional building for lualibs and core.so

[[Category: Troubleshooting]]