amiga-news ENGLISH VERSION
.
Links| Forum| Kommentare| News melden
.
Chat| Umfragen| Newsticker| Archiv
.

amiga-news.de Forum > Amiga, AmigaOS 4 > AOS3/AROS Monkey Target [ - Suche - Neue Beiträge - Registrieren - Login - ]

-1- 2 [ - Beitrag schreiben - ]

01.12.2011, 20:39 Uhr

bruZard
Posts: 307
Nutzer
Neues Update
Bild: http://www.sedm.de/monkey/AmigaTarget_Draw.jpg
Der Monkey Code zum Bild:
code:
Strict

Import amigaos3

Function Main:Int()	
	Local win:Window = CreateWindow("Hallo Amiga", 100, 100, 600, 400)
	Local mx:Int		= 0
	Local my:Int		= 0
		
	Cls(win)
	SetColor(win, 255, 0, 0)
	
	Repeat
		WaitEvent(win)
		mx = MouseX(win)
		my = MouseY(win)
		
		If EventClass(win) = CLOSEWINDOW Then Exit
		If MouseDown(win) then Plot(win, mx, my)
	Forever
	
	CloseWindow(win)
	
	Return 0
End

Changelog:
code:
12/01/2011 v0.2
added	: Window.eventClass:Int()
added	: Window.eventCode:Int()
added	: Window.setColor:Void(r:Int, g:Int, b:Int)
added	: Window.getBestPen:Int(r:Int, g:Int, b:Int)
added	: Window.setAPen:Void(pen:Int)
added	: Window.cls:Void()
added	: Window.plot:Void(x:Int, y:Int)
added	: Window.mouseX:Int()
added	: Window.mouseY:Int()
added	: Window.mouseDown:Int()
added	: Window.mouseUp:Int()
added	: EventClass:Int(win:Window)
added	: EventCode:Int(win:Window)
added	: SetColor:Void(win:Window, r:Int, g:Int, b:Int)
added	: GetBestPen:Int(win:Window, r:Int, g:Int, b:Int)
added	: SetAPen:Void(win:Window, pen:Int)
added	: Cls:Void(win:Window)
added	: Plot(win:Window, x:Int, y:Int)
added	: MouseX:Int(win:Window)
added	: MouseY:Int(win:Window)
added	: MouseDown:Int(win:Window)
added	: MouseUp:Int(win:Window)
changed	: renamed Window.IntuiMessage:Int() to Window.WaitEvent:Int()
changed	: renamed GetIntuiMessage:Int() to WaitEvent:Int()
fixed	: windowtitle was not set


Download: http://www.sedm.de/monkey/AmigaTarget.zip
das AOS3 Executable liegt unter /bananas/Amiga/amiga.build/aos3/appAOS3

Viel Spass beim malen :)
--
PanzerZ |
methusalem | basic

[ - Antworten - Zitieren - Direktlink - ]

01.12.2011, 21:28 Uhr

Floppy
Posts: 392
Nutzer
@bruZard:
Das gleiche funktioniert für AROS mit Import aros statt import amigaos3?

[ - Antworten - Zitieren - Direktlink - ]

01.12.2011, 21:44 Uhr

bruZard
Posts: 307
Nutzer
als ich anfing wollte ich eigentlich nur AmigaOS3.x unterstützen, dass AROS dazu kam war Zufall, darum heissen die ganzen Sachen "amigaos3", "aos3" etc.

Für Aros:

Im Monkey-Ordner /bin/ gibt es eine Datei namens winnt.config.txt. Trage dort einfach AROS=1 ein und es werden Binaries für Aros386, ArosPPC und Aros64 erzeugt.

1. Installe AmiDevCpp von http://amidevcpp.amiga-world.de/

2. Ergänze die Windows PATH Variable um den Pfad von [AmiDevCpp]/usr/local/amiga/bin Wie das geht kann man die Jungs von Google fragen. Ein Treffer wäre dieser: http://software4u.de/FAQDetail.aspx?lng=de&id=91

3. Ziehe Dir die Demo (eigentlich keine Demo sondern die Public Domain Version) von Monkey von http://www.monkeycoder.co.nz/file/get.php?file=/Products/demos/MonkeyDemo45c.zip.

4. Entpacke AmigaTarget.zip über das Monkey Verzeichnis

5. ändere die Datei bin/winnt.config.txt wie oben angegeben und starte Monk.

6. Lade das Example "amiga.monkey" aus /bananas/Amiga/ und starte ein Build (Rakete die nach oben zeigt).

7. Kopiere das Build Deiner Wahl (appAros386, appArosPPC, appAros64) aus dem Ordner /bananas/Amiga/amiga.build/aos3/ in Deine Aros Installation und starte es.

8. Freuen


--
PanzerZ |
methusalem | basic

[ - Antworten - Zitieren - Direktlink - ]

01.12.2011, 23:26 Uhr

Floppy
Posts: 392
Nutzer
@bruZard:
Es funktioniert. Cool! Nur mit AROS_x86-64 gibt es noch ein Problem...

code:
Translating amiga
"C:/Program Files/MonkeyDemo45c/bin/trans_winnt" -target=aos3 "C:/Program Files/MonkeyDemo45c/bananas/Amiga/amiga.monkey"

TRANS monkey compiler V1.26
Parsing...
Semanting...
Translating...
Building...
main.cpp: In function 'int calcHex(int, char*, int)':
main.cpp:1270: warning: deprecated conversion from string constant to 'char*'
main.cpp:1271: warning: deprecated conversion from string constant to 'char*'
main.cpp: In function 'int calcHex(int, char*, int)':
main.cpp:1270: warning: deprecated conversion from string constant to 'char*'
main.cpp:1271: warning: deprecated conversion from string constant to 'char*'
main.cpp: In function 'int calcHex(int, char*, int)':
main.cpp:1270: warning: deprecated conversion from string constant to 'char*'
main.cpp:1271: warning: deprecated conversion from string constant to 'char*'
main.cpp: In member function 'void AWindow::create(CString, int, int, int, int)':
main.cpp:1337: error: cast from 'char*' to 'ULONG' loses precision
TRANS Failed to execute 'x86_64-aros-g++ -o appAROS64 main.cpp', return code=1

Process Complete


Jetzt muss ich noch das Executable auf AROS386 testen.

[ - Antworten - Zitieren - Direktlink - ]

02.12.2011, 21:58 Uhr

Floppy
Posts: 392
Nutzer
Es läuft auf Icaros (AROS-386). Fantastisch!
Bild: http://aros-exec.org/modules/xcgal/albums/userpics/10645/normal_pic.jpg

[ Dieser Beitrag wurde von Floppy am 02.12.2011 um 22:06 Uhr geändert. ]

[ - Antworten - Zitieren - Direktlink - ]

02.12.2011, 22:00 Uhr

bruZard
Posts: 307
Nutzer
Version 0.21 ist unter http://www.sedm.de/monkey/AmigaTarget.zip verfügbar.

