PlayBasic

Hey Shaun

Are you looking to make a 3D game? Do you have any experience?

Hi, everybody.
My name's Shaun and I was introduced to this Wiki/Forum by my Fiance. She knows I've had an idea(s) for many years and happened upon this site. I've always wanted to create an RPG or Action RPG of epic proportion and have had many ideas with regards to it. I've tried the RPG Maker series and, simply put, it doesn't do what I want it to do.

The thing I want to get started with, and this would just be to experiment on, is boss fights. I like the way the more complicated boss fights like Kingdom Hearts II and World of Warcraft play through. You have to be in certain locations at certain times to dodge projectiles or avoid a blast or hit the boss in a certain location. I find a lot of games are just too simple with this regard (Beat on boss till dead sorta thing).

I know the boss fights don't make a game, but to start with my first attempt, they will. lol

Anyway that's my Spiel for now.

~Shaun

PlayBasicFX V1.76 _Retail Upgrade_ is Now Available

This release upgrades (transforms) the existing PB1.63m to PB1.64c retail releases or the PBFX1.7x releases into the current [b]WIP version[/b] of PlayBasicFX V1.76 Therefore prior to installing this, you'll need at some retail version of PB previously installed !

This is this next step in the long migration of a PB project into the PBFX world. Ironically, while PBFX is the successor of PB, it's slowly got behind in terms of various compiler features added to V1.64 editions of PB. So this edition implements all of those features such as, optional parameters, passing UDT types in/outs of functions/spub, returning arrays from functions, loads of new math short operators such as (++, —, +=, -=, *=,/=, &=,~=, |=) , dynamic function calling (CallFunction) and various others tidbits..

Have fun !

For more information about PlayBASIC, please visit the home page and download the free learning version and dive in.

Url: www.PlayBasic.com

Download

See Announcement for Download

YAAC (Yet Another Asteroids Clone)
Fairly simple asteroids demo with various special effects applied, such as Blur-O-Vision and particles

Spooky Shadows

2D lighting and shadows tech demo. This one makes use the PlayBasics world and ray intersection features to model light. This is then rendered as lightmap and merged with the background.

Parallax Platformer Tech Demo

This is updated version of the standard 2D platform game that comes with PlayBasic. Except this version has a number special effects jammed into it, just to test everything out all at once :)

All Music By: http://www.ardvarc.net/

You can only make executables with the paid for version of PB.
- Peepshow

Sorry for replying so late, i have been so busy lately…

My favorite hartnell has to be galaga… it was so addictive

B.T.W. do you know if it is possible to create executables from our games?
I find no information on this, so i guess not? Or is it possible with another program?

thanks

PlayBASIC V1.64 K BETA ROUND up #9 to Beta #20

** PlayBASIC V1.64 K BETA #7**

This beta focuses on a number stack opt's in the runtime.

PlayBASIC V1.64 K BETA #9

This adds the new auto assignment casting between Integers/Floats and pointers, as well as it includes some (VERY) limited Array operator support. See example

PlayBASIC V1.64 K BETA #10

This beta adds the ability to declare and return locally allocated UDT pointers from functions..

Read Here about usage

PlayBASIC V1.64 K BETA #12c

This beta adds the ability to pass individual UDT's into functions (as well as the original array containers) as well as the ability to pass locally declared Integer Arrays out of functions. So you can create an array inside a function then export it it's handle. To access the array you either need to assign the handle to an existing array, or create a redirection array so you access the data.

Passing UDT's to Functions

Returning Local Arrays from Functions

PlayBASIC V1.64 K BETA #13

This beta adds the ability to return typed arrays/variables & list containers from functions.

Returning Typed Arrays & Lists from Functions

PlayBASIC V1.64 K BETA #14

This beta corrects from bugs found in beta 13 plus adds support for post fixes on user functions and bound functions.

Read More About Beta 14

PlayBASIC V1.64 K BETA #16

This beta adds support for (import/export) pointer and buffer operations into PSub.

Read more about POinters/Buffers And Psubs

PlayBASIC V1.64 K BETA #17

PlayBasic V1.64k17 is the latest beta of PBV1.64 retail update. This beta corrects some issues found in beta #16 with Array passing into PSUB's

Read about Here

PlayBASIC V1.64 K BETA #19

This beta adds the [b]CallFunction[/b] operator. This features allows the user to dynamically call user defined functions/psubs and linked dll functions by Name. While the call can pass parameters (basic types only such as Integers,Floats and String), the operation can't handle returning data from the called function at this time.

What does CallFunction give you, it gives you the ability write routines that have call backs (ie emulated function pointer ) styled behavior

Read about Here

PlayBASIC V1.64 K BETA #20

With this beta we're finally about to bring some support for optional parameters in internally bound functions and commands. Not every command or function has optional support, in fact at the moment only a hand full do (List in history). Most of which relate to switch styled parameters. A flag to return something on/off in the command.

