Global Agenda First Looks

Recently I purchased global agenda and after a few long sessions I have finally come up with an initial opinion on it. Global agenda is not an MMO. Why would I say this? well global agenda does not have a shared space required for a true MMO.

The construct of global agenda consists of a main lobby area were people can change and buy items and then instance missions. The instance missions themselves just activate after you waited X amount of time in the queue. The best way I can describe this game is it's like TF2 in PvP and L4D in PvE but since most of the time you only play with 4 in co-op and 16 players in PvP there's nothing massive about this game.

A lot of people called Global Agenda the new planetside. I don't think this is a fair assessment. PlanetSide the norm was to have 100vs100 wars and sometimes 100vs100vs100 when things got really hectic. Unfortunately global agenda isn't this exciting or dynamic.

Global Agenda has recently added a shared questing area but unfortunately it's far too short for me I finished this area in about 2 days that's hardly any time at all for an MMO.

Although some may argue that the game has been streamlined I believe that it is far too streamlined to. The draw to MMO's was always there was this massive persistent world where you could explore together with other players. Random encounters (with other players) are always encouraged and add to the experience. However here Global Agenda misses the point as well because the only random encountering your going to get after the initial quests (which are more like a long tutorial anyways) is the randomly being put together with a few other people when your assigned a mission.

This would be fine if the missions were more varied but sadly they are not they always consist of killing some random spawns. Going through a trap and then defeating some boss. To that end the boss don't even have any real strategy to them it's just hit them with all you got.

TR0N planning (for Dec 17 2010)

Looking to get together a few people for TR0N opening night here's what everyone replied:

Joel	No
Eva	Yes
Andrew	No

IT adventures at home

At home I have a reasonably complicated network 11 devices in total that need to connect to our network. Our network consists of 3 routers and 1 wifi access point (not the primary gateway like most home setups).

There are a total of 7 devices on the hard line and the remaining 4 exist purely on wirelsss.

Once a network gets this large some level of network management is required. In our network setup each zone exists in it's own IP range (still on the same subnet) and wireless is served in it's own subnet entirely.

The 3 routers have divided duty as:

Gateway
Internode
Downlink

The gateway is the most powerful of the 3 routers it's duty is to take care of QoS and firewall duties. As well as run the DHCP.

the internode is the linking point that distributes traffic it primarily operates as a switch and access point joining the wireless network to the primary network. It exclusively handles wireless traffic and isolates it from the network.

The downlink connects to the home server. The downlink also performs additional QoS functions as it is connected to the home server. The server is often throttled during peak times when other clients need to utilize more bandwidth.

With all this network management I was horrified when some random Chinese programs some family members installed just took down the entire network by using every last drop of upload bandwidth.

I recently discovered 2 offenders on my network PPStream and UUSee both are chinese P2P streaming programs and both analyse how much bandwidth you have in the upload channel and attempt to use up all of it. Unfortunately on modern routers with QoS still can't set a static maximum upload per host rule. Or more ideally the rule will be written as:

Allow burst traffic for up to 5 min (upload unrestricted). Then:
Throttle any additional upload from that host until their upload is less than 50% of the allotted cap.

Essentially a host would have to be transmitting past a set rate say more than 70% of your total upload capacity for a full 5 min before the throttle kicks in and it fixes the situation. Normal browsing wouldn't trigger this gaming wouldn't trigger this as most games don't have very high upload demands unless your the server. VoIP should get through just fine. And P2P software that allows the user to set limits would also work just fine. But those Chinese streaming software are particularly nasty and there's very little you can do to limit their rates.

Failing to communicate effectively to less technical users that they were essentially making our network unusable I resorted to a software solution. "NetLimiter 3 Lite" is employed currently on a trial basis to see if it can resolve the situation. Net limiter is unique in that it allows you to throttle on the client and on a per software basis. The offending pieces of software are now given a reasonable amount of bandwidth to work properly and so far the network seems to have recovered.

I'd recommend giving it a shot if your the network admin and you have control over client machine administration.

Javadoc Rant

Javadoc is this wonderful invention. It allows a programmer put a comment into their code above the methods they are writing in order to generate automatic API documentation. But it’s simplicity is also a curse often times Javadoc descriptions are absolutely awful.

And in some cases Javadoc descriptions which are suppose to contain how and why you would use something serve to only remind a programmer what the method name was called. For example in the GXT API for google web toolkit extra widgets we have this excerpt:

 

getStyle

public TreeStyle getStyle()

Returns the tree style.

Returns:

the tree style

 

Hmm… I think most programmers can guess the that from reading the method. But what is a style? In particular what is a TreeStyle? What does it define?

Almost all JavaDocs I’ve come across so far suffer from lack of information. If any JavaDoc users out there are listening. The reason many programmers flock to languages like C# is the documentation is gold. Javadoc is a great technology but if it is to compete Javadoc writers need to not only state what the method does but also mention why you may want to use it.