Geändert hat sich dass ich ein paar Methoden überladen habe. Bislang hat SetColor() noch RGB Werte als Parameter genommen, man kann jetzt auch direkt die Stift Nummer übergeben. Neu hinzugekommen ist die Funktion "ClsColor()", auch diese ist überladen und kann sowohl Werte für Rot, Grün und Blau annehmen als auch eine Stift Nummer.

Der Fehler beim Build für Aros64 ist behoben, so dass jetzt auch AROS 64Bit User Monkey AmigaTarget verwenden können.

Der Versuch Mojo zu implementieren ist bisher fulminant fehlgeschlagen da AOS selbst bei einfachsten Klassen Operationen ohne lesbare Debug-Info ins Nirvana geht. Bin dort aber noch am Ball.

Ein ausführbares AOS3.x Executable für 0.21 liegt dem Archiv bei. Es ändert die Hintergrundfarbe auf ein freundliches Blau und malt mit gedrückter linker Maustaste nette rote Punkte in das erzeugte Fenster.

Das Example kann problemlos für AROS (egal ob i386, x86 oder x64) übersetzt werden.

Die Update Zyklen werden jetzt etwas länger weil ich ums Verrecken mein Mojo Derivat ans Laufen bekommen will. Endziel ist das Übersetzen aller verfügbaren Monkey Codes für AOS/Aros
--
PanzerZ |
methusalem | basic

[ - Antworten - Zitieren - Direktlink - ]

03.12.2011, 22:24 Uhr

Floppy
Posts: 392
Nutzer
@bruZard:
Danke für die Weiterentwicklung!

Leider gibt es für AROSx64 immer noch ein Problem:
code:
language="Translating amiga 
C:/MonkeyDemo/MonkeyDemo45c/bin/trans_winnt -target=aos3 
C:/MonkeyDemo/MonkeyDemo45c/bananas/Amiga/amiga.monkey  

TRANS monkey compiler V1.26 
Parsing... 
Semanting... 
Translating... 
Building... 
main.cpp: In member function 'void AWindow::create(CString, int, int, int, int)': 
main.cpp:1305: error: cast from 'char*' to 'ULONG' loses precision 
TRANS Failed to execute 'x86_64-aros-g++ -o appAROS64 main.cpp', return code=1  

Process Complete"



[ Dieser Beitrag wurde von Floppy am 03.12.2011 um 22:25 Uhr geändert. ]

[ - Antworten - Zitieren - Direktlink - ]

04.12.2011, 21:25 Uhr

bruZard
Posts: 307
Nutzer
Heute gibt es nichts zum downloaden, dafür aber ein Status-Update.

Das Target besitzt nun die Klasse "App". Diese Klasse ist der erste Schritt um dem AmigaTarget beizubringen jeden verfügbaren Monkey Code zu kompilieren. Um das zu erklären muss ich etwas ausholen:

Um mit Monkey ein Spiel schreiben zu können benötigt man das Modul "Mojo". Dieses importiert man einfach via "Import mojo". Nun werden zwei Dinge erwartet:

1. Es muss die Funktion "Main()" existieren. Sie ist der Einsprungpunkt für jedes Monkey-Programm.

2. Es muss eine Klasse existieren die von "App" abgeleitet ist und mindestens folgende Methoden definiert:

- OnCreate()
- OnUpdate()
- OnRender()

In der Funktion "Main()" erzeugt man nun eine neue Instanz dieser Klasse. Es wird dann automatisch die Methode "OnCreate()" aufgerufen. Ist diese Methode abgearbeitet springt Monkey abwechselnd in die Methoden "OnUpdate()" und "OnRender()" und führt den darin enthaltenen Code aus ... für immer.

Für immer?!? Ja, da Monkey für eine Reihe von Zielen kompiliert musste man sich auf den kleinsten gemeinsamen Nenner einigen und das sind Systeme auf denen eine App sich nicht selbst beenden muss, sondern vom System beendet wird: iOS, Android, WindowsPhone, XBox, Flash, HTML5. Das Einzige Ziel für das Mojo eine Abbruchbedingung vorsieht ist GLFW, dort wird die App beendet wenn das Fenster geschlossen wird.

Für das AmigaTarget habe ich die Methode "ExitApp()" implementiert damit der geneigte Programmierer selbst entscheiden kann wann sein Programm beendet wird. Es wird dann der Destructor aufgerufen der alle Libraries schliesst und den Speicher aufräumt.

Ein weiteres Merkmal von Mojo ist dass es dem Programmierer in Monkey nicht gestattet eine Bildschirmauflösung/Farbtiefe zu definieren, dies geschieht über die Templates die jedem Ziel zugeordnet sind. In Android ist es bspw. die "MonkeyApp.xml", unter GLFW muss die "config.h" geändert werden etc.
Damit das Amiga-Target dieses Verhalten nachahmt ruft das Modul automatisch die entsprechende Methode auf und erstellt ein Fenster auf der Workbench in der Grösse 600x400. Das ist notwendig damit die existierenden Monkey-Spiele auch auf dem Amiga kompiliert werden können.
Um zu unterbinden dass das geschieht ruft man den Konstruktor seiner App Klasse mit dem Wert "NOGRAPHICS" auf.
Will man irgendeinen Source kompilieren hat man natürlich das Problem dass der Author nicht wusste dass sein Spiel mal für Amiga kompiliert wird. Das heisst dass es sich nicht beenden lässt. Für diesen Fall habe ich IDCMP_CLOSEWINDOW an ExitApp() gehangen wenn "App" nicht mit "NOGRAPHICS" initialisiert wurde.

Einfach so kompilieren ist aber nicht. Das Problem ist dass ich kein weiteres "Mojo Target" programmieren darf. Ich müsste Mojo in weiten Teilen anpassen und diese Anpassungen mit dem Target mitliefern, das ist aber nicht gestattet. Wer also einen bestehenden Source für Amiga kompilieren will muss diesen leicht ändern. Man schaut einfach in den Kopf des entsprechenden Source und sucht die Zeile "import mojo". Diese ändert man dann in "#if TARGET = "aos3" ; Import amigaos3 ; #else ; Import mojo #endif". Danach kann man den Code dann einfach kompilieren.

Folgendes Bild zeigt ein einfaches Konsolenprogramm welches von 0 - 10 zählt. Links sieht man in welcher Methode die Ausgabe gemacht wurde. Die Steuerung der Methodenaufrufe ist durch das Modul "amigaos3" übernommen.

Bild: http://www.sedm.de/monkey/AmigaTarget_Callbacks.jpg

Hier der Source der die Ausgabe aus obigem Bild erzeugt:
code:
Import amigaos3

Class myApp extends App
	Field time:Int = 0
	
	Method OnCreate()
		Print "OnCreate : Los gehts... wir zählen von 0 - 10 und beenden dann das Programm"
	End
	
	Method OnUpdate()
		Print "OnUpdate : time += 1"
		time+= 1
		
		if time > 10
			Print "OnUpdate : time > 10 ... Ende!"
			ExitApp()
		EndIf
	End
	
	Method OnRender()
		Print "OnRender : time = " + time
	End
