My Shortie: Ray Camden's Beginner ColdFusion Contest (Monster Maker) : Kinky Solutions : A Student's Perspective by Ben Nadel

My Shortie: Ray Camden's Beginner ColdFusion Contest (Monster Maker)

Posted May 16, 2007 at 9:19 AM

Tags: ColdFusion, HTML / CSS, Javascript / DHTML, AJAX

Now that Ray Camden's Beginner ColdFusion Content has ended, I can discuss my unofficial entry. Seeing as I am not a beginner, I could not technically enter the contest, but I thought it would be a cool little project to have a go at, especially since I am not tremendously proficient with CFCs and object oriented programming (OOP).

Before I get into the details, I figured you might want to try the application. It is called My Shortie and can be launched here:

Launch My Shortie

Here is a screen shot of the application (don't worry, there is nothing Saucy about this application):

The labotomize button resets the Shortie's data. Also I am sure that is misspelling that word (labotomize) but I was too deep into the project to care by the time I found out :)

This little project proved much harder than I thought it was going to be. My first real hurdle was, How the heck do I interact with this entity (the Shortie) and how do I know how to affect the environmental properties in a way that is open to change? My first break through was the idea of an "Interaction".

An Interaction was a base component that defined what an interaction event with the Shortie would do; how does it affect the Shortie's energy? How long does it take to complete this interaction? How does it affect feelings of anger or love? Here is the base ColdFusion component that defines what an Interaction must define:

Launch code in new window » Download code as text file »

<cfcomponent
output="false"
hint="This component defines interactions with your Shortie. This is the base interaction that has zeroed out values. This interaction's INIT method should be overridden by specific interactions.">
<!---
Run pseudo constructor. Here is where we can set
up default data structures and data values.
--->
<!---
Create a private data structure to hold all instance
related data.
--->
<cfset VARIABLES.Instance = StructNew() />
<cfset VARIABLES.Instance.Name = "" />
<!---
This is the unique key for this interaction. No TWO
interactions should share the same key. This will help
the user keep track of repetative interactions.
--->
<cfset VARIABLES.Instance.Key = "base_interaction" />
<!---
This is the amount of time that the interaction
requires. All interactions require a minimum of 1 hour
(shortie hour, not real world hour). Some interactions
will take longer.
--->
<cfset VARIABLES.Instance.TimeRequired = CreateTimeSpan(
0,
1,
0,
0
) />
<!---
The following are suggested values as to how this
interaction will leave the user feeling. How the user
actually interpruts these values is out of our hands.
Positive values means that this interaction should
leave the end user feeling more of that dimension.
Negative numbers should leave the end user feeling
less of that dimension.
--->
<!---
This is how much love (feelings of being loved) a
user should feel after this interaction.
--->
<cfset VARIABLES.Instance.Love = 0 />
<!---
This is how much anger a user should feel after
this interaction.
--->
<cfset VARIABLES.Instance.Anger = 0 />
<!---
This is how much hunger a user should feel after
this interaction (negative values, for example,
means less hungry).
--->
<cfset VARIABLES.Instance.Hunger = 0 />
<!---
This is how much happiness a user should feel
after this interaction.
--->
<cfset VARIABLES.Instance.Happiness = 0 />
<!---
This is how much energy consumption is used after
this interaction (a negative value here means that
the user had to PUT OUT energy to perform this
interaction. A positive value, such as that defined
by sleep, would result in a higher final eneregy).
--->
<cfset VARIABLES.Instance.Energy = 0 />
<!---
This is a subjective flag as to whether the
interaction in general is thought of as a positive
or negative one. This flag will not always determine
how the end user views this interaction.
--->
<cfset VARIABLES.Instance.IsPositive = true />
<cffunction
name="Init"
access="public"
returntype="any"
output="false"
hint="Returns an initialized Interaction component. This method is supposed to be overriden by interactions that extend this base interaction.">
<cfreturn THIS />
</cffunction>
<cffunction
name="GetAnger"
access="public"
returntype="numeric"
output="false"
hint="Gets the anger rating.">
<cfreturn VARIABLES.Instance.Anger />
</cffunction>
<cffunction
name="GetEnergy"
access="public"
returntype="numeric"
output="false"
hint="Gets the energy rating.">
<cfreturn VARIABLES.Instance.Energy />
</cffunction>
<cffunction
name="GetHappiness"
access="public"
returntype="numeric"
output="false"
hint="Gets the happiness rating.">
<cfreturn VARIABLES.Instance.Happiness />
</cffunction>
<cffunction
name="GetHunger"
access="public"
returntype="numeric"
output="false"
hint="Gets the hunger rating.">
<cfreturn VARIABLES.Instance.Hunger />
</cffunction>
<cffunction
name="GetIsPositive"
access="public"
returntype="boolean"
output="false"
hint="Gets the positive vs. negative falg.">
<cfreturn VARIABLES.Instance.IsPositive />
</cffunction>
<cffunction
name="GetKey"
access="public"
returntype="string"
output="false"
hint="Gets the interaction key.">
<cfreturn VARIABLES.Instance.Key />
</cffunction>
<cffunction
name="GetLove"
access="public"
returntype="numeric"
output="false"
hint="Gets the love rating.">
<cfreturn VARIABLES.Instance.Love />
</cffunction>
<cffunction
name="GetTimeRequired"
access="public"
returntype="numeric"
output="false"
hint="Gets the time required to perform action.">
<cfreturn VARIABLES.Instance.TimeRequired />
</cffunction>
</cfcomponent>

As you can see, each interaction MUST have the following properties that are Get()able:

Anger
Energy
Happiness
Hunger
IsPositive
Love
TimeRequired

I decided that every interaction with the Shortie could be defined as some combination of these properties. Most of the properties (anger, energy, happiness, hunger, love) are simply numeric values that either add or subtract from the Shortie's properties. For instance, telling the Shortie, "I love you," should have a positive "Love" property since you tend to feel more loved when someone says they love you.

All interactions defined for the application must extend this base interaction. So for example, here is concrete ColdFusion component that defines the interaction for taking the Shortie to dinner (TakeToDinner.cfc):

Launch code in new window » Download code as text file »

<cfcomponent
extends="Interaction"
output="false"
hint="Take someone out to dinner.">
<cffunction
name="Init"
access="public"
returntype="any"
output="false"
hint="Returns an initialized interaction.">
<cfset SUPER.Init() />
<!---
Set interaction specific values. We are
NOT adding any new values here; these are
the values that will override the base
values set by the base interaction. NOT
all of the previously defined values need
to be overridden.
--->
<cfset VARIABLES.Instance.Name = "Take To Dinner" />
<cfset VARIABLES.Instance.Key = "take_to_dinner" />
<cfset VARIABLES.Instance.TimeRequired = CreateTimeSpan(
0,
3,
30,
0
) />
<!---
This interaction can make the user feel a bit more
loved, or it can just be part of the routine.
--->
<cfset VARIABLES.Instance.Love = 1 />
<!---
This interaction can make the user feel a bit less
angry, or it can just be part of the routine.
--->
<cfset VARIABLES.Instance.Anger = -1 />
<!---
This interaction can give the user more energy or
leave them with some serious food coma.
--->
<cfset VARIABLES.Instance.Energy = 3 />
<!---
This interaction can increase happiness or it can
just be part of the routine.
--->
<cfset VARIABLES.Instance.Happiness = 1 />
<!---
This interaction will most definitely leave the user
feeling less hungry than they were before.
--->
<cfset VARIABLES.Instance.Hunger = -10 />
<!---
This interaction is a positive overall
experience.
--->
<cfset VARIABLES.Instance.IsPositive = true />
<cfreturn THIS />
</cffunction>
</cfcomponent>

As you can see, these concrete implementations of the Interaction base class just override the constructor (Init) method. All the Getter methods are defined by the base ColdFusion component. The only thing that is special about the concrete Interactions is that they have a special combination of the properties listed above. So, looking at the TakeToDinner.cfc, you can see that eating results in a -10 change in the Shortie's hunger (potentially) and requires 3.5 hours of time.

The idea behind the TimeRequired is that you can't simply fire interaction after interaction. Interactions with anyone take time. Sure, some interactions don't take very long, but for our simple application, we are going to assume that no interaction takes any less than one hour.

Once I started to flesh out more of the concrete interaction ColdFusion components, I felt really good about where this path was leading. This combination of properties, while simple, does feel quite natural. The next big hurdle was data persistence. The application has to be really simple and portable, so that means no database. But, since we cannot depend on purely APPLICATION-scoped values as this application must survive over time, the next best solution is data persistence via XML files.

But what are we persisting? Not just any old data - we are persisting how the Shortie feels at a given time. To me, this sounds like a Brain. So, I created a Brain.cfc ColdFusion component that has generic Get() and Set() methods. These Get() and Set() methods can take any kind of serializeable data (strings, numbers, dates, arrays, structs). These data points then get serialized and stored to an XML file via ColdFusion's WDDX functionality:

Launch code in new window » Download code as text file »

<cfcomponent
output="false"
hint="This the brain of the shortie and is used to persist data between application instances.">
<!---
Run pseudo constructor. Here is where we can set
up default data structures and data values.
--->
<!---
Create a private data structure to hold all instance
related data.
--->
<cfset VARIABLES.Instance = StructNew() />
<!---
We are going to be persisting this data via an XML
file that we write to disk. This is the file path
of the XML file. By default, we are going to store
the XML file in the same directory (but this can be
overridden in the INIT method).
--->
<cfset VARIABLES.Instance.DataFilePath = (
GetDirectoryFromPath( GetCurrentTemplatePath() ) &
"brain.xml"
) />
<!---
This is the struct in which we are going to hold the
data. This is going to be the only form of data we
store. I am going to assume that this struct will
only hold simple value. I am not going to enforce this.
--->
<cfset VARIABLES.Instance.Data = StructNew() />
<cffunction
name="Init"
access="public"
returntype="any"
output="false"
hint="Returns an initialized brain instance.">
<cfargument
name="DataFilePath"
type="string"
required="false"
default=""
/>
<!---
Check to see if we were passed a new file path.
If so, then store this one as our XML file path.
--->
<cfif Len( ARGUMENTS.DataFilePath )>
<cfset VARIABLES.Instance.DataFilePath = ARGUMENTS.DataFilePath />
</cfif>
<!---
Now that we have a data file stored, we can read
in what ever data might already exists. Load the
persisted data.
--->
<cfset VARIABLES.LoadData() />
<cfreturn THIS />
</cffunction>
<cffunction
name="ClearData"
access="public"
returntype="void"
output="false"
hint="Clears the stored data.">
<cfset StructClear( VARIABLES.Instance.Data ) />
<cfset THIS.CommitData() />
<cfreturn />
</cffunction>
<cffunction
name="CommitData"
access="public"
returntype="void"
output="false"
hint="Commits the data to persited storage. This is a public access function so that the invoker can delay auto-committing during other methods.">
<cfset var LOCAL = StructNew() />
<!---
Convert the internal data structure to a WDDX
xml data structure. Again, not crazy about WDDX,
but it is easy for our purposes.
--->
<cfwddx
action="CFML2WDDX"
input="#VARIABLES.Instance.Data#"
output="LOCAL.FileData"
/>
<!---
Write the data to the data file. We don't care
if we overwrite an existing data file or just
create a new one.
--->
<cffile
action="WRITE"
file="#VARIABLES.Instance.DataFilePath#"
output="#LOCAL.FileData#"
/>
<cfreturn />
</cffunction>
<cffunction
name="Get"
acces="public"
returntype="any"
output="false"
hint="Gets a stored value at the given key. If no value is found, returns an empty string.">
<cfargument
name="Property"
type="string"
required="true"
/>
<!---
Check to see if we have a value stored at the
given property key. If we cannot find the given key,
then just return the empty string. Think about a
brain - if you can't remember something, your head
doesn't explode - ok maybe not, but that's how
this is going to work.
--->
<cfif StructKeyExists(
VARIABLES.Instance.Data,
ARGUMENTS.Property
)>
<cfreturn VARIABLES.Instance.Data[ ARGUMENTS.Property ] />
<cfelse>
<!---
No value was found. Return our default
value which is the empty string.
--->
<cfreturn "" />
</cfif>
</cffunction>
<cffunction
name="LoadData"
access="private"
returntype="void"
output="false"
hint="Tries to load the XML file into the data struct. If the data file does not exist, no action is taken.">
<cfset var LOCAL = StructNew() />
<!---
Check to see if our data file eixsts. If it
does not, then we might have not done anything
yet (ignore action).
--->
<cfif FileExists( VARIABLES.Instance.DataFilePath )>
<cffile
action="READ"
file="#VARIABLES.Instance.DataFilePath#"
variable="LOCAL.FileData"
/>
<!---
Convert the XML data to our internal struct
data using a WDDX conversion. I am not crazy
about this WDDX conversion, but it's easy.
--->
<cfwddx
action="WDDX2CFML"
input="#LOCAL.FileData#"
output="VARIABLES.Instance.Data"
/>
</cfif>
<cfreturn />
</cffunction>
<cffunction
name="Set"
access="public"
returntype="void"
output="false"
hint="Sets the given property value at the given key.">
<cfargument
name="Property"
type="string"
required="true"
hint="The key used to access the property value."
/>
<cfargument
name="Value"
type="any"
required="true"
hint="The property value. This should be a simple value, but I am not enforcing that."
/>
<cfargument
name="CommitData"
type="boolean"
required="false"
default="true"
hint="If the invoker is planning on calling serveral sets in a row, they might choose to delay commiting and then commit manually after the last Set method call."
/>
<cfset VARIABLES.Instance.Data[ ARGUMENTS.Property ] = ARGUMENTS.Value />
<!---
Check to see if we are committing the data. If we
are not, then skip the commit and leave it up
to the invoker.
--->
<cfif ARGUMENTS.CommitData>
<cfset THIS.CommitData() />
</cfif>
<cfreturn />
</cffunction>
</cfcomponent>

I decided to build the Brain.cfc as a separate component from the Shortie.cfc (up next) because I really wanted to stress the separation of concerns. This Shortie itself should not really have to know how to store data over time. And think about it in the real world; do we know how data gets stored? Sort of? Not really? We just send nerve impulses to our brain and our brain just kind of stores and retrieves it via some sort of crazy awesome black magic.

By building the Brain.cfc separately, it allowed me to unit test the brain functionality before I even started working on the Shortie.cfc. Also, by breaking the system down into smaller parts, it made it easier for me to think about.

Now that we have our interactions defined and our model for data persistence, it's time to actually build something to interact with. The Shortie.cfc ColdFusion component is our representation of the "Monster" (the original contest idea was Monster Maker). The Shortie.cfc was, by far, the most complicated of the involved components. Not so much because the code was crazy - more so because people are irrational and crazy and random and how the hell to you model that EVEN if you have good Interaction definitions?

The Shortie's Interact() method takes an instance of the Interaction.cfc ColdFusion component. It then grabs the properties out of that instance and updates its own internal state. To try to model the real world, this method if chock full of "randomness". Every now and then, it will totally flip the properties so that something that should have given you energy make you tired and something that should have made you feel loved will fill you with anger.

The other difficult thing about this component was that I didn't want it to be in real time. Meaning, like dog years, I wanted the Shortie's time to be smaller but proportional to real world time. For this application, one day of real world time is the equivalent of 120 days of Shortie time (one Shortie hour = 30 seconds real world time).

Aside from the time scale itself, incrementing time was hard to figure out. When you increment time, you are doing more than just changing a single variable; time wears on people - it makes them hungry, it sucks energy. And, if interactions themselves take time, then incrementing the Shortie time is going to be coupled with possibility of interactions.

Here is the Shortie.cfc code:

Launch code in new window » Download code as text file »

<cfcomponent
output="false"
hint="This is your shortie; treat her well.">
<!---
Run pseudo constructor. Here is where we can set
up default data structures and data values.
--->
<!---
Create a private data structure to hold all instance
related data.
--->
<cfset VARIABLES.Instance = StructNew() />
<!---
This is the brain that the shortie will use to persist
data. This is a place holder. The actual data fill be
passed in during construction.
--->
<cfset VARIABLES.Instance.Brain = "" />
<!---
These are the base line values on the shortie
properties. These are the values that will be updated
by the interactions. These will be used to calculate
the overall mood and health of your shortie. A positive
number indicates "more" of that property where as a
negative value indicates "less" of that property.
For a more in-depth explanation of what these
properties mean, check out the Interaction.cfc code.
--->
<cfset VARIABLES.Instance.Anger = 0 />
<cfset VARIABLES.Instance.Energy = 0 />
<cfset VARIABLES.Instance.Hunger = 0 />
<cfset VARIABLES.Instance.Happiness = 0 />
<cfset VARIABLES.Instance.Love = 0 />
<!---
This is the current time in which the Shortie exists.
This is not necessarily reflective of the real world
time and it might be overriden by the Brain.
--->
<cfset VARIABLES.Instance.Time = Now() />
<!---
This is the real world time. We need to keep track of
this so we can later on figure out how much time has
passed since we last calculated the time.
--->
<cfset VARIABLES.Instance.RealTime = Now() />
<!---
This is the time scale to days of real world time
to shortie world time. Hour shortie hours are going
to equal 30 real world seconds. Since our time
difference are going to be calculated in fractions
of a day, we need to figure out how to multiple our
day fractions to get shortie hours.
H = Hour
D = Day
SH = Shortie Hour
SD = Shortie Day
1 H == 60 * 2 SH
24 H == 60 * 2 * 24 SH
1 D == 60 * 2 * 24 / 24 SD
1 D == 60 * 2 SD
1 D == 120 SD
--->
<cfset VARIABLES.Instance.DayScale = 120 />
<!---
This is the time at which the next interaction will
be available. This is to prevent you from abusing your
shortie and to take into account that each interaction
does require some time to enact. For now, we will just
set it to now(), but that can be overridden.
--->
<cfset VARIABLES.Instance.NextInteractionTime = Now() />
<cffunction
name="Init"
access="public"
returntype="any"
output="false"
hint="Returns an initialized shortie instance.">
<cfargument
name="Brain"
type="any"
required="true"
/>
<!---
Store the passed in brain object. The brain object
should already have the persisted data loaded into
it, so no need to alter the Brain in any way.
--->
<cfset VARIABLES.Instance.Brain = ARGUMENTS.Brain />
<cfset VARIABLES.LoadData() />
<!---
Adjust time to get the Shortie's time scale the
current time (if time has elapsed since that last
time the Application was fired up).
--->
<cfset THIS.AdjustTime() />
<cfreturn THIS />
</cffunction>
<cffunction
name="AdjustTime"
access="public"
returntype="void"
output="false"
hint="This adjusts the shortie time to make sure it scales to regular world time increments.">
<cfset var LOCAL = StructNew() />
<cfset LOCAL.Now = Now() />
<!---
Get the difference in real world time that has
elapsed since our last time adjustment. This will
give us the fraction of days that have passed.
Then, we need to multiple that by are day factor to
get how many shortie hours have passed.
--->
<cfset LOCAL.DayDiff = (
(LOCAL.Now - VARIABLES.Instance.RealTime) *
VARIABLES.Instance.DayScale
) />
<!---
This is the actual date that we need to adjust
our internal time value to.
--->
<cfset LOCAL.TargetTime = (
VARIABLES.Instance.Time +
LOCAL.DayDiff
) />
<!---
Increment the time. This will take care of
actually updating the internal time value. We want
in increase the time only that is required.
--->
<cfset VARIABLES.IncrementTime(
(LOCAL.TargetTime - VARIABLES.Instance.Time)
) />
<!---
Update the real time so that our date-diffs don't
lose track of our scaled time.
--->
<cfset VARIABLES.Instance.RealTime = LOCAL.Now />
<cfreturn />
</cffunction>
<cffunction
name="CommitData"
access="private"
returntype="void"
output="false"
hint="This commits short term memory to the brain.">
<cfset VARIABLES.Instance.Brain.Set(
Property = "Anger",
Value = VARIABLES.Instance.Anger,
CommitData = false
) />
<cfset VARIABLES.Instance.Brain.Set(
Property = "Energy",
Value = VARIABLES.Instance.Energy,
CommitData = false
) />
<cfset VARIABLES.Instance.Brain.Set(
Property = "Hunger",
Value = VARIABLES.Instance.Hunger,
CommitData = false
) />
<cfset VARIABLES.Instance.Brain.Set(
Property = "Happiness",
Value = VARIABLES.Instance.Happiness,
CommitData = false
) />
<cfset VARIABLES.Instance.Brain.Set(
Property = "Love",
Value = VARIABLES.Instance.Love
) />
<cfset VARIABLES.Instance.Brain.Set(
Property = "Time",
Value = VARIABLES.Instance.Time
) />
<cfreturn />
</cffunction>
<cffunction
name="GetNextInteractionTime"
access="public"
returntype="numeric"
output="false"
hint="Gets the time at which the Shortie can next be interacted with.">
<cfreturn VARIABLES.Instance.NextInteractionTime />
</cffunction>
<cffunction
name="GetProperties"
access="public"
returntype="struct"
output="false"
hint="Returns the 'mental' properties of the shortie.">
<cfset var LOCAL = StructNew() />
<cfset LOCAL.Anger = VARIABLES.Instance.Anger />
<cfset LOCAL.Energy = VARIABLES.Instance.Energy />
<cfset LOCAL.Hunger = VARIABLES.Instance.Hunger />
<cfset LOCAL.Happiness = VARIABLES.Instance.Happiness />
<cfset LOCAL.Love = VARIABLES.Instance.Love />
<cfreturn LOCAL />
</cffunction>
<cffunction
name="GetTime"
access="public"
returntype="string"
output="false"
hint="Returns the shortie time (internal time model).">
<!---
Return the time as a string with full date / time
stamp formatting.
--->
<cfreturn (
DateFormat(
VARIABLES.Instance.Time,
"mm/dd/yyyy "
) &
TimeFormat(
VARIABLES.Instance.Time,
"hh:mm TT"
)
) />
</cffunction>
<cffunction
name="IncrementTime"
access="private"
returntype="void"
output="false"
hint="This increments time.">
<cfargument
name="TimeSpan"
type="numeric"
required="false"
default="#CreateTimeSpan( 0, 1, 0, 0 )#"
hint="The time to increase for this iteration (defaults to an hour)."
/>
<cfset VARIABLES.Instance.Time = (
VARIABLES.Instance.Time +
ARGUMENTS.TimeSpan
) />
<!---
Every time we increment the time, it takes a
toll on the shortie. Time makes you tired, it
makes you hungry. This is on top of any
interactions that have just taken place. For every
four hours that pass, the shortie loses 1 energy
units (scaled to our time span).
--->
<cfset VARIABLES.Instance.Energy = (
VARIABLES.Instance.Energy -
(
1 *
ARGUMENTS.TimeSpan / CreateTimeSpan( 0, 4, 0, 0 )
)
) />
<cfset VARIABLES.Instance.Hunger = (
VARIABLES.Instance.Hunger +
(
1 *
ARGUMENTS.TimeSpan / CreateTimeSpan( 0, 4, 0, 0 )
)
) />
<cfset VARIABLES.CommitData() />
<cfreturn />
</cffunction>
<cffunction
name="Interact"
access="public"
returntype="void"
output="false"
hint="This is how you can pass in an interaction. This will update the internal state.">
<cfargument
name="Interaction"
type="any"
required="true"
hint="This is an interaction that must implement the interaction interface."
/>
<cfset var LOCAL = StructNew() />
<!---
Before we do any interaction, we have to adjust
the time. We might not even be able to perform an
interaction and we will need to adjust time in
order to figure that out.
--->
<cfset THIS.AdjustTime() />
<!---
Now that we have the proper time, check to see if
we can perform an interaction.
--->
<cfif (VARIABLES.Instance.NextInteractionTime GT VARIABLES.Instance.Time)>
<!---
We have not yet reached our time of next
possible interaction. Just return out of the
interaction method call.
--->
<cfreturn />
</cfif>
<!---
ASSERT: At this point, we know that we have waited
long enough to perform another interaction.
--->
<cfset LOCAL.TimeRequired = ARGUMENTS.Interaction.GetTimeRequired() />
<!---
This interactoin will "lock" the shortie's ability
to interact for a given amount of time. Keep track
of that time by adding the time required to the
current shortie time.
--->
<cfset VARIABLES.Instance.NextInteractionTime = (
VARIABLES.Instance.Time +
LOCAL.TimeRequired
) />
<!---
With all interactions, there is some degree of
error and randomness. We are going to produce
this randomness and we are going to do it on
several levels.
Create a general multiplier. We are going to
default this to one, but one time out of 30
(statistically) this is going to be totally
haywire and flip.
--->
<cfif (RandRange( 1, 30 ) EQ 15)>
<!---
This interaction is NOT going to make any
sense. But that's ok - that is life sometimes.
--->
<cfset LOCAL.Multiplier = -1 />
<cfelse>
<cfset LOCAL.Multiplier = 1 />
</cfif>
<!---
ASSERT: At this time, we have determines if this
going to be a completely non-sensical interaction
or a normal interaction. Now, we can determine the
minor randomness.
--->
<!---
Create an interum struct that will hold the deltas
for our internal properties.
--->
<cfset LOCAL.Delta = StructNew() />
<!---
Get the delta values from the interaction. When
getting the base data, add some minor noise to
each value and multiple the random multiplier.
--->
<cfset LOCAL.Delta.Anger = (
(
ARGUMENTS.Interaction.GetAnger() *
LOCAL.Multiplier
) +
RandRange( -1, 1 )
) />
<cfset LOCAL.Delta.Energy = (
(
ARGUMENTS.Interaction.GetEnergy() *
LOCAL.Multiplier
) +
RandRange( -1, 1 )
) />
<cfset LOCAL.Delta.Hunger = (
(
ARGUMENTS.Interaction.GetHunger() *
LOCAL.Multiplier
) +
RandRange( -1, 1 )
) />
<cfset LOCAL.Delta.Happiness = (
(
ARGUMENTS.Interaction.GetHappiness() *
LOCAL.Multiplier
) +
RandRange( -1, 1 )
) />
<cfset LOCAL.Delta.Love = (
(
ARGUMENTS.Interaction.GetLove() *
LOCAL.Multiplier
) +
RandRange( -1, 1 )
) />
<cfset LOCAL.Delta.IsPositive = ARGUMENTS.Interaction.GetIsPositive() />
<!---
Now that we have the delta values with random
noise, update the internal data model.
--->
<cfset VARIABLES.Instance.Anger = (
VARIABLES.Instance.Anger +
LOCAL.Delta.Anger
) />
<cfset VARIABLES.Instance.Energy = (
VARIABLES.Instance.Energy +
LOCAL.Delta.Energy
) />
<cfset VARIABLES.Instance.Hunger = (
VARIABLES.Instance.Hunger +
LOCAL.Delta.Hunger
) />
<cfset VARIABLES.Instance.Happiness = (
VARIABLES.Instance.Happiness +
LOCAL.Delta.Happiness
) />
<cfset VARIABLES.Instance.Love = (
VARIABLES.Instance.Love +
LOCAL.Delta.Love
) />
<cfset VARIABLES.CommitData() />
<cfreturn />
</cffunction>
<cffunction
name="LoadData"
access="private"
returntype="void"
output="false"
hint="Loads the property data from the brain (persisted data).">
<!---
From the brain, set the initial values for our
internal state properties. Since we might not have
all of these value set, be sure to Val() each
value that gets returned.
--->
<cfset VARIABLES.Instance.Anger = Val(
VARIABLES.Instance.Brain.Get( "Anger" )
) />
<cfset VARIABLES.Instance.Energy = Val(
VARIABLES.Instance.Brain.Get( "Energy" )
) />
<cfset VARIABLES.Instance.Hunger = Val(
VARIABLES.Instance.Brain.Get( "Hunger" )
) />
<cfset VARIABLES.Instance.Happiness = Val(
VARIABLES.Instance.Brain.Get( "Happiness" )
) />
<cfset VARIABLES.Instance.Love = Val(
VARIABLES.Instance.Brain.Get( "Love" )
) />
<cfset VARIABLES.Instance.Time = Val(
VARIABLES.Instance.Brain.Get( "Time" )
) />
<!---
Make sure our time is valid. If for some reason
we are not starting out with a valid time, then
set it equal to the real world time.
--->
<cfif NOT VARIABLES.Instance.Time>
<cfset VARIABLES.Instance.Time = VARIABLES.Instance.RealTime />
</cfif>
<cfreturn />
</cffunction>
<cffunction
name="Labotomize"
access="public"
returntype="void"
output="false"
hint="Clears the brain data, thereby, resenting the properties.">
<cfset VARIABLES.Instance.Brain.ClearData() />
<cfset VARIABLES.LoadData() />
<cfset VARIABLES.Instance.NextInteractionTime = Now() />
<cfreturn />
</cffunction>
</cfcomponent>

Notice that the Shortie takes an instance of the Brain.cfc in its Init method. I think this is a good application of composing one object inside another. But again, I am learning this stuff as I go.

The one final hurdle to conquer was not letting interaction after interaction being fired. We know that interactions take time (one of their properties). Using this, the Shortie keeps track of a "Next Interaction Time". Once an interaction gets sent to the Shortie, the time required for the interaction is added to the Shortie's current time. Then, if any more interactions get passed in (Interact() method) before the Shortie's time is greater than the next interaction time, they are simply ignored.

The one final piece of the back end is the Application.cfc which ties it all together. The Application.cfc ColdFusion component here is very simple. All it does really is create an instance of the Brain.cfc and injects it into the instance of the Shortie.cfc and then caches it in the APPLICATION scope.

Launch code in new window » Download code as text file »

<cfcomponent
output="true"
hint="Handles application definition and application level events.">
<!---
Run pseudo constructor. Set up the Application
properties and session management.
--->
<cfset THIS.ApplicationName = "KinkySolutions - My Shortie" />
<cfset THIS.ApplicationTimeOut = CreateTimeSpan(
2,
0,
0,
0
) />
<cfset THIS.SessionManagement = false />
<cfset THIS.SetClientCookies = false />
<cfsetting
requesttimeout="20"
showdebugoutput="false"
/>
<cffunction
name="OnApplicationStart"
access="public"
returntype="boolean"
output="false"
hint="Runs when application starts or is manually reset.">
<!---
Even though the OnApplicationStart() method is
meant to be single threaded, since we might be
calling it manually, we have to be sure to
force the single thread - the act of calling
this method alone will not accomplish that.
--->
<cflock
scope="APPLICATION"
type="EXCLUSIVE"
timeout="10">
<cfset StructClear( APPLICATION ) />
<!---
Create an instance of the user defined
functions library, cached in the application.
--->
<cfset APPLICATION.UDFLib = CreateObject(
"component",
"UDFLib"
).Init()
/>
<!---
Create a shortie and cache her in the
APPLICATION scope. We only need one per
application and we need her to persist
across page requests. When creating the
shortie, we need to initialize her with
a brain that knows where to store its