what is the best way to contact you?
Thanks for the offer Aleksandr! Here’s our contact page…
http://www.whatif-productions.com/contact.htm
Do you have any idea on how much a licence fee will be?
You probably missed it but here’s what I posted earlier… “The system will
be licensed to professional game developers at a later date TBD /
pricing is TBD. The eventual goal is to streamline the system to make it
possible for the general public to develop content too.”
No offense Posm, but … You demonstrate well enough some of art implementation, but nothing no how to make stuff interactive.
Heheh, no problem, no offense taken. Sorry it has taken so long to get back to you, but we’ve been real busy, and I wanted to get the chief architect of the system to explain it properly. Here’s what he has to say… I hope this helps.
“EXPlanations” are Whatif’s underlying model for simulating an experience inside of a computer, such as a concrete historical recreation, a gritty fictional adventure or an abstract artistic expression. Whatever the setting, EXPlanations allow you to do what today’s video games, scientific software, and military training simulators do using the traditional software techniques of programming code to work with data, as done in C++, Java, or Python.
Architecturally, EXPlanations were designed to avoid some of the frustrating limits of the traditional software approach, such as:
- the cost in time and engineering skills to implement ideas that can be readily described in words or pictures,
- the inability to easily assimilate distinct proprietary code/data_models into a pre-existing system,
- the inflexible relationships between the fixed data models and fixed programming code of most of today’s languages.
Our goal was to encourage experimentation and make it easy to use content (things, behaviors, concepts) from other sources that might be applicable to your current project. This means that content from very different worlds, very different perspectives can be shared, tweaked or even used as a starting point for further development. Whether its a realistic, highly physically accurate science exploration of Dinosaurs with darwinian survival instincts, metabolisms and temperatures or the campy yet heroic action of 1950s B-movie Dinosaurs with blood&guts, evil rampages, and sinister yet consitently dramatic timing, or a child’s fun & cartoony journey with Dinosaurs with talking, singing, and playful rolling of googily eyes, each simulation’s Dinosaur can co-exist in the same place at the same time.
However, each Dinosaur is simulated according to its own subjective reality with all of the concepts that EXPlain what happens as time passes. More significantly, it is possible for each Dinosaur to share, translate, analyze and learn from each other’s concepts and EXPlanations. Perhaps that seems like a ridiculous example, but the goal is to encourage experimentation and to shorten the timespan to get complex simulations implemented and modified/tuned to the desired result. By being able to trade, filter and assimilate these EXPlanation ‘granules’ of simulation, we have a set of building blocks that doesn’t need to be thrown out, created from scratch, or significantly altered for every shifted project need, computing platform, or new project. This approach permits organic, living software that can grow and shrink over time according to its goals.
So how are they created?
Well EXPlanations can be created in many different ways, depending on your needs and what tool is used. This approach is similar to Microsoft’s goals with .NET and the theoretical potential of the Java JVM. EXPlanations can be created in the same way that many of today’s programming languages allow you to write in plain text, drag’n’drop icons into a graph, plug values into a GUI, or select radio buttons from ‘Wizard’ applications that walk you through choices. EXPlanations are created using tools written in other EXPlanations. Thus you can type or use Speech-Recognition to write plain text inside of an EXPlanation tool that parses this text from simplified English commands, Perl, C++, Flash, or BASIC into valid EXPlanations. You could use a different tool that works with simple drop-down menus, complex 2d icon graphs, or rich 3d word stacks with containers & bridges. You can mix, match, and grow the tools in the same way as any other creature being simulated. However, as of today, our implementation of tools is rather minimal and exists as a specialized LISP-like language built for internal development. We will get to the aforementioned tools as soon as we are able. Right now, we are creating tools that are specific to creating EXPlanations for a particular genre of video game.
Currently our demo-EXPlanations can be read in a simplified-English Command format. Some examples would be:
-
Calculate_My_Total_Strength
*Consider my_weight in kg’s.
*Considermy_muscle_density in percentage.
*My_Total_Strength in strength_power_units = my_weight * my_muscle_density -
Stalk_My_Target
*Consider this_target’s distance to me.
*Consider my_threshold for near_and_far distances of a_target.
*If this_target’s distance is less_than my_threshold’s near_distance,
then consider my_current_plan and change_it_to Avoid_My_Target
*If this_target’s distance is greater_than my_threshold’s far_distance,
then consider my_current_plan and change_it_to Chase_My_Target
*Consider this_target’s Interesting_Factor in percentage
*If Interesting_Factor is less_than 40%
then consider my_current_plan and change_it_to
Wander_And_Find_New_Target
- Basketball_Visual_Sensations
*Consider Sphere_Shape in Geometry
*Consider Basketball_Diffuse_Colors in Color
*Consider Basketball_Layout in Map_Wrapping
*Consider Basketball_Bumps in Elevations
*Consider Basketball_Diffuse_Colors in Color
*Consider Ball_Age in Intensity
*Consider My_Tint in Color
*Consider Rubber_Shine
*Consider Corporate_Logo
*Consider Ball_Age
*Consider Print_Smearing
*Consider Logo_Wrapping_1972
Visual_Sensations =
Sphere_Shape
coated with
( (Basketball_Diffuse_Colors* My_Tint + Rubber_Shine decayed_by Ball_Age ) scaled by Basketball_Bumps ) using Basketball_Layout
and
coated with
( Corporate_Logo filtered by Print_Smearing decayed_by Ball_Age) using Logo_Wrapping_1972
Hopefully the three examples above give you a sense of the minimal level of simplified English that we accomodate. As programmers, we use abbreviations for everything that shrinks this to a more reader-friendly style. The above translations are working with ‘Concepts’ such as Weight, Kg, Ball_Age, Intensity, and Chase_My_Target that are all previously defined before this EXPlanation was written. Each of those concepts may have individually-specific answers for the particular entity (object) that is ‘EXPlained’ with this EXPlanation or it may rely on generic default answers or group-specific answers.
This means that unlike traditional C++ or Java code, the actual ‘EXPlanation code’ can change itself overtime in response to feedback/learning, or the introduction of new data structures such as a different model for a Character’s strength vs. muscle vs. toughness, analytical vs. memory vs. observation pathfinding techniques, means to represent an emotion (happy as a percentage vs. joyful as a set of tokens vs. delight as a location in a 4d emotional spatial-map).
Despite the tools used to create an EXPlanation, it is always stored in the same format. Thus, the same EXPlanation can always be viewed in any of the tools that read them so that programmers, artists, designers, fanatics, and casual folks can all examine the same piece of content with tools that they are comfortable with and into a level of detail that they understand. It should be noted however, that an EXPlanation created in a drag’n’drop graph tool might not appear as clear or accessible when viewed in a simplified English command tool.
The EXPlanation formula is a ‘tokenized, compressed, and encrypted’ stream of symbols. It actually executes and modifies itself always in a compressed and encrypted state as well. This ‘stream of symbols’ is best thought of as tiny programs and data that are used to create ‘service requests’ to Whatif’s service-provider ‘Dors’ program on any applicable computer-platforms (WinXP, PS2, Palm OS). Each EXPlanation request is parsed, compiled into ‘processor&data-friendly’ assembly code for optimal speed/size, and cached for future reuse. This allows us to operate independently across many computers today and into the future. It was particularly architected for massively parallel machines and the ability to use the cycles of other machines on nearby or distant networks.
EXPlanations of symbol streams contain formulas that ‘explain’ what to do to simulate something, such as adding two concepts together to get a third one. If those two concepts are a number, the result will be another number. If those two concepts are images, the result will be a composite of both. The results of any formula depends on the concepts used and is always well defined by the definitions and of the actual concepts. If those two concepts each include a number and an image, the composited resulting image will be scaled by the numbers.
If the two concepts are other EXPlanations that describe how to evaluate another creature’s appeal, they will be mixed together.
For example, we may ‘add’ the Stalk_My_Target EXPlanation from above with the below…
Evaluate_Creature’s_Appeal (abbreviated version)
“Consider the creature’s size compared to mine as a ratio number and consider the speed at which it is approaching me in 6 levels from ‘very slow’ to ‘very fast’, then consider if the ratio number or the speed token are ‘greater-than’ my fear-threshold of a 2:1 ratio or a ‘fast’ level then decrease the creature’s Appeal by 200 units and check again in 1 second”
When they are mixed the concept of Appeal may interpret and resolve itself as an Interesting_Factor in percentages, which was considered at the end of Stalk_My_Target. Thus the Appeal value will now be influencing how long a target_creature is stalked and change the behavior of whomever is EXPlained with this mix.
The formulas that are used can contain other formulas and are able to easily accomodate deep complexity while still being navigatable and comprehensible by its author. In all cases, we’ve made certain we can represent any expression of today’s functional, procedural and mathematical programming languages so that simulations can be as robust or as artistically abstract as the author’s goal.
This writing probably raises more questions than answers but it was meant to give a generic sense of what EXPlanations were designed to do, including the power to self-modify its rules and information dynamically. There is much to clarify that is better demonstrated than it is written, but the Whatif team is focused on building those tools and demonstrations as quickly and efficiently as we can. We thank you for your interest in the visual aspects that we have shared so far and look forward to revealing more in the future.
)