Sunday, December 14, 2014

Excellent day today. I honestly enjoyed every minute of it -- the part where my eyes were closed and my brain asleep, the part where I woke up to check the forums for a brief period, the part where I went back to sleep, the part where I woke up to get a drink and, subsequently, plunged back into the bed, and finally...the part where I went out to dinner to stuff myself with pizza (which means, of course, that after I post this log, I'll likely be in serious need of...sleep!) Post-update-sleep-day is always such a good day

So it appears that reactions to the update are largely positive, although it's also clear that a growing number are becoming concerned about gameplay and the timeline. Indeed, I don't think we can carry on without a serious shift in the tone of development.

Tomorrow I'm planning a trip to the aquarium for some much-anticipated relaxation (yes, an odd way to spend a day off, but one that I'm sure will prove to be a whale of a good time ). When I return, it will be time to shift gears. I'll begin preparing to announce my upcoming plans concerning updates. I'm excited, but won't say more It's about to get real



PS ~ Sorry for that devlog savings bit...but...you know how it goes...

Monday, December 15, 2014

If you were expecting a fishy devlog today, you might be a tad disappointed Turns out I woke up too late to make a day trip worth anything. So I resorted to doing what I'm best at: working I'll try again tomorrow.

I decided last month that I would spend the first day or two of this month hammering at any remaining imperfections in LTSL. In Octember I burnt through way more code than ever before, and pushed LTSL way harder than ever before. Not surprisingly, I was able, for the first time, to get a really good feel for which parts of it are solid enough to stand up to the torches of the content sprint, and which parts may need upgrades beforehand. The great news here is that: it's held up really darn well so far. I had very few problems during Octember, and most those that I did have were easily-resolved (one day, in particular, I remember reducing the LTSL compile time from ~10 seconds to ~50ms for the main LT app. Yeah, I was doing something in a really bad way before that day ). There do, however, remain just a few bits that need some love to make sure that the rest of the code I pile on ends up being as effective as possible. Several of those bits are already solved as of tonight

I won't go into detail because I think we're probably all tired of talking about such technicalities But briefly, I'll say that I implemented 'references' (as in the & symbol in c++), and automatic path inference for types (a script in the 'Widget' folder needn't say 'Widget/Button:SimpleButton' -- since it's already in the 'Widget' folder, it can get away with just saying 'Button:SimpleButton'). I had seen the lack of both of these features hurting the concision of my code at several points during my work with warp rails and the market. After implementing them, I was able to go back and clean up all of the minor dirty spots that their absence had caused

Anyway, more interestingly, I've consulted my planning tree and tried to organize myself for the coming meta-update (update about updates ). Rolled into the meta-update will be a small update as well, and I'm trying to decide what exactly I will aim to include in this update. There are a lot of possibilities that jump out at me. Mission boards...fleet management...NPC interaction menu...faction information menu... Maybe it's an illusion, but there appears to me to be so much low-hanging fruit right now. I'll need to make a decision very soon. Perhaps if I'm able to go see the fishies tomorrow, they'll be able to offer me a bit of slick advice

Tuesday, December 16, 2014

Got it

Enjoyed a laid-back day of watching things swim around. Fun..I think? I'm not sure what I was expecting, but I guess I thought there would be a little more to it. Some kind of deeper feeling, or maybe even some insight about life or the universe or...anything, really. I guess I'm just not a kid inside anymore Although, come to think of it, I'm pretty sure that, even as a kid, I would have chosen Morrowind over fish Heh. Guess I should have stuck to my roots

On the bright side, the fish did give me some advice for where to go next in my work. Coming back from a day at the aquarium, there's really only one Limit-Theory-related concept that remains on the mind: fleets & formations. Watching those fishies swimming around, forming and disbanding patterned groups constantly in response to obstacles or roaming sharks, I couldn't help but see hundreds of little fighters.

I'm not sure if this is the direction in which I want to go, because true fleet play isn't a small topic. It may be prudent to first get a handle on the asset management widget. Work on the fleet editor last month felt a bit premature. That being said, there's nothing holding up AI-side fleet play, as far as I know. The question of when and where the AI uses fleet structures rather than single assets will need to be explored. Perhaps more than anything, various fleet structures will need to be tested in combat against one another to verify that fleet mechanics are implemented in a way that makes a difference.

Will think more about it tomorrow before I start. I really want to start grabbing the most bang for my buck. Temporal efficacy is the name of the game from now until the end. For now, though, I will grab a bit of respite before it begins

Wednesday, December 17, 2014

Starting off with a bang Wouldn't have it any other way. There's really no time to waste.

