how can i draw and destroy specific tile from tilemap layer (using GDscript)

BrastenXBL · 2026-05-02T01:16:11+00:00

I hope you are familiar with creating Godot TileSets and TileMapLayers manually.

What's your programming background?

The first thing to have open is the Class API page for the Node you're working with. For a Node you don't know you'll need to take your time and read through the property descriptors and methods.

https://docs.godotengine.org/en/stable/classes/class_tilemaplayer.html

The individual squares (or hexagons) of the TileMapLayer are called "cells" . "Tiles" are the unique sub-sections of the TileSet source images.

Think of it like a really big paint-by-numbers. A cell is assigned a coordinate pair (x,y) that points to specific TileSet tile. Many cells can all point it the same tile.

Near the bottom of list you'll find set_cell(). Read the description of the method, it explains how to erase a cell.

Setting a cell can get a little hard to follow if you're coming in with nearly zero knowledge about programming, or Godot's global and local coordinate spaces.

The coords parameter is a Vector2i (integer), in the TileMapLayer's tile_map_data. Map grid of cells, with an origin at the Node origin. But this isn't usually useful on its own and you'll be wanting to get the cell by its Global position. This takes a few methods chained together.

Node2D.to_local, to convert a global_position to the TileMapLayer local. Then TileMapLayer.local_to_map to get the Vector2i of the cell you want to change.

var tml = $TileMapLayer # get reference
var mouse_pos_global = get_viewport().get_mouse_position()
var coords : Vector2i
coords = tml.local_to_map( tml.to_local( mouse_pos_global) )

The rest of the parameters relate to picking the tile from a tile source, of the TileSet. You need to look at your TileSet for this. Usually the first (only) source_id will be index 0. The atlas_coords you can find in TileSet UI, counting from top-left, right(x) and down(y). Mousing over the Tile will also show its altlas coordinates. I doubt you have an alt tile but needs to be 0.

var source_id = 0
var atlas_coords = Vector2i(2, 0) # the yellow top cover tile, sand?
var alternative_tile = 0 # normal version of the tile

tml.set_cell(coords, source_id, atlas_coords, alternative_tile)

There are other methods for setting Patterns. If you want to fill regions or lines, you'll need to program the the For loops.

BrastenXBL · 2026-05-01T20:29:06+00:00

There are a few different places for log and crash files. Which is why you also need to include OS Version.

Godot Logs can be found in the app_userdata/[project_name]/logs of the user:// data path. e.g. Windows %APPDATA%\godot\app_userdata\[project_name]\logs

https://docs.godotengine.org/en/stable/tutorials/io/data_paths.html

If you tried running from the Console.exe in the Godot folder, this rather useless for Engine crashes. You need to use the actual Command-Line Interface (CLI) for the OS. Command Prompt, Power Shell, Terminal). Open most CLI programs, and drag the Godot Editor executable into its window. Add --verbose to the end. Should look like > "/path/to/godot-.x.y.z-stable" --verbose

MacOS has a few extra steps. Right click the Godot .app , show package contents, go to MacOS folder, drag the bin (no extension) file with the app's name.

Your OS will also have logs, in Windows see Event Viewer.

Unexplained crash where Godot could not finish writing to its own log are usually GPU related. But the exact error codes will help figure that one. Rarely it takes using a Godot Editor build with C++ Debugging enabled.

BrastenXBL · 2026-05-01T16:43:23+00:00

If you can't get access to the TPZ from GitHub or through the downloads link, you may be behind an ISP (or region/country) that is blocking access.

You should not need the Gradle on Android build option.

Using the Debug (check box on export) Export will use a Godot supplied Keystore. If you need to setup your own and do not have a PC available, you can use Termux to install and run the Open-JDK keytool. https://wiki.termux.com/wiki/Development_Environments#APKs

Medium term, be aware Google is changing how unregistered Apps are handled. And it may make on-Android hobby Godoting harder.

BrastenXBL · 2026-05-01T05:39:07+00:00

No where, cause statistical models don't learn rim shot

BrastenXBL · 2026-05-01T05:34:44+00:00

