GoldRush: Android App Development

-
This is my first post! I'm going to talk about Java programming on Android devices. I got a 7 inch Samsung Galaxy Tab from DigiPen's summer camp. I have always been an iPad user, so using the Android device was a new experience. While the Galaxy Tab is similar to the iPad in many ways, it had some nice features the iPad did not have. The live wallpapers I downloaded were fun - I enjoyed touching the screen and seeing the water ripple, and occasionally poking at the fish in the "koi pond". The widgets turned out to be very useful because they quickly gave me information like weather, emails, and the news. I also liked the Google keyboard, which helped me to type faster and more accurately by sliding between letters. Android allows for more customization than iOS and has a lot of potential to be a mobile information dashboard. 

GoldRush is my first Android app. I have done Java programming for a few years but have never programmed for Android before this. As part of learning the platform, I planned to build a game that would incorporate sound, graphics, and touch. I used Eclipse, but in the future I would like to use Android Studio, which came out recently. The first concept in Android programming is an Activity. The OnCreate method is called when we create the Activity. It lets you setup your UI (specifically, Views/widgets), and prepare resources. Next, is the OnStart method. This is showtime (when the user sees the activity)! In this method, I locked the screen to landscape mode, set the first layout, and started the game. I used buttons to allow players to switch from layout to layout. The OnStop method allowed the app state to be persistent, which can be reloaded on OnRestart. Even if a user stopped GoldRush via TaskManager, the game could resume from where it was last time. 

Within the IDE, it was a lot of fun to develop the UI code (I am an Emacs user). I could easily create colorful buttons by adding a behavior to an ImageView. It was also very easy to build the program inside the Eclipse IDE and deploy it on the device - just click the run button and wait for a couple seconds for the app to appear on the screen. I used LogCat to debug and catch errors. After finding bugs or finding a feature I wanted to change, I could go back quickly and change my program. The whole program-build-test process was interactive and smooth. 

Here's a peek at my game: 

After beginning the game...you can see your level, and how much money and energy you have.
Occasionally, you'll meet the Cave Monster while mining!
You can buy tools and food at the General Store.
I enclosed my project here. 

I'm excited to work with the Galaxy Tab to do data visualization. I'll try network programming and server side data preparation. This also means I will do Java server side programming.   

P.S. I would like to thank DigiPen, and in particular my adviser Luke Powell, who made the camp a great experience! 























Popular posts from this blog

Building A Toy Language Interpreter in Go

-
Image
In this post, I'll be giving a high-level overview of interpreters, why they're interesting, and how they work. I'll be referencing my repo, go_interpreter , which is a simple interpreter written in Go for a toy language. The figure below shows the structure of our interpreter with an example input: What is an interpreter?  An interpreter is a language processor that seems to directly execute the source program on user input: In contrast, a compiler first takes in a source program and translates it to an executable machine code target program. Then, the user can pass in inputs to this target program and get outputs. In general, an interpreter is better at reporting errors since it's processing statements one at a time, and a compiler is faster at generating outputs from inputs. In this post, we're going to go over a simple interpreter that is capable of supporting: integers, booleans, strings, arrays, hashmaps prefix, infix operators index opera
Read more

Space Race: a simple Rust game built on the Bevy framework

-
Image
When I saw a post announcing the release of the Bevy framework  (an open source game engine written in Rust), I thought it'd be a fun way to learn Rust.  So I made Space Race , a 2 player game on top of the Bevy framework. How to Play The Astronaut moves around collecting jewels (using WASD keys). The Alien moves around trying to catch the Astronaut (using arrow keys).  The Astronaut wins if they collect at least 5 jewels and make it back to home base before the Alien catches them.  The Alien wins otherwise.  Things I learned about Rust  I had a lot of fun making & playing this game, and also got some hands on experience with Rust like working with structs enums vectors iterators traits dyn trait vs impl trait  dyn trait is used for trait objects, which are fat pointers made up of 1) a pointer to the value 2) a pointer to a vtable. A vtable is a table of methods, where each method points to its implementation, generated once at compile time. Each instance of a type that impleme
Read more

Building a Toy Language Compiler in Go

-
Image
A follow-up to my previous post about building a toy language interpreter in Go. Throughout this post, I'll be referencing my repo . We'll go over a compiler which translates source code to machine code, and then a VM to execute this machine code. What is a compiler?  A compiler takes source code and translates it to executable machine code . (See my previous post for more details.) The figure below shows the high-level architecture of a simple compiler. Like the interpreter we built previously, our compiler has a lexer and a parser which turn our source code into an AST . This is our compiler's frontend . However, that's where a compiler diverges.  The compiler may translate the AST into at least one internal representation (IR) . The IR(s) may be represented using any data structure (even another AST!), but they should follow two rules: (1) be easy to produce, (2) be easy to translate into the target machine code. The IR can also be optimized
Read more