In addition almost every MSDN documentation I’ve seen to date gives at least one example of the method in practical use so the programmer has no doubt as to how to use that API. Ask yourself when’s the last time you saw a useful example inside a Javadoc?

Technology is great Javadoc is incredibly easy to generate, but the ease of use leads to very poor documentation. Most JavaDocs are an afterthought and it’s highly disappointing.

Windows Auto-Updaters

If anyone from Microsoft reads this I have a pretty simple feature request for Windows 8. Windows desperately needs some for of auto-update api. On my current Win7 install right now I have this situation:

Chrome: has their own updater

Firefox: has their own updater

Winamp: has their own updater

Flash: has their own updater

Digsby: has it’s own updater

iTunes: has their own updater

… etc.

 

Aside from all these programs requiring memory resident services in order to maintain the periodic update check the main annoyance is that each of these updates bug you at different times through a different interface about the programs they know about.

Since updating and patching for security flaws is a common thing in the modern application world this would be a big benefit to users of Microsoft products if there’s a centralized way of alerting the user of new changes. If it could be listed along with the standard windows update interface all the better (maybe a third party applications section).

I would submit to Microsoft directly but it doesn’t appear they have a feature request page in a casual search of the Microsoft Windows divisions site.

Reading Android XML Resources

I’ve been playing recently with some Android development and recently I needed to load an XML resource (for API 3). I was very surprised to find that Android doesn’t have a super easy way of loading XML resource files.

The XMLPullParser works but it’s very bare metal and does leave quite a bit to be desired. So I decided to go ahead and create a generic XML parser that all android developers can use (and improve).

---

public class XMLData {
    public String mValue;
    public XMLData mParent;
    public List mChild;
   
    public XMLData(String value, XMLData parent) {
        mParent = parent;
        mChild = new ArrayList();
        mValue = value;
    }
}   

---

First we establish a base XML data structure I decided to keep things simple here so I'm not at all doing anything about attributes if you wish to handle attributes you need to add a new ArrayList for attributes.

Now that we have our basic XML data type we can start create a class to read it:

---

    public static XMLData Load(XmlPullParser parser) {
        XMLData xmlModel = null;
        XMLData currentNode = null;
       
        try
        {
            int eventType = parser.getEventType();
           
            while (eventType != XmlPullParser.END_DOCUMENT){
                String name = null;
                    switch (eventType)    {
                        case XmlPullParser.START_DOCUMENT:
                            xmlModel = new XMLData("root", null);
                            currentNode = xmlModel;
                            break;
                        case XmlPullParser.START_TAG:
                            name = parser.getName();
                           
                            if (name != null) {
                                XMLData dataNode = new XMLData(name, currentNode);
                                currentNode.mChild.add(dataNode);
                                currentNode = dataNode;
                            }
                            break;
                           
                        case XmlPullParser.TEXT:
                            name = parser.getText();
                           
                            if (name != null) {
                                XMLData fieldNode = new XMLData(name,currentNode);
                                currentNode.mChild.add(fieldNode);
                            }
                            break;
                           
                        case XmlPullParser.END_TAG:
                            name = parser.getName();
                           
                            currentNode = currentNode.mParent;
                            break;
                    }
                   
                    eventType = parser.next();
            }
        } catch (XmlPullParserException e) {
            Log.e("ParseEx", e.getMessage());
        } catch (IOException e) {
            Log.e("IOEx", e.getMessage());
        }
       

        return xmlModel;
    }

---

So let's back up for a second and look at what this does. We start off by first executing:

int eventType = parser.getEventType();

This reads off our first tag for the XMLPullParser.what follows is the main while loop.

There are 4 Major event types we are concerned with:

XmlPullParser.START_DOCUMENT

XmlPullParser.END_DOCUMENT

XmlPullParser.START_TAG

XmlPullParser.END_TAG

XmlPullParser.TEXT

START_DOCUMENT and END_DOCUMENT denote the beginning and end of the document when we get a start we concern ourselves with initializing the XMLData so we can start to build an XML tree.

START_TAG and END_TAG denote when each of the tags expand. On a START_TAG we prepare ourselves to traverse into the ENTRY by creating a new XMLData.

---

 case XmlPullParser.START_TAG:
             name = parser.getName();
                            
             if (name != null) {
                XMLData dataNode = new XMLData(name, currentNode);
                currentNode.mChild.add(dataNode);
                currentNode = dataNode;
             }
             break;

---

dataNode in this case is the newly created node ready for traversal. We then perform currentNode = dataNode remember that we are now traversing down the node.

On END_TAG we do one and only one thing we go up one level from our tree structure. This is accomplished with the following code:

---

         case XmlPullParser.END_TAG:
            name = parser.getName();
                           
            currentNode = currentNode.mParent;
            break;

---

Finally we have TEXT in which we read off the actuall data of an element:

---

     case XmlPullParser.TEXT:
         name = parser.getText();
                   
         if (name != null) { 
             XMLData fieldNode = new XMLData(name,currentNode);
             currentNode.mChild.add(fieldNode);
         }
         break;

