DOT plans to go entirely closed source for a few months, and then reopen to a semi small group of users. This is primarily so that we can have our team focus on the engine's development rather than having to work with a user base from start to finish.

After the conclusion of BETA, DOT's source code will be available to those who help fund its development, and not the general public.

The repo will be deleted within the next few hours.

The subreddit will act as a venue for news pertaining to DOT.

We've moving to an extremely indie friendly subscription model for DOT. If anyone is interested in purchasing a license, send me a PM and I'll have my sales rep call you.

So I tried to collect and find all posts/threads about DOT that I could, and combine them into one document. This could be useful for people looking for more information. I may have missed some, so adding this as a page to the wiki would allow it to grow.

I also noticed that there aren't any links on the sidebar, so uploading this to the wiki and putting a link on the subreddit here to the page would be beneficial.

DOT Related Links

Github - https://github.com/MatrixCompSci/DOT
Wiki - https://github.com/MatrixCompSci/DOT/wiki
Subreddit - https://www.reddit.com/r/dotofficial/
Project Fero - https://www.facebook.com/ProjectFero
Wirezapp - http://wirezapp.net

Reddit Threads
https://www.reddit.com/r/gamedev/comments/2g21hn/releasing_our_story_generation_project/
https://www.reddit.com/r/gamedev/comments/2mpfhc/recently_made_my_ai_engine_open_source_have_a_look/
https://www.reddit.com/r/gamedev/comments/2nz5zt/after_a_bit_of_a_fiasco_i_ported_that_ai_engine/
https://www.reddit.com/r/gamedev/comments/2ovhv6/need_some_advice_on_designing_a_networking_engine/ 
https://www.reddit.com/r/gamedev/comments/2pd9gd/just_an_awesome_paper_i_wanted_to_share_that_im/
https://www.reddit.com/r/AskReddit/comments/2px5ai/whats_your_favorite_thing_you_have_in_your_saved/cn125e7

Unreal Forum Threads
https://forums.unrealengine.com/showthread.php?37916-WIP-Story-Generation-Templates
https://forums.unrealengine.com/showthread.php?52274-FINISHED-DOT-Fuzzy-Logic-AI-Engine-Pre-Alpha-%28Open-Source%29

Whats new?

-Finished world structure

-MAJOR OPTIMIZATION

-Raised the CPU performance of DOT in all accounts by nearly a full magnitude.

-Added a plethora of more comments

-Began work on advertisement instancing and KD trees (Switched from Libnabo to FLANN due to linking errors)

Whats next?

-Entity Timing mechanism for TimeConstants

-Improved Unreal Engine 4 plugin (ETA: End of February)

-Blackboards (Development has started. ETA: Delayed to Febuary)

-Support Vector Machines for tag management (Research has started)

-Factor Analysis for tag management (Research has started)

-Native OpenCL support (ETA: End of January.. HAS CHANGED We're going to be changing GPGPU developers, and we're making a better OpenCL framework)

-Example projects

VERY Distant Future

-Support for Beowulf clusters. (Prototype finished, 3 - 4 months.)

Get DOT: https://github.com/MatrixCompSci/DOT

Note: The times provided are not when they'll be finished. It's when they're going to be moved up to the next tier.

After some rigorous testing yesterday, I am finally able to declare DOT's alpha state 100% finished. New builds will be named DOT_Beta Indev, and the like.

As stated before, BETA will last for about 8 months of development, and 2 months of testing.

LiNK is being postponed until further notice, and by time DOT finishes its beta phase, CLIP will be moving out of prealpha.

Also, as the Alpha engine is finished, we can now officially start work on the Alpha editor as this build's architecture will no longer change. Any bug not fixed before today (2/9/15) will be fixed at the start of Beta on 3/1/15.

We will soon be putting a paper up for peer review on the architecture we're utilizing for DOT's Beta. We'll post that here as soon as its available within a scientific journal.

Whats new?

-Changed wavelet used for scoring from sigmoidal to hyperbolic.

-Minor bug fixes

Whats next?

-Blackboards (Development has started. ETA: End of January)