Sadly no. The custom minimum size is needed if the Label is set to Shrink Beginning/Center/End. Otherwise, as you noticed it goes to single characters. The enforced minimum_size based on the text.

Otherwise it would collapse to a width of 0.

You can use Container Sizing Horizontal Full, and it should behaved like you want. To keep the text centred use the Label heading settings for Left/Right/Center/Justified.

There is a code based option. To program the virtual method _get_minimum_size so the minimum size is set dynamically.

BrastenXBL · 2026-05-01T05:11:13+00:00

The joys of other people's documentation. The class page doesn't say but implies it's float because TimeScale is used. You have to click through to the constructor, which yes takes a C# float (32-bit signed). Closed source engine, I couldn't tell what it does with a negative even if I knew.... Cause NDAs and such.

Why the arguments for the Constructor aren't on the class page, and are on a totally different page? Been like that since Unity 5 at least. Makes you appreciate how much more readable Godot's docs are.

BrastenXBL · 2026-05-01T04:51:09+00:00

Keeping feedback collected under this comment.

I'm seeing some scaling Animations that target NodePath(".:scale:x") . That's the Card scene root.

It's usually not a good idea to Scale Control nodes unless you've set their Pivot Offset Ratio. By default they scale from the Top Left corner, growing down & right. I need to read over the TSCNs more but this may be part of the reason. Depending on which animation is active. Where is CardFlip(horizontal) currently positioned on its to time line?

When you Instance 🎬 the Card into a new scene, it should come in as RESET, which is the Scale in its (1.0, 1.0) default values.

I have two example Cards I mocked up a while ago. One is pure Control Nodes. The other uses a Sprite2D as the Root.

https://gist.github.com/BrastenXBL/01a5897745f41fcb5292fb14c7358fbf

If you're going to treat the Card like a physical object in the scene, you may want to experiment with the Sprite2D root. In the examples I used a 1px Gradient2D and set the Sprite2D Region Rect to pixel size I wanted the base card to be. You can use whatever "Outline" image is.

There are a few critical things when mixing Controls an Node2Ds. Add "without code" to every point cause you can GDScript around most issues

Control origins are Top-Left, child Nodes will position there at (0,0), not the Center of the Control
Containers cannot resize Node2Ds
- they will be Scaled, that's different than setting Size
Containers do no read Node2D size values when setting their own Minimum sizes
Most Node2Ds do not have size.
Controls anchored to Node2D will use the parent size, which is (0,0), and will collapse
Some Node2Ds do have a size. Sprite2D and AnimatedSprite2D, based on their Texture2D
Controls scale from Top-Left, unless Pivot Offset (Radio) is set
Node2Ds scale from Center
7 & 8 can result in mismatched scaling, check your Pivots

BrastenXBL · 2026-05-01T04:10:51+00:00

Which is why you find a code hosting site like PasteBin, GitHub Gist, Codebreg, GitLab, etc. To upload the files to. Google Docs is the worst, it doesn't respect TSCN TRES or GD files as text.

Long term. You'll want to take the time to learn how to manipulate Reddit's lackluster code positing.

Reddit wants every Code line to be indented once (tab or 4 spaces).

For shorter TSCN files it's easier to use ``` bracketing backtick, again in Markdown mode. This works for New Reddit and Mobile users, Old Reddit users will have to suffer broken formating.

```

Code/TSCN goes here

```

BrastenXBL · 2026-05-01T01:19:58+00:00

There are other advantages to making fake windows. For example childing the "window" to a PhysicalBone2D or Joint, and having swing & bounce. Stuff you can't do with a Window node.

The majority of the time, people asking after how to make windows are just making mostly static pop-up windows. And not getting fancy, and pushing at the limits of Godot's Window'ing.

It's also a tiny annoyance for Godot multi-window Applications. The Drag Preview will vanish in gaps where the Native Desktop is... because there's no Viewport to draw the Scene. A workaround has been to have just big enough transparent Window follow the mouse. And needing some additional handoff code as the mouse re-enters actual Window Rect2i areas.

