Simple Script Max

Kommentare anzeigen Worklog abonnieren
Gehe zu Seite Zurück  1, 2, 3, 4, 5, 6, 7, 8  Weiter

Worklogs Simple Script Max

Primitive OOP Unterstützung

Freitag, 26. Dezember 2008 von coolo
Hallo erstmal,
nun nach langem überlegen wie ich OOP am besten einbauen könnte, bin ich schlussendlich zu einer Lösung gekommen, wie ichs gelöst hab sag ich nicht, aber ich kann euch das Resultat zeigen. Es ist eine simple Image Klasse, welche Methoden und Felder vorweisen kann.
Code: [AUSKLAPPEN]

importall() ;Importiert alles
local hndl1 as timage
hndl1\x%=5
hndl1\y%=9
print (hndl1\x%)
hndl1\load("gfx/player.png")
repeat
     hndl1\draw()
until(keyhit(1))

Dies ist NICHT die endgültige Klasse, es ist nur ein simpler Test.
Auffällig ist das sich der Syntax doch ein bisschen geändert hat. aus
Code: [AUSKLAPPEN]

local hnd1l%=Timage()

wurde
Code: [AUSKLAPPEN]

local hndl1 as timage

Der Grund war, weil es für mich einfacher ist dies so zu bewerkstelligen.

Und natürlich kann man jatzt auch Variablen so initialisieren:
Code: [AUSKLAPPEN]

local meincoolerint as int
meincoolerint%=5
print(meincoolerint%)


Falls euch der Syntax gefällt oder nicht gefällt oder ihr Anregungen habt, nurzu, schreibt Kommentare.

Optimierungen und API

Sonntag, 21. Dezember 2008 von coolo
Hallöchen
nach langer Zeit melde ich mich wieder. nun ja was habe ich gemacht? Ich habe hauptsächlich optimiert. Wo habe ich optimiert? Hauptsächlich beim Parsen/präparsen/Compilieren. Nun dauert das compilieren doppelt so schnell wie vorher. Wofür wird das gebraucht? Nunja, hauptsächlich für Realtime Codeprocessing. Das heißt es wird eine Funktion geben, nennen wir sie mal eval(), die führt eine Funktion zur Laufzeit aus. Das sollte einige Dinge erleichtern.

Außerdem wurden die Variablen Referenzen doch rausgeschmissen. Warum? Nunja, das braucht doch eine Scriptsprache wie Simple Script nicht. Die Funktions Referenzen sind nach wie vor in meiner Todo Liste Wink.

Optimiert habe ich auch bei den Variablen und Schleifen. Jetzt ist Simple Script 2 ung. halb so schnell wie BB. Optimieren kann man nur mehr bei dem Funktions System, aber darauf habe ich jetzt keine Lust.

Außerdem hat Simple Script 2 eine noch mehr verbesserte API bekommen:
Früher hieß es so:
Code: [AUSKLAPPEN]

hndl=create_script("script1.sb")
;Hier Variablen erzeugen
add_intvar("int1",5)
add_stringvar("String1","hallo ich bin dumm")
add_floatvar("float1",5.565)
parse_script(hndl)
exec_script(hndl)

Jetzt heißt es so:
Code: [AUSKLAPPEN]

init_simplescript("parsedir","Scriptdir") ;die Ordner
hndl=create_script("script1.sb")
;Hier Variablen erzeugen
add_var(hndl,"INT","int1",5)
add_var(hndl,"STRING","String1","hallo ich bin dumm")
add_var(hndl,"FLOAT","float1",5.565)
parse_script(hndl)
exec_script(hndl)
print get_var(hndl,"INT","int1") ;gibt den Inhalt von int1 aus
free_script(hndl)
free_simplescript()

Wie man sieht deutlich flexibler.
Folgende Befehle gibt es noch:
Code: [AUSKLAPPEN]

get_id(scripthndl,name$);gibt die Id einer Variable zurück
get_varfast(scripthndl,typ$,id,wert$) ;gibt wert zurück,schneller, aber man muss die id der Variable wissen
set_varfast(scripthndl,typ$,id,wert$);setzt einen wert,schneller aber man muss id wissen
set_var(scripthndl,typ$,name$,wert$);setzt einen Wert
add_func(name$,pars);fügt eine Funktion hinzu
call_func(name$,par0,par1,par2,...) ;ruft eine Funktion auf

Es müssen noch die API Funktionen für die Globale Variablen erstellt werden. dann ist die API eigentlich schon fertig.

Cu cuulo

Referenzen

Dienstag, 16. Dezember 2008 von coolo
Heute habe ich mich auf ein Feature gewagt, welches sehr wichtig für das OOP sein wird. Nämlich Referenzen. Es soll 2 Arten von denen geben.
1. Variablen Referenzen
2. Funktions Referenzen.
Die erste Variante ist schon lauffähig und muss nur noch auf Globale Variablen ausgeweitet werden. Wobei dies nur Tipparbeit ist.
Die Funktionsrefernezen kommen demnächst.
Code: [AUSKLAPPEN]

