We would like to announce that we are now officially testing Alpha Gamma Theta. We do no know when this engine will be ready, Expect more news soon.

KryogenTech is now working on a physics engine for DarkBASIC that will create realistic collsion effects and force effects. The biggest feature, however, is the creation of destructible environments. What we mean is, that we are creating a physics engine that will allow you to destroy buildings almost completely. This physics engine will be offered as a download on the Kryotech website, expected to go up soon. The name of this physics engine is Alpha Gamma Theta. This engine is expected to be created soon. This will be the first in a series of physics engines based on the same idea.

So far, we have found one thing that may be a problem to some people. DarkBASIC cannot run multiple functions that have loops in them in a loop at once. While it is definitely possible to get around this obstruction, but it is something to keep in mind when it comes to designing AI or physics in DarkBASIC. Functions that do not have loops in them can be run together in a loop. One thing that one must remember while designing AI is that it will come to the same conclusion every time it runs in DarkBASIC unless something has somehow drastically changed within a few seconds. If you are using a do loop command in your AI, there is no need to loop the entire sequence over and over again. If you are using a for next loop, there is a great, non looping, alternative to it. As for loops like the repeat until loop and the while endwhile loop, you will have to find ways to substitute those particular sequences of code with something that will not be a loop of any type. If all loops can be removed from the AI function, then multiple AI's and other types of non looping commands can be run together in one main game loop. A game in DarkBASIC, and most other game design softwares, will look like this in short:


InitGame(<parameters>)

MainGame(<parameters>)

EndGame(<parameters>)

This model may need to be modified depending on what your independent games require, and as for multiple levels, it is hard to say as of now how that will work in a game made in DarkBASIC, yet it is, once again, definitely possible, as many people have created multi level games using DarkBASIC.

Although the actual AI itself has not seen any action so far, we tested a component of it and it turns out that there is a major flaw in it and the AI must be edited in order for it to work. In fact, we did get one test going, but there was an error we still have to fix. Although this is somewhat of a setback, the reason for the testing is to reveal any flaws before the AI is actually even used in action. The AI is still there, it’s just that we need to fix it a little more.

Our first test on the tactical AI component have started. Although there is nothing to report as of yet, in some time there will be. Technically, the first test failed to initialize, so we have nothing to report. Keep checking for updates.

KryogenTech is proud to announce that the first AI component, in a series of three components has been completed. The first test for this component will take place all thoughout this weekend. This is the tactical AI component, and it is the first AI to ever be completed by KryogenTech. This is to be a part of a main AI, which will link three other AI components together to form the main AI. The components are tactical AI, dig in and defend AI, and retreat AI. The first AI is the most agressive of the AI’s, as it moves foward to make gains on the enemy’s position and tries to eleminate him. The dig in and dfend AI is an AI that digs in and defends its current positions for as long as possible. The last part of the AI retreats while covering its flank. There are two versions of this AI. One is the single retreat, where one object has too low health and the others cover his retreat. The other is the complete squad retreating, where their is either not enough squad members or the swarm AI orders it. This brings us to the swarm AI component, which has not been made yet. The swarm AI mangages swarms of units and decides what needs to be where. This is basically the final authority over the individual and squad AI’s. There can be small or big swarm AI’s or there can even be swarn AI’s managing swarm AI’s. Although that would be something that most computers would not be able to handle, it still is an interesting topic. This weekend, testing will begin on the tactical AI component, and the test results will be here on this blog by either next week, or the week after.

We’ve talked quite a bit about DarkBASIC. But what is it? It is a software that was created off of BASIC. If you know what BASIC is, and you know the language, then you know that BASIC is, well, a basic to learn language. BASIC is meant to be easy to learn. It wasn’t meant for game design, but The Game Creators adapted it and came up with DarkBASIC. The software doesn’t use actual object orientation, but a hidden form of it. Instead of having classes, there is numbers that denote each object. There doesn’t seem to be actual methods, but there is functions and all. This is a language that is more or less simliar to BASIC itself. Obviously it would be, for it is based off of BASIC. The language is a good one, and the commands are easy to learn. It can be hard to get the hang of, but when you do, you can use it to some great effect. For people who are used to using OO programming, this isn’t OO, so be ready to change that. Otherwise, it has some great aspects to it. It’s very easy to manipulate objects and load objects with animations. This is a software that can be used professionally.

We’ve been talking a lot about what makes a good AI. But how does one actually make a good AI? Of course, we just started, so we’re still working on the AI, but we do have some things down. One of these functions is line of sight. While line of sight isn’t really an AI function, it does make the AI seem more realistic. Line of sight tells us whether or not an object is visible to the object itself. While an AI can be made without this function, the AI will seem cheap for it can see through cover that the player can’t. This is the code:

type 3dobject

object as integer

x as integer

y as integer

z as integer

endtype

function lineofsight(current as integer, start as integer, ending as integer, object2 as integer)

dim coverobjects(ending-start) as 3dobject

for n=start to ending

coverobjects(n).x=object position x(n)

coverobjects(n).y=object position y(n)

coverobjects(n).z=object position z(n)

coverobjects(n).object=n

next n

returnValue as integer

for n=start to ending

if distancex(object position x(current), object position x(object2))>=distancex(object position x(n), object position x(object2))

if distancez(object position z(current), object position z(object2))>=distancez(object position z(n), object position z(object2))

returnValue=1

endif

endif

if returnValue<>1

returnValue=0

endif

endfunction

function distancex(x a integer, x2 as integer)

returnValue as integer=x-x2

endfunction(returnValue)

function distancez(z as integer, z2 as integer)

returnValues as integer=z=z2

endfunction(returnValues)

The main function here is the line of sight function, and the rest of the functions are just their to help create the main function by measuring distance. Their will be more to come.

Ever since Alice 2.0 research was suspened by our parent organization, Kryotech, many of us wondered what were the problems with the software? Although Kryotech did talk about the problems, we have analyzed the software, and have come up with a conclusion. The best things about Alice 2.0 is that it is very simple to use. It is the easiest object oriented software to use. Best of all, it’s completely free. Creating things with Alice are relatively easy. Using the interface is simple, and adding objects is super easy. So what are the problems. The problems are that this software is just not polished at all. It is impossible to create large worlds and be able to keep them. A world with too many variables will just crash the software and you will lose all of your work. So using this software for game developement is a bad idea. Why? because it is impossible for a game designer to have all the variables and objects he needs without either slowing down, or possibly crashing the game and the software. Creating smarter AI is just a matter of pushing at it until another breakthrough comes through. But that doesn’t get rid of the inherent problems that Alice has. So overall, Alice can and should be used to introduce people to the concept of programming but not anything else.

As far as we are concerned, making such an AI is not impossible. DarkBASIC is meant for beginners, but it does have power. It can be used professionally to develop professional style games. Although games in DarkBASIC actually take longer than in what Kryotech previously used, Alice 2.0, they results are by far more satisfying. Are we developing such an AI? Not currently. Currently, we are creating our first base AI. Details have yet to be released. Keep checking for updates.