End

Function Main()
	New myApp
End


Jetzt müssen alle Funktionen aus Mojo portiert werden. Viele davon werden einfach nichts tun weil sie mit dem Amiga NDK nicht zu realisieren sind, aber es werden genug Funktionen implementiert damit alle Monkey Spiele funktionieren.


P.S.: AROSx64 werde ich mir nochmal zur Brust nehmen.
--
PanzerZ |
methusalem | basic

[ - Antworten - Zitieren - Direktlink - ]

05.12.2011, 21:41 Uhr

bruZard
Posts: 307
Nutzer
Liebes Tagebuch ....

Timing Probleme bewirken gerade dass die ClsColor für alle Pens gesetzt wird. Aber das ist zu lösen. Wichtig ist dass das Framework nun die überladenen Methoden verwendet um wahlweise auf ein selbst erstelltes Fenster oder auf das Standard "Mojo Style" Fenster zu wirken. Monkey daran zu hindern in jedem Fall ein Fenster zu erstellen indem dies per Konstruktor bekannt gemacht hat leider nicht funktioniert, den Konstruktor einer Monkey Klasse die extern geladen wird kann man leider nicht überladen. Ich habe das nun so gelöst dass es im Verzeichnis /modules/amigaos3/ eine Datei namens "config.monkey" gibt mit der das Standard-Verhalten bei einem Build beeinflusst werden kann.
Wenn sich das AmigaTarget nicht wie Mojo verhalten soll muss in der OnCreate Methode "SetGraphicsMode(AMIGA_MODE)" aufgerufen werden. Wird dies getan erstellt das Framework kein eigenes Fenster und somit auch keinen globalen Kontext für nachfolgende Operationen. In diesem Fall sind die Funktionen zu verwenden bei denen man den Paramter win:Window oder scr:Screen angeben muss.
Im einfachsten Fall verwendet man das OOP Interface und wendet die Methoden direkt an:
code:
Local myWin:Window = new Window;
myWin.create("Hello World, 0, 0, 600, 300)
myWin.cls()

Ein normaler Monkey Code wird nun anstandslos kompiliert, läuft logischerweise aber noch nicht da wichtige Funktionen wie "LoadImage", "DrawImage" etc. noch nicht implementiert sind.

Die Funktion "Plot()" heisst nun "DrawPoint()" da Monkey mit der Version 0.5 diesen Namen eingeführt hat. Es existiert aber immer noch die Version aus 0.45 damit wir mit der Demo kompatibel bleiben. So kann mit der Demo alter und aktueller Code übersetzt werden.

Ich baue gerade die Möglichkeit ein eigene TagLists für selbst erzeugte Fenster zu erstellen. Da man die Klasse Window erst erzeugen muss bevor man mittels "create()" tatsächlich ein Fenster erstellt, besteht die Möglichkeit vor dem "create()" die TagList zu ändern. Man kann natürlich auch alles in einem Rutsch haben:
code:
Local myWindow:Window = new Window().create("My Window", 0, 0, 600, 300)


Zum Abschluss noch der Code der dem "Mal-Beispiel" vom letzten Mal entspricht, aber diesmal dem Mojo-Style folgt:
code:
Import amigaos3

Class myApp extends App
	Field mx:Int
	Field my:int
		
	Method OnCreate()
		'SetColor(255, 0, 0)
		'ClsColor(90, 120, 200)
	End
	
	Method OnUpdate()
		mx = MouseX()
		my = MouseY()
	End
	
	Method OnRender()
		'Cls()
		if MouseDown() DrawPoint(mx, my)
	End
End

Function Main()
	New myApp
End

--
PanzerZ |
methusalem | basic

[ - Antworten - Zitieren - Direktlink - ]

06.12.2011, 21:40 Uhr

bruZard
Posts: 307
Nutzer
Version 0.22 ist nun online.

Neu ist zunächst die Änderung an der Datei "install.txt" welche jetzt "readme.txt" heißt. In dieser Datei gibt es nun Links zu den benötigten Dateien, Hints zu Sachen welche wo nicht funktionieren, und was man derzeit benötigt um Monkey Code zu schreiben und zu kompilieren:
Zitat:
AmigaTarget is a new compiler target for the new programming language "Monkey". You can get the
public domain version of Monkey from http://www.monkeycoder.co.nz/file/get.php?file=/Products/demos/MonkeyDemo45c.zip.

with this target you have the ability to compile a Monkey code for Amiga m68k (OS3.x required)
and for the targets AROSi386 and AROS-PPC.

this version is Alpha! at this time there is no Monkey codes wich you can compile for Amiga targets. Read the file
changes.txt to know wich functions are currently implemented.
"Monkey AmigaTarget" builds still run on a naked Amiga1200 with OS3.1

Requirements:
- WindowsXP or newer
- AmiDevCpp from http://amidevcpp.amiga-world.de/AmiDevCpp/info/AmiDevCpp_graceful_Bulldozer_v098_Setup.exe.php
- Monkey as demo from http://www.monkeycoder.co.nz/file/get.php?file=/Products/demos/MonkeyDemo45c.zip or the full version

Installation:
1. get Monkey Demo from http://www.monkeycoder.co.nz/file/get.php?file=/Products/demos/MonkeyDemo45c.zip
2. extract Monkey Demo
3. extract the AmigaTarget.zip Archive over the Monkey direćtory
4. install AmiDevCpp from http://amidevcpp.amiga-world.de/AmiDevCpp/info/AmiDevCpp_graceful_Bulldozer_v098_Setup.exe.php
5. add the AmiDevCpp path ([AMIDEVCPP]\usr\local\amiga\bin) to your windows path variable

Ich weiß dass mein Englisch Scheisse ist, wer es korrigieren möchte ist herzlich eingeladen ;)

Die wichtigen Änderungen finden sich in der changes.txt:
Zitat:
12/06/2011 v0.22
added : ready to start winnt_config.txt to /bin/
added : Window.AppTitle:Void(title:String)
added : AppTitle:Void(win:Window, title:String)
added : AppTitle(title:String) [Mojo Style]
added : Window.DrawRect:Void(x:Int, y:Int, width:Int, height:Int)
added : DrawRect(win:Window, x:Int, y:Int, width:Int, height:Int)
added : DrawRect(x:Int, y:Int, width:Int, height:Int) [Mojo Style]
added : SetGraphicsMode:Void(mode:Int)
added : PNG Icon for AOS3 executables
changed : Plot() now called DrawPoint()
changed : added -noixemul to compiler options
changed : removed the targets AmigaOS4.x, MorphOS and AROS-64Bit
changed : /bin/winnt_config.txt is prepared. there is no more need to alter them.
fixed : MouseDown() was active at start
fixed : ClsColor() has changed the current pen


