PDA

Archiv verlassen und diese Seite im Standarddesign anzeigen : Limit Theory: An Infinite, Procedural Space Game


Metal Maniac
2014-07-12, 16:43:49
Da es anscheinend noch keinen Thread dazu gibt: Limit Theory, das im Dezember 2012 erfolgreich bei Kickstarter (https://www.kickstarter.com/projects/joshparnell/limit-theory-an-infinite-procedural-space-game) losgetreten wurde, nähert sich langsam dem Ende der Entwicklung, hier das neueste Update:
https://www.kickstarter.com/projects/joshparnell/limit-theory-an-infinite-procedural-space-game/posts/897359

Es handelt sich hier um eine Art Sandbox-Space-Game in einem komplett prozedural generierten Universum (das schließt Raumschiffe, Planeten, Asteroiden, Stationen etc. mit ein). Was der Typ da auf die Beine gestellt hat ist meiner Meinung nach ziemlich beeindruckend:
http://www.youtube.com/user/LimitTheory

Hab' mich beim Kickstarter auch beteiligt und bin gespannt, wie das Endprodukt wird. Beta soll Ende 2014 für Backer rauskommen, das fertige Spiel Anfang 2015.

N0Thing
2014-07-13, 19:31:36
Ja, ich freue mich auch schon sehr auf das Spiel und die Entwicklung anhand der monatlichen Videos zu verfolgen war ebenso interessant wie unterhaltsam. :)

