DEV Community: Kira L

Making Your First Game in Blue

Kira L — Wed, 11 Aug 2021 23:18:40 +0000

Hello everyone! Today, I'm writing a post about how to get started with Blue. Blue is a creative, graphical, and browser-based programming language which makes it easy and enjoyable to get started with programming. First off, you can check it out at https://blue-js.herokuapp.com. Blue is also open source, and its GitHub is https://github.com/i8sumPi/blue.

In this tutorial, we'll be making a carrot catching game, with only 25 lines of code (try it here)

The Code!

Let's start by drawing our main character. We can do this using:

var player = new Premade(costume, x, y, size)

We replace the word "costume" with the character that we want, and x and y with the coordinates of where we want to place our new character.

Blue uses the same coordinate system as Scratch. The x axis goes from -240 to 240, and the y axis goes from -180 to 180.

In our case, we can use:

var player = new Premade("bunny1_ready", 0, -112, 0.4)

This places the bunny in the bottom-middle, and makes its size 0.4 of the original. Note that the name of the costume must be in quotations.

If you would like to use a different character than the bunny, go into the documentation > premade characters and sounds > all images.

The Background

Now let's draw a simple background. We can draw it using rectangles. Rectangles are created using:

new Rectangle(x, y, width, height, color)

The x and y values of a rectangle represent the coordinates of the top-left corner. The color can be a string with the color name, like "red" or "blue", but if you want more detail, you can also use hexidecimal colors. You can find a hexidecimal color using htmlcolorcodes.com.

In our case, we want a blue sky and a green ground, which can be done using:

new Rectangle(-240,180, 480, 360, "#D0F8FF") # sky
new Rectangle(-240, -150, 480, 30, "green") # ground

Note that the grey text after a # does not run. It is a comment, and its purpose is just to remind us of what we're doing.

Note: if you don't see the bunny anymore after drawing the background, you drew the background over it. You can put the bunny on top by either putting the bunny's code after the background, or by adding the line player.layer = 1. A layer of 1 or more brings a character to the top, and a negative layer brings it underneath.

Motion

We need to make the bunny follow the mouse. We can do this with the following code:

forever:
    player.x = mouse.x

The code inside the forever loop runs constantly. The second line is setting the player's x position to the mouse's x position. This means that at every moment, the player is moving to where the mouse is, or in other words, the mouse is moving the player.

How does Blue know what is inside or outside the forever loop? It's pretty simple—code that is inside the forever loop is indented. This indented chunk of code is known as a code block. Code that isn't inside the forever loop isn't indented.

An example of this (that doesn't relate to the current project, so don't add this to your code):

forever:
    print("I am inside the forever loop")
    print("I am also inside the forever loop")
print("I am not inside the forever loop")

Note that you can also have a code block within a code block, or a code block within a code block within a code block. To do this, you simply use multiple indentations.

Clones

Now we need to generate many many many carrots :D

In order to keep track of the carrots, we will use a list. A list is a special kind of variable that can hold multiple values. We initialize (start) a new, empty list using:

var carrots = []

We can add lots of carrots using:

var carrots = []
repeatEvery 0.3:
    carrots.push(new Premade("crop_carrot", random(-230, 230), 180))

Let's break down this code. new Premade("crop_carrot", random(-230, 230), 180) is creating a new carrot with a random x value, and a y value of 180, which puts it at the top of the screen. random(-230, 230) returns a random value from -230 to 230.

carrots.push() adds this newly generated carrot to our list called carrots.

repeatEvery 0.3 repeats the code below it every 0.3 seconds. You can change the difficulty of the game by changing this number, for example, if you used repeatEvery 0.5 instead, the carrots would appear more slowly, and the game would be easier. When you run this code, you should see lots of carrots appearing at the top of the screen.

Moving the carrots

We can move each carrot down by using a forEach loop. The forEach loop will iterate through (or go through each one of) the carrots so that we can move each carrot down. We add it to the end of our already existing forever loop in order to do this constantly. Note that the first two lines of this code are from the forever loop that we already have.

forever:
    player.x = mouse.x
    forEach carrot in carrots:
    carrot.y -= 10

carrot.y -= 10 is shorthand for carrot.y = carrot.y - 10. It just moves the carrot's y position down by 10.

Score

We can display the score using a text. You create a new text using:

new Text(text, x, y, font size)

We need one variable to be the text that displays the score, and another to store the score itself.

var scoreCounter = new Text("Score: 0", 0, 0, 20)
var score = 0

In order to update the score whenever the bunny touches a carrot, we can use distanceTo. We add this to the end of our forEach loop:

    if carrot.distanceTo(player) < 50:
    carrot.delete()
    score += 1
    scoreCounter.text = "Score: "+score
    new Sound("jingles_PIZZI16", 0.2)

carrot.delete() deletes the carrot so it disappears.

score += 1 adds 1 to the score.

scoreCounter.text = "Score: "+score updates the score display.

new Sound("jingles_PIZZI16", 0.2) plays the bu-dup sound. The 0.2 means it is 0.2 of the original volume. You can choose another sound in Blue Documentation > Premade Characters and Sounds > All sounds.

Losing

The last thing to add is making the game stop when you miss a carrot. We can do this by checking if any carrot's y is less than -240, which is the bottom of the screen, and if so, stop the game. So, we can add this to the bottom of our forEach loop:

    if carrot.y < -240:
    scoreCounter.text = "You missed a carrot! Your score was "+score+"."
    pause()
    new Sound("jingles_PIZZI01")

The pause() freezes the game at that moment. The new Sound("jingles_PIZZI01") plays the losing sound.

Music

As a final touch, we need to add some music to complete the vibe. The 1 means to keep 100% of the volume, and the true indicates that you want the music to loop as the game continues.

new Sound("bensound-jazzyfrenchy", 1, true)

You're Finished!

Congrats on finishing your first game in Blue! Feel free to share it with your friends, and start another project of your own. Thanks for reading!

The Final Code:

new Sound("bensound-jazzyfrenchy", 1, true) # background music
new Rectangle(-240,180, 480, 360, "#D0F8FF") # sky
new Rectangle(-240, -150, 480, 30, "green") # ground

var carrots = [] # store carrots
var player = new Premade("bunny1_ready", 0, -112, 0.4)
var scoreCounter = new Text("Score: 0", 0, 0, 20)
var score = 0

forever:
    player.x = mouse.x
    forEach carrot in carrots:
    carrot.y -= 10
    if carrot.distanceTo(player) < 50:
    carrot.delete()
    score += 1
    scoreCounter.text = "Score: "+score
    new Sound("jingles_PIZZI16", 0.2)
    if carrot.y < -240:
    scoreCounter.text = "You missed a carrot! Your score was "+score+"."
    pause()
    new Sound("jingles_PIZZI01")

repeatEvery 0.3:
    carrots.push(new Premade("crop_carrot", random(-230, 230), 180))

2048 Circle

Kira L — Mon, 28 Sep 2020 13:39:19 +0000

For those of you who love the game 2048, please check out my new variation: 2048 Circle!

There are a ton of variations on the game (in fact, the game itself is a variation of 1024), however none have experimented with a non-square board. When the board is a circle, the game becomes just a bit harder to predict, so there is no simple strategy.

I made this game from scratch, not by forking the original game. If you are interested in making your own 2048 variation, check out the GitHub repository. Using some fancy array tricks, I was able to create the whole thing with just around 200 lines of JavaScript.

Lastly, check out the product hunt page for more info.

Hope you enjoy!

Making an Online Beard-ifier

Kira L — Tue, 22 Sep 2020 12:30:47 +0000

Were you made for facial hair? Well there's only one way to find out: my online beard-ifier.

For this project, my internet was too slow to download a facial recognition dataset, so I used face-api.js.

face-api gives 68 reference points of the face. For example, there are points that may represent the center of the eye, or the bottom of the chin. I was able to combine these reference points into the shape of a beard, and then draw it using the HTML5 canvas. After looking at tons of pictures of beards on the internet (I now get lots of ads for beard products), I was able to design/copy my favorite 5 beard styles!

If you are interested in making your own facial recognition project, check out my source code on GitHub.

Hope you enjoy!

Walking AI: Simple Neural Network from Scratch

Kira L — Fri, 04 Sep 2020 01:03:14 +0000

In this tutorial, we are going to make a walking or running AI from scratch in JavaScript, with matter.js as the physics engine. If you don't plan on using JavaScript or matter.js, you can certainly follow along, but you will have to rewrite the code. If you would like to watch a video about this, go here. The final project can be seen here, and the GitHub repository is here.

