Show Posts

This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.


Topics - dbox

Pages: [1]
1
Programs / QBJS - Import code from external .bas files
« on: April 15, 2022, 04:43:54 pm »
Hi All,

I wanted to share the latest feature I've been working on for QBJS to solicit some input from the community.  I've implemented the ability to include "modules" from external source files into your program.  This concept is similar to include from c/c++ and import from javascript.  The idea here is to make it easy to create reusable libraries that can be shared between projects.  Here's an example:

Code: QB64: [Select]
  1. Import MyLib From "https://raw.githubusercontent.com/boxgaming/qbjs/main/samples/include/test.bas"
  2. Import Maths From "https://raw.githubusercontent.com/boxgaming/qbjs/main/samples/include/maths.bas"
  3.  
  4. MyLib.DoStuff          ' Call exported sub
  5. Print MyLib.GetThings  ' Call exported function
  6.  
  7. Print Maths.Factorial(10)
  8. Print Maths.Plus1(11)
  9.  

Try it on QBJS-Dev

Any imports must be the first statements in your program.  In this example we've imported functionality from two different external source files.  Any methods exported from those libraries can be accessed in your program by prefixing them with the alias specified after the import statement.

Only the content specified for export will be available in the calling program.  This lets us have "private" shared variables and helper functions in our included modules.

Here's what the library files look like:

test.bas
Code: QB64: [Select]
  1. Export GetStuff As GetThings
  2. Export DoStuff
  3.  
  4. Dim foo
  5. foo = "somthing"
  6.  
  7. Function GetStuff
  8.     GetStuff = "got the stuff"
  10.  
  11. Sub DoStuff
  12.     Print "do the stuff"
  14.  

maths.bas
Code: QB64: [Select]
  1. Export increment As Plus1
  2. Export factorial AS Factorial
  3.  
  4. Function increment (num)
  5.     increment = num + 1
  7.  
  8. Function factorial (num)
  9.     Dim res
  10.     $If Javascript Then
  11.         if (num === 0 || num === 1) {
  12.             num = 1;
  13.         }
  14.         else {
  15.             for (var i = num - 1; i >= 1; i--) {
  16.                 num *= i;
  17.             }
  18.        }
  19.     $End If
  20.     factorial = num
  22.  

Export statements must appear at the top of your module code.  If you want to have a different name for the exported method from it's internal name you can use the "As Alias" syntax as shown above.

Import Entire Programs
Another benefit of this feature is that you can import entire programs from an external source file to make it easier to share large programs. Here are a couple of examples:

QBJS Paint
Code: QB64: [Select]
  1. Import QBJSPaint From "https://raw.githubusercontent.com/boxgaming/qbjs/main/samples/apps/paint.bas"
  2.  
Try it on QBJS-Dev


Terry Ritchie's Excellent Flappy Bird Clone
Ported from QB64
Code: QB64: [Select]
  1. Import FlappyBird From "https://raw.githubusercontent.com/boxgaming/qbjs/main/samples/games/trfbird.bas"
  2.  
Try it on QBJS-Dev

I'd be very interested to hear your thoughts.

2
Programs / Finger Painting in QBJS
« on: April 09, 2022, 06:18:56 pm »
Hi All,

One of the features I'm working on for the next QBJS is support for touch events and more dynamic scaling/sizing when viewing QBJS programs on mobile.  I'd be very curious to hear your experience with the following example.  I've adapted a drawing program I shared earlier.  With this version you should be able to draw now with your finger on your mobile (or otherwise touch-enabled) device.

Click here to try it out!

I'd be very curious to know your experience and what kind of device you tried it on.  Were you able to draw with the various tools and change colors?  Did the scaling look appropriate for your device?

If you want to see the code you can click here.   (This is still in development so some of the syntax may change slightly.)

3
Programs / QBJS - QBasic for the Web
« on: February 18, 2022, 09:58:59 am »
Update 30-Mar-2022
New beta release v0.3.0
https://qb64forum.alephc.xyz/index.php?topic=4670.msg141653#msg141653


Hi All,

I've decided to spin off QBJS into it's own project.  This started as a feature of the GX game engine https://qb64forum.alephc.xyz/index.php?topic=4481.0 that allows you to publish games built in QB64 for the web.  Based on the interest in this feature I've created a new stand-alone project: QBJS.

 
qbjs-screenshot.png


The goal here is to recreate the feel and accessibility of programming in QBasic/QB64 in the browser.  You can try it out here:

https://boxgm.itch.io/qbjs

This is still a work-in-progress, but it is pretty functional at this point so I thought I would share with a wider audience to get some additional feedback.  I've tried to document what is currently supported here:
https://github.com/boxgaming/qbjs/wiki/QBasic-Language-Support
https://github.com/boxgaming/qbjs/wiki/Supported-Keywords


