TIS-100: The assembly game you never asked for

[.oisyn]

Introductie

Zachtronics, bekend van games als SpaceChem en Infinifactory, heeft een heuze assembly game gemaakt: Tesselated Intelligence System - 100

Het is eigenlijk een puzzelgame, waarbij je assembly code moet schrijven om specifieke problemen op te lossen. Denk hierbij aan het filteren van input op minimale en maximale waardes, het omkeren van een getallenreeks, etc.

Naast het oplossen van de problemen zelf, is er natuurlijk de drang om dat in zo min mogelijk cycles, instructies of nodes te doen. De resultaten zijn direct te vergelijken met je vrienden om Steam en de rest van de community . Verder zijn er natuurlijk een aantal achievements te behalen.

Momenteel voor €6,99 te verkrijgen op Steam

How to play

Scott Manley heeft op Youtube een goede uitleg geplaatst:

TIS-100 blinkt uit in zijn eenvoud, terwijl er toch best complexe dingen mee te maken zijn. De virtuele computer bestaat uit een twaalftal nodes geplaatst in een 4x3 grid. Elke node kan communiceren met de node links, rechts, boven en onder zich. Input wordt altijd aangeboden aan de bovenste rij nodes, en outputs zullen verbonden zijn aan de onderste rij nodes.

Nodes

Niet elke node is hetzelfde. Er zijn een paar verschillende typen:

Compute nodes
Dit zijn nodes waarin je je assembly code kunt typen. Er is ruimte voor maximaal 15 instructies per node. Elke compute node voert zijn instructies uit onafhankelijk van andere nodes, en het is in weze dus een soort van multicore systeem. Na het uitvoeren van de laatste instructie zal hij automatisch weer met de eerste beginnen.

Stack nodes
Dit zijn speciale nodes waar je data naartoe kunt schrijven en vandaan kunt lezen. Elk getal dat je schrijft zal op een stack worden geplaatst, en elke leesactie zal het bovenste getal van de stack halen. Een stack node biedt zijn data automatisch aan aan alle aangrenzende nodes, en elke aangrenzende node kan ernaar schrijven

Corrupt nodes
Deze zijn niet bruikbaar en vormen eigenlijk louter een blokkade om de problemen iets ingewikkelder te maken, omdat je communicatiepaden erdoor gelimiteerd worden. Verder vormen ze een deel van de storyline, voor zover je daarvan kunt spreken.

Assembly syntax

De assembly syntax komt redelijk overeen met wat je wellicht gewend bent, en het aantal instructies is zeer gelimiteerd. Elke instructie bestaat uit een opcode, gevolgd door 0, 1 of 2 operanden. Mogelijke operanden bestaan uit registers, getallen (van -999 t/m +999), of labels in het geval van jump instructies. Wat betreft de volgorde van de operanden indien er twee zijn, dan komt eerst het bronregister en daarna het doelregister. Dit is tegengesteld van wat je wellicht gewend bent van menig echte assembly syntax. Labels definieer je met een identifier gevolgd door een dubbele punt, eventueel direct gevolgd door een instructie. Comments beginnen met een #

Voorbeeld:

code:

#My super leet program
MOV LEFT, ACC
ADD 5
JLZ Done
MOV ACC, DOWN
Done:
MOV 45, LEFT

Je kunt breakpoints plaatsen door een uitroepteken voor de instructie te zetten.

Registers
Er zijn in totaal 6 registers: ACC, BAK, LEFT, RIGHT, UP en DOWN. Daarnaast zijn er nog de "virtuele" registers ANY, LAST en NIL.

• ACC is de accumulator, en wordt gebruikt voor het doen van berekeningen, vergelijkingen en tijdelijke opslag.
• BAK is een backup register. Met de SAV en SWP instructies kun je data verplaatsen van ACC naar BAK en vice versa, maar hij is anderzijds niet direct aan te spreken met andere instructies.
• LEFT, RIGHT, UP en DOWN zijn port registers, waarmee je kunt communiceren met aangrenzende nodes. Deze vormen tevens een vorm van synchronisatie: een node die een waarde schrijft naar RIGHT, zal niet verder gaan met het uitvoeren van instructies voordat die waarde wordt uitgelezen door de node rechts van hem.
• ANY gebruik je om je data aan te bieden aan alle omliggende nodes, of juist om data te lezen van een willekeurige omliggende node. De eerste node die een leesactie doet zal de data verkrijgen, en vice versa. Het gedrag als er meerdere aangrenzende nodes lezen of schrijven is "implementation defined" volgens de handleiding (hint: het is weldegelijk deterministisch en hier kun je soms je voordeel mee doen ).
• LAST is nuttig in combinatie met ANY. Elke compute node onthoudt namelijk het register waar dmv ANY het laatst naar geschreven of van gelezen is. Deze kun je opnieuw aanspreken met LAST. Het is implementation defined wat er gebeurt als je LAST gebruikt voordat je ANY hebt gebruikt.
• NIL is vergelijkbaar met /dev/null . Een leesactie van NIL zal gewoon 0 opleveren, en een schrijfactie naar NIL gooit de waarde weg. Je zal dit vooral gebruiken als doelregister bij het lezen van een van de port registers, om te kunnen synchroniseren zonder dat je verplicht bent iets met de betreffende waarde te doen.

Instructies
MOV <source>, <dest>
Verplaatst data van het ene register naar het andere. Het <source> operand kan een register of een getal zijn, het <dest> operand is altijd een register.

ADD <source>
Telt een register of getal op bij de huidige waarde in ACC.

SUB <source>
Trekt een waarde of register af van de huidige waarde in ACC.

NEG
Keert het tegen van ACC om. Oftewel, ACC = -ACC.

SAV
Slaat de waarde van ACC op in BAK.

SWP
Verwisselt ACC en BAK.

JMP <label>
De eerstvolgende instructie die zal worden uitgevoerd is die direct na <label> (of de allereerste als er niets meer na <label> komt),

JEZ <label>
JNZ <label>
JLZ <label>
JGZ <label>
Conditional jump - sprint alleen naar <label> als de waarde in ACC respectievelijk: gelijk is aan 0, niet gelijk is aan 0, kleiner is dan 0, groter is dan 0.

JRO <source>
Een relatieve jump. <source> is een register of een getal. De eerstvolgende instructie is de huidige + de waarde van <source>. Dus JRO -1 springt 1 instructie terug en JRO 4 sprint 4 instructies verder. JRO LEFT leest van LEFT en springt zoveel instructies vooruit of achteruit. Een waarde van 0 zorgt ervoor dat hij naar zichzelf springt.

NOP
Een no-operation. Volgens de handleiding equivalent aan ADD NIL. Gebruik je vooral voor exacte timing, of het creëren van een juiste aantal instructies bij het gebruik van JRO.