---

Hopefully this tutorial breaks down an easy way to access your XML data. If you want to use XMLData right away you can grab it here! I haven't decided what license I'll release it under but I'm thinking it'll be under the same license as Google SDK.

DOWNLOAD SOURCE

iTunesMonitor 2.5 (Update)

I've recently updated iTunesMonitor to 2.5 status you can find the original description here (The download link was updated there as well).

The main difference is it now respects Windows 7's UAC controls so no more crashing due to permission issues. Keep in mind you will need .NET framework 4 to run this now.

Among other nice features 2.5 iTunesMonitor finally gives iTunes the ability to work with your media keys even when iTunes does not have focus for those die hard iTunes users.

The system is "install free" meaning as long as you have iTunes installed detection and launching is automatic.

Download iTunesMonitor 2.5

On the streets of G20

G20 started getting dangerously close to my house so I decided I should see if there was any immediate danger. Well I’m not going to caption but here’s what it looks like on the streets.








As tensions build the police fire rubber bullets into the crowd you can spot a rubber bullet near the end of this video.







After firing the rubber bullets the crowd gets rowdy and pushes back.



And as soon as the cops back off the Hooligans camouflaged into the rest of the crowd set fire to yet another police cruiser.



You can all make up your own captions about the event it should be somewhat self explanatory.
I’ll make it clear that I don’t support the actions of the violent protesters the peaceful ones were around but they’ve been largely overshadowed by the few violent ones.

Learning Unity a Beginner's Prespective

First I should probably give everyone a little background. I'm a Programmer by trade not an artist so I approach things from a programming standpoint. Me and a friend of mine recently decided that we would like to make an attempt at producing an indie game title.

After some of the ground work had been established we decided that it's would be an appropriate time to take a look at some toolkits. The Unity Game Engine has been recieving a lot of praise from the indie crowd recently. I felt it was appropriate to at least give it a fair evaluation.

Arriving from a programmer's background the first thing one would notice is that Unity is built somewhere in between the artist and programmer tools. Although I would place unity more heavily towards the artist side of the game development. The first hurdle a programmer will find is that a lot of the terminology is geared towards the artist so it may be hard to figure out what "bones" are or the concept of a "scene" is.

Once you get beyond that and start your own project you find another lacking area of Unity the tutorials seem to span. "This is the UI" and "Here's an advanced tutorial that we expect you to know how to use the toolkit well" but nothing in between. What I was looking for as a coder is "this is your first unity level" but there really wasn't any tutorial that ran you through creating a box with the player in it and giving it some basic lighting.

In this area unit could be improved upon. If the tutorial exists then it really wasn't made that clear where you could go and find it.

As a programmer game development for us works as follows. Build Rough Game Mechanic concept --> Make ugly place holder graphics --> Test game concepts --> Refine and acquire final art assets. Unity however doesn't work this way. Any object you want to put into Unity must be first drawn in your 3D modeller package. Unity does not include any form of "primatives" you can just drop in. This basic disconnect forces people used to the programming model to adhere to the unity work flow model of: Build rough art assets --> Drop into unity --> Attach scripts --> Test gameplay --> Refine models.

Admittedly to non artists this model can seem Alien often times we use code to compensate for the fact that we don't understand how to use all the features of the complex 3D modelling packages such as rigging, bones, mesh deformation, and particle effects.

Overall though for a first look Unity may seem baffling at first but I can definitely see signs that once you get a hold of how to appropriately utilize the tools unity definitely seems to speed up the "concept / code / test" cycle we are used to. I only caution the programmers about to be introduced to this tool to be cautious and be aware that when they first start they will be baffled in what appears to be a tool designed for artists.

Flash programmers would be well aware of this concept that the editor doesn't assist the coders instead it's somewhat expected the coders use their own coding environments to get the job done.

Mass Exodus of Facebook

It's interesting from a long ago Facebook quitter to observe this new mass exodus that is now occurring. 4 Months ago me and my group of friends discussed privacy concerns over Facebook and since then deactivated our accounts.

It would seem that the world is catching up to our tech savvy movement. Recently in the last few weeks the Internet has been in an uproar about privacy concerns over Facebook. Facebook has introduced a service that allows you to be logged in to share data over various services. Once again like all Facebook introductions everything is defaulted to public for their entire network.

As the patterns build up it seems to all point to what me and my friends assumed 4 months ago. Facebook it would appear doesn't really care about privacy and will never learn from their mistakes. The act of opening all your personal information to the public is not a mistake so much as a conscious business strategy. It is very much to Facebook's benefit to make all your information public. As such they will continue to try and open up every last piece of data you put on it until you finally delete your account.

Best RC I've seen today

Ok it might not fly well but I love it anyways.

And here's a star fighter from my child hood video game "descent" the Pyro GX

This one is impressively detailed (can't tell if it's the same one) but hats off to the builder he really made this one shine