Adds fromgrams from web ide on Sylvanite

Author: apblack

binaryTrees/drawTree.grace

@@ -0,0 +1,60 @@
+import "graphix" as graphix
+import "binaryTree" as tree
+import "unicode" as u
+
+class layout(t) {
+    // creates an object that lays-out the tree t
+    var col := 0
+    def locationOf = dictionary [ ]
+    method knuthLayout(root, depth) {
+        if (root.left.isEmpty.not) then { knuthLayout(root.left, depth + 1) }
+        locationOf.at(root) put(col@depth)
+        col := col + 1
+        if (root.right.isEmpty.not) then { knuthLayout(root.right, depth + 1) }
+    }
+
+    method draw(root) {
+        if (root.left.isEmpty.not) then {
+            drawEdgeFrom(locationOf.at(root)) to (locationOf.at(root.left))
+            draw(root.left)
+        }
+        if (root.right.isEmpty.not) then {
+            drawEdgeFrom(locationOf.at(root)) to (locationOf.at(root.right))
+            draw(root.right)
+        }
+        drawNode(locationOf.at(root), root.data)
+    }
+    knuthLayout(t.root, 0)
+    draw(t.root)
+}
+
+// Drawing stuff
+def g = graphix.create(200, 300)
+def scale = 20
+def offset = 15@30
+
+method drawNode(location, label) {
+    def shape = g.addCircle.setRadius(10).filled(true).colored "yellow".
+          at(location * scale + offset).draw
+    def labelText = g.addText.setContent(label).setFont "9px Arial".
+          at((location * scale) + offset - (2@6)).draw
+}
+
+method drawEdgeFrom(s) to (e) {
+    g.addLine.setStart((s * scale) + offset).setEnd((e * scale )+ offset).draw
+}
+
+// An example tree to demonstrate the algorithm
+def exampleTree = tree.with [ ]
+tournamentTree(exampleTree, 1, 10)
+method tournamentTree(grow, lo, hi) {
+    if (lo <= hi) then {
+        def k = ((lo + hi) / 2).truncated
+        def d = u.create("a".ord - 1 + k)
+        grow.at(k) put (d)
+        tournamentTree(grow, lo, k-1)
+        tournamentTree(grow, k+1, hi)
+    }
+}
+
+layout(exampleTree)

fallingApples/andrewsAppleLab.grace

@@ -0,0 +1,123 @@
+import "graphix" as graphix
+import "random" as random
+
+var graphics := graphix.create(200,700)
+
+//
+// Game class
+//
+class createAppleGame(numberOfApples)  {
+    method isBadGuess(char) -> Boolean{
+        // answers true if char has not been guessed before, and is not in the word.
+        // NOT IMPLEMENTED 
+        true
+    }
+    method wordSize -> Number {
+        // the size of the current word
+        // NOT IMPLEMENTED
+    }
+    method numberOfBadGuesses -> Number { numberOfApples }
+    
+    //  add more methods as required
+}
+
+def display = createDisplayForGame(createAppleGame(6))
+
+//
+// GameDisplay class
+//
+class createDisplayForGame(g) {
+    def trunk is public = graphics.addRectangle.at((110@75)).setSize(40@325).colored "SaddleBrown".filled(true).draw
+    def leaves is public = graphics.addEllipse.at((5@30)).setSize(250@140).colored "DarkGreen".filled(true).draw
+    //  NOT IMPLEMENTED - Create the correct number of apples. 
+    //  The starter code creates only one apple.
+    def apple1 = createAppleAt(50@70)
+    def newGameButton = graphics.addButton.setText "new game" .setSize(75@33).at(10@450).draw
+    def inputBox = graphics.addInputBox.setWidth(40).at(80@450).draw
+    // NOT IMPLEMENTED - starter code does not create the row of boxes for the letters to fill.
+    inputBox.onSubmitDo { apple1.fall }
+    newGameButton.onClick := {
+        // NOT IMPLEMENTED - should request the game to start over
+        apple1.at(50@75)
+        apple1.draw
+    }
+}
+
+//
+// wordList object
+//
+def wordList = object {
+    def words = list [
+        "Apple", "Apricot", "Avocado", "Banana", "Bilberry", "Blackberry", 
+        "Blackcurrant", "Blueberry", "Boysenberry", "Cantaloupe", "Currant", "Cherry", 
+        "Cherimoya", "Cloudberry", "Coconut", "Cranberry", "Damson", "Date", 
+        "Dragonfruit", "Durian", "Elderberry", "Feijoa", "Fig", "Grapefruit", "Guava", 
+        "Huckleberry", "Jackfruit", "Kiwi", "Kumquat", "Lemon", "Lime", "Loquat", 
+        "Lychee", "Mango", "Marionberry", "Melon", "Cantaloupe", "Honeydew", 
+        "Watermelon", "Mulberry", "Nectarine", "Olive", "Orange", "Clementine", 
+        "Mandarine", "Tangerine", "Papaya", "Passionfruit", "Peach", "Pear", 
+        "Persimmon", "Physalis", "Plum", "Pineapple", "Pomegranate", "Pomelo", 
+        "Mangosteen", "Quince", "Raspberry", "Salmonberry", "Raspberry", 
+        "Rambutan", "Redcurrant", "Satsuma", "Starfruit", "Strawberry", "Tamarillo"]
+
+    method atRandom -> String {
+      // returns one of the strings from in the list words, chosen at random.
+      def index = (random.between0And1 * words.size).truncated + 1
+      words.at(index)
+    }
+} 
+
+//
+// Apple class
+//
+class createAppleAt(position) {
+    inherits graphics.addCircle
+    self.at(position).setRadius 10.colored "YellowGreen".filled(true).draw
+    var applePath
+    def fallAction = {
+        if (applePath.isEmpty) then {
+            graphics.clearTicker
+        } else {
+            self.location := applePath.first
+            self.draw
+            applePath.removeFirst
+        }
+    }
+    
+    method fall {
+        applePath := fallPath
+        graphics.tickEvent(fallAction, 20)
+    }
+    method fallPath is confidential {
+        def duration = 500
+        def path = list [ ]
+        def gravity = 0@2
+        def damping = 0.5
+        var initial := self.location
+        def ground = initial.x@390
+        var tick := 0
+        var p := initial
+        while { p.y < ground.y } do {
+            // the fall from rest to the ground
+            // uses s = ut + (a.t^2)/2
+            tick := tick + 1
+            p := initial + (gravity * tick * tick / 2)
+            path.addLast(p)
+        }
+        var v := gravity * tick
+        repeat 5 times {
+            def u = (0@0) - (v * damping)
+            v := u
+            tick := 0
+            do {
+                // the bounce:
+                // uses s = ut + (a.t^2)/2 and v = u + at
+                tick := tick + 1
+                p := ground + (u * tick) + (gravity * tick * tick / 2)
+                v := u + (gravity * tick)
+                path.addLast(p)
+            } while { p.y < ground.y }
+        }
+        path
+    }
+}

