Particle FX Library – NOW AVAILABLE to Registered Users!

  NOW, FOR A LIMITED TIME,  we are offering OUR ENTIRE COLLECTION of OVER THREE HUNDRED original, ultra-high-quality, and MIND-BLOWINGLY UNIQUE particle effects….  FOR FREE!

  This collection contains a wide variety of effects, including numerous ultra-realistic explosions, fire, spark, electrical, and fog FX, as well as never-before-seen vortex, implosion, atomic, plasma, and space-type FX (including a huge library of various unique sun/star FX) , as well as an entire subset of original weapon FX, including both projectile and beam weapons, the likes of which you (and your potential players)  have never seen before!

All Particle FX are provided in GML format — modify them as you wish — learn from the code.

Visit the DOWNLOADS page* to access this unique FX library.

Remember… these effects will only be FREE for a LIMITED TIME.

 NOW- Get the entire library in one archive for only $1.99!!


PFX_COMPLETE


Price/piece: $1.99
($1.99 excl. taxes)

* This one-of-a-kind library is available ONLY to REGISTERED USERS
   Registration is simple! Sign up now to gain access to the Free FX Downloads!
 

AI Kits – Coming Soon!

DO NOT MISS THIS ANNOUNCEMENT!

  Within the next week, we will be offering for sale at extraordinary prices,  specially selected Game AI Code Solutions , directly from Holohedron Gameworks’ private code library.  These special “AI Kits” consist of GameMaker projects, extensions, libraries, and resources designed to address a wide range of Game AI / Agent development scenarios, from the most common, such as steering behaviors, finite state machine architectures, various pathfinding and navigation methodologies, through more advanced solutions, such as fully functional, highly-configurable goal-planning agents, sensory & memory modeling, agent “personality-endowment” code, scripting & configuration platforms, as well as a complete toolchain for creation, management, and custom integration of multi-purpose node-based graphs & trees (which can be used for many purposes, including but not limited to navGraph pathfinding, behavior tree construction, strategy / goal – tree systems, conversation trees, resource / dependency graphs, and many, many others). 

  And our AI Solutions don’t stop there. This library includes code and resource kits which address some of the most esoteric issues, such as fuzzy logic, machine learning & neural networks, self-organizing maps, genetic algorithms, as well as an ENTIRE COLLECTION of highly original (in many cases completely unique) hybrid and unclassified agent architectures, including but not limited to ones based in concepts such as subsumption heirarchies, multi-tiered concurrent goal arbitration & planning, “emotion” / “mood” – influenced behavior arbitration,  heirarchical state-machines with embedded parallel planners, sense/memory/identity/purpose-based comprehensive, long-term planners, and MANY MANY OTHERS which are so unique they defy classification.    
   Every AI Kit contains the entire GameMaker project, source  code (GML as well as C++ if external DLLs are utilized), applicable art and sound assets,  necessary DLLs, extensions, and any other resources, if required. Detailed documentation, both API and High-level, as well as tutorials, examples, and when necessary, theoretical explanations, are always included. 
   While some of these kits are specially designed from the outset as consumer products, targeted at designers, independent or collective, in need of high-quality, tried and tested, configurable, reusable solutions to problems both common and unusual in the field of Game AI & Autonomous Agent Design, the majority of them are actually repurposed, customized, and re-interfaced compositions of code which has actually been previously used with successful results in existing products.   But don’t worry, this doesn’t mean that you, the developer employing them will face any type of extensive editing and refactoring of code ripped directly from its native environment. On the contrary, each of our AI Kits have been carefully pored over to ensure complete context-neutrality, complete encapsulation in terms of variable scope as well as naming conventions, and then re-connected at both ends to easily-understood, highly-accessible public interfaces
   This means virtual plug-and-play integration from the developer’s perspective. All incoming signals pass through an input interface (which can of course be customized to your heart’s content), and all final actions terminate not in any execution of visible, game level events, but instead as signals to an actuation adapter interface, which stands as a middleman between our solution and your existing or developing application. Simply map signals to actions, and the AI will be operating seamlessly in your context.
  In addition to completely accessible code for the core AI operations, many kits also contain GUI-based Helper Apps (source is provided for these as well), which aid in tasks such as data population, graph/tree creation, ruleset creation, map/navgraph creation, etc.   Each of these tools has been tested and put through its paces in practical settings, ensuring optimal workflow.  We feel that many of them are truly invaluable to the time and resource-constrained developer (you) who needs every advantage they can get when it comes to expediting and simplifying their job in any way possible.
   But the best part of all of this is the PRICES we are offering these solutions for. You will be absolutely blown away by the numbers you see representing dollar amounts. You will question our typesetting and proofreading abilities, but we assure you, all decimal points are in the right places. The numbers which would ordinarily represent dollars and hundreds of dollars are indeed representing cents when it comes to these unique, high-quality products.
   WE GUARANTEE YOU WONT FIND ANYTHING LIKE THESE ANYWHERE ELSE!

 