What optional parameter supports does, is it lets the programmer use the commands 'default' parameters for a particular operation. So each command/function that supports optional, gives the optional parameters a default value. You can't change these, they're built in. These defaults will hopefully be the most commonly used settings though. So they're a sort cut.

Now those with very long memories, will remember some of the initial PB design discussions. Where we asked various communities about how the PlayBASIC commands names/ basic features should be set out. Surprisingly, optional parameters wasn't something that was seen as a bonus. I think the reason for is, was that it can actually make code more cryptic. As functions seems to pull their operational state from thin air. For example, if a user sees a function being used with 3 parameters say, then elsewhere they see it with 4, or 5 even. This will no doubt case one of those WTF moments, and hence is one the initial reasons why it was demoted to the PB V2.00 design document..

Read More about the new features in the beta at the links bellow.

FUnction Index & Function Exist

Optional Parameters In Commands

Optional Parameters In Functions

Download

See Beta Announcements For Latest Download

WIP Thread

Follow the WIP beta gallery thread in the show case

PlayBASIC V1.64 K BETA #6

This beta brings a more compiler level changes, some Runtime speeds up and a few bugs fixes from the previous beta.

In this beta the math short cuts have been extended further, both in what they can be applied to (should support all data types) and the a few new operators, namely AND (&=), OR (|=), XOR (~=) operators

Other changes revolve around the priority of certain opcodes (low level stack + pointers) within the VM1 instruction set. The latter gives a nice speed boost to accessing array fields in user defined types. In fact all pointer operations should be faster, but don't get too excited though we're probably only talking 10->15% real world speed improvement on those operations. Of course, if you don't really use pointers, then this is unlikely to make any great impact in your programs.

The last changes have been to the stack opcodes. While the changes thus far are fairly minor really, even so, the clean up should help with programs that use a lot of function calls. In some test programs the changes we're producing a handy 12% speed up, but In real world code, I doubt we'll see that. Perhaps 5%. But a saving is a saving..

**PlayBASIC V1.64 K BETA TESTING ROUND UP **

--PlayBASIC V1.64 K BETA #4 (Retail Compiler Only Beta) - (Avail for Registered Users ONLY)--

This beta brings a few new compiler level changes to PB, namely math short support and Byte & Word field support in User Defined Types.

Math Short cuts are another idea borrowed from C. The syntax is basically the same, expect PB only supports these operations in Assignments, while in C you can apply them anywhere, which is handy in C, not so much in BASIC.

What are they ? - Well they're simply a way of short cutting math operations being performed upon the same variable or array.

For example, in older versions of PB, if you have a variable SCORE and wish to add 100 to it, they you'd either type Score=Score + 100 or use the INC operator. Eg INC score,100 (Note: Only available in older editions of PB V1.64)

Now in V1.64K we have the following short cut operators.

++ ; Increase by one. This is the equivalent of the INC operator. Except you can use these on arrays/ type fields
— ; decrease by one. This are the equivalent of the DEC operator. Except you can use these on arrays/ type fields

+= ; Add right value to left. Eg Score += 100 , is the same as Score = Score +100
-= ; Subtract right value from left. Eg Score -= 100 , is the same as Score = Score -100
*= ; Multiply right value by left. Eg Score *= 100 , is the same as Score = Score *100
/= ; Divide right value by left. Eg Score /= 100 , is the same as Score = Score /100

So really these additions just allow us to shorten some long expressions. These operators can be used on most data types and structures within PB. Including Integers, Floats, Strings, Arrays, Pointer writes (limited support) and even User Defined Users. However Array Field elements in User defined types are not currently supported.

Dim Table(2000)

        Table(110)+=1000
        Table(110)-=2222 

        print Table(110)

        Dim Table#(1000)
        Table#(10)=1000

        Table#(10)/=50
        print Table#(10)

        Dim Table$(200)
        Table$(10)="Yeah"

        Table$(10)+="Dude"
        print Table$(10)

        a$="Cool"
        print a$

        c$="DUDEDDD"
        b$="YESAH"
        A$=C$+b$
        print a$

        a$++
        print a$

        Type Test
                Aaa
                X
                Y#
                z$
        EndType

        Dim Dude as test

        Dude.x +=100
        Dude.x +=100
        Dude.x +=100
        Print Dude.x        

        Dude.y +=200
        Dude.y +=200
        Print Dude.y        

        Dude.z +="aaa"
        Dude.z +="bbb"
        Print Dude.z        

        Dim Qrr(10,5) as test
        print "Typed Array"

        Qrr(10,5).x =45

        Qrr(10,5).x +=100
        Qrr(10,5).x +=100
        Qrr(10,5).x +=100
        Print Qrr(10,5).x

        Dim You2 as integer pointer

        Dim You as integer pointer
        Bank=NewBank(1000)
        addr=GetBankPtr(Bank)
        You= addr

        *You = 45
        *You += 100
        *You *=2
        *You /=10
        print *You

        Dim Me as test pointer
        Me = new test

        me.x =13        
        print me.x

        me.x *=4        
        print me.x

        me.x /=13        
        print me.x

        print "Y test"

        me.y +=22        
        print me.y
        me.y *=4        
        print me.y
        me.y /=13        
        print me.y

        me.z +="HellO"
        me.z +="HellO"
        me.z +="HellO"
        print me.z

        Sync
        waitkey

