05.Okt.2023
|
Tutorial: Ein Amiga-GUI-Programm in C schreiben (Englisch)
Edwin van den Oosterkamp hat sich bereits in zwei Büchern der Programmiering auf dem Amiga gewidmet: "Classic AmigaOS Programming - An introduction" ist eine Einführung in die Programmierung des AmigaOS in C und Assembler. Zielgruppe sind Programmierer ohne Amiga-Erfahrung, oder ehemalige Amiga-Programmierer die nach längerer Unterbrechung wieder für den Amiga entwickeln möchten. "Bare Metal Amiga Programming" geht auf die Programmierung der Hardware unter Umgehung des Betriebssystems ein.
Wir haben den Programmierer eingeladen, anhand eines konkreten Beispiels den Einstieg in die C-Programmierung aufzuzeigen und sagen herzlichen Dank für die nachfolgende Anleitung:
"There are many things I love about the Amiga and one of these is the OS. AmigaOS provides a lot of the things we now take for granted in an operating system. Not only the obvious things like windows, menus, icons and such but also things like multi-tasking and inter-process messaging. And compared to modern operating systems there are not many layers between AmigaOS and its applications, so it feels like you're having direct access to the OS. Personally I really like using my Amiga for productivity tasks and this includes using it to write Amiga software. This article uses a simple example program to show how an Amiga GUI program in C can be created using the Amiga itself. To save you all the typing I have also released the source code for this program so that you can download it from here.
Native development
When the new Kickstart/Workbench 3.2 was released its developers also released the matching Native Development Kit, or NDK for short. This kit can be downloaded for free from the Hyperion website and contains (amongst other things) the include headers needed for development in C. The 3.2 NDK does not just cover all the new things that Kickstart 3.2 brought, but also all includes for the older functionality of previous kickstarts. It is therefore perfectly fine to use the 3.2 NDK and develop software for Kickstart 2.0 and upwards - or even Kickstart 1.x and upwards. You do need to be careful not to call any of the new functions that were not available on the older Kickstart versions.
The NDK does not include a compiler nor a text editor. For the text editor you can use any editor you like. I've been using the "TextEdit" program that comes with Workbench 3.2 but plenty more options are available on places like Aminet. There is of course also "edit", the standard text editor that has been part of the Workbench since the 1.x days.
There are a number of different C compilers available for the Amiga. From gcc forks down to the old compilers people used in the 90's. My choice for native compilation is VBCC, which is a compiler that runs on the Amiga natively, creates good code and is still actively maintained. It is also designed to run on systems with considerably less resources than a modern PC, unlike for example versions of gcc.
Speaking of resources, to install the NDK your Amiga will definitely need a hard disk. It does not matter if it is a real spinning rust drive, a CF card or an emulated one on a memory card. When installed the NDK simply does not fit on a floppy. Of course it is possible to cherry pick just those header files that are required for a certain project, but then you are not making it easy on yourself. Your system also needs something faster than a standard 68000 CPU. The newer versions of VBCC require a 68020 or higher, and while it is possible to use an older version on a 7Mhz 68000, it just takes too long to compile any non-trivial project for it to be really practical.
Installing LHA
The NDK download will be in the LHA file format. This is an archive format similar to (but not the same as) the ZIP format used by Windows nowadays. The "lha" command is used to extract the archive, which can be downloaded from Aminet here: http://aminet.net/util/arc/lha.run. If your Amiga already has LHA installed then please feel free to skip this section.
The lha.run file is a self-extracting archive that, when run on an Amiga, will produce multiple files. Two are documentation files, one as a "readme" text and one in "guide" format. Then there are three executables, one for the 68k, one for the 68020 (and higher) and one for the 68040 and higher. Select the one that is correct for your system, rename it to "lha" and copy it into the C: folder.
Installing the 3.2 NDK
The first step is downloading the NDK from the Hyperion website.
To keep things organised I recommend creating a drawer named "Develop" in the root of your hard drive. If you use multiple partitions then it does not matter which one you choose, that is up to you. Then inside that "Develop" drawer create a drawer named "NDK3.2". Then copy the downloaded lha file of the NDK into this "NDK3.2" drawer.
Open a Shell or CLI window and navigate into this "NDK3.2" drawer. To extract the lha archive, type the following command into the shell window:
> lha x NDK3.2R4.lha
Please note that the developers of the NDK are planning to keep updating it as and when required. This means that the name of the lha archive may change and that the file you have downloaded may not be named "NDK3.2R4.lha" like mine was. Please update the filename used to unpack the archive with the name your archive has. The above command will unpack all the contents of the lha file. After that has successfully concluded you can safely delete the lha archive from the drawer.
Installing VBCC
The VBCC compiler consists of two parts, the compiler part and the target part. This allows VBCC to be used for cross-compilation. For example, with the Amiga compiler and the Atari target it is possible to write Atari software on an Amiga. With the Windows compiler and the Amiga target it is possible to create Amiga executables on a Windows PC.
In this case we want to download the Amiga 68k compiler:
vbcc_bin_amigaos68k.lha.
And the AmigaOS 68k target:
vbcc_target_m68k-amigaos.lha.
The above target allows for compiling software for Kickstart 2.0 and newer. To develop for the older Kickstart 1.x versions a different target is required, which can be downloaded from:
vbcc_target_m68k-kick13.lha.
The example used by this article depends on Kickstart 2.0 functionality and therefore the first of the two target archives is required. For more information about VBCC, please check out the website (http://sun.hasenbraten.de/vbcc/) where you can also find compilers and targets for next generation PPC based Amigas and other systems.
The lha archives for VBCC contain an installer script that will copy all files to the correct location and set everything up for use. These archives therefore need to be unpacked into a temporary location like the ram: disk or the T: directory. After unpacking you can simply double click the "install" icon and follow the on-screen instructions. First start with the "bin" archive and then follow up with the contents of the "target" archive.
One of the things the VBCC installer is going to ask for is the location of the NDK. This location is the "NDK3.2" drawer into which the NDK lha archive was unpacked previously.
Hello world, meet our first program
The program below will open a small window titled "Hello World!", which then closes itself automatically after a short time. To open the window a function called OpenWindowTagList() is used, which was introduced with Kickstart 2.0 (Intuition library V36). This program therefore requires Kickstart 2.0 or newer to run.
#include <proto/exec.h>
#include <proto/intuition.h>
#include <proto/dos.h>
#include <intuition/intuitionbase.h>
#include <intuition/intuition.h>
int main()
{
char Title[] = "Hello World!";
ULONG WinTags[] = {
WA_Width, 200,
WA_Height, 100,
WA_Title, (ULONG)&Title,
WA_Activate, 1,
TAG_END
};
struct Window * pWin = OpenWindowTagList( NULL, (struct TagItem *)&WinTags );
if ( !pWin )
{
return -1;
}
Delay( 500 );
CloseWindow( pWin );
return 0;
}
To compile it, copy/paste it into a text file named 'test.c' and use the following command in a shell/CLi window:
> vc -c99 -lauto test.c -o Test
This will create an executable named "Test", which you can run from the shell.
The "-c99" argument enables the compiler's support for the C99 standard. Amongst other things this enables support for comments starting with '//' as well as support for declaring variables at their first use, instead of placing them all at the top of the function.
The "-lauto" argument tells the linker to automatically open and close the system libraries used by the program. For example, the OpenWindowTagList() function is part of the Amiga's Intuition library, while the Delay() function is part of the Dos library. Without the "-lauto" argument it is up to the programmer to open and close these libraries as and when required. Letting the linker worry about these things keeps things a bit more readable.
Closing on command
Instead of closing automatically, it would be much better if the window had an actual working close gadget. To achieve that we need to enable the window's close gadget and then respond to it when it is clicked by the user. On AmigaOS the windows are managed by the Intuition library and the library communicates with the applications via messages. These messages are received via each window's "Intuition Direct Communications Message Port", or IDCMP for short. The messages are therefore known as IDCMP messages. It is up to the application to indicate which class of message it wants to receive for each window.
The updated program is shown below. Two new tags have appeared in the Window's taglist: the WA_CloseGadget tag enables the window's close gadget and the WA_IDCMP tag indicates the classes of messages the program wants to receive - only the IDCMP_CLOSEWINDOW class at this point.
#include <proto/exec.h>
#include <proto/intuition.h>
#include <intuition/intuitionbase.h>
#include <intuition/intuition.h>
int main()
{
char Title[] = "Hello World!";
ULONG WinTags[] = {
WA_Width, 200,
WA_Height, 100,
WA_Title, (ULONG)&Title,
WA_Activate, 1,
WA_IDCMP, IDCMP_CLOSEWINDOW,
WA_CloseGadget, 1,
TAG_END
};
struct Window * pWin = OpenWindowTagList( NULL, (struct TagItem *)&WinTags );
if ( !pWin )
{
return -1;
}
WaitPort( pWin->UserPort );
CloseWindow( pWin );
return 0;
}
The only other difference is that the Delay() function from the Dos library has been replaced with the WaitPort() function from the Exec library. WaitPort() puts the program to sleep until a message arrives on the port. And in this case that can only be an IDCMP_CLOSEWINDOW message, so as soon as we receive a message on the port we know we can close the window and call it a day.
On AmigaOS it is important to ensure that the program closes all Windows, files and so on before it terminates. Unlike modern operating systems there is nothing keeping track of these things for your process. If you forget to close a window upon exit then that Window will stay there. On AmigaOS you are solely responsible to close/free everything that you've opened/allocated.
Closing on command, now properly please
The previous program works as intended but only because it is a trivial program. With a normal program there will be a number of different classes of IDCMP messages coming in, each requiring a different response from the program. To do this properly for our program the following part needs to be added instead of the "WaitPort( pWin->UserPort );" line:
int Run = 1;
while ( Run )
{
WaitPort( pWin->UserPort );
struct Message * pMsg;
while ( pMsg = GetMsg( pWin->UserPort ) )
{
struct IntuiMessage * pIMsg = (struct IntuiMessage *)pMsg;
switch ( pIMsg->Class )
{
case IDCMP_CLOSEWINDOW :
Run = 0;
break;
}
ReplyMsg( pMsg );
}
}
The program is still put to sleep while waiting for messages on the port. But now when the program wakes up it actually gets the message from the port, checks the class of the message and replies the message. This last point is important since only then will Intuition know that the message has been dealt with and that any resources held can be released. The program receives the messages in a loop since it is possible that there is more than one message waiting when the program wakes up. And if the message is not of the IDCMP_CLOSEWINDOW class (unlikely in our still trivial case) then the program needs to continue running and processing.
Let's add some more GUI based functionality to our little program.
Gadtools
With Kickstart 1.x the only way to create menus and gadgets was via the Intuition library. With Kickstart 2.0 a second method was introduced with the Gadtools library. Gadtools made creation of menus and gadgets much simpler and at the same time added a number of new standard gadgets. These new standard gadgets meant not only that programmers no longer needed to create their own, but also that these gadgets now had an uniform look across different programs. The menus and gadgets created with Gadtools still consist of Intuition based elements and can be mixed with traditional Intuition based gadgets and menus.
Since Gadtools has been bolted on top of Intuition all messages its elements generate are IDCMP messages. Some of these messages are for internal use by Gadtools only and to filter these out Gadtools provides its own version of the GetMsg() and ReplyMsg() functions that should be used instead. This also means that some IDCMP messages are for Gatools' use only, in which case the GT_GetIMsg() function may return NULL on the first call if there are no other messages available.
Using the Gadtools functions the message loop from the previous section now looks as follows:
int Run = 1;
while ( Run )
{
WaitPort( pWin->UserPort );
struct IntuiMessage * pIMsg;
while ( pIMsg = GT_GetIMsg( pWin->UserPort ) )
{
switch ( pIMsg->Class )
{
case IDCMP_CLOSEWINDOW :
Run = 0;
break;
}
GT_ReplyIMsg( pIMsg );
}
}
One additional nicety is that the GT_ functions work on IntuiMessage structs instead of Message structs. This removes the need to cast from one type of pointer to another and makes the code look a bit cleaner.
Gadtool menus
GadTools menus are created via an array of NewMenu structs. From this array the Gadtools function CreateMenuA() generates a list of Intuition Menu structs. None of the sizes and locations of the menus and their items are calculated at this point. This is done by calling the Gadtools LayoutmenusA() function. This function also requires a pointer to a VisualInfo struct, which contains all information Gadtools requires to calculate screen and font sizes. A pointer to this struct is obtained from the GetVisualInfo() function.
The last field of the NewMenu struct is a pointer that can be used for user data. This can for example be a pointer to a function, when the user selects that menu item the program can use the pointer to call a particular function. In this case I have created a number of integer defines that are interpreted as commands. The program can read the user data and show the About window when it sees the CMD_ABOUT value or for example quit the program when it sees CMD_QUIT.
struct Menu * CreateMenu( void * pVI )
{
struct NewMenu nm[] = {
{ NM_TITLE, "Project", 0, 0, 0, 0 },
{ NM_ITEM, "About...", "A", 0, 0, (APTR)CMD_ABOUT },
{ NM_ITEM, NM_BARLABEL, 0, 0, 0, 0 },
{ NM_ITEM, "Quit", "Q", 0, 0, (APTR)CMD_QUIT },
{ NM_TITLE, "Options", 0, 0, 0, 0 },
{ NM_ITEM, "High", 0, CHECKIT|MENUTOGGLE|CHECKED, 0x6, (APTR)CMD_OPTHIGH },
{ NM_ITEM, "Mid", 0, CHECKIT|MENUTOGGLE, 0x5, (APTR)CMD_OPTMID },
{ NM_ITEM, "Low", 0, CHECKIT|MENUTOGGLE, 0x3, (APTR)CMD_OPTLOW },
{ NM_END, 0, 0, 0, 0, 0 }
};
struct Menu * pMenu = CreateMenusA( nm, 0 );
if ( !pMenu )
{
return NULL;
}
LayoutMenusA( pMenu, pVI, 0 );
return pMenu;
}
At this point the menu structure has been setup including the size and location of each of its items. The menu is now ready to be added to a window, for example via the SetMenuStrip() function that is part of the Intuition library.
Intuition will send the IDCMP_MENUPICK message each time the user interacts with the menu. In order to receive these messages for our menu we need to add that message class to the WA_IDCMP tag used for the OpenWindowTagList() function. This is done by logic-OR-ing the new message class with the already existing class. In the message loop we also need to add the IDCMP_MENUPICK class to the switch statement that checks the pIMsg->Class field of the received message.
The code field of the IDCMP_MENUPICK message has a unique number identifying the menu/item. This number is assigned by Intuition and indicates the item's position in the menu bar (e.g. 5th item of 3rd menu). The NDK provides handy macros to decode the menu number and Intuition provides the ItemAddress() function for obtaining a pointer to the Menu or MenuItem struct of the menu element that the user interacted with.
Unfortunately neither the Menu struct nor the MenuItem struct have user data fields. Gadtools worked around this by placing the user data immediately after the struct of the element. It is important to keep in mind that a Menu struct has a different size compared to a MenuItem struct. Before we can read the user data we need to find out if it was a menu or an item that caused the message. In the case of our example program only items have interesting user data, so if the message was not caused by the user interacting with an item then we can skip the reading of the user data.
The following function does all the things discussed above; it uses one of the menu number macros to check if the message is from an item. Then it gets the address to the MenuItem struct and moves the pointer to directly after the struct. It interprets the data after the struct as an integer and returns the value of that integer. The returned value also includes a value defined elsewhere in the program to indicate that this command came from a menu selection.
int ProcessMenuPick( struct Menu * pMenu, struct IntuiMessage * pIMsg )
{
if ( ITEMNUM( pIMsg->Code ) == NOITEM )
{
return CMD_NONE;
}
char * pItem = (char *)ItemAddress( pMenu, pIMsg->Code );
if ( !pItem )
{
return CMD_NONE;
}
pItem += sizeof( struct MenuItem );
int Command = *(int *)pItem;
return Command | SRC_MENU;
}
Gadtools gadgets
The creation of gadgets works slightly different from the way Gadtools creates menus. Menu creation was done via an array of structs that represented multiple items and menus. Gadgets are created one at a time by calling the CreateGadgetA() function for each gadget. Gadgets are linked into a list by providing the pointer to the previous gadget when calling CreateGadgetA() to create the next gadget. The start of this linked list must first be created by calling CreateContext() and the pointer from CreateContext() is then passed on to CreateGadgetA() for the creation of the first actual gadget.
The following function creates a list of gadgets and returns a pointer to the top of the list. This pointer is later required to free the list. The function uses arrays for most of the arguments of CreateGadgetA(). More gadgets can be added by extending these arrays.
struct Gadget * CreateGadgets( struct Window * pWin,
void * pVI,
struct Gadget * pGadgets[] )
{
#define NUM_GADGETS 3
// The labels and tags for the cycle gadget
static char * cycLabels[] = { "High", "Mid", "Low", 0 };
ULONG cycTags[] = { GTCY_Labels, (ULONG)cycLabels, TAG_END };
// The arrays used for the creation of the gadgets
int ggKind[NUM_GADGETS] = { BUTTON_KIND, BUTTON_KIND, CYCLE_KIND };
ULONG * ggTags[NUM_GADGETS] = { NULL, NULL, cycTags };
struct NewGadget ggNew[NUM_GADGETS] = {
{ 100,78,85,14, "Quit", 0,1,0, pVI, (APTR)CMD_QUIT },
{ 100,20,85,14, "About..", 0,2,0, pVI, (APTR)CMD_ABOUT },
{ 100,35,85,14, "Options", 0,3,0, pVI, (APTR)CMD_OPTIONS },
};
struct Gadget * pGad;
struct Gadget * pContext = CreateContext( &pGad );
if ( !pContext )
{
return NULL;
}
for ( int Index=0; Index < NUM_GADGETS; ++Index )
{
pGad = CreateGadgetA( ggKind[ Index ], pGad, &ggNew[ Index ], (struct TagItem *)ggTags[ Index ] );
pGadgets[ Index ] = pGad;
}
AddGList( pWin, pContext, 0, -1, 0 );
RefreshGList( pContext, pWin, 0, -1 );
return pContext;
}
After the gadgets have been created the Intuition function AddGList() is used to add the gadgets to the window, followed by Intuition's RefreshGList() function which ensures that all gadgets are setup correctly and show the correct state on screen.
One additional thing to note is the pGadgets[] argument of the function above. This array of pointers takes the pointer of each gadget created by Gadtools. These pointers can be used by the program to manipulate the state of the gadgets when required. There wiil be an example of this later on in this article, where the selected item of the cycle gadget will be changed.
The window will receive IDCMP_GADGETUP messages when the user interacts with the buttons. Please note that other types of buttons may produce other classes of messages as well. Internally Gadtools may depend on other IDCMP messages as well, but without passing them on. To ensure that the right messages are being received for Gadtools' purposes a macro is provided for each type of Gadtools gadget. In our case we use only the BUTTON_KIND and CYCLE_KIND gadgets. To ensure these work correctly we need to logic-OR the macros BUTTONIDCMP and CYCLEIDCMP with the other classes already present for the window's WA_IDCMP tag.
The IDCMP_GADGETUP message has in its "IAddress" field the address of the Gadget structure of the gadget the user interacted with. This is a pointer to the Intuition Gadget struct and unlike the structs used by the menus, this struct does already contain a UserData field. Reading this field will tell us which gadget was being clicked by the user. The only extra step required is for the CYCLE_KIND gadget, where the "Code" field of the message gives the (zero-based) index number of the option the user selected.
Since all information we need is already provided by the IntuiMessage of the IDCMP_GADGETUP class, dealing with it is simpler than the dealing with the IDCMP_MENUPICK message, as the following function shows:
int ProcessGadgetUp( struct IntuiMessage * pIMsg )
{
struct Gadget * pGadget = (struct Gadget *)pIMsg->IAddress;
if ( !pGadget )
{
return CMD_NONE;
}
int Command = (int)pGadget->UserData;
if ( Command == CMD_OPTIONS )
{
Command += pIMsg->Code;
}
return Command | SRC_GADGET;
}
Just like the function dealing with the IDCMP_MENUPICK message, this function adds an indicator to show that the command was produced via interaction with a gadget.
Updating the user interface
There are times when a program needs to update the menu or gadget selections in order to reflect the program's state. In our example program we have a cycle gadget and a menu, each showing the exact same selection. It would only be proper for the program to ensure that both indeed always show the same selection. To do this, the program needs to be able to change the selection of the cycle gadget as well as the selection of the mutual-exclusive menu items.
Updating the cycle gadget is straight forward with Gadtools' GT_SetGadgetAttrsA() function. This function takes a pointer to the gadget as well as a taglist with the gadget's new setting. In this case all we need to do is to provide the new selection via the GTCY_Active tag and call GT_SetGadgetAttrsA(). The fact that we need the pointer to the gadget to be able to do this is the reason that our CreateGadgets() function returned all the individual pointers via the the pGadgets[] array.
Unfortunately updating the menu is a bit more involved. Before we can make any changes to the menu we need to remove it from the window using the ClearMenuStrip() function. After the changes have been made we can use ResetMenuStrip() to place it back on the window. Intuition menus consist of linked lists. We know that the first selection item is the 1st item on the 2nd menu, so we can use the ItemAddress() function to get the address of the MenuItem struct of the first selection item. The structs of the next two selection items can be found by following the "NextItem" fields of each struct. Updating the selection tick for an item is done by adding or removing the CHECKED flag in the "Flags" field of each item's MenuItem struct.
The following function uses the "Command" value to update the cycle gadget and the menu items. The "Command" value also indicates what the source of the command was so that it can be used to prevent updating the element that provided the command. For example, when the user interacts with the menu then the menu does not need to be updated by the program.
void UpdateOptions( int Command, struct Window * pWin, struct Gadget * pGadList[] )
{
int Source = Command & SRC_MASK;
int Option = Commnad & 0x0F;
if ( (Source != SRC_GADGET) && pGadList && pGadList[2] )
{
ULONG cycTags[] = { GTCY_Active, (ULONG)Option, TAG_END };
GT_SetGadgetAttrsA( pGadList[2], pWin, NULL, (struct TagItem *)&cycTags );
}
if ( Source != SRC_MENU )
{
struct Menu * pMenu = pWin->MenuStrip;
if ( pMenu )
{
ClearMenuStrip( pWin );
UWORD MenuNumber = FULLMENUNUM( 1, 0, 0 );
struct MenuItem * pItem = ItemAddress( pMenu, MenuNumber );
for ( int Index=0; Index < 3; ++Index )
{
if ( pItem )
{
if ( Index == Option )
{
pItem->Flags |= CHECKED;
}
else
{
pItem->Flags &= ~CHECKED;
}
pItem = pItem->NextItem;
}
}
ResetMenuStrip( pWin, pMenu );
}
}
}
Keyboard action
In a lot of cases there is not much to do for a program in order to support the keyboard. The menu takes care of its own shortcuts and any gadgets that take text, e.g. string gadgets, take care of the keyboard themselves. There is one thing though that Intuition does not provide for, mainly since it was not really a "thing" back in the day. And that "thing" is closing a window when the escape key is hit by the user. Of course our window is actually a main window for which close-on-esc is less common, but it still useful to show how simple it is to do this for an AmigaOS application.
Keyboard support is provided by means of IDCMP messages, of which there are two key related classes. The IDCMP_RAWKEY message is sent each time a key is pressed and each time a key is released. It contains the raw key code directly from the keyboard, but without translating it according to the installed keyboard layout. The other message is the IDCMP_VANILLAKEY message, which does translate the key codes by using the default keymap. For keys that don't translate to a keymap (like the function keys for example) no IDCMP_VANILLAKEY message will be sent, to receive key codes for those the IDCMP_RAWKEY message is needed.
In our case all we need to know is that the user has released the "Esc" key and for that the IDCMP_RAWKEY message is enough. To receive the message we need to add the IDCMP_RAWKEY class to the window's WA_IDCMP tag. Each time a key is pressed and each time a key is released the program will now receive an IDCMP message with the IDCMP_RAWKEY class and the raw key code in the "Code" field of the message. The function below shows a simple way to deal with this message:
int ProcessRawKey( struct IntuiMessage * pIMsg )
{
if ( pIMsg->Code != 0xC5 )
{
return CMD_NONE;
}
return CMD_QUIT;
}
The magic number "0xC5" used above is the code sent by the keyboard when the "Esc" key is released. This key is in the same location on all keyboard layouts and therfore the code will be the same for all keyboard layouts.
Resources
There you have it, a small AmigaOS GUI program that does absolutely nothing. Nothing, apart from showing how things work within the AmigaOS graphical environment. It is up to you now to expand on it. Maybe add some different types of Gadtools gadgets? Or actually add some useful functionality? In any case, to take it further here are some resources that are useful to the general AmigaOS programmer..."
- The "Autodocs" directory in the NDK3.2 directory contains a lot of in-depth information on the various system library calls.
- The "Examples" directory in the NDK3.2 directory.
- The Amiga Developer Docs at amigadev.elowar.com.
- The coders section on the English Amiga Board at eab.abime.net.
(dr)
[Meldung: 05. Okt. 2023, 20:49] [Kommentare: 10 - 07. Okt. 2023, 19:09]
[Per E-Mail versenden] [Druck-Version] [ASCII-Version]
|
04.Okt.2023
|
Veranstaltung: Letzte Informationen zur Amiga38
Diesen Freitag öffnet die diesjährige Amiga38 ihre Pforten. Markus Tillmann hat die wichtigsten Informationen für uns nochmal zusammengefasst und freut sich mit allen Beteiligten und Gästen auf eine spannende Veranstaltung:
"Eins vorweg: auch wenn dieses Jahr wieder viele namhafte Amigapersönlichkeiten und -entwickler der Einladung zur Amiga38 gefolgt sind, so lebt sie natürlich auch von den vielen Enthusiasten, Einzelkämpfern und Hobbyprogrammierern. Stellvertretend sei hier Christian 'TheoTheoderich' Wiegel genannt, der unermüdlich an seinem Spiel Settle the World arbeitet, um es angemessen auf der Amiga38 präsentieren zu können. Man darf sich auf einige solcher Projekte freuen.
Aber natürlich gibt es auch ein paar Highlights: interessant wird mit Sicherheit der Vortrag des AmigaOS Dev Teams gekrönt von der Präsentation von Camilla Boemann - unter anderem IDE Codecraft - werden. Ebenso wird die frühere Commodore-Angestellte Beth Richards zu Gast sein. Nico Barbat wird die die ehemaligen Zeitschriftenredakteure Hans Ippisch und Horst Brandl interviewen, genauso wie Richard Löwenstein, der sein neues Spiel Reshoot Proxima 3 vorstellen wird.
Aber es gibt auch noch 1-2 Überraschungen, auf die ich mich ebenfalls sehr freue, die ich aber noch nicht verrate.
Anbei der letzte Stand des Raumplans:
- A1 Backup Amiga38
- A2 Wavem Studios
- A3 - A7 APC&TCP / Amiga Future
- A8 - A9 Virtual Dimension
- B1 – B6 Marvin Droogsma / Retro8BitShop.com
- C1 David Pleasance
- C2 – C3 Look behind you
- C4 – C6 Alinea Computer
- D1 – D8 AAA Technology (Amedia Computer, AmigaKit, A-Eon)
- E1 Jan Stermann
- E2 Sascha Müller
- E3 Lavago
- E4 Aged Code Studio
- E5 HunoPPC
- E6 Richard Löwenstein
- F1 – F3 A1200.net
- F4 – F5 TheoTheoderich
- F6 – F7 Holger Weßling
- F8 – F9 Commotron
- F10 Arkadiusz Kwasny
- G1 – G2 A-Cube Systems
- G3 – G5 Factor 5
- G6 AmiWorx
- G7 AmiKit.Amiga.SK
- G8 – G9 GoldenCode
- H1 – H2 Imica / Stephen Jones
- H3 MorphOS Team
- H4 – H5 Logical Byte
- H6 Media-X
- I1 – I2 Wolfsoft
- I3 Sebastian Eggermont
- I4 Berlin.Creators e.V.
- I5 – I6 Relec
- J1 – J10 Amiga User
- K1 – K2 Free Tables / Commodore Alumni Meeting Point
- L0 Return Magazin (plus 3 stations)
- L1 – L2 Christian Bierwirth
- L3 – L4 Andy Brenner (MiSTer FPGA / Amiga Germany Fanzine)
- M1 – M2 ConsoleKabels.be
- M3 Amitopia / AmiDev Team
- M4 – M5 HomeComputerMuseum
- M6 AUGS
- N1 - N3 Poly.Play
- N4 – N5 AmigaOS Dev Team
- N6, N9 PiStorm Emu68 Team
- N7 – N8 Paul Bloemen
- N10 Micha Schneider
- O1 – O3 Individual Computers
- P1 – P4 Apollo Computer – Coding and V4 Testing Area
- P5 – P10 Apollo Computer
- P11 Hyperion Entertainment
Ansonsten dürfen sich die Besucher auf die bekannten Programmpunkte am Samstag freuen: Bühnenprogramm, Ausstellung, Verkauf, Verlosung, Verleihung des Community Awards - alles wieder dabei. Hier das Programm in der Übersicht:
 |
 |
Die Amiga38 ist übrigens ausverkauft. Wer dennoch das Geschehen verfolgen möchte:
- der YouTube-Kanal TheShadowsNose bietet einen live-Stream
- auf ihrem Twitch-Kanal überträgt BBSindex am Freitag um 20:45 Uhr die "Reshoot Proxima 3"-Release-Party und am Samstag um 10:55 Uhr einen Vortrag von Michal Schulz zu PiStorm und ab 13:15 Uhr die Interviewrunde mit Nico Barbat. Grundsätzlich versucht man aber, alle zu übertragen.
Wir haben noch ein kleines Ticket-Kontingent für die Tageskasse zurückgehalten, Spontanentschlossene können also auch hier noch zuschlagen. Zu beachten ist, dass vor Ort Getränke und Speisen nur mit Karten bezahlt werden können. Außerdem findet am Freitagabend das Fußballspiel Borussia Mönchengladbach gegen Mainz 05 statt, d.h. ab ca. 17:00 Uhr ist in Mönchengladbach mit erhöhtem Verkehrsaufkommen zu rechnen." (dr)
[Meldung: 04. Okt. 2023, 21:20] [Kommentare: 14 - 08. Okt. 2023, 19:59]
[Per E-Mail versenden] [Druck-Version] [ASCII-Version]
|
04.Okt.2023
|
Chat-Software: AmigaGPT V1.2.0
Cameron Armstrong hat mit AmigaGPT ein Chatprogramm für AmigaOS 3.2 geschrieben, das die Leistungsfähigkeit des Chatbots ChatGPT nutzt (amiga-news.de berichtete). Die neue Version 1.2.0 sollte nun auch unter AmigaOS 3.9 laufen.
Direkter Download: AmigaGPT.lha (207 KB)
(dr)
[Meldung: 04. Okt. 2023, 18:52] [Kommentare: 0]
[Per E-Mail versenden] [Druck-Version] [ASCII-Version]
|
04.Okt.2023
ANF
|
Veranstaltung: Gameday#2 im Hallenbad Wolfsburg
Nach der Premiere im März, an der einem Video zufolge auch der Amiga im Retrobereich vertreten war, findet am 22. Oktober der Gameday#2 im Hallenbad Wolfsburg statt. Der Retrobereich ist bereits ab 10 Uhr geöffnet.
Wer seinen eigenen Rechner im Retrobereich ausstellen möchte, nimmt bitte unter bloekchen@gmx.de mit dem Organisator Kontakt auf.
(snx)
[Meldung: 04. Okt. 2023, 12:53] [Kommentare: 0]
[Per E-Mail versenden] [Druck-Version] [ASCII-Version]
|
04.Okt.2023
Amigaworld.net (Forum)
|
AmigaOS 4: Touch Device 0.12
Das Touch Device ermöglicht es unter AmigaOS 4.1, auch die Berührfunktion von Touchscreens zu nutzen - eine Liste unterstützter Modelle finden Sie unter dem Titellink. Portierungen für MorphOS und AROS sind geplant.
Die Version 0.12 enthält nun erstmals auch einen HID-Touch-Treiber, mit dem die meisten modernen Touchscreens genutzt werden können sollen. (snx)
[Meldung: 04. Okt. 2023, 12:40] [Kommentare: 1 - 04. Okt. 2023, 21:42]
[Per E-Mail versenden] [Druck-Version] [ASCII-Version]
|
03.Okt.2023
|
Vorstellung: Das AMOS-Spiel "The Gate" (in Entwicklung)
Schon seit längerer Zeit berichten wir über Fabio 'Allanon' Falcuccis Projekte wie das Hollywood-GUI-System HGUI oder das Hollywood-Dienstprogramm APPBuilder. Nach G.E.M.Z. widmet sich der Programmierer nun erneut einem Spiel, dem er den vorläufigen Namen "The Gate" gegeben hat und mit AMOS Professional und AMCAF & Turbo Erweiterungen geschrieben wird. Wir haben Fabio gebeten, etwas über sich, seine Entwicklungsgeschichte und die des neuen Action-Adventures zu schreiben. Herzlichen Dank, Fabio!
"Ich bin mit dem Commodore 64 aufgewachsen, dem mächtigen C64! Dieser magische Kasten ist dafür verantwortlich, mir die Welt des Programmierens eröffnet zu haben, zuerst mit seinem eingebetteten Basic, und dann mit dem unglaublichen Simon's Basic, und ich muss sagen, dass es ein Segen für mein Leben war :)
Ich erinnere mich noch daran, als es passierte: Ich spielte ein Spiel und nach einer Weile stürzte das Spiel ab und meldete einen Zeilennummernfehler, also listete ich das Programm auf und sah all diese erstaunlichen Befehle! Was ich also tat, war, das Spiel zu laden, es zum Absturz zu bringen und Simon's Basic zu benutzen, um meine eigenen Programme zu erstellen :D
Zu dieser Zeit gab es noch kein Internet, man musste raten und denken, um etwas zu lernen, oder Zeitschriften kaufen!
Während ich mit dem C64 und später mit einem Amiga 500 Spaß hatte, habe ich auch die dunkle Seite in der Schule kennengelernt, wo wir einen Olivetti M24 hatten, mit dem wir mit GW-Basic programmierten. Aber der Amiga war von einem anderen Planeten, ich stehe in der Schuld des Amiga 500, weil er meine Kreativität entfesselt hat, und ich bin jetzt, was ich bin, wegen dieser wunderbaren Maschine: Ich fing an, ernsthaft darauf zu programmieren, lernte Assembler, fing an, logisch zu denken, komponierte mehrere Stücke mit jeder damals verfügbaren Musiksoftware und ich lernte so viel, dass es unmöglich ist, hier alles aufzuzählen.
Der letzte Schritt auf dem Commodore-Abenteuer war das Upgrade auf einen Amiga 1200 (den ich immer noch habe und liebe), und zusammen mit dem Amiga 500 hat er mein Leben für immer geprägt, als ich anfing, mit AMOS und BlitzBasic ernsthaft zu programmieren.
Die Zeit verging, und ich kaufte einen PC, und dann noch einen, und dann noch einen... während der Amiga 1200 mich beobachtete, ohne ein Wort zu sagen :)
Nach der Schule arbeitete ich als Buchhalter, da mein Schulabschluss "Programmierer-Buchhalter" war, aber ein Buchhalter zu sein ist soooo langweilig! Ich erstellte viele VBA (Visual Basic)-Programme für die Firmen, für die ich arbeitete und lernte moderne Programmierkonzepte wie OOP (objektorientierte Programmierung).
Für eine kurze Zeit versuchte ich mich in der Amiga NG Welt und kaufte einen SAM440ep... nun, ich war völlig verwirrt von diesem Produkt, ich fühlte mich nicht zu Hause, und mein Amiga 1200 stand immer noch da, starrte mich an und wartete auf meine Rückkehr. Nach ein paar Jahren verkaufte ich den SAM und konzentrierte meine ganze Aufmerksamkeit auf die Emulation mit WinUAE, als ein weiterer Funke in meinem Kopf zündete: Hollywood von Andreas Falkenhahn.
Ich werde nicht beschreiben, wie gut Hollywood ist und wie viele Funktionen es hat, stattdessen werde ich nur sagen, dass ich mich damit zu Hause fühlte, da ich, als ich es entdeckte, ernsthaft mit LUA programmierte (Hollywood basiert auf LUA und hat viele Ähnlichkeiten mit ihm).
Ich habe angefangen, mit Hollywood zu programmieren und habe schließlich sehr große Projekte wie HGui (ein fast komplettes GUI-Toolkit, das komplett in Hollywood geschrieben wurde, ohne irgendein Plugin) und mehrere Bibliotheken, einfache Hollywood-Includes, auf meinem GitHub veröffentlicht.
Jetzt bin ich freiberuflicher Programmierer und benutze Hollywood immer noch für einige Aufträge, da diese erstaunliche Sprache für fast jeden Rechner der Welt kompiliert werden kann.
Aber irgendetwas fehlte noch: Da Hollywood für alte Amigas keine brauchbare Option ist, experimentierte ich mit verschiedenen Sprachen und landete bei AMOS Pro, meiner ersten Liebe :)
Ich habe angefangen, mich daran zu erinnern und damit zu experimentieren, und ein paar Ideen für mögliche Spiele waren geboren. Ich wollte schon immer etwas Gutes für den Computer schaffen, der mein Leben geprägt hat, also habe ich wieder angefangen, mit AMOS Pro zu programmieren.
Das Projekt, an dem ich in diesen Tagen arbeite, heißt "The Gate" (vorläufiger Name) und ich versuche, eine Mischung aus "Impossible Mission" und "Project Firestart" mit meinen eigenen Ideen und Konzepten zu schaffen, mit (zumindest für mich) schönen Ergebnissen.
Ich habe mich aus Zeitgründen für AMOS Pro und nicht für Blitz entschieden. Ich habe versucht, mich an Blitz zu erinnern, aber, nun ja, die Erinnerungen an AMOS waren in meinem Kopf noch lebendig :)
Wir sind uns alle bewusst, dass Blitz schneller ist, aber viel komplexer als AMOS, aber AMOS Pro hat einen vertrauteren Editor und es gibt keine zeitkritischen Anforderungen für die Projekte, die ich erstellen möchte, also war AMOS eine gute Wahl für mich.
Zur Zeit füge ich Features hinzu und versuche, den Code so weit wie möglich zu optimieren. Ich versuche, den Standard-Amiga 1200 anzustreben, aber ich experimentiere noch, weil ich wissen muss, wie weit ich mit der Logik gehen kann: Ich bin noch zu sehr mit modernen Programmiersprachen und ohne CPU-Beschränkungen vertraut, aber bei diesem Projekt zählt jeder einzelne CPU-Zyklus!
Hier ist eine kurze Beschreibung der Hauptidee:
Der Spieler ist ein Detektiv, der in einem riesigen Gebäude ermittelt. Das Gebäude besteht aus Abschnitten, die durch Türen miteinander verbunden sind. In jedem Abschnitt gibt es Räume, in denen man Hinweise zu seinen Ermittlungen finden kann: Gegenstände, Terminals, mit denen man interagieren kann und natürlich Feinde und vom Computer gesteuert Charaktere, mit denen man sprechen kann.
Der Spieler steuert die Hauptfigur mit der Tastatur und der Maus. Mit der Tastatur kann man sich um die Hauptfigur herum bewegen (W-A-S-D-Tasten) und springen, er kann auch Aktionen (Leertaste) durchführen, indem er ein spezielles Aktionsmenü benutzt.
Mit der Maus kann man zielen und schießen (linke Maustaste) und/oder einen sekundären Gegenstand benutzen (rechte Maustaste). Die Steuerung über die Tastatur ist konfigurierbar.
Ich habe vor, die Abschnitte so zu gestalten, dass Veränderungen vom Spieler bestehen bleiben: wenn man in die Wände schießt, bleiben die Einschusslöcher erhalten, wenn man ein Möbelstück zerstört, bleibt es auch erhalten, wenn man die Karte erneut betritt, und so weiter.
Ich habe so viele Ideen, aber wie ich schon sagte, muss ich genau bestimmen, wie weit ich gehen kann :)
Technisch gesehen verwende ich große Bilder für die Abschnitte. Das Bild, das ich zum Testen verwende, hat eine Größe von 960x600 Pixeln und das Scrollen wird durch Hardware-Offsets erreicht, da die CPU-Kosten fast null sind.
Ich habe versucht, Kacheln zu verwenden, aber nachdem ich einen sehr flüssigen multidirektionalen Bildlauf erreicht hatte, hatte ich Probleme mit all den Dingen, die ich implementieren wollte, also habe ich den Weg gewählt, der mehr Speicherplatz und weniger Rechenleistung beansprucht.
Die Grafik für den Hauptabschnittsbildschirm ist im 64-Farben-EHB-Modus, LowRes und ich haben eine Palette erstellt, die darauf ausgelegt ist, Spezialeffekte wie Abdunkeln und Aufhellen zu verwenden, und ich will ganz ehrlich sein: Ich habe einen großen Motivationsschub von den Videos bekommen, die BitBeamCannon veröffentlicht hat, in denen sie einige fortgeschrittene Techniken erklärt haben, die sie beim Prototyping ihres neuen Spiels "Daemon Claw" auf dem Amiga verwendet haben.
Im Moment scheinen die Ergebnisse vielversprechend zu sein, der letzte Test, den ich mit dem oben erwähnten Abschnitt gemacht habe, hatte den Spieler (der bereits in der Lage ist, sich zu bewegen, zu schießen und zu springen), voll funktionierende Kollisionen mit den Wänden und 5 animierte Türen (alle von ihnen sind animiert, natürlich während des Öffnens/Schließens, aber auch wenn sie geschlossen oder geöffnet sind).
Das Action-Menü wurde implementiert und die Hauptfigur kann nun mit Türen interagieren.
Die Grafiken sind nicht von mir, sondern ich habe einige Assets von itch.io gekauft und ich werde den Autoren Anerkennung zollen, wenn das Projekt fertiggestellt ist, ich habe nur die Farben angepasst und einige Frames nach meinem persönlichen Geschmack verändert :)
Ich werde den Soundtrack machen, das ist sicher :P
Um diesen langen Text zu beenden, hier die größten Hindernisse, auf die ich gestoßen bin, als ich beschlossen habe, diese Projekte zu starten:
- Da ich so viel OOP vermisse, war das Arbeiten mit Arrays anstelle von Objekten zu Beginn dieses Abenteuers ein Albtraum.
- Der Versuch, sich daran zu erinnern, wie man flüssiges Scrolling und Animationen erstellt
- Versuchen herauszufinden, wie die in AMOS integrierte Animationssprache AMAL funktioniert
Nun, da meine Erinnerungen wieder da sind und ich einige Handbücher aus dem Internet zusammensuchen konnte, kann ich mich daran machen, zu sehen, wie dieses Abenteuer enden wird."
Einen Eindruck vom aktuellen Stand des Spiels kann man sich durch ein kleines Video verschaffen, das der Autor einem seiner letzten Mastodon-Posts beigefügt hat.
Auf seiner Patreon-Seite hat man die Möglichkeit, den Autor zu unterstützen und sich für vergangene und zukünftige Projekte zu bedanken. (dr)
[Meldung: 03. Okt. 2023, 15:25] [Kommentare: 0]
[Per E-Mail versenden] [Druck-Version] [ASCII-Version]
|
03.Okt.2023
|
Veranstaltung: Amiga Ireland 2024
Am 19./20. Januar 2024 findet die nächste Amiga Ireland statt. Ort für das Treffen, an dem regelmäßig auch prominentere Mitglieder der Amiga-Gemeinde teilnehmen, ist wie gewohnt das Sheraton-Hotel der im Herzen der Insel gelegenen Stadt Athlone. Eintrittskarten können unter dem Titellink bereits erworben werden. Die kommende Amiga Ireland soll hinsichtlich des Zeitplans wesentlich entspannter werden: so wird es weder ein "offizielles" Essen, noch einen Hauptgast geben. So soll mehr Zeit für Workshops und Spiele bleiben. (dr)
[Meldung: 03. Okt. 2023, 07:05] [Kommentare: 0]
[Per E-Mail versenden] [Druck-Version] [ASCII-Version]
|
02.Okt.2023
|
Vorstellung: Forschungsprojekt "CH LUDENS"
"Confoederatio Ludens", kurz "CH LUDENS", ist ein im Februar 2023 begonnenes, gemeinsames Projekt der beiden Universitäten Bern und der Universitäten von Lausanne und Zürich und soll bis 2027 die Schweizer Spielekultur im Zeitraum von 1969 bis 2000 erforschen.
Der Name des Projektes ist angelehnt an den latenischen Namen der Schweiz, Confoederatio Helvetica, wobei Helvetica durch das latenischen Worte für "spielen", ludere, bzw. dessen Partizip-Präsens-Aktiv-Form, ludens, ersetzt wurde: Konföderation der Spielenden.
Unter anderem soll die These untersucht werden, dass neuen Technologien immer auch durch spielerische Ansätze begegnet wird und es ziemlich sicher viel mehr Spiele und Spielekultur rund um die Einführung der Digitalität gibt, als uns bewusst und bekannt ist. Diese wurden jedoch oft als Kinder- oder Hobbykram abgetan.
Während Jahrzehnten wurden in der Schweiz digitale Spiele in Nischen programmiert, aber auch mit kommerziellem Erfolg. Sie zeugen von vielen Sub-Szenen und einer sich durch die Digitalisierung verändernden Gesellschaft.
Das Team der Confoederatio Ludens erforscht diese weitgehend unbeachtete Spieleindustrie und unternimmt einen Schritt zur breiteren Bewahrung eines höchst flüchtigen und verschwindenden kulturellen Erbes.
Ein bereits bestehendes Projekt hat dafür bereits einige Vorarbeit geleistet: Swiss Games Garden hat es sich zur Aufgabe gemacht, alle aus der Schweiz stammenden Computerspiele aufzulisten. Den Amiga betreffend dürfte eines der bekanntesten Spiele sicher Traps'n'Treasures sein.
Nun hat sich Adrian Demleitner, Mitglied der Forschungsgruppe, am Beispiel des Amigas Gedanken in einem Blogeintrag gemacht, wie man mit Videospielen auf Disketten als Forschungsmaterial umgehen soll. Dazu hatte er sich, wie er auf Mastodon schreibt, zunächst ein komplettes Amiga-500-Set besorgt, inklusive einiger gängiger Joysticks, einer Maus, einem Commodore 1084 Monitor und Dutzenden von Disketten besorgt. In gewissem Sinne schloss sich für Adrian damit der Kreis, da er mit einem Amiga 500 aufgewachsen war.
In seinem Dossier wirft er unter anderem die Frage auf, wie man ein z.B. in den 90er Jahren veröffentlichtes Spiel heute authentisch spielt. Denn nicht nur das Spiel selbst, sondern auch die Spielumgebung trägt zum Gesamterlebnis bei: ist es wichtig, das Spiel mit dem ursprünglichen Joystick zu spielen? Ist es akzeptabel, das Spiel zeit- und ressourceneffizient auf einem Emulator laufen zu lassen und es über ein 3,5-Zoll-Display anzuzeigen? Welche Rolle spielte die Materialität der Original-Hardware, einschließlich der Geräusche, die sie produzierte, für das Spielerlebnis? (dr)
[Meldung: 02. Okt. 2023, 09:50] [Kommentare: 7 - 04. Okt. 2023, 23:42]
[Per E-Mail versenden] [Druck-Version] [ASCII-Version]
|
02.Okt.2023
|
Chiptune-Tracker: Furnace V0.6 für Windows, Mac und Linux
Eineinhalb Jahre nach der letzten Veröffentlichung steht eine neue Version von Furnace zur Verfügung: einem Tool, mit dem Soundchips-Musik ("Chiptune"), meist aus der 8/16-Bit-Ära, erstellt werden kann. Es unterstützt eine große Auswahl an Funktionen und Soundchips, von NES, SNES und Genesis bis hin zu ES5506, VC-20 und natürlich dem Amiga.
Jeder Chip wird mit vielen Emulationskernen emuliert, daher ist der Sound, den Furnace erzeugt, authentisch zu dem der echten Hardware. Eine englischsprachige Anleitung steht zur Verfügung. (dr)
[Meldung: 02. Okt. 2023, 08:49] [Kommentare: 3 - 03. Okt. 2023, 23:06]
[Per E-Mail versenden] [Druck-Version] [ASCII-Version]
|
01.Okt.2023
Amiga.org (Forum)
|
AmigaOS 4: Blog-Zusammenfassung des Monats September (englisch)
Auch für den September hat 'Puni' unter dem Titellink wieder eine Zusammenfassung der Neuerungen aus den Bereichen Hard- und Software für AmigaOS 4 auf englisch veröffentlicht. (snx)
[Meldung: 01. Okt. 2023, 19:06] [Kommentare: 13 - 03. Okt. 2023, 16:26]
[Per E-Mail versenden] [Druck-Version] [ASCII-Version]
|
01.Okt.2023
Frank Wille (ANF)
|
Entwicklerwerkzeug: vasm 1.9e
Frank Wille hat ein Update für den modularen Assembler vasm veröffentlicht.
Changes:
- Exit before reading the source (from stdin) when there were errors already.
- Make sure the relocated blocks within all sections are closed after parsing. Otherwise the first pass may find the section in a wrong state.
- Output modules may define the default section, when no SECTION or ORG directive was given. "bin", "ihex" and "srec" now default to "ORG 0".
- New output module "woz", which outputs sections as "wozmon" monitor commands, suitable for ASCII transfer via a serial connection. Contributed by anomie-p.
- m68k: Improved -opt-movem (OPT om+) optimizations, for MOVEM with two registers.
- m68k: Fixed Apollo ADD/SUB->ADDQ/SUBQ optimization with AMMX registers.
- m68k: Enabled Apollo FPU instructions using 64-bit data registers: Fxxx.D Dn,ea, FMOVE.D Fn,Dm, etc.
- m68k: Added missing PC-relative destination addressing modes for Apollo shift instructions and FMOVE, FMOVEM.
- m68k: Apollo bchg/bclr/bset/btst Dn,An must not be allowed (conflicts with MOVEP).
- m68k: New Apollo instructions FDBcc.L, DBcc En,lab; EXTUB.L and EXTUW.L.
- 6809: Fixed typo in the opcode for the 6309 LDMD instruction.
- mot-syntax: Allow multiple consecutive relocated blocks within a section.
- mot-syntax: New directives LOCAL and RSEVEN for compatibility.
- mot-syntax: Allow any type of expression for RSSET, SETSO, SETFO.
- madmac-syntax: Allow multiple consecutive relocated blocks within a section.
- oldstyle-syntax: The label defining the size of a STRUCT block may have been moved into the previous section, or caused a segfault at ENDSTRUCT, since V1.9b.
- tos-output: Also write absolute symbols (equates) into executables.
- tos-output: New option -szbx to enable unlimited symbol names using the SozobonX extension.
- bin-output: New option -start to define the start address for the default org-section.
(snx)
[Meldung: 01. Okt. 2023, 19:01] [Kommentare: 0]
[Per E-Mail versenden] [Druck-Version] [ASCII-Version]
|
01.Okt.2023
|
Aminet-Uploads bis 30.09.2023
Die folgenden Pakete wurden bis zum 30.09.2023 dem Aminet hinzugefügt:
TGD-MrRobot2023.lha demo/aga 1.1M 68k Mr Robot by The Gentlemen Dem...
MCE.lha game/edit 3.7M 68k Multi-game Character Editor
MCE-OS4.lha game/edit 4.2M OS4 Multi-game Character Editor
AmiArcadia.lha misc/emu 5.0M 68k Signetics-based machines emul...
AmiArcadiaMOS.lha misc/emu 5.3M MOS Signetics-based machines emul...
AmiArcadia-OS4.lha misc/emu 5.5M OS4 Signetics-based machines emul...
Sunshine.lha mods/misc 411K Sunshine 16bit 4ch Reggea R&B...
deark.lha util/arc 4.0M 68k Extracting data from various ...
ModelerConverter10.lha util/conv 10K 68k 3D Object Converter from 1991
PDF2JPG.lha util/conv 16M MOS convert PDF to JPG
PDF2PDF.lha util/conv 15M MOS convert PDF to PDF
listercompare.module.lha util/dopus 17K 68k DOpus Magellan II: Compare li...
Turkish_Packs.lha util/wb 123K Turkish Catalog packs some ap...
(snx)
[Meldung: 01. Okt. 2023, 07:28] [Kommentare: 0]
[Per E-Mail versenden] [Druck-Version] [ASCII-Version]
|
01.Okt.2023
|
OS4Depot-Uploads bis 30.09.2023
Die folgenden Pakete wurden bis zum 30.09.2023 dem OS4Depot hinzugefügt:
nallepuh.lha aud/mis 411kb 4.1 NallePUH (Paula emulation) for O...
touchdevice.lha dri/inp 216kb 4.1 Device API for touch devices
amiarcadia.lha emu/gam 5Mb 4.0 Signetics-based machines emulator
soniccd-rsdk.lha gam/pla 10Mb 4.1 A Full Decompilation of Sonic CD...
mce.lha gam/uti 4Mb 4.0 Multi-game Character Editor
avalanche.lha uti/arc 115kb 4.1 Simple ReAction GUI for xadmaster
touchbench.lha uti/mis 59kb 4.1 Mouse emulator for touchscreens
(snx)
[Meldung: 01. Okt. 2023, 07:28] [Kommentare: 0]
[Per E-Mail versenden] [Druck-Version] [ASCII-Version]
|
01.Okt.2023
|
AROS-Archives-Uploads bis 30.09.2023
Die folgenden Pakete wurden bis zum 30.09.2023 den AROS-Archiven hinzugefügt:
lilcalendar.i386-aros.lha uti/wor 3Mb Calender scheduling and reminder...
(snx)
[Meldung: 01. Okt. 2023, 07:28] [Kommentare: 0]
[Per E-Mail versenden] [Druck-Version] [ASCII-Version]
|
01.Okt.2023
|
MorphOS-Storage-Uploads bis 30.09.2023
Die folgenden Pakete wurden bis zum 30.09.2023 dem MorphOS-Storage hinzugefügt:
GPSTool_1.0.lha Devices/GPS A GPS tool by by Marcus...
AmiArcadia_30.30.lha Emulation A Signetics-based machi...
Deark_1.6.5.lha Files/Archive Extracting data from va...
listercompare.module_1... Files/Manager Dopus Magellan II: Comp...
Easy2Install_1.0b37.lha Network/PackageManager A package manager to do...
LilCalendar_2.7.lha Office/Organizer Versatile calender and ...
(snx)
[Meldung: 01. Okt. 2023, 07:28] [Kommentare: 0]
[Per E-Mail versenden] [Druck-Version] [ASCII-Version]
|
01.Okt.2023
|
WHDLoad: Neue Pakete bis 30.09.2023
Mit WHDLoad können Spiele, Szene-Demos und Intros von Cracker-Gruppen, die nur für den Diskettenbetrieb gedacht waren, auf der Festplatte installiert werden. Die folgenden Installationspakete wurden bis zum 30.09.2023 hinzugefügt:
- 2023-09-24 improved: Bismarck (PSS) german version supported (Info)
(snx)
[Meldung: 01. Okt. 2023, 07:28] [Kommentare: 0]
[Per E-Mail versenden] [Druck-Version] [ASCII-Version]
|
01.Okt.2023
Amiga Future (Webseite)
|
AmigaRemix: Weitere Lieder hinzugefügt
AmigaRemix stellt neue Abmischungen bekannter Soundtracks von Amiga-Spielen als MP3-Dateien zum Herunterladen bereit. Seit unserer letzten Meldung kamen folgende Titel hinzu:
- Scumm Bar Theme Live Performance
- The Great Bath Live Performance
- Details Shadow of the Beast (Plains 1)
(snx)
[Meldung: 01. Okt. 2023, 07:28] [Kommentare: 0]
[Per E-Mail versenden] [Druck-Version] [ASCII-Version]
|
30.Sep.2023
Amigans (Forum)
|
AmigaOS 4: libegl_wrap 0.7.21 (Beta)
Hugues 'HunoPPC' Nouvel arbeitet an einem EGL-OpenGL-Wrapper, der auf die von A-EON-Vertriebene Warp 3D Nova/OpenGL-ES-Kombination aufsetzt und die Portierung von modernen OpenGL-basierten Spielen vereinfachen bzw. ermöglichen soll (Youtube-Video-Beispiel für Prey 2006).
Die neue Betaversion 0.7.21, die von zukünftigen Spiele-Portierungen durch Nouvel vorausgesetzt werden wird, bietet folgende Änderungen:
- Fixed!! ENV: gl4es prefs after quit EGL_Wrap
- Fixed!! delete GL renderer on quit native opengl
- Recompiled all samples
- Added version on SDL2egl_library
- Added new functions on intenal lib GLEW renderer
(dr)
[Meldung: 30. Sep. 2023, 21:30] [Kommentare: 1 - 01. Okt. 2023, 20:52]
[Per E-Mail versenden] [Druck-Version] [ASCII-Version]
|
30.Sep.2023
'Sosi' im Amiga-News-Kommentarbereich
|
Ankündigung: Workbench-Distribution AmiKit für PiStorm/PiStorm-lite
Neben den bereits vorhandenen Versionen für Raspberry Pi, Windows, Mac und Linux wird es demnächst die Workbench-Distributionen AmiKit auch für den PiStorm bzw. PiStorm-lite geben (YouTube-Video). Unter dem Titellink sind bereits die Hard- und Softwareanforderungen einsehbar.
Wie uns der Entwickler schildert, hätte nach fast einem Jahr harter Arbeit AmiKit für PiStorm Goldstatus erreicht und wird auf der Amiga38-Veranstaltung zum Kauf erhältlich sein.
Das physische Produkt wird vorinstalliert mit einer 32GB oder 64GB microSD-Karte in einem sehr speziellen Markenetui geliefert. Nur eine begrenzte Anzahl von Einheiten wird auf der Amiga38 erhältlich sein.
Die Website wird noch am selben Tag - dem 7. Oktober - freigeschaltet, Online-Bestellungen werden nur wenige Tage später möglich sein. Auch die Stückzahl wird begrenzt sein. Der Preis liegt bei 39,95 ¤ für die 32-GB-Version und 49,95 ¤ für die 64-GB-Version. (dr)
[Meldung: 30. Sep. 2023, 20:29] [Kommentare: 0]
[Per E-Mail versenden] [Druck-Version] [ASCII-Version]
|
30.Sep.2023
|
Plattformer: Amiga-Port von Electro Man
Paweł 'tukinem' Tukatsch - unter anderem Plattformer Tony - ist dabei, das ursprünglich 1992 von den polnischen Programmierern Maciej Msik und Janusz Pelc für MS-DOS veröffentlichte Spiel Electro Man für AGA-Amigas zu portieren (YouTube-Video). FastRam ist nicht zwingend erforderlich, aber zu empfehlen. Joystick oder Tastatur können verwendet werden. Bislang hat das Spiel nur 2 Level, aber die zweite Ebene ist nach Angaben des Entwicklers sehr schwierig. (dr)
[Meldung: 30. Sep. 2023, 12:18] [Kommentare: 3 - 04. Okt. 2023, 18:56]
[Per E-Mail versenden] [Druck-Version] [ASCII-Version]
|
29.Sep.2023
Yawning Angel (E-Mail)
|
Video-Tutorial: Erweiterte Menüfunktionen in AMOS
In einem weiteren Teil seiner Reihe von Kurztutorials über AMOS Pro schaut sich Retro- und Amigafan 'Yawning Angel' einige der erweiterten Menüfunktionen in AMOS an und führt damit ein Videotutorial aus dem letzten Jahr fort. Die Quelldateien für das Programm in diesem Video können kostenlos von seiner Webseite heruntergeladen werden. (dr)
[Meldung: 29. Sep. 2023, 06:28] [Kommentare: 0]
[Per E-Mail versenden] [Druck-Version] [ASCII-Version]
|
29.Sep.2023
|
Veranstaltung: Ausstellungskatalog zur Classic Computing 2023
Vom heutigen Freitag bis Sonntag veranstaltet der Verein zum Erhalt klassischer Computer e.V. die Classic Computing 2023, eine der größten Retrocomputer-Veranstaltungen in Deutschland, in Dietzenbach (Hessen) (amiga-news.de berichtete). Dazu gibt es nun einen detaillierten Ausstellungskatalog, der einen Lageplan und die Beschreibung einzelner Exponate enthält, so auch für einen Amiga 3000T. (dr)
[Meldung: 29. Sep. 2023, 06:22] [Kommentare: 1 - 03. Okt. 2023, 06:06]
[Per E-Mail versenden] [Druck-Version] [ASCII-Version]
|
| |
| Aktuelle Diskussionen |
 |
|
|
|
| Letzte Top-News |
|
|
|
|
| amiga-news.de |
|
|
|
|
| |
|
|