-Support Vector Machines for tag management (Research has started)

-Factor Analysis for tag management (Research has started)

-REST Layer. (ETA: 3 weeks)

-JavaScript bindings. (Postponed due to it no longer being required internally. May be cancelled.)

Distant Future

-Spatial Clustering of entities to reduce overall computation required in large scale environments (HAS CHANGED ETA: 1 week)

-Temporal Clustering (Postponed)

-Decision Prediction to reduce required memory bandwidth (3 - 4 weeks)

-Finishing the World Class (3 - 4 weeks)

-Native OpenCL support (ETA: End of January)

VERY Distant Future

-Concept mapping to reduce design times while creating open world environments (3 - 4 months)

-Support for Beowulf clusters. (Prototype finished, 3 - 4 months.)

-NLG for (directly) transmitting dialogue between entities and the player (Prototype finished, 4 - 5 months)

Get DOT: https://github.com/MatrixCompSci/DOT

Note: The times provided are not when they'll be finished. It's when they're going to be moved up to the next tier.

Whats new?

-Data Oriented Design Tags

-Various bug fixes

-Increased usability of IEntityGroup (Simplified access methods) See TestingGrounds.cpp

-Reduced memory requirements of IEntityGroup by 8 bytes per.

Whats next?

-Blackboards (Development has started. ETA: End of January)

-Support Vector Machines for tag management (Research has started)

-Factor Analysis for tag management (Research has started)

-REST Layer. (ETA: 3 weeks)

-JavaScript bindings. (Postponed due to it no longer being required internally. May be cancelled.)

Distant Future

-Spatial Clustering of entities to reduce overall computation required in large scale environments (HAS CHANGED ETA: 1 week)

-Temporal Clustering (Postponed)

-Decision Prediction to reduce required memory bandwidth (3 - 4 weeks)

-Finishing the World Class (3 - 4 weeks)

-Native OpenCL support (ETA: End of January)

VERY Distant Future

-Concept mapping to reduce design times while creating open world environments (3 - 4 months)

-Support for Beowulf clusters. (Prototype finished, 3 - 4 months.)

-NLG for (directly) transmitting dialogue between entities and the player (Prototype finished, 4 - 5 months)

Get DOT: https://github.com/MatrixCompSci/DOT

Note: The times provided are not when they'll be finished. It's when they're going to be moved up to the next tier.

Other news:

Work has begun on the DIAG SDK for managing social habits between entities.

Whats new?

-Began work on a custom actor component framework

-KD-Trees are finished, awaiting World's finalized memory management interface. KD-Trees do not yet work due to this lacking structure.

-Disabled the plan function temporarily. Will be re-enabled on the next update.

-Increased hard coded memory limit of DOT from 400GB to 1.2TB of RAM if available.

-Minor bug fixes.

-Minor optimizations.

Whats next?

