I’ve decided to follow “Invent with Python” to start learning game development using Python. Just a note, I may branch out to other game development languages in the future. It’s just that, for now, I think this is the easiest path for me through my journey on game development.

Chapter 1 deals with installing Python and IDLE (Interactive DeveLopment Environment). I’ve setup mine by using VirtualBox with Ubuntu 14.04 giving me Python and I just needed to install the idle3 package. I used VirtualBox so I can have a sandbox just for game development using Python.

Chapter 2 teaches you how to work with IDLE’s interactive shell and basic programming concepts such as integers, floating points, expressions, variables and arithmetic operators. I just quickly brushed through this chapter since I am already familiar with the concepts all I had to look for is how they are done in Python. One thing to remember is that there is no increment(++) nor decrement(--) operators and you have to use the shorthand operators such as += and -=.

Chapter 3 will give you your first taste of creating a Python source code using IDLE’s editor. As most will expect, you will start off with a “Hello World!” program. You will encounter print(), input(), how string(including concatenation) works and convention on naming your variables. I thought of putting my own source codes for the sample programs on GitHub but decided against it because they are already in the book and on its website. Just remember to experiment with the source code and try to recreate it on your own as practice.

Chapter 4 tackles on a “Guess the Number” game where you generate a random number from 1 to 20 and you let the user guess in 6 tries. Along the way you will learn how to use modules, while statement, if statement, comparison operators, blocks, booleans, break and how to convert from string to integer and vice versa using str() and int().

You can skip Chapter 5 as this only discusses how to not automatically append a new line with print(). You can also skip Chapter 7 and return to it on a later time if you need to learn how to use IDLE’s Debugger.

Chapter 6 is the last and most interesting chapter I went through since this is where you first define your own function and use them. The chapter also teaches you how variable scope works. You are to create a game where the user will choose between two caves. One of the caves will have a good dragon who will give the user its treasures and the other one has a bad dragon who will eat the user in an instant.

So far so good! I skimmed through the first 7 chapters of the book and it got a little bit interesting towards the end. I hope it gets better and more interesting on the next chapters.

Last bit of comment, I think this is a good resource not just for game development but as a starting point for programming beginners.

One of my favorite pastimes is playing computer games and while searching for a new game to try last weekend I stumbled upon Papers, Please. You play as an immigration inspector in a war-torn dystopian nation of Arstotzka. I’ve played the game for a few hours and got 16 out of 20 possible endings.

As a developer myself, I was quite interested on how the game was created and poked around. I found out that the game is created by an indie game developer, Lucas Pope. I also discovered that he joins game jams organized by Ludum Dare.

Needless to say, discovering games which were in Ludum Dare’s game jams, rejuvenated my interest in learning game development. As such, I’ve decided to start right away.

Going over Q&A’s about beginning game development I’ve decided to use Python (I did some quick programming a few years back with Python and I want to start working on it too.) and follow Invent with Python, and most probably, continue with Making Games with Python and Pygame.

I’ll try to write about my progress as much as possible and hope that I’d do well and maybe help others who find themselves looking to learn about game development.

pom.xml

Let’s start with the pom.xml…

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.sample</groupId>
    <artifactId>jsf</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>
    <name>jsf-sample</name>
    
	<repositories>
		<repository>
			<id>jboss</id>
			<name>JBoss Repository for Maven</name>
			<url>https://repository.jboss.org/nexus/content/groups/public/</url>
		</repository>
		<repository>
			<id>central</id>
			<name>Maven Repository Switchboard</name>
			<url>http://repo1.maven.org/maven2</url>
		</repository>
		<repository>
			<id>maven2-repository.java.net</id>
			<name>Java.net Repository for Maven</name>
			<url>http://download.java.net/maven/2/</url>
		</repository>
	</repositories>

    <dependencies>
    	<dependency>
			<groupId>javax</groupId>
			<artifactId>javaee-web-api</artifactId>
			<version>6.0</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>com.sun.faces</groupId>
			<artifactId>jsf-api</artifactId>
			<version>${jsf.version}</version>
		</dependency>
		<dependency>
			<groupId>com.sun.faces</groupId>
			<artifactId>jsf-impl</artifactId>
			<version>${jsf.version}</version>
		</dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                </configuration>
            </plugin>
            <plugin>
              	<groupId>org.apache.maven.plugins</groupId>
             	<artifactId>maven-war-plugin</artifactId>
              	<version>2.1.1</version>
              	<configuration>
                  	<failOnMissingWebXml>false</failOnMissingWebXml>
                  	<contextRoot>/jsf</contextRoot>
              	</configuration>
          	</plugin>
            <plugin>
          	 	<groupId>org.apache.maven.plugins</groupId>
              	<artifactId>maven-eclipse-plugin</artifactId>
              	<version>2.8</version>
              	<configuration>
                  	<wtpmanifest>true</wtpmanifest>
		          	<wtpversion>2.0</wtpversion>
		          	<manifest>${basedir}/src/main/resources/META-INF/MANIFEST.MF</manifest>
              	</configuration>
	        </plugin>
        </plugins>
    </build>
    
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <jsf.version>2.1.2</jsf.version>
    </properties>
