micropolis

r Micropolis (SimCity), a work in progress, but I haven't written the rendering stuff yet: https://github.com/SimHacker/MicropolisCore/blob/main/microp... Also, here's a video of the Unity3D pie menus I implemented a dozen years or so ago (there's a link to the code in the description, but it's 12 years old and Unity's approach to user interfaces has changed a lot since then): https://www.youtube.com/watch?v=sMN1LQ7qx9g

ng 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/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 Multi Player SimCityNet for X11 on Linux: https://www.youtube.com/watch?v=_fVl4dGwUrA TCL Doc: https://github.com/SimHacker/MicropolisCore/blob/main/notes/... Callbacks: 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/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/ Development Plan (old): https://github.com/SimHacker/MicropolisCore/blob/main/notes/... OLPC Plan (old): https://github.com/SimHacker/MicropolisCore/blob/main/notes/... To Do (old): https://github.com/SimHacker/MicropolisCore/blob/main/notes/... User Interface Plan (old): https://github.com/SimHacker/MicropolisCore/blob/main/notes/... OLPC Notes (old): 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 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/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. //

n packs for The Tower II that were only released in Japan, and I plan on making a more flexible modern version of TowerKit in the form of a Yoot Tower SDK that lets you dynamically script and download extensions in JavaScript instead of modifying and recompiling C++ code. https://github.com/YootTowerManagement/YootTower/tree/main https://web.archive.org/web/20000521002924fw_/http://www.ope... >What's Tower Kit? >Tower Kit is optional software for The Tower II. In The Tower II, you can select the stage where you want to start the game using the concept of a "map." The Tower II package comes with three maps: "Shinjuku Subcenter," "Hawaii Diamond Head," and "Kegon Falls," and the "Tower Kit" adds these maps. By installing this tower kit, a new stage game will begin. Tower kits don't just add more stages. Each map has new features, allowing you to play a completely new game. >Please try the "Tower Kit" which allows for infinite variations. >A love story between you, the person in charge of the Liberty Island redevelopment project, and two men and women who are your subordinates. Your work will have a subtle influence on the course of your love life. The Tower II is the first attempt at a crossover between redevelopment and love, set in New York. What is the ending...? I did a similar thing for Micropolis/SimCity more than a decade ago, but with Python and SWIG, instead of emscripten and embind, so you could program your own agents (like PacBot, who follows the roads and eats traffic) and zones (like the Church of Pacmania, which worships and attracts PacBots, and causes lots of traffic to feed them). Micropolis Online (SimCity) Web Demo: https://www.youtube.com/watch?v=8snnqQSI0GE A demo of the open source Micropolis Online game (based on the original SimCity Classic source code from Maxis), running on a web server, written in C++ and Python, and displaying in a web browser, written in OpenLaszlo and JavaScript, running in the Flash player. Developed by Don Hopkins. Source Code: https://github.com/SimHacker/micropolis HAR 2009 talk: Constructionist Educational Open Source SimCity: https://donhopkins.medium.com/har-2009-lightning-talk-transc... Church of PacMania: https://github.com/SimHacker/micropolis/blob/master/Micropol... PacBot: https://github.com/SimHacker/micropolis/blob/main/Micropolis... https://github.com/SimHacker/micropolis/blob/master/laszlo/m... Back when I was porting SimCity to Unix in the early 90's, Maxis gave me the source code to SimEarth too, but I never had the chance to port it, and don't have permission now unfortunately. I'd love to make a modern version of SimEarth and SimAnt too, but neither of them were as successful or engaging a game as SimCity. Will Wright discusses SimEarth, SimAnt, and SimCity 2000 in this 1996 talk he gave to Terry Winnograd's user interface class, and also demonstrates a very early version of The Sims when it was called Dollhouse. His point was that SimAnt was too simple, SimEarth was too complex, but SimCity 2000 was just right, and Dollhouse was the next thing he was working on, which became The Sims. I'd also love to make a modern version of The Sims 1, but I don't have permission for that either, and have never been able to talk anyone at EA to reproduce the miracle it took to release SimCity. But I'm delighted and grateful to have the chance to work with Yoot Saito on SimTower instead, since he retained all the rights to his code, and we're both on the same page about educational games, constructionist education, and our respect for Alan Kay and Seymour Papert's philosophy about teaching kids to program and motivating it with games. A visual programming language in Micropolis and Yoot Tower would be great (that's the long term plan), like the SimAntics VPL in The Sims 1 (but much easier to use and extend). Will Wright - Maxis - Interfacing to Microworlds - 1996-4-26: https://www.youtube.com/watch?v=nsxoZXaYJSk Here's an article I wrote about that talk right after attending it, that I updated in later years after working with Will on The Sims, and then even more recently when Stanford finally published the video of the talk decades later: https://donhopkins.medium.com/designing-user-interfaces-to-s...

anese bar, but he had some time to chat. >He said he once did a big interview with BBC about SimTower (which would be worth looking up and watching if you can find it), and had a friend who worked in the elevator industry, who told him generally about how elevators worked, but much of it was secret and proprietary, so he had to come up with how they worked in the game himself, based on the general ideas he learned and his own experience and imagination. >He also said he's interested in releasing the original source code of SimTower as free open source software, like I did with the original SimCity Classic source code, so I volunteered to help him and find other people who could help. Anybody interested? ;) Yoot recently sent me a huge code drop of the Windows sources as well as the Gameboy SP and DS versions and production documents, and I'm sorting it out and cleaning it up to make a version that compiles with emscripten and runs in the web browser. We've decided it release it under the MIT license, and develop a version that runs in the web browser using emscripten and SvelteKit. I'd appreciate hearing from people who are interested in helping out, especially people who know Japanese, since there is a lot of great content in The Tower II that was only released in Japan that needs translating to English and other languages. I've also started the process of porting the Micropolis (open source SimCity) code to run in the web browser in the same way as Yoot Tower, since they are both from the same era (and from Maxis) and share a lot of technologies and requirements, so they will both be able to share much of the code and infrastructure (WebAssembly, emscripten, embind, SvelteKit, canvas, html, css, user interface code, github actions, etc), with the eventual goal of being able to embed multiple Yoot Towers in your Micropolis city! https://github.com/SimHacker/MicropolisCore >Open Source Micropolis, based on the original SimCity Classic from Maxis, by Will Wright. >MicropolisCore C++ Core >This is the source code for Micropolis (based on SimCity), released under GPL-3. Micropolis is based on the original SimCity from Electronic Arts / Maxis, designed and written by Will Wright, and ported to Unix by Don Hopkins. >The origin of this repo is the "MicropolisCore" directory of the full micropolis repo, https://github.com/SimHacker/micropolis , but it's been stripped down and simplified. >I am now in the process of converting it to build for WebAssembly with emscripten and bind to JavaScript with embind, and implementing a SvelteKit front-end. Since I know the SimCity code well already and have ported it to many different platforms, and put years of effort into cleaning up the old code to be well organized C++ code with clean interfaces and doxygen documentation, it's a great way to learn the new technologies, work out the approach, and prepare for porting SimTower the same way. ChatGPT has been a huge help, especially analyzing the code and writing documentation and translating the Japanese comments, and now I'm using Aider for them both: Aider: AI pair programming in your terminal (github.com/paul-gauthier): https://news.ycombinator.com/item?id=39995725 Here's a code map for each source file that I made with ChatGPT that focuses on helping me get a high level view of the code, its dependencies, purposes of each file, and porting issues: https://github.com/YootTowerManagement/YootTower/blob/main/Y... The Nintendo Gameboy SP and DS versions of Tower have a whole lot of proprietary Nintendo SDK code and also their precious proprietary content and characters like Mario, which we are certainly not able to release ourselves under the MIT license, so I'm working with the more generic Windows version instead. Yoot owns the rights to the source code to his own games, but we can't just release stuff with Nintendo's crowned jewels like Mario and their SDKs in it as open source. We are being extremely careful not to infringe on anyone’s copyrights or trademarks, of course! Maxis got into a lot of trouble with Godzilla just because they had a big monster on the box but didn’t mention Godzilla by name (but a review in a magazine did, which was too much), and Maxis (now EA) own the SimTower trademark, so we’re calling it Yoot Tower. The Nintendo Gameboy and DS console ports of SimTower have a lot Nintendo content (like Mario), so we definitely don’t want to make Nintendo or EA mad by infringing on their trademarks or copyrights. Jeff Braun (CEO of Maxis) told me the story of what happened decades ago with Maxis and Godzilla, so I want to be careful to avoid stomping on anybody’s property: >Maxis was sued by Toho. We never referred to the name Godzilla, our monster on the box cover was a T-Rex looking character, but... a few magazine reviews called the monster, Godzilla. That was all it took. Toho called it "confusion in the marketplace". We paid $50k for Godzilla to go away. In all honesty, Toho liked Maxis, they said $50k was the minimum they take for Godzilla infringement. I doubt you will need to worry about Toho, as long as there are no magazine reviews that call the monster Godzilla. I guess the lesson is to always make sure to give your monsters a unique name, and don’t leave that up to the user’s imagination.

versity of Cambridge Library Archives: https://www.cl.cam.ac.uk/library/archives.html In 1986 Mike Gallaher and I together came up with the same idea, and I implemented a prototype proof-of-concept for the X10 window system I called "theta menus": https://donhopkins.com/home/pub/piemenus/theta-menus/ Mitch Bradley suggested the name "pie menu", and I implemented them in the X10 "uwm" window manager, which I integrated into Mitch's Sun Forth system so it was possible to script the window manager in Forth: https://donhopkins.com/home/pub/piemenus/pietest/ https://donhopkins.com/home/pub/piemenus/pietest/fuwm-main.f X10 Pie Menu Window Manager: https://www.youtube.com/watch?v=IJhvB6kwmog You could define both pie menus and linear menus in a special menu definition syntax in your .uwmrc file, and configure them to run various window management, application launching, and shell scripting commands. But there was no pie menu editor, just a text file defining the menus. We performed an experiment to compare the speed and error rate of pie menus and linear menus, which I programmed in Forth to randomize and present the menus and measure the error rates and timing statistics. Pie Menu Experiment: https://www.youtube.com/watch?v=s0zEUi6p2ws Implementing a Forth scriptable pie menu window manager for X10 led the way to implementing pie menus in PostScript for various versions of the NeWS window system. It was easy for me to make the transition from Forth to PostScript, which is much more like Lisp than like Forth, and NeWS had an object oriented programming system like Smalltalk which is great for implementing user interface toolkits. Just the pie menus from All The Widgets: https://www.youtube.com/watch?v=mOLS9I_tdKE Ben Shneiderman demo: Don Hopkins and pie menus in ~ Spring 1989 on a Sun Workstation, running the NEWS operating system. https://www.youtube.com/watch?v=8Fne3j7cWzg PSIBER Space Deck Demo: https://www.youtube.com/watch?v=iuC_DDgQmsM HCIL Demo - HyperTIES Authoring with UniPress Emacs on NeWS: https://www.youtube.com/watch?v=hhmU2B79EDU NeWS Tab Window Demo: https://www.youtube.com/watch?v=tMcmQk-q0k4 After NeWS, I made an X11 window manager based on "twm" called "piewm": https://donhopkins.com/home/pub/piemenus/piewm/ https://www.donhopkins.com/home/catalog/unix-haters/x-window... Then I implemented pie menus for TCL/Tk on X11, which I used for the X11 version SimCity (which EA later relicensed under GPL-3 and released for the OLPC). https://github.com/SimHacker/micropolis/blob/master/micropol... X11 SimCity Demo: https://www.youtube.com/watch?v=Jvi98wVUmQA Multi Player SimCityNet for X11 on Linux https://www.youtube.com/watch?v=_fVl4dGwUrA Playing SimCity for X11 on Linux with Pie Menus in San Francisco: https://www.youtube.com/watch?v=1p7_fapUq20 I later implemented the pie menus in The Sims, which you can see an early version of here, including a graphical zooming/rotating pie menu that didn't make it into the game: The Sims Steering Committee - June 4 1998: https://www.youtube.com/watch?v=zC52jE60KjY Another take on pie menus that did make it into the game was the object placement tool that let you rotate objects both as you picked them up and set them down, like an invisible "direct manipulation pie menu" (see the demo of object placement tool placing chairs around the dining room table at 4:45): https://www.youtube.com/watch?v=-exdu4ETscs Not only can you rotate it while placing it down, but also while picking it up. Clicking picks up or places down without rotating, but pressing and moving rotates to face the direction of motion. Unfortunately, later versions of The Sims didn't implement that simple feature, so instead you have to use the keyboard or repeatedly click multiple times until it rotates around to the direction you want, which is much more difficult and less natural than simply dragging in the direction you want it to face when picking up or placing down. Here's a later web based version of Micropolis (open source SimCity) with pie menus implemented with OpenLaszlo / Flash -- at 3:00 it demonstrates how the pie menus work as an alternative to the traditional tool palette, and once you learn the pie menus you can hide away the palette to gain many acres of SimCity "screen real estate": https://www.youtube.com/watch?v=8snnqQSI0GE ActiveX Pie Menus: https://www.youtube.com/watch?v=nnC8x9x3Xag The ActiveX pie menus were implemented as an OLE Control, which supported editing via a tabbed property sheet using traditional gui widgets like buttons, tree editors, text editors, and a wysiwyg (but not editable) preview. One nice feature was that you could simply type in an indented outline into the text editor to produce a whole tree of nested menus, which saved a whole lot of pointing and clicking gui widgets to create the menus and items one by one. But I hit a wall because I wanted more control over the graphical presentation and dynamic feedback, that was extremely difficult to program with MFC/Win32/C++/GDI, and I wanted the full features of a web browser to render each item, including animated gifs, css styles, etc. JavaScript Pie Menu IE5 Behavior Components: https://www.youtube.com/watch?v=R5k4gJK-aWw So implementing pie menus inside the web browser in JavaScript with DHTML and CSS was the obvious next step, which also made it easy to define menu structures with XML and presentation with HTML. You could put anything you wanted into the pie menu center or items. But Microsoft's IE5 Behavior Components were a dead-end. JQuery Pie Menus: https://github.com/SimHacker/jquery-pie So later on after jQuery came along I implemented pie menus for jQuery, using jQuery-UI. Unity3D Pie Menu Demo: https://www.youtube.com/watch?v=sMN1LQ7qx9g Pet Rock Remote Control -- Touch screen pie menu interface on Pocket PC for sending commands to rocks: https://www.youtube.com/watch?v=SG0FAKkaisg