4
Programs / Simple, Consolidated Game Device Input
« on: January 11, 2022, 01:02:54 am »
Hi All,

I put a good deal of work into a simple, consolidated game input API that allows for simple detection and testing of input from keyboard, mouse or game controller devices and thought I would share as there have been recent discussions on this topic.

With this approach device input can be detected with the following:

Code: QB64: [Select]
  1. Dim Shared diMoveLeft As GXDeviceInput
  2. GXDeviceInputDetect diMoveLeft
  3.  

The program will wait until a keyboard key, mouse button, or game controller button or axis movement has been detected.  Then later in your code when you want to test for that device input, simply do this:

Code: QB64: [Select]
  1. If GXDeviceInputTest(diMoveLeft) Then
  2.    ' Do your move left logic here
  4.  

I've added specific logic for linux and maxos to handle the fact that keyboard button presses are not returned by the _DEVICEINPUT method on those environments so that the behavior can be consistent cross-platform.  This is actually related to my very first post on the forum: https://qb64forum.alephc.xyz/index.php?topic=4448.msg138691#msg138691.

I've included a few demonstration programs in the attached zip.

1) The detect.bas program will display the last detected input and print information about the device input:
Code: QB64: [Select]
  2. '$Include:'gx/gx.bi'
  3. _Title "Detect Device Input"
  4.  
  5. Print "Waiting for input..."
  7.     Dim di As GXDeviceInput
  8.     GXDeviceInputDetect di
  9.     Cls
  10.     Print "Device #:    " + Str$(di.deviceId)
  11.     Print "Device Name: " + GXDeviceName(di.deviceId)
  12.     Print "Device Type: " + GXDeviceTypeName(di.deviceType)
  13.     Print "Input Type:  " + GXInputTypeName(di.inputType)
  14.     Print "Input Id:    " + Str$(di.inputId)
  15.     If di.deviceType = GXDEVICE_KEYBOARD Then
  16.         Print "Key Name: " + GXKeyButtonName(di.inputId)
  17.     End If
  18.     Print "Input Value: " + Str$(di.inputValue)
  19.     Print
  21.  
  22. Sub GXOnGameEvent (e As GXEvent): End Sub
  23. '$Include:'gx/gx.bm'
  24.  

detect.png


2) The input.bas demonstrates detecting input for certain actions and then testing for those inputs in a game loop:
Code: QB64: [Select]
  2. '$Include:'gx/gx.bi'
  3. _Title "Test Device Input"
  4.  
  5. GXSceneCreate 500, 300
  6. GXFrameRate 10
  7.  
  8. Dim Shared dleft As GXDeviceInput
  9. Print "Press Left... ";
  10. GXDeviceInputDetect dleft
  11. PrintDeviceInput dleft
  12.  
  13. Dim Shared dright As GXDeviceInput
  14. Print "Press Right...";
  15. GXDeviceInputDetect dright
  16. PrintDeviceInput dright
  17.  
  18. Dim Shared djump As GXDeviceInput
  19. Print "Press Jump...";
  20. GXDeviceInputDetect djump
  21. PrintDeviceInput djump
  22.  
  24.  
  25. GXSceneStart
  27.  
  28. Sub GXOnGameEvent (e As GXEvent)
  29.     Dim ldown As Integer
  30.     Select Case e.event
  31.         Case GXEVENT_UPDATE
  32.             If GXKeyDown(GXKEY_ESC) Then GXSceneStop
  33.  
  34.         Case GXEVENT_DRAWSCREEN
  35.             GXDrawText GXFONT_DEFAULT, 10, 10, "Press one or more mapped inputs:"
  36.             If GXDeviceInputTest(dleft) Then
  37.                 GXDrawText GXFONT_DEFAULT, 100, 100, "Left"
  38.             End If
  39.             If GXDeviceInputTest(dright) Then
  40.                 GXDrawText GXFONT_DEFAULT, 150, 100, "Right"
  41.             End If
  42.             If GXDeviceInputTest(djump) Then
  43.                 GXDrawText GXFONT_DEFAULT, 125, 125, "Jump"
  44.             End If
  45.     End Select
  47.  
  48.  
  49. Sub PrintDeviceInput (di As GXDeviceInput)
  50.     Print GXDeviceName(di.deviceId) + " : ";
  51.     Print GXInputTypeName(di.inputType) + " : ";
  52.     Print Str$(di.inputId) + " : ";
  53.     If di.deviceType = GXDEVICE_KEYBOARD Then
  54.         Print " [ "; GXKeyButtonName(di.inputId); " ]";
  55.     Else
  56.         Print ;
  57.     End If
  58.     Print " : "; di.inputValue
  59.     Print
  61.  
  62. '$Include:'gx/gx.bm'
  63.  