</project>

If you’re using a web server such as Tomcat 6.0 or above you will need to have jsf-api and jsf-impl. I’ve decided to use the jars in the public JBoss repository because the ones in the central Maven repo will produce an error during server start-up:
java.lang.ClassFormatError: Absent Code attribute in method that is not native or abstract in class file javax/faces/FacesException

You can use any Java EE 6 server instead but that is not part of this post because there maybe additional configurations such as ear pom configuration which I haven’t tried yet.

web.xml

Next, we need to configure the web.xml file to direct *.xhtml requests to the FacesServlet.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  xmlns="http://java.sun.com/xml/ns/javaee"
  xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
  xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" 
  version="2.5">
  <!-- Minimum requirement for JSF 2 is a servlet 2.5 declaration -->
  <!-- Map FacesServlet -->
  <servlet>
    <servlet-name>Faces Servlet</servlet-name>
    <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>Faces Servlet</servlet-name>
    <url-pattern>*.xhtml</url-pattern>
  </servlet-mapping>
  <!-- For better error messages during development -->
  <context-param>
    <param-name>javax.faces.PROJECT_STAGE</param-name>
    <param-value>Development</param-value>
  </context-param>
 
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.xhtml</welcome-file>
  </welcome-file-list>
</web-app>

Mapping *.xhtml to FacesServlet will allow us to use JSF tags in our xhtml files.

faces-config.xml

At the minimum we need to have an empty faces-config.xml in WEB-INF.

<?xml version="1.0"?>
<faces-config xmlns="http://java.sun.com/xml/ns/javaee" 
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-facesconfig_2_0.xsd"
   version="2.0">
  <!-- Empty but needed -->
</faces-config>

Test

To test the configuration I created a basic index.xhtml file which uses some JSF tags (with the h prefix) in src/main/webapp.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" 
	  xmlns:h="http://java.sun.com/jsf/html">
<h:head>
	<title>JSF | Index</title>
</h:head>
<h:body>
	<h1>Hello World!</h1>
</h:body>	
</html>

Just run the mvn clean eclipse:clean eclipse:eclipse install, import in Eclipse, create a server, add the project, run the server and go to index.xhtml.

I hope this helped you. Cheers!

So there I was reconstructing everything that I mentioned starting with Java Persistence with Hibernate Part 2 – Getting Started until I was done with my test class to see if everything works and that’s what I was expecting but I was wrong. Instead I got this error:

Exception in thread "main" java.lang.AbstractMethodError: com.microsoft.jdbc.base.BaseDatabaseMetaData.supportsGetGeneratedKeys()Z

I immediately blamed the JDBC driver I have for SQL Server 2000 and then I also remembered that there’s a new JDBC version already for SQL Server. Sure enough when I changed to sqljdbc4.jar(I’m using JDK 6.0, use sqljdbc.jar for JDK 5.0) and changed the driver class to com.microsoft.sqlserver.jdbc.SQLServerDriver everything went smoothly and the application executed correctly.

Hope this helps someone cause it’s really hard to find the solution for the error that I encountered if you’re not familiar with the history of JDBC with SQL Server. For more information on using the new driver please visit Using the JDBC Driver.

Create the Mapping File