local int%=7
local reference%
reference%=ref(int%)
int%=4
print(reference%)

Ausgabe:
Code: [AUSKLAPPEN]

4


For Next Schleifen

Montag, 15. Dezember 2008 von coolo
Hallo, nun habe ich die letzte Etappe der Schleifen gemeistert, nämlich die For Next Schleifen. Sie funktionieren problemlos und vorallem schnell genug.

Code: [AUSKLAPPEN]

importall()
local i%
for (i%=0,i%>5,1) ;1. Startwert, 2. Wann beendet werden soll3. Um wieviel hinzuaddiert werden muss
    print("durchlauf"i%)
next


Technisch gesehen ist es eine aufgemotzte while Schleife mit einer weiteren Codezeile fürs inkremieren oder dekremieren.

Bis denne
Kuhlo

Globale Variablen

Sonntag, 14. Dezember 2008 von coolo
Hallo,
nun nach nervenaufreißenden 5 Tagen habe ich Globale Variablen eingebaut. Warum hat das so lange gedauert? Nunja, das liegt hauptsächlich daran, dass ein kleiner Bug die ganze Produktion lahmgelegt hat. Es war letztendlich nur ein kleines Vertauschen der Code Reihenfolge. Ich habe auf ein Dim Array zugegriffen, welches noch garnicht initialisiert war... Nundenn, jetzt ist es eingebaut und funktioneirt prächtig.
Leider sind mir beim testen noch ein paar andere Käfer aufgefallen, welche alle noch beseitigt werden müssen.
Code: [AUSKLAPPEN]

global var%=4

hallo()

function hallo()
   var%=3
   print (var%)
endfunction

Ausgabe:
Code: [AUSKLAPPEN]

3


Nundenn, bis zum nächsten mal.

Funktionen funktionieren!!!

Dienstag, 9. Dezember 2008 von coolo
Hallöchen,
vieleicht habt ihr euch gefragt, warum keine Einträge mehr kommen. Das liegt daran, dass ich jetzt mich entschieden habe, nicht mehr jeden Tag sondern immer wenn ein Kapitel abgeschlossen ist einen Eintrag zu schreiben. Außerdem(ja jetzt mit scharfen ß Wink), hat mein Computer gestreikt sodass ich nicht weitermachen konnte.
Nundenn, ich habe heute weitergemacht und kann sagen, das Funktionen prächtig funktionieren. Es funktionieren Lokale Variablen, Parameter, vordefinierte Parameter, es können Strings entgegen genommen werden uvm. . Was ich als nächstes gedenke zu machen, weiß ich auch nicht wahrscheinlich werden die Globalen Variablen an der Reihe sein.

Mein bisheriger Beispielcode:
Code: [AUSKLAPPEN]

import("key")
print("Muh")
print (hallo(5,9))
print("MAH")

function hallo(say%,lol%=4)
   local sappa%=9999
   print("hallo1")
   print("hallo2")
   print("hallo3")
   print (say%)
   print (lol%)
   print (sappa%)
   hallo2()
   return("Hallo")
endfunction

function hallo2()
   print("Hallo4")
endfunction

Ausgabe:
Code: [AUSKLAPPEN]

Muh
hallo1
hallo2
hallo3
5
9
9999
Hallo4
Hallo
MAH


Außerdem habe ich mich entschieden KEIN direktes OOP einzubauen. Es werden die von BB bekannten Types geben. Warum denn ein indirektes OOP? Nunja, es können normale Funktionen zu Methoden "konvertiert" werden. Seht selbst:


Code: [AUSKLAPPEN]

Type Thouse
;Felder deklarieren
     field(x%)
     field(y%)
     field(imghndl%)
;Methoden hinzufügen
     addMethod("Thouse","draw_house")
     addMethod("Thouse","create_house")
     addMethod("Thouse","delete_house")
     setasconstruct("create_house")
     setasdestruct("delete_house")
end type
function delete_house()
     deleteimage(self.imghndl%)
end function
function create_house(layer%,x%,y%)
     ;hier init und so
end function
function draw_house()
     drawimage(selft.imghndl,self.x,self.y)
endfunction
local hndl%=Thouse(layer%,x%,y%)
hndl\x=5
hndl\y=8
hndl\draw_house()
hndl\delete_house() ;man kann auch hndl:destruct() aufrufen

Und das Beste daran ist, durch diese Indirekte Types, kann man zur Laufzeit eigene Methoden und Felder hinzufügen. Ausserdem ist auch Vererbung und Polymorphie möglich, aber dies ist Zufunktsmusik.
Dafür gibt es keine Private/Public/protected deklanationen, überladene Funktionen, .... Also all der unnötige Schnick Schnack.

Edit:
Jetzt mit \ statt : .

Bis dann
coolo

Parameter gehen mir am A******

Freitag, 5. Dezember 2008 von coolo
Hallö,
ich habe nun die Parameter weitgehend eingebaut. Es können zwar bis jetzt nut Floats und ints eintgegengenommen werden, aber der Rest funktioniert.

Code: [AUSKLAPPEN]

