jAMAL - AMOS BASIC AMAL reimplementation in Java!

[Mequa]

I am working on a total reimplementation of the AMOS Animation Language in Java.



Thread on Amos Factory - Update: This has now moved.

I present my first public release - jAMAL alpha demo 0.1.
Runnable JAR and readme files enclosed in the attached zip file.

This is still somewhat buggy, but as a proof of concept this alpha works well.
I'll likely improve and debug it over the Christmas break.

In the meanwhile, I've already sent this demo to François Lionet.

Enjoy!

Edit: Now updated below.

[TCD]

Moved to News as requested by Mequa. Hope that gives him a bit of extra motivation

[Mequa]

I wrote an AMAL interpreter in Clickteam's Jamagic from 2002-2003. (Clickteam was co-founded by François Lionet of AMOS fame.)
I demoed it as part of my "Project Myqu" at the Clickteam convention in Hemel Hempstead in 2003 (details), which was an attempt at an AMOS to Jamagic source translator. This died with Jamagic. François liked it though!

My original AMAL interpreter was a bit more complete than this alpha, which I recently rewrote in Java from my Jamagic source base. (Much of it was originally written in AMOS itself and converted to Jamagic with "Myqu"!)

The shift in languages (to Java) let a few bugs in, which I'd like to eradicate. The sprite engine wrapper (using JGame) will also need a rewrite to match the sophistication of my Jamagic original.

When it's fully working, I'll release the source under a permissive BSD-style license, for the Amiga community to exploit as they wish (so long as my work is credited).


Now all we need is Java support under AROS

Unless I rewrite the whole thing (jAMAL) in C++ (maybe some day - would be easier than going from Jamagic to Java).


P.S. I just found this old heated discussion concerning my very own Project Myqu. Oh boy! I guess converting Amiga software to PC is offensive to some

[gibs]

Interesting !

[Mequa]

Update: jAMAL alpha demo release 0.1.1

Changes from alpha demo 0.1
- More examples added, and added more comments. Should be much easier for beginners now!
- Pausing improved. "Run" and "Pause" now both function as "Unpause".
- Will now officially translate AMAL to Java! (early alpha stage, not yet buildable)

P.S. François thought this was quite fun!

[Mequa]

Update: jAMAL alpha 0.2

Changes from alpha demo 0.1.1
- Fixed a major concurrency bug. All examples now load first time now.
- Improved the examples and added two "bouncy ball" demos.
- Can now save and load external files in ASCII format. [EAB Edit: Uses OS-native file requester.]
- PLay is now lexed correctly (movement banks not yet implemented).
- You can now strip your code. Oh là là!
- Added the ability to view all your programs in standard or stripped mode.

[Mequa]

Update: jAMAL alpha 0.3

Changes from alpha 0.2
- AMAL to Java machine-translated source code is now DIRECTLY BUILDABLE WITHOUT MODIFICATION!
AMAL scripts can now run either interpreted, or translated directly into Java and built.
(Requires full jAMAL source [with JGame] and Java SDK to build your own - former coming soon!)
- Can now export .java files which contain a complete buildable Java class (using OS-native endlines).
- A fully translated-to-Java and working non-interpreted AMAL example has been integrated into the editor.

Happy holidays!

[Mequa]

Changes from alpha 0.3:

- Now uses a higher resolution game window (640x512) and more sprite images.
- Sprites are now fully V-reversible as well as H-reversible.
- 90 degree rotation is possible for the pacman sprite (now also stored in rotated form).
- Some Amiga-style "boing ball" and "checkmark" sprites (and the jAMAL logo) were added to the examples.

Happy 2011!

[kriz]

Nice work !! Best wishes for 2011 !!

[Mequa]

As an aside: The public domain NASA nebula background is now treated as a JGame sprite.

This will make it pretty easy to add Amiga-style screen scrolling effects, as well as tying Bobs (high-level emulated Blitter Objects) to a screen while it is scrolled around.

P.S. I'll likely add (Java Swing-based) 'tabbed' editing soon. I'll also keep the current drop-down menu for selecting the program from the bank. Eventually importable and exportable directly to/from AMOS .abk.

[Mequa]

Update: No new versions since Dec 31st due to full-time commitments, however I have just released the source on SourceForge: https://sourceforge.net/projects/javaamal/

I'll look at making it easier to build and setting up a Subversion tree, but for now the (somewhat horrendous) Java source for my AMAL reimplementation alpha is now available.

Edit: The source zip archive in /src should now be importable into Eclipse IDE and buildable.

[Mequa]

jAMAL source release:

