YesBox

If you're interested in playing a new game in this genre, I've been developing a city builder game over the last year, heavily inspired by Dwarf Fortress, Rim World, Cities: Skylines, Sim City, etc.

My game will have more granular demand (not just vague "you need more commercial zones"). The player will see the interior of buildings and will be able to watch their sims live their lives.

Im working on getting version 0.2 release by Q1 2023. The game is isometric now! Working on releasing a new vlog to show it off.

I developed a new path finding algorithm to build big cities. Here's an old version of the game path finding 1,000,000 units to their own unique destinations:

https://www.youtube.com/watch?v=x0HCnQqF5K4

Subreddit:

https://reddit.com/r/Archapolis

If you're interested in playing a new game in this genre, I've been developing a city builder game over the last year, heavily inspired by Dwarf Fortress, Rim World, Cities: Skylines, Sim City, etc.

My game will have more granular demand (not just vague "you need more commercial zones"). The player will see the interior of buildings and will be able to watch their sims live their lives.

Im working on getting version 0.2 release by Q1 2023. The game is isometric now! Working on releasing a new vlog to show it off.

I developed a new path finding algorithm to build big cities. Here's an old version of the game path finding 1,000,000 units to their own unique destinations:

https://www.youtube.com/watch?v=x0HCnQqF5K4

Subreddit:

https://reddit.com/r/Archapolis

This is an interesting approach, though I dont think it will work. Vehicles/units move pixel by pixel, not tile by tile. Each wall tile in my game takes up one tile, and walls sit on the edge of a tile. I dont think this will handle unit/wall rendering order properly unless I also form larger shapes from the walls.

This works perfectly for isometric cubes, and is what I do currently.

If you imagine two long rectangles, one in each of your two hands, and pretend they are two cars passing each other in an isometric world, you will see that pretty soon, one car's screen.y position will be below the other before it's clear of the vehicle which should actually be occluding part of it.

Somewhere between one to $tile_size pixels. Tile size depends on the zoom level (I'm using SFML, had to add a separate sprite sheet for each zoom level cause SFML's built in zoom out method is awful).

This is the first time of hearing BSP, and I read most of the OP's article to have a very basic understanding how it works.

Since this is a tree, reordering N elements would be approach N^2 complexity, would it not? (edit: I assumed you would have to find each node from the root, which could very well be a bad premise).

I'm developing an isometric city builder game. I've figured out how to depth sort everything on the CPU efficiently, though there were some ugly workarounds I had to implement. Suffice to say, for anything outside of buildings, sorting on the screen.y position of the texture works perfectly (so long as each asset is one tile in size, or broken up into multiple tiles).

But, I am starting to implement vehicles, first time adding assets that are multiple tiles in size. It would be really nice if I could create one asset for the vehicles, but the sorting on screen.y will not work for 3D rectangles, so I am breaking the up into multiple tiles...

Do you think BSP trees will work with thousands of moving assets? i.e., I would have to recreate the BSP tree every frame.

Thanks for mentioning those, I havent heard of either

Shoot me an email (in profile)

Seems like a lot of people like your approach, so I'll clarify. I am focused on releasing my game because I want to continue working for myself and having the opportunity to choose/direct my creativity every single day.

The journey is important, you'll probably have a hard time making it in this industry and/or burn out if you aren't deriving joy from the day to day work.

For me, not releasing my game ASAP is not an option. I'm living off of my savings. That's why I prefer other full time devs because survival mode is very different than safe mode. (I feel 10 times more alive. Not sure how others feel).

Anyways, Im mostly responding to encourage you to create your own group because there seems to be a lot of people who are in the same boat as you. I have to say, meeting up with people every week who share the same drive/passion as I do is a great experience.

Interesting, I assumed the roads were not going to change frequently (but rather, in bursts). So I used that premises to develop my algo. To enforce this behavior (on a code level), I will be adding a "planning" mode, where roads can be placed freely/frequently. Once the user sends the plan off to be constructed, then the graph will update. I may go one step further and have construction (i.e. graph updating) only happen at night, and give the user something else to do while its updating.

That being said, if they have a modern machine, then there will be no need for this at all (just need to figure out the avg user CPU GHz & core count). It takes 10 seconds for my algo to find the all pairs/all possible shortest paths between two nodes on my machine for 10,000 nodes, which by that point is a HUGE city.

The reason I did not go with A* is because it doesn't scale to 100K+ units and it always chooses the same path.

Quick update, I've released a video showing off my algorithm to the extreme (path finding 1,000,000 units), as well as other development progress.