3) The nes-config.bas program is an example of using the API in a device setup screen with the ability to save the config:
Code: QB64: [Select]
  2. '$INCLUDE:'gx/gx.bi'
  3. '$INCLUDE:'control-config.bi'
  4.  
  5. GXSceneCreate 256, 240
  6. GXSceneScale 2
  7.  
  8. ControlConfigInit
  9. ControlConfigShow
  10.  
  11. GXSceneStart
  12.  
  13. Sub GXOnGameEvent (e As GXEvent)
  14.     OnControlConfigEvent e
  16.  
  17. '$INCLUDE:'gx/gx.bm'
  18. '$INCLUDE:'control-config.bm'
  19.  

nes-config.png


Feel free to use any of the examples in your own projects.  I would be very interested in any feedback you have.

5
Programs / Zelda - The Legend of GX
« on: December 27, 2021, 05:43:53 pm »
Since there are a number of zelda projects currently in-progress, I thought I'd put together a little version as a shameless plug for GX.  One of my current game projects is actually a NES mashup that will have crossover from a number of titles.  So I already had the map built using the GX map editor.  This version will let you walk the entire overworld map.  As an example I've also implemented the lost woods maze.  There are triggers on the map for all of the cave and dungeon entrances.  At the moment this will take you to an empty cave map.  (I haven't built any dungeon maps.)  If you exit the cave it reloads the overworld map and puts you back in the right spot.

Use the arrow keys to walk around.  You can press F1 to toggle debug mode.

I'd be interested in any feedback.  If you'd like to use this in your own projects, you are more than welcome.

6
Programs / GX - A QB64 Game Engine
« on: December 14, 2021, 01:28:12 pm »
Hi All, I wanted to share a project I've been working on for a bit.  I know there are several folks here with a lot of gaming experience and I would love some feedback.

In the process of working on several 2d game projects I was noticing that I was needing to write a lot of game "plumbing" for each project.  I wanted to see if it would be possible to create a generic game API and engine for QB64 that could support a number of different types of 2D games (platformers, top down, isometric strategy, etc.).  GX is the result of this effort so far.

The goal here is to create a flexible, event-based game engine. Based on your game requirements you can use as much or as little of it as you need, but the engine will take care of the main tasks of managing the game loop and screen buffering for the display.  The current alpha version has support for:
  • Scene (viewport) management
  • Entity (sprite) management
  • Tiled map creation and management - Including a world/map editor (built with Inform)
  • Bitmap font support
  • Basic collision detection
  • Basic physics/gravity
  • Device input management
  • Keyboard, mouse, and game controller
  • Interactive debugging

I've made an effort to document the project here:
https://github.com/boxgaming/gx/wiki

There are several samples included in the project and even a tutorial here:
https://github.com/boxgaming/gx/wiki/Tutorial

You can download the pre-release here:
https://github.com/boxgaming/gx/releases

I'm still in the process of documenting the API, so not all of the calls are there yet, but there is a good start.  I've tried to make the style similar to the QB64 wiki.

Additionally, I'm working on a export to web feature that I will be committing in subsequent updates that will convert a GX-based QB64 game into a canvas-based javascript game that can run in the browser.  It's not quite ready for primetime yet but I've included a screenshot of where I've converted one of the sample projects.

I would appreciate any and all feedback.

- dbox

7
QB64 Discussion / Device Input Question
« on: December 01, 2021, 12:30:39 pm »
Hi QB64 community.  First off, let me just say a big thank you to all who are keeping this project going.  I have had an absolute blast since I found this project.  Like many others I was trying to find a way to run my old QBasic projects on a modern OS without needing a virtual DOS machine.  I've been impressed with the modern extensions especially as regards to the graphics capabilities which are available.

So I've been working on some new game-related material that I hope to share shortly and I've run into what seems like a cross-platform compatibility issue with device input.  I'm trying to use a flexible device input scheme that would allow dynamic mapping of inputs to game actions, regardless of whether the input is from a keyboard, mouse or game controller.

On windows the idea is working as expected.  However, when I try to run the code on Linux or MacOS it does not seem as though the keyboard events are being caught by the device import methods.

Here is a bit of sample code to demonstrate:
Code: QB64: [Select]
  2.     Dim i As Integer
  3.     For i = 1 To _Devices
  4.         If _DeviceInput(i) Then
  5.             Cls
  6.             Locate 1, 1
  7.             Print Str$(i) + " : " + _Device$(i) + " : " + Str$(_LastButton(i))
  8.             Dim j As Integer
  9.             For j = 1 To _LastButton(i)
  10.                 If _Button(j) Then
  11.                     Print "button: " + Str$(j)
  12.                 End If
  13.             Next j
  14.         End If
  15.     Next i
  16.     _Limit 60
  18.  

If you run this on windows you will see button ids corresponding to the keys that are pressed down.  However, on Linux and MacOS it only seems to be detecting mouse and controller button events.

If this has already been addressed in another thread or there is an open issue that I missed just let me know and forgive my noobness.

Pages: [1]