Alpha 0.4 was the first source release on SourceForge. BSD Licence pending.
- jAMAL_src.zip is now importable into Eclipse IDE under "Existing Projects into Workspace".
- It should now be buildable out of the box. (JGame libraries are in 'jgame' directory.)
- It should also build out of the box with AmalPrograms.java replaced with a jAMAL-exported Java file. Enjoy!

jAMAL alpha 0.41:

Changes from alpha 0.4
- Tidied up and refactored the Java source. It's now tidier and produces a smaller JAR file.
- Now launches JAMAL.java in jAMAL/src/jamal/ (instead of MyGame.java in jgame-sample/src/mygame/)

Attached version includes runnable JAR file, documentation and full source archive.
This and further updates will be available from http://sourceforge.net/projects/javaamal/files/ (Edit: now working)

Mequa

[LuMan]

Hi Mequa - This looks great. Good work I couldn't create any custom anims, is this something for a future release, or am I doing something wrong?

Keep up the good work!!

[Mequa]

The editor is still in an early state - I've yet to add functionality to add or delete a sprite/channel, but it is possible to modify the scripts. You can't yet cut and paste to/from external programs, and saving/loading is currently limited to the immediate location of the JAR file. If you select the Blank example, you can animate up to 5 sprites. (If it doesn't work, try restarting the JAR).

It doesn't yet support all of AMAL, but much of it already works. You can't yet add or import more sprite images, however the source is provided, so it's possible to play about with the resource files.

The spirit of this project is closer to AROS than UAE, or closer to ScummVM than DOSBox. Perhaps also comparable with Wine, although it is a much smaller and more obscure project than any of these. It's not a true emulator, but an interpreter with a high-level cross-platform reimplementation of a vintage API.
(It's also just within my current programming abilities. )

Complete guide to AMAL from the AMOS Pro manual

[Mequa]

Changes from alpha 0.41 in alpha 0.42:

• Now supports AMAL functions with multiple arguments (=XScreen(1,2), =YScreen(1,2), =XHard(1,2), =YHard(1,2), =BobCol(1,2,3), =SpriteCol(1,2,3)). Collision detection and multiple screen support is not yet implemented.
• =Z function (for random numbers) no longer locks up when used without an argument (still needs more work).

I also include documentation in PDF format. As before, you can get these files over at SourceForge.
This upgrade fixes a major bug in the Lexer, which now allows for all AMAL functions and instructions to be parsed (=Z without brackets is still to do).
Stay tuned for a working example or three at a later date, once I implement multiple screen support and collision detection.

[Mequa]

I'm currently working on extending this project by reimplementing the AMAL Environment Editor, which will make it somewhat more powerful.

This was basically a sub-sub-language of AMOS included in François Lionet's original AMAL Editor, and incorporated into the AMAL bank .abk file format. The syntax of the Environment Generator is a very stripped-down version of AMOS BASIC itself, used for initialising the environment for the animation scripts.

Currently the syntax parser for the Environment Editor is almost complete, and will be integrated into the editor very soon. Complete functionality however will take some time - I'll need to wrap more high-level Amiga emulation (such as multiple screens, bobs, sprite, rainbows) round the current sprite engine.

Mequa

[Mequa]

Update: jAMAL alpha 0.50 (July 23rd 2011)

After 4 months of development, a new build of jAMAL is ready for release.

Changes in jAMAL alpha 0.50:
• The AMAL Environment Generator has been reimplemented. This is based on a subset of AMOS BASIC itself.
• Can now load a background image from a file (or resource).
• Can now load sprite images from a folder or directory (disk or resource).
• The AMAL-to-Java Compiler has been greatly optimised (still needs more work though).
• A new background was added (from Photos8.com).
• Can now create a new project, and create a new AMAL channel and program.
• Added support for screen dragging and scrolling effects using Screen Display and Screen Offset in the Environment Generator. These can now be allocated to AMAL channels to allow AMAL scripts to control the screen directly. Some new examples were included.

Runnable JAR, documentation and source are downloadable from jAMAL's SourceForge page:
http://sourceforge.net/projects/javaamal/

Mequa

[Mequa]

Minor update: jAMAL alpha 0.51:
• Bug fix: The playfield is now correctly reset after using Screen Offset (screen scrolling demo) on loading a new example or program.


As well as on SourceForge, jAMAL alpha 0.51 is now downloadable from:

http://mequa.dragotech.net/jamal/jAMAL.jar (executable)
http://mequa.dragotech.net/jamal/jAMAL.pdf (documentation)
http://mequa.dragotech.net/jamal/jAMAL_src.zip (source)

UPDATE: jAMAL YouTube video

P.S. This now includes AbkViewer integrated into the jAMAL editor.
(Support for using original AMOS ABK sprites with animation scripts is planned.)

UPDATE: This has now been featured on Softpedia: http://mac.softpedia.com/get/Utilities/jAMAL.shtml

[Mequa]

Update: jAMAL alpha 0.51 has now been featured a second time on Softpedia, under free development tools for Windows.
More Softpedia screenshots are included:

http://www.softpedia.com/get/Program...ns-jAMAL.shtml

[Mequa]

Update: jAMAL alpha 0.52

Changes from alpha 0.51 in alpha 0.52
• Added Bell command to Environment Generator (with AMOSPro bell sound)
• Enhanced the quality of the scrolling example background
• Added digital speech on startup, stripping and translating code
• Added a new game control example – Shoot.amal

http://mequa.dragotech.net/jamal/jAMAL.jar (executable)
http://mequa.dragotech.net/jamal/jAMAL.pdf (documentation)
http://mequa.dragotech.net/jamal/jAMAL_src.zip (source)

Also available at: http://sourceforge.net/projects/javaamal/files/

[asymetrix]

This is great work - keep it up !

Have you seen alvyn editor ? Its a Java based editor that looks like Amos Pro ! :
I think it was supposted to be Amos Pro in Java, but not quite finished, maybe the two projects can be combined ?

http://alvyn.sourceforge.net/

[Mequa]

I have tried Alvyn, it doesn't appear to be updated since 2004.

Alvyn was meant to be an AMOSPro-compatible BASIC interpreter, and captures much of the feel of the AMOSPro editor. While the Alvyn editor was written in Java, it appears the Alvyn interpreter is written in C++, while jAMAL is written entirely in Java, so merging the two projects would require a rewrite of one or both (and a merging of sprite/screen engines, etc). This may be more fruitful when jAMAL is more complete and memory-efficient.

In addition to Alvyn, there was also the Mattathias BASIC project, which is written in ANSI C and aims to implement a full BASIC compiler compatible with AMOSPro (unlike Alvyn which is interpreted). This was discussed over at AMOS Factory (and I enquired here about the possibility of combining code with jAMAL), unfortunately it appears Mattathias is no longer in active development either.

These 3 projects all attempt a high-level reimplementation of parts of AMOSPro on modern hardware and operating systems. This is a similar approach AROS has taken with AmigaOS, and is a similar kind of reimplementation to projects such as ScummVM (and even Wine, as it implements the API level) - only allowing many enhancements beyond the capabilities of the original Amiga.

This is in contrast to emulators such as WinUAE, which replicate vintage hardware at a very low level, and so can already run the original AMOSPro near-perfectly under emulation - albeit limited to the original chipset's graphics. This is the approach taken by the AMOS for Windows installer.


P.S. A few years ago, I wrote a simple BASIC-style interpreter in C++ called "MequaScript", itself much inspired by AMOS.
If I ever get the time to do a Java port (it would need a lot of work and expanding), I would consider integrating AMOSPro-compatible syntax, and finally merging it with the jAMAL project. (Not this year however, unfortunately.)

[asymetrix]

That is interesting, maybe you could make a few bounties for each stage towards completion, at least you should get paid for your efforts.

Amiga desperatly needs an AmosPro basic interpreter in C++, fully portable.

The best thing about Amos Pro is that it 'just works' out of the box even today, whilst every other language needs some messing about and as of today Amos Professional has NEVER CRASHED !

Now we have a windows version (emulated), Im sure even Universitied would be interested in it as teaching BASIC programming material -and we have loads of source code examples and games written.

We also have a html and PDF manual created by yours truely.

Your C++/Java versions would be portable, and most vital.

thanks so much for your efforts, keep up the great work !

[Mequa]

For programming bounties, this would of course need to attract funding from those willing to see a full AMOS reimplementation.
I see 3 stages concerning jAMAL (not necessarily in strict order):

1) Complete the core implementation of AMAL in Java, including full AMAL syntax support, error checking, a debugger/monitor, more efficient use of memory, fully working translation/compilation to Java, and direct support for AMOS BASIC AMAL .abk banks (not to be confused with sprite banks). It should also be able to test if code is forward compatible with the original AMAL (allowing for possible expansion otherwise).
If it is, perhaps it could have the option to launch WinUAE or PUAE directly and test the AMAL scripts on a 'real' Amiga.

2) Improve the graphical engine so it supports multiple Amiga-style screens and screen clipping (currently only one screen is supported), as well as simulated rainbow/copper effects, and native support for AMOS BASIC .abk sprite banks (using one or multiple banks or combined with other sprites). It should also support screen drawing/graphics. This part is already implemented in Jamagic in my "Project Myqu", but will take some work to complete in Java using JGame and/or AWT.