Byte & Word Fields

PB now supports BYTE (8 bit unsigned) and WORD (16bit unsigned) fields within User defined type structures. This address a bit of gotcha when trying to work with some external functions (ie windows, other 3rd party dll's mainly).. But you can use this stuff in your programs like so.

// Create a structure so we can access the fields of ARGB colour
   // directly from memory (via pointer). Notice the order, INTEL
   // sludge boxes use LITTLE ENDIAN, so longs are stored in memory in reverse order
    Type  Colour
        B as byte
        G as byte
        R as byte
        A as byte
    EndType        

    // allocate a bank the size of the Colour structure (4 bytes in other words)
    Bank=NewBank(sizeOf(Color))

     // me a user defined type pointer, so we can query memory.
         Dim me as Colour Pointer

     //  set the ME to point at our Bank
         Me = GetBankPtr(Bank)

    //  Poke a colour into the bank
         PokeBankInt Bank,0,Argb(50,100,200,250)

   // use the Typed Pointer to query the colour that we stored in the bank
        print Me.A
        print Me.R
        print Me.G
        print Me.B

        Sync
        waitkey

Hi 2dboy. :)

I remember the Atari 2600 well.

A platform game is great as a long term project and if you're just beginning I recommend that you start with something more simple, something like an Atari game. What was your favorite?

— hartnell

hello everyone. My name is peter. I live in belgium and my englisch is so and so… I grew up with video games and i love them. The first console i played was an atari. I still love some of those games just as much as i do current ones. Now i am going to have a go at making a platform game because it seems like alot of fun. I searched the web for possible way's to make one and this seems like an excellent way to start. I also share your opinion that it's pretty much pointless making platform games with engine's that don't making use of programming (or not enough). I want to learn!!

I'm going to start by reading alot of info on this site. If i get stuck along the way i'll let you guys know and hopefully you can help me. Thanks and you'll here from me soon!

2009 PlayBASIC (game programming) Competition Starting Soon !

Surprise! - Yes, we've lined up another wacky competition for all the code crushing indie game programmers/designers out there.

What is it / When does it start ?

Visit Forums

http://www.Playbasic.com

PlayBasic V1.64K WIP thread

Work is progressing fairly well on the next major PlayBasic update. So far i'm focusing upon adding some features that are from the PlayBasic V2.00 (PBFX) design doc..

Latest additions are a bunch of new C styled math short cuts to the parser.

Read More

it looks really retro… where did you get this? Or is it your own creation?

First Shot :

SetFPS 60

ExpCR = 0
ExpR = 50
ExpMC = $bb
ExpX = 100
ExpY = 100

Do
    ExpX = ExpX - 1
    ExpY = ExpY - 1
    If ExpR > 0 Then ExpR = ExpR - 1
    If ExpCR < ExpR Then ExpCR = ExpCR + 2
    If ExpMC > 0 Then ExpMC = ExpMC - 2
    Cls 0
        CircleC ExpX,ExpY,ExpR + 2,True,$ff0000
        CircleC ExpX,ExpY,ExpR,True,RGB($ff,ExpMC,00) 
        CircleC ExpX,ExpY,ExpCR,True, $000000
    Sync
Loop

— hartnell

hehe jep. It is good to see you are getting your hands dirty :)

I figured out my mistake, needed to plug in x, y for circle instead of 100, 100

I'm new to programming trying to learn the basics of PB, so far I have been succesful in moving a dot with arrow keys and wasd keys but cant move a circle.

Here is the code I'm using

SetFPS 60

X=400
Y=300

    Constant vk_w = 17
   Constant vk_a = 30
   Constant vk_s = 31
   Constant vk_d = 32

Do
  If keystate(vk_w) Then y= y+ -2
  If keystate(vk_s) Then y= y+  2
  If keystate(vk_a) Then x= x+ -2
  If Keystate(vk_d) Then x= x+  2

    Cls 0
       Circle 100, 100, 16 true
    Sync
Loop

All I did was replace Dot x, y with the circle code, is there more I need to do before it will become mobile?

The original plan was for there to be more balls on screen. I might make a version which does that. I also like the idea of balls bouncing around.

PlayBasic V1.64j2 _Retail Upgrade_ is Now Available (14th, Sep, 2009)

This release updates the PlayBasic V1.63w2 -> V1.64j retail editions to the current retail release version of PlayBasic V1.64j2. However, if your edition of the PB is older than PB1.63w2, then you'll need to install that patch prior to updating the latest.

The PB1.64j package includes updates of PB Compiler, Release / Debug Runtimes, SLIBS, DOCS & IDE V1.17. The main changes for various SLIB updates and a healthy 180K reduction in the runtime sizes.

See Announcement