Day 51: In Which We Catch Up Again

Today was a day to get plenty of work done! That is, so much work has been done that production is having trouble keeping up.

I ran into an actual bug today! Whoo! This one is mainly attributed to weightless objects going through walls. When trying it, I didn't have too much of a problem, but closing the character in on the PhysicsHandle results in some very nasty clipping and depenetration velocity strong enough to wiggle the object outside of walls. I managed a sweep test that would fail-safe the system and shut off levitation, should that occur.

The fog moves as it should! The deadly fog, that is. I figured moving the KillZ volume (or a volume that acts like KillZ) would be appropriate, but the volume must only hit and cause the FellOutOfWorld function to characters (player, insects).

As for the programming assignment? I learned from an important source that if a source is cloned and owns data, it must delete and never change or mix ownership with non-owned materials.

As for neurofeedback? Eh. Not too well. The UDP receiver I'm trying to attach to EEGer isn't working; I'm not sure what the other side is doing that I can intercept. Perhaps it's not timing out properly?

Day 50: Who Uses The Metric System?

We do, most certainly! Mainly the system of metrics we plan to use for gameplay testing and measurement. Right now I've been tasked with just getting possible metrics written over time, the simplest being length of gameplay in a session. It's as simple as writing to a csv file, right?

Nay! The file writing of UE4 seems to be limited to writing a single string to a single file, so I took over and converted the FStrings to std::string objects so I could use the fstream objects to write to a file. So far, so good!

I've also tried to find ways to change KillZ in the game, but it's been extremely tricky. The KillZ volume can't be changed in game, so what I must do is place an object that invokes the FellOutOfWorld function when overlapping. Simple? Maybe. Difficult? You betcha.

Day 49: Dark Times A-Comin

Similarly to an earlier post, the research into foggy sheets has actually come out pretty well! As long as I keep it in Blueprints (due to the nature of Construction Script Material Instance Dynamic Instancing and Billboard Components), one can create a "fog sheet" that can be properly placed under a KillZ area for some very good fill below:

As for Programming work, the parsing is all set and run through correctly! I just had to remember that the XML_Parser in Expat needs a free method, especially during exceptions to preserve memory state.

The kicker? Looks as if writing data to a file with metrics is pretty tricky; regular DataTable objects can only be read to for data-driven programming, so I have to experiment with writing readable text files for metrics.

Day 48: WIP

My brain is much too tired for a full post. Been working on XML parsing with Expat all day. For those of you who don't know what Expat is, it's a C library devoted to reading XML. That said, it's not nearly as friendly as I had hoped, with it stopping its data handler on every single tab and newline character.

However! Parsing is now going well and cloning is going smoothly also. For cloning, we're kickstarting work into the Factory pattern by using cloning over regular copy construction.

What next? Sleep. Please sleep.

Day 47: Dark Lines and UI A-Comin

Today was quite the busy day (still in progress!), but I've made considerable progress today to give a status report.

Capstone was relatively straightforward in terms of work. I dug into another programmer's code to figure out why the lines weren't showing when the central-focused nodes were calcified, so I refactored a bit for better feedback:

What's that at the lower left corner? UI in progress! Right now I'm hooking up another UI widget to the PlayerController to ensure visual feedback on stamina and health.

As for the final portion, I've worked on a simple elevator translation of a producer prototype. The elevator only goes when the nodes are not calcified, allowing proper vertical ascension with a "barrier" of progress.

What's next? Work on XML parsing. Our next assignment is parsing XML the hard way...(through a wrapper in Expat and abstract base classes!)

Day 46: So Much Out of A Shiny Ball

Today was a good day for the targeting ball! After adjusting to different design changes, the targeting ball now scales based on distance, operating with much more visibility and the same accuracy as before:

The ball also now changes color based on interactivity, not the ley line power. Sure, it should shine with the power when usable, but only when! An example is shown below.