Timing
Elke instructie kost in principe 1 cycle, met uitzondering van het schrijven naar een van de port registers met behulp van MOV. Het kost 1 cycle om zijn data aan te bieden, en dan zal hij wachten tot de data gelezen wordt (dus minstens 1 extra cycle als de aangrenzende node op dat moment aan het lezen is). Ook de input en outputs van de TIS-100 zijn hieraan gebonden, maar worden altijd direct gelezen en geschreven dus het lezen van een input of het schrijven naar een output kost altijd 2 cycles.

Achievements

	RTFM View the TIS-100 manual.
	BUSY_LOOP Solve SELF-TEST DIAGNOSTIC in over 100,000 cycles.
	PARALLELIZE Solve SIGNAL AMPLIFIER in fewer than 100 cycles.
	UNCONDITIONAL Solve SIGNAL COMPARATOR without using the JGZ, JLZ, JEZ, or JNZ instructions.
	NO_BACKUP Solve SEQUENCE COUNTER without using the SWP instruction.
	NO_MEMORY Solve SEQUENCE REVERSER without writing any values to a stack memory node.
	HALT_AND_CATCH_FIRE Crash the TIS-100 with the hidden opcode.
	ILLEGAL_EAGLE Find and solve the hidden puzzle.
	100_PERCENT_V1 Solve every puzzle in the TIS-100 SEGMENT MAP.
	100_PERCENT_V2 Solve every puzzle in the TIS-NET DIRECTORY.

Tips

Als je ruimte over hebt en nodes lopen niet in sync en wachten veel op elkaar, dan kan het lonen om de nodes verder uit elkaar te leggen en tussenliggende nodes te gebruiken om data door te voeren. De schrijvende node kan zijn data dan meteen kwijt en kan verder gaan, en voor de lezende node staat de data al meteen klaar als hij er langs komt. Je kunt hiermee soms grote winsten halen zonder dat je iets aan je algoritme verandert.

Experimenteer met JRO, je gaat hem nodig hebben . Bedenk dat je hem niet alleen kunt gebruiken voor rekenkundige operaties (spring X stapjes verder aan de hand van een bepaalde waarde), maar het is ook voor een node een manier om te vertellen wat een aangrenzende node moet doen. Op die manier kun je bijvoorbeeld loop logic, waar je doorgaans ACC voor nodig hebt, thuisbrengen in een aangrenzende node, zodat je ACC vrij kunt houden voor andere zaken.

Links

Website van de game zelf: http://www.zachtronics.com/tis-100/
Steam Store: http://store.steampowered.com/app/370360

Tot slot

Het posten van jouw minimale score op een bepaald probleem en bijbehorende discussie wordt aangemoedigd

[ Voor 30% gewijzigd door .oisyn op 31-08-2015 12:01 ]

[mclegodude]

Zo'n leuk spelletje, heb hem gekocht na dat scott manley er een video over had gepost

[Daos]

Leuk spel. Een score van mij:

Segment 40196 Signal Pattern Detector
655 cycles
8 nodes
33 instructions

Erg slecht al je de grafiekjes moet geloven. Mijn oplossing werkt zo:

spoiler:

In de middelste nodes wordt de waarde van 0, 1 en 2 terug bewaard en wordt naar onderen gestuurd of dit 0 of anders is. Die waarden worden opgeteld en als het resultaat 0 is, wordt de uitvoer 1 gemaakt

Edit:
Segment 52544 Exposure Mask Viewer
3056 cycles
9 nodes
79 instructions

Uren mee bezig geweest. Steeds maar meer dan 15 regels nodig. Gelukkig toch gelukt, maar het resultaat is weer erg slecht als je de grafiekjes moet geloven.

[ Voor 23% gewijzigd door Daos op 30-08-2015 13:27 ]

[.oisyn]

Daos schreef op zondag 30 augustus 2015 @ 03:25:
Leuk spel. Een score van mij:

Segment 40196 Signal Pattern Detector
655 cycles
8 nodes
33 instructions

Erg slecht al je de grafiekjes moet geloven.

Die heb ik in 157/4/15

Je oplossing lijkt me nodeloos ingewikkeld

spoiler:

Bedenk een statemachine wat er moet gebeuren bij elke input. Je hoeft in feite niets te onthouden, de instruction pointer zegt genoeg. Alle logic kan in 1 node

Segment 52544 Exposure Mask Viewer
3056 cycles
9 nodes
79 instructions

565/8/63. Dat was een leuke . Probeer nodes niet teveel te laten doen, essentiele informatie met bijbehorende logic kun je aanvoeren vanuit buurnodes.