First up, the handling testbed. Let's face it: flight controls in LT still aren't perfect, despite eons of iteration. But we're living in this new world where things can be F5'd to death and perfected in microseconds, right?? So why not that too!? Ah, well you see, the code that handles handling ( ) is a rather uniquely-weird piece of code, because it lives halfway between the UI and the game world (it is, in fact, a very confused little piece of code ). Both pieces presented challenges for porting to LTSL. Today those challenges were blasted and the F5 cannon was brought to bear on flight handling in the new handling testbed. Along the way, we picked up a few things like inter-script messaging and some new math exposed to LTSL. But the real victory is, of course, the F5ability. It hasn't been F5d to perfection yet, but it's already better than before. I really want it to feel more visceral, especially when piloting smaller, nimble ships. F5s in hand, we will soon achieve that goal.

But that's not good enough right now. Right now (for reasons that will come to light soon), we need to pack more punch into LT. And where does one find punch? Well, after extensive rumination, I've decided that the most punch to be had lies with colonies. We've got the absolute basics working. But colonies are to be the fountains of life in LT. They need more. Not only do they need more innards (modeling of the internal population and economy that drive their markets, etc.), but I'd also like to see a half-decent informational widget. In the end, my ultimate test of LT's dynamism will be to spawn only a single colony on a single planet in a single system, and watch life grow. If the end result is a bustling system ablaze with trade, piracy, mining, production, research, construction, etc...then we'll know we've really succeeded That is a ways off, particularly due to the lack of construction mechanics as well as the AI's inability to use income to expand its operations. But for now, I would simply like to focus on the source. The question that I will be asking myself continuously is: if all the other mechanics were implemented, would these colony dynamics be sufficient to spark (and sustain) a living system? I think this is a good guideline. As you may have guessed, the answer is currently "no"

But! That's still not good enough for right now. We don't just need working stuff. We also need working, visible stuff. So along with colonies, I'm going to vow to push further into the game's event system and the visualizations thereof -- in particular, the news feed. I have had the concept of events implemented in the game for quite some time, where an event is basically just an encapsulation of "X did Y at Z with W" kind of thing. Fundamentally, in describes how things in the universe are changing. More importantly, it gives us a way to see, and, ideally, even understand those changes. Well, that is, if we actually had a way to see them Enter the news feed. The news feed is simply an aggregation of local events of significance. I've always known that making the dynamism of the universe visible would be a critical part in making it matter. But it's only recently occurred to me that aggregation of events is a remarkably simple and effective way to do it (and a way for which some code already exists!) To me, only one major question comes up here: what are the criteria for an event becoming 'known'? If a tree falls in the forest and no one is around to hear it, does Freeport 7 have a headlining story about it the next day?

I have actually considered the possibility that knowledge of events is, like other knowledge, encoded in physical 'data' form. That is to say, if we witness the destruction of an Imperial Star Destroyer, we may automatically have that event recorded in our database. Certainly one could see how this opens up the possibility for a lot of interesting gameplay (from inter-system news-runner to factional spy gathering information about enemy activities). But it is, IMO, a luxury. So for now, I will likely proceed by registering events above a certain significance threshold with a system-wide news buffer, which will be displayed at station / colony news boards. From there we can always add more nuance.

Finally, getting back to what I actually coded today (yes, as you've probably gathered, I spent a lot of the day thinking about what I want to do next ), I managed to kick a little extra functionality into LTSL while I was at it. We now have static variables as well as some new optimizations to the way local variables are allocated and freed. Both of these additions result in higher performance and cleaner code! Worth mentioning, but I'll leave it at that My LTSL wishlist, developed largely during the last few weeks of sprinting, grows shorter by the day.

Whew. Long day today. Time for sleep

Thursday, December 18, 2014

A bit of a short day today, as I worked longer than I should have yesterday. I've only been awake for about 7 hours, and now have to cut work short to begin my journey home for the holidays. What developments can a short day like this one possibly hope to bring? ...

Absolute devastation

Today the LTSL wishlist has lost its most prized element -- the one element, above all else, that holds me back from dumping gallons of awesomesauce into AI and gameplay scripts. Dynamic Arrays. A rather run-of-the-mill thing for those of you familiar with programming. They go by vectors in C++, ArrayLists in Java, and they're one of the most basic programming concepts out there. You store stuff in them! How much stuff? Well, as much stuff as you like (hence the 'dynamic' part)! It doesn't take much imagination to think of all the places that this is used in something like LT. Objects in a system, hardpoints on a ship, enemies targeted, widgets on the UI, missions on the mission board, items on the market, ships in the hangar bay, passengers on the warp rail, so on and so forth. All of those are handled by dynamic arrays.

Despite being such an ubiquitous concept, dynamic arrays aren't necessarily trivial for a language to support, because, to have real dynamic arrays in a static type system, one requires parametric types -- data types that are built using other types. If, for example, a script defines a new type 'ColonyEvent,' then a dynamic array of ColonyEvents is a unique data structure with unique functions (because the array must manipulate ColonyEvents, and manipulating ColonyEvents is different from manipulating Items or Widgets or Ewoks or whatever other types you've got). Suffice it to say, parametric typing is a big technical hurdle. And it's a hurdle that I took out in one fell swoop today I'd love to run free with this devlog. I really would. I'd love to berate you with talk of void*s and type erasure and all the cleverness that underlies getting a heavyweight concept like this to work seamlessly in little-old-LTSL. I'd love to express my joy that brutal tests such as Arrays of Arrays of Arrays work perfectly, and that swapping arrays into several pieces of existing LTSL have already boosted performance. But I won't Let us not get distracted from the focus here