Also, a checkpoint system was deemed more viable than distance-based respawning, so I included a class very similar to a checkpoint class from long ago...

As for the programming assignment? Soon it will be released. I think. Those are always slow to release.

Day 45: Not Much To Show

However...much work is done!

The Attributed class is covered fully and is ready to roll. Looks like that in order to test the original code, I had to call the base versions of the functions. All in all, though, it works! XML parsing will move on soon, but I'm iffy about using Expat to read XML.

As for Game Lab, I put in a score multiplier real quickly, but it was mostly helping the others actually setup their things with making sure EEGer had compatibility with Unity on their systems. If only they had done it earlier...

And as for tasks! I'm secretly working on my Sprint tasks in advance; don't tell anyone I'm fixing bugs...

Day 44: Multi-Man Neuro Brigade

Great news today! After enough struggle, I've finally figured out the last piece of my programming assignment. The main tricky part was to differentiate class member representation (external storage) from script-influenced member representation (internal storage), but I'll be ready to test build and coverage tomorrow!

Also! I got myself a design document from my producers for the neurofeedback script! I also got a good idea from them and set volume as a form of neurofeedback. Unfortunately sound cannot be displayed in a screenshot, but that force radius effect never gets old:

As for capstone, I finished researching possible ways to limit the character's stamina and got some quick builds done on slowdown and movement.

Next up... not sure yet. Gotta get a list of tasks from the higher-ups.

Day 43: Two Man Neuro Brigade

Bad news first; Attributed's got me by the brains. I've put down a list of questions and scrapped up a find-index function for checking prescribed attributes, but...I'm just not sure.

Capstone has been bug-fix city. If there's something that needs made, debug boss ability keys, not sprinting unless while moving, and other such bugs...I've fixed em'. Hopefully we're good for internal playtesting.

The exciting good news? Somebody finally joined on actually making some progress with neurofeedback! It was mainly keeping sure they actually could setup the project to receive data, but it's progress nonetheless. I also got Muse data into EEGer, but the game needs authoring before we can stream live data.

I also put another subscriber into the force grid so the music-only part can be controlled with neurofeedback! Feel the insanity!

Day 42: One Man Neuro Brigade

Seriously, I really do feel like this. At this point for our neurofeedback team, the team has been rather...procrastinatory. I'm afraid that for the work that I'm bringing back (reward subscribers, timer for reward cooldown to prevent overloads, etc.) will be the only work for Thursday.

Today was a good time for bug fixing in capstone though! Got some debug keys in so the main character can switch abilities on the fly. I'll see if I can debug boss attacks tomorrow.

As for the homework? Yeuch. There's not much I know until I actually ask from the voice of authority, who is (unsurprisingly) absent from answering questions for the third week in a row...

Day 41: The Exterminator

That's what they call me these days; as the Exterminator, I've dropped some unnecessary tasks to focus entirely on bug fixes.

Weightless power not working? The Physics Handle object isn't checking state? No problem! Also had to make a slight change for the player to grab the AttackCapsule on the enemies when weightless, as that is the vessel for the object when drifting through the sky. The object also had to move with camera rotation, not player rotation; that meant attaching it to the camera's forward vector.

Some design changes came through as "bugs", though, so I had to clarify to make sure it was the direction we were headed in. Distance-based deactivation is no longer a thing (ssiiiiigh) and they want the weightless objects to ironically carry weight. That results in specific linear/angular dampings for the specified objects.

What's next? Been working with UMG and specified graphics scalability settings for a menu to use for minimum specifications. Is that a bug? Only when I leave the low settings on.

Day 40: PostEditChangeProperty

Yeesh. It feels like I'm doing something I'm not supposed to be doing with Unreal. The main thing I want to do is spawn/respawn actors on the fly, so I took the prototype that one of my producers did on a procedurally built floor of moving blocks. What's the caveat? They have to update from property changes in the editor. Yeeeesh. With a mix of abusing the OnConstruction method (once, and deleting any objects that currently have no parent) along with a Super-less PostEditChangeProperty method (which would throw the weirdest exception if I spawned anything from it then exited the statement.