import("key")
print("Muh")
print (hallo(5))
print("MAH")

function hallo(say%,lol%=3)
     print("hallo1")
     print("hallo2")
     print("hallo3")
     print(say%)
     print (lol$)
     hallo2()
´   return("Hallo")
endfunction

function hallo2()
     print("Hallo4")
endfunction


Ausgabe:
Code: [AUSKLAPPEN]

muh
hallo1
hallo2
hallo3
5
3
Hallo4
Hallo
MAH

Es gibt noch ein paar Fehler...

Anfänge von API

Donnerstag, 4. Dezember 2008 von coolo
Hallöchen,
heute wurde eine art API eingefügt. Man kann berweits beim start vordefinierte Variablen hinzufügen. Ausserdem wurd das Design unter der Haube verändert.

Anfangs gab es die 2 Befehle:
Code: [AUSKLAPPEN]

hndl=parse_script("script1.sb")
exec_script(hndl)

Und jetzt:
Code: [AUSKLAPPEN]

hndl=create_script("script1.sb")
;Hier VAriablen erzeugen
add_intvar("int1",5)
add_stringvar("String1","hallo ich bin dumm")
add_floatvar("float1",5.565)
parse_script(hndl)
exec_script(hndl)

Wie man sieht, deutlich flexibler.

Konstanten

Mittwoch, 3. Dezember 2008 von coolo
Heute wurden Konstanten eingebaut. Sie haben KEINERLEI einfluss auf den SPeed, wie man sich denken kann.
Code: [AUSKLAPPEN]

const hallo:5
print(hallo)


Ausserdem habe ich mich an Parametern von Funktionen herangemacht, dies hat leider zu keine funktionierenden Eregebnissen geführt.

Funktionen sind schon was feines....

Dienstag, 2. Dezember 2008 von coolo
Hallo,
Zuerst zum Positiven: Der Bug das man eine gleiche Funktion nur einmal aufrufen kann, wurde behoben... und Strings können perfekt ohne Probleme zurüchgegeben werden.
Ausserdem habe ich damit begonnen, Parameter für benutzerdefinierten Funktionen einzubauan. Funktioniert zwar noch nicht, aber ich wollte es mal erwähnen.
Code: [AUSKLAPPEN]

print("Muh")
print (hallo())
print("MAH")

function hallo(say$)
     print("hallo1")
     print("hallo2")
     print("hallo3")
     hallo2()
     return("Hallo")
endfunction

function hallo2()
     print("Hallo4")
endfunction

Dieser Code wird in 2 ms ausgeführt. Was wie ich finde ziemlich schnell ist.

Endlos schleife:
Code: [AUSKLAPPEN]

print("Muh")
print (hallo())
print("MAH")

function hallo(say$)
     print("hallo1")
     print("hallo2")
     print("hallo3")
     hallo2()
     hallo()
     return("Hallo") ;kommt gar nicht zu stanede...
endfunction

function hallo2()
     print("Hallo4")
endfunction


Nun zum langweiligen Teil:
Ich habe mir heute den Kopf darüber zerbrochen um ein ordentliches Konzept für Simple Script 2 zu erstellen.
Da kam folgendes raus:
Es wird 3 Zweige von Simple Script 2 geben.
Der 1. ist als eine Spielescriptsprache für kleine Minigames. Da kommts ja nicht soo auf die Geschwindigkeit an.

Der 2. ist als reine Script Engine angelegt, das heißt, dass man eine easy to use Scriptengine ähnlich LUA in BB einbinden kann. Damit man endlich seine Games ohne viel aufwand modbar machen.

Der 3. ist zum Automatisieren von Vorgängen am Computer gedacht. Wer AutoIt kennt weiß was ich meine. Da ja AutoIt3 zum Teil OpenSource steht, werde ich mit die Dll "nehmen" und eine Wrapper für BB schreiben.

Nun habe ich mir ausserdem die Idee aus dem Kopf geschlagen eine 3D Engine in SS2 einzubinden, dafür ists doch ein bisschen zu langsam.
Als 2D Engine verwende ich die berühmte SpriteCandy von X-pressive. Da wird im berreich 2D sicher vorgesorgt sein. Die restlichen Engines(Sound, UDP,TCP,Key-System,Stream) übernimmt BB.
Bei der GUI bin ich mir nicht so sicher. Vllt. nehme ich die EscapeGui von EPS oder doch eine andere... Vllt. könnt ihr mir etwas empfehlen. Am naheliegensten wäre, die GUI, die bei der SpriteCandy dabei ist, dann hätte man eine Hardware beschleunigte GUI...
Nun habe ich noch eine Frage an euch. Ich habe schon viel überlegt, und bin zu keiner Entscheidung gekommen.
Soll SS2 OOP bekommen? Dafür würde sprechen, dass man die Engines gut kapseln kann, dagegen, sprcht das es sehr aufwendig und langsam ist. Ich hoffe ihr gebt eure MEinung darüber ab in den Kommentaren.

Cu
CooLo

Gehe zu Seite Zurück  1, 2, 3, 4, 5, 6, 7, 8  Weiter