Core War

Dieses Spiel erinnert mich irgendwie an Robocode wo man roboter anweisungen geben kann wie sie sich zu verhalten haben wenn sie einen feindlichen roboter gefunden haben usw.. geniales spiel... wem Core War gefällt wird robocode sicherlich auch gefallen =)
 
Hba auch mal Robocode gezockt
Ist aber vom Programmieren etwas ganz anderes.
Wenn man sich mal die guten Robots anseiht dann merkt mal das die Tonnen von Code benutzen. Mit x Stratiegien , Posotionsberechnung etc.
Hab mal sogar einen gesehen der mutiert, so im evolutions style
Da hat man als Anfänger keine Chance.

CodeWar ist viel Logischer da man auch mit Wegin Code viel erreichen kann.
Seht euch doch nur mal BiShot an und vergelicht ihn mit Robots von anderen Seiten.
Er schlägt selbst welche mit 10x soviel Code
 
o.O

Hab mal mit CoreWin simuliert und ehy_key seinen code gegen meinen antreten lassen.

;redcode

;name ehy_
;version 1
;author ehy_key
;date 2005-Nov-15

;strategy kill_the_opponent

spl 0, 0
mov 2, <1
spl -1, 10
jmp -1, -1

vs.

;Redcode
;name EuSo_

SPL 0,0
MOV 0,1


Ich muss dazu sagen das ich vor 5min. Assembler angefangen hab ^^ hab bisher nur c++ coding betrieben ... so aber laut simulation kommt dies raus:

EuSo 157
ehy 15
(auf der rechten Seite im Prog.) Das kann doch nich sein das ich gewonnen hab o.O ?Das geht garnicht!
 
Also, euch war doch klar, dass sich ein Noob melden würde^^
Und hier bin ich jetzt.

Kann mir irgendjemand nur mal ansatzweise erklären, wie dieser Warrior funzt?:

MOV -3, @+4
ADD #2, +3
JMP -2
DAT #1234
DAT #4

Ja, ich weiss, ich verlange eine Step by Step Anleitung, wäre dennoch schön, wenn sich mir jemand erbarmen könnte^^.
Diese seltsamen Anleitungen kapier ich garnicht...

Wieso steht da nicht einfach eine Tabelle mit

Befehl a bringt das
Befehl b bringt das
?
 