https://www.youtube.com/watch?v=x0HCnQqF5K4

Currently I can close edges (i.e. an individual road between two intersections), but right now I would have to rebuild the path finding graph each time the graph changes. I was thinking of this problem too, cause it would be really cool to temporarily close a road down for repairs/construction. I think there is a way to make it work without needing to rebuild! Just havent had time to look into it.

Right now the units are moving in tile-sized increments. I'll be implementing floating point movement soon. I move the map around while the units are moving and you'll see its not at 4 FPS.

I think with any quasi-infinite growth game, you are going to run into a problem of it slowing down, eventually. That's what inspired me to create this algorithm. I wanted a game that could scale, and traditionally path finding is a CPU intensive task.

The video I linked is out of date, I'll be making a new one soon.

Now: building the path finding graph is now stored in a vector (i.e. array) instead of an unordered_map (and still has constant time access/find). This cut CPU cycles by 66% since a vector doesnt use linked list/pointers/store a hash, and reduced RAM requirements by 75%. Then I parallelized that part of the code base.

So for my 6 core machine, I can find all the all-pairs, all-possible shortest paths in a 50 x 50 grid of roads in 10 seconds. This is about 13 square miles of city if each block is the size of a Manhattan block. I'll be working around this time by implementing a planning mode so it only updates as needed.

Im working on a game in the same vein: Archapolis, a city builder with real time traffic simulation and interior views of your citizens homes (which you can customize/build yourself if you want), so you can watch them live their lives. I'd like the player to have a more hands on approach to managing the city as well.

Here's a tech demo of what I've been working on: https://www.youtube.com/watch?v=7q0l87hwmkI

I created a path finding algorithm that can simultaneously path hundreds of thousands of units to random destinations at a comfortable frame rate (or around 100-200K like in the video using one CPU core). Units can choose from any of the shortest paths between two points (there are many in a grid), and from those paths, can also choose the path that matches any preferences they have.

Very early stages of development still!

Neat! Thanks, I will look into this

I recently wrote some multi-threaded code (for the first time) for a game I'm working on. Luckily the data I need to process is in a (C++) vector, so I was able to break the data up by dividing the vector size by available cores. I certainly felt 10 ft. tall when it worked!

Another area of my code where concurrency will greatly benefit it requires updating an unordered_map. Since it's positioned based and not unit_id based, I'll need to figure out a way to prevent data races. The best option I've thought of so far is assigning thread numbers to each edge in my graph, and storing the units in each edge in a queue, which should prevent data races and car collisions. (edit: ha)

That being said, I'm the sole developer on this project and I cannot imagine working on a multi-threaded application with dozens of other developers. It is nice dipping my toes in the water though.

You might be interested in my game. I'm working on Archapolis, a city builder with real time traffic simulation and interior views of your citizens homes (which you can customize/build yourself if you want), so you can watch them live their lives. I'd like the player to have a more hands on approach to managing the city as well.

Here's a tech demo of what I've been working on: https://www.youtube.com/watch?v=7q0l87hwmkI

I created a path finding algorithm that can simultaneously path 300,000 units to random destinations at a comfortable frame rate. Units can choose from any of the shortest paths between two points (there are many in a grid), and from those paths, can also choose the path that matches any preferences they have.

Very early stages of development still!

I pinged your gmail. I misread your OP and thought your were tinkering with existing games, not building your own model. Very very cool!

It's a solved problem. Off road travel off screen will use timed-teleporting, on screen I will use A*. I dont need to worry about real time path finding inside homes (no traffic, no combat, etc) if the unit isnt visible.

If this is something you are serious about then I'd recommend unlocking your enthusiasm and ideas. I'm not able to connect with you if you're secretive and indirect. If that makes sense then you're welcome to send me an email (see profile). My door is open to working with up to a small group of people, provided they can support themselves now and its a good fit.

Thanks! I appreciate it. The player connecting to the world they build is vital IMO.

I'll be using old.reddit.com/r/Archapolis if you want to know when the first release is out.

Awesome, thanks! I may release a prealpha version for free or very very cheap in the coming months.

Feedback is really important to me. I'm aiming for a Venn diagram that captures what I want and what the users want.

Thanks! For now I'm using old.reddit.com/r/archapolis

www.yesboxstudios.com for blogging about development if you prefer long form