The other thing was a notice of not too many large tasks in the way; most of them are all on-the-fly bug fixes. Like putting the laser on the butt end of a charger! Yeah for scorpion designs! I had to be careful to rotate the laser each time so that the forward vector would intersect with the character at her vertical location each time when spinning:

Day 39: We Have Contact

Today was one heck of a tough day, but it was worth it.

The first tough part was the translation of a producer prototype; the simple part was the setting of cubes that would just move up and down in a regular fashion.

The hard part? The idea was to setup a procedural object where by placing it in the scene, it would spawn numerous blocks in a grid. Right after placing it in the editor. Yeesh. At first nothing would work; thankfully, the OnConstruction method would allow the spawning of objects after construction but before the game would play. Unthankfully, the OnConstruction method rapid fired spawning, requiring a hasSpawned boolean. Oddly enough, two copies would still form; one that was properly attached to the object and one that had no parent, but would spawn as soon as I dropped it into the scene. The cure? PostEditChangeProperty, which acts as a form of Tick in the Editor. If the objects were not attached, they would delete and force garbage collection.

The other hard part? The neurofeedback; I had to carefully craft the project to manage the same type of JSON feedback that I achieved during Winter Break. With much luck, I managed to get data onto the screen. Progress!

Day 38: Out of Scope (For Real This Time)

Phew! Today was spent primarily on finishing up Scope (due to the lack of any particular tasks to keep up with for this capstone Sprint. Onto tomorrow!)