The basic structure of a mapping file is like this:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.phoenixone.hibernate.model">
	<class name="com.tutorial.enrollment.model.Student" table="student">
		<id name="id" column="student_id">
			<generator class="org.hibernate.id.enhanced.SequenceStyleGenerator" />
		</id>
		<property name="firstName" column="first_name" />
		<property name="lastName" column="last_name" />
	</class>
</hibernate-mapping>

The DOCTYPE is required in the mapping file. You can use it for auto-completion of the XML elements of the mapping file. The DTD is included in hibernate3.jar.

<hibernate-mapping> is the root element of the XML mapping file. You need to provide the package where the class belongs.

<class> tags is used for mapping the persistent class and other classes to which your persistent class is dependent.
e.g. If we have an Address property

private Address address;

inside the Student class then we need to create another <class> tag for Address but that’s another topic.

The <id> tag is used to mapped the primary key in the table to the property in the class.

The <generator> tag provides auto-generation of the id. You can choose from a list of generator classes or short names which you can find here. You can also plugin your own generator strategy.

The <property> tag is used to map the other properties of the class. Just make sure that the value of name attribute has the same casing as you used in the class file.

After creating the mapping file save it as Student.hbm.xml and put it on the same directory as Student.java. All mapping files should have the same name as the class it maps and ends with .hbm.xml.

Create the Hibernate Configuration File

Ok, at this point we already have our database(enrollment) and persistent class(Student.java) which was done in Part 3 and earlier in this post we have the mapping file for Student.java(Student.hbm.xml). There’s only one thing left to configure so we can store and load objects with Hibernate and that is tell Hibernate our database configuration, how to locate the mapping files(*.hbm.xml), etc.

Here’s how our configuration file may look like…

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
	<session-factory>
		<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="connection.url">jdbc:mysql://localhost/enrollment</property>
		<property name="connection.username">root</property>
		<property name="connection.password">root</property>
		
		<property name="dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
		<property name="show_sql">true</property>
		<property name="hbm2ddl.auto">update</property>
		<property name="current_session_context_class">thread</property>
		
		<mapping resource="com/tutorial/enrollment/model/Student.hbm.xml" />	
	</session-factory>
</hibernate-configuration>

The DOCTYPE here is different from the mapping file’s DOCTYPE.

<hibernate-configuration> is the root element of the file.

<session-factory> allows you to configure Hibernate’s SessionFactory which is the one responsible for a specific database. The SessionFactory is also the one responsible for creating Session objects that will allow us to store and load objects as we will see in Part 5. If you have several databases then you should have several <session-factory> elements too.

The first four properties take care of our database connection. You can search for your particular database’s connection configuration by searching on how to use the JDBC driver for it. As for MySQL it’s here.

The dialect property determines what particular SQL variant Hibernate will generate depending on your database. For other dialects go here.

The show_sql property tells Hibernate to print the generated sql to the console.

If by chance you accidentally dropped the database for our persistent class you can add hbm2ddl.auto and it will automatically create the database schema for you, handy isn’t it?

The current_session_context_class property enables the automatic session context management.

You can visit this page if you want to learn about other configurations you can set.

Part 3 – Create the Database and Persistent Class o0o Part 5 – Creating a SessionFactory Helper and Storing/Loading Objects

In using Hibernate you may either create the database first and create the class we need to persist or vice-versa.

create database enrollment;
create table student(
 student_id int,
 first_name varchar(40),
 last_name varchar(40),
 primary key(student_id)
);

With the SQL code above, we’ve created a database named “enrollment” and a table named “student” with three columns(student_id, first_name and last_name) with student_id as our primary key(unique identifier).

Create the Eclipse Project

Again, you don’t need to have an eclipse project just adjust what is done here to your development environment.

1. Create a new Java project in this case I named the project “com.tutorial.enrollment”. Image
2. Add the libraries mentioned in Part 2 to the build path Image 1, Image 2

Create the Student Class

package com.tutorial.enrollment.model;

import java.io.Serializable;

public class Student implements Serializable {
	private static final long serialVersionUID = 6981987850136048701L;
	
	private Long id;
	private String firstName;
	private String lastName;
	
	public Long getId() {
		return id;
	}
	public void setId(Long id) {
		this.id = id;
	}
	public String getFirstName() {
		return firstName;
	}
	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}
	public String getLastName() {
		return lastName;
	}
	public void setLastName(String lastName) {
		this.lastName = lastName;
	}
}