Ik ben nu wel benieuwd wat je hebt bij Image Test Pattern 1. Als je die optimaliseert kom je tot bepaalde inzichten die je erg kunnen helpen bij de Exposure Mask Viewer. Dat was bij mij in ieder geval zo. 1187 moet je daar wel kunnen halen, 1186 is mogelijk met een hack (die heb ik wel zelf ontdekt, maar ook alleen maar omdat ik op internet had gelezen dat 1186 mogelijk was anders had ik er nooit naar gezocht. Ik bedacht 'm ineens in bed, dat was wel een leuk eureka moment ).

De enige die ik heb die niet echt in het bovenste percentiel van de community zit is Sequence Indexer: 1232/8/83. Maar ik heb nog wel een ideetje hoe ik die wat kan versnellen. Ik probeerde het eerst op een compleet andere manier maar daar heb ik niet genoeg ruimte voor. Ik moet denk ik gaan voor een hybride van beide oplossingen.

Overigens een algemene tip: JRO is je vriend. Het duurde even voordat ik echt doorhad hoe waardevol die instructie eigenlijk is.

[ Voor 16% gewijzigd door .oisyn op 30-08-2015 14:13 ]

[Daos]

.oisyn schreef op zondag 30 augustus 2015 @ 13:57:
[...]

Die heb ik in 157/4/15

Je oplossing lijkt me nodeloos ingewikkeld

spoiler:

Bedenk een statemachine wat er moet gebeuren bij elke input. Je hoeft in feite niets te onthouden, de instruction pointer zegt genoeg. Alle logic kan in 1 node

Met een

spoiler:

statemachine

krijg ik 161/4/17. Op een of andere manier is mijn eerste waarde fout en die moet ik even weg gooien onderweg.

Ik ben nu wel benieuwd wat je hebt bij Image Test Pattern 1. Als je die optimaliseert kom je tot bepaalde inzichten die je erg kunnen helpen bij de Exposure Mask Viewer. Dat was bij mij in ieder geval zo. 1187 moet je daar wel kunnen halen, 1186 is mogelijk met een hack (die heb ik wel zelf ontdekt, maar ook alleen maar omdat ik op internet had gelezen dat 1186 mogelijk was anders had ik er nooit naar gezocht. Ik bedacht 'm ineens in bed, dat was wel een leuk eureka moment ).

Ik krijg nu niet bepaald nieuwe inzichten door Image Test Pattern 1
2336/1/10

spoiler:

MOV 0, DOWN
SWP
MOV ACC, DOWN
ADD 1
SAV

MOV 30, ACC
INNR:MOV 3, DOWN
SUB 1
JNZ INNR

MOV -1, DOWN

De enige die ik heb die niet echt in het bovenste percentiel van de community zit is Sequence Indexer: 1232/8/83. Maar ik heb nog wel een ideetje hoe ik die wat kan versnellen. Ik probeerde het eerst op een compleet andere manier maar daar heb ik niet genoeg ruimte voor. Ik moet denk ik gaan voor een hybride van beide oplossingen.

Sequence Indexer heb ik 2719/6/36

spoiler:

Ik vul eerst de bovenste stack. Loopje: na vullen verplaatst ik afhankelijk van de index een deel naar de onderste stack. Ik haal de waarde eruit en verplaats alles weer naar de bovenste stack zodat de volgende iteratie kan starten

Overigens een algemene tip: JRO is je vriend. Het duurde even voordat ik echt doorhad hoe waardevol die instructie eigenlijk is.

JRO heb ik nog niet 1 keer gebruikt. Heb je een voorbeeld waar dit handig is? (LAST en ANY heb ik trouwens ook nog niet gebruikt)

[.oisyn]

Daos schreef op zondag 30 augustus 2015 @ 15:37:
Ik krijg nu niet bepaald nieuwe inzichten door Image Test Pattern 1
2336/1/10

spoiler:

MOV 0, DOWN
SWP
MOV ACC, DOWN
ADD 1
SAV

MOV 30, ACC
INNR:MOV 3, DOWN
SUB 1
JNZ INNR

MOV -1, DOWN

Maar dat is dan ook hoe het niet moet . Als we het even analytisch benaderen: een regel heeft 30 karakters, en daarnaast ben je 3 outputs kwijt aan overhead (rij, kolom, afsluitende -1), dus dat is 33 outputs per regel. Er zijn 18 regels, dus 594 outputs, al is de laatste -1 niet nodig want hij stopt al zodra je het laatste karakter tekent, dus 593 outputs. Dat komt neer op minimaal 1186 cycles, maar dan mag er dus geen enkele loop instructie in de uitvoerende node staan.

spoiler:

Kijk, dat eerste gedeelte is al zonde. Waarom zou je die logic in de node stoppen? Als je er een node naast gebruikt met

MOV ACC, RIGHT
ADD 1

dan kun je de het hele eerste stuk vervangen met

MOV 0, DOWN
MOV LEFT, DOWN

En in plaats van 1 karakter-output per iteratie, kun je er ook meerdere doen, wat uiteindelijk tot veel minder overhead leidt. Maar wat als ik nou vertel dat je zelfs dat loopje niet nodig hebt, en gewoon 30x achter elkaar effectief een MOV 3, DOWN kunt doen? "Ja maar dat past niet" hoor ik je al zeggen. Natuurlijk past dat wel, je moet alleen meerdere nodes gebruiken

Sequence Indexer heb ik 2719/6/36

spoiler:

Ik vul eerst de bovenste stack. Loopje: na vullen verplaatst ik afhankelijk van de index een deel naar de onderste stack. Ik haal de waarde eruit en verplaats alles weer naar de bovenste stack zodat de volgende iteratie kan starten

spoiler:

Zo had ik 'm eerst ook inderdaad. Maar je hoeft natuurlijk niet steeds van voor af aan te beginnen. Eigenlijk moet je gewoon kijken naar het verschil van de huidige met de vorige, en aan de hand daarvan een aantal elementen terugschuiven of doorschuiven

JRO heb ik nog niet 1 keer gebruikt. Heb je een voorbeeld waar dit handig is?

Het meest voordehandliggende is natuurlijk met een variabele input, waarbij je een bepaalde handeling een aantal keer wilt uitvoeren. Bijvoorbeeld

code:

JRO ACC
MOV 3, DOWN
MOV 3, DOWN
MOV 3, DOWN
MOV 3, DOWN
MOV 3, DOWN
MOV 3, DOWN

Door ACC naar 1 t/m 6 te zetten, kun je dus resp. 6 t/m 1 waarden outputten. De JRO kan natuurlijk ook ónder de moves staan, dan is het -1 t/m -6 voor respectievelijk 1 t/m 6 outputs.

Maar het échte nut komt niet van dit soort rekenkundige sprongetjes. Je kan een aangrenzende node de controle geven over waar deze node naartoe moet springen. Bijvoorbeeld, een node die een waarde leest, die op commando herhaalt aan een aangrenzende node, en op een gegeven moment weer geinstrueerd wordt om een nieuwe waarde te lezen:

code:

MOV UP, ACC
JRO RIGHT
MOV ACC, RIGHT

De node rechts van hem kan dan met een MOV -1, LEFT ervoor zorgen dat hij een nieuwe waarde inleest, en met MOV 1, LEFT ervoor zorgen dat hij de waarde doorgeeft. Natuurlijk zijn hier veel complexere zaken mee te maken. Op die manier kun je de control flow heel makkelijk aan een andere node overlaten.

[Daos]

Ik moet van de eerste pagina alleen Segment 63534 Sequence Sorter nog.

spoiler:

Mijn idee was om de data tussen de stacks te laten bewegen en steeds een item onderweg op de juiste positie in te voegen. Dit past alleen (nog) niet in de 15 regels per node.

Iemand een tipje?

Edit: het is al gelukt met mijn idee hierboven. 3975/9/75

[ Voor 14% gewijzigd door Daos op 30-08-2015 18:54 ]

[.oisyn]

spoiler:

Dat wilde ik ook nog proberen. Ik doe het momenteel andersom - steeds het laagste element eruit halen en outputten. Ik denk dat je uiteindelijk met een insert minder logica nodig hebt.

Mijn huidige score is 2890/8/90

[H!GHGuY]

Ik heb spacechem nog (met veel plezier) gespeeld, dus ik heb na lezen van de TS meteen m'n oude paypal van onder het stof gehaald.

.oisyn schreef op zondag 30 augustus 2015 @ 15:59:
[...]
Maar dat is dan ook hoe het niet moet . Als we het even analytisch benaderen: een regel heeft 30 karakters, en daarnaast ben je 3 outputs kwijt aan overhead (rij, kolom, afsluitende -1), dus dat is 33 outputs per regel. Er zijn 18 regels, dus 594 outputs, al is de laatste -1 niet nodig want hij stopt al zodra je het laatste karakter tekent, dus 593 outputs. Dat komt neer op minimaal 1186 cycles, maar dan mag er dus geen enkele loop instructie in de uitvoerende node staan.

spoiler:

Kijk, dat eerste gedeelte is al zonde. Waarom zou je die logic in de node stoppen? Als je er een node naast gebruikt met

MOV ACC, RIGHT
ADD 1

dan kun je de het hele eerste stuk vervangen met

MOV 0, DOWN
MOV LEFT, DOWN

En in plaats van 1 karakter-output per iteratie, kun je er ook meerdere doen, wat uiteindelijk tot veel minder overhead leidt. Maar wat als ik nou vertel dat je zelfs dat loopje niet nodig hebt, en gewoon 30x achter elkaar effectief een MOV 3, DOWN kunt doen? "Ja maar dat past niet" hoor ik je al zeggen. Natuurlijk past dat wel, je moet alleen meerdere nodes gebruiken

Adhv deze tip ben ik ook op 1187/4/17 geraakt. Die laatste cycle moet ik er nog eens uitpeuteren.
Ik heb het echter wel anders gedaan dan jij...

spoiler:

Nodes:
1
|
2-3-4

1)
MOV 20, ACC
N:SUB 1
JEZ GO
JMP N
GO: MOV 1, DOWN
MOV 21,ACC
JMP N

2)
MOV 0, RIGHT
MOV 0, RIGHT
L: JRO UP
NL: ADD 1
MOV -1, RIGHT
MOV 0, RIGHT
MOV ACC, RIGHT
JMP L

