For the first entry in the progress pulse series I'll touch on some things from the past week or so. There's been a lot of smaller things being churned in the code base, some of them interesting, and others less interesting so I want to highlight a few. As a side note, it's really cool to see that the layout and architecture is allowing for features to be added pretty easily, so I'll dive a bit deeper on that. Overall, I'm pretty happy with how things are going.
Unity3D - Don't Fight It!
I heard from a colleague before that Unity3D does some things you might not like, but don't try to fight it, just go with it. To me, that's a challenge. If I'm going to be spending time coding in something I want it to be with an API that I enjoy. I don't want to spend time fighting it. An example of this is how I played with the stitching pattern to make my Autofac life easier with Unity3D behaviours.
However, I met my match recently. At work, we were doing an internal hackathon where we could work on projects of our choosing over a 24 hour period, and they didn't have to be related to work at all. It's a great way to collaborate with your peers and learn new things. I worked on Macerus and ProjectXyz. I was reaching a point where I had enough small seemingly corner-case bugs switching scenes and resetting things that I decided it was dragging my productivity down. It wasn't exciting work, but I had to do something about it.
After debugging some console logs (I still have to figure out how to get visual studio properly attached for debugging... Maybe I'll write an article on that when I figure it out?) I noticed I had a scenario that could only happen if one of my objects was running some work at the same time... as itself? Which shouldn't happen. Basically, I had caught a scenario where my asynchronous code was running two instances of worker threads and it was a scenario in my game that should never occur.
I tried putting in task cancellation and waiting into my unity game. I managed to hang the main thread on scene switching and application close. No dice. I spent a few hours trying to play around with a paradigm here where I could make my ProjectXyz game engine object run asynchronously within Unity and not be a huge headache.
I needed to stop fighting it though. There was an easier solution.
I could make a synchronous and asynchronous API to my game engine. If you have a game where you want the engine on a thread, call it Async(). Unity3D already has its own game engine loop. Why re-invent it? So in Unity3D, I can simply just call the synchronous version of the game engine's API. With this little switch, suddenly I fixed about 3 or 4 bugs. I had to stop fighting the synchronous pattern with my asynchronous code.
The lesson? Sometimes you can just come up with a simple solution that's an alternative instead of hammering away trying to fix a problem you created yourself.
DevOps - Build & Copy Dependencies
This one for me has been one of my biggest nightmares so far.
The structure of my current game setup is as follows:
- ProjectXyz.sln: The solution that contains all of my back-end shared game framework code. This is the really generic stuff I'm trying to build up so that I can build other games with generic pieces if I wanted to.
- Macerus.sln: The game-specific business logic for my RPG built using ProjectXyz as a dependency. Strictly business logic though.
- Macerus Unity: The project that Unity3D creates. This contains presentation layer code built on Macerus.sln outputs and ProjectXyz.sln outputs.
So what have I been doing?
- I build ProjectXyz.sln.
- The outputs go into this solution's bin folder
- I build Macerus.sln
- There's a prebuild step that copies ProjectXyz dependencies over
- The outputs go into this solutions bin folder
- I use a custom in-editor menu to copy dependencies into my Unity project
- This resets my current "dependencies" asset folder
- The build outputs form the other solutions are copied over
- I can run the project with new code!
I've been refactoring and renaming assemblies to better fit the structure I want. A side note worth mentioning is that MUCH of my code is pluggable... The framework is very light and most things are injected via Autofac from enumerating plugin modules. One of the side effects is that downstream dependencies of ProjectXyz.sln (i.e. Macerus.sln) have build outputs that include some of the old DLLs prior to the rename. And now... Visual Studio doesn't seem to want to clean then up on build. So what happens?
Unity3D starts automatically referencing these orphaned dlls and the auto-plugin loading is having some crazy behaviour. I've been seeing APIs show up that haven't existed for weeks because some stale DLL is now showing up after an update to the dependencies. This kind of thing was chewing up HOURS of my debugging time. Not going to fly.
I decided to expand my menu a bit more. I now call MSBuild.exe on my dependency solutions prior to copying over dependencies. This removes two completely manual steps from the process I also purged my local bin directories. Now when I encounter this problem of orphaned DLLs, my single click to update all my content can let me churn iterations faster, and shorten my debugging time. Unfortunately still not an ultimate solution to the orphaned dependencies lingering around, but it's better.
The lesson learned here was that sometimes you don't need THE solution to your problem, but if you can make temporarily fixing it or troubleshooting it easier then it might be good enough to move forward for now.