Tech is a lonely soul without a piece of real content to use it! Rest assured, though, this tech development has more than a few pieces of content itching to dance with it. I am now starting to apply my new-found Arraycannon to a concept that I mentioned last month -- procedural text generation (descriptions, news, dialogue, etc.) I mentioned the 'event' architecture and how it can be used for news yesterday, but I didn't reveal that the most interesting challenge about it all is actually in the 'visualization' of that information. The text generating system in LT is one of the few systems that has gone almost completely untouched. It's time to fix that. Generating events is not hard. Capturing them to a system-wide buffer is not hard. Displaying them in a feed that shares a good bit of code with the market will not be terribly hard. But getting that information into a format that is interesting, immersive, and descriptive, all at the same time? Now this, my friends, will be a fun one And it all starts with arrays.

Not too bad for a short day Tomorrow I'll be on the road but, like always, I'll be thinking of LT!

Friday, December 19, 2014

Well that was a fun day Didn't have the energy to write a log when I got in, so instead, I did what was necessary: slept for half a day, then wrote a log!

Apparently, life noticed that I've been having a relatively (!) stress-free time ever since #21 dropped. Since this is, of course, totally unacceptable now that I've been promoted to 'brutal' life difficulty tier. In accordance, I was blessed with a solid five hours of intense storm during the last half of the trip (the kind where you can see about 20 feet in front of you). Makes for a tiring trip, but hey, it didn't kill me!! And you know what, although I didn't have much free CPU for LT-related thoughts, I did still have some fun thoughts.

And here I am now, home, safe, and with a few extra thoughts than I had yesterday (and one heck of a car wash, to boot). Again, this is totally unacceptable. As I opened the trunk to retrieve luggage, I heard a curious noise. Much to my dismay, I realized that one of the rear tires was punctured and leaking air. Well-played life, well-played! But we'll get it fixed today. I dare say, I'm curious to see what plans life has to make my return journey appropriately difficult. We'll just have to wait and find out!

Now then, about these thoughts. Strictly-speaking, they weren't LT-related. But I had an idea about a week or two ago. I haven't explored it much. But it's been haunting me a bit ever since. It's an idea about AI. In particular, it's the idea that there's this one technique with a certain key underlying principle, that has not been explored yet in neural networks. For some reason, I had and still have a very strong gut feeling that this particular technique is...very important. I won't say much about it until a long time from now, after LT, when I finally have a chance to see if it will work as well as I believe. But in my head, I can keep developing the theory on long car drives The more I think about it, the more excited I get. The more I think about it, the more I am able to delude myself into believing that...this may actually be 'the answer.' Well. Time will tell.

Time to get the tire fixed, and then, back to work! Really need to put in the hours today

Saturday, December 20, 2014

Not a very big day, sad to say it Between tire fixing and some quality family time, there wasn't as much LT going on as I would have liked.

That being said, I still did make some headway. Today I wrote a quick context-free grammar parser in LTSL that will be used in the procedural description generator. I've got that all working, but I didn't make as much conceptual progress as I would have liked. There's a lot to think about here. In particular, the actual grammar (which defines how the structure of a description is unfolded all the way up until it becomes pure plaintext) will need to adapt based on circumstance. It will need to take into account time (are we talking about the past, present, future?), tone (if we are dealing with a non-neutral-third-party, such as NPC dialogue, what is the tone of the speaker toward the subject?), personality (is the speaker generally curt? Eloquent? Matter-of-fact? Grandiose? Timid? Overconfident? Aggressive? Curious? etc..all based on the personality vector of the AI), and perhaps other things as well. I believe that dynamically computing the weights of the grammar rules can get us part of the way ("Burn in the fires of our doombeams" has weight proportional to aggressiveness, for example ). But there will be more that is required for true coherence. I look forward to exploring it.

Frankly, I focused on that today because I knew that I didn't have enough time to do damage to colonies or events, hence picking up a 'fun' piece of work and running with it

It's worth mentioning that, in the process, I implemented 'direct' StringList support in LTSL, so that you can write StringLists (this is the data structure that LTSL is made out of for those who don't remember ) directly in the code and use them as the contents of a variable or argument. This was very useful in my grammar parser, as it's really convenient to be able to write the grammar rules directly in LTSL as a StringList. I then implement a function that takes a StringList and parses it into the internal data structures used to describe a grammar. This is quite reminiscent of LISP, where lists were both convenient ways to handle data, as well as the actual language of the code.

More to come tomorrow