As a disclaimer, this is not an end-to-end tutorial. I explain the most difficult parts, but it is up to you to do the parameter-fiddling, graphics, and general structure.

What We Will Cover:

Making the Robot
The Machine Learning
- Getting the inputs
- Running the neural network
- Drawing the Robot
- Displaying Its (Currently Random) Gait
The Genetic Algorithm
- How to Rank the Robots
- Which Robots Should Reproduce, and How Many?
- The Reproduction
Parameters to Fiddle With
My Final Result

Making the Robot

Over half of the source code is just making the robots exist. If you haven't used matter.js before, you can download it here. You can read the whole documentation here, but the functions we will need are:

//set up
const {Engine,Composite,Render,World,Bodies,Body,Detector,Constraint,Runner} = Matter;
var engine = Engine.create();
var runner = Runner.create();

// creates a static rectangle (can't move)
var ground = Bodies.rectangle(x, y, width, height, {isStatic: true, collisionFilter: {
    category: 1
}});

//creates a rectangle that can be moved
Bodies.rectangle(x, y, width, height, paramsObject);

//creates a circle that can be moved
Bodies.circle(x, y, radius, paramsObject);

//draws a rectangle/circle/polygon in the HTML canvas
ctx.beginPath();
ctx.moveTo(verts[0].x, verts[0].y)// go to the first vertex
for (var i = 1; i < verts.length; i++) {
    ctx.lineTo(verts[i].x, verts[i].y); // draw each of the next verticies
}
ctx.lineTo(verts[0].x, verts[0].y); //go back to the first one
ctx.fill(); // fill it
ctx.stroke(); // add a border

//makes an object that won't intersect with anything
var paramsObject = {
    collisionFilter: {
        category: 2,
        group: Body.nextGroup(false),
        mask: 1
    },
    // other parameters such as friction, density, etc. here
}
//and then pass paramsObject into where you create the rectangle/circle

//add something to the world
World.add(engine.world, [list of things to add])

Since more than one robot will race at a time, we will create a class called Bob (the robots are named Bob), and a list called bobs which will store all of the Bobs.

var ground = Bodies.rectangle(600, 600, 1200, 100, {isStatic: true, collisionFilter: {category: 1}});
var bobs = [];

class Bob{
    constructor(weights){
        // Make all of the body parts here.
        // I won't include the code to make the body parts because it's too long.
        // Go to graphics.js in the source code if you want to copy exactly how I did it,
        // but I would recommend designing the robot on your own.

        // add all of the body parts to the world
        World.add(engine.world, [
            ground,
            this.rightThigh, 
            this.leftThigh, 
            this.rightShin, 
            this.leftShin, 
            this.torso, 
            this.head, 
            this.arm, 

            this.leftTorsoToLeg, 
            this.rightKnee, 
            this.leftKnee, 
            this.rightTorsoToLeg, 
            this.sholder,
            this.neck
        ]);
        bobs.push(this); //add this to the list of bobs
    }
    draw(col){
        //draws each limb in the color specified
        appearRect(this.leftThigh.vertices, col);
        appearRect(this.leftShin.vertices, col);

        appearRect(this.rightThigh.vertices, col);
        appearRect(this.rightShin.vertices, col);

        appearRect(this.torso.vertices, col);
        appearCirc(this.head, col);
        appearRect(this.arm.vertices, col);
    }
}

The appearRect and appearCirc functions draw the rectangles and circles (you can write the functions yourself). Now, every time you want to create a robot, use new Bob([list of weights]). When you want to draw all of the robots, just iterate through the list bobs and draw() each of them. To remove all of the robots, you need to use:

World.clear(engine.world);
Engine.clear(engine);
bobs = [];

The Machine Learning

For this project, I did not use tensorflow.js or any other machine learning library. Implementing a very simple neural network and Genetic Algorithm from scratch is surprisingly easy if you understand the theory behind it!

I started with the most simple neural network possible, and never actually ended up needing anything more complicated. This neural network has neither biases (the biases actually made it worse) nor hidden layers. All it does is take 7 inputs with information about where the robot is, multiplies them by the appropriate weights, and gives 4 outputs which describe where the robot should move in the future.

Getting the inputs