You might be interested in what I'm setting to out build. I'm working on Archapolis, a city builder with real time traffic simulation and interior views of peoples homes (which you can customize/build yourself if you want). While the game wont scale up to the country scale, I do want the player to have a more hands on approach to managing the city. Im thinking it would be cool if the player could hire their own board if they wanted to, otherwise they would have to manually manage that aspect of the game (e.g. no fire marshal could mean manually sending out fire trucks to fires, scheduling building inspections, etc).

Here's a tech demo of what I've been working on: https://www.youtube.com/watch?v=7q0l87hwmkI

I created a path finding algorithm that can simultaneously path 300,000 units to random destinations at a comfortable frame rate. Units can choose from any of the shortest paths between two points (there are many in a grid), and from those paths, can also choose the path that matches any preferences they have.

Very early stages of development still!

I've figured out how to make the path finding scale well-enough. Before I was using a hash table but that ate up 12.5 GB of space for 10,000 nodes. I looked around for better hash libraries and managed to lowered the RAM needed to 10 GB.

Then I figured out a way to store the results in a vector while still maintaining constant time access, which lowered the space needed to 2.5 GB. (This discovery came after the linked video, hence not being mentioned)

For reference, 10,000 nodes would be about 50 x 50 blocks (~4 nodes per intersection). Using Manhattan sized blocks, that's about 13 square miles of city, which is the same area as 3 x 3 Cities: Skylines tiles. Should be way more than enough!

Regarding the name, my first choice Metropoly was taken by existing companies (plural), and there's a domain squatter holding metropoly.com. Im not attached on the name yet so there's room to change it.

That would be quite an impressive game. Each simulation would need to be automateable in case the player does not want to manage that particular aspect of the game. Otherwise the game will fall into the trap of "trying to please everyone pleases no one".

Anyways, I'm working on Archapolis, a city builder game. The game will feature more hands on management than existing games in the genre, such as being able to design/build your own buildings. The player will see the interior of the buildings so making the exterior pretty wont need to be worried about. I'm also aiming to have a city board that will automate parts of the game for you if you choose (like having a fire marshall to handle fires)

I've got a tech demo of the path finding code up on youtube here, in case you're interested in path finding hundreds of thousands of units efficiently

https://www.youtube.com/watch?v=7q0l87hwmkI

This is such a fascinating challenge I want to tackle!

I'm creating Archapolis, a city builder game. Handling the micro economy is a far off goal. But one aspect of the game I want to implement on the macro scale is charging ~30% more for utilities and goods imported into the city.

So one of the goals of the player is help grow the businesses they want. This helps the budget in three ways:

- Collecting corporate tax

- Collecting sales tax

- Higher margins on goods

For anything that is imported, they city loses potential income by not being able to tax corporate and lower profit margins

I'm currently working on path finding right now, and I've got a tech demo here: https://www.youtube.com/watch?v=7q0l87hwmkI

I'm working on Archapolis, a city builder game. I have been considering the feature you are desiring. The problem to solve is giving the player something to do while the buildings are being constructed.

One way I have potentially solved this issue is by giving players the ability to design their own buildings in game. The player will see only the interior of the building, so I dont have to worry about making buildings look good (that's up to the player).

I dont have a video featuring this yet, but if you want to see what I've got so far, I've got a path finding tech demo here:

https://www.youtube.com/watch?v=7q0l87hwmkI

2x Thanks!

I'm using C++, SFML (graphics framework), and SQLite (for data storage/saves). Game & engine is developed from the ground up.

A lot of people choose existing engines for their games. I definitely would if I were to go 3D.

With 2D grid based games, it's not too difficult to get an engine up and running. It took me around 6 weeks IIRC (no physics or networking code though) to have basic tile placement functionality and outputting the game world to the screen.

You might be interested in what I'm setting to out build. I'm working on Archapolis, a city builder with real time traffic simulation and interior views of peoples homes (which you can customize/build yourself if you want). Very early stages of development still.

As for steroids, here's a tech demo of what I've been working on: https://www.youtube.com/watch?v=7q0l87hwmkI

I created a path finding algorithm that can simultaneously path 300,000 units to random destinations at a comfortable frame rate. Units can choose from any of the shortest paths between two points (there are many in a grid), and from those paths, can also choose the path that matches any preferences they have.

I'm working on Archapolis, a cross between sim city and the sims (and inspired by Dwarf Fortress, Cities Skylines). I'm working on real time traffic / pathfinding currently. My game can handle 100K to 300K agents path finding simultaneously to random destinations.

Game is still very early development, but here's a tech demo video

https://www.youtube.com/watch?v=7q0l87hwmkI