MOV -3 @+4 | bewegt das was 3 zeilen davor im core steht (DAT #0,#0) 4 zeilen vor die aktuelle
ADD #2,+3 | addiert zu dem was 2 zeilen weiter unten steht +3
JMP -2 | springt wieder zu MOV...
DAT#1234 |ist eine so genannte Bombe....denn jeder prozess der einen dat-befehl ausführt stirbt
DAT #4 | -||-

meiner meinung nach(bin auch nur anfänger und hab auch nie aktiv angefangen) is dieser code un effektiv und totaler stuss....
probier mal den:
MOV 4 @+4
ADD #-1,+3
JMP -2
DAT #10,5 //farbige bombe damit ein prozess wenn er das feld auf 0,0 überprüft es trothzudem ausführt...

MfG cube
 
Original von Cube
MOV -3 @+4 | bewegt das was 3 zeilen davor im core steht (DAT #0,#0) 4 zeilen vor die aktuelle
ADD #2,+3 | addiert zu dem was 2 zeilen weiter unten steht +3
HÖÖÖ?
es addiert also zu DAT #1234+3?
JMP -2 | springt wieder zu MOV...
DAT#1234 |ist eine so genannte Bombe....denn jeder prozess der einen dat-befehl ausführt stirbt
DAT #4 | -||-

sonst danke
meiner meinung nach(bin auch nur anfänger und hab auch nie aktiv angefangen) is dieser code un effektiv und totaler stuss....

probier mal den:
MOV 4 @+4
ADD #-1,+3
JMP -2
DAT #10,5 //farbige bombe damit ein prozess wenn er das feld auf 0,0 überprüft es trothzudem ausführt...

MfG cube
Zum Vergrößern anklicken....

der tut es nicht richtig, auch mit dem Komma beim Mov befehl.....stirbt direkt.
 
Er "läuft" einfach nicht...
er beschreibt ein paar Zellen, und dann ist Ende.

EDIT:

So, hier ist nun einer meiner ersten "Gehversuche":

test db
add #3, test
mov test, 3
MUL -1,test
sub #1,test
mov test, -3
jmp -5


eigentlich nichts anderes als imp

---------------------------------------------------

Kann mir jemand vielleicht hier helfen?
Was ich eigentlich wollte ist, dass es immer brav hin und her schreibt, dass heisst, test wird immer größer, und der mov befehl kopiert es dann die entsprechende Stelle, aber stattdessen kommt so ein seltsames Muster heraus.


test db
add #3, test
add #2, test
mul test, -1
mov 4, test
mul test, -1
mov 0, test
jmp -5
 
sowas wie mein code,ein dwarf, macht auch nix anderes als felder beschreiben und dabei versuchen einen dat befehl in den gegner zuschreiben...
wenn du soviele zeilen brauchst um die selbe funktion wie ein imp zu erreichen bist du viel zu uneffektiv...

Edit:
Er hört irgendwann auf weil er sich selber überschreibt...deshalb gewinnt er auch nuir manchmal gegen imps,etc... is halt ein billisges einfaches ding mit dem man nich sehr weit kommt...is aber am angfang normal sone dinger zu schreiben...später machst du nen scanner der nur bombt wenn er was findet und sich selbst ausnimmt...
 
hier habe auch mal ein bissle dannach ausschau gehalten ich blick es aber nicht ganz
hier habe ich einen der mit chili bei mir jedenfalls unentschieden das ergebniss war


;redcode-qs
;name KafMini-Q^3 AQP
;author summon
;strategy KafuFFLe's Mini-Q^3 with A Quickscanner's Paper
;strategy 32 (+1) scans with a 42 line qscan
;strategy descended from nPaper II's Mini-Q^3 - minor improvements
;assert CORESIZE == 8000

org qGo

pGo EQU boot

pStep1 EQU 2341
pStep2 EQU 2421
pStep3 EQU 3241

pAway1 EQU 2000
pAway2 EQU 6000

pEnd EQU (silk3 + 1)

boot spl 1
mov.i -1, 0
spl 1

mov.i < pBoot1, { pBoot1
pBoot1 spl pAway1, pEnd

mov.i < pBoot2, { pBoot2
pBoot2 jmp pAway2, pEnd

silk1 spl @ silk1, < pStep1
mov.i } silk1, > silk1

silk2 spl @ silk2, < pStep2
mov.i } silk2, > silk2

mov.i { silk2, < silk3
silk3 djn.f @ silk3, < pStep3

for 45
dat 0,0
rof

qf equ qKil ; Mini-Q^3
qs equ 222
qd equ 322
qi equ 7
qr equ 11

qGo: seq qd+qf+qs, qf+qs ; 1
djn.f qSki, {qd+qf+qs+qi
seq qd+qf+6*qs, qf+6*qs ; B
djn.f qFas, {qd+qf+6*qs+qi
seq qd+qf+5*qs, qf+5*qs ; B-1
jmp qFas, <qBmb
seq qd+qf+7*qs, qf+7*qs ; B+1
jmp qFas, >qBmb
seq qd+qf+9*qs, qf+9*qs ; A-1
djn qFas, {qFas
seq qd+qf+10*qs, qf+10*qs ; A
jmn qFas, {qFas

seq qd+qf+3*qs, qf+3*qs ; C
djn.f >qFas, {qd+qf+3*qs+qi
seq qd+qf+2*qs, qf+2*qs ; C-1
jmn >qFas, {qSlo
seq qd+qf+4*qs, qf+4*qs ; C+1
jmn >qFas, }qSlo
seq qd+qf+12*qs, qf+12*qs ; B*C-B
jmn qSlo, {qSlo
seq qd+qf+15*qs, qf+15*qs ; B*C-C
jmp qSlo, <qBmb
seq qd+qf+21*qs, qf+21*qs ; B*C+C
jmp qSlo, >qBmb
seq qd+qf+24*qs, qf+24*qs ; B*C+B
jmn qSlo, }qSlo
seq qd+qf+27*qs, qf+27*qs ; A*C-C
djn qSlo, {qFas
seq qd+qf+30*qs, qf+30*qs ; A*C
jmn qSlo, {qFas
sne qd+qf+18*qs, qf+18*qs ; B*C
jmz.f pGo, qd+qf+18*qs-10

qSlo:mul #3, qKil ; C=3
qFas:mul.b qBmb, @qSlo
qSki:sne >qf+23*qs, >qKil
add #qd, qKil
qLoo:mov *qKil, <qKil
qKil:mov qBmb, }qs
sub #qi-1, @qLoo
djn qLoo, #qr
djn.f pGo, <10 ; A=10
qBmb:dat {qi*qr-10, {6 ; B=6

END
;redcode-qs​
 
hier mein erster warrior hab ihn mal gegen alle die ich hier im forum gefunden hab antreten lassen. hier mein warrior
Code: 
;redcode-94b
;assert 1
;name sas1
;author Jan Ruh
;date 2007-Sep-02
;version 1


start        spl     attack
                spl  defence
defence   spl             3
                spl             3
                spl            -2
                jmp            0,     <-7
                mov           0,         1
attack      mov    bomb,         4
                add.ab   #2,        -1
                jmp    attack
bomb       dat         #0,       #0
 
Hi!


Ich hab iwie das mit dem # Vor den Zahlen nicht verstanden.. was bedeutet das?

Wie z.b. DAT #0,#0

was bedeutet da die "#"'s davor?

Thx

Ansonsten hab ich einen kleinen "antiimp":

Code: 
;redcode-94b
;assert 1
;name AntiImp
;kill AntiImp
;author ChiefWiggum
;strategy kill_the_opponent
;date 2007-Oct-10
;version 1

mov 5,-1
mov -2,4
jmp -2

Muss ich mir mal näher angucken :D Fun machts ^^

EDIT:

Wegen den '#''s

Code: 
ADD #4, 3
MOV 2, @2        ; next instruction
JMP -2
DAT #0, #4

ADD #Befehlzeile, #wert-des-2ten-wertes

richtig?
(Befehlzeile in relation zur grade ausgeführten zeile also
NOP 0
ADD #-1,2

Würde doch dann "NOP 2" draus machen oder?
 
Zuletzt bearbeitet:
Um antworten zu können musst du eingeloggt sein.
Zurück
Oben