Productivity has been high this week...in certain regards. In regards to writing it hasn't been quite so.

Nevertheless I do have the word count, if piecemeal, and I present 1616 words. Changing things up this week and going to try to post the writing here instead of shunting it towards Google Docs. Largely this is because the formatting of the various texts just won't allow it the same way this week.

To begin, I've been coding this week - just some basic, basic C++ lessons to get myself back in the swing of things. At the head of each of these lessons, I've written things for amusement, and here I've collected them..

If any of you are familiar with a little book called "Beginning C++ Through Game Programming, 2nd ed.", you'll note the titles come from the first few chapters. I've included the titles for reference, but am not counting them. Totalled, the rest is 386 words.
Spoiler
Show

//Game Over
//A first C++ program

//Written by someone who really should know better
//to get back into the swing of coding
//because procrastination is
//absolutely terrible
//and makes things
//like this
//happen.
-------
//Game Over 2.0
//Demonstrates using a directive

//To a person who by now should really know
//both what a directive is
//and what it does
//but does not
//proficiently
//know.
-------
//Game Over 3.0
//Demonstrates using declaration

//Which let's be perfectly honest
//of course I won't use them
//until my programs get
//large enough that
//I give a damn
//versus the
//directive.
-------
//Expensive Calculator
//Demonstrates built-in arithmetic operators

//And also summarily demonstrates via the title
//the full extent of what I have ever done
//in all my off-and-on coding years
//and what anyone ever purchases
//when they acquire
//a goddamn
//PC.
-------
//Game Stats
//Demonstrates declaring and initializing variables

//I initially considered using incredibly inappropriate variable names
//but decided against it to be more professional
//and besides the only thing
//with 6572.89 tentacles
//is Cthulhu, who does
//not do porn of
//any sort
//I hope.
-------
//Game Stats 2.0
//Demonstrates arithmetic operations with variables

//I know that I said I intended to be professional in these variable names
//and I certainly intend to keep my word on that point
//but you have to admit that the temptation
//to use one dirty word for a variable
//just one dirty word for a variable
//is so incredibly strong
//that I certainly hope
//that you appreciate
//my Herculean force
//of will.
-------
//Game Stats 3.0
//Demonstrates constants

//The desire to name the variables dirty things has overall largely subsided
//but I take solace in the knowledge that, should I so choose
//I have the power to, at any time, fire up the IDE
//and write an entire program whose variables
//are nothing but various names
//of various body parts
//phallic references
//sex positions
//politicians
//and such.
-------
//Lost Fortune
//A personalized adventure

//Surely given a few minutes' thought, sufficient caffeine, and an inspirational spark,
//I could write out an entirely different story with additional variables
//some more customization, perhaps branching paths
//and a dozen other doodads and trinkets
//and perhaps I yet shall, but for now
//I feel I have just enough coffee
//to write the program as shown
//and leave the remainder
//for another, more
//caffinated day.
-------
//Score Rater
//Demonstrates the if statement

//Because despite the concept of "if something, then something" being an obvious one
//we get a whole two lessons' worth of coding to explain them
//and pair them up with "else"
//so let's get right
//to it.
-------
//Score Rater 2.0
//Demonstrates the else clause

//I'm beginning to run short of witty opening lines for these programs
//and as I have some eight chapters and change yet to complete
//I think that I will do myself a brief favor
//and keep this introduction short
//so I may reserve my wit
//for later lessons
//where I may have
//better lines
//to say.
(It comes as no small irony, or hypocrisy, that this is one of the longer headers. - Ed.)
-------
//Menu Chooser
//Demonstrates the switch statement

//In hindsight I should point out that a switch statement would have been
//a vastly superior option for youwilldie, as opposed
//to its inelegant if/else shenanigans
//and as such I am at a loss for
//smug statements, and will
//shut up and do
//the lesson.


Next, a bit more about Noah's sword, 168 words. It's appended to an earlier document, but only the appended portion is given here. I've also begun basic modelling of the blade in AutoCAD 360 for reference and may change these dimensions to taste.
Spoiler
Show
After some additional research I'm revising my thoughts on Noah's sword a little. Anything below this line supercedes anything written above.

The actual dimensions aren't quite inches because inches as we understand them were not developed in either the Old or New worlds. However, they're comperable - the tolerance here varies slightly but is at maximum one-fifth of an inch off in either direction and is perfectly fine for the purpose of discussion. Noah's sword is 60 inches long, with a 50 inch blade and a 10 inch handle. It's also a whopping 25 inches wide, which allows its use as a guard but makes the weapon rather unwieldy. The handle is also a minute amount thicker as a result and two-handed wielding is discouraged in favor of hand-and-a-half, using the handle inset into the blade - otherwise the handle could potentially snap from the force of striking something tough enough. The inset handle begins 32 inches from the base of the blade and is itself 6 inches long.


Third we have a high-level document for a basic RPG combat engine, the likes of which nearly anyone has likely seen. I've often played such games but never considered their inner workings and how to craft them; this is my brainstorming on how to do so. It is unsurprisingly neither complete nor elegant, but it is 550 words.
Spoiler
Show
//Basic combat engine high-level
//A practice C++ program in notes and pseudocode
//By redfeatherraven

//First thing's first, let's describe the game loop.

//First, combat is initialized, with a Player and an Enemy. The goal is to later

extend the program to accept multiples of each, allowing for a Player Party and an

Enemy Party, but for now it's fine to hard-code one Player and Enemy. These can later

be used as the basis of individual Player and Enemy entities.