Das Archiv für die Version 0.22 kann wie gehabt unter http://www.sedm.de/monkey/AmigaTarget.zip herunter geladen werden.

Im Archiv enthalten sind Executables für AmigaOS3.x, AROSi386 und AROS-PPC.

Der "Mojo Style" läuft nun super was überhaupt notwendig war um irgendwann bestehende Monkey Codes zu kompilieren. Desweiteren wurden ein paar Fehler ausgebügelt. Hinzugekommen ist "DrawRect" welches es gestattet ein Rechteck in der aktuell gesetzten Farbe in das Fenster zu malen. Dieses Fenster kann nun automatisch erstellt werden (Mojo Style) oder selbst definiert werden indem man SetGraphicsMode() aufruft. Es gilt zu beachten dass im Mojo Style kein Fenster als Parameter für Funktionen angegeben werden muss. Im Amiga Mode muss dies aber passieren damit Monkey weiß welches Fenster angesprochen wird. Eine genaue Dokumentation dafür wird noch erstellt.

Bild: http://www.sedm.de/monkey/AmigaTarget_DrawRect.jpg

Wie man sieht funktioniert der Timer noch nicht. Das Timer-Device ist aber auch ein Biest ;)

[ Dieser Beitrag wurde von bruZard am 06.12.2011 um 22:27 Uhr geändert. ]

[ - Antworten - Zitieren - Direktlink - ]

07.12.2011, 23:26 Uhr

Floppy
Posts: 392
Nutzer
@bruZard:
Die Fortschritte sehen richtig gut aus. Danke und weiter so!

[ - Antworten - Zitieren - Direktlink - ]

10.12.2011, 20:16 Uhr

bruZard
Posts: 307
Nutzer
Dank der Hilfe und der extremen Geduld einiger a1k Member kann ich heute Version 0.23 präsentieren. Neu sind die Funktionen MilliSecs(), LoadFont(), SetFont() und DrawText().
Zitat:
12/10/2011 v0.23
added : MilliSecs:Int()
added : Window.LoadFont:Font(fontName:String, size:Int)
added : Window.LoadFont:Font(fontName:String, size:Int, style:Int)
added : Window.LoadFont:Font(fontName:String, size:Int, style:Int, flags:Int)
added : Window.SetFont(font:Font)
added : Window.DrawText(text:String, x:Int, y:Int)
added : LoadFont:Font(win:Window, fontName:String, size:Int)
added : LoadFont:Font(win:Window, fontName:String, size:Int, style:Int)
added : LoadFont:Font(win:Window, fontName:String, size:Int, style:Int, flags:Int)
added : LoadFont:Font(fontName:String, size:Int) [Mojo Style]
added : LoadFont:Font(fontName:String, size:Int, style:Int) [Mojo Style]
added : LoadFont:Font(fontName:String, size:Int, style:Int, flags:Int) [Mojo Style]
added : SetFont(win:Window, font:Font)
added : SetFont(font:Font) [Mojo Style]
added : DrawText(win:Window, text:String, x:Int, y:Int)
added : DrawText(text:String, x:Int, y:Int) [Mojo Style]

LoadFont()
LoadFont() lädt derzeit nur Amiga Fonts per OpenDiskFont(), die überladenen Methoden für AFont.load() sind noch nicht in Monkey implementiert. Derzeit kann man nur den Namen und die Größe des gewünschten Fonts angeben.

SetFont()
LoadFont() und SetFont() müssen derzeit explizit aufgerufen werden wenn man mittels DrawText() etwas ins Fenster schreiben möchte. In Zukunft wird Monkey aber einen Default-Font laden (gibt es auf AOS4, AROS und MOS noch ROMFONT?)

DrawText()
Diese Funktion verwendet zwar schon den APen, der BPen ist aber zufällig. Wird noch geändert.

Hier ein Bild mit dem aktuellen Entwicklungsstand:
Bild: http://www.sedm.de/monkey/drawText.jpg

...und hier der Monkey Source im "mojo style" der dieses Bild erzeugt hat:
code:
Import amigaos3

Class myApp extends App
	Field mx:Int
	Field my:int
	Field time:Int
	Field FPS:Int
	Field tmpFPS:Int
	Field tmpTime:int
	Field lastFPS:Int
	Field fnt:Font
	
	Method OnCreate()
		fnt = LoadFont("helvetica.font", 16)
		SetFont(fnt)
		AppTitle("draw with Monkey")
		SetColor(255, 255, 0)
		ClsColor(90, 120, 200)
		Cls()
	End
	
	Method OnUpdate()
		mx = MouseX()
		my = MouseY()
		tmpFPS = tmpFPS + 1
		tmpTime = MilliSecs()
		
		if tmpTime - time > 1000
			FPS		= tmpFPS
			tmpFPS	= 0
			time 	= tmpTime
		EndIf
	End
	
	Method OnRender()
		if MouseDown() DrawRect(mx-1, my-1, 3, 3)
		if tmpTime <> time DrawText("FPS: " + FPS + " Time: " + time, 10, 10)
	End
End

Function Main()
	New myApp
End


Download AmigaTarget for Monkey v0.23 (~1.1MB)


Vielen Dank nochmal an alle Helfer, ohne Euch wäre ich noch nicht so weit!
--
PanzerZ |
methusalem | basic

[ - Antworten - Zitieren - Direktlink - ]

10.12.2011, 22:29 Uhr

Floppy
Posts: 392
Nutzer
@bruZard:

Es läuft gut auf AROS386. Danke!

Bild: http://aros-exec.org/modules/xcgal/albums/userpics/10645/normal_pic2.jpg

[ - Antworten - Zitieren - Direktlink - ]

11.12.2011, 00:03 Uhr

hjoerg
Posts: 3853
Nutzer
Auch aros386:

Bild: http://hjoerg.homepage.t-online.de/monkey.png


EDIT u. AOS3(WinUAE):

Bild: http://hjoerg.homepage.t-online.de/monkeyAOS3.png

EDit v24:

Bild: http://hjoerg.homepage.t-online.de/monkeyaos3v24.png

EDit v24.2:

Bild: http://hjoerg.homepage.t-online.de/monkeyaos3v24.2.png



--
WinUAE Fan
hjörg :dance2:
Nethands

"Wenn ich dir Recht gebe, liegen wir beide falsch"


[ Dieser Beitrag wurde von hjoerg am 11.12.2011 um 22:27 Uhr geändert. ]

[ - Antworten - Zitieren - Direktlink - ]

11.12.2011, 22:08 Uhr

bruZard
Posts: 307
Nutzer
danke fürs testen Jungs ;)

Version 0.24 ist am Start.