At this stage the jAMAL project would be mostly complete, and a third stage would be as follows:

3) Create a BASIC interpreter in Java, syntax compatible with AMOSPro, and integrate with jAMAL's AMAL interpreter/compiler as well as its graphical engine (and AMAL editor).


Finally, if a native non-Java build is required:

4) Port jAMAL from Java to C/C++, using an appropriate sprite engine, including builds for AROS and classic AmigaOS.
(This could then either port a BASIC interpreter written in Java, or merge with code from Alvyn and/or Mattathias.)

[Adgarharrison]

This AMOS for Windows install uses Bernd Meyer's Just-In-Time (JIT) compiler for extra speed. This is needed as the included AROS-68k ROM beta is still quite slow. JIT compilation involves translating whole blocks of machine code WHILE RUNNING from one instruction set (Amiga 680x0) to another (PC x86). It even works with the AMOSPro Compiler, and AMOSPro's compiled AMAL and Interface scripts, translating them all into x86 machine code.
The resulting emulated 680x0 CPU gives Pentium 1-level performance on an Intel Atom netbook, Pentium 2-level performance on a Core2Duo, and Pentium 3-level performance on an i7. Needless to say, AMOS has never run natively on such a fast platform. It also uses immediate Blitter emulation for faster graphical performance. A few included AMOS games will need to be modified to be playable on such a fast CPU (try adding "Wait Vbl").
Unfortunately the JIT compiler is not currently compatible with Vsync (e.g. smooth scrolling). You will still need a real Kickstart ROM (such as by purchasing Amiga Forever 2012) to use AMOS under emulation with smooth scrolling. This AMOS for Windows build currently only works with AROS-68k ROM, but will be updated soon to support a "drop-in" ROM for extra performance and compatibility.