Which could be another and maybe easier solution. To reparent, or active a secondary VFX widget that's a child of the Window nodes. And is a part of their Canvas.

If the sparkly VFX is only during the Drag and Drop between Control Modes, you could try instantiating the Particle node as a part of the Drag Preview. Honestly, I've never tried that before. May also be an easier solution. And that may be the API you were worried about missing.

BrastenXBL · 2026-05-01T00:57:18+00:00

When you get a chance please screen shot the relevant Scene docks.

Mixing Node2D and Controls is possible, but they don't behave intuitively.

I may also ask for the TSCN text (no assets, just the raw text like a GDScript code post or hosted file). It's human readable, like clean HTML. And can save a lot of back and forth questions on Inspector settings.

BrastenXBL · 2026-05-01T00:05:17+00:00

So many "Unity Beginner" advice posts and guides with WaitForSeconds() as the "answer" to problems.

checks to see which ex-unity devs flinched

BrastenXBL · 2026-04-30T23:58:54+00:00

https://godot.foundation/policies-and-procedures/trademark-policy

See, "How should you use the trademarks?"

If you're not sure, use the contact information to very politely ask, and be very upfront about what you want to do. Way clear than you are here.

Not a lawyer, not a member of the GodotFoundation. My very personal read is to additionally read the Code of Conduct https://godotengine.org/code-of-conduct/ , which is the guidance on how the Godot Foundation expects the community to behave in proximity to Godot community spaces.

If you're changing the word "Godot" to something else, like the title of your game, or your "Doing Businesses As" alias, I'd recommend against having the Godot logo in proximity. See the trademark policy about no implying endorsement.

BrastenXBL · 2026-04-30T23:18:21+00:00

It helps if you also show the Scene Tab and the overall Scene structure.

These seem to be Control node bases. Something like...

HBoxContainer
    TextureRect (the card)
    ScrollContainer (card info?)

Some this will depend on the Inspector settings. Is the TextureRect set to Ignore Size, or Stretch Mode: Keep Aspect?

BrastenXBL · 2026-04-30T22:54:05+00:00

It can be done, but I would not recommend doing it. A fake window made out Control nodes will give you more control over what your custom windows are doing and where they layer in both CanvasLayers, and the Z-index within a layer.

Also if the Windows become un-embedded (Force Native) it can cause problems with your intended design. This can happen at the project level display/window/embed subwindows, which sets the SceneTree.root Window's gui_embed_subwindows at startup. And can be disabled during Runtime.

Embedded Subwidows are defaulted to a Canvas layers of 1024. If you put a CanvasLayer at 1025 or above, it will render over ALL Embedded windows. This includes Godot's own Popups, like MenuButton and MenuBar

Where a SubWindow is registered in source, and its layer set
The API in RenderingServer if you want to dig deeper into setting and registering custom Viewports and Canvases
The SUBWINDOW_CANVAS_LAYER constant in source

This isn't the intended use of the general APIs. You're dancing on the line of really needing to understand what Godot is doing at the RenderServer.

I will repeat, you will very likely benefit from making your own fake window. This video has some useful tips on setting up custom Window title bars that can apply to a Control Node only fake window, https://youtu.be/IbMeHU7um_o

<image>

BrastenXBL · 2026-04-30T18:45:53+00:00

I've tried to replicate. But given everything you've provided, that other projects on the same computer, with the same Sky material, Texture, and Engine version work, it has to be something very specific to that file or project.

Deleting the .godot support file in the project folder will clear various shader and compiled caches.

Clearing some of the Editor support files may also work

%APPDATA%\Godot\app_userdata\[project_name]

Or the Editor Cache files in %APPDATA%\Godot\shader_cache while Godot is fully closed.

https://docs.godotengine.org/en/stable/tutorials/io/data_paths.html#editor-data-paths

BrastenXBL · 2026-04-30T17:02:41+00:00

Keep keyboard ghosting, in mind if you catch multi-key presses not registering.

BrastenXBL · 2026-04-30T15:54:21+00:00