The Student class follows the JavaBeans specification with the use of private variables and public getters and setters method. Also, we tried to have the same properties in our class and columns in the student table.

Save Student.java in com.tutorial.enrollment/src/com/tutorial/enrollment/model.

Part 2 – Create the Database and Persistent Class o0o Part 4 – Create the Mapping File and Configuration File

Hibernate has several modules which answer specific problems. The two most important modules to learn are Hibernate Core and Hibernate Annotations.

Hibernate Core

Hibernate Core for Java generates SQL for you, relieves you from manual JDBC result set handling and object conversion, and keeps your application portable to all SQL databases. Hibernate offers sophisticated query options, you can write plain SQL, object-oriented HQL (Hibernate Query Language), or create programatic Criteria and Example queries. – from hibernate.org

Hibernate Annotations

Hibernate, like all other object/relational mapping tools, requires metadata that governs the transformation of data from one representation to the other (and vice versa). As an option, you can now use JDK 5.0 annotations for object/relational mapping with Hibernate 3.2. You can use annotations in addition to or as a replacement of XML mapping metadata. – from hibernate.org

To be able to use the power of Hibernate we only need Hibernate Core. But since Hibernate Core requires a lot of XML configurations, Hibernate Annotations is used to make development simpler and faster. To better understand this let’s create a simple Hibernate application.

Getting Started

First we need to prepare all the libraries for creating a Hibernate application. This could be easily done if you know build tools like Maven or Ant but I decided not to use them because it’s not a requirement and maybe some of you are not familiar with those tools.

1. Download Hibernate Core
   Extract the zip file and you will get hibernate3.jar. Image
2. Inside the lib folder there is a required folder and inside that you will find antlr-2.7.6.jar, commons-collections-3.1.jar, dom4j-1.6.1.jar, javassist-3.9.0.GA.jar and jta-1.1.jar. We will use a different version of sl4j. Image
3. Download sl4j-1.5.6.zip and extract. We will need slf4j-api-1.5.6 and slf4j-simple-1.5.6
4. Lastly we will need the JDBC driver for the database that we would be using, in this case MySQL 5.0. You may use other databases if you want just be sure know how to use them and configure them for database access from Java. Download the MySQL Connector/J 5.0. We need mysql-connector-java-5.0.8-bin.

Java Persistence with Hibernate Part 1 o0o Java Persistence with Hibernate Part 3 – Create the Database and Persistent Class

Persistence in Computer Science basically means the existence of data even after an application or program has ended. This can be done through the use of a relational database such as MySQL or SQL Server with some stored procedures.

However, in creating applications we do not use relational databases by themselves (Imagine all of us creating queries and stored procedures just to save or retrieve data). We just integrate a database as a means to store data to our main application. Your application may be developed using Java or any other object-oriented language but this is where our problem starts.

Our application is an Object-Oriented language which is built around the idea of objects having states and behaviors while the database we are using is Relational which is all about tables. The problem is in translating those objects into a form that can be stored in a relational database.(Paradigm mismatch: Object Relational Mapping)

Another concern is that Java has a different syntax than SQL(the base language being used by relational databases). Well, Java has JDBC but is it enough? Do we just hard-code all of our SQL commands?

Lastly, different relational database management systems(RDBMS) uses different extensions of SQL, meaning they may have different syntax for several SQL commands. This poses a problem when you are trying to migrate from one RDBMS to another. Let’s say you used MySQL as your RDBMS for development and you had all your SQL commands hand-coded within your application. However, before deploying the application your client tells you that they would be using Oracle instead. You think that there’s no problem, since you used JDBC you just need to change some configurations regarding the driver used and migrate the MySQL tables to Oracle. But lo and behold when you deployed the application some part of it was not working. Most probably this is because some of your hand-coded MySQL commands have different syntax in Oracle.

Hibernate is an ambitious project that aims to be a complete solution to the problem of managing persistent data in Java. It mediates the application’s interaction with a relational database, leaving the developer free to concentrate on the business problem at hand. – from the book “Java Persistence With Hibernate”

There are other issues regarding Object Relational Mapping but I guess with the above explanation you already have a basic idea of the importance of Object/Relational persistence.

Java Persistence With Hibernate Part 2 – Getting Started