Just like any other machine learning project, we need to start with the data preprocessing. We generally want all of the inputs to be from 0-1, but this isn't strict. If there is a specific input that you think is 5 times as important, try making it range from 0-5 instead of from 0-1.

// obj is the robot to be moved
var inputs = [
    obj.leftTorsoToLeg.angleA/Math.PI/2, //angle of left torso
    obj.rightTorsoToLeg.angleA/Math.PI/2, //angle of right torso
    obj.rightKnee.angleA/Math.PI/2, //angle of right knee
    obj.leftKnee.angleA/Math.PI/2, //angle of left knee
    obj.torso.angle/Math.PI/2, //angle of torso
    1/(1+Math.E**(550-obj.leftShin.bounds.max.y)), //lowest point off the ground of the left shin
    1/(1+Math.E**(550-obj.rightShin.bounds.max.y)) //lowest point off the ground of right shin
];

Let's explain what each of these inputs are. First, we will break down 1/(1+Math.E**(550-obj.something.bounds.max.y))). 550-obj.something.bounds.max.y is the distance from the limb's lowest point to the ground, and 1/(1+Math.E**x)) is a sigmoid. We include a sigmoid because the distance from the ground can be extremely large or extremely small, and we need to normalize it.

obj.leftTorsoToLeg.angleA/Math.PI/2 is the angle of the left hip. We divide by Math.PI/2 so that all of the angles range from 0 to 1 instead of from 0 to 2PI.

Running the neural network

var outputs = [0,0,0,0,0];

for (var i = 0; i < 35; i++) {
    outputs[Math.floor(i/5)] += obj.weights[i] * inputs[i%7];
}

The % operator is the modulus, or the remainder when divided by 7. The code above is a shorter way of writing

var outputs = [0,0,0,0,0];

outputs[0] += obj.weights[0] * inputs[0];
outputs[0] += obj.weights[1] * inputs[1];
outputs[0] += obj.weights[2] * inputs[2];
outputs[0] += obj.weights[3] * inputs[3];
outputs[0] += obj.weights[4] * inputs[4];
outputs[0] += obj.weights[5] * inputs[5];
outputs[0] += obj.weights[6] * inputs[6];

outputs[1] += obj.weights[7] * inputs[0];
outputs[1] += obj.weights[8] * inputs[1];
outputs[1] += obj.weights[9] * inputs[2];
...
outputs[4] += obj.weights[28] * inputs[4];
outputs[4] += obj.weights[29] * inputs[5];
outputs[4] += obj.weights[30] * inputs[6];

Each of the outputs is the linear combination of the inputs and its weights. The first output uses weights 0-6, the 2nd uses 7-12, the 3rd uses 13-18, the 4th uses 19-24, and the 5th uses 25-30.

obj.weights is a list containing all of the weights for that specific robot. For example, the winning weights in my program look like:

[0.18834910252749903,-0.42210118210117537,-0.282405069062347,-0.18779796377809643,0.35392962793905547,0.08652163281465311,-0.1683227913757347,0.27437336159984244,-0.15736460024327373,0.14172118611462192,-0.4330814082625428,0.28958751579459086,-0.2359942212566043,0.3178187768335743,0.13653278898043975,-0.45054794905994267,-0.06280852816771779,-0.3340736301275634,-0.1783600329925001,0.17661413127755907,-0.4968709401087665,-0.04941657163272649,0.0806457051422557,-0.10155357399245674,0.107063353032232954,-0.4223661866478451,-0.2831760111970353,0.3557805746944544,0.25778944810578747,0.24074724355018923,0.47785061674252083,0.2546941475880225,-0.2816248228446361,0.0388214927192042,0.39670983755588035,-0.08301800688060372,-0.05630540145803672,-0.09999896706725496,-0.008475885592672955,0.039582396033190456]

The genetic algorithm is the part chooses these weights. Until we make that, obj.weights can just be completely random.

Moving the robot

Now, once we have the outputs, we have to actually move the robot. In matter.js, it looks like this:

// move the body parts with the outputs of the NN
Body.setAngularVelocity(obj.rightThigh,activation(outputs[0]));
Body.setAngularVelocity(obj.leftThigh,activation(outputs[1]));
Body.setAngularVelocity(obj.rightShin,activation(outputs[2]));
Body.setAngularVelocity(obj.leftShin,activation(outputs[3]));
Body.setAngularVelocity(obj.arm,activation(outputs[4]));