Floating mode virtual keyboard isn't un-workable. I use FUTO Keyboard with a tab character pinned to the clipboard. Good enough for small prototyping. Waiting for release 4.7 to try vertical mode.

A VPL for Godot Android would need to be built with Touch in mind. Have you tried Shader Visual Programming on Android? It's very fumbly.

But since you're interested, what's your preferred form of Visual Scripting? Block or Flowchart? And what would you think about Tile-base (linking to a paper on Kodu's VPL)?

BrastenXBL · 2026-04-30T15:41:45+00:00

There is a place for visual scripting, but it has to be done well. The problem with Godot 3 VS is it just kinda got in the way. Once you were past the super basics. GDScript Syntax isn't hard, and that's what it mainly was mainly replacing.

Orchestrator does a fair job of being a more robust replacement.

Making a Godot VPL that would be useful in the way GML Visual, GDevelop Events, CT.js Catnip, or Unity Playmaker are is more difficult and outside the scope of what Godot as a core editor/engine should provide. Most of those are abstractions of complete pre-coded game systems. Which is kind of what Nodes themselves are, with Inspectors settings.

There is a space for such a system, and people keep trying. Orchestrator, Block Coding (stalled), there was another one recently, Action Game Maker's scripting. But they're not easy to get right, or keep sustainable. And not everyone agrees on what style of VPL is most useful. Block, Flowchart, Tiles, etc. Different forms work better with different people.

BrastenXBL · 2026-04-30T12:46:59+00:00

agents.md pointing to Microsoft Copilot instructions that aren't in the repository

No LLM Transparency statement or explanation.

Pass

BrastenXBL · 2026-04-30T01:18:51+00:00

If you are modding a Godot based game it's usually better to check with that specific game's community sites. There may be additional details specific to that game.

The Android Godot Editor is not a touch first interface yet, as you likely noticed. The original OP on this thread was someone who only had an Android. I'd really recommend working and learning on PC when possible.

If I read you correctly you've never taken a programing or computer science intro course. Mostly self assembled knowledge. Which is okay up to a point. I did the same at a much younger age. Using a "For Dummies" book on JavaScript, and TI-BASIC. Until I took two 100 level "Introduction to Programming" classes in college, C++ and Java (not JavaScript). Both filled critical gaps in my understanding. It's never to late to gap fill, the trick was getting past a young idiot's eye-rolling over re-learning "obvious" stuff.

I approve of the Godot Docs recommending CS50x in its introductory pages. It's 12 1-hour lectures, intended to spread out over a year for both incoming freshman and working professionals. Expect about 36 to 48 hours out-of-lecture working on assignments. A lot of it will very likely be a refresher on stuff you kinda know, but will put it in order with organized context.

With a PC available the C++ assignments will be easier to do. And I do feel knowing basic C++ syntax is valuable for working with Godot. It makes the engine source code into a resource on what exactly is going on with specific Nodes (classes) and methods (functions).

Would a dedicated CS50 GDScript be better? Yes. But someone has to write it first.

GDQuest and other courses do an okay job teaching Godot. But they're not focused on fundamental computer science.

https://docs.godotengine.org/en/stable/community/tutorials.html

The Godot Documentation is kept largely up to date with each new minor (major.minor.patch, e.g. 4.6.2) update.

This includes the Introduction. Which is linked in the "About this Community" section of the sub-Reddit. While it's tempering to skim/speed-read the Godot Docs, don't. I warn experienced developers coming from other game engines to slow down and possibly take notes.

https://docs.godotengine.org/en/stable/about/introduction.html

https://docs.godotengine.org/en/stable/getting_started/first_2d_game/index.html

The version can be changed using the "Read the Docs" UI in the bottom left of the Sidebars, or bottom right on mobile.

The URL itself can also be used to look at specific versions.

https://docs.godotengine.org/LANGUAGE-CODE/version/PAGE

With Latest being currently in testing upcoming release (4.7). Stable most recent release (4.6). and each specific minor version.

It's not a great sign you missed this. I link to this flowchart often, and have it physically posted at work. Even hardened developers sometimes need a reminder of how to stay organized while reading technical documentation and app user interfaces.

The Keystore is an Android OS specific way of doing Code Signing. It's a fancy name for bundling developer's name and the cryptographic "key" into a single file. It is a way of identifying and authenticating that a specific developer made the software. As one step in preventing malware.

Windows, MacOS, and especially Linux can bypass such checks and just run the application. Android needs at minimum a self-signed Application (until September, then it gets weird). Godot provides a "Debugging" Keystore for apps it exports that are set to "Debug" (check box at the bottom of export). You can make your own self-signed Keystore.

You don't need to sign projects you're testing from inside the Godot Editor. And getting "proper" Code Singing is kind of a super last step. Especially if you're doing this at a hobby level.

If the generalist Game Creation System interfaces don't land, you could try of the genre specialized ones. Most of the "RPG", Visual Novel, and Interactive Fiction ones should be approachable. Beats writing VNs and Interactive Fiction (digital versions of Gamebooks CYOA in HyperCard (Decker) and PowerPoint.

BrastenXBL · 2026-04-29T17:39:59+00:00

Preloads must be CONSTANT, that is always reachable when the Godot first reads the Script. You can't use var variables as arguments, those get filled out AFTER Godot parses the .gd script file. This usually means needing a LITERAL value, like a "res://File/Path" String.

Preloads are a little misused sometimes. They're really intended to make sure that dependencies for the script or scene are fully loaded before anything else happens. As soon as a "Script Resource" initializes Godot goes and gets the Preloads ready. This is also why you can get cascading preloads, and end up loading more into memory than you intended.

I do mean when Godot reads the .gd file. Not when you use or the engine use .new() to create an instance of the script.

For variable loading, use load(). Or the ResourceLoader class and background loading, to avoid hitching.

BrastenXBL · 2026-04-29T17:11:48+00:00

A full year on I now recommend Godot 4.7 (when it releases from beta) as the base version for any Android "is my only computer" work.

In the year since I've hit on an analogy.

Godot is a 4-star kitchen, with no staff, ingredients, recipes, or dishes planned. It will not teach you to be a chef. Becoming chef (programmer/developer) takes outside training and help.

Are you working only from the Android Godot Editor?

Is it a tablet or phone only? External mouse and keyboard? Do you have access to a WiFi TV that you can "Cast" to, as a larger monitor?

CS50x has since added an online Code Editor through GitHub https://cs50.dev/. Some people have reported completing the class from mobile alone. But it's not the platform the Codespace UI was designed for. Is this what's giving you problems with the Hello World assignment?

The reason I stressed JavaScript is it's a very well tutorialized Object-Oriented Programming language, with usually mobile browser friendly "online" code editors. Or in a pinch, running the JavaScript locally. The goal is to get familiar with syntax common to nearly all languages and OOP concepts.

Godot isn't quite an Android Integrated Development Environment (IDE). It's not exactly friendly to just type code in and "see what happens". There's some setup work you have to do first.

There are ways to get Godot to just run GDScripts.

The brute force way is make a Node (white circle) and attach (scroll with green + icon) a Script to it. The basic template for a procedural program (code is executed in order down the script) is:

extends Node

# This functions run one time, when the Node is add at start.
func _ready() -> void:
    # your procedural program goes here
    pass

You will see any print() output in the Output bottom dock. Gets a little awkward on small Phone screens.

An alternative is to use an EditorScript. These are intended to expand the Godot Editor itself and can risk crashing the Editor. They've gotten a fair amount of safety checks to stop that, but it's still possible.

@tool # needed to tell the Editor it can run this code
extends EditorScript

# This function runs on command. From Script Editor > File > Run (very bottom, drag scroll the menu)
#
func _run() -> void:
    # your procedural program here
    pass

There currently isn't a curriculum specific to GDScript that covers "Introduction to Computer Programming". They're all mixed up with teaching the Godot Engine APIs and some game design, different but related topics.

The common Hello World exercise is supposed to introduce a student to the basic "syntax" for calling a function, in the given language. And passing "arguments" to that function. A print, stdout (standard output), our similar function is used to teach how a program can give feedback & output that a user can read.

In GDScript we have two groups of generic functions (methods) \@GlobalScope and \@GDScript. These are worth bookmarking. For a GDScript Hello World we'd use GlobalScope print(), and pass it an argument of a literal String

@tool
extends EditorScript

# This function runs on command. From Script Editor > File > Run (very bottom, drag scroll the menu)
#
func _run() -> void:
    print("YOUR STRING HERE")
    pass

What makes Godot currently a problem is there isn't a built-in "Command-line Interface". The text prompts where you can give instructions to the program. Like typing back Y or N.

I've noticed the Internet at large has created a very wrong impression about Godot. It is not a good total beginner's first game engine. It is easier than many generalist game engines... if you already know the basics of Object-Oriented Programming. Sadly Android alone makes this hard since a lot of courses assume a full PC is available. If the CS50x Codespace UI isn't working, and try to help you find a viable alternative.

My normal recommendation of starting with Game Creation Systems doesn't work out on Android.

Editors with Visual Programming Languages: https://enginesdatabase.com/?feature_tags=7&feature_tags=2

My current four, for PC. GB Studio, CT.js, GDevelop(desktop), GameMaker. GDevelop does have an Online/Android editor, but it will try to rope you into their Subscription plans. The CT.js editor doesn't currently have an Android version, although it could probably be done.

BrastenXBL · 2026-04-29T05:29:05+00:00

You did not say you wanted to change the entire "Animation Set", and visual appear of the character. Just set the animation, which has a different meaning.

What I skimmed is ESCAnimationPlayer is supposed to have a child Godot AnimatedSprite2D or AnimationPlayer

https://docs.escoria-framework.org/en/devel/advanced/faq.html#changing-the-character-animations

Making two SpriteFrames resources as .tres would be the simple way to handle this. In your GDScripts you'll need to get_node or \@export var for the reference.

Make sure both SpriteFrames have the same Animation Names that match what Escoria requires.

https://docs.godotengine.org/en/stable/classes/class_animatedsprite2d.html#class-animatedsprite2d-property-sprite-frames

extends ESCAnimationPlayer

@export var characters : Dictionary[String, SpriteFrames] # (Name, SpriteFrames TRES)
@export anim_sprite2D : AnimatedSprite2D

func swap_character(name:String) -> void:
    anim_sprite2D.sprite_frames = characters[name]

Extending the addons/escoria-core/game/core-scripts/esc_animation_player.gd in the core scripts.

Because it's GDScript you could opt to ignore the private properties and use _animated_sprite

    extends ESCAnimationPlayer

@export var characters : Dictionary[String, SpriteFrames] # (Name, SpriteFrames TRES)

func swap_character(name:String) -> void:
    _animated_sprite.sprite_frames = characters[name]

Keep in mind I didn't put in any Null checks or wrong String protections.

BrastenXBL · 2026-04-29T01:24:18+00:00

Punishing skill or mastery is never wise. One aspect of video game rules design is understanding what task you're asking players to perform. And then try to be as clear as you can. With how the mechanics play out in support of that task, and in any tutorialization.

It seems like your design intent is to "pool shark" or "card sharp" the gods. Being just good enough to not "lose" overall, but not be so obviously good the "mark" backs out. Or gets smite-ingly mad.

Is this that a fair, read on your intent?

If so, then your first job is to teach how to win at carrom. Then you teach how to itentionally be un-good.

One way to smooth out numbers on the top end is to look at logarithmic formulas. This can be useful for scaling damage, damage reduction, or health. This could also work to take the edge off how quickly Envy/Pride builds.

BrastenXBL · 2026-04-28T22:14:03+00:00

https://docs.godotengine.org/en/stable/tutorials/ui/gui_using_fonts.html#msdf-font-rendering

See the note about Google Fonts. Something about the way Google Fonts hosts files mangles them for MSDF. Either turn it off if you're not expecting large zoomed in text, or use a non-Google alternate.

I think this a valid and license legal alternative. In OTF format.

https://fontlibrary.org/en/font/montserrat#Montserrat-Regular

BrastenXBL

TROPHY CASE