Goal-Planning Agents – 2 Subtypes (dev doc)

************************************************************************************************************************
PLANNING AGENTS – 2 Types
************************************************************************************************************************

* Hypermetric Strategy Planner — uses aggregate-state disambiguator to find position on strategy-state flowchart every update and plans a path  from there to the “win” node. Looks ahead one node at a time, assigning node cost on the fly based on “state distance” (i.e. # of precondition variables and value differences between current state and state required for adjacent-node occupation), choosing lowest-cost path. All “goals” (in this case,  tasks, really) are atomic, and each is capable of changing the value of a precondition variable. “plans” are created just prior to each edge traversal (of the state-strategy graph), and comprise the tasks needed to set the bot’s state vars to values within a range acceptable to the destination node’s precondition set.

* Steady-State Goal Planner  — uses desirability scores for goal arbitration, calculated based upon current state variable values upon every update cycle execution.

    **** SLIGHT VARIANT: Heirarchical SSP

   An SSP which, while operating its “main loop” in a “steady state” (that is not changing major contexts on its own, the way the HSP does), but receiving the definition of this “steady state” as a message from a “commanding agent”, and capable of handling changes to this definition over the course of a game. (For instance, steady state could be “defend base”, “patrol area”, “attack player”, etc. — essentially a composite goal which stays in place until changed by the commander)

************************************************************************************************************************
UPDATE CYCLE SYNOPSIS / PSEUDOCODE:   [[HYPERMETRIC STRATEGY PLANNER]]
************************************************************************************************************************

On update{
  currNode = strategyStateDisambiguator->getNode()
  while (bot.currPathCnt < pathPlanner->getPathCnt(currNode, rootNode){
 bot.goalPaths[] = pathPlanner->getNextPath(currNode, rootNode)
 }
  if (bot.currPathCnt > 1){
 foreach (bot.goalPaths[] as currGoalPath){
  adjacentNode = currGoalPath->getAdjacentNode()
  bot.currLowestCost = 1;
  bot.currBestNode  = -1;
  foreach (adjacentNode.preconditions[] as currPrecondition){
   adjacentNode.cost += clampVal(0, 1, abs(currPrecondition.var.val – bot->getVarValue(currPrecondition.var)))
   if (adjacentNode.cost < bot.currLowestCost) {
    bot.currLowestCost = adjacentNode.cost;
    bot.currBestNode    = adjacentNode.id;
    }
   }
  foreach (bot.currBestNode.preconditions[] as currPrecondition){
   bot.taskStack->pop(bot->getTaskToSatisfy(currPrecondition))   
   }
  bot.stackStatus = incomplete
  altTask = -1;
  foreach (bot.taskStack as currTask){
   if (altTask > -1){
     currTask = altTask
     altTask = -1
    }
   currTask->activate()
   status = currTask->process()
   if (status == complete) currTask->terminate()
   if (status == failed) {
        altTask = bot->getAlternateTask(currTask, currTask.precondition)
        currTask->terminate()
                    }
   bot.stackStatus = status
   }
   return bot.stackStatus
  }
 } else {
  currPrecondition = bot->goalPaths[0]->getAdjacentNode()
  bot.taskStack->pop(bot->getTaskToSatisfy(currPrecondition))   
  bot.stackStatus = incomplete
  altTask = -1;
  foreach (bot.taskStack as currTask){
   if (altTask > -1){
     currTask = altTask
     altTask = -1
    }
   currTask->activate()
   status = currTask->process()
   if (status == complete) currTask->terminate()
   if (status == failed) {
        altTask = bot->getAlternateTask(currTask, currTask.precondition)
        currTask->terminate()
                    }
   bot.stackStatus = status
   }
   return bot.stackStatus
    }

 
} // end update
************************************************************************************************************************
UPDATE CYCLE SYNOPSIS / PSEUDOCODE:   [[STEADY-STATE GOAL PLANNER]]
************************************************************************************************************************

On update{
if (bot.goalStack = empty){
  currGoal = goalThink->getGoal
  } else {
     currGoal = bot.goalStack->topGoal
         while (currGoal.goalType = composite){
             currGoal = currGoal.subgoalStack->topGoal
            }
         }
     currGoal->activate()
     status = currGoal->process()
     if (status = complete) currGoal->terminate()   // which removes goal from stack
   return status   // return values of “failed” are handled appropriately by object calling this function (i.e. some form of replanning)
} // end update

VN:F [1.0.9_379]
Rating: 0.0/10 (0 votes cast)

Customizable “Plug-n-Play” Goal Planning Agent – Coming Soon

  We are in the process of developing a “plug-n-play” (meaning that it will work right out of the box with a bare minimum of setup & integration required from the developer using it) Goal Planning Agent, which is  highly customizable, extremely flexible, and completely reusable, since its architecture is designed to be completely context-neutral, with all input and output signals filtering through adapter interfaces, which are used to map all interactions between your existing or developing application context, and the agent itself.  Though this technically is what can be described as a “black box” architecture (wherein the workings of the module, in this case, the Goal Planning Agent, are completely internalized and segregated from the rest of the application, and accessible only through its public interfaces), this does not in any way rule out tinkering on the part of the developer/user.
  This agent will be available in our new AI Kit Library, and like all others, will come with the complete source code, GameMaker project files, and all assets required for re-compilation. If you own it, you can modify it as extensively as you need to or wish to.
  But even if you aren’t highly-versed in GML, or programming at all, you will still be able to customize this agent to function in virtually any context, since all of its goal structures, behavior mappings, and arbitration functions are not hard-coded, but instead contained in easily-readable and editable .INI files.
  And if that is still not easy enough, don’t worry, because this Goal Planning Agent Solution comes with a complete toolchain of GUI-based Helper Apps, which allow the developer/user to edit every aspect of the agent’s behavior graphically, in easy-to-understand node-based tree / graph form. If you can draw a flowchart or dependency tree (you can), you can configure this agent to behave exactly how you want it to, and map its behaviors to actions, behaviors, or functions within your existing or developing application, as well as to ones which have yet to be defined. Remember, all input and output signals to and from the agent pass through special adapter interfaces, ensuring that the agent can function flawlessly within any context. It will never be dependent on any application elements outside of its own scope, which means that changes to other parts of your program will never affect the operation of the agent. You could make changes so extensive that the outward appearance of your game could go from an underwater submarine simulation to a medieval jousting tournament, and the agent will continue to function perfectly. The only changes you’d ever have to make would be to the interface maps.
   If you wish to harness the powerful advantages of Goal-Planning Agent architecture for your next or current project, and don’t relish the thought of extensive refactoring of both your code as well as whatever agent solution you choose, if you need extreme flexibility of form and function, if you need an inexpensive solution which you will find yourself reusing again and again, perhaps in every subsequent project requiring this type of AI, if you would rather build robust, complex goal heirarchies which use extremely sensitive, accurate, and context-appropriate arbitration methods using GUI TOOLS insteadof spending endless hours coding monotonous and confusing lists of element definitions and dependencies…
   THIS IS YOUR DREAM SOLUTION!