Zitat:
12/11/2011 v0.24
added : Window.DrawLine:Void(x1:Int, y1:Int, x2:Int, y2:Int)
added : DrawLine:Void(win:Window, x1:Int, y1:Int, x2:Int, y2:Int)
added : DrawLine:Void(x1:Int, y1:Int, x2:Int, y2:Int) [Mojo Style]
added : Window.DrawEllipse:Void(x:Int, y:Int, width:Int, height:Int)
added : DrawEllipse:Void(win:Window, x:Int, y:Int, width:Int, height:Int)
added : DrawEllipse:Void(x:Int, y:Int, width:Int, height:Int) [Mojo Style]
added : Window.DrawOval:Void(x:Int, y:Int, width:Int, height:Int)
added : DrawOval:Void(win:Window, x:Int, y:Int, width:Int, height:Int)
added : DrawOval:Void(x:Int, y:Int, width:Int, height:Int) [Mojo Style]
added : Window.DrawCircle:Void(x:Int, y:Int, radius:Int)
added : DrawCircle:Void(win:Window, x:Int, y:Int, radius:Int)
added : DrawCircle:Void(x:Int, y:Int, radius:Int) [Mojo Style]
changed : at start Monkey stets BPen to pen number 0


Ich weiß dass "DrawEllipse" und "DrawOval" dasselbe tun, aber wenn Monkey da redundant ist muss ich es auch sein ;)

Bild: http://www.sedm.de/monkey/linesAndCircles.jpg

Der Code zum Bild:
code:
Import amigaos3

Class myApp extends App
	Field mx:Int
	Field my:int
	Field time:Int
	Field FPS:Int
	Field tmpFPS:Int
	Field tmpTime:int
	Field lastFPS:Int
	Field fnt:Font
	Field lastX:Int
	Field lastY:Int
	
	Method OnCreate()
		fnt = LoadFont("helvetica.font", 16)
		SetFont(fnt)
		AppTitle("draw with Monkey")
		SetColor(255, 255, 0)
		ClsColor(200, 90, 0)
		Cls()
		
		lastX = 0
		lastY = 0
	End
	
	Method OnUpdate()
		mx = MouseX()
		my = MouseY()
		tmpFPS = tmpFPS + 1
		tmpTime = MilliSecs()
		
		if tmpTime - time > 1000
			FPS		= tmpFPS
			tmpFPS	= 0
			time 	= tmpTime
		EndIf
	End
	
	Method OnRender()
		if MouseDown() 
			DrawCircle(mx-1, my-1, 3)
			if lastX > 0 And lastY > 0 DrawLine(lastX, lastY, mx, my)
			lastX = mx
			lastY = my
		EndIf
		
		if tmpTime <> time DrawText("FPS: " + FPS + " Time: " + time, 10, 10)
	End
End

Function Main()
	New myApp
End


http://www.sedm.de/monkey/AmigaTarget.zip >> Download Amiga Monkey Target 0.24 (ca. 1.1MB)
--
PanzerZ |
methusalem | basic

[ - Antworten - Zitieren - Direktlink - ]

13.12.2011, 21:22 Uhr

bruZard
Posts: 307
Nutzer
0.25 macht Monkey bunt!
Download AmigaMonkey 0.25

Changes:
Zitat:
12/13/2011 v0.25
added : class Image
added : Image.Width
added : Image.Height
added : Image.Depth
added : Image.Load:Void(filename:String, remapColors:Bool = False)
added : Image.Free:Void()
added : LoadImage:Image(filename:String)
added : LoadImage:Image(filename:String, remapColors:Byte)
added : Window.DrawImage:Void(img:Image, x:Int, y:Int)
added : DrawImage:Void(win:Window, img:Image, x:Int, y:Int)
added : DrawImage:Void(img:Image, x:Int, y:Int) [Mojo Style]
added : FreeImage:Void(img:Image)
added : Window.SetScreen:Void(pubScreen:String = "workbench")
added : SetScreen:Void(win:Window, pubScreen:String = "workbench")
added : SetScreen:Void(pubScreen:String = "workbench") [Mojo Style]
added : SetUpdateRate:Void(hertz:Int) [only with Mojo Style]
added : Window.getWidth:Int()
added : Window.getHeight:Int()
added : WindowWidth:Int(win:Window)
added : WindowHeight:Int(win:Window)
added : DeviceWidth:Int() [Mojo Style]
added : DeviceHeight:Int() [Mojo Style]
changed : MilliSecs() now returns a 64 bit value
changed : CreateWindow() now has the optional parameter "borderless"
fixed : ClsColor() now affects the BPen
fixed : in Mojo-Style now the workbench will be locked

Bild: http://www.sedm.de/monkey/drawImage.jpg
Der Source zum Bild:
code:
Import amigaos3

Class myApp extends App
	Field mx:Int
	Field my:int
	Field time:Int
	Field FPS:Int
	Field tmpFPS:Int
	Field tmpTime:int
	Field lastFPS:Int
	Field fnt:Font
	Field lastX:Int
	Field lastY:Int
	Field img:Image
	Field bg:Image
	
	Method OnCreate()
		fnt = LoadFont("helvetica.font", 16)
		img = LoadImage("amiga.data/monkey.iff")
		bg = LoadImage("amiga.data/background.jpg")
		
		SetFont(fnt)
		AppTitle("draw with Monkey")
		
		SetColor(255, 255, 0)
		ClsColor(200, 90, 0)
		Cls()
				
		lastX = 0
		lastY = 0
		
		SetUpdateRate(60)
	End
	
	Method OnUpdate()
		mx = MouseX()
		my = MouseY()
		tmpFPS = tmpFPS + 1
		tmpTime = MilliSecs()
		
		if tmpTime - time > 1000
			FPS		= tmpFPS
			tmpFPS	= 0
			time 	= tmpTime
		EndIf
	End
	
	Method OnRender()
		DrawImage(bg, 0, 0)
		
		if MouseDown() 
			DrawCircle(mx-1, my-1, 3)
			if lastX > 0 And lastY > 0 DrawLine(lastX, lastY, mx, my)
			lastX = mx
			lastY = my
		EndIf
		
		if tmpTime <> time DrawText("FPS: " + FPS, 10, 10)
		
		DrawImage(img, mx, my)
	End
End

Function Main()
	New myApp
End

Diesen Source kann man noch nicht für andere Targets übersetzen da Monkey Fonts nicht kennt, sondern dort ein Image lädt und die Chars als Frame behandelt. Das Amiga Target lädt einen AmigaFont als "DiskFont". Desweiteren imitiert das Amiga Target noch nicht das Verhalten von Mojo was das Filesystem angeht. Mojo erwartet Dateien in "[Name des Projekts].data". Innerhalb dieses Raums kann man dann beliebige Verzeichnisse verwenden. Das Amiga Target berücksichtigt dies noch nicht.

Prinzipiell könnt man jetzt schon Spiele mit Monkey für Amiga programmieren, leider gibt es noch keine Masken oder gar Alpha für Images und Tastatureingaben werden noch nicht berücksichtigt. Wer aber nur mit der Maus und mit rechteckigen Images klar kommt darf loslegen ;)