It was difficult, but I finally understood the last pieces of the puzzle. Capacity refers to the hashmap (underlying to the actual Scope's memory), and must have properly instantiated hashmaps and reserved vectors to assure a set amount of memory being allocated. As for the AppendScope, it was answered in a relatively vague way, but the method cannot be used for the Adopt method; rather, the method adds only the child, not any extra scope that may be created with AppendScope.

As for neurofeedback? I was pretty busy preparing for my talk today on teaching nonviolent strategies in games; it actually went by pretty well! One less thing I have to worry about before the end of the semester.

What's next? Tackling capstone tasks and working back in the janky old version of neurofeedback!

But now? I rest!

Day 37: Leaky Memory

Yeragh! So much has been put into this Scope assignment! Thankfully I learned a couple of things:

Scopes keep track of their own heap allocated memory; when making a scope within a scope, one must never do static allocation, as that is automatically destroyed when going out of scope.

Adopt methods don't have an index! Whoohoo!

Remove and Find methods (templated, overloaded, or otherwise) are actually kind of a necessary thing in the case of working with Scopes. Had to implement them as a result in the previous Datum.

Memory leaks! Yeesh. Turns out when doing a deep copy, I had to be careful to heap-allocate new scopes but only when necessary (keeping the rest of the Datum objects intact). Those CRT libraries don't really do too much, even with mapping the allocations to their files.

What next? More scopes, more testing! I have a couple of questions regarding appending scopes and such that need to be answered...

Day 36: Tuck and Roll

Today was a short day, as the frustrations grow and answers grow thin.

Unfortunately I'm unable to figure out the compilation issue I'm having with getting the proper dll files, so I downgraded to Unity 32-bit. That said, I'm still lost.

Scope? I've managed to test the Datum portion of Scope, but it's still a roll into darkness.

As for capstone? Thank goodness! Managed a dive roll (Re-purposed the sprint jump in the animation blueprint to be dropped in a raycast towards the bottom), so that one could roll in a specified direction when pressing jump right before hitting the ground.

I've also managed some bug fixes, including a neat discovery; timers are actually regulated by Global Time Dilation! The caveat with this is that the cooldown timer follows the same round, meaning that while time is dilated, it takes nearly five times the amount of cooldown. Luckily we've fixed that and the slow down arrow firing is ready to roll!

Day 35: Out of Scope

Yeuch. The Scope assignment is beyond my knowledge right now. How the datum objects and scope objects interact is beyond me.

Also, them dll files were of the wrong configuration for our neurofeedback project, as Unity requires 64-bit dlls, not 32-bit.

What's the good news? Capstone! Thank goodness! Polish is going over nicely and the Matinee Actor, however Blueprints only, has been managed with enough C++ code. Meet an exploding bridge!

Day 34: Days Like These

Days like these, you just want to sit back and relax and not post a thing.

However! Progress was made; applying a radial force to a UDestructibleComponent did indeed induce the gravity-well induced effect we were planning on destructible bridges.

It's like that scene from Poltergeist!

What's next? Still working on Scope. Works a little better, now that I realize that the vector is used on an ordered insertion basis, instead of ordering the hashmap. (shivers)

Day 33: Magical Corridor

Phew! Persistent Level Streaming is now available. I had to deal with a few bugs (resetting warps so one doesn't warp to an unloaded area and determining which Player Start to spawn at) but they're all set.

Datum is done, but Scope is the next assignment. By creating a tree of scope and data objects, we effectively might be creating our own programming within programming. Yeuch.

As for the neurofeedback, the application has now been updated to output data through a dll! Wonderful! Problem is, the output program was written in C++, and we need something to provide string data. I've done a bit of work in using C# to borrow methods from native C++ dll files, but I'm definitely not sure I can manage through the haze of the JSON data output program to make a C# version with what I'm provided. Heck, the program looks like only console data output was built in.

Day 32: Persistent Headache

Kerblagh. Took awhile with enough shots on code coverage, but the Datum is fully tested, covered, and ready to ship as an assignment.

For work to-do? Persistent level loading! It took a bit of a while, especially differentiating between World Composition (not quite the same thing, pre-loads all the levels into a single whole) and making a sufficient C++ interface. Luckily enough, streaming levels seems to be a cinch, and can be applied to our project as a whole.

Worlds collide!

Day 31: Time Flies When You're Testing Code

But no, seriously, I had intended to stop coding an hour ago. Today was mainly spent fixing up the evasion dodge to include invincibility and continue working on the Datum.

Did you know the Datum requires a bracket? I didn't! Heck, it feels weird the way it's supposed to be called in a templated version.

Did you know that the externally stored Datum can change values and size as long as no memory was allocated? I didn't either. I expected the thing to be a read-only version.

Did you know that, depending on the right hand side of an assignment, you may have to convert internal storage to external and external to internal? And Datum objects carrying external data to internal Data is bad!

So many things! I don't know! Until it's too late!

Well, too late enough to code at a decent hour.

Day 30: Spinarama

Today continues the saga of the Datum. I couldn't avoid switch statements (more to lack of time than anything else), so I've managed to create a full interface and am in the middle of testing.

A neat thing I discovered about testing that I didn't know before was that I can actually assign data and create a consistently used memory state (with consistently used pointers) on the Initialize and Cleanup test methods instead of during every method. Such productivity!

On the capstone end, the laser is finally integrated with the charger and I've started work on the quick step. The tricky part is making sure I manage the camera input and only disable specific inputs in the midst of the quick step.

On the other hand? A legion of chargers!

Day 29: Frustrating Rabbit Hole

Today's work on the assignment led me on a wild goose chase, which I must warn ye about in the future!

IF you make an object, say an array of data types, whose "type" was defined by a strongly typed enum instead of polymorphism, there is no way to avoid switch statements, save for a large array of function pointers. I thought that templated functions could work out, but they only work for constant expressions.

That is, if one wanted to make a templated function and use the enumerated type, one would have to code it so that the enumeration would be known at runtime.

Unless we're specifically supposed to use function pointers, I think I'll stick with the switch statements for now. The Open-Closed Principle may be violated, but there's not much one can do, save for besmirching the assignment and making a set of Datum classes (IntDatum, PointerDatum, etc) which was not part of the assignment. This has felt like a messy assignment, but it may shed some light somewhere down the road.

Day 28: How Many Datas Could a Datum Data?

Today marks the first big leap I've made in the current Datum assignment. In figuring out the template function issues, I've declared (not defined) the generic Get function, but declared and later defined in the implementation all the template specializations.

What's the fun stuff? Smooth rotation! Seems like by disabling Controller Rotation as Yaw in the character editor and setting Orient Rotation to Movement, the character now rotates smoothly while moving!

What's the problem? How to rotate without moving? Use RInterpTo! Problem is, using ticks inside the actual behavior tree..snap rotation? It's peculiar, and I've had to keep the rotation outside of the AI tree. There's still a bit of a bug with going straight from movement oriented rotation to non-moving rotation.

Next up? A laser! This spinning was meant for its purpose.

Day 27: Overloaded

Today was going to be a day where I could get a fair amount of work done. Today definitely turned out to be a lot more work than I'm used to handling.

The main portion wasn't the capstone work (the charger implementation is going smoothly, but otherwise nothing too much of note) or the upcoming datum assignment (a dynamic array with runtime overloads? Egads!), but code coverage.

Code coverage is a necessary part of code testing, and something that anything below Visual Studio Enterprise does not offer for native C++ testing. Does that stop me? Nay! By using an open source plugin, I effectively used the vstest.console.exe as a vessel for a "managed" test and got code coverage for my libraries. Success! Unfortunately, it cost me quite a bit of time and sanity.

Do I have time to rest? After this post...

Day 25: Caught Red-Bridged

Today was an interesting balance of tasks. The main capstone task for the day was to utilize the bridges I created from the past couple of days; this was a bit tricky on damaging the player, but using overlapping events did the trick. Combining it with rotating the direction of the bridge around the z-axis resulted in quite the amazing effect:

As for programming work, I'm almost free of the hashmap assignment! We just had to use the crt debug library to test for memory leaks in our class.

The most interesting part? Game Lab work is in progress! We're mainly working on an environment before receiving the data, unfortunately. Muse is too persnickety when it comes to bluetooth connections and we've still no word on improvements in sending JSON data

Day 24: Silent Bridge, Deadly Bridge

Another long day, but actual progress on Game Lab has been brought! Unfortunately, progress on integrating EEG data from EEGer to Unity is as (predictably following the same path and as difficult) as I thought, but I have pulled in my own work on possible gameplay aspects to incur neurofeedback with. Look out for a green seagull-shaped set of cubes!

As for the bridges today, I've been working on getting the dissolve phase material a classmate of mine used and programatically integrated it with the actual expanding bridge. Next up? Corrupt, evil bridges! They hurt the player pretty badly and are an important facet of the boss when the boss script is checked in.

Day 23: Building a Bridge Through My Skull

Phew! The HashMap is completed. It seems as though the issue was averted (not fixed, averted) by a fortunate requirement to shift the user-defined class implementation to a class-based implementation. That way, the test class is not an actual class used by other programs (it's quite hypothetical), but it and its special hash functor implementation is slipped right into a set of headers only accessed by the test class. I will miss testing it in non-test programs though. In all honesty, debugging tests is slower than debugging actual code.

As for the actual work on neurofeedback (once again!) it's definitely as I've feared; the program provided barely provides data (definitely not to a Unity interface) and is not set with clear instructions. I've setup the .exe as a gamedef file but the damn thing doesn't work.

More good news? Thankfully! The bridge power is fully setup as a C++ power. Now one can shoot an arrow from one spot to another and create a bridge that later self-destructs itself to prevent object bloat. Unfortunately, nobody on the Internet's been able to properly figure out timeline objects (updating a value over time), so I included a Blueprints timeline that calls a C++ function. Really though, I'm unsure whether we actually need the things...