8 ms·

SimCity in the web browser using WebAssembly and OpenGL

254 points by tambourine_man 2y ago

gnfedhjmm2 2y ago
It’s funny I was thinking about writing some browser based games using Pyscript with web assembly. But now I think by the time I finish the games they’ll have ported enough of Python into web assembly that I might as well write it with Kivy or Pygame and then it would be cross platform. Pygame already in the browser, but slow and clunky IMO. In 6 months who knows?
- nextaccountic 2y ago
  Don't let analysis paralysis deter you from writing games. Pyscript is fine. Other stuff is fine too. Pick whatever technology you want, and make quick games with rapid prototyping. Join some game jams and keep your scope small. It's better to create and ship many small games. About pygame in the browser: check out pygbag.
  - gnfedhjmm2 2y ago
    Would like technical thoughts, not cheerleading. I’ve written many games before just not with a new shaky stack.
    - JKCalhoun 2y ago
      Some of us appreciated the cheerleading though. :-)
    - nextaccountic 2y ago
      Oh but in technical terms my thoughts are completely opposite. Python wouldn't be my first choice for games in general, and much less for web games. Really the only way to justify using Python in this domain is if you're more comfortable with Python than other languages, and what you are building is a small, lightweight game. But this is reason enough to validate the idea! So if you want to build a game with Python, go for it. But if you're minimally comfortable with Typescript it would be a seriously better fit for this domain. Something like https://github.com/pixijs/pixijs https://github.com/pixijs/pixijs will work much better than Pygame or anything. It's geared towards simple 2D games too. One reason for that is dependencies. By using Python with Pyscript you will be constrained with what libraries you can use, because not all of them is compatible with Pyscript. (I myself am more comfortable with Rust, and Rust libraries like https://github.com/not-fl3/macroquad https://github.com/not-fl3/macroquad can target browsers, desktop and mobile; and it's also meant for simple 2D games. And I prefer the Rust ecosystem of libraries, too)
super_linear 2y ago
https://github.com/SimHacker/MicropolisCore https://github.com/SimHacker/MicropolisCore
modeless 2y ago
Porting old games to the web is fun! Many are smaller than a typical modern webpage. They load fast and run great. I just ported Quake 3 and I'm having some fun with it: https://thelongestyard.link/ https://thelongestyard.link/
- geuis 2y ago
  That was a lot of fun and a blast from the past. Thanks for porting that.
  - modeless 2y ago
    Thanks! This is loading just the demo assets, but I got the Emscripten support merged into upstream ioquake3 so you can check out the code, build it yourself, and with the right game asset files you can play the full game, Team Arena, mods, or whatever. https://github.com/ioquake/ioq3/pull/658 https://github.com/ioquake/ioq3/pull/658 The only major feature missing from the original game is networking. Obviously kind of important for Quake 3. Should be possible with WebRTC DataChannel. And while the original game didn't have it, for the modern web a touchscreen control scheme is essential since half of everyone is on their phone. Of course it won't be great compared to mouse/keyboard but some mobile support is better than none. So those are the two features I'd like to add (besides performance optimizations; it's a bit slower than it should be for some reason).
    - hauxir 2y ago
      check out https://openarena.live https://openarena.live its open arena running on humblenet which does take advantage of webrtc/p2p
- Jyaif 2y ago
  That input latency is why I hate browsers when making games. Great job though!
  - DonHopkins 2y ago
    If you refactor and structure your code in the right way, you can get it to perform pretty well. What will kill you is stacking up layers of emulation, so you're feeding browser input into a Windows or Mac emulation layer, and even an x86 instruction set emulator, plus a useless obsolete operating system "middle ware", because the way input and animation works on old desktop guis is a lot different and much less efficient that how it works in the browser. It's certainly possible to run the original version of Mac or Windows SimCity in the browser inside a Mac or Windows emulator inside a WebAssembly module, but not only is the user interface itself terrible, klunky, and awkward, it's extremely slow and flakey because it's emulating all that obsolete operating system crap and instruction set underneath all the web browser crap between your mouse clicks and the game engine. Since the web browser is so much better and more flexible at user interface and graphics stuff, you want to totally strip all of the user interface and graphics and sound out of the game, implement an efficient API and callback mechanism (that doesn't spend a lot of time thunking and marshalling and unmarshalling parameters, and pass simple primitive data types, sending what you need all at once, instead of ping-ponging back and forth with proxy objects), and implement all of the UI in the browser (especially the animation timers and input handlers), calling back to the simulator only when necessary. One thing I did was to use shared memory between the WebAssembly module and the WebGL tile renderer, and write a custom shader that understands the native 16 bit unsigned int column major SimCity tile format, so WebGL only has to draw two triangles, and there is zero copying to draw the tiles.
_ache_ 2y ago
Seriously, I'm stun about what happen if you it the space bar. Nice fractals.
- DonHopkins 2y ago
  Game Helpin' Squad's review of World Quester 2 is the inspiration for the Space Inventory, and I aspire to design the Micropolis menus and user interface to be as freaking awesome as World Quester 2! https://www.youtube.com/watch?v=0Gy9hJauXns https://www.youtube.com/watch?v=0Gy9hJauXns
detuks 2y ago
A while back ported RuneScape client to web. https://play.rsps.app/ https://play.rsps.app/ Wasm, Typescript and WebGL
simonebrunozzi 2y ago
Wondering whether an LLM could be able to port a game like this instantly.
- DonHopkins 2y ago
  Good question, please don't downvote -- there's an interesting discussion to be had about that! The best approach is to use it like any other tool, and not expect it to do all the hard work for you, just relieve you of a lot of tedious work, and help you learn how to be a better programmer yourself, not replace you. There's no such thing as a free lunch, but some lunches are tastier and more nutritious and less expensive than others. I've been using ChatGPT to develop it, and it's helped a lot, and takes a great deal of iteration and guidance, but it's anything but instant. LLMs won't replace programmers, but programmers with LLMs will replace programmers without LLMs. Here's an example of how it was helpful in simply explaining the documentation and best practices of tools like Emscripten and Embind, getting the makefile to work, analyzing the code, categorizing methods and instance variables as private and public (to be wrapped by embind), generating the boilerplate Embind declarations, and writing the documentation through a back-and-forth discussion of goals and requirements, and acting like a glorified grep that actually understands the code syntax and accepts English queries instead of obscure command line arguments. The comments at the top (included below) were mostly written by ChatGPT in response to me writing the strategy, telling it in detail what I wanted to do, describing my goals, and how I wanted it to work, with lots of iterating and refining and hand editing: https://github.com/SimHacker/MicropolisCore/blob/main/MicropolisEngine/src/emscripten.cpp https://github.com/SimHacker/MicropolisCore/blob/main/Microp... The process was anything but automatic or instant -- in total it took about 33 years (and counting, I'm not done yet). I had to guide ChatGPT a lot, drawing from my previous experience porting the Mac version of SimCity to HyperLook on the NeWS window system in 1991, and other platforms later on. At the time I considered using a Mac compatibility library for X11, but that would have resulted in a terrible klunky user interface, could not have taken advantages of the Sun Workstation Unix programming and user interface environment (networking, big screen, better window management, pie menus and other nice user interface components, scalable color PostScript graphics and fonts, using native file formats for resources, audio mixing, lots of computing power to animate fast and zoom into the map, run the simulation super fast by skipping screen updates, profiling and optimizing the code, etc), tied the game to a proprietary library that is long obsolete, and would have only supported X11, not NeWS. For a game like SimCity, it was well worth throwing away the Mac UI, cleaning up the simulator to be independent of the UI, and writing a new high quality UI for HyperLook in NeWS (then later another for TCL/Tk in X11). Porting it to NeWS required separating the simulator from the user interface and defining a clean network API and shared memory raster animation library, rewriting the user interface in PostScript, and defining a messaging protocol between the simulator and UI. Then a few years later I ported that to TCL/Tk on X11, refactoring the simulator/UI messaging interface into TCL extensions. TCL/Tk made it possible to develop a networked multi-player version of SimCity. X11 SimCity Demo: https://www.youtube.com/watch?v=Jvi98wVUmQA https://www.youtube.com/watch?v=Jvi98wVUmQA Multi Player SimCityNet for X11 on Linux: https://www.youtube.com/watch?v=_fVl4dGwUrA https://www.youtube.com/watch?v=_fVl4dGwUrA TCL Doc: https://github.com/SimHacker/MicropolisCore/blob/main/notes/DocTCL.txt https://github.com/SimHacker/MicropolisCore/blob/main/notes/... Callbacks: https://github.com/SimHacker/MicropolisCore/blob/main/notes/CALLBACKS.txt https://github.com/SimHacker/MicropolisCore/blob/main/notes/... A couple of decades later, we made SimCity open source, released the TCL/Tk/X11 version for the OLPC and Linux, then I cleaned up and overhauled the simulator code into C++, and used SWIG to define the API and a callback mechanism, so I could plug it into Python. Micropolis Core: https://github.com/SimHacker/micropolis/tree/master/MicropolisCore https://github.com/SimHacker/micropolis/tree/master/Micropol... Refactoring the code as C++ really helped modularize and organize it, made it easy to use doxygen to generate documentation, and much easier to wrap and port to different platforms. Doxygen documentation (current): https://micropolisweb.com/doc/ https://micropolisweb.com/doc/ Development Plan (old): https://github.com/SimHacker/MicropolisCore/blob/main/notes/DevelopmentPlan.md https://github.com/SimHacker/MicropolisCore/blob/main/notes/... OLPC Plan (old): https://github.com/SimHacker/MicropolisCore/blob/main/notes/PLAN.txt https://github.com/SimHacker/MicropolisCore/blob/main/notes/... To Do (old): https://github.com/SimHacker/MicropolisCore/blob/main/notes/TODO.txt https://github.com/SimHacker/MicropolisCore/blob/main/notes/... User Interface Plan (old): https://github.com/SimHacker/MicropolisCore/blob/main/notes/UserInterfacePlan.txt https://github.com/SimHacker/MicropolisCore/blob/main/notes/... OLPC Notes (old): https://github.com/SimHacker/MicropolisCore/blob/main/notes/OLPC-notes.txt https://github.com/SimHacker/MicropolisCore/blob/main/notes/... I implemented a couple of Python user interfaces, including a desktop based PyGTK/Cairo/X11 interface, and a web based TurboGears/AMF/OpenLaszlo/Flash client/server interface. Micropolis Online (SimCity) Web Demo (old): https://www.youtube.com/watch?v=8snnqQSI0GE https://www.youtube.com/watch?v=8snnqQSI0GE Bil Simser used SWIG it integrate the simulator engine with C#. (SWIG's point is to integrate C++ code into many different scripting languages, not just Python.) C# Micropolis: https://github.com/SimHacker/micropolis/tree/master/MicropolisCore/src/csMicropolis https://github.com/SimHacker/micropolis/tree/master/Micropol... After all that work, and writing and executing on the design documents linked above, I had a pretty good idea how to prompt ChatGPT to write a design for the Emscripten/Embind API, and it was helpful for writing the boilerplate code, and validating the design, but not so much for coming up with the design in the first place. Beyond refactoring and wrapping the API, ChatGPT has also been extremely useful for learning the intricacies and best practices of TypeScript, SvelteKit, node, WebGL, canvas, CSS, HTML, etc, for developing the user interface. //////////////////////////////////////////////////////////////////////// // This file uses emscripten's embind to bind C++ classes, // C structures, functions, enums, and contents into JavaScript, // so you can even subclass C++ classes in JavaScript, // for implementing plugins and user interfaces. // // Wrapping the entire Micropolis class from the Micropolis (open-source // version of SimCity) code into Emscripten for JavaScript access is a // large and complex task, mainly due to the size and complexity of the // class. The class encompasses almost every aspect of the simulation, // including map generation, simulation logic, user interface // interactions, and more. // // Strategy for Wrapping // // 1. Core Simulation Logic: Focus on the core simulation aspects, such // as the methods to run the simulation, update game states, and handle // user inputs (like building tools and disaster simulations). This is // crucial for any gameplay functionality. // // 2. Memory and Performance Considerations: JavaScript and WebAssembly // run in a browser context, which can have memory limitations and // performance constraints. Carefully manage memory allocation, // especially when dealing with the game's map and various buffers. // // 3. Direct Memory Access: Provide JavaScript access to critical game // data structures like the map buffer for efficient reading and // writing. This can be done using Emscripten's heap access functions // (HEAP8, HEAP16, HEAP32, etc.). // // 4. User Interface and Rendering: This part might not be necessary to // wrap, as modern web technologies (HTML, CSS, WebGL) can be used for // UI. However, providing some hooks for game state (like score, budget, // etc.) to JavaScript might be helpful. // // 5. Callbacks and Interactivity: Ensure that key game events and // callbacks are exposed to JavaScript, allowing for interactive and // responsive gameplay. // // 6. Optimizations: Where possible, optimize C++ code for WebAssembly, // focusing on critical paths in the simulation loop. // // Decisions and Explanations // // - Excluded Elements: // // - Low-level rendering or platform-specific code, as this can be // handled more efficiently with web technologies. // // - Parts of the code that handle file I/O directly, as file access // in a web context is typically handled differently (e.g., using // browser APIs or server-side support). // // - Any networking or multiplayer code, as web-based // implementations would differ significantly from desktop-based // network code. // // - Included Elements: // // - Core game mechanics, such as map generation, zone simulation // (residential, commercial, industrial), disaster simulation, and // basic utilities. // // - Game state management, including budgeting, scoring, and city // evaluation. // // - Direct memory access to critical structures like the map // buffer, allowing efficient manipulation from JavaScript. // // - Essential callbacks and event handling mechanisms to ensure // interactivity. // // Conclusion // // Given the complexity and size of the Micropolis class, wrapping the // entire class directly is impractical. However, focusing on key areas // essential for gameplay and providing efficient interfaces for // critical data structures can create a functional and interactive city // simulation in a web context. Further optimizations and adjustments // would likely be needed based on testing and specific requirements of // the web implementation. // // Implementation Notes // // The enum_, class_, constructor, function, and property functions // from the emscripten namespace are used to specify how C++ // constructs should be exposed to JavaScript. You can use these to // control which parts of your code are accessible and how they should // be used from JavaScript. // // I've made some assumptions here: // // The types MapValue and MapTile are simple types (like integers or // floats). If they are complex types, they would need their own // bindings. // // I'm assuming that the copy constructor and copy assignment // operator for the Position class are correctly implemented. If // they aren't, then the Position object may not behave as expected // in JavaScript. // // Micropolis Binding Design // // The Micropolis interface organizes the Micropolis class header into // categories of functions that are relevant for interaction with the // JavaScript user interface, scripts, or plugins. The aim is to expose // functions that could help in monitoring and controlling game state // effectively. //
DonHopkins 2y ago
Micropolis Web Demo 1: https://www.youtube.com/watch?v=wlHGfNlE8Os https://www.youtube.com/watch?v=wlHGfNlE8Os Micropolis Web is the browser based version of Micropolis (open source SimCity), that uses WebAssembly, WebGL, and SvelteKit. Based on the original SimCity Classic code, designed by Will Wright, ported by Don Hopkins. This first demo shows an early version that runs the WebAssembly simulator and animates the tiles with WebGL, but most of the user interface is still a work in progress. Live MicropolisWeb Site: https://MicropolisWeb.com https://MicropolisWeb.com GitHub Repo with source code and documentation: https://github.com/SimHacker/MicropolisCore https://github.com/SimHacker/MicropolisCore Much more Info in Chaim Gingold's book, "Building SimCity": https://mitpress.mit.edu/9780262547482/building-simcity/ https://mitpress.mit.edu/9780262547482/building-simcity/ Chaim Gingold's "SimCity Reverse Diagrams": https://smalltalkzoo.thechm.org/users/Dan/uploads/SimCityReverseDiagrams.pdf https://smalltalkzoo.thechm.org/users/Dan/uploads/SimCityRev... Micropolis Web Space Inventory Cellular Automata Music 1: https://www.youtube.com/watch?v=BBVyCpmVQew https://www.youtube.com/watch?v=BBVyCpmVQew Micropolis Web is the browser based version of Micropolis (open source SimCity), that uses WebAssembly, WebGL, and SvelteKit. Based on the original SimCity Classic code, designed by Will Wright, ported by Don Hopkins. This first video has music by Juho Hietala, Blamstrain, and the Space Inventory Cellular Automata is performed by Don Hopkins. Music by Juho Hietala, Blamstrain: https://blamstrain.com/ https://blamstrain.com/
- ziggy_star 2y ago
  Mr Hopkins you are by far one of my favorite posters on this website and these sort of comments are golden. On occasion they get appropriate engagement but sometimes there are no replies. You should know that it does not go unnoticed. The breadcrumbs you leave will be followed by youngsters far into the future, a worthwhile endeavor. Thank you for brightening my sunday and everything you’ve done and your efforts at documenting and preservation. While HN is not what it used to be I consider you royalty and old school users like yourself are the reason many of us still frequent this place. You are appreciated sir. Cheers.
  - DonHopkins 2y ago
    Thank you! It feels great to have finally gotten the code working well enough that other people can use it, and to hear your kind feedback! It makes it all worthwhile. I've gotten so much pleasure just staring at the cellular automata for hours on end that I wanted to make that work and share it, even if you can't play the game yet. It will be even more fun once I get the city editing tools and disasters menu working, so you can bulldoze and draw roads and buildings and release monsters to stomp around and cause other disasters in the cellular automata! They're also useful for building and destroying cities, too, but painting in the live cellular automata is even more fun. Here's an old blurry video of that on the X11 version: Cellular SimCity: Cellular Automata in SimCityNet on Unix. https://www.youtube.com/watch?v=P8KJ--drZO8 https://www.youtube.com/watch?v=P8KJ--drZO8
parasti 2y ago
This is cool. I didn't expect much on mobile (hey it's Simcity), but this page actually froze Firefox for me, on Android. Had to kill the process. That happens rarely. BTW, here's a little game that I ported to the browser. Getting it to run was very straightforward (Emscripten+SDL2 is a great combo), but honestly making it fully playable on a phone took the most effort: https://play.neverball.org/ https://play.neverball.org/
- DonHopkins 2y ago
  I fully intend to make it support mobile! And I already fixed one bug that prevented it from running on Firefox on Ubuntu, thanks to a well written bug report that included a stack trace. Give it another try, maybe it works now, and if not, please report the bug and include a stack trace and any information about your platform. https://github.com/SimHacker/MicropolisCore/issues/1 https://github.com/SimHacker/MicropolisCore/issues/1 I wanted to release this as soon as possible so other people could run it, instead of waiting until it was finished and perfect, so there's a lot more work to do on the user interface, robustness, cross platform support, mobile, etc. But once I got the simulator and tile renderer working, I threw together a minimalistic zooming panning + keyboard control interface, and a little window with hints that you can close by clicking the "+" button in the upper right corner. What I'm really looking forward to doing is integrating it with visual programming languages like Snap! so you can live code it and write plug-in zones, robots, monitoring and control systems, data visualization and export (i.e. Grafana dashboards, etc), and alternative interfaces via visual programming, instead of raw non-interactive JavaScript or TypeScript! Edit for parasti: You can use a USB cable to attach an Android phone to a Mac or PC, or an iPhone to a Mac, and then use the Chrome (or Safari on Mac) browser's debugger to attach to the phone and remotely see the console messages, debug, and even live code it! It might even work over Wifi if you can get all the stars to align, if Google hasn't canceled that feature, or if Apple hasn't forbidden it in the first place.
  - parasti 2y ago
    That's awesome, looking forward to it. Would love to report more, but this is on Android - I wouldn't even know how to go about getting a stack trace. Being on Android, I can't even see the developer console.
robblbobbl 2y ago
Good job! Now we need a Age of Empires and Empire Earth port!
usrbinbash 2y ago
Why is there a fire department in almost every city block?!
- DonHopkins 2y ago
  Because fire fighters are awesome.
TapamN 2y ago
I worked on a port of Micropolis to the Sega Dreamcast, but never finished it. https://www.youtube.com/watch?v=MlFu-y1LDbs https://www.youtube.com/watch?v=MlFu-y1LDbs One thing I really disliked about the SNES port of SimCity Classic was how slow the interface was. Having to access the menu for everything was a pain. For my port, the cursor would move faster, and snap instantly to the next tile if it was tapped. The analog stick could be used for fast cross map movement. The menuing was replaced by mapping every command to a button combination, with different palettes of commands available depending on what shoulder buttons were pressed. If you weren't holding a shoulder button, the ABXY buttons were set up for A (primary action button) for roads, X (secondary action) for rail, Y (the green button) for parks, and B (cancel button) for bulldozer. Holding L was reserved for system commands, you could zoom in or out with A or Y, and adjust the speed with X and B. Holding R completely would allow building zones, color coded to the controller's buttons, with the red (A) button to build residential, blue (B) for commercial, and yellow (X) for industrial. There were two more palettes, accessed by either pressing L+R, or half pressing the R button, for infrequently built things like power plants and airports. It might sound complicated from the description, but I think it would be pretty easy to get used to if you actually tried it a bit. I did a bit more work after I made the video, like adding map overlays (pollution, traffic, etc) and a display of what the current face button palette is, to help learn the combinations. I was also adding split screen, for multiplayer. I was planning for you to be able either build a city together with someone else, or do competitive city building, like race to clear a scenario, or get the highest population or funds in a certain amount of time. I think I got the split screen two different cameras on the same city working, but no controls for anyone besides player 1. I spent some time optimizing the simulation, because I wanted absolute solid 60 FPS. There would be occasional 1 or 2 frame stutters on large cities went certain phases of the simulation ran. The worst was when it calculated power. The power grid connectivity is calculated in a bizarre way. Instead of a regular, scanline based flood fill, it basically has a Logo turtle walk the power grid. It uses the exact same class that the monster uses for movement, tracking the facing of the turtle, with functions to turn, take one step forward, etc. The version of GCC I was using was not automatically inlining the movement functions (they were in .CPP files, and no LTO), so it added a ton of overhead to an already slow algorithm. I moved the functions into the header so they would be inlined, which helped a lot, but was still planning to replace the whole thing with a real flood fill. Even after inlining the walker, there were still single frame stutters. A lot of the map data for things like pollution and land value have filters applied to them, and the filter has a slow implementation. It does X and Y bounds checking on every tap of the filter, even in the middle when it can't go out of bounds. A better filter implementation would have helped. The C++ simulation seemed to have some kind of bug, which would cause periodic mass abandonment, that I never figured out. I never noticed the Java version having the same problem.
deleted 2y ago
[deleted]
yanslookup 2y ago
I'm not a gamer but I remember playing SimCity as a kid... Did game play change in the last ~25 years or is my browser broken? It doesn't seem to do anything? I can load a city and watch it do things but I remember being able to actually build cities myself in SimCity... Is there supposed to be a way for players to... play?
- DonHopkins 2y ago
  It's an early snapshot of a work in progress -- I just got the simulator and tile engine working, but haven't implement much more of the user interface yet. (I'll put a disclaimer on the page to avoid confusion.) The "Space Inventory" is actually a couple of cellular automata rules, one is a dithered 8 bit chaotic wrapping heat diffusion, kind of like "Heat", and the other is a variation of "EcoLibra" that Rudy Rucker came up with and published in Autodesk's Cellab, which he made with John Walker. It combines "Anneal" (aka "Vote 4/5") with "Life" and "Brian's Brain". https://www.fourmilab.ch/cellab/ https://www.fourmilab.ch/cellab/ https://www.fourmilab.ch/cellab/manual/rules.html#EcoLiBra https://www.fourmilab.ch/cellab/manual/rules.html#EcoLiBra https://www.fourmilab.ch/cellab/manual/rules.html#Life https://www.fourmilab.ch/cellab/manual/rules.html#Life https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life https://www.fourmilab.ch/cellab/manual/rules.html#Brain https://www.fourmilab.ch/cellab/manual/rules.html#Brain https://en.wikipedia.org/wiki/Brian%27s_Brain https://en.wikipedia.org/wiki/Brian%27s_Brain https://www.fourmilab.ch/cellab/manual/rules.html#Vote https://www.fourmilab.ch/cellab/manual/rules.html#Vote https://conwaylife.com/wiki/List_of_Life-like_rules https://conwaylife.com/wiki/List_of_Life-like_rules https://www.fourmilab.ch/cellab/manual/rules.html#Heat https://www.fourmilab.ch/cellab/manual/rules.html#Heat I added those CA rules to SimCity so they display the cell values with the SimCity tiles back in 1991, which I distributed via anonymous ftp as a free fully functional unlockable demo, that used cellular automata as DRM: you could play the game for a few minutes, then if you hadn't bought a license, it would switch to the cellular automata and melt your city! https://www.donhopkins.com/home/catalog/simcity/simcity-announcement.html https://www.donhopkins.com/home/catalog/simcity/simcity-anno... https://www.donhopkins.com/home/catalog/simcity/simcity-review.html https://www.donhopkins.com/home/catalog/simcity/simcity-revi... https://www.donhopkins.com/home/HyperLook-SimCity-Manual.pdf https://www.donhopkins.com/home/HyperLook-SimCity-Manual.pdf https://www.donhopkins.com/home/catalog/hyperlook/HyperLook-SimCity.gif https://www.donhopkins.com/home/catalog/hyperlook/HyperLook-... https://www.donhopkins.com/home/catalog/hyperlook/SimCity.INSTALL https://www.donhopkins.com/home/catalog/hyperlook/SimCity.IN... >Now that you have installed SimCity, you can run the "GetKey" shell script to get a license key from DUX software, or run "SimCity" in demo mode without getting a key. In demo mode, your city will melt after 5 minutes, or when you try to save it to disk, so buy a license, it's cheap! When you buy a license, DUX will ship you the latest version of the software, a nice 100 page manual with lots of nifty illustrations, and a handy reference card. And when you're ordering, don't forget to ask how to embezzle funds!
verbalstoner 2y ago
Controls aren't working and as soon as the browser loaded something my CPU fan kicked in. Are we sure this isn't just some janky crypto miner in disguise? And if it isn't, what's the point of publishing something that doesn't work?
- DonHopkins 2y ago
  The point is to get feedback about how it works on different systems that I don't have access to. And it's better to get feedback from people as early as possible while you're developing software, than trying to fully complete it and make it perfect before ever releasing it to anyone. Especially open source software. The bottom line is that I simply can't afford to own every different type of computer and mobile phone, and even if I did, I don't have the time to test it on them all myself, since nobody's paying me to do this. But if you do want to pay me, you can be the first to support me via Patron, which I'd appreciate, but is not necessary. https://www.patreon.com/DonHopkins https://www.patreon.com/DonHopkins But that's not why I'm working on the project: it's a labor of love, not a source of income. However, I am running a special offer right now where you can pay me $5 to shut the fuck up for 5 minutes a month about any topic you want. You are free to examine all of the source code on Github, and report bugs, and build it yourself. And your web browser also has excellent built-in debugging and reverse engineering tools that you can use to examine the WebAssembly binary and pretty print the compiled JavaScript, if that would make you less anxious. The WebGL shader is in plain text, so you can read that too, and verify that it matches the source code in the repo. https://github.com/SimHacker/MicropolisCore https://github.com/SimHacker/MicropolisCore And if you can find any evidence of janky crypto mining software, you are free to report me to the FBI and Interpol and Github, since it's quite easy to identify where the software came from and track me down, as I'm publishing the source code and binary under my own name from my own Github account and domain. Here's is a great example for you to emulate of somebody helpfully reporting an issue, identifying the system they're using, and including a stack trace identifying the problem, which I was able to fix in a few minutes. https://github.com/SimHacker/MicropolisCore/issues/1 https://github.com/SimHacker/MicropolisCore/issues/1 I'm glad you're so motivated to engage with the open source software community, and I hope you can write such a useful bug report yourself, and possibly even fix it yourself and submit a PR! Did you try pressing the numeric keys to control the speed? (I haven't tested it with a numeric keypad, which I don't have, so use the digits along the top of the keyboard.) If you press "1" it slows down to one frame per second with one simulator tick per frame, while "9" runs at 120 frames per second with 50 simulator ticks per frame. That runs smoothly in Chrome on my M1 Mac, and the user interface is still quite responsive. Which controls aren't working? What hardware and operating system and browser and GPU are you using, and did you see any error message printed on the browser developer console? Please include any console stack traces in your bug reports.

It’s funny I was thinking about writing some browser based games using Pyscript with web assembly. But now I think by the time I finish the games they’ll have ported enough of Python into web assembly that I might as well write it with Kivy or Pygame and then it would be cross platform. Pygame already in the browser, but slow and clunky IMO. In 6 months who knows?

nextaccountic 2y ago
Don't let analysis paralysis deter you from writing games. Pyscript is fine. Other stuff is fine too. Pick whatever technology you want, and make quick games with rapid prototyping. Join some game jams and keep your scope small. It's better to create and ship many small games. About pygame in the browser: check out pygbag.
- gnfedhjmm2 2y ago
  Would like technical thoughts, not cheerleading. I’ve written many games before just not with a new shaky stack.
  - JKCalhoun 2y ago
    Some of us appreciated the cheerleading though. :-)
  - nextaccountic 2y ago
    Oh but in technical terms my thoughts are completely opposite. Python wouldn't be my first choice for games in general, and much less for web games. Really the only way to justify using Python in this domain is if you're more comfortable with Python than other languages, and what you are building is a small, lightweight game. But this is reason enough to validate the idea! So if you want to build a game with Python, go for it. But if you're minimally comfortable with Typescript it would be a seriously better fit for this domain. Something like https://github.com/pixijs/pixijs https://github.com/pixijs/pixijs will work much better than Pygame or anything. It's geared towards simple 2D games too. One reason for that is dependencies. By using Python with Pyscript you will be constrained with what libraries you can use, because not all of them is compatible with Pyscript. (I myself am more comfortable with Rust, and Rust libraries like https://github.com/not-fl3/macroquad https://github.com/not-fl3/macroquad can target browsers, desktop and mobile; and it's also meant for simple 2D games. And I prefer the Rust ecosystem of libraries, too)

super_linear 2y ago

https://github.com/SimHacker/MicropolisCore https://github.com/SimHacker/MicropolisCore

modeless 2y ago

Porting old games to the web is fun! Many are smaller than a typical modern webpage. They load fast and run great. I just ported Quake 3 and I'm having some fun with it: https://thelongestyard.link/ https://thelongestyard.link/

geuis 2y ago
That was a lot of fun and a blast from the past. Thanks for porting that.
- modeless 2y ago
  Thanks! This is loading just the demo assets, but I got the Emscripten support merged into upstream ioquake3 so you can check out the code, build it yourself, and with the right game asset files you can play the full game, Team Arena, mods, or whatever. https://github.com/ioquake/ioq3/pull/658 https://github.com/ioquake/ioq3/pull/658 The only major feature missing from the original game is networking. Obviously kind of important for Quake 3. Should be possible with WebRTC DataChannel. And while the original game didn't have it, for the modern web a touchscreen control scheme is essential since half of everyone is on their phone. Of course it won't be great compared to mouse/keyboard but some mobile support is better than none. So those are the two features I'd like to add (besides performance optimizations; it's a bit slower than it should be for some reason).
  - hauxir 2y ago
    check out https://openarena.live https://openarena.live its open arena running on humblenet which does take advantage of webrtc/p2p
Jyaif 2y ago
That input latency is why I hate browsers when making games. Great job though!
- DonHopkins 2y ago
  If you refactor and structure your code in the right way, you can get it to perform pretty well. What will kill you is stacking up layers of emulation, so you're feeding browser input into a Windows or Mac emulation layer, and even an x86 instruction set emulator, plus a useless obsolete operating system "middle ware", because the way input and animation works on old desktop guis is a lot different and much less efficient that how it works in the browser. It's certainly possible to run the original version of Mac or Windows SimCity in the browser inside a Mac or Windows emulator inside a WebAssembly module, but not only is the user interface itself terrible, klunky, and awkward, it's extremely slow and flakey because it's emulating all that obsolete operating system crap and instruction set underneath all the web browser crap between your mouse clicks and the game engine. Since the web browser is so much better and more flexible at user interface and graphics stuff, you want to totally strip all of the user interface and graphics and sound out of the game, implement an efficient API and callback mechanism (that doesn't spend a lot of time thunking and marshalling and unmarshalling parameters, and pass simple primitive data types, sending what you need all at once, instead of ping-ponging back and forth with proxy objects), and implement all of the UI in the browser (especially the animation timers and input handlers), calling back to the simulator only when necessary. One thing I did was to use shared memory between the WebAssembly module and the WebGL tile renderer, and write a custom shader that understands the native 16 bit unsigned int column major SimCity tile format, so WebGL only has to draw two triangles, and there is zero copying to draw the tiles.

_ache_ 2y ago

Seriously, I'm stun about what happen if you it the space bar. Nice fractals.

DonHopkins 2y ago
Game Helpin' Squad's review of World Quester 2 is the inspiration for the Space Inventory, and I aspire to design the Micropolis menus and user interface to be as freaking awesome as World Quester 2! https://www.youtube.com/watch?v=0Gy9hJauXns https://www.youtube.com/watch?v=0Gy9hJauXns

detuks 2y ago

A while back ported RuneScape client to web. https://play.rsps.app/ https://play.rsps.app/ Wasm, Typescript and WebGL

simonebrunozzi 2y ago

Wondering whether an LLM could be able to port a game like this instantly.

DonHopkins 2y ago
Good question, please don't downvote -- there's an interesting discussion to be had about that! The best approach is to use it like any other tool, and not expect it to do all the hard work for you, just relieve you of a lot of tedious work, and help you learn how to be a better programmer yourself, not replace you. There's no such thing as a free lunch, but some lunches are tastier and more nutritious and less expensive than others. I've been using ChatGPT to develop it, and it's helped a lot, and takes a great deal of iteration and guidance, but it's anything but instant. LLMs won't replace programmers, but programmers with LLMs will replace programmers without LLMs. Here's an example of how it was helpful in simply explaining the documentation and best practices of tools like Emscripten and Embind, getting the makefile to work, analyzing the code, categorizing methods and instance variables as private and public (to be wrapped by embind), generating the boilerplate Embind declarations, and writing the documentation through a back-and-forth discussion of goals and requirements, and acting like a glorified grep that actually understands the code syntax and accepts English queries instead of obscure command line arguments. The comments at the top (included below) were mostly written by ChatGPT in response to me writing the strategy, telling it in detail what I wanted to do, describing my goals, and how I wanted it to work, with lots of iterating and refining and hand editing: https://github.com/SimHacker/MicropolisCore/blob/main/MicropolisEngine/src/emscripten.cpp https://github.com/SimHacker/MicropolisCore/blob/main/Microp... The process was anything but automatic or instant -- in total it took about 33 years (and counting, I'm not done yet). I had to guide ChatGPT a lot, drawing from my previous experience porting the Mac version of SimCity to HyperLook on the NeWS window system in 1991, and other platforms later on. At the time I considered using a Mac compatibility library for X11, but that would have resulted in a terrible klunky user interface, could not have taken advantages of the Sun Workstation Unix programming and user interface environment (networking, big screen, better window management, pie menus and other nice user interface components, scalable color PostScript graphics and fonts, using native file formats for resources, audio mixing, lots of computing power to animate fast and zoom into the map, run the simulation super fast by skipping screen updates, profiling and optimizing the code, etc), tied the game to a proprietary library that is long obsolete, and would have only supported X11, not NeWS. For a game like SimCity, it was well worth throwing away the Mac UI, cleaning up the simulator to be independent of the UI, and writing a new high quality UI for HyperLook in NeWS (then later another for TCL/Tk in X11). Porting it to NeWS required separating the simulator from the user interface and defining a clean network API and shared memory raster animation library, rewriting the user interface in PostScript, and defining a messaging protocol between the simulator and UI. Then a few years later I ported that to TCL/Tk on X11, refactoring the simulator/UI messaging interface into TCL extensions. TCL/Tk made it possible to develop a networked multi-player version of SimCity. X11 SimCity Demo: https://www.youtube.com/watch?v=Jvi98wVUmQA https://www.youtube.com/watch?v=Jvi98wVUmQA Multi Player SimCityNet for X11 on Linux: https://www.youtube.com/watch?v=_fVl4dGwUrA https://www.youtube.com/watch?v=_fVl4dGwUrA TCL Doc: https://github.com/SimHacker/MicropolisCore/blob/main/notes/DocTCL.txt https://github.com/SimHacker/MicropolisCore/blob/main/notes/... Callbacks: https://github.com/SimHacker/MicropolisCore/blob/main/notes/CALLBACKS.txt https://github.com/SimHacker/MicropolisCore/blob/main/notes/... A couple of decades later, we made SimCity open source, released the TCL/Tk/X11 version for the OLPC and Linux, then I cleaned up and overhauled the simulator code into C++, and used SWIG to define the API and a callback mechanism, so I could plug it into Python. Micropolis Core: https://github.com/SimHacker/micropolis/tree/master/MicropolisCore https://github.com/SimHacker/micropolis/tree/master/Micropol... Refactoring the code as C++ really helped modularize and organize it, made it easy to use doxygen to generate documentation, and much easier to wrap and port to different platforms. Doxygen documentation (current): https://micropolisweb.com/doc/ https://micropolisweb.com/doc/ Development Plan (old): https://github.com/SimHacker/MicropolisCore/blob/main/notes/DevelopmentPlan.md https://github.com/SimHacker/MicropolisCore/blob/main/notes/... OLPC Plan (old): https://github.com/SimHacker/MicropolisCore/blob/main/notes/PLAN.txt https://github.com/SimHacker/MicropolisCore/blob/main/notes/... To Do (old): https://github.com/SimHacker/MicropolisCore/blob/main/notes/TODO.txt https://github.com/SimHacker/MicropolisCore/blob/main/notes/... User Interface Plan (old): https://github.com/SimHacker/MicropolisCore/blob/main/notes/UserInterfacePlan.txt https://github.com/SimHacker/MicropolisCore/blob/main/notes/... OLPC Notes (old): https://github.com/SimHacker/MicropolisCore/blob/main/notes/OLPC-notes.txt https://github.com/SimHacker/MicropolisCore/blob/main/notes/... I implemented a couple of Python user interfaces, including a desktop based PyGTK/Cairo/X11 interface, and a web based TurboGears/AMF/OpenLaszlo/Flash client/server interface. Micropolis Online (SimCity) Web Demo (old): https://www.youtube.com/watch?v=8snnqQSI0GE https://www.youtube.com/watch?v=8snnqQSI0GE Bil Simser used SWIG it integrate the simulator engine with C#. (SWIG's point is to integrate C++ code into many different scripting languages, not just Python.) C# Micropolis: https://github.com/SimHacker/micropolis/tree/master/MicropolisCore/src/csMicropolis https://github.com/SimHacker/micropolis/tree/master/Micropol... After all that work, and writing and executing on the design documents linked above, I had a pretty good idea how to prompt ChatGPT to write a design for the Emscripten/Embind API, and it was helpful for writing the boilerplate code, and validating the design, but not so much for coming up with the design in the first place. Beyond refactoring and wrapping the API, ChatGPT has also been extremely useful for learning the intricacies and best practices of TypeScript, SvelteKit, node, WebGL, canvas, CSS, HTML, etc, for developing the user interface. //////////////////////////////////////////////////////////////////////// // This file uses emscripten's embind to bind C++ classes, // C structures, functions, enums, and contents into JavaScript, // so you can even subclass C++ classes in JavaScript, // for implementing plugins and user interfaces. // // Wrapping the entire Micropolis class from the Micropolis (open-source // version of SimCity) code into Emscripten for JavaScript access is a // large and complex task, mainly due to the size and complexity of the // class. The class encompasses almost every aspect of the simulation, // including map generation, simulation logic, user interface // interactions, and more. // // Strategy for Wrapping // // 1. Core Simulation Logic: Focus on the core simulation aspects, such // as the methods to run the simulation, update game states, and handle // user inputs (like building tools and disaster simulations). This is // crucial for any gameplay functionality. // // 2. Memory and Performance Considerations: JavaScript and WebAssembly // run in a browser context, which can have memory limitations and // performance constraints. Carefully manage memory allocation, // especially when dealing with the game's map and various buffers. // // 3. Direct Memory Access: Provide JavaScript access to critical game // data structures like the map buffer for efficient reading and // writing. This can be done using Emscripten's heap access functions // (HEAP8, HEAP16, HEAP32, etc.). // // 4. User Interface and Rendering: This part might not be necessary to // wrap, as modern web technologies (HTML, CSS, WebGL) can be used for // UI. However, providing some hooks for game state (like score, budget, // etc.) to JavaScript might be helpful. // // 5. Callbacks and Interactivity: Ensure that key game events and // callbacks are exposed to JavaScript, allowing for interactive and // responsive gameplay. // // 6. Optimizations: Where possible, optimize C++ code for WebAssembly, // focusing on critical paths in the simulation loop. // // Decisions and Explanations // // - Excluded Elements: // // - Low-level rendering or platform-specific code, as this can be // handled more efficiently with web technologies. // // - Parts of the code that handle file I/O directly, as file access // in a web context is typically handled differently (e.g., using // browser APIs or server-side support). // // - Any networking or multiplayer code, as web-based // implementations would differ significantly from desktop-based // network code. // // - Included Elements: // // - Core game mechanics, such as map generation, zone simulation // (residential, commercial, industrial), disaster simulation, and // basic utilities. // // - Game state management, including budgeting, scoring, and city // evaluation. // // - Direct memory access to critical structures like the map // buffer, allowing efficient manipulation from JavaScript. // // - Essential callbacks and event handling mechanisms to ensure // interactivity. // // Conclusion // // Given the complexity and size of the Micropolis class, wrapping the // entire class directly is impractical. However, focusing on key areas // essential for gameplay and providing efficient interfaces for // critical data structures can create a functional and interactive city // simulation in a web context. Further optimizations and adjustments // would likely be needed based on testing and specific requirements of // the web implementation. // // Implementation Notes // // The enum_, class_, constructor, function, and property functions // from the emscripten namespace are used to specify how C++ // constructs should be exposed to JavaScript. You can use these to // control which parts of your code are accessible and how they should // be used from JavaScript. // // I've made some assumptions here: // // The types MapValue and MapTile are simple types (like integers or // floats). If they are complex types, they would need their own // bindings. // // I'm assuming that the copy constructor and copy assignment // operator for the Position class are correctly implemented. If // they aren't, then the Position object may not behave as expected // in JavaScript. // // Micropolis Binding Design // // The Micropolis interface organizes the Micropolis class header into // categories of functions that are relevant for interaction with the // JavaScript user interface, scripts, or plugins. The aim is to expose // functions that could help in monitoring and controlling game state // effectively. //

DonHopkins 2y ago

Micropolis Web Demo 1: https://www.youtube.com/watch?v=wlHGfNlE8Os https://www.youtube.com/watch?v=wlHGfNlE8Os Micropolis Web is the browser based version of Micropolis (open source SimCity), that uses WebAssembly, WebGL, and SvelteKit. Based on the original SimCity Classic code, designed by Will Wright, ported by Don Hopkins. This first demo shows an early version that runs the WebAssembly simulator and animates the tiles with WebGL, but most of the user interface is still a work in progress. Live MicropolisWeb Site: https://MicropolisWeb.com https://MicropolisWeb.com GitHub Repo with source code and documentation: https://github.com/SimHacker/MicropolisCore https://github.com/SimHacker/MicropolisCore Much more Info in Chaim Gingold's book, "Building SimCity": https://mitpress.mit.edu/9780262547482/building-simcity/ https://mitpress.mit.edu/9780262547482/building-simcity/ Chaim Gingold's "SimCity Reverse Diagrams": https://smalltalkzoo.thechm.org/users/Dan/uploads/SimCityReverseDiagrams.pdf https://smalltalkzoo.thechm.org/users/Dan/uploads/SimCityRev... Micropolis Web Space Inventory Cellular Automata Music 1: https://www.youtube.com/watch?v=BBVyCpmVQew https://www.youtube.com/watch?v=BBVyCpmVQew Micropolis Web is the browser based version of Micropolis (open source SimCity), that uses WebAssembly, WebGL, and SvelteKit. Based on the original SimCity Classic code, designed by Will Wright, ported by Don Hopkins. This first video has music by Juho Hietala, Blamstrain, and the Space Inventory Cellular Automata is performed by Don Hopkins. Music by Juho Hietala, Blamstrain: https://blamstrain.com/ https://blamstrain.com/

ziggy_star 2y ago
Mr Hopkins you are by far one of my favorite posters on this website and these sort of comments are golden. On occasion they get appropriate engagement but sometimes there are no replies. You should know that it does not go unnoticed. The breadcrumbs you leave will be followed by youngsters far into the future, a worthwhile endeavor. Thank you for brightening my sunday and everything you’ve done and your efforts at documenting and preservation. While HN is not what it used to be I consider you royalty and old school users like yourself are the reason many of us still frequent this place. You are appreciated sir. Cheers.
- DonHopkins 2y ago
  Thank you! It feels great to have finally gotten the code working well enough that other people can use it, and to hear your kind feedback! It makes it all worthwhile. I've gotten so much pleasure just staring at the cellular automata for hours on end that I wanted to make that work and share it, even if you can't play the game yet. It will be even more fun once I get the city editing tools and disasters menu working, so you can bulldoze and draw roads and buildings and release monsters to stomp around and cause other disasters in the cellular automata! They're also useful for building and destroying cities, too, but painting in the live cellular automata is even more fun. Here's an old blurry video of that on the X11 version: Cellular SimCity: Cellular Automata in SimCityNet on Unix. https://www.youtube.com/watch?v=P8KJ--drZO8 https://www.youtube.com/watch?v=P8KJ--drZO8

parasti 2y ago

This is cool. I didn't expect much on mobile (hey it's Simcity), but this page actually froze Firefox for me, on Android. Had to kill the process. That happens rarely. BTW, here's a little game that I ported to the browser. Getting it to run was very straightforward (Emscripten+SDL2 is a great combo), but honestly making it fully playable on a phone took the most effort: https://play.neverball.org/ https://play.neverball.org/

DonHopkins 2y ago
I fully intend to make it support mobile! And I already fixed one bug that prevented it from running on Firefox on Ubuntu, thanks to a well written bug report that included a stack trace. Give it another try, maybe it works now, and if not, please report the bug and include a stack trace and any information about your platform. https://github.com/SimHacker/MicropolisCore/issues/1 https://github.com/SimHacker/MicropolisCore/issues/1 I wanted to release this as soon as possible so other people could run it, instead of waiting until it was finished and perfect, so there's a lot more work to do on the user interface, robustness, cross platform support, mobile, etc. But once I got the simulator and tile renderer working, I threw together a minimalistic zooming panning + keyboard control interface, and a little window with hints that you can close by clicking the "+" button in the upper right corner. What I'm really looking forward to doing is integrating it with visual programming languages like Snap! so you can live code it and write plug-in zones, robots, monitoring and control systems, data visualization and export (i.e. Grafana dashboards, etc), and alternative interfaces via visual programming, instead of raw non-interactive JavaScript or TypeScript! Edit for parasti: You can use a USB cable to attach an Android phone to a Mac or PC, or an iPhone to a Mac, and then use the Chrome (or Safari on Mac) browser's debugger to attach to the phone and remotely see the console messages, debug, and even live code it! It might even work over Wifi if you can get all the stars to align, if Google hasn't canceled that feature, or if Apple hasn't forbidden it in the first place.
- parasti 2y ago
  That's awesome, looking forward to it. Would love to report more, but this is on Android - I wouldn't even know how to go about getting a stack trace. Being on Android, I can't even see the developer console.

robblbobbl 2y ago

Good job! Now we need a Age of Empires and Empire Earth port!

usrbinbash 2y ago

Why is there a fire department in almost every city block?!

DonHopkins 2y ago
Because fire fighters are awesome.

TapamN 2y ago

I worked on a port of Micropolis to the Sega Dreamcast, but never finished it. https://www.youtube.com/watch?v=MlFu-y1LDbs https://www.youtube.com/watch?v=MlFu-y1LDbs One thing I really disliked about the SNES port of SimCity Classic was how slow the interface was. Having to access the menu for everything was a pain. For my port, the cursor would move faster, and snap instantly to the next tile if it was tapped. The analog stick could be used for fast cross map movement. The menuing was replaced by mapping every command to a button combination, with different palettes of commands available depending on what shoulder buttons were pressed. If you weren't holding a shoulder button, the ABXY buttons were set up for A (primary action button) for roads, X (secondary action) for rail, Y (the green button) for parks, and B (cancel button) for bulldozer. Holding L was reserved for system commands, you could zoom in or out with A or Y, and adjust the speed with X and B. Holding R completely would allow building zones, color coded to the controller's buttons, with the red (A) button to build residential, blue (B) for commercial, and yellow (X) for industrial. There were two more palettes, accessed by either pressing L+R, or half pressing the R button, for infrequently built things like power plants and airports. It might sound complicated from the description, but I think it would be pretty easy to get used to if you actually tried it a bit. I did a bit more work after I made the video, like adding map overlays (pollution, traffic, etc) and a display of what the current face button palette is, to help learn the combinations. I was also adding split screen, for multiplayer. I was planning for you to be able either build a city together with someone else, or do competitive city building, like race to clear a scenario, or get the highest population or funds in a certain amount of time. I think I got the split screen two different cameras on the same city working, but no controls for anyone besides player 1. I spent some time optimizing the simulation, because I wanted absolute solid 60 FPS. There would be occasional 1 or 2 frame stutters on large cities went certain phases of the simulation ran. The worst was when it calculated power. The power grid connectivity is calculated in a bizarre way. Instead of a regular, scanline based flood fill, it basically has a Logo turtle walk the power grid. It uses the exact same class that the monster uses for movement, tracking the facing of the turtle, with functions to turn, take one step forward, etc. The version of GCC I was using was not automatically inlining the movement functions (they were in .CPP files, and no LTO), so it added a ton of overhead to an already slow algorithm. I moved the functions into the header so they would be inlined, which helped a lot, but was still planning to replace the whole thing with a real flood fill. Even after inlining the walker, there were still single frame stutters. A lot of the map data for things like pollution and land value have filters applied to them, and the filter has a slow implementation. It does X and Y bounds checking on every tap of the filter, even in the middle when it can't go out of bounds. A better filter implementation would have helped. The C++ simulation seemed to have some kind of bug, which would cause periodic mass abandonment, that I never figured out. I never noticed the Java version having the same problem.

deleted 2y ago

[deleted]

yanslookup 2y ago

I'm not a gamer but I remember playing SimCity as a kid... Did game play change in the last ~25 years or is my browser broken? It doesn't seem to do anything? I can load a city and watch it do things but I remember being able to actually build cities myself in SimCity... Is there supposed to be a way for players to... play?

DonHopkins 2y ago
It's an early snapshot of a work in progress -- I just got the simulator and tile engine working, but haven't implement much more of the user interface yet. (I'll put a disclaimer on the page to avoid confusion.) The "Space Inventory" is actually a couple of cellular automata rules, one is a dithered 8 bit chaotic wrapping heat diffusion, kind of like "Heat", and the other is a variation of "EcoLibra" that Rudy Rucker came up with and published in Autodesk's Cellab, which he made with John Walker. It combines "Anneal" (aka "Vote 4/5") with "Life" and "Brian's Brain". https://www.fourmilab.ch/cellab/ https://www.fourmilab.ch/cellab/ https://www.fourmilab.ch/cellab/manual/rules.html#EcoLiBra https://www.fourmilab.ch/cellab/manual/rules.html#EcoLiBra https://www.fourmilab.ch/cellab/manual/rules.html#Life https://www.fourmilab.ch/cellab/manual/rules.html#Life https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life https://www.fourmilab.ch/cellab/manual/rules.html#Brain https://www.fourmilab.ch/cellab/manual/rules.html#Brain https://en.wikipedia.org/wiki/Brian%27s_Brain https://en.wikipedia.org/wiki/Brian%27s_Brain https://www.fourmilab.ch/cellab/manual/rules.html#Vote https://www.fourmilab.ch/cellab/manual/rules.html#Vote https://conwaylife.com/wiki/List_of_Life-like_rules https://conwaylife.com/wiki/List_of_Life-like_rules https://www.fourmilab.ch/cellab/manual/rules.html#Heat https://www.fourmilab.ch/cellab/manual/rules.html#Heat I added those CA rules to SimCity so they display the cell values with the SimCity tiles back in 1991, which I distributed via anonymous ftp as a free fully functional unlockable demo, that used cellular automata as DRM: you could play the game for a few minutes, then if you hadn't bought a license, it would switch to the cellular automata and melt your city! https://www.donhopkins.com/home/catalog/simcity/simcity-announcement.html https://www.donhopkins.com/home/catalog/simcity/simcity-anno... https://www.donhopkins.com/home/catalog/simcity/simcity-review.html https://www.donhopkins.com/home/catalog/simcity/simcity-revi... https://www.donhopkins.com/home/HyperLook-SimCity-Manual.pdf https://www.donhopkins.com/home/HyperLook-SimCity-Manual.pdf https://www.donhopkins.com/home/catalog/hyperlook/HyperLook-SimCity.gif https://www.donhopkins.com/home/catalog/hyperlook/HyperLook-... https://www.donhopkins.com/home/catalog/hyperlook/SimCity.INSTALL https://www.donhopkins.com/home/catalog/hyperlook/SimCity.IN... >Now that you have installed SimCity, you can run the "GetKey" shell script to get a license key from DUX software, or run "SimCity" in demo mode without getting a key. In demo mode, your city will melt after 5 minutes, or when you try to save it to disk, so buy a license, it's cheap! When you buy a license, DUX will ship you the latest version of the software, a nice 100 page manual with lots of nifty illustrations, and a handy reference card. And when you're ordering, don't forget to ask how to embezzle funds!

verbalstoner 2y ago

Controls aren't working and as soon as the browser loaded something my CPU fan kicked in. Are we sure this isn't just some janky crypto miner in disguise? And if it isn't, what's the point of publishing something that doesn't work?

DonHopkins 2y ago
The point is to get feedback about how it works on different systems that I don't have access to. And it's better to get feedback from people as early as possible while you're developing software, than trying to fully complete it and make it perfect before ever releasing it to anyone. Especially open source software. The bottom line is that I simply can't afford to own every different type of computer and mobile phone, and even if I did, I don't have the time to test it on them all myself, since nobody's paying me to do this. But if you do want to pay me, you can be the first to support me via Patron, which I'd appreciate, but is not necessary. https://www.patreon.com/DonHopkins https://www.patreon.com/DonHopkins But that's not why I'm working on the project: it's a labor of love, not a source of income. However, I am running a special offer right now where you can pay me $5 to shut the fuck up for 5 minutes a month about any topic you want. You are free to examine all of the source code on Github, and report bugs, and build it yourself. And your web browser also has excellent built-in debugging and reverse engineering tools that you can use to examine the WebAssembly binary and pretty print the compiled JavaScript, if that would make you less anxious. The WebGL shader is in plain text, so you can read that too, and verify that it matches the source code in the repo. https://github.com/SimHacker/MicropolisCore https://github.com/SimHacker/MicropolisCore And if you can find any evidence of janky crypto mining software, you are free to report me to the FBI and Interpol and Github, since it's quite easy to identify where the software came from and track me down, as I'm publishing the source code and binary under my own name from my own Github account and domain. Here's is a great example for you to emulate of somebody helpfully reporting an issue, identifying the system they're using, and including a stack trace identifying the problem, which I was able to fix in a few minutes. https://github.com/SimHacker/MicropolisCore/issues/1 https://github.com/SimHacker/MicropolisCore/issues/1 I'm glad you're so motivated to engage with the open source software community, and I hope you can write such a useful bug report yourself, and possibly even fix it yourself and submit a PR! Did you try pressing the numeric keys to control the speed? (I haven't tested it with a numeric keypad, which I don't have, so use the digits along the top of the keyboard.) If you press "1" it slows down to one frame per second with one simulator tick per frame, while "9" runs at 120 frames per second with 50 simulator ticks per frame. That runs smoothly in Chrome on my M1 Mac, and the user interface is still quite responsive. Which controls aren't working? What hardware and operating system and browser and GPU are you using, and did you see any error message printed on the browser developer console? Please include any console stack traces in your bug reports.