I agree that it would take a high degree of good-citizen co-operation. In fact it wouldn’t be trivial to even find your neighbours after it has grown organically in random directions. More thought is needed. ]]>

It would be feasible to implement Cyberspace as a plugin or type of scripted entity in High Fidelity, where world owners specify which worlds they want to be their neighbors in each direction, and the plugin grabs that world’s geometry (other worlds would have to publish the geometry in a network-friendly format) and renders it as an entity in the current world. Navigation between worlds would be supported teleporting the player as soon as they walk into the neighbor entity.

However, the main issues of this are the limits of 3D space – you can only have 4 or 6 neighbors, crazy stuff would happen if your neighbors didn’t reciprocate your connection, things that happen in other nodes would take a while to propagate to the current node…

]]>In the languages I’m familiar with, multiplication and division have the same precedence. When both occur in the same expression, without parenthesis, order is from left to right.

In Basic4GL, it appears that either division has higher precedence over multiplication, or order is from right to left.

For instance:

printr 7 * 285 / 100 + 285

printr (7 * 285 / 100) + 285

printr (7 * 285) / 100 + 285

printr ((7 * 285) / 100) + 285

The first two expressions print 299.

The second two print 304.

I would argue that this is inconsistent with what is standard arithmetic.

But in any case, I still think Basic4GL is pretty cool!

So I changed the code, and used parenthesis to force the precedence/ordering needed, and now I get the expected sequence with Basic4GL.

(200574 60372774 120544974 180717174 240889374 301061574 309886830)

]]>It does actually keep going after printing 195452, it just takes a little while.

Basic4GL is a virtual machine based language, so it can’t compete speed-wise with those that compile to actual machine code. But it does get there.

If you set the language to “traditional” (in the Basic4GL options), division is performed using floating point. In which case it outputs:

200612

60384212

120567812

180751412

240935012

301118612

309945540

I couldn’t say why the numbers are different.

My recommendation would be to debug through the code in Basic4GL and another BASIC and try to narrow down the point where it starts to diverge.

Incidentally, I tried it in QBasic (using the DOSBOX emulator) and it eventually output 200730

]]>Thanks again!

]]>For let me say that Basic4GL is very impressive! Good job!

I have a little benchmark program that I use to test integer operations and looping speed of various interpreters and compilers. I’ve successfully tested it with the follow Basic interpreters/compilers:

FreeBasic

BCX

VisualBasic.Net

Oxygen Basic

PowerBasic

QB64

JWillia basic

ChipMunkBasic

Yabasic

SdlBasic

SmallBASIC

SpecBAS

BBCBasic

ThinBasic

FBSL

Scriba

RCBasic

LBB

DDS5

MY-BASIC

MiniBASIC

nuBASIC

Basic256

bscript

However, for some reason, I have not been able to get it to run correctly in Basic4GL. Would you be able to spot what I’m doing wrong?

The program should print out the following sequence:

200574 60372774 120544974 180717174 240889374 301061574 309886830

But when I run the Basic4GL version, I get:

195452

And nothing else.

Here is the program – this is very similar to the one I’ve run for the processors listed above:

—————————————–

dim left_edge as integer

dim right_edge as integer

dim top_edge as integer

dim bottom_edge as integer

dim max_iter as integer

dim x_step as integer

dim y_step as integer

dim y0 as integer

dim x0 as integer

dim x as integer

dim y as integer

dim i as integer

dim x_x as integer

dim y_y as integer

dim temp as integer

dim the_char as integer

dim accum as integer

dim count as integer

accum = 0

count = 0

while count bottom_edge

x0 = left_edge

while x0 < right_edge

y = 0

x = 0

the_char = 32

x_x = 0

y_y = 0

i = 0

while (i < max_iter) and (x_x + y_y 800 then

the_char = 48 + i

if i > 9 then

the_char = 64

end if

else

temp = x_x – y_y + x0

if ((x 0)) or ((x > 0) and (y < 0)) then

y = (-1 * ((-1 * x * y) / 100)) + y0

else

y = (x * y / 100) + y0

end if

x = temp

end if

i = i + 1

wend

accum = accum + the_char

x0 = x0 + x_step

wend

y0 = y0 – y_step

wend

if count % 300 = 0 then

print accum

end if

count = count + 1

wend

print accum

—————————————–

Note. I've tried setting the main loop counter to 1 (instead of 1545) and for other processors, the result is 200574. For Basic4GL however, it is still 195452.

Thanks for any help!

]]>I don’t know this far in advance what the architecture will be but further functionality expansions (say pathfinder, collision detection, etc) could be paid upgrades as well as in Unity. Priced right, I think it would work.

Just my 2 cents.

Cheers!

]]>ES 1.1 is a subset of OpenGL fixed pipeline but enought for Basic4GL without special OpenGL plugins.

(so far I know)

DJ

]]>