Ein weiterer Stolperstein ist dass Monkey sich verhält wie sich Systeme neben dem Amiga halt verhalten: Sie malen die Spielegrafik in jedem Frame neu. Mein Rechner malt Crysis2 in einer Sekunde 120 Mal neu. Ein Amiga schafft das leider nicht (außer er ist ein aktueller PPC Rechner oder eine WinUAE Emulation). Es wird noch zahlreiche Änderungen geben um zu gewährleisten dass man mit Monkey auch Spiele schreiben kann die auf einem 14MHz A1200 noch hinreichend laufen ... aber zunächst soll es erstmal komplett sein und funktionieren.

Auf zur 0.26 ... es gibt viel zu tun!
--
PanzerZ |
methusalem | basic

[ - Antworten - Zitieren - Direktlink - ]

14.12.2011, 18:42 Uhr

bruZard
Posts: 307
Nutzer
wawa fragte im a1k nochmal nach einer genaueren Beschreibung der Installation. Natürlich will ich Euch diesen Beitrag nicht vorenthalten.


  • 1. Das Ganze funktioniert nur wenn Du einen Windows-Rechner hast auf dem Du kompilieren kannst.

  • 2. Du benötigst:

  • 3. Installiere AmiDevCpp
  • 4. Entpacke die Monkey Demo irgendwo hin
  • 5. Entpacke das Amiga Target und kopiere den Inhalt über die Monkey Installation, es werden einige Dateien ersetzt und andere hinzugefügt.
  • 6. Füge den Pfad zu AmiDevCpp\usr\local\amiga\bin der Windows Umgebungsvariable PATH hinzu. Unter Windows 7 geht das mit Rechtsklick auf "Computer" -> Eigenschaften -> Erweiterte Systemeinstellungen -> Umgebungsvariablen. Dort in der unteren Liste die Variable PATH suchen, auf "Bearbeiten" klicken und an das Ende der Zeile den Pfad anhängen. Bitte daran denken dass einzelne Variablen durch ein Semikolon getrennt werden. Also erst ein Semikolon ans Ende der Zeile und dann den Pfad eintragen. Ggf. den Rechner neu starten.
  • 7. "Monk" aus dem Monkey-Verzeichnis starten
  • 8. Trage folgenden Source ein:
    code:
    import amigaos3
    
    Function Main()
      Print "Hallo Amiga!"
    End

  • 9. sichere den Quelltext irgendwo
  • 10. Klicke auf das Symbol mit der Rakete die nach oben zeigt
  • 11. Wähle als Ziel "aos3" aus und klicke auf "Build"
  • 12. wenn er kompiliert hat findest Du im Verzeichnis in das Du den Source gespeichert hast einen neuen Ordner mit dem Postfix ".build". Darin einen weiteren Ordner namens "aos3" und darin die Executables für OS3.x, AROSi386 und AROS-PPC
  • 13. kopiere "appAOS3" auf Deinen Amiga und starte das Programm


Obiges Beispiel ist Standard Monkey Source. Ich empfehle aber den "Mojo Style" da der prinzipiell von jedem Monkey-Coder da draussen verwendet wird. Dieser ist objektorientiert und das obige Beispiel sähe dann so aus:
code:
import amigaos3

Class HalloAmiga Extends App
  Field hallo:String

  Method OnCreate()
    hallo = "Hallo Amiga"
  End

  Method OnUpdate()
    ' leer, es gibt nichts zu "updaten"
  End

  Method OnRender()
    Print hallo
  End
End

Function Main()
  New HalloAmiga
End


Kommentare werden mit dem ' eingeleitet, mehrzeilige Kommentare startet man mit #rem und schliesst sie mit #endrem ab.
--
PanzerZ |
methusalem | basic

[ Dieser Beitrag wurde von bruZard am 14.12.2011 um 18:42 Uhr geändert. ]

[ - Antworten - Zitieren - Direktlink - ]

12.02.2012, 20:41 Uhr

bruZard
Posts: 307
Nutzer
Status:

Der Monkey Compiler "Trans" kann sich nun selbst fehlerfrei für AmigaOS3.x kompilieren. Leider läuft das erzeugte Binary aber noch nicht. Es wird noch die Trans-Version in die Shell ausgegeben, dann implodiert das System in einem hübschen Guru, hier muss noch einiges angepasst werden.
Wenn das aber irgendwann funktioniert benötigt man kein Windows mehr um Monkey für AOS3.x zu verwenden. Es wird dann halt notwendig sein den g++ nebst OS3.x NDK auf dem Rechner zu haben um Monkey Code in native Binaries zu kompilieren.
Für AROS, MorphOS und AOS4.x werden die Anpassungen vorgenommen sobald Trans auf AOS3.x läuft.

Noch eine andere (marginale) Änderung:
Viele haben mich gefragt warum das Target "aos3" heißt wenn es doch für diverse Amiga Derivate kompiliert. Ohne jetzt die Story nochmal aufzuschreiben: Ich habe das Target und das Modul geändert so dass sie nun beide "AMIGA" heissen. Bevor hier jemand fragt warum wer für AROS das AMIGA Target wählen soll: Mach es einfach, es funktioniert ;-)
Ja, Amiga User sind manchmal etwas "Monk" wenn es um schwabbelige Bezeichner geht ;-)

Da ich, wie bereits erwähnt, "Mojo" nicht portieren darf (nicht Public Domain) heißt mein Modul (welches Mojo nachahmt) "amiga", vorher hieß es "aos3". In Zukunft muss also "amiga" importiert werden anstelle von "aos3" ... leicht zu merken und es sind ja noch ein paar Tage bis ich Monkey native auf AOS3.x habe so dass sich jeder durch beständiges, wiederholtes lesen daran gewöhnen kann. Und "Ja", auch MorphOS und AROS User müssen dann "Import amiga" schreiben ;-) ;-)

stay tuned...
--
PanzerZ| Monkey

[ - Antworten - Zitieren - Direktlink - ]

24.02.2012, 21:20 Uhr

bruZard
Posts: 307
Nutzer
Monkey 0.26 kann jetzt von http://www.sedm.de/monkey/amonkey/AMonkey026.zip heruntergeladen werden. Hier das Changelog:

  • geändert : Die Mojo-Reimplementation heisst jetzt "Amiga"
  • geändert : Das Target selbst heisst jetzt auch "Amiga" und nicht mehr "AOS3"
  • geändert : Das Target besitzt nun ein eigenes Config File
  • geändert : Man kann jetzt für jede einzelne Plattform angeben ob sie kompiliert werden soll oder nicht. Auch die Aros Ziele sind nun einzeln definierbar
  • geändert : Der Pfad zu den AmiDevCPP Binaries wird jetzt in der Config angegeben und muss nicht mehr in die Windows PATH Variable eingetragen werden
  • geändert : Die Monkey Demo wird nicht mehr benötigt. Das oben verlinkte Archiv beinhaltet alles was man benötigt um Monkey Programme für den Amiga unter Windows zu kompilieren. Einzig AmiDevCPP muss noch heruntergeladen werden.
  • beachte : Zwar können alle Ziele in der Config auf True gesetzt werden, aber nur AmigaOS3.x, Aros386 und ArosPPC werden derzeit fehlerfrei übersetzt.
  • beachte: Bis "Trans" komplett auf Amiga/MorphOS/Aros portiert ist, muss die Datei config.winnt.txt angepasst werden, die Datei "config.amiga.txt" ist erst relevant wenn sie auf einem Amiga gelesen wird.