fallingApples/graphixAnimation.grace

@@ -0,0 +1,61 @@
+import "graphix" as g
+
+// Create the graphics stage
+var graphics := g.create(200,400)
+
+def trunk = graphics.addRectangle.at(110@75).setSize(40@325).colored "SaddleBrown".filled(true).draw
+def leaves = graphics.addEllipse.at(5@30).setSize(250@140).colored "DarkGreen".filled(true).draw
+def apple = graphics.addCircle.at(50@70).setRadius 10 .colored "YellowGreen".filled(true).draw
+
+var applePath
+
+leaves.onMouseDownDo { print "mouse down" ; "error".wombat }
+leaves.onMouseUpDo { print "mouse up" ; "error".wombat  }
+// leaves.onMouseOverDo { print "mouse over"; "error".wombat  }
+
+apple.onClick := { 
+        applePath := fallPath
+        graphics.tickEvent(fall, 20)
+}
+method fallPath {
+    def duration = 500
+    def path = list [ ]
+    def gravity = 0@2
+    def damping = 0.5
+    var initial := apple.location
+    def ground = initial.x@390
+    var tick := 0
+    var p := initial
+    while { p.y < ground.y } do {
+        // the fall from rest to the ground
+        // uses s = ut + (a.t^2)/2
+        tick := tick + 1
+        p := initial + (gravity * tick * tick / 2)
+        path.addLast(p)
+    }
+    var v := gravity * tick
+    repeat 5 times {
+        def u = (0@0) - (v * damping)
+        v := u
+        tick := 0
+        do {
+            // the bounce:  
+            // uses s = ut + (a.t^2)/2 and v = u + at
+            tick := tick + 1
+            p := ground + (u * tick) + (gravity * tick * tick / 2)
+            v := u + (gravity * tick)
+            path.addLast(p)
+        } while { p.y < ground.y }
+    }
+    path
+}
+
+
+def fall = {
+    if (applePath.isEmpty) then { 
+        graphics.clearTicker
+    }
+    apple.location := applePath.first
+    apple.draw
+    applePath.removeFirst
+}

joeTheBox/boxesUnderGravity.grace

@@ -0,0 +1,73 @@
+dialect "objectdraw"
+import "noahBox" as box
+import "animation" as anim
+inherits graphicApplicationSize(1000@1000)
+
+// Noah Zentzis
+// CS 420 (Object Oriented Programming)
+// HW 1 - Dancing Boxes
+// April 5, 2016
+
+def boundary = filledRectAt(0@0) size (1000@1000) on (canvas)
+boundary.color := color.neutral
+boundary.addToCanvas(canvas)
+
+startGraphics
+
+def alice = box.named "A"
+alice.showOn(canvas)
+alice.moveTo(450@450)
+
+def bob = box.named "B"
+bob.showOn(canvas)
+bob.moveTo(550@550)
+
+def nullForce = object {
+    method calculate(state, time) { 0@0 }
+}
+
+var mouseForce := nullForce
+
+class gravity.towards(positionBlock) and(other) {
+    def posBlock = positionBlock
+    def last = other
+    
+    method calculate(state, time) {
+        // F_g = 0.5 * (G * m1 * m2) / (d ^ 2)
+        // not using real gravity, because this is more interesting
+        def pos = posBlock.apply
+        def dist = state.position.distanceTo(pos)
+        def multiplier = 0.5 * 20000 / (dist)
+        def vector = (pos) - state.position
+        def unit = vector / vector.length
+        
+        (unit * multiplier) + last.apply.calculate(state, time)
+    }
+}
+
+method onMousePress(pt:Point) -> Done {
+    mouseForce := gravity.towards { pt } and {nullForce}
+}
+
+method onMouseDrag(pt:Point) -> Done {
+    mouseForce := gravity.towards { pt } and {nullForce}
+}
+
+method onMouseRelease(pt:Point) -> Done {
+    mouseForce := nullForce
+}
+
+def bobForce = gravity.towards {alice.position} and {mouseForce}
+def aliceForce = gravity.towards {bob.position} and {mouseForce}
+
+anim.while {true} pausing 10 do {
+    alice.moveFor(0.01) accelerating(aliceForce)
+    bob.moveFor(0.01) accelerating(bobForce)
+    
+    if(alice.isOutsideBounds(1000@1000)) then {
+        alice.repositionInside(1000@1000)
+    }
+    if(bob.isOutsideBounds(1000@1000)) then {
+        bob.repositionInside(1000@1000)
+    }
+}