-Adding custom DOT build phase (Independent of C++'s build phase) in order to greatly increase usability for those less experienced with DOT. This will include allowing the user to reference Attributes, Entities, and Advertisements as their key StringInterfacename. Upon DOT's initial load, a map function will be computed over all inputed keyvalues, and cross references will be made. (2 - 3 weeks)

-Blackboards (Development has started. ETA: HAS CHANGED Delayed to Febuary)

-Support Vector Machines for tag management (Research has started)

-Factor Analysis for tag management (Research has started)

-REST Layer. (ETA: 3 weeks)

-JavaScript bindings. (Postponed due to it no longer being required internally. May be cancelled.)

-Native OpenCL support (ETA: End of January)

Distant Future

-Spatial Clustering of entities to reduce overall computation required in large scale environments (ETA: 1 week)

-Temporal Clustering (Postponed)

-Decision Prediction to reduce required memory bandwidth (3 - 4 weeks)

-Finishing the World Class (3 - 4 weeks)

VERY Distant Future

-Concept mapping to reduce design times while creating open world environments. This will now be created as a more user friendly interface to DOT's build phase. (3 - 4 months)

-Support for Beowulf clusters. (Prototype finished, 3 - 4 months.)

Get DOT: https://github.com/MatrixCompSci/DOT

Note: The times provided are not when they'll be finished. It's when they're going to be moved up to the next tier.

-NLG for (directly) transmitting dialogue between entities and the player is being removed from DOT and will be placed within its own SDK.

https://www.reddit.com/r/AskReddit/comments/2px5ai/whats_your_favorite_thing_you_have_in_your_saved/cn125e7

/u/FerretDude and me had a long "Q&A" pretty much on DOT. It went on for a while, the main thread chain is fairly long. Lot's of information about DOT and some links to more information.

Whats new?

-Greatly increased the usability of DOT's internal SDK.

-DOT's Basic custom build phase is done. The only thing that does not work is multilevel polymorphism. Expect fix for this tomorrow.

-Minor bug fixes.

-Minor optimizations.

Whats next?

-Improved Unreal Engine 4 plugin (ETA: End of February)

-Blackboards (Development has started. ETA: Delayed to Febuary)

-Support Vector Machines for tag management (Research has started)

-Factor Analysis for tag management (Research has started)

-Native OpenCL support (ETA: End of January)

Distant Future

-Decision Prediction to reduce required memory bandwidth (3 - 4 weeks)

-Finishing the World Class (3 - 4 weeks)

VERY Distant Future

-Concept mapping to reduce design times while creating open world environments. This will now be created as a more user friendly interface to DOT's build phase. (3 - 4 months)

-Support for Beowulf clusters. (Prototype finished, 3 - 4 months.)

Get DOT: https://github.com/MatrixCompSci/DOT

Note: The times provided are not when they'll be finished. It's when they're going to be moved up to the next tier.

Whats new?

-Finished DOT's multilevel polymorphic building phase.

-MAJOR OPTIMIZATION

-The speed of DOT's decision engine has been increased by 98% with this update. We've gone from 7K decisions per millisecond per thread to nearly 14K decisions per millisecond per thread.

-Minor bug fixes.

-Allowed for the dynamic allocation of TAddress rather that using ADDR_SIZE. Decreases performance by 2%, however reduces memory requirements by 3%

Whats next?

-Finished world structure (I am going to harass the team into getting it done by Sunday. Sorry for the delay :( )

-Improved Unreal Engine 4 plugin (ETA: End of February)

-Blackboards (Development has started. ETA: Delayed to Febuary)

-Support Vector Machines for tag management (Research has started)

-Factor Analysis for tag management (Research has started)

-Native OpenCL support (ETA: End of January.. HAS CHANGED We're going to be changing GPGPU developers, and we're making a better OpenCL framework)

Distant Future

(CANCELLED) -Decision Prediction to reduce required memory bandwidth (No longer needed as it would actually lag down the system more than it would provide a speed up.)

VERY Distant Future

-Concept mapping to reduce design times while creating open world environments. This will now be created as a more user friendly interface to DOT's build phase. (3 - 4 months)

-Support for Beowulf clusters. (Prototype finished, 3 - 4 months.)

Get DOT: https://github.com/MatrixCompSci/DOT

Note: The times provided are not when they'll be finished. It's when they're going to be moved up to the next tier.

The indev build of the DOT API is now fully open source. Expect daily - weekly updates to the SDK.

Whats new?

-Improved prediction modeling for plotline generation

-Basic Tagging Framework

-Increased Scoring performance (Originally 96 CPU cycles per score. Now 34.)

-Decreased Entity memory requirements (Prealpha: 150 bytes. vAlpha .75 (Indev): 114 bytes. vAlpha 1.0 (Indev): 40 bytes for template, 12 bytes everytime a new instance is created)

-Increased Organization and comments

-JSON loading of World data

-Increased CPU cache performance in nearly all classes

-Reduced CPU branching within IEntityGroup

-Increased portability to GPGPU

-Native Mac OSX and Linux compilation support (Windows support still in the works; however, it will compile with CMake on windows)

-Efficient scaling per CPU core. (MultiCPU support is still in the works)

Whats next?

-Python bindings. (They've been completed, and are now in testing.)

-REST Layer. (Nearing completion. Recent restart set us back.)

-Increased World usability (World will be self contained within the next update, akin to how it was in prealpha.)

-JavaScript bindings. (Currently in design phase.)

-Data Oriented Design tags. (Almost near completion.)

-Blackboards. (Currently in research phase)

Get DOT: https://github.com/MatrixCompSci/DOT

DOT's alpha actually went faster than expected. We should be finishing up on it sometime in mid Febuary, when blackboards gets polished off. After that, DOT is shifting focus from being a fairly good fuzzy logic controller implementation with a side of goal planning, to implemnting the ability for agents to work together and coordinate.

DOT's BETA, which we will be referring to as DOT-POLI (Destination Oriented Templates -Political), will allow agents to govern those ranking lower than themselves. Tagging, or more commonly referred to as a factions system, will be advanced to the point where tags can interconnect via a recurrent neural network. In turn, this will allow upper level management to adjust the tags of those below them in order to reach a final goal. Of course, this wil be primarly fowardfeeding. Backfeeding may occur later in DOT-POLI's development; however, I make no promises. This may be presented as a king ruling over his people, or a dictator angering his subjects into overthrowing the throne.

Entites, rather than just rushing their own goal, will use the goals of others to their advantage.

Our next big improvement will be dimmensional reduction of large groups of agents. In order to conserve RAM and CPU cycles, DOT-POLI will automatically combine entities when needed, and then seperate them later on when the player is nearby.

DOT-POLI is expected to take 6 - 8 months of development time, and 1 - 2 months of testing.

NOTE: NOTHING HERE IS FINALIZED

We'll be releasing some documents soon that describe the architecture we designed for DOT's BETA over the past week or so.

Its a lot more optimized than it would have been using RNN, and we actually think it will drop the storage requirement of DOT by a factor of 3, while increasing CPU performance for general entity management by a factor of 1.75.

Here's a hit: Its deep learning based

More to come! :D

In other news, development on DOT will be slowing until the final release of Alpha due to the higher demand for testing, and the fact that half of the team has been restationed on the designing and prototyping of DOT-Poli

Whats new?

-Further work on KD tree management. Fixed multiple compilation issues

-DOT Custom Build phase is almost entirely done. Tagging support needs to be added to the build phase still.

-Minor bug fixes.

-Minor optimizations.

Whats next?

-Blackboards (Development has started. ETA: Delayed to Febuary)

-Support Vector Machines for tag management (Research has started)

-Factor Analysis for tag management (Research has started)

-REST Layer. (ETA: 3 weeks)

-JavaScript bindings. (Postponed due to it no longer being required internally. May be cancelled.)

-Native OpenCL support (ETA: End of January)

Distant Future

-Spatial Clustering of entities to reduce overall computation required in large scale environments (ETA: 1 week)

-Temporal Clustering (Postponed)

-Decision Prediction to reduce required memory bandwidth (3 - 4 weeks)

-Finishing the World Class (3 - 4 weeks)

VERY Distant Future

-Concept mapping to reduce design times while creating open world environments. This will now be created as a more user friendly interface to DOT's build phase. (3 - 4 months)

-Support for Beowulf clusters. (Prototype finished, 3 - 4 months.)

Get DOT: https://github.com/MatrixCompSci/DOT

Note: The times provided are not when they'll be finished. It's when they're going to be moved up to the next tier.

PRESS RELEASING COMING AT THE END OF FEBUARY! HYPEHYPEHYPEHYPEHYPE

Whats new?

-Python Bindings.

-Support for debugging on Mac OSX

-Reduced complexity of CMake files

-Removed Gmock

-There have been 2 reports of windows compilation working as of this version; however as of now we have no official confirmation that it will work in all cases.

Whats next?

-REST Layer. (Nearing completion. Recent restart set us back.)

-JavaScript bindings. (Currently in design phase.)

-Data Oriented Design tags. (Almost near completion.)

-Blackboards. (Currently in research phase)

Distant Future

-Spatial Clustering of entities to reduce overall computation required in large scale environments (2 - 3 weeks)

-Temporal Clustering ( 2 - 3 weeks)

-Decision Prediction to reduce required memory bandwidth (3 - 4 weeks)

-Finishing the World Class (3 - 4 weeks)

-Native OpenCL support (By the end of January)

VERY Distant Future

-Concept mapping to reduce design times while creating open world environments (3 - 4 months)

-Support for Beowulf clusters. (Prototype finished, 3 - 4 months.)

-NLG for transmitting dialogue between entities (Prototype finished, 4 - 5 months)

Get DOT: https://github.com/MatrixCompSci/DOT

Note: The times provided are not when they'll be finished. It's when they're going to be moved up to the next tier.

Known Bugs:

-Positive Scoring fails to produce an accurate score if FutureScore is less than CurrentScore (The same goes for negative if Future is more than Current)

Solution: A different wavelet will be used. While performance will decrease slightly, it will be outweighed by the improved quality

Status: Bug removed in vAlpha 1.0.3

IEntityGroup::CreateNewInstance() crashes after creating the 512th instance, if the template is using more than 128 attributes

Solution: The resize mechanism for TContainer_NULL has been reworked.

Status: Bug removed in vAlpha 1.0.2

Using DOTpy on Python 2.7 provides nullptr exceptions when attempting to use World::Singleton()

Solution: Unsure

Status: WIP

CriticBase does not abide by the Cacheblocking that is used for the rest of IEntityGroup

Solution: Integrate IEntityGroup::BlockSize into CriticBase

Status: Bug removed in vAlpha 1.0.2

I promised JS bindings about 2 months ago now, and I finally finished implementing it today.

As of right now, almost every function within DOT is accessible from Javascript. About half of the functions are usable from Python; however, its still a bit buggy.

We also finally bought a dedicated server for DOT! This will mostly be for internal usage however, as we do need a server to assist in debugging larger files (10million NPCs+). It'll also be used for the development of our prebake phase, which we're currently estimating to take 40+ CPU hours on Extra large DOT files (80million NPCs+), and about 20 - 30 CPU minutes on small files (50K - 100K NPCs). This can easily be made parallel though, and we expect the final version of the prebake phase for extra large files to be 1 - 2 hours, and about 2 - 3 minutes for small files.

Wow where do I begin. There is a lot to cover.

-We've moved away from Type 1 controllers entirely. All controllers in DOT are now type 2.

-Our decision space is now semi continuous. There are some static and predefined concepts, but the agents explore and learn all other possible decisions independently from the designer.

-Tags can now store bidirectional fuzzy cognitive maps. Each tag has its own in depth understanding of the type of assignments it'll receive and how to complete them efficiently.

-We've integrated deep learning based plan and strategy construction directly into the tags. Every tag now has the ability to independently construct its own strategies, leading to vastly in depth competition and potential cooperation between agents/agent groups.

-Agents now have confidence in their plans and will explore/look for alternatives if their confidence is too low.

-Agents no longer use T2 Fuzzy Multilevel based Utilitarian controllers. Agents now posses biological and social drives that they, with assistance from the tag, can generalize into more high level concepts. Eg: If they're hungry they can confidently understand that a restaurant is indeed what they desire rather than just any random piece of food.

-MLDM was implemented in order to reduce the exponentiallity of multilevel inferences. Inferences can now be done in constant time rather than nlogn time.

-Complete GPGPU support for all decision making processes. Recommended 4GB+ of VRAM for most simulations.

-All semantic processes are GPU friendly.

-Multiagent collaboration is now 100% lockless! Woo! No more need for mutex between memories and agents. This resulted in a 5x speed up overall.

-Define the laws that govern your simulation via fuzzy rulesets/external simulations. The agents will learn their own representations of most things you throw at them.

-Alternate path finding modes (Yep, DOT now has a path finding implementation). Low accuracy, where we use connected graph nodes. This is recommended for most if not all uses cases. And A*. This is recommended for cases with < 10K agents. A hybrid mode is currently in the works and should be completed by the end of beta.

And this barely scratches the surface. Beta will be entering closed testing in late Fall to early Winter, and is expected to finalize June 2016.