Zizaco's Forum Posts

  • Are you using a vps or something similar?

    No. Are you?

    If you are, what is the VPS you're running on?

    Bear in mind that vCPUs in a VPS are considerably slower than your typical CPU core in a desktop PC or laptop. VPS are virtualized environments that provide access to only a small portion of the actual CPU, which can lead to spikes up to 100% utilization even during relatively light CPU tasks.

    For example, don't be fooled by "8 vCPU cores", expecting it to perform similarly to a 13th-gen Intel Core i5-13420H (8 cores). The performance difference between these two can be significant (several orders of magnitude).

    You should perform a CPU benchmark on both your local PC and your VPS to at least have an idea of what to expect.

    For improved CPU performance, consider bare-metal hosting (instead of a VPS). It provides direct access to the physical CPU hardware, rather than sharing pooled CPU in the form of "vCPUs".

    Edit: I'm curious to what your reasoning is for having dedicated hosts vs letting player hosts their own rooms?

    An alternative would be to have player hosts rooms while all peers (and the host) are also connected to a central server for the features that need to be centralized (not synchronized at 30 times a second).

  • There's Master Pose (Spanish, but with English dub/sub)

  • No headless browser, but multiple C3 instances without problems: construct.net/en/forum/construct-3/general-discussion-7/construct-multiplayer-187718

    Could be an issue with your implementation (Playwright, node, etc...)

  • Yes, it is possible. You can open the multiplayer examples and the docs to check it out.

  • I just added support for it as well as an example

    Brilliant!

    The example doesn't compile properly when Shader Language is WebGPU or OpenGL2:

    Unhandled Rejection: Error compiling fragment shader: ERROR: 0:34: 'varying' : Illegal use of reserved word

    (It does work with OpenGL1)

  • Try Construct 3

    Develop games in your browser. Powerful, performant & highly capable.

    Try Now Construct 3 users don't see these ads

  • Interesting. I believe we'll see some kind of official MCP server in the future.

    However, this seems heavily "vibe-coded" and quite problematic, as it modifies the project .json files directly without going through the editor (as described here).

    It appears to have started as a Read-only MCP, and now is branching into Editing/modifying projects (as seen by some commits fixing "breaking project" bugs).

    Besides not syncing with the editor, this can cause all sorts of issues and project corruption. The MCP will modify things in an unsupported way, without proper checks or using supported APIs. (For example, in-editor event sheets are type-safe. If you're directly editing a project's .json file, you are one keystroke away from corrupting your project)

    Before using this, make sure you're using git, since it's very likely that it will break/corrupt your project and you'll have to have some sort of rollback-and-retry process.

    (edit: I looked into the source code, and it doesn't look good. It even has its own image pipeline that mimics the behavior of the construct editor. This can silently corrupt your project and lead you down a path where you're unaware of what went wrong. Personally, I think a MCP/skills that interacts with the editor through the browser would be a better approach atm.)

    Personally, I just:

    • Asked my coding agent to read the docs and create my own "Read-only Construct Skill" to read my project.
    • Make projects mostly TypeScript-based. TypeScript is a very easy language for LLMs/agents to work with reliably without breaking the code. Construct's TypeScript support is phenomenal, as it provides all necessary type definitions.
    • Still handle "editor-centric" tasks myself, although you can let your agents use Playwright/Browser MCPs for some limited, repeatable tasks.

  • It would be amazing to have the new world position (introduced in v480) available!

  • The difference:

    • EventSheets are more accessible for non-developers.
    • EventSheets state is integrated with the "Save & Load" actions (if you use JS, you need to handle state yourself).
    • EventSheets are mostly type-safe, which helps prevent type-related bugs. (If you use TS instead of JS, you'll also get type safety.)
    • EventSheets are not so practical and can get quite verbose for more complex logic. (compared to JS/TS)
    • EventSheets are more difficult to copy & paste and share. Because of how its type safety works, it can block you from pasting in certain situations.
    • Currently, EventSheets are not well understood by AI. The level of AI assistance you'll get is more limited.

    It's worth highlighting that you can use both at the same time: simple logic in EventSheets and JS/TS for more complex or intricate logic.

    You can call EventSheets from JS/TS using runtime.callFunction(name, ...params)

    and you can also interact with your JS/TS from EventSheets via scripts in actions and importsForEvents

  • Can you explain how?

    How I changed my mind

    Be impartial, challenge/review your own beliefs, and be the devil's advocate against your own skepticism. This will make you evolve. The biggest "lightbulb moments" in my software career came from truly trying something I was skeptical about.

    How AI agents can truly boost productivity in a meaningful way

    I could write a novel about this... In summary, if you are a senior developer and have the proper workflow, you can feel like you're chatting and reviewing Pull Requests made by a team of Mid/Junior developers. Including them asking you questions you didn't even think to ask about how to proceed with an implementation.

    Of course, you need to write specs and establish best practices (for example, AGENTS.md). But a true Senior+ developer understands the importance of these things regardless of AI use.

    You will still need to read, understand, and review the code, and likely handle the most difficult parts. However, working with a "team of Mid/Junior developers" significantly boosts your productivity. Meaning, AI can only be as good as you are yourself.

    How to filter out the hype

    Look for balanced takes from experienced developers. It's not easy to filter out all the newbie "vibe coding" crap, but if you succeed, you'll notice that top developers are already integrating AI into their workflows (and recognizing its advantages).

    Some examples: 1, 2, 3, 4 (game-dev example), 5, 6

    warning: As of today, if you're still a junior developer, unsure about how to code a feature, write specs, write self-documenting code, how to do test automation, work with git & pull requests. Then you'll probably be frustrated if you try to use AI... However, this can say more about your current skill level than the AI workflow.

    Again, in the context of Construct, it's important to be prudent and wait for the conventions to be better established before putting work into making it "AI-ready".

  • AmogusJS A few months ago, I would have agreed with you. I understand your skepticism about AI, and I was on the same page as you are. However, after giving it an honest try, I’ve come to see that, once you get the hang of it, AI agents can truly boost productivity in a meaningful way.

    context: 20+ years building software professionally.

  • I think an official Construct MCP server (that essentially allows existing AI agents, such as Claude Code, GitHub Copilot, Gemini-CLI, etc., to interact with the Construct editor) would be a great way to provide the "foundation" for folks to develop Skills and feed examples into it.

    I don't consider this a priority at the moment, but given the direction things are developing, building an MCP server appears to be the most "future-proof" and "user extendable" method to support those interested in using AI.

    IF AI conventions remain consistent, it is reasonable to consider an MCP server as part of the roadmap within the next 1~2 years.

    I agree with Ashley. Things are evolving rapidly. Those who invested in an "AI chat" interface in their product have essentially created something costly and ineffective, as conventions have shifted towards MCPs now. So it's important to be prudent and to wait for the conventions to be less flaky/unstable before putting work in this area.

    It's quite likely that the Construct team is already exploring Agentic coding internally, just like many other development teams. First-hand experience and having time with it will be really valuable for when the moment comes to introduce a Construct MCP (or other ways to support AI workflows).

    BTW: Those who don't want to wait, consider using Construct with TypeScript. The current AI toolchain (for instance, Claude Code) is quite capable of parsing the documentation and utilizing the TypeScript type definitions exported by Construct to handle most use cases.

  • It is possible without external addons. You'll have to set up all the events to handle Z elevation yourself (gravity, jump, block heights, and collision). There's literally a user working on a Landstalker remake here in the forums: construct.net/en/forum/construct-3/your-construct-creations-9/landstalker-remake-183858 & youtube.com/watch

    Unfortunately, there's no easy way around it. As a reference on how to achieve this, you can look for the `3D Platformer` example, specifically in the "Update the entire 3D physics system for the player." block of the Gameplay event sheet. (`Avalanche` is another good example of how to handle the Z axis)

    If you were to do this in a pure 2D game, you'd have to replace the Z (Z Elevation) with an Instance variable that tracks the height of each block. Probably in a Family of block objects.

    Or, you could stick with Z Elevation and make a 3D game using `Ortographic projection` in such a way that it looks like a pure 2D game.

  • I quickly reviewed the Android exported options of the latest Construct version (r470). Here are the available options:

    Min.version options:

    • 7.0+ (Nougat)
    • 7.1+
    • 8.0+ (Oreo)
    • 8.1+
    • 9.0+ (Pie)
    • 10.0+
    • 11.0+
    • 12.0+
    • 13.0+
    • 14.0+
    • 15.0+

    Android build options:

    • Cordova project
    • Android Studio project
    • Debug APK
    • Unsigned release APK
    • Unsigned Android App Bundle
    • Signed debug APK
    • Signed release APK
    • Signed Android App Bundle

    Documentation can be found here.

    Don't hesitate to check the mobile examples here. (-> Browse examples -> Tags -> "Mobile", then remove "Recommended" tag)

  • I need to update/polish/document my multiplayer template to make it easier for others to understand. After completing this, I might share the entire C3 project.

    For now, here's a demo:

    Subscribe to Construct videos now

    [info: hosts disconnects at 0:11 and 0:37. Net code speed: 1 sync per second]

    In short, here's how the seamless host-switch works:

    • Peers exchange messages about the name of the "fallback room" and which peer has priority on becoming the host. (sorted based on ping)
    • If a disconnect happens, they try to connect to the fallback room with a delay equal to their priority on becoming the host. (so the client with higher priority can create the room first)
    • Host and peers exchange custom messages to ensure objects are in sync.

    For this to work smoothly, the project doesn't rely on the native Sync object. Network objects are part of the "Network objects" family. This special family have instance variables dedicated to my own network synchronization messages (network_id, peerid, local, posX, posY, sync_frequency, sync_last), and I interpolate their position (move-to, tween, pathfinding) based on my own given network_id to know which object is which.

    (Sounds complicated, but it's relatively simple)

    Here's how it's set up in the layout:

    1. Invisible "Room Manager Object" defines the base roomName to connect to, maxPeers, and net_code_speed. On start of the layout, the game uses this object to know how to handle multiplayer for this given "region" in the game. In a dungeon, I can set it up for faster (example: 15 times a second) and 8 maxPeers, while in a city, I can make its net code speed lower (once every 2 seconds) and allow for 32+ maxPeers. (In the video above, the net code speed is set to once per second, creating a latency between peers... which is intentional (to save bandwidth). If I increase it to 30 times per second, the latency between clients becomes nearly imperceptible). This object also hold the fallbackRoomName that is kept in sync on all peers
    2. Invisible "Network object/family" synchronizes the general position and behavior for a group of monsters. Which player are they targeting, HP of each child, etc. Synchronized using my custom messages, according to the settings on the "Room Manager Object". This object continuously sends messages about its position and actions (attack, die, etc.), which are queued/dequeued by the clients. It's the "brain" of things that have to be synchronized over the network
    3. "Offline object" the client manages these. They stick close to the parent ("Network object") and try to follow its commands in a deterministic way (random seed shared between all peers). Since these are local to the client, their movements are fluid, and the player can interact with them "in real-time".

    Since I want a more action-based combat, the host can temporarily make "Network object" local to the clients. With this, the client becomes the authoritative "owner" of the enemies targeting the player (pathfinding, quick reaction, etc), and sends messages to the host. This way, the action combat seems very fluid for the player while using very little network bandwidth (way less than the minimal Sync object's 30 times a second bandwidth profile).

    It would be easy to add a central server (which could be an HTTP server) to persist major data across players' rooms... this would allow for a multiplayer gameplay/architecture similar to No Man's Sky, which feels like an MMORPG without many of the common downsides of the genre.

  • I remember you were not so excited about 3D Features 😅. It turns out 3D Models are pretty versatile!

    Thank you for sharing! I vaguely heard of Moho and didn't know it could be used as a Spine alternative.