//After initialization is the main combat loop.

//The first step in the combat loop is Players choosing their action for the turn.
//Enemies will then choose their action for the turn according to their AI.

//Once actions are selected, Initiative is calculated and compared.

//Actions are added to a queue stack. The highest Initiative is put into the stack

first, followed by the next highest, and so on until all entities have put their

actions into the stack.

//The stack resolves, FIFO. After each action resolves the stack is checked for

deadEntities - Players or Enemies who may have died as a result of previous actions -

and their actions are removed from the queue before the next action resolves.

//After all the actions resolve the game checks to verify living entities on both

sides. If both sides have combatants the combat loop continues, else it breaks.

//At the break, if Player entities remain then the Player wins; else if Enemy entites

remain the Player loses, else the Player still loses (the final scenario being a

wipeout on both sides).

//-------------Concepts

//Initiative: The relative speed of the entities, in hierarchical order. The faster

the entity, the higher the Initiative, and the sooner their action will be performed

compared to others'.

//Damage: Representative of wounds and such sustained in combat. Most actions deal

damage, represented as a number. It would be unfun to represent this realistically

(Critical Existence Failure is in full effect here). Later versions may include more

realistic damages, such as crippled limbs and what what, but this will not be

represented at first. Later versions may also increase Damage with equipment.

//Health: Representative of how many wounds one can take before succumbing to them.

Succumbing doesn't have to mean death. It usually still does. Health is represented as

a number with a maximum cap. Damage decreases this number. Other skills may increase

it again, but never past the cap. At 0, the entity becomes unable to fight. Further

updates may handle revival; the initial version will not need it.

//Armor: Reprasentative of anything standing between Damage and Health. Expressed

numerically, any incoming damage is reduced by this amount before being applied to

Health. Later, skills may improve Armor temporarily or bypass it entirely. Later

versions may also improve Armor with equipment, similar to Damage above.

//Base Stats: The numbers that determine the calculations for Initiative, Damage,

Health, and Armor. Unsurprisingly this leads to Agility, Strength, Vitality, and

Defense, respectively. All of these skill levels and physical traits are rendered in

cold numerals and factor in to the derived statistics above. Other stats, such as

Intelligence or Luck, may come into play in later versions; in the initial version, it

may be considered that everyone is a fortune-neutral mouth-breathing beatstick

droolbox.

//Entity: A collection of stats that represents a character in the combat.

//Player: An entity under player control.

//Enemy: An entity the player must fight, under AI control.


Lastly is another high-level treatment for a proposed "tall tale generator" which I hope will be more writing exercise than coding. I suspect by the end it'll be a combination of the two. This comprises 515 words.

Regardless of how the project itself turns out I'm rather fond of the poem it leads with.
Spoiler
Show
//Tavernfire Tales from the Raging Bull
//A game of programming practice

//Where the ales are fine and the lads are bold and the wildest tales unfold
//Of men that ride through land and brine and swords that clash and chop
//And those in from the cold may stop and find the hearth sublime
//And all the stories spun do turn and weave and shine as gold
//And as they intermix with food and wine and songs of old
//If any further stretched were what is told
//It'd be a taffy shop.

//Concept
//-------

//More than anything a wild tavern tale generator. The goal is to find a method by which these tales might be "mad-libbed" in such fashion as to keep dramatic tension.
//The tale-tellers should come from a variety of adventuring backgrounds, and have varied temperaments and flairs for the dramatic. This should then be reflected in the way they tell their tales.
//Obviously to a degree the tales, or parts, will begin to repeat themselves. However, the better the generator, the better the stories.
//Luckily, the coding is liable to be rather simplistic at first. If I begin to actually map out bits of narrative that sound appropriate with each other, or try to optimize the flow, then perhaps things could get dicier.
//However, until I do, it is literally a random generator's job spliced with either a switch or functions.
//While I could come up with tables and such, the simplest method would be to give each character a few temperaments, and then each temperament a handful of things they might say over the course of a story.

//Characters
//-------

//Characters will be comprised primarily of an occupation, which will determine the kinds of skills they bring to bear, and a temperament, which will influence both the actions they took in their tales and the telling.
//Secondarily they may have other minor attributes such as general appearance, clothing/armor/weapons in broad strokes, scars, missing eyes/limbs/etc, preferred drinks, that kind of thing.
//The secondary attributes will likely be glossed over, unless integral to the story ("Have I tol' ye the one about how I lost me eye?"), and merely add character.
//The storyteller character will be the most important during any given tale, but other characters will naturally be present, and they may interact with the teller (to heckle, for example). This functionality will likely appear down the road.

//Occupation
//-------

//One of a few of the general fantasy role-player's classes. Warriors, mages, and thieves would be the most prominent, all working-class-esque.
//The bold and braggart white knight might be at home here, but he better be bragging, and intellectual, age-like mages will probably be right out.
//The tavern is a seedy-ish place. You might find paladins, clerics, even priests, but they'd be really interesting types.
//Monks would likely be of the eastern ascetic variety rather than the medieval religious variety.
//Bards would be right at home but more difficult to develop as their stories would be, essentially, mad-libbed songs - kind of a nightmare for rhythm and meter, that.
//Some other classes you might find are rangers, scouts, witchhunters, soldiers...essentially anyone who might be willing to drink and tell a tale, and who I might be able to write.



Sadly none of this contributes to the theme, as I couldn't write up any scenes where adventurers told stories of dragons and hecklers claimed them to be imaginings. But it was in my thoughts, at least.

Hopefully next week will be more effectively productive, wish me luck.