var activation = x=>Math.sin(x);

This code sets the angular velocity of each of the limbs to the neural network's output. The angular velocity is basically how much the limb is turning. You canalso have the neural network control the angles themselves, or the angles of the joints instead of limbs, etc.

For the activation function, I found that a sine wave worked best. You can use a different (more normal) activation function if you would like to as well.

Displaying Its (Currently Random) Gait

We will need to display this gait, even though it is currently terrible. I will not go over the actual code for the graphics part, but 4 things are executed every 30 milliseconds:

moves the time in matter js forward 30 milliseconds.
displays the background and then draws each of the robots (64 of them run at a time).
moves each the robots based on their (currently random) neural networks.
checks if any robots died, and whether or not it should start a new generation.

The Genetic Algorithm

When you run the neural network now, it obviously won't walk, because it's random!

So, we have to teach it to learn. To do this, we will us the most simple possible genetic algorithm: asexual reproduction. This is split into three parts: ranking the robots, choosing which robots to reproduce, and the actual reproduction.

How to rank the robots

Once a robot's head goes below the red line (70 pixels off the ground), it dies. When a robot dies, it cannot move anymore. Also, to speed up training time, all the robots die after 10 seconds. The robots are then ranked by distance traveled before dying. Once all of the robots have died, the current generation ends and a new generation starts. You can tweak the ranking system, or completely change it, if needed.

//obj is the robot currently being moved
if(obj.head.bounds.max.y > 480 || timePassed > 100){
    //kill a robot. 
    //sets each body part static so the computer doesn't spend effort moving the dead body parts anymore
    Body.setStatic(obj.rightThigh, true); 
    Body.setStatic(obj.leftThigh, true); 
    Body.setStatic(obj.rightShin, true); 
    Body.setStatic(obj.leftShin, true); 
    Body.setStatic(obj.torso, true); 
    Body.setStatic(obj.arm, true); 
    Body.setStatic(obj.head, true); 

    obj.distanceTraveled = closestPos(obj); // the closest position to the starting line

    numberBotsDead++;
    if(numberBotsDead == bobs.length){
        endGeneration();
    }
}

function closestPos(ob){
    var limbs = [
        ob.rightThigh.bounds.min.x, // the limb's lowest x position
        ob.leftThigh.bounds.min.x, 
        ob.rightShin.bounds.min.x, 
        ob.leftShin.bounds.min.x, 
        ob.torso.bounds.min.x, 
        ob.arm.bounds.min.x, 
        ob.head.bounds.min.x, 
    ];
    return Math.min(...limbs); //the lowest of each limb's lowest x positions
}

Which Robots Should Reproduce, and How Many?

Now, we have to choose which robots to kill, save, and reproduce. First, we need to rank the robots based on distance traveled:

// bobs is the list of robots in the previous generation
var sorted = bobs.sort((a,b)=>{
    return b.distanceTraveled - a.distanceTraveled;
});

Now the first element in sorted is the best robot, and the last element in sorted is the worst.

Next, we will add the variations. We can't just add 64 of the best robot because it would prematurely kill new ideas.

Suppose the robots already found a pretty good way of walking. Then, one robot discovers a radically different way of walking, but doesn't go as fast as the original way. If we don't kill this new idea immediately, the new way of walking might evolve into something much better than the old way.

Because of this, we will add:

Variations of the top 7 placing weights.
10 new, randomly generated weights.
The best 5 placing weights from the previous generation, to make sure it never gets worse.

Note that these numbers are completely arbitrary, so feel free to change them.

haveKids(sorted[0], 25); //have 25 kids from the best one
haveKids(sorted[1], 10); //have 10 kids from the next best
haveKids(sorted[2], 5); //etc.
haveKids(sorted[3], 5);
haveKids(sorted[4], 4);
haveKids(sorted[5], 3);
haveKids(sorted[6], 2);

// ad 10 completely random ones
for (var i = 0; i < 10; i++) {
    var weights = [];
    for (var j = 0; j < 35; j++) {
        weights.push(rand());
    }
    new Bob(weights)
}

// in order to make sure it never gets worse, add back the best 5 from the previous generation
new Bob(sorted[4].weights);
new Bob(sorted[3].weights);
new Bob(sorted[2].weights);
new Bob(sorted[1].weights);
new Bob(sorted[0].weights);

