Here’s a module for requiring modules without caching, and monitoring Source changes. A key difference from other implementations is that loadstring isn’t used. The killer feature is that breakpoints can be synced between copy and original, so debugging is possible.

https://github.com/Anaminus/roblox-library/tree/master/modules/ModuleReflector

Unfortunately, plugins can’t access the DebuggerManager, so the debugging method has to be invoked through the command bar. Fortunately, plugins and the command bar share the same _G table, so a plugin can expose it that way.

Have GuiButtons always passed mouse movement inputs or am I crazy? They sink mouse button inputs just fine.

Can’t even use GetGuiObjectsAtPosition to enforce sinking because plugin GUIs aren’t a descendant of any BasePlayerGui. This is fun.

Boring Facts: If Destroying is used to add a child to the destroyed instance, that child wont be destroyed.

“According to our analytics, no one was using the setting to opt out of telemetry, so we decided to remove it.”

Certain input types have to be handled in certain ways. Key repetitions must be handled by monitoring the key’s InputObject, while mouse wheel input is best handled by getting it from a source, because an emission from a source doesn’t always correspond to a property change.

Boring Facts: The Position of a Keyboard InputObject will update with the position of the mouse while the key is held down.

Correction: Only some keys do this, including the arrow keys, Return, Backspace, and Delete.

Further correction: this is caused by key repetition. Generally, a keyboard object will update with the position of the mouse. However, certain keys that repeat will switch to the End state, then immediately back to the Begin state, and repeat again while the key is held down.

Boring Facts: Keyboard InputObjects are reused per KeyCode, but only while the current source (e.g. UserInputService or a GUI) is in focus.

Widget to visualize how InputObjects are produced. Whenever a new object is made, it is added to the list, then monitored for changes. Each Source+UserInputType+KeyCode combination produces its own object. Sources used are the Input signals from UserInputService and a Frame GUI.

A unique advantage of ScrollingFrames over a custom implementation is that the scrollbar can track the mouse across the entire screen, not just the viewport.

Correction: This isn’t unique: the behavior applies to InputObjects, but only while a mouse button is held down.

Fusion widget to help narrow down what StudioStyleGuideColor a studio element is using.

A port of my “lattice” container GUI to Fusion. Takes a grid of columns and rows defined as constant pixels or fractional values, and turns them into static UDim2s. Has options for padding, margins, and a visualizer for debugging.

furiously begins authoring the “If-Expressions Considered Harmful” paper

The Roblox API Reference hasn’t been updating since the start of June, but it should now be working normally again. https://robloxapi.github.io/ref/updates.html

Definitely kicked up some dust trying to fix it. Can’t wait to rewrite it.

Game: depicts hand-holding

Roblox: this game is rated 17+

Operation Radio Silence to Improve Chances of Securing my Discord Username was a resounding success.

The -> operator is unergonomic to type and almost always looks like shit but new languages will always find an excuse to include it because teehee it’s an arrow.

stop [clap] using [clap] child [clap] indexing

The entire problem is that the operation isn’t forward compatible. Either we can’t index children, or Roblox can’t add new class members.

At this point, I’m just gonna call it: VM with GPU passthru is dead. Long live KVM switches.

https://devforum.roblox.com/t/proper-support-for-the-linux-platform/56544/88

Surely we’re past punishing users for playing our games in ways we don’t like.

Theory: The reason player characters move at different speeds from NPCs is because the PC has been calibrated on the player’s perception. PCs can’t move as slow as NPCs because it would feel sluggish, and NPCs can’t move as fast as PCs because it wouldn’t look realistic.

It occurs to me that twitter will probably silently nuke shit out of this tweet. If you are one of the lucky few to see it, hi!

Instead of trying to work out a good-but-hard design from scratch, just start with a bad-but-easy design. Refactoring a bad design into a good design is rewarding and creates momentum.

Hot Take: The table.clone-type immutable data libraries that people keep making are actually just table utility libraries with immutability add in for vague reasons. They don’t actually do any of the heavy lifting involved in making immutable data efficient.

boolean := "true"
         | "fake"

boolean := "right"
         | "false"

Been rewriting rbxfile. I think I’ve got property type implementations abstracted down to something satisfying. “it” stands for “iterator”, so this could be considered a pun.

func (it *itRect) ReadValue() (v values.Rect) {
	v.Min.X = it.reads.rf32b()
	v.Min.Y = it.reads.rf32b()
	v.Max.X = it.reads.rf32b()
	v.Max.Y = it.reads.rf32b()
	return v
}

func (it *itRect) WriteValue(v values.Rect) {
	it.writes.rf32b(v.Min.X)
	it.writes.rf32b(v.Min.Y)
	it.writes.rf32b(v.Max.X)
	it.writes.rf32b(v.Max.Y)
}

Tip for using WireframeHandleAdornment: The Color3/Transparency of the adornment only affects newly added lines, so you only need one adornment to draw lines with any appearance.

The screen/viewport split was one of the biggest blunders Roblox ever made.

Visualization of an r-tree. WireframeHandleAdornment is essential for debugging.

It’s harder to draw shapes, but it’s way better than keeping track of a million handle adornments.

My local news on balloons: Here’s some old information that we repeated yesterday and the day before. We’ll be sure to keep you up to date on the latest nothing that’s unfolding.

My local news on catastrophic industrial disasters: That happened. Here’s the weather.

Roblox allowing things like profanity will actually make the writing of angry characters worse.

Renamed enum items are “removed” from the API, but still stick around as an alias to whatever replaced them.