We are the featured developer on the Scoreoid Website. You can read our interview here. http://www.scoreoid.net/featured-developers/featured-developer-rotating-canvas-games/.

Two of our games use Scoreoid :-

Tap Shoot Zombie

Speedboat Santa.

Try them. They are free.

Also if you are considering adding high scores, achievements etc in your game then you should try out Scoreoid. Its cross platform, uses web services to handle scores and also as it has no sdk so it does not increase the size of the application as well. Finally it is really easy to implement also. So try it out.

Our latest game:

Also check our latest game Rapid Car Rush. Its available for free in Google Play Store and Slide me.

Thanks

For parsing JSON we are using the source code available in this link JSON in Java. Here is the Github link. In this post we would only explain the desktop specific part of the code. Please check the previous post Using Scoreoid with Libgdx/Android for more details.

Here is the ScoreInterface.java  file which we would be calling in the main game code. This would be implemented differently in different environments to handle platform specific requirements.

public interface ScoreInterface {
public void OpenHighScores();
}

The Main.java in desktop would implement ScoreInterface and we would pass this object to our ApplicationListener super class (starting point for a libgdx game). Below is a snippet.

Main.java

public class Main implements ScoreInterface {

static Main app;
public static final String SCOREOID_URL = "https://www.scoreoid.com/api/";
public static final String GETBESTSCORES = "getBestScores";

public static void main(String[] args) {
LwjglApplicationConfiguration cfg = new LwjglApplicationConfiguration();
cfg.title = "ScoreoidExample";
cfg.useGL20 = false;
cfg.width = 480;
cfg.height = 320;

if (app == null)
app = new Main();

new LwjglApplication(new ScoreoidExample(app), cfg);
}

@Override
public void OpenHighScores() {

//....

}

So the Main class implements ScoreInterface and then it passed as argument when creating ScoreoidExample object. So when OpenHighScores is called, depending on the platform, desktop/android version is executed.

To get this working we would need to :

• Make Http calls to receive response from Scoreoid Api.
• Parse the json response

Make Http calls to receive response from Scoreoid Api

As scoreoid api provides post services, so we have to make a post request and pass parameters to get the score data. This is similar to handling any other post services in java. Here is a snippet for fetching the response.

public class ScoreoidConstants {

public static final String SCOREOID_APIKEY="PLACE YOUR API KEY HERE !!!";
public static final String SCOREOID_GAME_ID="PLACE YOUR GAME ID HERE !!!";
public static final String SCOREOID_RESPONSETYPE="json";
public static final String SCOREOID_SCORE_ORDERBY="score";
public static final String SCOREOID_SCORE_ORDER="desc";

}

The constants file where we are storing the apikey,gameid etc which would be used to form the parameters we pass to the url.

Url url=null;

public StringBuffer GetResponse(URL url) throws Exception {
        this.url = url;
StringBuffer buffer;
String line;
int responseCode;
HttpURLConnection connection;
InputStream input;
BufferedReader dataInput;

//ADD PARAMETERS TO FETCH DATA FOR GETBESTSCORES API
String urlParameters="api_key="+ ScoreoidConstants.SCOREOID_APIKEY+"&"
+"game_id="+ScoreoidConstants.SCOREOID_GAME_ID+"&"
+"response="+ScoreoidConstants.SCOREOID_RESPONSETYPE+"&"
+"order_by="+ScoreoidConstants.SCOREOID_SCORE_ORDERBY+"&"
+"order="+ScoreoidConstants.SCOREOID_SCORE_ORDER+"&"
+"limit="+"0,20";

//CREATE CONNECTION
connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("POST");
connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
connection.setDoOutput(true);
connection.setRequestProperty("charset", "utf-8");
connection.setRequestProperty("Content-Length", "" + Integer.toString(urlParameters.getBytes().length));
connection.setUseCaches (false);

//WRITE PARAMETERS TO CONNECTION
DataOutputStream wr = new DataOutputStream(connection.getOutputStream ());
wr.writeBytes(urlParameters);
wr.flush();
wr.close();
connection.disconnect();

responseCode = connection.getResponseCode();
if (responseCode != HttpURLConnection.HTTP_OK) {
throw new Exception("HTTP response code: "
+ String.valueOf(responseCode));
}
try {
buffer = new StringBuffer();
input = connection.getInputStream();
dataInput = new BufferedReader(new InputStreamReader(input));
while ((line = dataInput.readLine()) != null) {
buffer.append(line);
buffer.append("\r\n");
}
input.close();
} catch (Exception ex) {
ex.printStackTrace(System.err);
return null;
}
return buffer;
}

We would pass the scoreoid url for the api as agrument for the above function. In the source code provided we are getching best scores. So url would be “https://www.scoreoid.com/api/getBestScores”

First we make the parameters string which we would pass in to the url (urlParameters). Then we open the connection. Set its properties. For our case it is POST method and Content-Type is “application/x-www-form-urlencoded”. We have to pass parameters also so we set the Content-Length to the size of the string and then write the parameters into the connection using DataOutputStream.

After this is done we check for the response. If we receive successful response (HttpURLConnection.HTTP_OK) then we read the response in a string buffer and return it.

Parse the json response

Now we just have to parse the json response. Here is the Score class which would be used store score values.

public class Score {
public String PlayerName;
public String ScoreValue;
public long Position;
public Score(String pn,String sv){
Set(pn,sv);
}

public void Set(String pn,String sv){
PlayerName=pn;
ScoreValue=sv;
}
}

Here is the JSON Parser class.

List<Score> scores;

public JSONParser(){
scores=new ArrayList<Score>();
}

public List<Score> ParseScores(String response){
scores.clear();
if(response==null)
return scores;
try {
//For parsing the data just look at the content in the Scoreoid Console
//and then we can understand the structure of the return data
//We receive a json array of player scores
JSONArray json=new JSONArray(response);

for (int i = 0; i < json.length(); i++) {
//To get each player score object from the array
JSONObject jsonObject = json.getJSONObject(i);

//Inside this object we have two objects of Player and Score
//Create json object from player String
JSONObject playerobj=jsonObject.getJSONObject("Player");

//Retrieve the player first name
String playerFName=playerobj.getString("first_name");
if(playerFName.equals(""))
playerFName=playerobj.getString("username");

//Create json object from score string
JSONObject scoreobj=jsonObject.getJSONObject("Score");
//Retrieve score
String score=scoreobj.getString("score");

//Create a Score object and add it in the arraylist
scores.add(new Score(playerFName, score));

}
} catch (JSONException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

return scores;
}

It is mostly similar to the class we wrote for the Android version. There is a slight difference in reading JSON Objects from JSON Arrays. In Android version first we used to create a JSONString object for a string value(eg “Score”) and then create JSONObject using it. Here we are directly creating JSON Object using the string value (eg “Score”);

So for parsing the scores we just have to know the structure of JSON received. We receive a JSON Array and in this case we get 20 objects (as we set the limit to 20). Each object has two JSON Objects inside it (Score and Player). We get player name from Player object and score value from Score object.

For this example we are just printing the scores using Gdx log.

Source Code:

Finally the source code with all the snippets mentioned above which can be imported in eclipse workspace.

Scoreoid Libgdx/Desktop Eclipse Workspace

Note :- Input your Scoreoid API Key and Game ID in ScoreoidConstants.java file for the code to show some data.

When you run the example click on the trophy icon at the centre to see the scores.

If you have any query/suggestion/feeback please put it in the comments section.

Thanks

We have been working on a new 2d libgdx platformer game for sometime now and it is coming along nicely. While working on it we found the need to add an edge shape rather a rectangle for our platforms. And we found out edge shapes are quite easy to add in box2d.

At the bottom of the post we have attached the source code for this example. Here  is a screenshot.

Box2D Edge Shape

Making Edge Shape in Box2D:

For making the edge shape first we need to pass the position of the body (which would be center of the line segment in this case). After the body is create we need to attach a fixture to it whose shape would be a edge shape. In edge shape we get the option to set values for x1,y1 and x2,y2 (the ends of the line segment). As we have set the position of body at the center of line segment, we will calculate and set the offset of these two points from center as values for x1,y1 and x2,y2.

Here is a snippet on creating an edge shape.

    public static float WORLD_TO_BOX=0.01f;
public static float BOX_TO_WORLD=100f;

static float ConvertToBox(float x){
return x*WORLD_TO_BOX;
}

static float ConvertToWorld(float x){
return x*BOX_TO_WORLD;
}

    public Body CreateEdgeBody(World world,BodyType bodyType,
float v1x, // X1 WORLD COORDINATE
float v1y, // Y1 WORLD COORDINATE
float v2x, // X2 WORLD COORDINATE
float v2y  // Y2 WORLD COORDINATE
){
BodyDef bodyDef = new BodyDef();
bodyDef.type = bodyType;

//CALCULATE CENTER OF LINE SEGMENT
float posx=(v1x+v2x)/2f;
float posy=(v1y+v2y)/2f;

//CALCULATE LENGTH OF LINE SEGMENT
float len=(float) Math.sqrt((v1x-v2x)*(v1x-v2x)+(v1y-v2y)*(v1y-v2y));

//CONVERT CENTER TO BOX COORDINATES
float bx=ConvertToBox(posx);
float by=ConvertToBox(posy);
bodyDef.position.set(bx,by);
bodyDef.angle=0;

Body body = world.createBody(bodyDef);

//ADD EDGE FIXTURE TO BODY
MakeEdgeShape(body,len,bodyType,1,0,1);

//CALCULATE ANGLE OF THE LINE SEGMENT
body.setTransform(bx, by, MathUtils.atan2(v2y-v1y, v2x-v1x));

return body;
}

void MakeEdgeShape(Body body,float len,BodyDef.BodyType bodyType,
float density,float restitution,float friction){
FixtureDef fixtureDef=new FixtureDef();
fixtureDef.density=density;
fixtureDef.restitution=restitution;
fixtureDef.friction=friction;

EdgeShape es=new EdgeShape();
//SET LENGTH IN BOX COORDINATES
float boxLen=ConvertToBox(len);
//SETTING THE POINTS AS OFFSET DISTANCE FROM CENTER
es.set(-boxLen/2f,0,boxLen/2f,0);
fixtureDef.shape=es;

body.createFixture(fixtureDef);
fixtureDef.shape.dispose();
}

In the above snippet we are first converting the world coordinates to box as we have set a ratio of box to world to 1:100. So we scale down while calculating box values and vice versa to calculate them back to world.

After we have determined the value of center of line segment we calculate is length and angle. After that we create edge shape as a horizontal line segment with half length as its offsets in left and right direction and then rotate the body by the angle calculated above. You can calculate the offset points by just subtracting end points from the center but in that case the angle of body would be considered 0 and we needed the angle of rotation to rotate the texture attached to the line segment. So we went along with the above method.

Here is an image to describe what we did above.

Attached is the source code below of the code files only and also full libgdx eclipse project workspace.

Code Files only

Edge Tutorial Source Files

Full Project

Edge Tutorial Full Project

If you have queries please post them in comments section. Thanks.

In our upcoming android game we are adding some box2d joints and in this post we would be creating a revolute joint. We are using Libgdx engine to make the game. Below is a screenshot of what  it looks like in game.

Box2d Revolute Joint from our WIP game

At the end of the post, you can find the source files for this revolute joint example attached.

Okay, a small description about revolute joint. It works with two bodies with one acting as the pivot while around revolves around it. With box2d we get the option to limiting the angle range in which the body revolves and also set the torque (how fast the body rotates about its origin) and motor speed (how fast the body rotates around the pivot).

Here is a snippet of the respective joint.

public class RevoluteJoint {
RevoluteJointDef revoluteJointDef;

public RevoluteJoint(Body bodyA,Body bodyB,boolean collideConnected){
revoluteJointDef = new RevoluteJointDef();
CreateRevoluteJoint(bodyA,bodyB,collideConnected);
}

void CreateRevoluteJoint(Body bodyA,Body bodyB,boolean collideConnected){
revoluteJointDef.bodyA=bodyA;
revoluteJointDef.bodyB=bodyB;
revoluteJointDef.collideConnected=collideConnected;

}

public void SetAnchorA(float x,float y){
revoluteJointDef.localAnchorA.set(x,y);
}

public void SetAnchorB(float x,float y){
revoluteJointDef.localAnchorB.set(x,y);
}

public void SetAngleLimit(float min,float max){
revoluteJointDef.enableLimit=true;
revoluteJointDef.lowerAngle=min*MathUtils.degreesToRadians;
revoluteJointDef.upperAngle=max*MathUtils.degreesToRadians;
}

public void SetMotor(float torque,float speed){
revoluteJointDef.enableMotor=true;
revoluteJointDef.maxMotorTorque=torque;
revoluteJointDef.motorSpeed=speed*MathUtils.degreesToRadians;
}

public Joint CreateJoint(World world){
return world.createJoint(revoluteJointDef);
}
}

Lets go through the above snippet. We first supply two box bodies which would form the revolute joint. Third argument (collideConnected) is to check if the two bodies associated with joint should be checked for collision.

SetAnchorA is to set the anchor point around which the revoluting body will rotate.

SetAnchorB is to set the other point where the second body will be positioned and will revolve around the pivot.

SetAngleLimit is to set the range in which the body should revolve around the pivot.

In SetMotor function we are setting the torque and motorSpeed for the joint. In our case we wanted the body to completely revolve around pivot every 1 second, so we give the speed of 360 (which is converted inside to radians as box2d expects the angles in radians).

Below is an image which (tries to) describes the revolute joint.

Revolute Joint

Below is a snippet to create a revolute joint using two bodies.

First a wrapper class to create box2d bodies.

public class BoxBodyBuilder {

public static float WORLD_TO_BOX=0.01f;
public static float BOX_TO_WORLD=100f;

static float ConvertToBox(float x){
return x*WORLD_TO_BOX;
}

static float ConvertToWorld(float x){
return x*BOX_TO_WORLD;
}

public Body CreateCircleBody(World world,BodyType bodyType,float posx,float posy,
float radius){
BodyDef bodyDef = new BodyDef();
bodyDef.type = bodyType;
bodyDef.position.set(ConvertToBox(posx),ConvertToBox(posy));
bodyDef.angle=0;

Body body = world.createBody(bodyDef);
MakeCircleBody(body,radius,bodyType,1,1,0,0);
return body;
}

void MakeCircleBody(Body body,float radius,BodyDef.BodyType bodyType,
float density,float restitution,float angle,float friction){

FixtureDef fixtureDef=new FixtureDef();
fixtureDef.density=density;
fixtureDef.restitution=restitution;
fixtureDef.friction=friction;
fixtureDef.shape=new CircleShape();
fixtureDef.shape.setRadius(ConvertToBox(radius));

body.createFixture(fixtureDef);
fixtureDef.shape.dispose();
}
}

In the above snippet we are creating a circle object. We are scaling the objects to ratio of 1:100. So if a world object is 50px wide then in box it would have a dimension of 0.5f. So while creating the body we convert the dimensions and location in box2d scale and in debugrenderer we scale the projection matrix by 100 to see the bodies in world dimensions.

Bodytype is to specify if a body is static, dynamic or kinematic. Our pivot will be static and other body will be dynamic.

Other properties are set to 1 or 0 but as for this example they were not that important.

Now the main code where we create the box2d bodies and revolute joint.

  //Creating the pivot and the rotating body
  bodyFactory=new BoxBodyBuilder();
  Body pivot=bodyFactory.CreateCircleBody(world, BodyType.StaticBody, 200, 200, 30);
Body spike=bodyFactory.CreateCircleBody(world, BodyType.DynamicBody, 200, 200, 20);
  MakeJoint(); //the function below creates the joint

  //Creating joint
  void MakeJoint(){
        //Using our custom class to create the revolute joint def
RevoluteJoint j=new RevoluteJoint(pivot,spike,false);
        //Set Anchor A location
j.SetAnchorA(BoxBodyBuilder.ConvertToBox(0), BoxBodyBuilder.ConvertToBox(0));
        //Set Anchor B location
j.SetAnchorB(BoxBodyBuilder.ConvertToBox(100), BoxBodyBuilder.ConvertToBox(0));
        //Set revolution speed and torque
j.SetMotor(20, 360);
        //This creates the joint
joint=j.CreateJoint(world);
}

In the above snippet first we create the two box2d bodies which will form the revolute joint. Then we create the joint and set the pivot and other body apart by 100 px. Then we set the torque to 20 and motor speed to 360 degrees per second so it will complete one revolution per second.

Then all you need to do is call world.step in update function to update the box physics and the joint will work accordingly.

Here are the source files and the libgdx eclipse project. We have used debug renderer in the source provided.

RevoluteJoint Example Source Files

RevoluteJoint Example Eclipse Project

If  you have queries/suggestions, please post them in comments.

Thanks

We used Scoreoid for our last two games TapShootZombie and SpeedboatSanta and we were really happy with the result because its easy to integrate, it uses web services (REST) to handle all the features so it is easy to implement in any platform and no need to include any library with the game, because as we mentioned it uses web based services. And when we thought of publishing SpeedboatSanta for Html5 we just had to write code for html5 and now we can compare android and html5 game scores.

Ok lets start. First goto Scoreoid, add a developer account, create a game after which you will get two strings -> API Key and Game ID which would be needed to get game data. In this post we would be just calling a service to get players best scores but it can be expanded for other features very easily. You can create players/scores though Scoreoid Console to test the code.

In this example we would have a sprite in the game which on clicked would open highscores window. Highscore window would be an android activity with a list view to display all the scores. In the end we will provide the eclipse project which you can download and import it in the workspace to play with it.

We would make a interface -> ScoreInterface with a function called OpenHighScores() which would be implemented differently in Android,HTML5 and would show a list with scores. For now we focus on android, in some of the later tutorials we would cover GWT part. Here is how ScoreInterface.java looks.

public interface ScoreInterface {
public void OpenHighScores();
}

You can check older tutorial (Writing Android Specific Code in Libgdx) to see how to implement platform specific code in Libgdx so i won’t go into details here. The mainActivity in Android would implement ScoreInterface and we would pass this object to our ApplicationListener super class (starting point for a libgdx game). Below is a snippet of what i was talking out.

public class MainActivity extends AndroidApplication implements ScoreInterface {
Handler handler;

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

AndroidApplicationConfiguration cfg = new AndroidApplicationConfiguration();
cfg.useGL20 = false;

//To queue new threads in Main UI Threads
handler=new Handler();

//Call new ApplicationListener object with this argument as
//MainActivity implements ScoreInterface
initialize(new ScoreoidExample(this), cfg);
}
}

So in the game code if we call this function we would be able to see the scores activity in Android (as we will implement the changes in Android) but no change would happen in the desktop application (because we will leave this function empty).

For ScoreActivity we need to do the following :-

• Custom Layout for ListView item having three textviews (Rank, Player Name & Score) which would be inflated when we add scores.
• Create a data adapter to load in the list view to show the scores
• AsyncTask to read scores over the internet using Scoreoid Api.
• Scoreoid Wrapper to make http calls and receive response from Scoreoid Api.
• A JSON Parser to parse the data in the required object  (rank, player and score) and update the list view with them.

List View Item :-

We would make an xml layout with three text views to hold Rank, Player Name and Score. Below is the snippet.

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="30dp" >

<TextView
android:id="@+id/playerPosition"
android:layout_width="wrap_content"
android:layout_height="match_parent"
android:layout_alignParentLeft="true"
android:paddingLeft="5dp"
android:textColor="@color/White" />

<TextView
android:id="@+id/playerTitle"
android:layout_width="wrap_content"
android:layout_height="match_parent"
android:layout_toRightOf="@+id/playerPosition"
android:paddingLeft="5dp"
android:textColor="@color/White" />

<TextView
android:id="@+id/playerScore"
android:layout_width="100dp"
android:layout_height="match_parent"
android:layout_alignParentRight="true"
android:textColor="@color/White" />

</RelativeLayout>

List Adapter :-

Here is the snippet of the custom data adapter.

//Score class to hold scores we retrieve from Scoreoid
public class Score {
public String PlayerName;
public String ScoreValue;
public long Position;
public Score(String pn,String sv){
Set(pn,sv);
}

public void Set(String pn,String sv){
PlayerName=pn;
ScoreValue=sv;
}
}

//We will attach this adapter with list view to show the scores in the activity

class ScoreAdapter extends BaseAdapter{
List<Score> scores;

//To inflate the custom list-view-item layout dynamically
LayoutInflater inflater;

public ScoreAdapter(Context ctx,List<Score> scores){
inflater = (LayoutInflater) ctx
.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
this.scores=scores;
}

public int getCount() {
// TODO Auto-generated method stub
if (scores != null)
return scores.size();
return 0;
}

public Object getItem(int position) {
// TODO Auto-generated method stub
if (scores != null && position >= 0 && position < getCount())
return scores.get(position);
return null;
}

public long getItemId(int position) {
// TODO Auto-generated method stub
if (scores != null && position >= 0 && position < getCount())
return position;
return 0;
}

//Here we inflate list item view and update it with score values
public View getView(int position, View convertView, ViewGroup parent) {
// TODO Auto-generated method stub
View view = convertView;
Score sc = scores.get(position);
if (view == null) {
view = inflater
.inflate(R.layout.list_score_item, parent, false);
}
TextView pTitle = (TextView) view.findViewById(R.id.playerTitle);
TextView pScore = (TextView) view.findViewById(R.id.playerScore);
TextView pPos=(TextView) view.findViewById(R.id.playerPosition);
if (pTitle != null)
pTitle.setText(sc.PlayerName);
if (pScore != null)
pScore.setText(sc.ScoreValue);
if(pPos!=null)
pPos.setText(""+String.valueOf(sc.Position)+".");

return view;
}

}

In the getview function we inflate the view which we want to show in the row in the list view. Then we update the values with the scores and return the udpated view.

In the activity we would just set an empty data adapter to the list view and when we get the data from scoreoid, we would update the scores array and notify the data adapter. Then the scores would start showing in the view.

AsyncTask to make Http Requests :-

With changes in new Android API (I guess 4.0),we are required to do network intensive tasks in an AsyncTask before it was optional. Anyways it is always good to use AsyncTask when we fetch something from internet. Here is the snippet.

A class to hold constants

public class ScoreoidConstants {

public static final String SCOREOID_APIKEY="PLACE YOUR API KEY HERE !!!";
public static final String SCOREOID_GAME_ID="PLACE YOUR GAME ID HERE !!!";

public static final String SCOREOID_BUNDLE_API="api";
public static final String SCOREOID_BUNDLE_SCORESTART="scoreStart";
public static final String SCOREOID_BUNDLE_LIMIT="limit";

public static final String SCOREOID_URL="https://www.scoreoid.com/api/";

public static final String SCOREOID_RESPONSETYPE="json";
public static final String SCOREOID_SCORE_ORDERBY="score";
public static final String SCOREOID_SCORE_ORDER="desc";

public static final String GETBESTSCORES="getBestScores";
}

Class extending AsyncTask to make run in background to fetch scoreoid scores.

public class WebService extends AsyncTask<Bundle, String, String>{

//Player's Rank
long startPosition;

@Override
protected String doInBackground(Bundle... arg0) {
// TODO Auto-generated method stub
String response="";
if(arg0[0]!=null){

// THIS TO CHECK WHICH API CALL IS MADE. FOR THIS EXAMPLE WE ARE
// CALLING ONLY HIGHSCORES

//                String api=arg0[0].getString(ScoreoidConstants.SCOREOID_BUNDLE_API);

long limit=arg0[0].getLong(ScoreoidConstants.SCOREOID_BUNDLE_LIMIT);
long start=arg0[0].getLong(ScoreoidConstants.SCOREOID_BUNDLE_SCORESTART);

//The scores return would be in descending order by score value
response=scoreoidObject.GetBestScores(start, limit);

//As the scores are in descending order we would just calculate rank
//by incrementing the start values by 1 during the loop
startPosition=start+1;

}
return response;
}

@Override
protected void onPostExecute(String response) {
// TODO Auto-generated method stub
if(response!=null && response!=""){
List<Score> tempScores= parser.ParseScores(response);
if(tempScores!=null && tempScores.size()>0){
scores.clear();
for(Score s:tempScores){
s.Position=startPosition;
scores.add(s);
startPosition++;
}
//To notify the list view to show the updated scores
adapter.notifyDataSetChanged();
}else{
Toast.makeText(getApplicationContext(), "No scores Available or Some Error Ocurred",
Toast.LENGTH_SHORT).show();
}
}
super.onPostExecute(response);
}

}

So we call the task with a bundle where we put data like which Scoreoid Api to call, with the different parameters required for the call. For this example we are using only one api , so we just mention the start and limit of number of scores we need from scoreoid.

Then we make the http call to Scoreoid and get the response which is json (you can set that to be xml also). After that we parse the data and update the list which we would do in the next two steps.

Scoreoid Wrapper :-

In this class we would do a http post to retreive the data from scoreoid.

public class ScoreoidWrapper {

DefaultHttpClient httpClient;
HttpContext localContext;
String webServiceUrl;

Handler handler;

HttpPost httpPost = null;
HttpResponse response = null;

public ScoreoidWrapper(){
HttpParams myParams = new BasicHttpParams();

HttpConnectionParams.setConnectionTimeout(myParams, 10000);
HttpConnectionParams.setSoTimeout(myParams, 10000);
httpClient = new DefaultHttpClient(myParams);
localContext = new BasicHttpContext();

//Scoreoid API BASE URL
webServiceUrl = ScoreoidConstants.SCOREOID_URL;
handler=new Handler();

}

String webInvoke(String methodName,List<NameValuePair> params){
httpPost = new HttpPost(webServiceUrl + methodName);
String data = "";
try {
//Passing the parameters
httpPost.setEntity(new UrlEncodedFormEntity(params));

//Getting HttpResponse
response = httpClient.execute(httpPost);

//Reading the content part of the response
InputStream is = response.getEntity().getContent();
BufferedInputStream bis = new BufferedInputStream(is);
ByteArrayBuffer baf = new ByteArrayBuffer(20);

int current = 0;
while ((current = bis.read()) != -1) {
baf.append((byte) current);
}

//Convert the reponse to string to parse it later
String ret = new String(baf.toByteArray());

// Response from the server
data = ret;
} catch (Exception e) {
// Exception handling

}
return data;
}
}

JSON Parser :-

After getting the response (in Json format) we parse the result and fill scores array with player’s first name and score value and return the array list.

public class JSONParser {
List<Score> scores;

public JSONParser(){
scores=new ArrayList<Score>();
}

public List<Score> ParseScores(String response){
scores.clear();
if(response==null)
return scores;
try {
//For parsing the data just look at the content in the Scoreoid Console
//and then we can understand the structure of the return data
//We receive a json array of player scores
JSONArray json=new JSONArray(response);

for (int i = 0; i < json.length(); i++) {
//To get each player score object from the array
JSONObject jsonObject = json.getJSONObject(i);

//Inside this object we have two objects of Player and Score
//Get Player Object's json string
String player=jsonObject.getString("Player");
//Create json object from player String
JSONObject playerobj=new JSONObject(player);

//Retrieve the player first name
String playerFName=playerobj.getString("first_name");
if(playerFName.equals(""))
playerFName=playerobj.getString("username");

//Get Score object's json string
String scoreStr=jsonObject.getString("Score");
//Create json object from score string
JSONObject scoreobj=new JSONObject(scoreStr);
//Retrieve score
String score=scoreobj.getString("score");

//Create a Score object and add it in the arraylist
scores.add(new Score(playerFName, score));

}
} catch (JSONException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

return scores;
}
}

In PostExecute code of  the AsyncTask we get the scores parsed and then loop through them to get the player rank. In the end we update the adapter with the new scores and list view is notified. Here is the snippet of the AsyncTask (same as above in the section where we showed AsyncTask code).

JSONParser parser

protected void onPostExecute(String response) {
// TODO Auto-generated method stub
if(response!=null && response!=""){
List<Score> tempScores= parser.ParseScores(response);
if(tempScores!=null && tempScores.size()>0){
scores.clear();
for(Score s:tempScores){
s.Position=startPosition;
scores.add(s);
startPosition++;
}
//To notify the list view to show the updated scores
adapter.notifyDataSetChanged();
}else{
Toast.makeText(getApplicationContext(), "No scores Available or Some Error Ocurred",
Toast.LENGTH_SHORT).show();
}
}
super.onPostExecute(response);
}

Source Code:

Finally the source code with all the snippets mentioned above which can be imported in eclipse workspace. Download from Box.net

Note :- Input your Scoreoid API Key and Game ID in ScoreoidConstants.java file for the code to show some data.

When you run the example click on the trophy icon at the centre to see the scores.

If you have any query/suggestion/feeback please put it in the comments section.

Thanks

Okay first the big image. Tada.

Google Play Store link :-  Speedboat Santa.

We just released our fifth game in Google play store. Its called Speedboat Santa. As you can see with the name and the game, the December month has had an effect on us. Okay straight to the description.

Santa lost his gifts in the ocean somehow somewhere while traveling. So now he got a speed boat and he is going over the ocean to get the gifts back. But there are mines, sharks and well, evil oysters trying to stop him. And speedboats run fuel which also has to be taken care of. So you shoot a cannon below to free the gifts from their bubbles (they got trapped into bubbles somehow) and jump over the mines and not jump at the sharks. Santa understands the need for speed so he speeds speedboat (ahh speed repeated three times) over time along with powerups hid in the ocean to aid his effort. Beat your score and compete with others and keep on playing.

Okay so the mandatory description is out of the way.

Qr Code:

Screenshots!

Video!

Well no video for now. It will be uploaded soon (hopefully).

Your feedback/reviews will be highly appreciated.

We wanted to share a small update with you all. A few days ago our new game Tap Shoot Zombie was featured in IndieGameHQ which is a great site featuring many independent games. You should check out the site for news and updates from the indie gaming world.

Thanks

We have released our fourth game for Android in Google Play Store- Tap Shoot Zombie!. Here is the link.

Qr Code:

Description:-

Shoot zombies in this simple fun game. One touch control, just tap to shoot. Gather points. Unlock guns. Upgrade Guns. Make combos. Share your score with friends and compete globally. Have fun.

*Features
Easy controls.
Four different guns to choose from including a shotgun.
Uses scoreoid to handle global scores.
Options to upgrade guns.
Addictive game.

Credits:
Libgdx
Box2d for cool fun physics
For Sounds:
* Mike Koenig
* Amanda

Gameplay video:-

Screenshots:

Feedback/comments/ratings will be highly appreciated. Thanks.

For detailed instructions checkout: https://launchpad.net/~abhshk-btra/+archive/rotatingcanvas Don’t forget to update your package indexes!

sudo add-apt-repository ppa:abhshk-btra/rotatingcanvas
sudo apt-get update

After adding our ppa to your repository list, you can install our lens by clicking this link – apt://googleplaylens or by issuing:

sudo apt-get install googleplaylens

Here is a screenshot of what the lens looks like:

To learn more about Ubuntu and Unity please visit http://www.ubuntu.com

We’ll appreciate a lot if you help us spread the word. Here are links to our games in Google Play Store

Choozak    Balloon Shooter    Polar

Cheers!
Rotating Canvas