3)
MOV ANY, DOWN

4)
MOV 3, LEFT

Meteen een mooi gebruik van "ANY" en de precedence...

Ik heb trouwens die test pattern 2, met slechts kleine aanpassingen gedaan in
1285/4/18

[.oisyn]

Image Test Pattern 2 heb ik in 1184/6/43. Ik neem aan dat je 1185 bedoelt? Dezelfde hack voor die ene cycle is ook daar van toepassing.

spoiler:

Wel clever gebruik van die input precedence trouwens, leuk

[ Voor 78% gewijzigd door .oisyn op 31-08-2015 11:07 ]

[Bv202]

Zit er in dit spel ook een soort tutorial om assembly te leren of is voorkennis echt vereist?

[Creepy]

Voorkennis is niet echt vereist. Het aantal instructies is zo klein, dat dat prima te leren valt in een paar minuten en .oisyn heeft ze allemaal opgesomt in de start post. De eerste 2 opdrachten zijn ook relatief simpel om als tutorial te dienen.

[Anoniem: 391619]

Gisteren gekocht, maar ik merk al dat ik toch even goed moet nadenken bij de meeste puzzels, ben nog maar de bij de 6e en moet nu toch even goed kijken hoe ik dit het beste kan aanpakken.
Verder een leuk spel moet ik zeggen, een keer wat anders dan het gebruikelijke!

spoiler: Verborgen opcode

Verder iemand de instructie HCF al gebruikt?

[.oisyn]

Maar wie heeft die hidden puzzle al gevonden (en opgelost)?

.edit: meteen maar even de achievements in de TS gezet.

.edit2:

mclegodude schreef op zaterdag 29 augustus 2015 @ 23:28:
Zo'n leuk spelletje, heb hem gekocht na dat scott manley er een video over had gepost

Dat is ook wel een goede voor de TS

[ Voor 83% gewijzigd door .oisyn op 31-08-2015 11:55 ]

[Creepy]

Pff, moet ik die ook nog gaan zoeken?
Ik moet eerst maar eens de laatste paar opdrachten gaan afronden. Ik heb de tweede image pattern opdracht afgerond en wel even kort de volgende bekeken. Ik heb een idee voor een oplossings richting.

[xChOasx]

Wat cool dat hier nu een topic van is!

Ben eigenlijk wel een fan van alle Zachtronics games. Ze maken zo veel coole spellen voor programmers/engineers!

Ik zal thuis ook eens in mijn scores duiken, maar meestal geldt bij mij: If it works, it's good enough