The Reproduction

Here, we will actually define the function haveKids(). Each "kid" is just its parent (one parent, not two) with some random changes. I call the amount of change the creativity (it's not a scientific term). As the robot is training, I can change the amount of creativity with a slider input (that's part of the HTML).

In your HTML:

Creativity: 
<input type="range" min="0.001" max="1" value="0.5" step="0.01" id="creativity">

// numKids is the second parameter passed into the function haveKids
for (var i = 0; i < numKids; i++) { // repeat this code the number of kids times
    var newWeights = parent.weights.slice(); // when we change newWeights, we don't change the old weights.

    for (var j = 0; j < newWeights.length; j++) {
        if(Math.random() < 0.1){ // only change a weight 10% of the time
            var creativity = document.getElementById("creativity").value;
            newWeights[j] += (rand()**5)*creativity; //changes the new weight a little
        }
    }

    var newBob = new Bob(newWeights);
}

function rand(){
    return Math.random()-0.5;
}

I use rand()**5, or rand() to the 5th power because it works best that way for me. Feel free to just use rand() or rand()/100, because that might work better for you.

And does it walk?

It most likely won't walk on its first try. If you're lucky, the robots might scoot on their first try. The final, most time consuming step is to fiddle with every possible parameter until it does walk.

Just like a baby, mine went from scooting, to crawling, to jitter-walking, to swinging their legs around their heads, to walking (all babies go through a leg swinging phase, right?). It took me approximately two weeks to get mine to walk as well as the video at the top of this article.

Parameters to Fiddle With

Here are a bunch of things that you can fiddle with to make your robot better. Everyone will have to try different combinations of these things in order to get their robot to walk.

If it is vibrate-walking, only let it move its limbs twice per second, instead of moving its limbs every time the screen is drawn (33 times a second for me).
Try making a more complicated genetic algorithm such as NEAT (I didn't try this, so I don't know if it is actually helpful).
Tinker with the physics. Try changing the friction, restitution, density, etc.
Change the inputs given to the neural network. For example, give the positions of the limbs instead of giving the angles.
Change what the neural network controls. For example, instead of controlling the angular velocity, maybe control the angle itself.
Maybe add hidden layers to the neural network? This may or may not be helpful, I haven't tried it yet.
Change the ranking system (currently just who goes furthest before dying). For example, you could rank them by speed, make the robots evade a death line that moves towards them, or give them a complicated fitness score that is a combination of everything.

My Final Result

If you would like to see my final result, go here! If you would like to watch a video about this, go here. If you want to see my other projects, go to kiraprograms.com. If you want to see my fully commented code, see the github repository:

i8sumPi / bob-the-walking-AI

A simple, yet effective, walking AI.

Bob the Walking AI

Bob was created using matter.js for the physics and a very simple neural network, with no hidden layers or biases. I did not use any Machine Learning libraries for this; I did it from scratch in JavaScript (see ml.js). This uses very simple evolution: Bobs die if their head goes below the red line, and the ones that move furthest may reproduce and evolve. Also, the activation function is a sine wave because it works best that way. Surprisingly, after hours of intense coding and tweaking, Bob actually learned how to run and skip (I call it running and skipping, it's not exact)! This project is of the most complex ones I have ever done, and I am honestly shocked that I got it working. However, I can't stop it from falling after around 4 steps. This is from a competition between me and n8progrmas…

View on GitHub

Algebra Expression Simplifier

Kira L — Thu, 03 Sep 2020 23:03:57 +0000

This is my relatively simple algebra expression simplifier! You can use it online here, or see the GitHub repository with explained code here.

I was having a lot of difficulty finding a free, moderately fast algebra simplifier online, so I decided to make my own. Hopefully it can ease the process of solving difficult mathematical problems (but please don't use it for cheating!). Simply enter an expression or equation, and you will get a step-by-step solution and simplified result.

For those interested in making their own algebra expression simplifier, I started by making a simple arithmetic simplifier following this tutorial. Then, I changed that code so that it could handle equations as well. I made this project for fun and by myself.

I am mainly posting it here because, even though I spent a lot of time debugging the algorithm, there are probably still bugs. If anyone finds a bug while using the program, please let me know. Hope you enjoy!

UPDATE: I fixed the negative multiplication bug. Now, expressions such as -1*-2 work.