Beachte: Es gibt noch keine unabhängige Amiga/MOS/Aros Version von Monkey. Ich schätze dass diese mit Version 0.3 verfügbar sein wird. Auch Amiga Monkey 0.26 benötigt noch Windows um für AmigaOS3.x, AROSi386 und AROS PPC zu kompilieren.

Nebenbei:
Ich könnte Hilfe gebrauchen. Ich suche Folks die Bock auf eine neue OOP Sprache haben und mir helfen wollen Module für diese zu entwickeln. Keine Ahnung ... vielleicht mag jemand MUI kapseln, oder ein anderer OpenGL ... what ever.
Monkey importiert C++ Sourcen in einem sogenannten "Extern Block", in diesem weißt man Basic Funktionen die Namen der Funktionen im CPP zu. Es können auch ganze Klassen importiert werden und die Methoden für Monkey bekannt gemacht werden.

Wer Interesse hat soll mir einfach eine Mail schicken oder hier antworten.
--
PanzerZ| Monkey

[ - Antworten - Zitieren - Direktlink - ]

12.06.2013, 20:34 Uhr

bruZard
Posts: 307
Nutzer
Mehr als ein Jahr hat es gedauert bis sich der Tornado über Monkey gelegt und Mark Sibly das System so gut wie komplett neu definiert hat. Das neue Target-System ist nun stabil und wird wohl vorerst keine weiteren Änderungen erfahren. Somit habe ich damit begonnen das Amiga-Target auf dieses völlig neue System anzupassen.

Dieser Source:
Bild: http://amigamonkey.colorflow.de/pics/amigamonkey02.jpg

erzeugt schonmal folgende Ausgabe:
Bild: http://amigamonkey.colorflow.de/pics/amigamonkey01.jpg

Warum das jetzt so spannend ist? In den letzten Versionen des Targets musste ich tief in essentielle Teile von Monkey eingreifen um solch eine Ausgabe erzeugen zu können. Jetzt hat sich tatsächlich nur das Target geändert, AmiDevCpp übersetzt den verbesserten Standard Module-Code nun ohne zu murren oder mit Amiga relevanten Definitionen zu kollidieren.
Das bedeutet dass ich AmigaMonkey C++ Code endlich in einen Namespace sperren kann und nicht mehr mit Mark Siblys Bezeichnern in Konflikt gerate. Das hat den Vorteil dass zum Einen der GC (GarbageCollector) endlich funktioniert und außerdem zum ersten Mal überhaupt das Modul "Reflection" verwendet werden kann.

In den letzten Versionen des Targets wurde alles in ein Modul gepackt um die Einfachheit von Monkey zu transportieren. Der Vorteil: Man kann so loslegen wie die Monkey-Folks es weltweit tun. Der Nachteil: Je umfangreicher das Modul wird, umso größer wird das Executable. Die Lösung: Amiga Libraries (dos, intuition, graphics etc.) werden in einzelnen Modulen gewrapped welche wiederum im optionalen Modul "amiga" in Monkey kompatible Funktionen gefasst werden. Wer also alles haben will importiert "amiga", wer differenzierter arbeiten möchte darf die Libraries einzeln importieren.

Mit der neuen Monkey Version (derzeit V71b) muss ich auch mit der Portierung von Trans (transcc) von vorn beginnen und es muss derzeit immer noch unter Windows via AmiDevCpp für Amiga und Derivate kompiliert werden. Die Liste sieht folgendes vor:

- AmigaOS3
- AmigaOS4
- AROS32
- AROS64
- AROSPPC
- MOS

...funktionieren tun derzeit die Ziele AOS3, AROS32 und AROSPPC

eine Config für alle Ziele sieht derzeit so aus:
Zitat:
AMIDEVCPP_PATH = "C:\AmiDevCPP"
BUILD_AOS3 = "true"
BUILD_AOS4 = "true"
BUILD_AROS32 = "true"
BUILD_AROS64 = "true"
BUILD_AROSPPC = "true"
BUILD_MOS = "true"


Sobald mehr geht als die substanziellen Spracheigenschaften (Class, Function, Method etc.) werde ich eine neue Version hochladen.

--
PanzerZ| Monkey

[ - Antworten - Zitieren - Direktlink - ]

12.06.2013, 20:52 Uhr

Floppy
Posts: 392
Nutzer
@bruZard:
Die Änderungen klingen sehr gut. Ich freue mich auf weitere Tests demnächst für AROSi386. Danke für die Weiterentwicklung!

[ - Antworten - Zitieren - Direktlink - ]

22.06.2013, 21:54 Uhr

bruZard
Posts: 307
Nutzer
Prinzipiell muss ich die Versionierung von vorn beginnen da mit den massiven Änderungen die Mark Sibly an Monkey vorgenommen hat, auch ich wieder von vorn beginnen muss. Also findet ihr nun unter http://amigamonkey.colorflow.de/downloads/AmigaMonkey.zip praktisch die Version 0.1

Neu ist die Trennung der Module in Amiga spezifische Definitionen. Während "Exec" noch kein eigenes Modul hat, aber per Default immer definiert ist, gibt es nun das Modul "amiga.intuition" und das Modul "amiga.window".

Man kann nun entweder das Modul "amiga" importieren und somit alles was es so gibt für dieses Target, oder aber man importiert ganz gezielt einzelne Module ... je nach dem was man mit seinem Programm machen will. Das hat zum Einen den Zweck dass man damit das Executable verkleinert (kleiner als 143kb geht leider nicht), zum Anderen dass spezifische Module leichter hinzugefügt werden können. Außerdem bietet es die Möglichkeit eine Ähnlichkeit zur Amiga C/C++ Programmierung zu erreichen. Ich weiß ... Monkey sieht kaum aus wie C/C++, aber auch kaum noch wie Basic obwohl es ein Basic-Dialekt ist.

Ein lauffähiges AmigaMonkey Programm:
code:
Strict

Import amiga.intuition


' der Einsprungspunkt eines jeden Monkey Programms
Function Main:Int()
	New AmigaMonkey()' wir instantiieren unser Programm
	Return 0
End