Im Forum kann man auch tägliche Entwicklungskommentare lesen (Link (http://forums.ltheory.com/viewforum.php?f=12&sid=dcfba9f38acf00bf6e34f65b44e22ad4)), ebenso gibt es dort auch torrent-Links zu den letzten monatlichen Videos, bevor sie bei Youtube hochgeladen wurden. (Link 2 (http://forums.ltheory.com/viewtopic.php?f=11&t=2642))


E:\ Die offizielle FAQ: http://forums.ltheory.com/viewtopic.php?p=5470&f=11#p5470

N0Thing
2014-10-07, 00:31:04
Neues Entwicklervideo zu Limit Theory. Ich bin immer wieder erstaunt, was ein einzelner heller Kopf so auf die Beine stellen kann. :)

MumoTz8CKtE

Metal Maniac
2014-10-08, 22:55:38
Jo, vor allem hab' ich hier nicht das Gefühl, dass jemand einfach nur die Kohle einstreicht und ansonsten 'ne ruhige Kugel schiebt, wie das bei einigen anderen Kickstarter-Projekten den Anschein macht...

Static
2014-12-20, 12:13:34
Neues Entwicklerupdate der letzten zwei Monate:
0tPdbLe3zx0

Keine Ahnung, ob daraus jemals ein brauchbares Spiel wird, aber die Videos sind einfach jedesmal großartig anzuschauen...

N0Thing
2016-05-02, 19:56:36
Wer weiterhin auf Limit Theory wartet, es wird weiter entwickelt, allerdings mußte der Entwickler Josh Parnell aus privaten und gesundheitlichen Gründen eine Auszeit nehmen, arbeitet inzwischen aber im und mit Unterstüzung des Louisiana Technology Park weiter an seinem Projekt.

https://www.kickstarter.com/projects/joshparnell/limit-theory-an-infinite-procedural-space-game/posts/1122988


Wer den Verlauf der Entwicklung weiter folgen möchte, aber dafür nicht das LT-Forum nach Neuigkeitenschnipsel absuchen möchte, der kann in diesem Foren-Thread (http://forums.ltheory.com/viewtopic.php?f=2&t=5031) alle relevanten Beiträge von Josh finden.

Metal Maniac
2016-05-03, 11:38:49
Danke für die Links, dachte das Projekt wäre schon längst gestorben, hatte es nach der Auszeit von Josh nicht mehr auf'm Radar. Bin aber nicht mehr ganz so überzeugt, ob da wirklich noch was Vernünftiges bei rauskommt...

N0Thing
2016-05-03, 18:17:12
Ich schwanke auch immer wieder zwischen Hoffnung und Skepsis. Ob was Vernünftiges heraus kommt, stand ja immer auf der Kippe, immerhin sitzt da ein einzelner Entwickler ohne Erfahrung dran. Die Optik ist in jedem Fall ansprechend, ob das Spiel abseits davon überzeugen kann, muss man leider abwarten, da gab es bisher ja kaum Informationen.

Optimistisch stimmt mich zur Zeit, dass Josh nun in professioneller Umgebung arbeiten kann und dass er sich nun vor allem auf die Dinge unter der Haube konzentriert. Dass er weiterhin sehr motiviert an die Sache heran geht, spürt man förmlich in jedem seiner Beiträge. Hoffentlich kann er das auch umsetzen.

Fusion_Power
2016-05-03, 18:30:38
Naja, habs mal verfolgt aber da tut sich nicht mehr viel. Vom Dev hört man auch quasi nichts mehr auch nach seinem breakdown, angeblich arbeitet er noch dran aber seit 1,5 Jahren quasi keine konkreten Updates mehr, das ist halt das Risiko bei ambitionierten 1-Mann-Projekten.

Butter
2016-05-03, 20:44:20
Schade, aber ich weiss schon warum ich nicht mehr kickstarter benutze...

N0Thing
2016-05-04, 01:47:23
Wie gesagt, es gibt nicht mehr jeden Monat öffentlich ein Statusupdate, aber doch immer wieder Neuigkeiten: http://forums.ltheory.com/viewtopic.php?f=2&t=5031

Wer wirklich Interesse an allen Beiträgen von Josh Parnell hat, der findet unter folgendem Link alle seine Beiträge im Forum: http://forums.ltheory.com/search.php?author_id=2&sr=posts

N0Thing
2017-02-03, 01:32:25
Nach einer langen Zeit von nur sporadischen, kurzen Informationshäppchen im Forum, gibt es inzwischen auch wieder ein Lebenszeichen auf Kickstarter vom Entwickler: https://www.kickstarter.com/projects/joshparnell/limit-theory-an-infinite-procedural-space-game/posts/1798322

Kurz gehalten: Er ist sowohl bei der Menge an Code als auch bei der Performance an seine/eine Grenze gekommen und hat die letzten Monate damit verbracht Lösungen zu finden, die ihm die Fertigstellung von Limit Theory ermöglichen. Zur Zeit testet er LuaJIT als Ergänzung zum C Kern, was vielversprechend aussieht und sich bei der Demo auf der PAX South bewährt hat.

Dev Logs der letzten beiden Wochen:


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





Tuesday, January 31, 2017

Good evening and welcome to the 'new' Limit Theory development logs! As per my promise to get back on the communication train, with this post I'll be kicking off the new logs (which may casually be referred to as The LT Fortnightlies), in hopes of ushering in a much-needed era of sane, stress-free, non-showmanly communication to you all. Note that, unlike the past devlogs, I am (at least tentatively) leaving these open to comments, until it proves to be a bad idea.

Now...that being said, it was a really busy and exciting week for LT, what with me attending PAX South in San Antonio with a 'kind of LT' demo. Due to the unusually-exciting week, my first fortnightly is going to be a lot longer (and perhaps more shiny) than the average one. Please do not take this first log as 'the standard,' because I will certainly not be attending something like PAX / creating a new LT demo every week. But for this week, I have a lot to write about and I want to, so I will :geek:

Last week was a ridiculously-busy flurry of code, electronic equipment, failures thereof, migraine-inducing bugs, triumphant successes, very little sleep (followed by far too much sleep), and, in the end, a lot of good feels. When I signed up to be a part of the Louisiana Tech Park's PAX group about three months ago, I had only one intention: to light a fire under myself to get something playable in a booth. At the time, that seemed impossibly far away. As of Sunday, it was reality :) Mission accomplished!


The Process

The demo that I showed off was, for the most part, built in about a week. More specifically, the bulk of it was built between last Tuesday and Sunday. As usual, I managed time poorly and would have had more features in the demo had I started earlier. Still, I don't think I'd change the way it played out, since the process proved to me a few things.

1. Perfectionist Josh is dead. There can honestly be no question about it. This puppy was rough. To even get it working in time, I had to muster duct tape and hacks like I've never mustered before. I cheated physics in ways that would have never even occurred to my little elegance-loving brain in the past. I cut my original grandiose goal down to the bone, literally re-organizing my 'critical features' priority list every hour or so as it came down to the wire, and slowly accepting that more and more things would not make it. Sounds bad, right? But in the end: there was something playable. :thumbup:

2. The current system of core C library + high-level scripting language (Lua / LuaJIT being the current flavor) works very well for building stuff quickly. Not surprising, since LTSL was similar. Still, it's nice to have confirmation on this front. I effectively built a small, arcade-ish space shooter in a little under a week. Huzzah, turns out I can still code real things!! \o/

3. (I will discuss this more later) My hopes that LuaJIT will yield the performance I need are cautiously growing. I was quite surprised at how well it held up.


The End Result

It took me until noon on Sunday (on Friday I alternated between a screenshot slideshow and a random nebula generator with a slowly-rotating camera; on Saturday I stayed in the hotel and coded all day because I couldn't handle not having something playable), but a playable demo finally arrived.

The demo was very simple, consisting of nothing more than a massive, free-for-all battle of 100 to 500 ships (I varied it through the day), many of which were hunting the player. The player had a small (box) ship, equipped with two pulse lasers. Controls were simple and included your standard LT-esque 6-DOF flight, shooting, switching between 1st/3rd person camera, (implemented later on in the day) a thrust booster, and (my favorite) a 'generate a new system' button (which, of course, included generating a new procedural nebula, starfield, configuration of ships, etc). As you can probably imagine, the original plans included way more (two warring factions, a 'home base', purchasable upgrades, etc...), but...*snip snip*

When I first arrived with the demo, it immediately became clear that it was too difficult. People couldn't hit ships at all. I guess I've become a bit too good at leading ships properly in order to hit them, and forgot that it's quite hard ;) So I pulled up gvim and, ten minutes later, aim assist was making the game all too easy as people simply held down the fire button and watched the enemies explode :lol: Five more minutes of gvim later, we had a 'partial' aim assist, which required people to aim relatively close before the targeting computer would help them. Finally, the difficulty was about right and people started to enjoy playing.

Interestingly, I think I garnered a lot more attention at the booth during those times when I was live-coding more features into the demo and gvim was up on the booth's screen :monkey: While I was implementing a boost feature later on, one guy told me he'd buy the game just because I knew what I was doing instead of 'copying and pasting from the internet.' Perhaps I should have just coded at the booth on Saturday instead of in the hotel :roll:

All-in-all, it was quite a simple demo, but it did have the taste of Limit Theory to it, and it was, in my estimation, quite a decent bit of fun for a relatively small amount of implementation time. Yesterday when I got back, my roommate asked me how the weekend went. I let him play the demo and he was surprisingly upset when he finally died, and told me that it got his adrenaline going (in fact, I think my roommate currently holds the high score for kills...), so that was nice to hear :D


The End Result (Meta)

While the concrete result of the process was the demo, I think the tertiary fruits of the week ended up being far more valuable than the demo itself:

1. The core C library gained a lot of features. To me this one of the most 'concrete' wins, because I consider that library to be the one permanent fixture of all this development. It's still unknown whether LuaJIT will pan out, therefore, whether the existing Lua code will be used in the final Limit Theory isn't known at this time. The C library, however, will be used, and it gained a lot of functionality this week. Loads of new matrix math routines, Mersenne Twister RNG implementation, heavily-expanded gamepad support & functionality, new fast noise library, some basic physics functionality (basic intersection tests, impact point calculations), and more.

2. I got a lot of inspiration and rekindled enthusiasm out of it. Truth be told, I've been down in the dungeons battling FPLT for so long that I've forgotten to come up for fresh air. When I first drove an ugly little box ship around a system again, it felt really good, good enough to inspire me for a moment or two. I've always had a problem with remembering to play and have fun with the GAME I'm making. I'm going to try to do a better job of that, because it's no fun feeling uninspired.

3. The LT community is now fully convinced that I'm intent on doing things differently for the better. Right? Right?? :angel:

4. I gained some important perspective on what matters. I know I've had trouble with this in the past, but again, I'm making a big effort to move to the land of pragmatism. During the development of the demo, I scrapped features that it almost killed me to scrap, out of pure necessity. I didn't have time to bring over a ship-generating algorithm, so my placeholder boxes never got replaced. I didn't have time to bring over my entire physics engine, so the player could fly right through other ships. These things killed me deep down. But how many people made an issue of them when playing? Zero. Instead, I heard things about targeting feeling clunky, movement not feeling 'tight' enough, wanting more weapons, etc. Throughout the day I tweaked these things with some live-coding to improve the experience, and it made all the difference. The few people that did figure out that they could fly through other ships didn't bat an eye, and just went on shooting. Granted, I'm not saying that I plan on ripping physics out of LT 1.0, or that I'm going to ship it with box ships. But it was an important reminder for me that I have a very skewed perspective as a developer, and that having people play the game and remark on what needs work is critical.

5. I got to meet some people who have been following LT (including a few forumers like Flatfingers, Skyfligher, Sebby McWester), and the experience of talking to them about LT and the things that made them excited made me really, really happy. I started Limit Theory to build my dream game. I'm still doing that, but as I've grown up a bit since the beginning, I think seeing the excitement and the smiles on other peoples' faces as they talk about LT gets me going more than it used to. All you guys who share my dream and have supported me in the journey to make it a reality are very much an inspiration to me at this point.


Moving Forward

Thanks to last week, I have a pretty strong feeling about where I need to go from here. As I mentioned, LuaJIT performed quite well the whole time. I never had issues with CPU bottlenecks, I seldom had issues with the GC (and was able to mitigate them substantially by tweaking the GC's settings). In the end, I was, frankly, amazed to be able to run 500 ships in a system with thousands of pulse lasers flying through the air at any given moment at a decent framerate. The game logic was simple compared to full LT logic, BUT not so simple that it can't be used as a rough measuring stick.

Before PAX, I was on the fence about LuaJIT. I was cautiously optimistic. After PAX, I am now even more on the fence, and even more cautiously optimistic. In other words, I have pushed much deeper in to doing things with it, and the situation with respect to whether or not it will work has remained unchanged. LuaJIT has thus made it farther than any of the previously-explored solutions.

This week, I intend to launch an intensive study into the performance characteristics of the PAX demo + features that I'll be adding in an attempt to get a better sense of what happens when the logic gets heavier. I basically need to prove that LuaJIT will work, or prove that it won't. That's my current goal: to hop off the fence.

To do so, I'm going to have to break out the measuring tools and do some serious profiling to figure out exactly where LJ is going to start hurting me. It's going to be tough, because JITs have a totally different set of performance characteristics from static languages, and I've been pretty off in my previous assessments concerning LJ and performance. I need to become an expert on LJ performance in the coming weeks.


Screenies!

Yep, I actually come bearing screenshots this week. Again, please don't be fooled by this first log: it was clearly an unusually exciting week!

LT @ PAX South 2017 Album (http://imgur.com/a/OpJaG)

(Yes, my cellphone camera is awful)

Some of my favorites:

http://i.imgur.com/6bMU6I7.png

http://i.imgur.com/2Y6ZZQs.png

http://i.imgur.com/MPR2ZQE.png

http://i.imgur.com/DHrApvX.png

Metal Maniac
2017-02-03, 10:43:51
Hab' mir seinen Mega-Post (http://forums.ltheory.com/viewtopic.php?f=11&t=5659) im Forum mal durchgelesen. Auf mich wirkt das, als hätte er sich von Anfang an zu wenig um ein sauberes Konzept gekümmert und einfach drauflos gehackt. So ein großes Softwareprojekt muss man in einzelne Module splitten, sonst kann man den Code irgendwann nicht mehr handhaben. Auch Architekturentscheidungen, verwendete Libraries, Frameworks etc. muss man vorher in einer Konzeptphase evaluieren, ansonsten darf man den Code in der Implementierungsphase ständig umschreiben und anpassen, wie hier geschehen. Ein wenig kann ich da mitreden, da ich als Diplomarbeit mal eine 3D-Space-Gameengine geschrieben hab', was ein ziemlicher Knochenjob war (und das war nur 'ne Mini-Engine!). Josh hat sich hier mit den ganzen geplanten Features ein Mammutprojekt vorgenommen, das man allein eigentlich gar nicht wirklich stemmen kann, vor allem wenn man noch keine große Erfahrung hat. Ich wünsch' ihm trotzdem alles Gute, vllt. kriegt er's ja hin.

N0Thing
2018-10-05, 22:16:53
Wie von vielen befürchtet, hat die Entwicklung von Limit Theory kein gutes Ende genommen. Das Geld ist aufgebraucht und Josh Parnell ist mental und physisch nicht mehr in der Lage, weiter an Limit Theory zu arbeiten. Der vorhandene Code wird veröffentlicht.

https://www.kickstarter.com/projects/joshparnell/limit-theory-an-infinite-procedural-space-game/posts/2270873



The End

It is with a heart of lead that I write this announcement. Not in my darkest nightmares did I expect this day to ever come, but circumstances have reached a point that even my endless optimism can no longer rectify. I can not finish Limit Theory.

After six years, I am finally at the end of my means. Financially, I am beyond the initial investment and have exhausted most of my personal savings. But significantly more troubling is that I am entirely out of energy -- emotionally, mentally, even physically. Every year that passes sees me becoming more desperate to make good on the dream with which you all entrusted me, but each such year I grow less and less capable of doing so as my mindset falls further away from that bright, beautiful hope that powered me from the beginning. I am not what I once was.

Despite what felt like an incredible amount of progress in the last year alone, Limit Theory remains frighteningly far from feature completion. It is my own fault, for having underestimated at every turn the amount of work that goes into such a creation. It is my own fault, for having overestimated my own cognitive resilience and for believing that no number of setbacks would ever inhibit my ability to bring a passion project to life.

I don't know how to make this right. For years now, I've been running on pure loyalty to you all -- it has been quite a long time, if I'm honest, since I was actually working from a place of inspiration -- yet even with the purest of intentions and the deepest desire to honor my commitment, I find myself unable to bring about miracles. No matter how hard I try, it's not enough to bring LT to fruition, and this pattern of failure has evicted all self-confidence and hope from my mind, leaving only doubt, anxiety, and despair. Some days I think to myself "how absurd that a game should make me feel this way," and I realize just how unfit I have become to build a source of joy. I wanted so, so badly to make you all proud. To bring you all joy. There are no words to properly convey how sorry I am that I have failed you all.

I imagine I could go on and on with this gushing of negativity -- the years have left me with no shortage of it. But I don't think much good will come of it. Those of you who have followed the project closely, you already know how much I have put into it; how I have given 110% of myself. Trying isn't the same as doing, so I don't expect any thanks for it, but I hope you all do know just how hard I've tried. I've simply got nothing more to give.

So, what now?

Well, I will prepare the source code for release. It's not a working game, and in my frenzy to get things working I've left huge swaths of code in a half-refactored or half-complete state. But releasing it is the least I can do. I don't imagine it will be of any use to anyone, other than as a monument to a failed dream. Perhaps those who are interested in game engines will glean a thing or two from the engine, as it is a fairly solid piece of engineering, much more solid than the Lua game code.

For the moment, though, I wanted to get this off my chest as soon as possible. It has been the most painful, difficult decision of my life, and I'm sure that there will be no shortage of blowback. But I simply cannot continue to destroy myself in search of a feat of which I am not capable. When I began this project, I felt that anything was possible. Here now, at the end, I must swallow the painful reality that: I, too, am human. I am limited by time, I am limited by finances, and I am limited by mental & emotional stamina.

One last time, I would like to thank everyone who contributed. From the bottom of my heart, thank you for believing in Limit Theory. Thank you for giving me the opportunity to try for something wonderful. One last time, I am so sincerely sorry for having let you down. I hope, at the very least, that some of you have enjoyed the ride as I've pitted my brain over the years against one challenge after the next.

I'll be in touch when I have readied the source code for release.

~Josh

Monger
2018-10-06, 10:03:06
Bin mal auf den Quellcode gespannt...
Der lange Sermon zu kompilierter Sprache vs Skriptsprache kommt mir irgendwie merkwürdig vor...
Klingt insgesamt danach, als hätte er versucht das Rad eckig neu zu erfinden. Und das Thema Projektmanagement nicht ausreichend ernst genommen.
Schade. Aber der Fairness halber muss man sagen, professionellere Teams haben sich bereits an kleineren Aufgaben verhoben.

Monger
2018-10-06, 12:59:43
Wenn ich so die Beiträge lese, fühle ich mich an Achron erinnert, ein RTS was auf Zeitreisen basiert... Auch so ein Einmannprojekt, auch technisch hochinteressant. Auch da konnte der Designer seitenweise über technische Herausforderungen lamentieren.
Achron kam allerdings irgendwann raus, und war dann ein interessantes Experiment, aber ein mieses Spiel.

N0Thing
2018-10-06, 15:20:53
Ich hatte auch den Eindruck, dass er sich in mehrerer Hinsicht übernommen hat. Oft konnte man von vermeintlich revolutionären Entwicklungsschritten lesen, die das weitere Arbeiten erleichtern sollte, oder die Performance dramatisch verbessern würde, was sich aber im Nachhinein als Irrtum herausgestellt hat.
Ich denke, wenn Josh sich nicht so sehr an die Idee geklammert hätte, alles alleine zu bewältigen, wäre es vielleicht etwas geworden, man hat ja in der Zeit, in der er dann doch Unterstützung von anderen in Anspruch genommen hat, endlich größere Fortschritte mitbekommen, die nichts mit hübscher Grafik zu tun hatten.

Metal Maniac
2018-10-08, 10:19:07
Ja, schade drum, aber war abzusehen. Dass es durchaus möglich ist, sowas mit einem kleinen Team auf den Weg zu bringen, beweist allerdings Avorion (https://www.avorion.net/). Die Pre-Alpha hatte Anfang 2017 durch sein Baukastensystem für Raumschiffe schon genug Stoff, um mich über 100h zu fesseln. Inzwischen werkeln da neben dem Kern-Team von 2 Leuten 3 weitere um das endgültige Produkt 2019 rauszubringen. Meiner Meinung nach hätte Josh sich da auch frühzeitig um ein kleines Team bemühen müssen anstatt alleine da rumzubasteln.

Monger
2018-10-08, 17:40:53
Es gibt halt brilliante Entwickler, Designer, Projektmanager und Künstler - aber halt nie in einer Person. Das hat mich an der Spieleentwicklung immer abgeschreckt: Selbst für das kleinste Projekt musst du ziemlich viele Leute an einen Tisch kriegen. Gibt viele andere Softwareprojekte wo man alleine was reißen kann, aber kaum bei Spielen.