(Trouwens, als jullie van dit soort spellen houden, Ik ben op dit moment beta tester voor Human Resource Machine (van Tomorrow Corporation, bekend van World of Goo). Geloof me, dat ga je ook leuk vinden! : http://tomorrowcorporation.com/humanresourcemachine )

[.oisyn]

xChOasx schreef op maandag 31 augustus 2015 @ 12:56:
maar meestal geldt bij mij: If it works, it's good enough

Pff where's the fun in that

[xChOasx]

.oisyn schreef op maandag 31 augustus 2015 @ 13:18:
[...]

Pff where's the fun in that

Meestal he!

Soms heb ik echt leuke ideeen en dan scoor ik prima, maar er zijn al-tijd wel mensen die hoger scoren, als ik optimaliseer is het voor mezelf, niet om de hoogste score te halen, als ik iemand iets zie doen met 3 'cores' waar ik er 6 voor nodig heb (en nog niet eens zo snel als die ander) , prima! Vierdaagse loop je ook uit, je hoeft niet de eerste te zijn he

Zelfde met Infinifactory. Man! Als ik af en toe naar oplossingen kijk! briljant (en ook volkomen de engine misbruiken ++ van mij hoor).

Maar ik hou van puzzels en ik moet al aan mijn vrouw uitleggen dat dit geen werk is

[Creepy]

Vergeet ook niet dat de drie statistieken los van elkaar worden bijgehouden. Dus als iemand maar 1 core gebruikt heeft betekent dat niet automatisch dat er dus ook maar 1 core is gebruikt in de oplossing voor het minste aantal cycles. Daar heb ik me in het begin ook op blind gestaart. Dus je kunt optimaliseren per stat. De beste wordt bewaard.

[TheNephilim]

Awesome!

Volgens mij gaat me zoiets wel hoofdbrekens opleveren, maar wel een erg leuk idee. Wellicht toch eens mee stoeien xd

[xChOasx]

Creepy schreef op maandag 31 augustus 2015 @ 13:29:
Vergeet ook niet dat de drie statistieken los van elkaar worden bijgehouden. Dus als iemand maar 1 core gebruikt heeft betekent dat niet automatisch dat er dus ook maar 1 core is gebruikt in de oplossing voor het minste aantal cycles. Daar heb ik me in het begin ook op blind gestaart. Dus je kunt optimaliseren per stat. De beste wordt bewaard.

Klopt, en ik ga niet voor alles optimaliseren

[.oisyn]

Ik vind instruction count en node count ook niet zo heel boeiend.

Hebben mensen al die community puzzels uit de TIS NET DIRECTORY gedaan? Mijn Sequence Merger was relatief langzaam en het was ook een hele kluif om die kloppend te krijgen. Misschien maak ik een rare gedachtenkronkel oid want die overige puzzels die ik tot nu toe gedaan heb waren een heel stuk simpeler.

[xChOasx]

.oisyn schreef op maandag 31 augustus 2015 @ 14:03:
Ik vind instruction count en node count ook niet zo heel boeiend.

Hebben mensen al die community puzzels uit de TIS NET DIRECTORY gedaan? Mijn Sequence Merger was relatief langzaam en het was ook een hele kluif om die kloppend te krijgen. Misschien maak ik een rare gedachtenkronkel oid want die overige puzzels die ik tot nu toe gedaan heb waren een heel stuk simpeler.

Ik heb alleen Integer Series Calculator gedaan, en dat was alleen oplossen, verder nog niet echt gekeken daar.

[.oisyn]

Ah ja die vond ik ook wel leuk. Mijn rudimentaire oplossing kwam op 6074/4/14. Mijn snelste is 2657/10/95. Zie ook het verschil in aantal nodes en instructies

spoiler:

Oh ja, nu weet ik 'm weer. Die was awesome . Mijn snelste methode rekent feitelijk gewoon (n²-n)/2 uit. Wat deze specifieke implementatie bijzonder maakt is dat ik 'm eerst in C++ had uitgewerkt. Hij doet namelijk zowel de kwadraat als de deling door 2 in een keer, met slechts een aantal compares en optellingen. Ik had voor m'n implementatie ook echt alle nodes nodig.

[ Voor 55% gewijzigd door .oisyn op 31-08-2015 16:38 ]

[H!GHGuY]

.oisyn schreef op zondag 30 augustus 2015 @ 23:06:
Image Test Pattern 2 heb ik in 1184/6/43. Ik neem aan dat je 1185 bedoelt? Dezelfde hack voor die ene cycle is ook daar van toepassing.

spoiler:

Wel clever gebruik van die input precedence trouwens, leuk

Nee, toch echt wat ik schrijf. Maar ik ben vertrokken van de oplossing van die test pattern 1 en met enkele kleine aanpassingen die pattern 2 gedaan. Wsch teken jij telkens alle witte blokjes, ik teken zowel zwarte als witte blokjes.

Ik had trouwens liever een fifo dan een stack gehad

[.oisyn]

Alleen de witte blokjes tekenen is alleen maar duurder, want dan moet je elke keer weer een -1, rij en kolom uitschrijven. Anders alleen maar een extra zwarte en dan kun je de volgende witte tekenen.

Wat ik niet snap is waarom je, als je uitgaat van de implementatie van ITP1 waar je 1187 haalde, er bij ITP2 ineens 100 cycles langer over doet .

Vervang jouw node 4 door een MOV 3, LEFT; MOV 0, LEFT, je eerste instructie van node 2 door een MOV LEFT, RIGHT, en maak een nieuwe node links van node 2 waarin je om en om een 0 en een 1 naar RIGHT schrijft.

Ik had trouwens liever een fifo dan een stack gehad

Dat had een hoop gescheeld ja

[ Voor 7% gewijzigd door .oisyn op 31-08-2015 17:06 ]

[Daos]

.oisyn schreef op maandag 31 augustus 2015 @ 14:03:
Ik vind instruction count en node count ook niet zo heel boeiend.

Hebben mensen al die community puzzels uit de TIS NET DIRECTORY gedaan? Mijn Sequence Merger was relatief langzaam en het was ook een hele kluif om die kloppend te krijgen. Misschien maak ik een rare gedachtenkronkel oid want die overige puzzels die ik tot nu toe gedaan heb waren een heel stuk simpeler.

Ik heb alleen de Integer Series Calculator in 8994/4/16.

Bij het mergen heb ik vrij makkelijk het eerste stuk (50 instructies), maar ik heb nog geen idee hoe ik het moet resetten na de 0-en.

Ik heb hem in 480/6/46 Niet helemaal juist, want

spoiler:

ik ga ervan uit dat waardes uniek zijn in een reeks en dat is gelukkig ook zo

[ Voor 10% gewijzigd door Daos op 31-08-2015 19:26 ]

[H!GHGuY]

.oisyn schreef op maandag 31 augustus 2015 @ 16:48:
Wat ik niet snap is waarom je, als je uitgaat van de implementatie van ITP1 waar je 1187 haalde, er bij ITP2 ineens 100 cycles langer over doet .

Vervang jouw node 4 door een MOV 3, LEFT; MOV 0, LEFT, je eerste instructie van node 2 door een MOV LEFT, RIGHT, en maak een nieuwe node links van node 2 waarin je om en om een 0 en een 1 naar RIGHT schrijft.

Ik had wat zitten foefelen (en, toegegeven, er niet zo lang over nagedacht), maar het probleem is dat je voor je volgende rij hetzelfde kleur moet hebben als de laatste van je vorige. Wat ik dus doe is voorbij het einde van de rij tekenen, tot de kleur goed is.
Simpelere oplossingen gingen allemaal voorbij aan dit punt.

[.oisyn]

Je kan elke oneven rij ook gewoon op kolom 1 laten beginnen.

@Daos: netjes . Daar moet ik nog even goed naar kijken. Gebruik je de stack nodes ook (en dan niet alleen voor het doorgeven van waardes)?

[ Voor 54% gewijzigd door .oisyn op 31-08-2015 20:13 ]

[Daos]

.oisyn schreef op maandag 31 augustus 2015 @ 20:11:
@Daos: netjes . Daar moet ik nog even goed naar kijken. Gebruik je de stack nodes ook (en dan niet alleen voor het doorgeven van waardes)?

spoiler:

nee, ik gebruik ze helemaal niet

Edit: nu 405/6/32 door gebruik te maken van JRO (mijn eerste keer).

[ Voor 10% gewijzigd door Daos op 31-08-2015 21:51 ]

[.oisyn]

Ik weet niet waarom ik eerst zo moeilijk deed 387/7/36 nu
.edit: 374/7/36 na het herordenen van wat instructies.

[ Voor 30% gewijzigd door .oisyn op 31-08-2015 21:54 ]

[H!GHGuY]

.oisyn schreef op maandag 31 augustus 2015 @ 21:45:
Ik weet niet waarom ik eerst zo moeilijk deed 387/7/36 nu
.edit: 374/7/36 na het herordenen van wat instructies.

Dat kan echt bizarre winsten opleveren.
Gisteren eentje van 400+ naar 280-something gekregen door gewoon instructies te reorderen.

[LennardF1989]

Erg leuk spelletje, ben er al redelijk wat uurtjes zoet mee geweest

[Daos]

.oisyn schreef op maandag 31 augustus 2015 @ 11:27:
Maar wie heeft die hidden puzzle al gevonden (en opgelost)?

Ik heb de hidden in 573/7/62.

[.oisyn]

544/6/35 .

[michelvosje]

Idd leuk spel. Had hem vorige week ook ontdekt. Leuk spel om rustig aan uit te spelen en niet doorheen te haasten .

Btw. Hoe werken die grafieken?

[.oisyn]

Dat zijn histogrammen met de resultaten van de community. Elke bar representeert een range van cycles/nodes/instructions, en de hoogte geeft aan hoeveel mensen in die range vallen.

[.oisyn]

Een hoop challenges in de TIS-NET directory waarvoor je een deling door een constante moet doen. Decimal Decomposer is wel leuk, waarbij je een getal moet opdelen in 3 afzonderlijke cijfers. 893/10/90

Of Signal Prescaler, waarbij je door 8, door 4 en door 2 moet delen. 1047/9/77.

[ Voor 17% gewijzigd door .oisyn op 04-09-2015 16:29 ]

[Daos]

Ik heb de Signal Prescaler in 68757/6/38 Delen door twee heb ik gedaan door

spoiler:

de ene teller steeds 2 lager en de andere 1 hoger te maken in een lusje.

Edit: Komen er bij Submaximum Selector maxima voor die dubbel zijn. Ik voer dan de 3e uit ipv de 2e. Ben ik al een paar uur bezig, krijg ik dit

Edit2: gefixt in nog geen 10 minuten 2444/10/100

Edit3: Decimal Decomposer in 4021/9/58

[ Voor 43% gewijzigd door Daos op 05-09-2015 21:01 ]

[Soultaker]

Ook maar even geïnstalleerd! Waar halen jullie de statistieken voor minimale cycle/node/instruction count vandaan, trouwens?

[Daos]

Statistieken interesseren mij (nog) niet zo veel. Ik wil eerst alles opgelost hebben en ga daarna aan de achievements werken

[Soultaker]

Wat dat betreft: waar zij je de achievements? Of zijn die Steam-only? (Ik heb de GOG-versie.)

[Daos]

Ik heb de Steam-versie. De achievements staan ook in de topicstart. Je kan dan voor jezelf bepalen of je ze gehaald heb.

[.oisyn]

Daos schreef op zaterdag 05 september 2015 @ 19:02:
Ik heb de Signal Prescaler in 68757/6/38 Delen door twee heb ik gedaan door

spoiler:

de ene teller steeds 2 lager en de andere 1 hoger te maken in een lusje.

spoiler:

Beter deel je door 8, voor het antwoord van 4 en 2 vermenigvuldig je gewoon resp. met 2 en 4 . Verder kun je dat natuurlijk verder optimizent door bijvoorbeeld steeds 64 ervan af te trekken en bij de andere 8 erbij te tellen, en de rest verder door 8 delen

[ Voor 3% gewijzigd door .oisyn op 05-09-2015 22:50 ]

[Soultaker]

.oisyn schreef op vrijdag 28 augustus 2015 @ 18:52:
Ook de input en outputs van de TIS-100 zijn hieraan gebonden, maar worden altijd direct gelezen en geschreven dus het lezen van een input of het schrijven naar een output kost altijd 2 cycles.

Dit is niet helemaal correct samengevat: het lezen van een input kost altijd 1 cycle.

[ Voor 48% gewijzigd door .oisyn op 06-09-2015 22:54 ]

[Anoniem: 517225]

Juist dit spel gekocht, best wel leuk om te spelen maar ben al vastgeraakt bij de 4de opdracht

spoiler: title

MOV LEFT, ACC
MOV ACC, RIGHT
JGZ TEST
MOV 0, DOWN

TEST:
MOV 1,DOWN

Ik dacht dat het TEST label alleen zou uitgevoerd worden wanneer JGZ een positieve waarde krijgt. Nu blijkt het label ook te worden uitgevoerd wanneer JGZ een negatieve (of 0) waarde krijgt en dan eerst MOV 0,DOWN uitvoert en dan het TEST label uitvoert, is dit normaal?

[Jeroen Sack]

Anoniem: 517225 schreef op zondag 06 september 2015 @ 21:13:
Juist dit spel gekocht, best wel leuk om te spelen maar ben al vastgeraakt bij de 4de opdracht

spoiler: title

MOV LEFT, ACC
MOV ACC, RIGHT
JGZ TEST
MOV 0, DOWN

TEST:
MOV 1,DOWN

Ik dacht dat het TEST label alleen zou uitgevoerd worden wanneer JGZ een positieve waarde krijgt. Nu blijkt het label ook te worden uitgevoerd wanneer JGZ een negatieve (of 0) waarde krijgt en dan eerst MOV 0,DOWN uitvoert en dan het TEST label uitvoert, is dit normaal?

Dat klopt, is bij normale assembly ook zo. Je kan vlak voor het label een JMP doen naar het begin om dat over te slaan.

[.oisyn]

Soultaker schreef op zondag 06 september 2015 @ 11:57:
[...]

Dit is niet helemaal correct samengevat: het lezen van een input kost altijd 1 cycle.

Het is wellicht wat onhandig verwoord, maar wat ik bedoelde was dat het net is alsof er een node boven zit die een write doet. Je kan dus maar 1 waarde per 2 cycles lezen, omdat het een cycle duurt voordat er weer een nieuwe waarde wordt aangeboden. De enige uitzondering zijn stack nodes, zij bieden wel hun data elke cycle aan.

Anoniem: 517225 schreef op zondag 06 september 2015 @ 21:13:
Ik dacht dat het TEST label alleen zou uitgevoerd worden wanneer JGZ een positieve waarde krijgt. Nu blijkt het label ook te worden uitgevoerd wanneer JGZ een negatieve (of 0) waarde krijgt en dan eerst MOV 0,DOWN uitvoert en dan het TEST label uitvoert, is dit normaal?

Een label heeft geen speciale betekenis; het geeft gewoon een plek in je code aan. Met een jump instructie zeg je niets meer dan: spring naar die plek. Dus ja, de tweede MOV instructie is gewoon de eerstvolgende instructie om uit te voeren na de eerste MOV

[ Voor 44% gewijzigd door .oisyn op 07-09-2015 11:11 ]

[.oisyn]

*schup*

Er worden te weinig scores gepost. Kom op, ik wil competitie

[Daos]

Ik zit nu vast bij de "Nexus 09.904.9 Sequence Mode Calculator"

Alvast verder heb ik al de "Nexus 18.427.7 Decimal to Octal Converter" in 1489/4/17. Dat was een kwartier tot half uur werk om te maken.

[Gerco]

Daos schreef op zondag 30 augustus 2015 @ 03:25:
Segment 52544 Exposure Mask Viewer
3056 cycles
9 nodes
79 instructions

Deze heb ik in 877/6/34. Blijkbaar heel weinig instructies, gemiddeld gezien. Daar heb ik echter wel vaker last van: Weinig instructies en veel cycles. Volgens mij betekent dat dat ik nog niet helemaal parallel genoeg heb leren nadenken

[Daos]

Daos schreef op zaterdag 12 september 2015 @ 18:31:
Ik zit nu vast bij de "Nexus 09.904.9 Sequence Mode Calculator"

Iemand een hint? Ik probeer eerst de getallen te tellen. Eerste poging was door boven steeds de boel te verplaatsen tussen de linker en rechter stack. Werkt aardig, maar die node zit helemaal vol en ik kan er dus verder niets mee. Poging vandaag is ook weer tellen, maar dan in een cirkeltje. Ik heb nu overal een beetje ruimte over, maar ik gebruik wel al alle nodes. Nu moet ik zien te stoppen bij een 0 in de input en dan nog bepalen welk getal het maximum heeft. Zit ik een beetje op de goede weg of moet ik het helemaal anders aanpakken?

edit:
Ik heb wel alle achievements behalve de "100_PERCENT_V2" die je krijgt als je alle puzzels opgelost hebt

[ Voor 7% gewijzigd door Daos op 02-09-2016 20:59 ]

[.oisyn]

Die heb ik in 1222/7/70

Wat bedoel je met getallen tellen? Ik maak gebruik van het feit dat een sequence altijd getallen 1 t/m 5 bevat, dus ik maak gebruik van een "array" van 5 elementen waarin staat hoe vaak elk getal voorkomt. En ook hier is JRO je vriend, want dan kun je zonder loop N elementen moven naar de andere stack.

Ik heb in de vakantie TIS-100 nog even aangeslingerd om een paar scores te verbeteren waar een collega aanvankelijk sneller was dan ik

Interrupt Handler: 163/10/48
Signal Pattern Detector: 125/5/30
Image Pattern Test 2: 1150/6/30

[ Voor 26% gewijzigd door .oisyn op 04-09-2016 15:01 ]

[Daos]

Met 'tellen' bedoel ik het proces dat jouw ""array" van 5 elementen waarin staat hoe vaak elk getal voorkomt" oplevert. Ik zit dus op de goede weg.

JRO heb ik pas in 1 programma gebruikt voor een jump/branch table om een bepaalde achievement te halen. Ik zie zo snel niet hoe het mij hier kan helpen.

Interrupt Handler: 201/9/42
Sequence Signal Pattern Detector: 161/4/17
Image Pattern Test 2: 2403/2/12

edit:
Met JRO kan ik zoiets maken, maar dat past niet.

code:

MOV UP, ACC
SAV
JRO ACC
MOV LEFT, RIGHT
MOV LEFT, RIGHT
MOV LEFT, RIGHT
MOV LEFT, RIGHT
MOV LEFT, ACC
ADD 1
MOV ACC, LEFT
SWP
JRO ACC
MOV RIGHT, LEFT
MOV RIGHT, LEFT
MOV RIGHT, LEFT
MOV RIGHT, LEFT
NOP

[ Voor 23% gewijzigd door Daos op 03-09-2016 14:01 ]

[.oisyn]

JRO is nuttig omdat je dan de loop logic niet nodig hebt.

Stel je array staat in de linker stack. Je leest een input X, en dan wil je het X'de element in de stack verhogen. Wat je dan moet doen is:
- Verplaats X-1 elementen naar de andere stack
- Verhoog de top van de stack
- Verplaats X-1 elementen weer terug.

Daar is JRO uitermate geschikt voor:

code:

mov up, down
jro down
mov left, right
mov left, right
mov left, right
mov left, right
mov left, acc
add 1
mov acc, left
jro down
mov right, left
mov right, left
mov right, left
mov right, left
nop

In de node eronder geef je gewoon de waarde die van boven komt 2x terug, en check je op 0 etc.

[Daos]

Ik had al ongeveer dezelfde code Zie mijn edit 3 minuten voor jouw bericht. Het tellen heb ik nu werkend met 3 nodes en het resetten van een reeks werkt ook al. Ik ga later vandaag kijken hoe ik hieruit de waarde krijg die het meeste voorkomt maar met nog 4 vrije nodes moet dat wel gaan lukken. Bedankt voor de tip!.

[storeman]

.oisyn schreef op zondag 30 augustus 2015 @ 13:57:

Die heb ik in 157/4/15

Je oplossing lijkt me nodeloos ingewikkeld

spoiler:

Bedenk een statemachine wat er moet gebeuren bij elke input. Je hoeft in feite niets te onthouden, de instruction pointer zegt genoeg. Alle logic kan in 1 node

Over Segment 40196 Signal Pattern Detector. Ik ben benieuwd waar je dat laatste beetje snelheid uit perst. Ik heb nu onderstaande code, maar hiermee kom ik op 177/4/15. Mijn eerste probeersel was ook nodeloos ingewikkeld en zo kwam ik op 473/7/29. Dus al een mooie vooruitgang geboekt. Ik vraag me af wat ik nu over het hoofd zie. Ik wil graag het laatste beetje er ook af schaven...

spoiler:

START:
MOV 0, DOWN
MOV UP, ACC
JGZ START
MOV 0, DOWN
MOV UP, ACC
JGZ START
MOV UP, ACC
JEZ FINISH
MOV 0, DOWN
JMP START
FINISH:
MOV 1, DOWN
JRO -5

[Daos]

Ik heb hem nu in 160/4/15

spoiler:

MOV UP, ACC
JNZ RS
MOV 0, DOWN
MOV UP, ACC
JNZ RS
MOV 0, DOWN
MOV UP, ACC
JNZ RS
L:MOV 1, DOWN
MOV UP, ACC
JEZ L
RS: MOV 0, DOWN

Hoe .oisyn dit in 157 (of misschien zelfs 125/5/30) kan zie ik ook niet.

En waarom gebruik je JRO -5? Je kan dan toch gewoon JMP label gebruiken? Een label en instructie kunnen trouwens samen op 1 regel.

[ Voor 11% gewijzigd door Daos op 04-09-2016 15:08 ]

[.oisyn]

Ik heb 125 idd momenteel. Met 39 outputs impliceert dat gemiddeld 3.2 cycles per output (of eigenlijk (125-4)/39 = 3.1 als je uitgaat van het feit dat het altijd minstens 4 cycles kost om een waarde van input naar output te moven over 4 nodes). Je zou zeggen dat het nooit in minder dan 4 cycles kan (read+compare+write = 4 cycles). De truc is dan ook om de compare logic te parallelliseren. Als je op 3 cycles per output wilt komen kun je niets anders dan 1 write + 1 extra andere instructie in je state machine. Het laat zich wel raden welke instructie dat dan is. Succes!

[ Voor 23% gewijzigd door .oisyn op 04-09-2016 15:46 ]

[Daos]

Ik heb de Signal Multiplexer (segment 22280) nu in 203/7/21. Best goed als je de grafiekjes moet geloven. En het algoritme is niet eens zo heel moeilijk.

[.oisyn]

Die heb ik ook op 203. Pretty straightforward idd, volgens mij is dat ook gewoon de limiet.

Wel heb ik zojuist Sequence Generator verbeterd van 105 naar 87

[.oisyn]

Heb nu 205 202 178 168 147 in Signal Edge Detector. Oude score was 283.

Kun je me eens adden op Steam? Gewoon ".oisyn"

.edit: hmpf de scores die hier staan zijn echt ziek

[ Voor 79% gewijzigd door .oisyn op 20-09-2016 02:21 ]

[.oisyn]

Btw, volgende maand komt er een nieuwe game van Zachtronics beschikbaar op Steam Early Access.
SHENZHEN I/O

Interessant

[Creepy]

.oisyn schreef op maandag 19 september 2016 @ 01:14:
Heb nu 205 202 178 168 147 in Signal Edge Detector. Oude score was 283.

Kun je me eens adden op Steam? Gewoon ".oisyn"

.edit: hmpf de scores die hier staan zijn echt ziek

Ik vond sommige scores van jou al redelijk.. eeh... ziek

[Gerco]

.oisyn schreef op woensdag 21 september 2016 @ 20:44:
Btw, volgende maand komt er een nieuwe game van Zachtronics beschikbaar op Steam Early Access.
SHENZHEN I/O

[video]

Interessant

Vet! Die naam is ook briljant natuurlijk. Ik kan alleen niet vinden hoe te pre-orderen of hoeveel 'ie moet kosten.

[.oisyn]

Daos schreef op zaterdag 17 september 2016 @ 00:53:
Ik heb de Signal Multiplexer (segment 22280) nu in 203/7/21. Best goed als je de grafiekjes moet geloven. En het algoritme is niet eens zo heel moeilijk.

166/9/47 nu

En ik denk dat ik wel weet hoe je dit verder kunt optimaliseren.
.edit: helaas dat leverde verder niets op.

[ Voor 15% gewijzigd door .oisyn op 22-09-2016 02:11 ]

[xChOasx]

Gerco schreef op donderdag 22 september 2016 @ 00:46:
[...]

Vet! Die naam is ook briljant natuurlijk. Ik kan alleen niet vinden hoe te pre-orderen of hoeveel 'ie moet kosten.

Ik heb 'm vorige week gekocht (Steam)! 14 euro ofzo.

Spel is ELKE cent waard en verdient een eigen topic!

[The Fox NL]

.oisyn schreef op donderdag 22 september 2016 @ 01:06:
[...]


166/9/47 nu

En ik denk dat ik wel weet hoe je dit verder kunt optimaliseren.
.edit: helaas dat leverde verder niets op.

Heb hem nu op 171/9/42

.oisyn:
gelukt, 5 eraf, zit nu voor Signal Multiplexer op 166/9/42 40 39! Door left en right om te draaien

[ Voor 19% gewijzigd door The Fox NL op 28-10-2016 00:07 . Reden: nog minder instructies ]

[.oisyn]

xChOasx schreef op zaterdag 22 oktober 2016 @ 08:04:
[...]


Ik heb 'm vorige week gekocht (Steam)! 14 euro ofzo.

Spel is ELKE cent waard en verdient een eigen topic!

Hij is leuk idd. Ik vind 'm alleen niet zo sterk als TIS-100. Tot nu toe vind ik de puzzels vooral een 'chore' en haal er niet heel veel voldoening uit. Het zijn er dan ook wel meteen een stuk meer dan TIS-100. Heb er nu een stuk of 15 gedaan oid? Heb niet het idee dat de campaign al bijna klaar is. De scores zijn dit weekend trouwens gereset wegens een nieuwe metric (instruction count) dus je moet alle oplossingen even opnieuw runnen. Bij veel puzzels heb ik bij die histogrammen zoiets als "WTF?! Hoe dan?". Of ik mis iets, of die stats kloppen niet helemaal

En ja, het verdient idd een eigen topic

The Fox NL schreef op donderdag 27 oktober 2016 @ 22:43:
[...]

Heb hem nu op 171/9/42

. Nog 6 eraf

[ Voor 27% gewijzigd door .oisyn op 27-10-2016 22:50 ]

[Boudewijn]

.oisyn schreef op donderdag 27 oktober 2016 @ 22:47:

En ja, het verdient idd een eigen topic

Bam. Shenzhen I/O

Ben ook aan dit spel verslaafd...

[The Fox NL]

Nieuwe scores:
Signal Multiplexer: 166/9/39
Exposure Mask Viewer: 557/7/55

[LightningBullet]

Voor degenen die interesse hebben:

TIS-100 zit in de huidige humble bundle, voor "wat je ervoor geeft" (Vanaf $1,- krijg je een steam versie).
De bundle is er nog tot (als ik goed heb gerekend) dinsdag 6 december 19:00.

https://www.humblebundle.com/nicks-staff-picks-bundle

[ Voor 13% gewijzigd door LightningBullet op 27-11-2016 10:09 . Reden: link toegevoegd ]

[frG]

LightningBullet schreef op zondag 27 november 2016 @ 10:08:
Voor degenen die interesse hebben:

TIS-100 zit in de huidige humble bundle, voor "wat je ervoor geeft" (Vanaf $1,- krijg je een steam versie).
De bundle is er nog tot (als ik goed heb gerekend) dinsdag 6 december 19:00.

https://www.humblebundle.com/nicks-staff-picks-bundle

Thanks, niet duur voor 1 dollar

Erg leuk spel, nog nooit in aanraking met assembly gekomen, maar lukt redelijk tot nu toe (nu nog erg makkelijke opdrachten natuurlijk).

Houden wij op tweakers ook een lijstje bij met scores per segment? Het is natuurlijk leuk om een segment op te lossen, maar wil graag weten of er een betere oplossing is en daar hopelijk dus ook weer van leren.

[LightningBullet]

Ik heb het spel zelf nog niet gespeeld. Naar aanleiding van dit topic (en het eigen topic) heb ik Shenzhen I/O gekocht (is van dezelfde maker). Kwam deze tegen, net gekocht, maar nog geen tijd gehad om te spelen helaas. Misschien vanavond even de eerste opdrachten proberen.

[Daos]

Ben laatst weer opnieuw begonnen. Eerste pagina bijna af en nu kom ik er pas weer achter dat JRO vaak best handig kan zijn. Vooral voor het ontvangen van commando's van andere nodes.

Mijn oude code voor een storage-node zag er zo uit (0 = read, 1 = write):

code:

MOV LEFT, ACC
JEZ R
MOV LEFT, ACC
JMP X
R: SWP
MOV ACC, LEFT
X: SAV

Dit is met JRO ook te schrijven als (3 = read, 1 = write):

code:

S: JRO LEFT
MOV LEFT, ACC
JMP S
MOV ACC, LEFT

Met wat swappen kan ik nu zelfs een 2e getal erin opslaan. Ook bij andere nodes heb ik nu veel meer ruimte voor andere instructies en houd ik bovendien de ACC vrij die ik eerst nodig had om het commando te verwerken.

[.oisyn]

Told you so

Overigens heeft Factorio mijn playtime op Steam ruimschoots die van TIS-100 overschreden (543h vs 238h)

[ Voor 49% gewijzigd door .oisyn op 07-07-2017 13:23 ]

[Daos]

Heb nu voor het eerst alle puzzels opgelost Heb daarmee nu ook alle achievements