As well as various (limited) mobile ports of UAE, there is also the PUAE Amiga emulator for non-Windows platforms, which is currently in development and includes the latest features from WinUAE. A stable version working with AROS ROM would make an out-of-the-box Linux and Mac OS X install of AMOS possible, with the possibility of including future WinUAE updates such as improved Vsync. (It still needs a bit of work though, but is very promising).

PUAE has also been ported to non-x86 platforms such as ARM platforms (including Linux and Android), however does not feature JIT except on Intel/AMD x86. To get good performance of AMOS on an ARM mobile device in the absence of JIT would thus require a real Kickstart ROM (still under copyright), until a UAE-compatible 680x0-to-ARM JIT-compiler is implemented. If that is done, that would make fast, legal and free out-of-the-box AMOS available in your pocket.

There is also AROS-x86, a free clone of AmigaOS for modern PCs (particularly its "Icaros Desktop" and "Broadway" distributions). This includes a port of the UAE Amiga Emulator called Janus-UAE, which includes special integration features, and has been reported working with AROS-68k. So on this OS, you can launch AMOS from its original Amiga icon on a PC, and it will seamlessly launch. (PUAE on AROS may also be a possibility, and a possible merge with Janus-UAE.) AROS already has a Linux-hosted ARM version, with the possibility of one day working as a native OS on ARM, incorporating integrated classical Amiga emulation. This would be another excellent platform for AMOS (especially when/if JIT compilation comes to that platform).

Finally, WinUAE and PUAE feature retargetable graphics, or RTG. This allows emulation of a 24-bit graphics card, and supports native desktop resolutions on a PC. This is not available in AMOS, which is limited to the original Amiga chipset, however there is nothing preventing some AMOS enthusiast from writing an RTG extension, allowing AMOS to work with fast true-colour graphics in future...

Who says AMOS is dead?

[Mequa]

Thanks Adgarharrison, but please attribute the source. The above post was originally written by myself on Clickteam's forums.
(I also included a link to AMOS Factory, which now appears to be down with ultimateamiga.co.uk.)

I was much more active there in the past, when Jamagic was still going.
Their "older products" forum occasionally gets mention of AMOS and STOS.

[Mequa]

Update:
jAMOS is coming soon! A new cross-platform AMOS reimplementation written in Java.

jAMOS alpha is almost ready for public release. This will replace the jAMAL project entirely with support for a subset of AMOS BASIC itself in addition to AMAL. It uses an interpreter based on my MequaScript which I have now ported successfully from C++ to Java.

A new news thread will be created on release.

Stay tuned.


Edit: A news thread with a link to the first public release has been posted, subject to moderator approval.