Home Forums Space/SciFi Combat and Simulation Game Discussion Limit Theory: An Infinite, Procedural Space Game

Tagged: 

Viewing 113 reply threads



  • Author
    Posts
    • #59432

      Limit Theory a new KS project.

      Quote:
      An RPG, RTS, and sandbox space exploration game all-in-one. Explore, trade, build, and fight in a beautiful, procedural universe.

      • An open-world space simulator / RPG
      • A sandbox game : No story, no restrictions.
      • Completely procedural : A completely new universe is only a button-click away.
      • Infinite : The game universe has no boundary.
      • Third-Person or First-Person : Command your ship from within or without.
      • Deep and intelligent : Engage in far more than just combat or trading.
      • Twitch-Based : Aim and fire weaponry directly, as you would in a shooter.
      • Approachable : Intuitive controls and slick interfaces ensure that playing will never feel like a job.
      • Strategic : Command an entire fleet when you amass enough cash to purchase more ships.
      • Extensively-Customizable : Outfit your ship, fleet, and space stations with whatever equipment you choose.
      • Single Player : A universe built just for you, that no one else will ever get to see (unless you choose to share it with them!)
      • Beautiful and Atmospheric : Gaze in awe at a universe as diverse, vibrant, and uniquely-atmospheric as your dreams.

      Site: http://ltheory.com/

      KS: http://www.kickstart…ural-space-game

      Good times for space sims. twitter thread since january

      the last tweet is pretty mysterious

    • #93872

      Pinback
      Participant

      Could in negations with a publisher,NDA and all that, although I guess time will tell what is going on.

    • #93873

      Geraldine
      Participant

      That too could be a possibility Pinback. It is puzzling though this total silence from Josh. The main thing is I hope he is ok.

    • #93874

      Pinback
      Participant

      It’s very strange although a single post on the forum or social media could clear this all up in a flash.

    • #93875

      It’s very strange although a single post on the forum or social media could clear this all up in a flash.

       

      Yes.

       

      Anyway, according to RPS, he is alive, kicking and working in LT. Good news  :girlcrazy: , but the extended silence is still a bit odd.

    • #93876

      Pinback
      Participant

      We might see an update in that case.

    • #93877
      sscadmin
      sscadmin
      Administrator
    • #93878

      Pinback
      Participant

      Good news that he is feeling better although their may be long term implication with the game.

    • #93879
      sscadmin
      sscadmin
      Administrator

      Do you mean in just getting it out?

       

      Yeah it will probably take longer which is ok by me. It just seems like Josh worked his self to bad health driven by his dream its a shame and I guess I would much rather do that for a dream of mine than for someone else πŸ™‚  Glad he is ok and Josh sounds motivated so lets see what 2015 brings and looking forward to see his next video update.

    • #93880

      Pinback
      Participant

      Do you mean in just getting it out?

       

      Sound like he suffered from severe burn out with developing the game and probably it would be best if he was to push the games release date back till later this year or even early next year.

    • #93881
      Cody
      Cody
      Participant

      What Pinback said – that sort of burnout is heavy stuff!

    • #93882

      Geraldine
      Participant

      Its good to see him back but he ought to take the time to heal. I posted a message for him in that thread D1 linked to.

    • #93883

      Really glad he’s back, but I hope he doesn’t push himself too much. I’d much rather see this game come out a year late than not at all. His development logs on youtube were amazing to follow.

    • #93884
      sscadmin
      sscadmin
      Administrator

      Here is something I pulled from LT forums while looking for progress that is interesting

      See more here in this posting: http://forums.ltheory.com/viewtopic.php?f=11&t=4640&start=450
       

      So the truth is, no, I don’t have anything to show at the moment, at least not graphics wise. But there is a tremendously-good reason for that πŸ˜‰
       
      Spoilers!
       
      Since people are getting angsty again, let me give some more detail on what I’ve been doing with LT. It’s quite technical but very, very important to actually being able to finish the game. So remember how I used to have this concept of testing ‘individual features’ in sandboxes using LTSL? Right, well, that was all well and good. But at the end of the day, it actually wasn’t all well and good, because, LTSL used the entirety of the game engine (liblt.so , liblt.dll, liblt.dylib depending on platform). It had no choice, because the game engine was one big blob. That means that, while each sandbox may only have called on particular features of the game engine, the entire engine was still there, in the background. Way too stuff was affecting the sandboxes simply because the engine wasn’t separated, it was ‘monolithic.’ Changes to improve the functionality of one sandbox would end up cascading through the entire codebase and, far too often, breaking other functionality in other sandboxes. It was remarkably frustrating and time-consuming.
       
      I’ve spent the past few months, in particular, completely changing this problem. LT is no longer a ‘monolothic’ engine but rather a compartmentalized (‘micro’) engine, comprised of many interlinked object files, each of which are independent from most others. Blah blah blah, technicalities. Why should you care? Why am I not able to show screenshots of this?
       
      Here’s the beauty: there are no screenshots of the game simulation, of the AI, of the core game logic, etc in isolation — and yet, I can develop them in isolation because one does not need graphics to develop any of these critical pieces of the game!! ‘Sandboxes’ are now simple console programs that give me readouts of market data, faction stats, etc etc. They have no concept of graphics. OTOH, the asset generation algorithms, which are a heavy WIP at the moment (I hope to be able to show you all some output as soon as I finalize the structure of the algorithms), need graphics but no other concepts from the game. They are simple graphical sandboxes to view single models, just like Maya or something of the sort.
       
      So. The game? Here’s the deal: you won’t actually see it until the component pieces are finished. At that point, we will wrap the player interaction layer over all the components, and that will be the LT alpha.
       
      That’s a high-level look at what’s going on right now. Frankly, I’m really excited about it. On a day-to-day basis, it makes me a lot more comfortable to be able to work towards a specific goal without touching code that needn’t be touched. In general, it makes me quite a bit more productive. It might sound like another one of my little ‘perfectionist’ tendencies, but, in fact, if one considers the complexity of a monolithic engine vs. a micro engine, roughly-speaking, it’s the difference between quadratic O(n^2) time to develop and linear O(n) time — that’s because the separation of dependencies ensures that touching one piece of a micro engine doesn’t cause a cascade effect that breaks all the other pieces. This is the epitome of the “wall of separation” concept that every good CS student should learn, but which I really failed to do well during my first attempt at structuring the LT engine.
       
      “Ok ok ok very technical, much wow, BUT I STILL WANT TO SEE THE GAME AND STUFF.” I know. Once I have asset generators in good shape, I’m going to stop being so stingy. I will be showing example assets as they come out of the pipeline when that pipeline is of sufficient quality. But, once again, as I have hinted at before, the next time you see a shot of the whole game (not just graphically, but including interaction and gameplay) will essentially be very, very close to BETA.
       
      Did that make any sense?? I hope so!

    • #93885

      Oh cmon you guys. It hurts me to watch you follow this game. Its clearly not going to be done this year or probably next. The dude burned out, I could see it the moment I counted the pimples on the youngster. He’s got excuses, hes got wonderfully written posts, and he’s got literally nothing to show for it. Come back to the light my friends! 

       

      Sorry to make light on you fellows and your pain, but… c’mon. Really? LT isn’t vaporware, but it’s not coming any time soon. His development is mirroring Bit Oddysey or any other number of 1 man dev teams. We’ve all seen it time and again.

    • #93886
      sscadmin
      sscadmin
      Administrator

      Oh cmon you guys. It hurts me to watch you follow this game. Its clearly not going to be done this year or probably next. The dude burned out, I could see it the moment I counted the pimples on the youngster. He’s got excuses, hes got wonderfully written posts, and he’s got literally nothing to show for it. Come back to the light my friends! 
       
      Sorry to make light on you fellows and your pain, but… c’mon. Really? LT isn’t vaporware, but it’s not coming any time soon. His development is mirroring Bit Oddysey or any other number of 1 man dev teams. We’ve all seen it time and again.

      Nooooooo…. it must be finished. I do see your reasoning and why it could be like this. Josh has been very silent and I definitely want to see a video because its almost been a year since the last one. I don’t like ever thinking something won’t be finished but it is reality sometimes. My son always wants me to purchase these early access games on steam and I try to explain to him when it is version 0.1.6 that it is very young in development and could take years to finish, nevermind that it is already a year old on steam πŸ™‚ But I cave and buy it for him anyway knowing one day he will tell me a favorite game of his closed down.

      I have to admit I thought he was close to release back almost a year ago, with that scripting language he wrote for the game let the players make the content. Just give us the engine and the framework and let the community build it. πŸ™‚ If its not out in 2016 though Ironhound I will accept your comments as true πŸ™‚

    • #93887

      Haha sorry man, its just I’ve seen this pattern with alot of kickstarters and early access games. Its made me bitter, and I’m seeing the EXACT same signs with Josh and Limit Theory as I’ve seen with other titles. Bit Odyssey, Malevolence: Sword of Ahkronox, Limit Theory, the list goes on and on. Basically, I’ve noticed a few reoccuring themes that I’ve seen across the internet.

       

      Personal issues cropping up. Normally, I would be sympathetic, until I realized how easy it is to say I have ‘mental health problems’ on the internet in order to buy time. A lady on kickstarter asked for thousands for medical treatment for suicidal tendancies. Her neighbor recognized her and revealed she was spending the money on parties and weed. (That was years ago, my memory could be off here.) With Malevolence, we hadn’t seen updates for months, and suddenly the dude behind it says he had to sell his house. I’ve seen this before. A long lapse in updates, and a personal issue, or ‘drive/data loss/computer death’ Its something you saw alot among the Half-Life modding community.

       

      I think I just have too much experience with this sort of thing lol. Half Life and The Elder Scrolls have magnificent modding communities with beautiful ideas. In a way, they are game developers, just on a smaller scale. Alot of these one man projects mirror a burnt out passion. You develop something, it becomes a full time job, you start dreading deadlines, and you stop having fun, your creative juices run on empty, and one day… you just get up and walk away.

       

      I wanted Limit Theory to succeed so I could buy it, but the kickstarter interviews just set off every warning bell I had.

       

      I would dearly love to be proven wrong.

    • #93888

      Pinback
      Participant

      I think their a good possibility that we will never know what’s going on LT but if the game fails to make any sort of appearance over the next year, then it probably won’t be released, where this will leaves the backers I have no idea.

       

      I always had the impression that LT has some good ideas which have been worked on a lot but the basic game from which to hang these ideas from may not be there and this may be the real problem as he seems to have spent a lot time working on the bits he likes while maybe ignoring the rest.

       

      One of the biggest problems with any crowd funded game is the changing or dropping of games features and it’s something we have all experienced if you have backed any crowd funded game.

    • #93889

      I think I agree with you pinback, I really feel like he only focused on the things he was interested, and assumed the procedural generation would fill in the rest.

       

      If nothing it was a REALLY cool idea. I just don’t think Josh is the one to pull it off.

       

      Luckily, we have space sims everywhere now, as opposed to when that kickstarter started, so I’m not as hurt about it. New games to take up the reigns.

    • #93890

      Anonymous

      Please read this post by Josh. 

       

      If you still are not convinced that Josh is working on LT then I’m not sure what to tell you.  We all want to play LT now, and we all want to see the features completed.  With Josh, we are going to get the finished product once he has found the fastest and most time efficient way to code LT.  Keep in mind that this also makes it easier for the end user to modify the game once it has been released.

    • #93891

      Pinback
      Participant

      Well I guess we will find out over the course of the next year.

    • #93892

      Please read this post by Josh. 

       

      If you still are not convinced that Josh is working on LT then I’m not sure what to tell you.  We all want to play LT now, and we all want to see the features completed.  With Josh, we are going to get the finished product once he has found the fastest and most time efficient way to code LT.  Keep in mind that this also makes it easier for the end user to modify the game once it has been released.

       

       

      Would you like me to go hunt down the big-worded posts with bolded and italiced words from Malevolence and Bit Odyssey? It means nothing when you havn’t put out updates in a while. The project may not be dead, but it isn’t coming out in 2016. I’ll eat my words, but I’m also so sure of this, I’d put money down on it. I’m not a blind believer, and I know a burnout when I see one. However, I respect your faith, and wish you the best.

       

      …just don’t take it too hard when it all falls apart. πŸ™‚ We are in a GOLDEN age for indie space sims. Astrox, Star Nomad 2, SR2 HD, Elite, Star Citizen, Star Sector, No Man’s Sky, etc. etc. etc.

    • #93893

      Anonymous

      Josh went though 6 months of burnout and mental health issues in 2015.  I’m not claiming that LT will come out this year (2016), but I do believe that Josh is now working in a healthier environment and in a healthier work week than he was in the past.

       

      If LT falls apart I will have lost a game which looked great, but also gained a handful of friends which I will be keeping in contact with.

    • #93894
      sscadmin
      sscadmin
      Administrator

      Finally a post from Josh:

       

      So yesterday I had written a rather lengthy response / update to this thread trying to clarify some of the questions popping up about the old vs. new underpinnings of LT…then I had to move locations, and when I hit submit my internet was gone and, naturally, phpBB doesn’t save the form state so when I hit back my response was also gone (so I gave up). Gonna try again today, using the clipboard more frequently :ghost:

      Here’s a basic rundown of what was and what is, why we’re in much better shape than before, etc πŸ™‚

      Old Setup:

      • Engine and most gameplay components written in C++ (~100+ source files since I like to keep things separated). Used some heavy-handed C++ constructs, adding to compile-time.
      • Despite being separated in terms of files, engine components were highly-interconnected, as I wasn’t good at modular structuring when I started this journey.
      • LTSL implemented via compilation to expression tree (like an executable AST), scripts executed via this tree — a fairly slow but clean approach
      • High build times due to interconnectivity and ‘monolithic’ structure (LT engine implemented in a single DLL / dylib / .so); even making changes to an isolated feature required an annoying amount of link time
      • Above problem led to higher use of LTSL for more and more features, eventually leading to exposing the performance limitations of LTSL…this ultimately backed me into a dark corner

      New Setup:

      • Minimal ‘platform’ written in very light C++ (basically C; no usage of the ‘heavy’ C++ features, no usage of C++ standard library); platform contains core graphics / audio / system functions (i.e. the microcomponents of the engine)
      • Everything else, including higher-level pieces of the engine as well as gameplay, written in a specific subset of an existing high-level language (i.e., an industrial-strength one πŸ˜› ). The platform configures, injects functionality into, and then starts up the language’s environment. LT is then started in the HLL.
      • Wait! Engine functionality written in a high-level language??? Sounds like another performance disaster / LTSL situation waiting to happen! — probably what you should be thinking right about now. This is where ‘magic’ happens. The platform on which everything rests allows for something rather awesome — it allows for pieces of the HLL code to be transformed into native machine code that executes as fast as anything that was pre-compiled into the platform. The awesome part is that the code can remain written in the high-level language, it just needs to adhere to a few things, and mark itself as wanting to execute ‘natively,’ and the platform automatically takes care of the rest.
      • Ultimately, this means we have both performance-critical and non-performance-critical code written in the same language but executed in different ways. So the beauty of it all is that I don’t need to guess whether or not some AI routine or PCG algo is going to be slow…if I run the game and it’s slow, all I have to do is mark it (this is done in the language itself, via a mechanism I added), and next time it’ll be converted to pure, optimized machine code that runs natively, just like all of the old LT used to run. There are a few drawbacks for code that wants to do this (namely, it can’t use the full featureset of the HLL, otherwise it wouldn’t be possible to convert it to low-level). But overall it’s an awesome setup that makes development so much more tractable AND makes sure that we’re ready to handle performance issues if and when they arise.
      • Due to this structuring, engine and game code can be developed independently. Entities needn’t be rendered in 3D just to see basic information about what they’re doing, what’s in their inventory, etc. The old testbed approach is just magnified 100x here, because we can play with even more minimal pieces of the game thanks to not having a monolithic engine.

      Please excuse my poor articulation of that all….I’m so caught up in the code right now that I think my english is degrading πŸ˜› At any rate, the point is, this restructured foundation for LT solves both the performance issue and the development complexity issue (good lord, I can’t even tell you how many lines of code are saved writing entity logic in the HLL!)

      Yes, details are intentionally withheld until all is ready to be revealed πŸ™‚ For now, though, I hope some of you can take peace in knowing that the platform is finished enough to be able to work on both game and higher-level engine code. All three of these things can be worked on concurrently. And gameplay code is being written – far more quickly than used to be possible :squirrel: It is currently first priority, as I want to know as soon as possible which pieces of gameplay code will require the platform’s ‘magic,’ and then test to verify that it does indeed remove performance bottlenecks as I expect (naturally this testing has already been done (successfully) on typical performance-benchmarking code, just not with LT gameplay code yet). Having written a good bit it already, I can tell you guys that, all this technical stuff aside, the single best part of this new approach is that building LT actually feels like building LT, not like thinking about the best way to implement each tiny piece of it. In that respect, a HUGE burden has been lifted from both myself as well as future modders!

      I told you all I was going to play it stealthy until I’m ready to show everything, but there’s a little peak at the structure so that you all don’t have to guess as much (although now I’m sure I’ve left new things to guess at…

    • #93895

      Pinback
      Participant

      Anyone know what the current state of the game is?.

    • #93896
      Cody
      Cody
      Participant

      Nope! I occasionly post in the LT forum’s off-topic section, but don’t bother with anything LT-related.

    • #93897
      sscadmin
      sscadmin
      Administrator

      They say Josh is still working on it. I truly hope he finishes it at least get it to a releasable state for the kickstart backers. The LT scripting language he was working on was amazing and you could possibly just finish the game using that if it was finished. But it is a shame this went dark for the most part because it was looking to be a great game. I know Josh had health issues and maybe some still. But he also collected over $100k, so this game needs to be finished.

    • #93898

      Anonymous

      They say Josh is still working on it. I truly hope he finishes it at least get it to a releasable state for the kickstart backers. The LT scripting language he was working on was amazing and you could possibly just finish the game using that if it was finished. But it is a shame this went dark for the most part because it was looking to be a great game. I know Josh had health issues and maybe some still. But he also collected over $100k, so this game needs to be finished.

      Hello again.  Since Josh doesn’t make official updates a topic has been made by one of the moderators which follows Josh’s latest LT related posts which can be found here.

      I’m hoping that Josh finishes development by the end of this year, but with the lack of information it is difficult to make a judgement.

       

      Hi Cody, nice to see you over here as well.

    • #93899
      Cody
      Cody
      Participant

      I’m hoping that Josh finishes development by the end of this year, but with the lack of information it is difficult to make a judgement.

       

      <waves> I have my doubts about that. Josh seems too wrapped-up in the ‘beauty of the code’ – dangerous!

    • #93900

      Hello again.  Since Josh doesn’t make official updates a topic has been made by one of the moderators which follows Josh’s latest LT related posts which can be found here.

      I’m hoping that Josh finishes development by the end of this year, but with the lack of information it is difficult to make a judgement.

       

      Hi Cody, nice to see you over here as well.

       

       

      Not a chance in hell. He’s made nothing resembling anything even remotely gameplay like. If he had even a few screenshots the fanbase wouldn’t be crawling up his ass lol. As it stands ya’ll got suckered.

       

      If he releases the game before I die of old age, I’ll admit you where right. If he releases the game this year, I’ll happily buy you a space sim off of Steam. That’s how certain I am this is beyond dead. Dude is in way over his head, with nothing but his ambition. I can get a loan and buy a ship too, doesn’t mean I’m ready for the ocean, or to build one from scratch.

    • #93901

      Pinback
      Participant

      Will be interesting to see if anything is heard from him in the next couple of months or will it be another wall of text.

    • #110141
      sscadmin
      sscadmin
      Administrator

      Finally a update from Josh, let us know what you think and enjoy the read:

      Hello and good evening lovely Limit Theorists!

      Warning: please ensure that your seat-belts are fastened, cockpits fully-pressurized, and pulse weapons overloaded to at least 110% of standard operating power. It’s going to be a long ride through this sector.

      ~ Introduction ~

      First off, I’ve got to start by saying that this post is coming to you several months too late, but, as I’ll discuss later, I’m taking serious steps to ensure that I change my communication habits. I’m sincerely sorry for not being on the forums for several months; I know, coming back and reading some of the intermittent posting, that it’s taken a toll on many of you guys’ outlook on the game. With this post, I aim to lift that outlook, but also to open up the hood and talk about why things are the way they are at the moment.

      Before we get down to it, a word about my previous updates and the community’s response. If you’re one of the many posters who has said something to this effect, know that I’ve heard you when you said “no more vagueness,” “concrete details,” “more than promises/empty words,” etc. I got it, my previous updates were not satisfactory, but give me a chance to prove to you that I can, in fact, change πŸ™‚ On the other hand, a forewarning: to those who have demanded “pictures/videos or LT is kill,” let me tell you up-front that you’re going to be disappointed. I’ll explain in detail why that’s not what development is about right now, and this is the part where you all are going to have to meet me halfway in understanding that progress and pretty screenshots are NOT equivalent — a mistake to which I’ve fallen prey for much of LT’s development.

      The fact that development is not fun, pretty, or exciting (at least to most) is part of the very reason for which I haven’t been excited to talk about it, and have even avoided doing so. For years I had beautiful things to throw up in the air and say “LOOK WOT I DID!” and receive praise for making things shiny. Man I miss those days so, so much…but the problems I’m dealing with currently are far more pressing to LT being released than more visual candy. I simply have to push through the problems I’m about to explain if you want LT to be finished. And I have every intention of LT being finished. There will be more pretties, more videos, etc., but let me be very clear: that won’t happen before I get past the current roadblock.

      ~ Development: Where We’ve Been, Where We Are, Where We’re Going ~

      To understand why development has taken the bizarre course that it has, I must take you back all the way to just before the Dark Days, when the ‘Road to the Beta’ was in full-swing and Josh was burning his candle at 17 different ends. Things seemed to be moving quickly and beta seemed within reach. Then, all of the sudden, the Dark Days were upon us. What exactly happened, other than stress and an unhealthy lifestyle pushing me over the brink? What happened is that I was backed into a corner from which there was no easy escape. I had been backing into this corner for quite some time without realizing it.

      LT was, at that time, a massive codebase. Not massive in relation to how much it did, but still massive with respect to your average programming project. With both C++ and GLSL included, the code was pushing dangerously-close to 100,000 lines. Interestingly, 100K lines is a bit of a special number in programming. It’s one of those rule-of-thumb things, but a large number of programmers, now including me, have found it to be roughly accurate: they say that a skilled programmer can manage about a hundred thousand lines of code. What do I mean by that? Think of it like RAM: your computer has a certain amount of RAM. When a program tries to use more memory than you have RAM, typically the program will still function via an OS mechanism called ‘paging,’ wherein hard drive space is used to effectively extend the limits of RAM. Problem is, doing so comes at a huge cost (less so with SSDs, but still a high cost): RAM accesses now may take orders of magnitude longer due to needing to page in/out memory from/to disk. Sure, your program will still run, but the moment you hit your RAM limit, a typical program will almost immediately incur a huge performance penalty. And so it is with programmers! Good programmers have a ‘RAM’ of about 100K lines of code. Beyond that, the difficulty of understanding and maintaining said code quickly becomes disproportionately hard, leading to a harsh dropoff in productivity.

      So, I was starting to approach the limits of my programmer RAM. My solution to this problem (as well as modding) was LTSL. LTSL made things gloriously easy to understand, and, for a while, made development gloriously fast in comparison to how C++ development had been. There was a brief period of time wherein I found myself basking in the sun and all was right with the LTverse. LTSL was making development a joy, I was able to keep everything in my mental RAM thanks to the compactness of the language…things were great. Until, one day, they weren’t.

      You see, while I had successfully evaded one wall, another was sneaking up on me, and I would soon be caught between a rock and a hard place. LTSL, like all non-compiled scripting languages, was slow. Not terribly slow, but certainly slow in comparison to C++. This was the price I had to pay for offloading gameplay code to LTSL. I didn’t anticipate that the price would be too much. On that point, I was quite wrong. It was a rather sudden thing, due to the nature of Limit Theory — there’s so much going on at all times…so many game entities, so many UI components, so much AI, so much physics, so much rendering — speed degradation of only a small bit of code can cause a frightening FPS hit, since that code may be running every frame on every entity that, just for example, emits an EM signature that can be picked up via scanner. As I pushed into my beautiful new world of C++ & LTSL, I was also pushing closer to the invisible wall of performance problems, and then, one day, I hit it: FPS was down to ~20 even in situations where a relatively small amount was going on (i.e., even without LOD system simulations active, without distant AI, etc.) I knew I was in trouble, because I knew it was just the tip of the iceberg, and that performance was going to quickly go to hell in a handbasket if I continued using LTSL, my saving grace. On the other hand, my inability to mentally manage and make progress on a near-100K LOC codebase in C++ awaited me if I were to turn back. In either direction, I faced a sharp drop-off, either of productivity or performance. I was in a truly impossible situation, and for once, my Crazy-Solution-Generator-3000 failed me. Cornered and out of options, with a community expecting an imminent RTB post, my kernel crashed. And it crashed hard.

      Therein lies the rub, the truly monumental challenge at the heart of building LT (a challenge so formidable that I’ve given it the title of The Fundamental Problem of Limit Theory; FPLT for short): the completion of Limit Theory demands the utmost efficiency in both run-time performance (a la C++), AND development cost (a la LTSL). These two interests, as most programmers know, are in oppisition to one another in the world of development. In general you can have one, not both. But, you see, with an enormous amount of gameplay logic to crunch on an enormous number of entities, and only one programmer with one mental RAM bank on which to make that all happen, Limit Theory requires both. Voila, FPLT.

      ~ Solving the Fundamental Problem of Limit Theory ~

      While I’ve worked on a lot of areas of LT over the past two years (since the Dark Days), >95% of my effort has been devoted to solving FPLT. This has made for a very, very frustrating two years as I’ve bashed my brain against the hardest problem of my programming career. I’ve explored numerous solutions. Each prospective solution requires a tremendous amount of effort to even get to a point where I have a simulation large enough to know whether or not said solution will be viable (i.e., I have to build a large-scale, component-based entity simulation with AI to know whether a solution is both compact and performant enough to be an answer to FPLT). So far, the answer has been ‘no’ to each. Despite all of my accumulated knowledge of code, performance, etc., it’s still far too difficult for me to simply intuit whether the prospective solutions will be viable, hence why testing is the only option. It’s been a slow, painful process of trial-and-error.

      I promised details, so let’s talk about some of my concrete work over the past two years. I’ve seen posts implying that I haven’t been working, and honestly, I can’t let that rumor stand. I’ve been working entirely too hard to get no credit for it, so I’m finally ready and willing to pony up the gruesome details, even though it goes against my long tradition of feeding you all nothing but unicorns and cupcakes πŸ™‚ So here it is…the good, the bad, and of course, the ugly. Put your gloves on.

      First, naturally, there was an attempt to rescue the existing LT by amping up LTSL with a performance overhaul. A practical move at the time. It was a relatively fast failure. I optimized, I changed the way LTSL runs, I molded the memory access patterns from ‘my RAM is crying’ to ‘it could run on punch cards!’ Still, I could see that the numbers weren’t going up. The gulch between the statically-compiled and intensely-optimized C++ and the runtime-compiled LTSL evaluation engine was too wide to make a dent. Despite my efforts, I’m a bit embarassed to admit that I wasn’t ever able to improve LTSL’s performance dramatically over baseline, even after blasting it with some of my best optimization cannons.

      With the most practical option shot down, I switched attack vectors and tried what seemed to me the next most practical: splitting the C++ into smaller bits to make it more manageable. I split up what was a ‘monolithic’ engine, compiled all into one library, into component pieces compiled into different libraries (libltcore, libltrender, libltui, libltai, etc.); this was an attempt to increase both runtime efficiency and my ability to keep all code in RAM. This attempt, luckily, only cost me a few months, as I quickly learned that code is code, and the programmer RAM limit applies no matter how you divvy up the lines. Another solution shot down, another lesson learned.

      I then moved on to a more dramatic change, recognizing that, clearly, the C++ core was simply too big. I was going to have to reduce. Thus ensued one of the most dramatic shifts in LT’s development history, as I carefully plucked pieces from the existing codebase and brought them over to a new, ‘minimal’ C core library. The general idea was to do the really performance-critical stuff in C, do the rest in a still-fast but high-level language (side note: I say C because, by this point in my programming life, I had basically abandoned most C++ constructs, so moving completely to C was not a big issue — C libraries are friendlier when it comes to linking with the outside world, which is what I was planning to do with respect to the high-level language). My language of choice? Python. It took quite some time, but I eventually engineered the salvaged ‘minimal’ core of LT, which was a very reasonable 20K lines, along with a cluster of (concise and easy-to-write) Python scripts that could leverage the LT core library for all of the performance-critical and gpu-related stuff. It was quite beautiful. Of course, I knew what I was getting in to: Python is slow. On the surface, it might not look too different from the old LTSL solution. But, unlike LTSL, Python has a massive ecosystem surrounding it. For performance, there’s pypy, Cython, Psyco, Pyrex, etc. Much to my chagrin, none of them suited my needs (pypy looked promising, but simply didn’t give a big enough speed boost). So I pursued a custom JITing solution. I wrote an intermediate-representation, an AST translator that took Python code to my IR, and an emitter that took my IR to C, which could them be JIT compiled in-memory and executed as machine code by the wonderful TCC. It was a beastly feat of code. In the end, it broke my heart when this solution also failed, not due to performance reasons, but because, as it turns out, compiling Python to a static language (or an IR intended for emission to static language) is indeed near-impossible. Too difficult for me, at least. My JIT worked for simple and moderately-complex logic, but it simply couldn’t handle the ‘meaty’ gameplay logic of LT, as the problem of type inference and other fun things started to become intractable.

      On the bright side, not all was lost with the valiant Python attempt. I did lose quite some time (perhaps on the order of six months) to it. From it, however, I had gained the minimal core onto which I have continued to build (with minimalism!) to this day. The C core will be part of the solution to FPLT. I now have that piece of the puzzle. For the other piece, the ‘driver’ that will control the core, I’m still searching.

      That brings us up to the present. At this time, my current attack vector is twofold.

      I’ve been building a solution involving LuaJIT for several months now and am nearing the point where I can do a feasibility test. While I’ve learned to temper my expectations and wouldn’t say that I’m confident that LuaJIT will be the answer, I can say that it’s by far the fastest scripting solution I’ve found. My initial tests, indeed, the only reason I began pursuing a solution in Lua (which wasn’t really on my radar), demonstrated that LJ achieves incredible speeds on limited-scope performance tests, even nearing the speed of my own, hand-written C. That’s not terribly surprising, since LJ is a genuine JIT, meaning that it’s effectively turning Lua into assembly/machine code. It seems to be darn good at doing so. That being said, we’ll see how it goes with a full-blown test. I have my reservations about Lua being garbage collected, and I fear that memory access, if anything, may make LJ infeasible. Nonetheless, LJ itself is a formidable feat of engineering, and even if it doesn’t end up solving the second piece of the FPLT puzzle, I have a feeling it may still contribute somehow to the final answer (this has happened with so many other ‘failed’ ideas throughout the course of LT that these days, I almost expect a failed attempt to end up being useful in some way in the future).

      On the other front, I’ve been building a solution that involves generating C++ via a meta-language based on Python. This would provide a means of performing a lot more of the game logic in ultra-fast compiled code without me having to write 100K lines. In order to get LT working in as few lines as I did previously, I had to use a HUGE amount of complex C++ trickery. While it meant far fewer lines to keep up with, it also made the code more complicated and, in a few cases, sub-optimal in terms of performance. With a meta-language, we can easily solve these problems: I don’t care how much code is generated, I only care how much I have to write to generate it. So, for example, whereas setting up the component-based entities in the old C++ engine took several layers of advanced C++, making the component logic hard to understand (boy was this a nightmare with the ‘market’ component…), I can generate equivalent code in far fewer lines of simple Python. As a bonus, the generated code compiles and runs faster because it’s not having to use trickery to reduce code size…I can get Python to spit out tens of thousands of lines in milliseconds, based on ~100 lines of my meta-language. This solution is only a few weeks old, and is sort of a ‘nuclear’ option in the event that the LuaJIT solution doesn’t work out. I’m fairly sure that I can get this approach to work, because it’s kind of brute-force. I’d rather be able to find a more elegant way, but if this is what it comes down to, so be it…above all else, I just want to get Limit Theory released at this point, and I’m willing to use whatever I have to use to get there. (By the way, this is totally differenet from the other solution involving Python. Whereas the idea there was to convert Python to machine code on-the-fly, the idea here is simply to use Python as an easier way to write / automate the writing of C++. Kind of like…writing the code…procedurally!)

      So there you have it…the past two years of my life. Has it been shiny? No. Has it been as exciting as the first two years of LT dev? No. But the hard truth is that Limit Theory is an exceptionally-ambitious project, especially considering that we can’t just brute force the development with a massive team and all the standard big-budget amenities. Yes, I was young and optimistic when I called it ‘easy.’ My mistake πŸ˜• LT is a hard problem. At the center of it all lies FPLT, which encapsulates the problem of needing to build something complex with minimal resources. It’s a solveable problem; of this I’m certain. The solution? No, of this I’m not yet certain, but, as I hope to have demonstrated by laying all of my attempts out on the table in detail, I really am attacking it with everything I’ve got. I can’t sugarcoat this situation as I’ve tried to do in the past, because it just leads to disappointment, so let me be perfectly honest: I don’t know when I’ll overcome FPLT. I sure as hell hope that it’s soon, because two years is already an exceptionally-long time to be beating one’s head against the same problem. What I do know is that every failure gets me closer. I learn more about what works and (perhaps mostly..) what doesn’t with respect to performance in large-scale simulations. I learn more about low-level performance both of static and dynamic langauges, which helps me to evaluate future solutions. I become adept with more languages, more technologies, hence have an ever-expanding arsenal with which to blast away at development problems (FPLT can only take so much DPS before it breaks. It’s a tough tank, but every month my DPS output goes up. It’s only a matter of time…) In the mean time, I continue to develop the LT core C library as much as possible to ensure that when I do come to the right solution, all of the underlying machinery is in place for me to quickly and easily plop the existing LT functionality into the mold of said solution.

      Is anyone still listening? :shifty: :ghost:

      ~ Re-Establishing Communication with the LTVerse ~

      Clearly, something needs to be done about my communication habits. Here’s the good news: a large part of what’s been causing me to not want to communicate with you all is, as mentioned above, the rather unglamorous nature of my work. I wanted to come back to you guys with guns blazing, yelling “YESSS LOOK AT THIS! AND THIS!! AND BETA IS COMING UP!” But I’m ready to accept that I can’t work that way anymore. Showman Josh and Perfectionist Josh are mostly dead at this point, and I think you’ll all be pleased to hear that Pragmatic Josh is now in full effect. At this point, my mentality on any given day is ‘find the shortest path between where I am and LT being released. Follow it.’

      So from this point forward, I will plan to use my Sunday evenings to write a dev log — however brief, unglamorous, or unexciting it may be — to inform you all of my work over the past week. I’m not yet sure whether I want to do this every week or every other week, so I’ll have to start with it and just go with what feels best.

      Again, I’m trying very hard to not make the same mistakes that I’ve been making with communication and end up disappointing you guys. To that end, I’m promising a regular but modest communication, something that will ensure you all that I’m still working to get LT in your hands without requiring as much of my time and effort as the daily dev logs, the monthly videos, RTB, etc. With FPLT I’m taking battleship-sized steps, but with communication we need to start back with fighter-sized steps πŸ™‚

      (Oh, and yes, this does count for my first log…I’m not going to post more of my life story today :P)

      ~ Gratuitous FAQ / Autointerview ~

      I thought it might be interesting, if a bit strange, to ask myself questions from the perspective of forumers and squeeze some answers out of myself. In the event that someone actually does ask one of these questions, now I’ve already provided an ‘official’ answer. Maybe you will find it enlightening. Or perhaps just strange. Either way, enjoy :ghost:

      Q. Thanks for joining us Josh.
      A. Thanks for having me, imaginary forum member. What can I answer for you?

      Q. Well, I read your post. I honestly did. But all I really heard was ‘code code code C++ Python code Lua code JIT beep boop mainframe.’ So…what’s going on with Limit Theory, you know, that GAME that I’d like to be playing right now?
      A. Yeah…it frustrates me too. I don’t enjoy working on the technical side of it all nearly as much as I used to; frankly I would much rather be tying off loose ends on the AI, zone control mechanics, simulation LODing, unstable wormholes mechanics, etc. But, as I explained, this problem must be solved before I can finish LT, and I would rather throw myself entirely into solving it than split my time between solving it and trying to write gameplay code when the platform for said code isn’t yet a solved problem.

      Q. So it sounds like you’ve made no gameplay progress then.
      A. Not true, but it is true that I haven’t made nearly as much gameplay progress as you would want from two years of work (see above: >95% effort dedicated to the big problem).

      Q. Oh? So then, what part of the game has changed the most since we last saw it?
      A. AI has progressed quite dramatically. The top-level AI action (‘Action_PlayGame’, heh) is much more fleshed-out than before, meaning AI players are capable of literally ‘playing’ Limit Theory to a greater capacity than before. There are still missing elements, mostly because of missing logic for actions that deal with higher-level concepts like war, research, and construction. There’s still a good bit to do here, but, having written some AI now in both Python and Lua, I’ve gotta say that, if we can get a fast scripting solution to work, AI development is going to go much faster when resumed full-time!

      Q. Cool. You mentioned some stuff in the post that kind of scared me and made me think you’re basically re-writing LT. Is that the case?
      A. Definitely not. I’m changing the foundation on which LT rests, but by no means have I torn down the building. As stated above, the ‘core’ pieces of LT, i.e., much of the actual ‘engine,’ is still present in the C library. GPU code is all present and doesn’t require porting. As for gameplay code / stuff that used to be in LTSL, I’ve ported it enough times now to know that it’s a quick task. I’ve said it before and I’ll say it again: it’s the ideas beneath the code that the majority of the time to come up with. Typing code is easy. Coming up with an idea that will make the code do something wonderful isn’t. Very little is ‘lost’ in this process.

      Q. Hrmmm….so then, you’ve got it rendering and such?
      A. Yep, I’ve got it rendering under both the current attack vector (LuaJIT) and the older one (Python). It’s not really a big task with the library in place.

      Q. Sweet, so, screenies?
      A. Don’t…even…!

      Q. But I… :3
      A. It looks the same as what you’ve already seen. I haven’t worked on graphics! Seriously, the graphics monkey is in the cage. Gameplay, yes. FPLT, very yes. Graphics, no. I literally haven’t changed the LT graphics in two years. It’s been hard for me to control myself like that, but yes, I’m ready to accept that the current graphics are absolutely good enough for release. LT 1.0 is going to look very much like the latest screenshots you’ve seen, except with the missing content filled in. No more ‘new metal shader version 298.0’.

      Q. Fair enough. I’m glad you managed to control the monkey. Speaking of monkies, when beta?
      A. When I solve FPLT and steamroll the remaining gameplay content.

      Q. Ugh. I hate this ‘FPLT’ thing. You know, now that I think about it, what if you just … ? Wouldn’t that work?
      A. (Depending on nature of …): No, sorry. / It’s a good idea but I’ve tried it and it didn’t work out. / Well, that’s essentially what I’m trying to do. / Dear God, why didn’t I think of that, you’re a genius, FPLT IS SOLVE o/ *hands over bank account while weeping tears of joy*

      Q. Okay then…back on-topic, why did you desert the forums?
      A. I honestly didn’t mean for it to become a ‘thing.’ It snowballed out of control: I just wasn’t on the forums for a while, not for any particular reason, and then one day it was like a ‘Josh is gone’ thing, at which point I could have chosen to say “No I’m not,” which would have pretty much done the trick. But instead I chose to give in to anxiety and was all “oh no, I’m gone!? Well now I have to come back with fireworks! :?” I really regret making that decision and letting it stagnate for so long.

      Q. You should, a lot of us pretty much lost faith in you.
      A. I understand. To be honest I can’t say that I deserve more. All I would ask is that you give LT the benefit of the doubt in the sense that when it comes out, judge it as Limit Theory the game, not as Limit Theory the product of a guy who let you down.

      Q. We’ll see. What about Kickstarter though? I mean it’s been even longer in the dark for them…
      A. It’s been a general pattern throughout development that I post more frequently to the forums than to KS. Historically, I’ve only put up KS posts when I felt that I had ‘very substantial’ material to post. As per above with the whole ‘not a glamorous era in development,’ I felt that I’d be letting everyone down with a text-based post, even if it’s the best way to bring everyone up to speed. Once again, a regrettable choice made by Showman Josh, but now attempting to be set right by Pragmatic Josh.

      Q. I like the sound of this ‘pragmatic’ Josh guy. Maybe he can finally get us a game?
      A. Yes.

      Q. Again, we’ll see. I’m almost ready to dip my toes back into the water, but the truth is, you seem pretty good with words, yet have let us down quite a few times with those words.
      A. Which is exactly why I’ve not sugarcoated this situation. Did you get the same ‘thrill’ reading all this that you did when I released an update video? Most assuredly not. But what I’m good at is raw honesty, which sometimes makes it hard for me when I honestly believe in my capability to do things at which I end up failing, or when the situation is honestly not so great. But I think you all, at this point, would much rather hear not-so-fun truths than nothing at all, which are the only two choices I’ve got. Notice the lack of glitter, unicorns, and grandiose promises in this whole thing!

      Q. I certainly noticed the lack of glitter. Speaking of which, why on earth did you not provide a TL;DR for what may be your most obnoxious wall of text ever?
      A. I considered it. I even wrote a TL;DR. But I realized very quickly that doing so was completely counter-productive to the point of this whole post. I took a lot of time to try to explain the current state of Limit Theory development; to try to get everyone to understand precisely what I’m doing from day-to-day right now and why it’s necessary. If someone truly wants to understand it, they need to read this post. If not, then ‘LT is not kill’ should suffice. I can’t explain it all and make my explanation super-compact. I could do that back when everything could be explained with images or videos. I can’t do that at the moment.

      Q. Indeed. Well, I’m rather exhausted from reading, and it’s apparent that you’re not going to give me screenies, so I’ll end it here. Thanks for the answers, and good luck with LT. I look forward to that (semi)weekly log.
      A. Thanks for listening, imaginary forum member.

      <3 Josh

    • #110641
      sscadmin
      sscadmin
      Administrator

      Here is some videos based on some developer info from the limit theory forums:

      https://www.youtube.com/watch?v=CCJ1em7R0MY
      https://www.youtube.com/watch?v=e9CVuSPuZPc&t=66s
    • #110971
      sscadmin
      sscadmin
      Administrator
      https://www.youtube.com/watch?v=IaJ1l86Rlr8
Viewing 113 reply threads
  • You must be logged in to reply to this topic.