Class AmigaMonkey
	Method New()
		' zuerst ein paar Angaben wie unser Fenster aussehen soll...
		Local windowFlags:Int	= WFLG_DRAGBAR | WFLG_CLOSEGADGET | WFLG_ACTIVATE
		' ...dann sagen wir auf welche Ereignisse das Fenster reagieren soll...
		Local idcmpFlags:Int	= IDCMP_CLOSEWINDOW | IDCMP_MOUSEMOVE |  IDCMP_INTUITICKS
		' ...und jetzt öffnen wir das Fenster...
		Self.myWindow = New Window("Hallo Amiga", 20, 20, 320, 256, windowFlags, idcmpFlags)
		' ...und hüpfen in die Hauptschleife:
		Self.main()
		
	End
	
	
	Method main:Void()
		Local exitFlag:Bool = False
		
		While Not exitFlag
			' wenn Intuition meldet dass der Closebutton des Fensters
			' gedrückt wurde....
			If Self.myWindow.WaitEvent() = IDCMP_CLOSEWINDOW exitFlag = True
		Wend
		
		' ...schliessen wir das Fenster und beenden das Programm
		Self.myWindow.Close()
	End
	
	Private
	Field myWindow:Window
End


Dies tut recht wenig ... es öffnet ein Fenster an der Position 20, 20 mit den Dimensionen 320x256, setzt den Titel des Fensters auf "Hallo Amiga" und wartet dann in der Methode "main" darauf dass das Fenster geschlossen wird. Der Garbage Collector kümmert sich dann um die Freigabe des allokierten Speichers (was in älteren Versionen des Targets noch nicht ging).

Die Window-Flags (WFLG_) und IDCMP Flags sind direkt nutzbar wie man oben in den Definitionen sehen kann. Derzeit nutzt die Klasse "Window" nur die Methode "OpenWindowTags", die anderen Möglichkeiten ("OpenWindowTagList" etc..) können aber problemlos nach gereicht werden.

Das oben verlinkte Archiv beinhaltet eine fast komplette Monkey-Installation in der Version V71b. Ich habe aus meiner Pro-Version alles entfernt was nicht Public Domain ist. Somit kann man das Archiv direkt nutzen und muss nichts mehr hinzu kopieren. Das Programm "monkey" ist eine recht gute IDE und das Target "Amiga" ist per Default eingestellt.

Zwei Textdateien erklären weitere wichtige Dinge zum Umgang mit diesem Archiv:
"amiga.changelog.txt" ist halt das Changelog ...
"amiga.readme.txt" erzählt etwas mehr über die Installation und Verwendung ....


Als nächstes muss ich die String Klasse anfassen .... leider hat Mark Sibly diese (und auch andere Konstrukte) nicht in einen Namespace gesperrt so dass ich sie wieder einmal umbenennen und bearbeiten muss. Wenn das passiert ist sollten auch die Ziele MorphOS, AROS32 und AROSPPC wieder funktionieren.

[ - Antworten - Zitieren - Direktlink - ]

24.06.2013, 11:26 Uhr

OlafSch
Posts: 91
Nutzer
@bruZard:

Vielen Vielen Dank für deine Arbeit. Ich werde am Wochenende eine Seite mit allen Möglichkeiten zur AROS (inkl. 68k) Softwareentwicklung aufbauen und darin natürlich auch Monkey beschreiben.

[ - Antworten - Zitieren - Direktlink - ]

26.06.2013, 19:59 Uhr

bruZard
Posts: 307
Nutzer
Version 0.12 erweitert die Liste der kompilierbaren Ziele um:

- AROS i386
- AROS 64Bit
- AROS PPC

ausführbare Beispiele für AmigaOS3.x und die drei AROS Ziele finden sich unter \bananas\basic\basic.build\amiga\

http://amigamonkey.colorflow.de/downloads/amigamonkey.0.12.zip (ca. 23MB)

Ab Version 0.13 werden die Updates kumulativ sein damit man nicht jedesmal das riesen Paket herunter laden muss.

[ - Antworten - Zitieren - Direktlink - ]

27.06.2013, 20:28 Uhr

bruZard
Posts: 307
Nutzer
Version 0.13 ist wie versprochen nur schlappe 800kb klein und setzt Version 0.12 voraus. Einfach das Archiv entpacken und über 0.12 kopieren.

    Was ist neu?
  • Window Flags (WFLG_) habe ich von amiga.intuition nach amiga.window verschoben
  • Intuition.OpenWindowTags() habe ich entfernt, Fenster werden jetzt grundsätzlich über die Klasse "Window" verwaltet
  • Window.Title:Void(title:String) ändert den Fenstertitel. Das funktioniert nun auch endlich auf AROS 64
  • amiga.window importiert nun amiga.rastport, in Vorbereitung auf 0.14 in dem wieder Zeichenmethoden eingeführt werden.


http://amigamonkey.colorflow.de/downloads/amigamonkey.0.13.zip

[ - Antworten - Zitieren - Direktlink - ]

28.06.2013, 14:48 Uhr

tbone
Posts: 99
Nutzer
Ein interessantes Ding! Die Kompilate für die verschiedenen Targets sind dann performance-mäßig mit "echten" C-Programmen zu vergleichen, oder ist davon auszugehen, dass man Monkey-Apps ihre Herkunft anmerkt !?

Ich meine so wie man halt merkt, dass SDL, Java/Flash oder irgendwelche anderen GUI-Toolkits/Frameworks für Verzögerungen und ein "besonderes Gefühl" sorgen, wenn man eine damit erstellte Anwendung bedient.

Programme ohne großes TamTam für alle Plattformen gleichzeitig builden zu lassen, ist jedenfalls traumatisch.. ich meine, ist ein traumhafter Ansatz!.. o)

[ - Antworten - Zitieren - Direktlink - ]

28.06.2013, 17:07 Uhr

bruZard
Posts: 307
Nutzer
@tbone:
Die Performance sollte sich im Rahmen normaler C++ Programme bewegen, denn nichts anderes wird hier erzeugt. Trans (der Monkey Transpiler) erzeugt aus dem Monkey Source C++ welches dann an den GCC geschickt wird.

[ - Antworten - Zitieren - Direktlink - ]

08.07.2013, 09:57 Uhr

OlafSch
Posts: 91
Nutzer
@bruZard:

Ich habe eine Seite entwickelt mit einer Beschreibung wie man es installiert:
http://www.aros-platform.de/html/devtools.html

Es läuft prima unter AROS 68k, ich freue mich schon auf die nächsten Versionen. Auf meiner "ToDo-Liste" ist bereits eine Referenz für Monkey.

[ - Antworten - Zitieren - Direktlink - ]

08.07.2013, 17:58 Uhr

bruZard
Posts: 307
Nutzer
Dankeschön! ;)

0.14 wird Ende der Woche fertig sein.

[ - Antworten - Zitieren - Direktlink - ]

17.07.2013, 10:52 Uhr

OlafSch
Posts: 91
Nutzer
@bruZard:

Irgendwelche Neuigkeiten?

[ - Antworten - Zitieren - Direktlink - ]


-1- 2 [ - Beitrag schreiben - ]


amiga-news.de Forum > Amiga, AmigaOS 4 > AOS3/AROS Monkey Target [ - Suche - Neue Beiträge - Registrieren - Login - ]


.
Impressum | Datenschutzerklärung | Netiquette | Werbung | Kontakt
Copyright © 1998-2024 by amiga-news.de - alle Rechte vorbehalten.
.