Commits

Anonymous committed dfa9ddb

Import of worb version 1.1 revision 2011.0428 (yoob implementation.)

  • Participants
  • Parent commits 8b5d215
  • Tags rel_1_1_2011_0428

Comments (0)

Files changed (5)

+# Makefile for worb (yoob version).
+# $Id$
+
+JAVAC?=javac
+JAVA?=java
+JAR?=jar
+PATHSEP?=:
+
+JFLAGS?=-Xlint:deprecation -Xlint:unchecked
+CDIR=bin/tc/catseye/worb
+CLASSES=$(CDIR)/WorbState.class
+
+YOOBDIR?=../../../lab/yoob
+CLASSPATH?=bin$(PATHSEP)$(YOOBDIR)/bin
+
+all: $(CLASSES)
+
+$(CDIR)/WorbState.class: src/WorbState.java
+	$(JAVAC) $(JFLAGS) -cp "$(CLASSPATH)" -d bin src/WorbState.java
+
+clean:
+	rm -rf $(CDIR)/*.class
+
+test: $(CLASSES)
+	$(JAVA) -cp "$(CLASSPATH)" tc.catseye.yoob.GUI tc.catseye.worb.WorbState

File bin/README.txt

+This is where compiled Java classfiles will go.

File doc/worb.html

File contents unchanged.

File make-cygwin.sh

+#!/bin/sh -x
+make \
+    JAVAC='"/cygdrive/c/Program Files/Java/jdk1.6.0_22/bin/javac"' \
+    JAVA='"/cygdrive/c/Program Files/Java/jre6/bin/java"' \
+    PATHSEP=';' \
+    $*

File src/WorbState.java

+/*
+ * tc.catseye.worb.WorbState -- noit o'mnain worb for yoob
+ */
+
+/*
+ * Copyright (c)2011 Cat's Eye Technologies.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ *   Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in
+ *   the documentation and/or other materials provided with the
+ *   distribution.
+ *
+ *   Neither the name of Cat's Eye Technologies nor the names of its
+ *   contributors may be used to endorse or promote products derived
+ *   from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * A tc.catseye.worb.WorbState implements the semantics of the
+ * noit o'mnain worb automaton under the yoob framework.
+ *
+ * This class targets version 0.2 of the yoob framework's interface,
+ * which isn't released yet, so knowing this doesn't help you much.
+ */
+
+package tc.catseye.worb;
+
+import tc.catseye.yoob.Error;
+import tc.catseye.yoob.*;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Random;
+import java.util.Iterator;
+
+
+class Worb implements Language {
+    public String getName() {
+        return "noit o' mnain worb";
+    }
+
+    public int numPlayfields() {
+        return 1;
+    }
+
+    public int numTapes() {
+        return 0;
+    }
+
+    public boolean hasProgramText() {
+        return false;
+    }
+
+    public boolean hasInput() {
+        return false;
+    }
+
+    public boolean hasOutput() {
+        return false;
+    }
+
+    public List<String> exampleProgramNames() {
+        ArrayList<String> names = new ArrayList<String>();
+        names.add("freefill");
+        names.add("magnetic field");
+        names.add("theory of time");
+        names.add("pressure");
+        names.add("slow loop");
+        names.add("fast loop");
+        names.add("transistor");
+        names.add("or gate");
+        names.add("subtraction");
+        names.add("division");
+        return names;
+    }
+
+    public WorbState loadExampleProgram(int index) {
+        String[][] program = {
+          {
+            /* eg/freefill.worb */
+            "######################",
+            "#                    #",
+            "#                    #",
+            "#                    #",
+            "#                    #",
+            "#                    #",
+            "#         +          #",
+            "#                    #",
+            "#                    #",
+            "#                    #",
+            "#                    #",
+            "######################",
+          },
+          {
+            /* eg/magnetic-field.worb */
+            "######################",
+            "#                    #",
+            "#                    #",
+            "#                    #",
+            "#                    #",
+            "#         -          #",
+            "#         +          #",
+            "#                    #",
+            "#                    #",
+            "#                    #",
+            "#                    #",
+            "######################",
+          },
+          {
+            /* eg/theory-of-time.worb */
+            "######################",
+            "#..........          #",
+            "#..........          #",
+            "#..........          #",
+            "#..........          #",
+            "#..........          #",
+            "#..........          #",
+            "#..........          #",
+            "#..........          #",
+            "#..........          #",
+            "#..........          #",
+            "######################",
+          },
+          {
+            /* eg/pressure.worb */
+            "#######################",
+            "#..........>          #",
+            "#######################",
+          },
+          {
+            /* eg/slow-loop.worb */
+            "#####################",
+            "#        <          #",
+            "# ################# #",
+            "# #               # #",
+            "# #               #.#",
+            "# #               # #",
+            "# ################# #",
+            "#         >         #",
+            "#####################",
+          },
+          {
+            /* eg/fast-loop.worb */
+            "#######",
+            "# < < #",
+            "# ### #",
+            "# >.> #",
+            "#######",
+          },
+          {
+            /* eg/transistor.worb */
+            "    ###",
+            "### #+#",
+            "#+# # #",
+            "# ###v#",
+            "#   < #",
+            "### < #",
+            "  # < #",
+            "  ###v#",
+            "    # #",
+            "    #!#",
+            "    #-#",
+            "    ###",
+            "",
+          },
+          {
+            /* eg/or-gate.worb */
+            "#####         #####",
+            "#   ###########   #",
+            "# . >         < . #",
+            "#   #####v#####   #",
+            "#####   #  ########",
+            "        #       >!#",
+            "        #v#########",
+            "        # #",
+            "        ###",
+          },
+          {
+            /* eg/subtraction.worb */
+            "###############",
+            "#.............#",
+            "#######v#######",
+            "      #       #",
+            "      #########",
+            "",
+          },
+          {
+            /* eg/division.worb */
+            "############",
+            "#..........#",
+            "#######v####",
+            "      #    #",
+            "      #v####",
+            "      #    #",
+            "      #v####",
+            "      #    #",
+            "      #v####",
+            "      #    #",
+            "      ######",
+          },
+        };
+        WorbState s = new WorbState();
+        s.playfield.load(program[index]);
+        return s;
+    }
+
+    public List<String> getAvailableOptionNames() {
+        ArrayList<String> names = new ArrayList<String>();
+        return names;
+    }
+
+    public WorbState importFromText(String text) {
+        WorbState s = new WorbState();
+        s.playfield.load(text.split("\\r?\\n"));
+        return s;
+    }
+  
+    private static final String[][] properties = {
+        {"Author", "Chris Pressey"},
+        {"Implementer", "Chris Pressey"},
+        {"Implementation notes",
+         "None yet."}
+    };
+
+    public String[][] getProperties() {
+        return properties;
+    }
+}
+
+class Bobule implements Element {
+    int pressure;
+    
+    public Bobule() {
+        pressure = 1;
+    }
+
+    public String getName() {
+        if (pressure == 1)
+            return ".";
+        if (pressure >= 2 && pressure <= 3)
+            return "o";
+        if (pressure >= 4 && pressure <= 6)
+            return "O";
+        return "@";
+    }
+
+    public boolean equals(Element e) {
+        return e instanceof Bobule; // a bobule is a bobule is a bobule!
+    }
+
+    public Bobule fromChar(char c) {
+        return new Bobule();
+    }
+}
+
+class WorbPlayfield extends BasicPlayfield<Element> {
+    protected HashMap<Position, Bobule> bobuleMap;
+    private Random rand;
+
+    public WorbPlayfield() {
+        super(new CharacterElement(' '));
+        bobuleMap = new HashMap<Position, Bobule>();
+        rand = new Random();
+    }
+
+    public WorbPlayfield clone() {
+        WorbPlayfield c = new WorbPlayfield();
+        c.copyBackingStoreFrom(this);
+        c.bobuleMap = new HashMap<Position, Bobule>(
+          (Map<Position, Bobule>)this.bobuleMap
+        );
+        return c;
+    }
+
+    public Element get(IntegerElement x, IntegerElement y) {
+        Bobule bobule = bobuleMap.get(new Position(x, y));
+        return (bobule == null) ? getBackground(x, y) : bobule;
+    }
+
+    public CharacterElement getBackground(IntegerElement x, IntegerElement y) {
+        return (CharacterElement)super.get(x, y);
+    }
+
+    public void step() {
+        Set<Position> bobulePositions = new HashSet<Position>(bobuleMap.keySet());
+        Iterator<Position> it = bobulePositions.iterator();
+
+        while (it.hasNext()) {
+            Position p = it.next();
+            Bobule b = bobuleMap.get(p);
+
+            b.pressure++;
+            IntegerElement new_x = p.getX().add(new IntegerElement(rand.nextInt(3) - 1));
+            IntegerElement new_y = p.getY().add(new IntegerElement(rand.nextInt(3) - 1));
+            Element e = get(new_x, new_y);
+            if (e instanceof Bobule) {
+                continue;
+            } else if (e instanceof CharacterElement) {
+                char c = ((CharacterElement)e).getChar();
+                if (c == '#')
+                    continue;
+                if (c == '<' && p.getX().compareTo(new_x) < 0)
+                    continue;
+                if (c == '>' && p.getX().compareTo(new_x) > 0)
+                    continue;
+                if (c == '^' && p.getY().compareTo(new_y) < 0)
+                    continue;
+                if (c == 'v' && p.getY().compareTo(new_y) > 0)
+                    continue;
+                // print chr(7) if $playfield[$new_x][$new_y] eq '!';
+            } else {
+                // No other possibilities
+            }
+            bobuleMap.remove(p);
+            b.pressure = 1;
+            bobuleMap.put(new Position(new_x, new_y), b);
+        }
+
+        Iterator<Map.Entry<Position, Element>> cit = store.entrySet().iterator();
+        while (cit.hasNext()) {
+            Map.Entry<Position, Element> entry = cit.next();
+            Position p = entry.getKey();
+            char c = ((CharacterElement)entry.getValue()).getChar();
+          
+            if (c == '+') {
+                Bobule b = bobuleMap.get(p);
+                if (b == null && rand.nextInt(10) == 0) {
+                    b = new Bobule();
+                    bobuleMap.put(p, b);
+                }
+            } else if (c == '-') {
+                Bobule b = bobuleMap.get(p);
+                if (b != null && rand.nextInt(10) == 0) {
+                    bobuleMap.remove(p);
+                }
+            }
+        }
+    }
+
+    public void loadChar(int x, int y, char c) {
+        if (c == '.') {
+            bobuleMap.put(new Position(x, y), new Bobule());
+        } else {
+            set(x, y, new CharacterElement(c));
+        }
+    }
+
+}
+
+public class WorbState implements tc.catseye.yoob.State {
+    protected WorbPlayfield playfield;
+    protected BasicPlayfieldView view;
+    private static final Worb language = new Worb();
+    
+    public WorbState() {
+        playfield = new WorbPlayfield();
+        view = new BasicPlayfieldView();
+    }
+    
+    public WorbState clone() {
+        WorbState c = new WorbState();
+        c.playfield = this.playfield.clone();
+        return c;
+    }
+
+    public Language getLanguage() {
+	return language;
+    }
+
+    public List<Error> step(World world) {
+        ArrayList<Error> errors = new ArrayList<Error>();      
+        playfield.step();
+        return errors;
+    }
+
+    public Playfield getPlayfield(int index) {
+        return playfield;
+    }
+
+    public Tape getTape(int index) {
+        return null;
+    }
+
+    public String getProgramText() {
+        return "";
+    }
+
+    public int getProgramPosition() {
+        return 0;
+    }
+
+    public List<Error> setProgramText(String text) {
+        ArrayList<Error> errors = new ArrayList<Error>();
+        return errors;
+    }
+
+    public View getPlayfieldView(int index) {
+        return view;
+    }
+
+    public View getTapeView(int index) {
+        return null;
+    }
+
+    public String exportToText() {
+        return playfield.dump();
+    }
+
+    public void setOption(String name, boolean value) {
+    }
+
+    public boolean needsInput() {
+        return false;
+    }
+
+    public boolean hasHalted() {
+        return false;
+    }
+}