Ziad Salloum Blog

Creating Configurable Game Levels In Unity

noreply@blogger.com (Anonymous) — Tue, 21 Oct 2014 22:28:00 +0000

This post is about creating game levels that are configurable using XML files in Unity3D.
However the concept can be easily applied anywhere.

When creating a game that contains levels, the last thing a developer would like to do is to code every single level. Instead what he wishes to do is to create independent game objects which he can put together in different combinations and levels using easily configurable XML files.

When developing LittleBirdy Android game I had to generate tens of levels because the game evolves from one level to another with different difficulties, different obstacles or surprises.

To make the task easier on myself, I conceptually designed a generic structure for all levels.
So each level will have a name and a description, a success message to be displayed when the player wins and failure message when he loses.
Furthermore the level must contain the scoring rule such as the target points to earn, the time limit, the targets to hit and the order in which they must be hit.

Then comes the board, which is the rectangular area where the gaming takes place which is different from the other displays such as the current score, the menu etc...
Inside the board we find the targets to be hit, their location, their condition of appearance, the points earned.
Then comes the obstacle settings inside the board. Each obstacle has a location and a dimension as well as a certain behavior: fixed, moving, rotating, growing/shrinking.
Outside the board element, you can find the BirdSettings that defines the number, location and velocity of the birds that will be in the level.
The BranchesSettings is used to tell how many Left and Right branches available in this level.
Finally the GiftSettings are the gift objects that appear from time to time to give the player extra bonus or eliminate certain threat.

The XML structure appears like the following:

Level
|
|------ Scoring
| |-------Target
| |-------Timer
| |-------Rules
| |-------RuleOrder
|
|
|------ Board
| |------- Targets
| | |----- Target (type, count, appearance times ...)
| |
| |------- Obstacles
| | |----- Obstacle (type, count, dimensions, postion ...)
| | | |
| | | |--- ObstacleBehavior (rotation, translation)
|
|
|------ BirdSettings
| |------- Birds
| | |----- Bird(name, type, x, y, velocityX, velocityY)
|
|
|------ BranchSettings
| |------- Branches
| | |----- Branch(name, side, count, image ...)
|
|
|------ GiftSettings
| |------- Gifts
| | |----- Gift(type, count, startTime, endTime, duration ...)

For each node in the above structure corresponds a C# class with the same name.
Using System.Xml.Serialization of .Net it is very easy to serialize/deserialize object hierarchy into XML files.
The method DeserializeReader shows how easy to read an XML file and create a C# object hierarchy from it.

         private Level DeserializeReader(TextReader reader){  
                XmlSerializer ser = new XmlSerializer(typeof(Level));  
                Level level = (Level)ser.Deserialize(reader);  
                return level;  
           }

Once the Level C# object hierarchy is ready, we can proceed to create Unity GameObject from these objects and assign to their components the corresponding data reas from XML file.

 void Build(Level lvl, List<GameObject> gameObjects){  
      if(lvl.Board != null){  
           GameObject board = GameObject.FindGameObjectWithTag("Board");  
           // create Targets  
           if(lvl.Board.Targets != null){  
                foreach(Target t in lvl.Board.Targets){  
                     try{  
                          GameObject go = GameObjectFactory.CreateTarget(t);  
                     }catch(Exception ex){  
                          Debug.LogException(ex);  
                     }  
                }  
           }  
           // create obstacles  
           if(lvl.Board.Obstacles != null){  
                foreach(Obstacle o in lvl.Board.Obstacles){  
                     try{  
                          GameObject go = GameObjectFactory.CreateObstacle(o);  
                     }catch(Exception ex){  
                          Debug.LogException(ex);  
                     }  
                }  
           }  

           // build the Gift Settings  
           if(lvl.GiftSettings != null && lvl.GiftSettings.Gifts != null 
                                       && lvl.GiftSettings.Gifts.Length > 0){  
                BuildGiftSettings(lvl, lvl.GiftSettings);  
           }  
// Set the bird  
           if(lvl.BirdSettings != null && lvl.BirdSettings.Birds != null 
                                       && lvl.BirdSettings.Birds.Length > 0){  
                Bird birdInfo = lvl.BirdSettings.Birds[0];  
                CBird.Instance.BirdSettings = birdInfo;  
           }  
                    
      }  
 }

The GameObjectFactory contains method to create Unity GameObject objects and assigns to them the corresponding XML data.
For example CreateTarget checks whether it knows hos to create the given Target object, TargertPeanut in the code below, and instantiates the GameObject using Unity APIs then gets the Unity Component (CPeanut) attached to the GameObject and gives it the Target 't' in order to initialize the GameObject variables such as location, speed, movement etc...

      GameObject CreateTarget(Target t){  
           if( t is TargetPeanut){  
                go = GameObject.Instantiate(Resources.Load("prefab/peanut")) as GameObject;  
                CPeanut gPeanut = go.GetComponent();  
                gPeanut.PeanutInfo = (TargetPeanut)t;  
           }  
...
      }

Using this approach hundreds of game levels could be created by simply duplicating XML files and apply some changes to each one.
In a team of two or more people, a developer can program each object or character of the game in an independent manner, while a level designer would easily write XML files to create combinations of scenarios and game play. With some extra efforts they can build level editor so level design will become a drag&drop gesture.

Tank Battle Field, HTML5 Game #6: First enemy unit

noreply@blogger.com (Anonymous) — Fri, 10 Jan 2014 22:33:00 +0000

Despite that the Flak 88 was a fearsome German anti-tank gun, it is not its historical reputation that made it through to be the first enemy unit in Tank Battle Field game.

As a matter of fact two reasons make it appealing:
- Easiness of animation
- Cheap artificial intelligence (AI) requirement

The animation

Flak88 animation is rather simple. The canon itself is composed of the base and the gun. The base is symmetric and fixed, while the gun can rotate 360°

It is easy to see a similarity with the tank chassis and its turret.

Notice that the gun orientation is horizontal and to the right (towards the increasing x-axis). This is important in case we don't have to worry about the initial angle. Otherwise we should subtract the initial angle each time the gun rotates.

Here's an example:

Suppose the sprite of the gun is upwards like in this picture.

Since the angular system is like the trigonometric one, this gun makes 90° with the x-axis. We are speaking visually wise. However the code does not know that! What it knows is that everything starts at 0°. So if you tell the gun to rotate 90°, the graphic engine will rotate the above sprite by 90° which makes it look like this.

Sadly enough, this is not our intention because visually speaking it is equivalent to 180°. To solve this we subtract 90° from the rotation angle to obtain the desired visual effect.

In order to avoid all this fuss, we draw (from the start) the gun horizontally and oriented to the right.

It is important to differentiate what your eyes see and what data is supplied to the code.

The artificial intelligence (AI)

Probably Flak88 has the easiest AI to implement in any war game!

Even in real life, the Flak88 mission is to track a tank until it has a good shot, then fires.

Same thing happens in the game. Flak88 calculates the angle that separates its gun from the center of the tank. Then starts closing this gap by rotating the gun until the gap reaches 2° or less. At this moment it fires.

There are times when the center of the tank is hidden behind a building. In such cases the Flak88 searches of any of the tank border points to which it has a clear line of fire, if it finds ones it closes in on it and fires.

Time now for some maths calculations:

The angle between the Flak88 and the tank is given by the calculating the arc-tangent of the slope of the line passing by the tank and the Flak88. The arc-tangent returns an angle within the range [-180, 180]. But on the other hand the angle of the gun is expressed in the range [- 360, 360].

So to be able to compute the difference between the two angles, we convert the gun angle to the range [-180, 180]. This is done like the following:

if gunAngle > 180 then gunAngle2 = gunAngle - 360 (ex: if gunAngle = 270° => gunAngle2 = -90°)

if gunAngle < -180 then gunAngle2 = gunAngle + 360 (ex: if gunAngle = -270° => gunAngle2 = 90°)

Now we calculate the deltaAngle which is the difference between the angle of the tank and the Flak88 and the Flak88 gun.

if tankFlakAngle and gunAngle2 have the same signs (both positive or negative) then

deltaAngle = tankFlakAngle - gunAngle2

However if tankFlakAngle and gunAngle2 have opposing signs (one is positive and the other is negative) then we have to be careful how to compute deltaAngle .

Suppose tankFlakAngle is 178° and gunAngle2 is -178°

Computing deltaAngle as tankFlakAngle - gunAngle2 will result in an angle of 356° which is not logical since as you can see on the picture above the real difference is 4°.

We can reach this result by doing the following:

if gunAngle2 < 0 then the gun is moving clockwise so deltaAngle must be negative:

deltaAngle = - ( (180 - tankFlakAngle ) + (180 + gunAngle2 ) )

if gunAngle2 > 0 then the gun is moving anti clockwise so the delta must be positive

deltaAngle = ( (tankFlakAngle + 180 ) + (180 - gunAngle2 ) )

Knowing the deltaAngle, now we can tell the gun to move to close the gap formed by this deltaAngle.

The demo

That's it for today, as always you can check the latest demo by going to http://tankbattlefield.eu.pn

Tank Battle Field, HTML5 Game #5: Collision detection

noreply@blogger.com (Anonymous) — Sun, 05 Jan 2014 00:21:00 +0000

Collision detection is an important feature in every game. Because of it you know where you can go, if you hit the enemy, etc... There are plenty of theories regarding this subject (you can check this blog for a good introduction) but they are beyond the scope of this article. What interests us in this post is how the collision detection is applied in the Tank Battle Field game.

In Tank Battle Field game, collision detection mostly applies in two cases:
- The primary tank (player tank) runs into a building, enemy or any other object on the ground
- Shells hitting the primary tank, the enemy units, building or other objects.

Main tank collision detection

As of this version of the game, the only moving vehicle on the field is the primary tank. Since it can move forward and backward, turns left and right, it is essential to be sure that any of these movements do not hit a solid object that denies the tank from changing position.
(it won't be realistic enough, nor interesting, to see the tank driving through buildings for instance).

So to be able to verify whether the tank hit something or not, we keep an eye on eight predefined points of the tank, and we check whether in the new position of the tank any of these points hit a solid object.
These points (called border points) are defined relatively to the center of the tank. For example the upper left corner has the coordinates x = - TankWidth/2 and y = TankLength/2 and so on for the other points.
Each time the tank moves or turns (rotates) the border points are computed in absolute coordinates taking into consideration the new position (including the rotation angle) that the tank it trying to move to.

Lets take an example. Consider that Xc, Yc are the coordinates of the center of the tank and Xul, Yul those of the upper left corner relatively to the tank center. When the tank moves the coordinates of the upper left corner in the absolute system will be:
AbsXul = Xc + (Xul * cosθ - Yul * sinθ)
AbsYul = Yc - (Xul * sinθ + Yul * cosθ)
where θ is the rotation angle of the tank

The above formula is a combination of a translation and a rotation transformations. (You can read more about transformations in the following wikipedia article "transformation matrix" )

The above has determined the border points of the tank. What remains is to check whether any of these points collided into a building. In other words, if any of these points came into intersection with building (or any other solid object) borders then we consider that a collision took place.

This suggests that we know the borders of these solid objects. In case of sprites, we know that they are always contained in a rectangle. However the rectangle might not accurately model the content of the sprite which might be of any shape. So the containing rectangle is not useful for a large number of cases which does not make it appealing. You can easily verify in the image below that the containing rectangle can quickly make the game unplayable.

In the image above, the tank can't move inside the containing rectangle which make the game unrealistic.
To solve this problem, we use polygons to model non-rectangular shapes such as this castle.
However this comes at a price of CPU power in order to try finding if any border point of the tank has crossed the polygon.
You may like to refer to this wikipedia article to know more about detection of a point inside a polygon.

The good news, is that not every thing requires a polygon, but there are cases where several rectangles might do the job. Telling that a point is inside a rectangle is by far faster than telling if it is inside a polygon. So, it is perfectly reasonable to model some objects using a series of rectangle as depicted in the image below.

In the above image, we modeled the house with two rectangles leaving the outdoors free for the tank to drive through.

Shells hit point

What makes tank games appealing is the ability to fire shells on targets. Determining how and where a shell hit a target is also a collision detection problem.
Mathematically this problem can be reduced to finding the intersection point between two lines.
The scenario where the tank fires on the castle,

can be reduced to the following intersection of two lines.

Here we consider that there are two lines defined as
Line A: y = a*x + b
Line B: y = c*x + d
Finding the hit point comes to find the intersection point of Line A with Line B. We define this intersection point by xi, yi. The solution becomes
xi = (b - d) / (c - a)
It follows that yi = a*xi + b

Certainly enough if the slopes represented by a and c are equal, this means the two lines are parallel and won't be intersecting thus the xi won't be determined since the denominator will be zero.

Mathematically this is valid solution. However this is not necessarily true in the game, because in maths the lines are infinite, so in case they are not parallel they will eventually intersect at some point. But in the game the shell has a limited range and the target's borders are also constrained in length. To be valid the intersection point must necessarily be with the valid range of each line.
Back to our previous example, if we say that the Line A stretches between point A1 and point A2 and Line B goes from point B1 to point B2. So in order for the intersection point given by (xi, yi) to be valid, the following relations should be true.
xi >= A1.x && xi <= A2.x assuming that A1.x <= A2.x
and
xi >= B1.x && xi <= B2.x assuming that B1.x <= B2.x

if the above relations are not true we might be in situation like in the image below, where the intersections happens outside the valid ranges.

Special case

We might think that we are done with the hit point. But still this not true yet!
Actually the equations handling the shell trajectory is based on time and velocity.
They have the following form:
x = Vx * t + x0
y = Vy * t + y0
where Vx and Vy are the components of the shell velocity along the x-axis and the y-axis while the x0, y0 is the point of origin (in other terms the tank).

The coordinates of the shell location are updated on each loop turn. This represents a problem since the update occurs every laps of time. So the graphical representation of the shell is discrete and not continuous.
The image below shows in grey the theoretical (continuous) trajectory of the shell, and in red dots the reel location of the shell over the time.

As you can see there is no way to verify that the shell hit the house by following the red dots alone. Actually the red dot never happen to appear inside the house borders.
To solve this issue, after each update of the shell position we check for intersection between the line formed by the starting point of the shell (position of the tank when it fired) and the latest shell position and the borders of the house.
It appears that for the first two shell positions there is no intersection. But on the third time we notice two intersections represented by the red crosses (X).
Naturally we chose the intersection that is closer to the tank as the hit point or the point of impact then we trigger the explosion sequence. Eventually we ignore the second intersection point and we don't show the third shell position on the screen.

Performance issue

So far the game does not contain too many objects nor requires too many computations that might affect performance. However, to do the things "right", we do take performance topic into consideration.
When detecting collision, we have to check the tank or shell position against every other solid object on the map. So in order to avoid using costly line intersections or polygons checks we first start by simply finding out what containing rectangles (surrounding objects) intersect with the rectangle formed by the tank position as first corner and the shell position as diagonally opposed corner (see image below). This way using cheap technique we can gather all solid objects that potentially lie in the way of the shell. Then we start testing using the more costly line intersection method on this reduced set of objects.

On the other hand, when seeking to find if the tank is about to collide with other solid objects, we start by checking for candidate objects by verifying if the tank crossed their containing rectangle, then we run a more accurate test using the point-in-polygon technique to find out if the tank really collided with one of them.

The demo

That's it for today, as always you can check the latest demo by going to http://tankbattlefield.eu.pn

D3GGQP7C7BF3

Tank Battle Field HTML5 Game #4: The Object Model

noreply@blogger.com (Anonymous) — Fri, 27 Dec 2013 21:12:00 +0000

Today's post is about the structure of Tank Battle Field game. Its object model.
Object model defines how objects are related to each other and determines the interactions with each other.

Tank Battle Field object model has two aspects. The containment model and the hierarchical one.

The containment model
As you can see in the picture below the objects are contained in a logical manner.

At the top there is the "Game" object which constitutes a global container which includes all other objects that are intrinsic to the game. It also constitutes a single entry point.
The "Game" object contains the following important objects:

"Model" object: defines the game logic and abstracts away logic from graphical representation. In turn it cotains

"Field" object, that represents the terrain or the theater in which the game takes place. The aim of this "Field" is to set the dimensions, background and relief.
"PrimaryTank" is the main tank of the game. The one controlled by the player.
"Buildings" is a object containing a collection of buildings. It has also the role to render them and make necessary calculations related to their positioning on the screen.
"Enemies" is the collection that contains the enemy units. This collection plays a role in coordinating AI enemy units movements.

"Graphics" object contains all what is necessary for rendering the game on the screen. Among others it contains:

"context" object which is a direct reference to the graphical device context provided by HTML5.
"layers" array that contains the layers which will be displayed on the screen using the z-index order.
"layer_ground" object has the lowest z-index order and thus it is displayed the first. It contains the background, and the field details as well as borders.
"layer_objects" object is the layer that contains static objects such as buildings. It is displayed second, over the "layer_ground".
"layer_units" object is responsible of rendering ground military units including friend and foes.
"layer_projectiles" object will contain transient objects such as shells, missiles, rockets as well as explosions. These objects are added to this layer at creation time then are removed when they expire.
"layer_high" object will contain all flying machines like airplanes.
"layer_widgets" object has the highest z-index order and is drawn last. It is responsible of displaying widgets on the screen such as a mini-map, primary tank status, notification messages or chats etc..

"Settings" object is where the game is configured, in terms of control keys, navigation mode etc. For the moment it contains "Navigation" and "Keys" objects for setting the navigation mode and the control keys.
"Res" objects contains resources needed by the game. Such as images, sounds etc...

The hierarchical model

Although that Javascript is not Object Oriented language, the Tank Battle Field game uses commonly known tricks to simulate class hierarchy and inheritance. The inheritance logic is hand crafted and does not use any library in order to keep it simple and minimal.

The concept of class does not exist in Javascript, everything is object but since hierarchy of classes is simulated in this section, the terms "class" and "object" refer to the same entity.

All objects in the game inherit from one super class which is ModelObjectClass. This gives the ability to get and set data and have an ID.

Objects that have dimensions, locations and rotation settings are of type ModelLocatableObjectClass. Note that the setX()/getX(), setY() /getY() coordinates functions represent the center of the object while the getTop(), getLeft() represent the top left corner of the object. It is also important to note that dimensions terms are not exactly the same as one might expect. Actually the width is the horizontal distance following the x-axis, the length is the vertical distance following the y-axis (which normally used to be called height), and height is the elevation from the ground following the z-axis. It is true that this is a 2D game, however the height (z-axis) will play a role.

Moving objects inherit from ModelMoveableObjectClass and have linear and angular speed, as well as acceleration.

VehicleClass contains commands to move forward, backward and to turn left and rights. It has also an import set of functions that determines how the vehicle will behave and how it is going to be rendered on the screen.

TankClass inherits from the VehicleClass and contains a turret object.

Other objects such as BuildingClass and Shell make use of this hierarchy of classes.

Initialization and data

Objects in the class hierarchy are instantiated using the new keyword, however the initialization does not take place inside the constructor, but by explicitly calling init() method and passing to it an arbitrary data object that each class might be expecting.

The reason for this approach is purely technical. Actually when instantiating an object using new keyword, the whole hierarchy of objects is instantiated and linked together via the __proto__ property.

So after the instantiation and the linking are done then it is possible to initialize using the init() method.

The data object given as parameter in the call to init() method, is used as momento design pattern, in the sens that it is used to save the state of the object so it can be saved or transferred via network in a multiplayer game.

Game loop: updates and rendering

As it is known by now, the game loop is a never ending cycle of tasks that is executed sequentially.
The loop reads the input of the user, calls updateModel() function on every object in the graphic layers. This method updates the internal state of the object, such as location, direction, health, etc...then the loop calls renderGraphics() on each object to draw itself on the screen, and finally updateModelAfterRendering() is called to update the state after the rendering phase. One example of the usefulness of the updateModelAfterRendering() method, is to reset the "fire" flag of the tank which was set by the updateModel() method and drawn by the renderGraphics() method.

Demo

That's it for now, as usual you can check the demo by going to http://tankbattlefield.eu.pn

HTML5 Game #3: Tank Battle Field, new approach

noreply@blogger.com (Anonymous) — Mon, 23 Dec 2013 23:38:00 +0000

Welcome to this new episode of HTML5 Tank Battle Field game. In this article a drastic restructuring of the game has been put in place.

In order to make the game more fit to new features and scenarios, some major concepts have been implemented:

1- World concept. The world concept is a simulation of how the tank battle occur in the real world. This is called the Model in the code.
The importance of the Model is that it abstracts away the real stuff from the graphic technicalities. So in theory, once the Model is ready, porting the game to different devices and/or different screen resolutions is a matter of adapting the graphics only.
It also ensures that the game play can vary by only touching the graphics without the need of rewriting the whole game.
A third important reason why the Model is crucial, is that the game could be transformed into multi-player one. So it will present a same world (Model) for all the players without caring about their graphic settings.

2- The Graphics, is what appears on the screen in front of the user. The graphic elements drawn on the screen will reflect what happens in the Model. However that does not mean that the mapping is one-to-one. Some transformations are required in order to render those elements appropriately.
Ideally the graphics coding structure will evolve separately from the Model, and the two can be linked by the "bridge design pattern". This will add great amount of flexibility.

3- Navigation view mode: As said in the first and second article, the game is about "first person vehicle" (as an analogy to the "first person shooter"). So despite the fact that this is a plain top view 2D game, the graphics are rendered to give the impression that the user is inside the tank. Which means that the tank is always fixed at the center of the screen and the objects move around it as it (the tank) moves.

However to keep things open for future navigation modes, this mode is used as part of the settings. In future releases, the user might be able to switch between navigation modes.

4- The game loop of course. It was not present in the previous article for simplicity purpose. However since the game is evolving, the game loop existence is extremely important. It has the role to keep the game together: It reads user input, updates the Model and renders the graphics and sounds.

The Model
As said the Model represents a simulation of the real world of the game which abstracts it from the graphics technical issues and constitutes a unique reference of what is happening in side the game for all players in a multi-player game.

As for this version of the game, the coordinates system of the Model is similar to the screen one, i.e. the origin (0,0) is at the top left of the screen, and the positive x-axis goes to the right, while the positive y-axis goes down.
The dimensions of the battle field, known as Field in the code, is 5000m x 5000m.
The angular system, is similar to the classic trigonometric one. So positive x-axis goes to the right, positive y-axis goes up and a positive angle is the one that goes from right to left.

There is no particular reason I have chosen this configuration, you can choose the one you want as long as you make the appropriate adaptation in your code.

The Graphics
The Graphics is to represent the objects of the Model on screen, by taking into consideration the screen resolution, the navigation settings, etc.
It is composed among other things of five layers:
The ground layer: To draw the background
The objects layer: Usually used to draw static objects such as buildings
The units layer: to draw the vehicles and big mobile objects
The projectiles layer: to draw the shells, rockets, missiles fired by the units
The flying layer: this is to draw any future flying object such as planes etc..
The widgets layer: this layer is for displaying extra features in the game such as mini-map, text messages etc..
As you can notice the existence of the layers determines the depth or z-index of the graphic elemnts. The rendering starts with the ground layer up to the widgets layer.

It is important to note that every object of the Model must be in one of these layers in order to appear on the screen.

The Navigation Mode
As already stated, the navigation mode in this version is about first person vehicle, or FixedCenter as referred to in the code. So the tank is fixed at the center of the screen, only its turret can turn. When trying to turn the chassis, the objects around the tank turns in the opposite direction to give the user the feeling that tank has turned.

So if the tank turns towards a building on its left, what the user sees on the screen is that the building is turning to the right to come in front of the tank. When the tank moves forward, or backwards, the building approaches or moves away.

It is important to note that all of this is only graphical, in the Model only the tank moves foward and backwards or turns left or right. But when representing those movements on the screen, the impression is given that the tank is fixed and the buildings are moving.

Technically, when the tank moves towards a building the distance between the tank and the building is measured and on the screen the building is drawn closer to the center.

When the tank turns, the building appears to be turning in the opposite direction, in order to come in front of the tank. However there is a little catch in here. Because our tank is always positioned upwards, in practice it is making 90° with the x-axis (according to our angular system). So when the tank moves left to position 120°, the building should rotate by 30° (120° - 90°) to the right (around the center of course).

Collision detection
For simplicity reason in this version the collision of the tank with any building is reduced to detecting whether the center point of the tank crosses the boundary of any building. Thus you will easily see half of the tank mounting the building.

Note that collision is detected in the Model and not graphically. So once the Model detects that the tank collided it cancel all movements towards the collision point, and this way the graphics on the screen keeps drawing the tank at the same position, giving the impression that it has stopped moving.

Demo
For the demo please go to the following http://tankbattlefield.eu.pn/tank6/index.html

HTML5 Game #2 : The Tank Battle

noreply@blogger.com (Anonymous) — Fri, 13 Dec 2013 23:55:00 +0000

In my previous article I have shown how to use a vehicle as "1st person navigator" in 2D.

After a second thought I found that there are more things to tell regarding HTML5game dev. So I decided to continue the series hoping that at the end of which I can come up with a minimum playable game. It would be a good practice for me and others.

During this series if you have remarks, or suggestions feel free to drop a line in the comments.

First I will redefine the game story.

Starting this article the game will be about a tank, navigating and and shooting on a map. The enemies are not very specific for the time being, they can be computer animated ones or other user(s) in a multiplayer game. Future articles will help determining them, since it is all about what can be achieved in a reasonable amount of time and efforts.

So in this article I will do the following:

1- add a tank with a moving turret

2- control the tank via keyboard instead of push buttons for better playability.

3- add some quick objects to the map

4- some technical stuff

As a matter of fact this article is more about polishing than anything else. It doesn't require any head scratching.

However before I start, I would like to point that the code has suffered a bit and needs some refactoring. I hope to be able to do this in the next articles.

1. The tank

In order to simulate a tank I have used a sprite PNG format with a transparent background. See image

The chassis and the turret are separate since the turret should be able to turn 360°.

Placing the chassis and the turret on the screen is straight forward. First you have to load the image then you have to draw each part alone.

It is worth noting that the tank is positioned upwards which is opposed to the relative axis system initial direction. This means that the turret along with its gun as the trajectory of the shell evolve in the negative values of the y-axis.

As I said earlier the chassis is fixed, but the turret can rotate. The good news is that since we are in a 2D and Top view, all objects are symmetric thus we don't need to draw every shape that the turret takes as it rotates. So delegating the job to the graphic engine is sufficient.

Tank forward, reverse, rotation speed as well as the rotation speed of the turret are controlled by the following variables in the code.
var ctDefaultForward = 5;
var ctDefaultBackward = 3;
var ctDefautltTurning = 2;
var ctDefautltTurretTurning = 2;

Firing is also constrained by the loading time. Meaning that after every shot there is a certain amount of time to wait until the next shell is loaded. This time is controlled by the variable.
var ctDefaultLoadTime = 20;

Explosion of the shell is a sequence of sprites that display one after the other.

Each of these sprites is contained in a 64x64 rectangle, so it suffice to know the number of the sequence in order to deduce the sprite position on the sprite sheet.
The variable explosionSeq keeps track of the explosion sequence. A value of -1 means there is no explosion.

Upon firing the gun recoils and this is reflected by move back of the turret. The variable recoil tells if there has been a recoiling and recoilDist controls the amount.

2. Tank control

Unlike in the previous article, the tank is now controlled via keyboard instead of push buttons. This is will allow a greater maneuverability.
The logic of the keyboard controls lies in the existence of a keyDown array. This array will take as index the key code and as value true in case the key is down and false in case the key is up. This keyDown array is essential when several keys are pressed down.
The variables that set the key controls are listed in here:
var ctKeyMoveUp = 69; /*E*/
var ctKeyMoveDown = 68; /*D*/
var ctKeyTurnLeft = 83; /*S*/
var ctKeyTurnRight = 70; /*F*/
var ctKeyTurretLeft = 37; /*left arrow*/
var ctKeyTurretRight = 39; /*right arrow*/
var ctKeyFire = 16; /*shift*/

In order to avoid the differences between QWERTY and AZERTY keyboards, I have set the control keys to match both layouts, whereas E = Forward, D = Backwards, S = TurnLeft, F = TurnRight, Left Arrow = Turret Left, Right Arrow = Turret Right, Shift = Fire.

3. Buildings

For the time being other objects on the map, particularly buildings are no more than rectangles of different dimensions and colors spread randomly.
As of this article, there are no collisions detection implemented in the source code.

4. Technical stuff

The most important technical issues to mentions are:
1- The game loop that maintain the game running. It is called every 100ms and consists of function readInput() for reading and analyzing the key strokes, the update() function that make some calculations regarding the positioning of objects, the drawAll() function that draws all the objects on the screen and finally the postUpdate() method that perform computations for the after drawing phase (useful in case of shell firing).
2- Another important issue, the rotating turret. The turret rotates within a relative axis system. This is the easiest way to do it, since the graphics api is able to rotate the turret sprite without deteriorating its quality.

5. The demo

Here is a live demo of this new version. Give it a try!

Keys: E = Forward, D = Backward, S = Left, F = Right, Left Arrow = Turret Left, Right Arrow = Right Turret, Shift = Fire

Please find below the source code of this version:

<!DOCTYPE html>
<html>
<body>
<canvas id="myCanvas2" width="600" height="480" style="border:1px solid #d3d3d3;">
Your browser does not support the HTML5 canvas tag.</canvas>
<br/>
<span id="loadingInfo"></span><br/>
<span id="info">Keys: E = Forward, D = Backward, S = Left, F = Right, Left Arrow = Turret Left, Right Arrow = Right Turret, Up Arrow = Fire</span><br/>

<script>
var timeIntervalID = -1;
var canvas=document.getElementById("myCanvas2");
var ctx=canvas.getContext("2d");
var info=document.getElementById("info");
var loadingInfo=document.getElementById("loadingInfo");
var imgSprites = new Image();
imgSprites.src="file:///C:/projects/tank/t2_1.png";
var imgExplo = new Image();
imgExplo.src="file:///C:/projects/tank/explo2.png";
var keyDown = [];
var ctDefaultLoadTime = 20;
var ctDefaultForward = 5;
var ctDefaultBackward = 3;
var ctDefautltTurning = 2;
var ctDefautltTurretTurning = 2;
var ctTotalExplosionSeq = 5;
var ctShellMaxRange = 300;

var ctKeyMoveUp = 69; /*E*/
var ctKeyMoveDown = 68; /*D*/
var ctKeyTurnLeft = 83; /*S*/
var ctKeyTurnRight = 70; /*F*/
var ctKeyTurretLeft = 37; /*left arrow*/
var ctKeyTurretRight = 39; /*right arrow*/
var ctKeyFire = 16; /*shift*/

// coordinates of the center of the map
// they are also those of the vehicle since it does not physically move on the map.
var canvasWidth = parseInt(canvas.width);
var canvasHeight = parseInt(canvas.height);
var centerX = canvasWidth/2;
var centerY = canvasHeight/2;

// the rotation angle by which the relative system will rotate
var rotAngle = 0;

// the rotation angle of the turret
var rotTurret = 0;

// movements
var deltaAngle = 0;
var deltaMove = 0;
var deltaTurret = 0;
var explosionSeq = -1;

// tank dimensions
var tankWidth = 40;
var tankHeight = 86;
var tankHalfWidth = 20;
var tankHalfHeight = 43;
var realTankPoints = [];

// this is the PI/2 which is 90 in radians
var PIover2 = Math.PI/2;

// coordinates of the objects in the relative system
var buildings = createBuildings();

var shellY = 0;
var fire = false;
var recoil = false;
var recoilDist = 2;
var loadingTime = 0;

// draw everything at start with no translation nor rotation
//drawAll(0, 0);
imgSprites.addEventListener("load", function(){
drawAll(0,0, 0);
});

window.addEventListener("keydown", function(ev){

if(ev.keyCode == ctKeyMoveUp || ev.keyCode == ctKeyTurnLeft|| ev.keyCode == ctKeyMoveDown|| ev.keyCode == ctKeyTurnRight || ev.keyCode == ctKeyTurretLeft || ev.keyCode == ctKeyTurretRight
|| ev.keyCode == ctKeyFire){
keyDown[ev.keyCode] = true;
}
});

window.addEventListener("keyup", function(ev){
if(ev.keyCode == ctKeyMoveUp || ev.keyCode == ctKeyTurnLeft || ev.keyCode == ctKeyMoveDown || ev.keyCode == ctKeyTurnRight || ev.keyCode == ctKeyTurretLeft || ev.keyCode == ctKeyTurretRight){
keyDown[ev.keyCode] = false;
}
});

function readInput(){
deltaAngle = 0;
deltaMove = 0;
deltaTurret = 0;

if(keyDown[ctKeyMoveUp]){
deltaMove = -ctDefaultForward;
}
if(keyDown[ctKeyMoveDown]){
deltaMove = ctDefaultBackward;
}
if(keyDown[ctKeyTurnLeft]){
deltaAngle = ctDefautltTurning;
}
if(keyDown[ctKeyTurnRight]){
deltaAngle = -ctDefautltTurning;
}
if(keyDown[ctKeyTurretLeft]){
deltaTurret = -ctDefautltTurretTurning;
}
if(keyDown[ctKeyTurretRight]){
deltaTurret = ctDefautltTurretTurning;
}

if(loadingTime > 0){
keyDown[ctKeyFire] = false;
}
if(keyDown[ctKeyFire]){
fire = true;
recoil = true;
keyDown[ctKeyFire] = false;
loadingTime = ctDefaultLoadTime;
}
}
function update(){

rotAngle = (rotAngle + deltaAngle) % 360;
}

function postUpdate(){

// loading time
if(loadingTime > 0){
loadingTime --;
loadingTime = Math.max(0, loadingTime);
loadingInfo.innerHTML= "Reloading: " + loadingTime;
}else{
loadingInfo.innerHTML = "Loaded";
}
}

// the drawAll function draws all the map and its objects
// parameters:

function drawAll(){
// compute the total rotation angle of the vehicle in degrees and radians
var rad = rotAngle*Math.PI/180;

// compute the forward vector coordinates in the relative system
var rotdy = Math.round(deltaMove * Math.sin(PIover2-rad));
var rotdx = Math.round(deltaMove * Math.cos(PIover2 - rad));

// clear the map
ctx.fillStyle = '#ffffff';
ctx.fillRect(0, 0, canvasWidth, canvasHeight);

// save the context in order to start the transformation
ctx.save();

// move the coordinates system to the center (this is the relative system)
ctx.translate(centerX, centerY);

// apply the rotation to the relative system
ctx.rotate(rad);

for(var i = 0; i < buildings.length; i++){
// make the necessary translation in the relative system
buildings[i].x += -rotdx;
buildings[i].y += -rotdy;

// draw the objects on the map in the relative system
ctx.fillStyle = buildings[i].c;
ctx.fillRect(buildings[i].x, buildings[i].y ,buildings[i].w, buildings[i].h);
if(buildings[i].hilit){
ctx.strokeStyle="#000000";
ctx.lineWidth=4;
ctx.strokeRect(buildings[i].x, buildings[i].y ,buildings[i].w, buildings[i].h);
}
}

// restore the previous context (return to the fixed system)
ctx.restore();

// draw the vehicle at the center of the map using the fixed system
ctx.drawImage(imgSprites, 1, 0, tankWidth, tankHeight, centerX - tankHalfWidth, centerY - tankHalfHeight, tankWidth, tankHeight);

// draw turrent
rotTurret = (rotTurret + deltaTurret) % 360;
var radDeltaTurret = rotTurret*Math.PI/180;
ctx.save();
ctx.translate(centerX, centerY);

// apply the rotation to the relative system
ctx.rotate(radDeltaTurret);
ctx.drawImage(imgSprites, 75, 0, 27, 99, - 15, - 80 + (recoil ? recoilDist : 0), 28, 99);

//fire
var fired = fire || false;
if(fired || shellY != 0){
if(shellY == 0){
shellY = -107;
}
recoil = false;
ctx.beginPath();
ctx.fillStyle = '#ff0000';
ctx.strokeStyle = '#ff0000';
ctx.arc(0,shellY,2,0,2*Math.PI);
ctx.fill();
ctx.stroke();

shellY += -50;

if(Math.abs(shellY) > ctShellMaxRange){
fire = false;
explosionSeq = 0;
explosionY = shellY;
shellY = 0;
}
}

// explosion
if(explosionSeq > -1){
var eX = (explosionSeq * 64) % 320;
var eY = 0;//(explosionSeq * 64) % 320;
ctx.drawImage(imgExplo, eX, eY, 64, 64, - 32, explosionY - 32, 64, 64);
explosionSeq++;
if(explosionSeq >= ctTotalExplosionSeq){
explosionSeq = -1;
}
}
ctx.restore();
}

timeIntervalID = setInterval(function(){gameLoop();}, 100);
function gameLoop(){
readInput();
update();
drawAll();
postUpdate();
}

function stopGame(){
clearInterval(timeIntervalID);
timeIntervalID = -1;
}

function createBuildings(){
var temp = [];
for(var i = 0; i < 20; i++){
var tx = getRandomInt(-200, 200);
var ty = getRandomInt(-200, 200);
var tw = getRandomInt(50, 150);
var th = getRandomInt(50, 150);
temp[i] = {
x: tx,
y:ty,
w:tw,
h:th,
c:'#'+Math.floor(Math.random()*16777215).toString(16),
}
}
return temp;
}

function getRandomInt (min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}

</script>

</body>
</html>

HTML5 Game #1: First person vehicle in 2D

noreply@blogger.com (Anonymous) — Fri, 06 Dec 2013 20:25:00 +0000

I am by no mean a game developer, however recently I have been tinkering with HTML5 2D graphics.I encountered a challenging problem when writing a piece of code for simulating a vehicle navigating through out a map.

The main idea is that the vehicle is fixed at the center of the map and the map objects move and rotate around it as the vehicle moves around.
Actually the concept is quite simple. When a person drives the vehicle he has the impression that objects (trees, houses, etc..) are moving.

Logically speaking the problem is quite easy, however the implementation is rather tricky. The issue stems from the fact that raw 2D engines APIs are not very flexible.PS the concept is the same disregarding the 2D technology you are using (JavaScript, c#, Java...)

So let's now put some hypothesis before we start.We have a fixed vehicle positioned at the center of the map having only one single direction which is upward. The vehicle can move forward, backward, and it can also rotate. But since the vehicle is always fixed in position and direction, it is the objects around it that move and rotate.

To solve this problem we will consider two axis systems.
1- the first one we call "fixed system", and is defined by the origin at the upper left corner with x-axis goes to the left, and the y-axis goes down.
2- the second axis system, which we call "relative system", has its origin at the center of the map and the axis can rotate in any direction

The fixed system is used to draw the fixed vehicle, while the relative system is used to draw the moving objects around the vehicle.

When the vehicle turns what actually happens is that the relative axis system that turns.
As you can see in the image below, the vehicle is still fixed but the circle that was on the left side came into the vehicle vision field.

Now when the vehicle move backward or forward the circle gets closer or farther.

So now what is done practically is that you tell the graphics engine to draw the vehicle at the center of the map (or canvas), then you translate the axis system to the center, rotate them then draw the circle. All of this is done via API calls. No tough calculations are done on your side.

Here is the 1st example:

In this example you can press the buttons forward and backward to move and the button left and right to rotate. You might be quite happy with that, but there is a glitch!
Try rotate the vehicle 90degrees then go forward!
Surprise! You notice that the vehicle seems to go horizontally rather than vertically. For sure you don't want your vehicle to go on the left or right when you meant to go forward.

So what happened behind the scenes?
It all lies in the relative axis system that has been rotated. The picture below depicts the concept.

Moving forward as seen in the picture happens in the relative axis system, which has been rotated and as you can see its axis directions have changed. So a simple translation of objects won't give the correct result because the translation occur in the relative system and not the fixed one.
In other words, if you rotate the relative axis 90 degrees the x-axis becomes vertical and the y-axis becomes horizontal, so moving along the y-axis (which is the forward direction) does not go vertically but horizontally which gives the impression that the vehicle is going to its side!

To solve this problem we need to understand that moving vertically in the fixed system means that we need to adjust the vertical vector to the relative system. This can be done by taking the rotation that occurred to the system into consideration.
Moving dy pixels in the fixed system means that in the relative system we have moved as follows
rdx = dy * cos(Π/2 - Θ); along the relative x-axis
rdy = dy * sin(Π/2 - Θ); along the relative y-axis
where Θ is the rotation angle of the relative system.
Now having the coordinates in the relative system we can translate any object in the that system via a simple operation:
Xobj += - rdx;
Yobj += - dy;

Lets see how this is concertized in reality

Hope this was useful to anyone who is facing a similar problem.
The finish, I have included the code below.

<!DOCTYPE html>
<html>
<body>
<canvas id="myCanvas2" width="300" height="150" style="border:1px solid #d3d3d3;">
Your browser does not support the HTML5 canvas tag.</canvas>
<br/>
<input type="button" id="btnForward2" value="forward" onclick="drawAll(0, -5)"/>
<input type="button" id="btnBack2" value="backward" onclick="drawAll(0, 5)"/>
<br/>
<input type="button" id="btnLeft2" value="left" onclick="drawAll(5, 0)"/>
<input type="button" id="btnRight2" value="right" onclick="drawAll(-5, 0)"/>

<br/>

<script>
var canvas=document.getElementById("myCanvas2");
var ctx=canvas.getContext("2d");

// the rotation angle by which the relative system will rotate
var rotAngle = 0;

// coordinates of the center of the map
// they are also those of the vehicle since it does not physically move on the map.
var centerX = 150;
var centerY = 75;

// this is the PI/2 which is 90 in radians
var PIover2 = Math.PI/2;

// coordinates of the objects in the relative system
var obj1X = 100 - centerX ;
var obj1Y = 5 - centerY ;
var obj2X = 135 - centerX ;
var obj2Y = 60- centerY ;

// draw everything at start with no translation nor rotation
drawAll(0, 0);

// the drawAll function draws all the map and its objects
// parameters:
// deltaAngle = is the angle by which the vehicle has turned compared to the previous time
// deltaForward = is the number of pixels the vehicle has moved forward since the last time
function drawAll(deltaAngle,deltaForward){
// compute the total rotation angle of the vehicle in degrees and radians
rotAngle = (rotAngle + deltaAngle) % 360;
var rad = rotAngle*Math.PI/180;

// compute the forward vector coordinates in the relative system
var rotdy = Math.round(deltaForward * Math.sin(PIover2-rad));
var rotdx = Math.round(deltaForward * Math.cos(PIover2 - rad));

// clear the map
ctx.fillStyle = '#ffffff';
ctx.fillRect(0, 0, 300, 150);

// save the context in order to start the transformation
ctx.save();

// move the coordinates system to the center (this is the relative system)
ctx.translate(centerX, centerY);

// apply the rotation to the relative system
ctx.rotate(rad);

// make the necessary translation in the relative system
obj1X += -rotdx;
obj1Y += -rotdy;
obj2X += -rotdx;
obj2Y += -rotdy;

// draw the objects on the map in the relative system
ctx.fillStyle = '#0000ff';
ctx.fillRect(obj1X, obj1Y ,100,10);
ctx.fillRect(obj2X , obj2Y ,30,30);

// restore the previous context (return to the fixed system)
ctx.restore();

// draw the vehicle at the center of the map using the fixed system
ctx.fillStyle = '#ff0000';
ctx.fillRect(centerX - 5, centerY - 5,10, 10);
ctx.fillRect(centerX - 2, centerY - 10,4, 10);

}

</script>

</body>
</html>

Demystifying Google Chrome Threading Model

noreply@blogger.com (Anonymous) — Tue, 23 Nov 2010 00:19:00 +0000

This post is all about technical stuff that might interest developers who are looking to enhance their thread programming skills.

May be the best way to learn is to see what others had already made in terms of proven concept. What better can this be more than learning how Google did it in its Chrome browser?

Google threading model consists of three components:
- Thread class that encapsulates the operating system threads. It is a class that abstracts Chrome browser from the operating system details. So whether it Windows, Linux or others Chrome code deals only with the Thread class.
- MessageLoop class contains queues for receiving and handling tasks. This is the way to communicate with the thread. Each Thread class contains one message loop. MessageLoop is subclassed to handle tasks in a specialized manner.
- MessagePump class, could be better named as orchestrator, controls the job of the MessageLoop. MessagePump comes with different flavors, depending on the mission it is designed for.

So a Thread object owns a MessageLoop object which in trun owns a MessagePump object. When this system runs it goes like the following:
After the tread is initialized and started, it calls its Run() method which subsequently calls the run method of the MessageLoop object which in turn calls the run method of the MessagePump.

MessagePump

The default behaviour of a MessagePump is an endless loop that passes through the following steps:
- tells the message loop to execute the pending tasks
- checks if a quit order has been issued, if this is the case quits otherwise continue
- tells the message loop to execute delayed tasks
- checks if a quit order has been issued, if this is the case quits otherwise continue
- tells the message loop to execute any idle job

MessageLoop

The MessageLoop has four queues to manage tasks. The incoming-queue that stocks any new task submitted to the thread, a work-queue that contains the tasks to be executed and a delayed-work-queue that contains tasks that should be executed sometimes in the future.
Finally the fourth queue is deferred-non-nestable-work-queue which has to do with reentrancy and will be discussed later.
All queues work in FIFO mode.

When a task is submitted to the Thread, it is inserted in the incoming-queue. The MessagePump tells the message loop to execute pending tasks, the MessageLoop checks whether the work-queue contains tasks. If it does not, all the tasks in the incoming-queue are transferred to the work-queue. If the work queue already contains tasks, the execution continues normally.
The MessageLoop pulls a task from the work-queue and verifies if it should be executed at once. If the task is delayed, meaning should be executed in the future, it is inserted into delayed-work-queue, otherwise it is executed right away.
Observers are components that might be interested in knowing what tasks are being executed in the MessageLoop. For this reason they register their intention with the message loop. The message loop notifies all observers before and after the execution of each task.

The good question to be asked in here is why to have the incoming-queue and the work-queue? Why not only have the incoming-queue alone! Actually it is all about performance. Each time a incoming-queue is accessed for input or output a lock is acquired to avoid data corruption. So in the aim to reduce the number of locks mainly by the MessageLoop, every once of a while (when the work queue becomes empty) a lock is acquired on the incoming-queue and all its content transferred to the work queue. This is way the income-queue is now available to receive more tasks while the message loop is busy executing those on work-queue.
It is worth noting that this strategy works fine when the number of expected incoming tasks is high. On the other hand if the number of incoming tasks is low there will be no performance gain since MessageLoop will waste time on locking and transferring tasks from the incoming-queue to the work-queue.

Reentrancy

Generally speaking a function is reentrant when it can be called again even when the first call did not finish yet. An example of reentrancy is recursive function.

MessageLoop is reentrant, meaning that when it is executing a task, its Run() method can be called to execute subsequent tasks even when the first one was not over yet. In this case we name the first call the outer MessageLoop and the second call to Run() the inner MessageLoop (Important: we are talking about the same MessageLoop instance. The outer and the inner qualify the first and second call to its Run() method).

Consider an example where a task opens a modal dialog box. This dialog box must be able to respond to user’s input so the message loop has to keep executing tasks! However since it did not return from the task that created the modal dialog box, it can’t proceed with the other tasks (this is the outer MessageLoop). To make this possible the modal dialog box calls the Run() method of the MessageLoop in the following way (this is the inner MessageLoop):

bool old_state = MessageLoop::current()->NestableTasksAllowed();
MessageLoop::current()->SetNestableTasksAllowed(true);
MessageLoop::current()->Run();
// Restore task state.
MessageLoop::current()->SetNestableTasksAllowed(old_state);

This ensures that the modal dialog box is responsive and the tasks are being handled by the same MessageLoop.

Tasks that run in an inner MessageLoop are called nestable tasks and have their nestable property set to true.
However if a task is not nestable this means it must be execute after the first task completes. So to make this possible, the inner MessageLoop won't execute the task but adds it to deferred-non-nestable-work-queue. When all inner message loops finish their job and are released the outer MessageLoop will be executing tasks that were pushed to deferred-non-nestable-work-queue.

This was a brief simplified overview of how threading in Google Chrome browser works. It constitutes a good start for those who scratch their heads to find a solid and proven concept to implement threading.

How to become world class developer

noreply@blogger.com (Anonymous) — Fri, 19 Nov 2010 23:20:00 +0000

Every developer dreams of reaching a world class rank. But reaching this rank is not given to everyone unless he/she is working in a big company, and on a big project. Working on small projects limits the horizons of the thoughts and hides much of the big projects complexities and approaches to the solutions.

While books are necessary to learn, they stop short of giving real experience. Books are good for getting started, learning the methodology, the object model and the APIs. No doubt this is a necessary package however it is necessary but not sufficient. No book is able to explain the details of a project and the pros and cons of every technical decision made in the course of the development.

The picture looks somehow dim for those who are not lucky enough to work in giant companies and produce softwares that are used by millions of people.

This is not completely true. There is a way of becoming top notch developer even while working on small projects. The solution exists but it is not free! It costs time and efforts. It is only for people who are passionate about developing.

The large majority of commercial softwares have their code hidden and restricted to the teams that are working on them. But there are also very important open source projects that are accessible to everyone and are used all around the world. These softwares are written by highly skilled engineers either part of their daytime job or on their free time. In both ways, these projects are “gold mines” for developers who are aiming to acquire new skills.

So the solution is to find the right open source project, one that is interesting to the person wanting to learn. Then, try to build the project and start learning the code. At first it looks like a daunting task. It might fail few times, but success comes with persistency and perseverance.

Every open source project has forums and discussion groups, but almost all of them lack complete and clean documentation. So a good approach would be to grasp the overall architecture of the project and all the available documentation that goes around. Then start looking in the code for the following points:
- Coding style: it is important to understand how the lines of codes are written because it helps improve readability.
- Tips and tricks: every module or sub module of the project brings a solution to a problem. Some are straight forward; others are trickier and utilize an indirect approach. It is crucial to learn these tricks in order to use them when facing similar problems.
- Global architecture: while tips and tricks are used on a granular level, the global architecture gives the big picture and discusses
the decisions made to solve key problems. It is worth mentioning that there is no single ideal solution, but a solution that fits certain priorities established by the project authors.

After understanding the code or at least part of it, it is important to get involved with the community that is working directly or indirectly on this project. For this reason it is imperative to visit the project forums on regular basis and actively contribute to the discussions. This will increase the understanding of the project and the reasons why some decisions are being taken.

Another major point is to discover bugs and propose solution for them. Many open source projects have policies to allow people to contribute to the project that has a mandatory path that goes through discovering and solving bugs. Once a certain number of bugs and fixes are reached, the person is allowed to become a committer which means contributing to the development of the project. When such a stage is reached, congratulations! You are now a world class developer.

VC++ Tip: Show Includes

noreply@blogger.com (Anonymous) — Sun, 10 Oct 2010 08:44:00 +0000

The following is a useful Visual C++ tip that solves a frequent problem any VC++ developer might face.
There are time in which you get errors from files you have never created, or included into your codes.
This can be very frustrating and hard to debug especially if that file is burried deep into #include tree.

Consider the following example where you get an error such as
c:\program files\microsoft visual studio 8\vc\include\math.h(486): error C2084: function 'long abs(long)' already has a body

You might be scratching your head to figure out what does this mean knowing that you have never included "math.h" in your code.
One way of proceeding is to go open each nested #include file to determine where this file is include. However you will soon discover
that you have entered a complex labyrinth in which the way out is so difficult to find.

Another easier approach is tell the compiler to show the list of all included files used in the comilation:
1.Open the project's Property Pages dialog box.
2.Click the C/C++ folder.
3.Click the Advanced property page.
4.Modify the Show Includes property to 'yes'

On compilation you get a list like the following:
:c:\globalProjects\localProjects\srcCtrl\srv\src\myproj\util\net\ServerBase.h
: c:\globalProjects\localProjects\srcCtrl\srv\src\myprojTools\myprojUtils.h
: c:\globalProjects\localProjects\srcCtrl\srv\src\myproj\util\net\NetworkConnection.h
: :c:\globalProjects\localProjects\srcCtrl\srv\src\myproj\util\Obj.h
: : C:\Dev\Dependencies\thrdParty\extension\thrdParty\stlport\stl\_threads.h
: : :C:\Dev\Dependencies\thrdParty\extension\thrdParty\stlport\stl\_cstddef.h
: : : C:\Program Files\Microsoft Visual Studio 8\VC\include\stddef.h
: : : :C:\Program Files\Microsoft Visual Studio 8\VC\include\crtdefs.h
: : : : C:\Program Files\Microsoft Visual Studio 8\VC\include\sal.h
: : : : C:\Program Files\Microsoft Visual Studio 8\VC\include\crtassem.h
: : : : C:\Program Files\Microsoft Visual Studio 8\VC\include\vadefs.h
: : :C:\globalProjects\thrdParty\extension\stlport\stl/_cstdlib.h
: : : C:\Program Files\Microsoft Visual Studio 8\VC\include\stdlib.h
: : : :C:\Program Files\Microsoft Visual Studio 8\VC\include\crtdefs.h
: : : :C:\Program Files\Microsoft Visual Studio 8\VC\include\limits.h
: : : : C:\Program Files\Microsoft Visual Studio 8\VC\include\crtdefs.h
: : : C:\globalProjects\thrdParty\extension\stlport\stl\_cmath.h
: : : :C:\Program Files\Microsoft Visual Studio 8\VC\include\math.h
: : : : C:\Program Files\Microsoft Visual Studio 8\VC\include\crtdefs.h
>c:\program files\microsoft visual studio 8\vc\include\math.h(486) : error C2084: function 'long abs(long)' already has a body

In here you will find the whole tree of #include before the error. Notice how deep math.h is include far below ServerBase.h.

It is extremely difficult to detect its presence without the use of this option.

Quality Content Comparative Analysis

noreply@blogger.com (Anonymous) — Sun, 03 Oct 2010 18:06:00 +0000

There are plenty of ways to create content on the internet. Blogs, articles, videos, forums, and Q&A etc...
There is also on unexploited potential way that can be used to create quality content which is chatting.
Certainly there are pros and cons for each way. Below is a comparative analysis for each method:

Articles and blogs are maybe the most well known methods their advantage is that they are or might be complete and detailed with complete exposure of the domain or point of view. On the other side they are the less interactive. Despite that most of them have commenting features; it is rare to see true interaction between authors and readers.

Video content are now notorious with Youtube especially that there are plenty of people who are trying to provide quality videos. Consuming this type of content is by far easier than reading especially when presented in an appropriate manner. The problem of video content is mostly in availability of the topics. It is still far behind written text. Interactivity is not better than blogs, it consists only of viewers comments.

Forums and Q&A on other hand have better interactivity but less complete content. They are usually centered on a post or a question that people discuss and exchange opinion. The content is not really a detailed info rather than an exposure of a problem that the community is asked to contribute to the solution. Although the interactivity is higher however it is not in real-time. So the interest party must have enough patience before succeeding getting the community to be engaged in the solution.

Chatting has always been the fun thing and to meet other people generally from the opposite sex. However this does not have to be this way. People are usually interested in topics, this clearly seen in the comments on blogs or videos as described earlier. So chatting can be part of the quality content creation if it is presented accordingly. Any event, news or article can trigger a discussion between supporters and opponents. Services like www.SimpleConnexion.com give people the option to find others who are interested in a particular subject and exchange with them opinion in real time fashion and at the end publish the content of this discussion so that other people benefit from this opinion exchange.
The advantage of this method is that it is real-time; people get replies in a matter of seconds. It is challenging because a person can easily ask his peer to clarify his answer or opinion which means it creates a better understanding. The content of the discussion can be published as just explained.
The difficulty is to really find someone to chat on a specified topic at a particular time. This difficulty will be overcome as more and more people adopt this type of chatting.

In conclusion diversity of methods leads to richness and creativity as well as provides suitable ways for different people according to their preferences and needs.

Added Value Chat

noreply@blogger.com (Anonymous) — Sun, 26 Sep 2010 16:18:00 +0000

There is chat for fun and there is chat for the sake of sharing knowledge and information. So far sharing knowledge was restricted to the realm of forums and blogs. Information chat on the other hand exists within enterprises via instant messaging systems (IM).

In companies colleagues and project members refer to shared documents for references and how-to information. But generally efficient knowledge transfer occurs, most of the time, after talking to other people. The key to such efficiency is the informal way the subject is tackled and the straight approach consisting of a direct question and a direct answer. This is not available with formal documentation because it contains lots of literature to explain the context and the scope of the document before delving into real material. Certainly these are most needed when starting a project. Project members need to know all the factors involved in the project.

However as the project goes on, questions start to rise from here and there. Sparse questions are met with sparse answers with lots of email exchange or direct discussion. Due to the workload and deadlines the documentations are rarely or never updated to reflect the topics discussed. This results in losing crucial information used on day to day basis.

One of the possible solutions to this problem is to encourage discussion between team members via chatting system and save those discussions and make them available to others so they can benefit from the information they contain.

www.Simpleconnexion.com is a service that pushes forward this concept.

Interview Your Contacts

noreply@blogger.com (Anonymous) — Fri, 24 Sep 2010 06:40:00 +0000

Whether for professional purposes or for fun any discussion between two people could be viewed as an informal interview in which opinion and/or information is exchanged. Interviews are not only a formal discussion between a journalist and a celebrity; it can also be a chat between two friends, or two colleagues. What matters is the information contained in such interviews and how valuable it is for the public.

Obviously interviewing has many forms, it can be on TV, in a newspaper or magazine, and it can also be online! With the unprecedented success of the internet and the adoption of the web, there is no reason that interviews can’t be done online.

Actually, informal interviews have been practiced since the early days of internet through the chatting services. The only difference from the formal ones, other than the style of course, is the persistency of the interview. While the latter are published and made available to virtually anyone to read, the former was mostly confined to the private domain.

There‘s no doubt that chatting is a form of interview. Even if it does not involve a well-known celebrity or an experienced journalist, nevertheless it still can contain valuable information that could benefit others.

Consider an example where one is asking his colleague about technical matter related to a certain project. Sometimes this exchange is done via email but there are other times when it is done over a chatting service like MSN. The best thing to do at the end is to publish this discussion that can be also thought as an interview. Even though there are no nationally or internationally known figures involved, however the contributors are valuable to their colleagues and other project members, and their issue they discussed is certainly important to them.

www.SimpleConnexion.com concept goes into this direction and tries to promote the concept of publishing added value discussions.

Chatting or Blogging

noreply@blogger.com (Anonymous) — Wed, 22 Sep 2010 22:12:00 +0000

This might seem odd to compare two distinct activities. One might think like comparing apples to oranges! Although at first this appears to be the case, but when looking closer, some similarities emerge to the surface.

Blogs (web logs) are usually maintained by an individual with regular entries of commentary, descriptions of events, or other material such as graphics or video. Most blogs are interactive, allowing visitors to leave comments and even message each other via widgets on the blogs and it is this interactivity that distinguishes them from other static websites.

On the other hand online chat can refer to any kind of communication over the Internet, but is primarily meant to refer to direct one-on-one chat or text-based group chat , using tools such as instant messengers, Internet Relay Chat, talkers and possibly multiple user dungeons (MUD)s. The expression online chat comes from the word chat which means "informal conversation".

So the differences between blogs and chat are persistency and formality. Blogs are persistent meaning they exist on a webpage and they can be accessed any time. They are also formal (at least a good part of them) and they address a whole audience and not a particular person. On the contrary, chat is transient, ephemeral; it does not live beyond the life of a discussion and of course the majority of the chat is informal.

Although differences seem to weigh considerably, similarities on the other hand exist. Blogging and chatting can both carry information that is valuable to others. Meaning, a person seeking a piece of information or looking to solve a problem, can find it either on a blog or in a chat room. The only concern related to the chat is that the info might have passed or not yet arrived so the timing is critical.

However, this can be solved by simply saving a discussion and convert it into an informal blog. This method offers good benefits to the reader because he will be seeing an interaction between two people and this means some specific questions and clarifications might be also evoked in the course of the discussion. To the person who is giving this information he is freed of the task of writing formal blog.

In this context www.SimpleConnexion.com is looking to promote this concept.

Educational Youtube (part 2)

noreply@blogger.com (Anonymous) — Mon, 30 Aug 2010 19:10:00 +0000

Shortly after I have written the blog about Educational Youtube, and what effective role it can play in the future education. I have been introduced to an amazing website that offers free educational courses using videos hosted by Youtube. Did I mention for free? Well it is for FREE.

This site is done by only one man; he made some 1600 videos separated into three main categories: Math, Science and Others. He made his videos in such manner that they are short and easy to understand; in another word you get the essential of each course in just 10minutes which is very efficient and straight forward. You don’t have to sit in a class room and listen to a lengthy and boring lecture. All what you have to do is pick a subject from the long list and pay attention to the explanation for few minutes and that’s it. Later on you can return to stay another ten minutes and continue the course.

But that’s not all! The story does not end here. Sal Khan, the creator of this video library www.KhanAcademy.com got a really unexpected and unusual fan: Bill Gates. According to Fortune when Bill Gates knew about Khan he said “this guy is amazing”.

He actually is; he might become a leader in innovative education with his stock of videos. He is surely able to reach a large base of potential students and change the way they are learning.
Of course this is also made possible because of the infrastructure laid down by Youtube service.

However, what is missing in this system as a whole is the interaction between student and teacher which is also a building block to the comprehension. But we are only seeing the beginning of the evolution, the tip of the iceberg. The technology will soon catch up and try to fill the gap.

Check the following link fo more details about the story of Sal Khan http://money.cnn.com/2010/08/23/technology/sal_khan_academy.fortune/index.htm

Educational Youtube

noreply@blogger.com (Anonymous) — Sun, 29 Aug 2010 20:11:00 +0000

The conventional way to learn new materials is either enroll into a course or read a book. However these are no more the only options that we have nowadays.

Actually the previous two methods have certainly their advantages such as getting some sort of certification after the completion of the course and this gives you credibility that you really know what you claim to know. As for reading a book it is still a handy and convenient way since you can take it with you while travelling in the train, plane or even on the beach. Note that even with these features books are being challenged by technology with the advent of IPad.

However, there are disadvantages related to those methods. Course involves displacement to a certain location on a certain date at a certain hour. For working people this is not always easy to do and even when done they might not be in shape to fully assimilate the explanation especially after having a bad day. On the other hand, books also require some energy to read and assimilate. In addition, if the content needs to be practiced there will be switching from reading to practicing and vice-versa.

Luckily, this seems to be changed by Youtube! Until recently I used Youtube to watch some funny movies. But the other day I had the idea to search for a technology related subject and I was surprised to see tens of videos to that topic.
When running few of them I realized how efficient this method is. The explanations are directly backed by a demonstration, so the viewer won’t lose focus switching from book to computer. When, in doubt or you miss something you can repeat the clip as much as you need. You can pause to have some rest and resume later. In short you have all the advantages that you don’t have when you take a real life course. Plus it is totally FREE.

This reminds me of the open-source model, where people spend considerable amount of time and efforts to build software only to give it away for free. Same thing seems to happen in here; people are doing a series of learning videos and put them on YouTube for free. Surely they expect to get something in return by becoming well known in the domain they are talking about, but nevertheless the public is profiting from this model to get free learning and educational stuff.

Could we see in the future students logging to their Youtube class?! Nobody knows for sure, but one thing is certain; technology is reaching every aspect of the human life.

Twitter Source of Discussion

noreply@blogger.com (Anonymous) — Sun, 29 Aug 2010 15:32:00 +0000

Beyond any doubt Twitter is the number one service in microblogging. With its 50million tweets a day it sits on top of “traffic chain” (term borrowed from “food chain”) and constitutes an enormous source of information.

Actually Twitter stream is a mixture of information and opinions, where a measure of the information popularity is possible thanks to the retweeting. However there is a gap in this system! Tweets are not long living. In fact their life expectation does not exceed few seconds. So catching a tweet among 50millions is like searching for a needle in a hay stack.

Because tweets carry information and information might be useful to different other people, they might use it in different ways according to their needs and objectives.

One of these objectives is to discuss information contained in the tweets and exchange opinions about them. One method to that is to reply to the original tweet with a comment. The drawback of this method is the lack of interactivity. The source of the tweet might not be available for replying or might be simply uninterested. On the other hand some other people might be happy to discuss it, but the problem is how to find them?
Besides of information a tweet carry an opinion. People interested in some news or information are logically tempted to tweet them. In other words what they do is bind their own preferences within the tweets. These people are more likely ready to talk about their tweets and discuss them.

Many products and services are trying to benefit from these two features. One of them is www.SimpleConnexion.com that tries to create discussions between people around a certain tweet.

Q&A websites review

noreply@blogger.com (Anonymous) — Thu, 26 Aug 2010 19:30:00 +0000

Social networking ideas are hatching everywhere. Basically there are endless ways to bring people together, the aim is to let people meet, discuss and interact.

The new trend nowadays is the Questions & Answers websites. People with questions go there ask them and people who have answers, whether right or wrong, reply.

Forums have been doing that for ages, but with a major difference. Forums are most of the time specialized, so you find IT forums, medical forums, parental forums etc… If you have a question first you need to find the right forum for yourself. Then you have to subscribe, create a thread and post your question. This might seem tedious for those who need a fast answer.

Questions & Answers websites have another approach to the problem. You go find any of these websites, you still have to subscribe or login using your Facebook account for those who support Facebook Connect. Then you ask your question. The website will take charge of finding people who might answer it. It alleviates the task of finding the right place and the right people.

Forums are still very efficient when you have a very specific question. For example if you are a developer and looking to solve a problem, it is by far better if you search for it in a specialized forum, because all its members are IT professionals.

Conversely if you have general question related to an event, celebrity or broad business Q&A sites will be useful for you, because they gather people from different domains and backgrounds.

Another major benefit of the Q&A is socializing. Because people might have general questions there is a better chance to create a discussion. While specific question means that you are mostly interested in a good answer that solves your problem without having the time to chitchat.
There are many Q&A websites out there but the most known are Quora.com and Vark.com.

However the drawback that lacks behind is the absence of direct one to one discussion with interesting people. This is where http://www.simpleconnexion.com/ is trying to solve.

Make Your Own Market Study For Free

noreply@blogger.com (Anonymous) — Sat, 17 Jul 2010 00:22:00 +0000

If you are one of these people who are seeking to create a new startup, you might have some ideas that you believe in and want take a new adventure. But before you start you need to tap the ground and discover the readiness of the market. Every project must have a market study to assess its viability. If you have big bucks in your pockets you can delegate this task to a company to do it for you and hand you the result while you are playing golf. However if you are startup creator, the last thing you need to do is to spend money uselessly. Every penny counts for entrepreneurs and their startups.

Market study is used to determine the consumer interest in your product and to weigh the competition. Based on these results you consider your decision whether to enter the domain or not.
Although there are professional companies that are specialized in making market studies, you can do it by your own using simple tools for free. These tools are:
- Google Trend
- Google Search
- Alexa.com

At start you might be interested in getting data about consumers needs. People usually use Google to search for what they are looking for. Luckily Google gives you a way to find out what they are looking for. By going to Google.com/trends you will discover the keywords that people used in their search. Put the keywords related to your new business and check the results. Try several combinations in order to get the best results. For example if you want to give online photography courses you might search for the following “online photography courses” or “photography courses online” (order of the keywords matters). If you are interested in one region of the world you can specify it too. In case the index given by Google Trend is not sufficiently high, you might not have a real market or you might be using the wrong keywords to describe your business or you need to find other ways to get data.

Once you are satisfied of the keyword results and you think there might be enough demand, what you need to do next is to determine the competition. Use Google search to find sites in your domain using the same keywords you used in Google Trend. Start by checking the commercial links displayed by Google because these companies are being aggressive at the market and you surely need to know what they are offering. Then take most of the results that appear on the first two pages of Google; check them one by one and see how they differ from your ideas and what features they are offering to the users.

After you have determined the quality of these sites you need to know how popular they are and if you will be able to compete against them. To know that go to Alexa.com and search for each of these websites and check their ranks and the traffic rank history. The current rank tells you how strong in popularity they are. If their rank is below 10 000 that means they are very strong and you might expect a fierce competition. The traffic rank history will give you an idea of how much time they took to reach their current position. This gives you an overview of how hard or easy is the road ahead.

In some cases you can get additional info about their financial situation such as sales and revenues either directly from their website or by searching for this info on some sites such as Tracked.com, although it is not always guaranteed that you will find useful data.

Now you have all the information in your hand. Based on these figures you can take a moment to study and evaluate your chances of success and the stiffness of the competition.

The Uptime Curse

noreply@blogger.com (Anonymous) — Thu, 15 Jul 2010 23:10:00 +0000

There are times in which you feel low, depressed and frustrated, and there are other times in which you have high morale, enthusiasm and optimism. While the former feeling is counterproductive and should be treated quickly to overcome it, the latter does not necessarily mean good thing. If not handled smartly it won’t result in boosting productivity as expected.

As a matter of fact high morale leads to a rise of the self confidence and may lead to overconfidence which might have severe consequences on the ability to take the right decision. When experiencing an uptime it is crucial to keep your feet on the ground and avoid thinking that everything is possible, and can be done disregarding of the required resources and efforts.

Ignoring this fact might lead you into an endless labyrinth which results into failure to achieve any of the given goals and shorten the way to another state of depression, pessimism and frustration.

To avoid this pitfall, you should understand that this sort of ecstasy you are passing through is certainly transient and does not make you a superman. You can’t go beyond your capabilities. In fact if you try to do that you will over burn this energy in a minimum amount of time and return to square zero.

Once you are convinced that what you can’t do normally you won’t be able to achieve because of some psychological burst, you should use this energy wisely and try to get the most benefits from it.
To do that you need to concentrate your efforts on one or few tasks or goals that you need to accomplish. Do not over estimate your capacity, just prioritize the tasks or projects you have and focus on the most important ones.

Avoid spreading your efforts on multiple subjects because you will soon discover that you are not progressing on any of them and that’s bad for your morale and your body.

Remember that the up time has its own curse too. Neglecting this fact will condemn you to failure and frustration.

How to Write Original Content

noreply@blogger.com (Anonymous) — Fri, 09 Jul 2010 14:22:00 +0000

Back to the early school days, it was very common that students were asked to construct a “meaningful” sentence using a verb such as “eat”. Usually most of the little girls and guys answer by “The boy eats an apple”. The sentence is grammatically correct; however the teacher was not happy seeing tens of similar copies. Same for search engines!

Search engines, just like teachers, do not like to see the same content recurring over and over for this reason they degrade its rank. However, you don’t need to be Shakespeare nor Einstein to be able to create an original content that pleases search engines.

Actually the original content is related to the writings and not to the subject. You really don’t have to come up with something totally new, creative and innovative. If you can this would be wonderful, but if you cannot it will not be a catastrophe.

Here are few steps to accomplish something original for your own blog:

Determine the area of interest on which you want to write
Search on the internet for articles, documentation, or even other blogs related to this subject
Read 3 or more of these articles and try to fully understand what they are saying
Take 15 min pause
Rewrite in your own way what you have understood from those readings
Congratulations, you have now an original content that search engines will like

If you are thinking this is might be somehow fraudulent, rest assured it is not! Quite on the contrary you are contributing to the general knowledge and culture of the people who are looking for the subject you wrote about.

In fact people have different ways for reading and assimilating the material they read. They might not be able to understand one article because it might be written in a way that is counterintuitive for them. This is why they will drop reading very fast and search for something similar. Because different people have different ways, there will be a group that will appreciate your article over others.

Therefore, your content has become original and useful.

What Is Selective Chat

noreply@blogger.com (Anonymous) — Mon, 05 Jul 2010 13:17:00 +0000

Since the old days of IRC till our days the expression “Hi, asl plz?” is the must have opening for every chatting session between two strangers. Furthermore, if you are a male you won’t accept less than something like “25 F …”

Due to the lack of enough information any discussion was very slow to start, moreover it is rarely scoped into a certain topic or subject. It is true that most of the chatters are males seeking females. This is what the statistics reveal, and can’t be denied. However any discussion would be far more interesting and fruitful if the two parties have minimum information regarding each other and be centered on a specific topic that is of common interest.

It is not unusual to meet someone who is seeking to talk with another having a certain intellectual background and education level or having experience in a very specific domain. There are thousands of people who are seeking information and are not sure where to find them and how to utilize them. Obviously it can be helpful if they can meet someone online who can help them in real time manner. No doubt this type of information exchange and collaboration increases the richness of the discussion and avoid wasting time on lengthy introductions that ends most of the time in frustration.

The importance of the selective chat as opposed to the random chat lays in the fact that the latter is full of bad surprises and annoyances, while the former is based on a careful selection of the peer in order to open a discussion with him or her. This gives a huge benefit for both parties because they can capitalize on their discussion to make new ones and maybe evolve their cyber relation to a real life one.

In this perspective www.simpleconnexion.com is trying to offer something of value to its users and by making it intuitive and friendly to use and avoiding the hassle of a long and boring registration process and profile management. Check about us for more info.

Breeding Ideas

noreply@blogger.com (Anonymous) — Wed, 30 Jun 2010 21:40:00 +0000

According the Merriam Webster online dictionary one possible definition of the word ‘idea’ is a “formulated thought or opinion”. So if you are looking for new ideas you need to think about it because they do not just come by themselves. Even if sometimes you think you got an idea spontaneously that’s not true, it is only an illusion. In reality your subconscious was busy working on it and was waiting for some sort of event or trigger to send it to your conscious.

So how ideas are created? Usually ideas are issued from unsolved problems or unsatisfying solutions. People who are having trouble with certain matters on a daily basis are more likely to think about new ways to improve the way to perform their day to day tasks.

If they succeed in finding a solution then the idea is born and might appear genius to some people and irrelevant to others. Not every idea will be a success at the business level, it all depends how the market reacts towards it. However, if you have solved a problem that you were facing, there are big chances that some others out there are facing the same issue and might be looking for the solution that you have invented.

The above is one approach for breeding ideas. But that’s not all! There is at least one other way to create new ones and innovate. Needless to say every approach requires intellectual efforts and brainstorming.

So another way to breed more ideas is to combine several existing one to create a new hybrid one. At start, there might not be an immediate need for this new idea, but as the time goes on and the idea is put to use, the public might discover that it is serving them in a way they did not expect.

Combining several ideas into one is straightforward. All what is needed is to draw a table in which you put current inventions in rows and their features or uses in columns.

Consider the following example: A mobile is used for making calls and send SMS at a long range; a remote control is used to control a device such a TV or Stereo at a small distance. One possible combination is to merge them into one instrument that allows people to make calls and control their home machinery over a long distance. This way when they get home they have everything in place as desired; like music is on, plate heated in the oven, the AC is working etc…

Is it useful or will it gain acceptance? This is a different story. The important is that you created the idea and now you can work on it to make it appeal to people.

You can also read an interesting blog “How to unlock your creative genius” written by Don Dodge in which he exposes his opinion about how genius ideas are born.

IPad, Just Another Gadget

noreply@blogger.com (Anonymous) — Mon, 28 Jun 2010 12:35:00 +0000

Recently I have been tinkering with IPad for some time, in an attempt to convince myself to use it on day to day basis. However I felt it is was not built for working people who use the computers to produce something of value to their companies or customers.

This might be hard said, but that was my reaction. For me IPad is a gadget and not a tool for work. Before going further, I would like to note that this does not diminish its value as an amazing technological device.

On the other hand for people who use computers as a productivity tool, there are some big issues related to it. The minute you lay your hands on one of them you will instantly notice the following:

Your fingers are not as precise as a mouse pointer, so if you are doing something like paintings or graphic design you will have hard times going through it.
Also it is not suitable for real work on spreadsheets such as Excel, due to the endless manipulations you need to do with your fingers, instead of a mouse.
Certainly it is not suitable for programming, but I guess this is the least of concerns for many people.
Another annoying feature is the continuous switching back and forth of keyboards as well as jumping from alphabetic mode to numerical mode. This will make any writings take at least 1.5 times the writing on a real keyboard.
Now the real big issue is in the design concept itself. To really use the IPad for writing you will have to bend over it to use its keyboard causing you a pain in the neck and shoulders on the long run, and reducing your ability to easily view the content of the screen. If you place it vertically to read or view the content you won’t be able to write without twisting your fingers and wrists.

So with all those drawbacks, what is IPad for?

Well it suffices to look at some of the advertisement to know that IPad is only for sharing photos, doing social networking, reading books or articles, viewing videos, and web browsing in general. But if you are doing serious work it won’t help you.

When I asked a friend if she is going to buy an IPad she replied: “what for? For music I have my IPod, for work I have my laptop and for roaming I have my mobile”.

So it is just fair to think that IPad is more cumbersome than a mobile, and less effective than a laptop.

Based on this assertion I don’t think that all of us agree with Mr. Steve Jobs that the era of PC is over.

The People, The Place and The Subject

noreply@blogger.com (Anonymous) — Fri, 25 Jun 2010 11:58:00 +0000

There are plenty of chatting and communication services out there. Each one has its own concept and tries to solve a specific problem. They adopt different approaches towards serving their users:

- Instant Messengers are centered on detecting when a friend or a contact goes online in order to chat with him/her.

- Chat rooms are about bringing people together in one place to discuss a certain subject. Usually rooms are labeled by topics. However there is rarely specified material to discuss and people engage into free discussions and speeches.

- Forums are usually more focused and members are required to stick to the subject of the thread otherwise their posts will be deleted. The problem of the forums is the lack of real time interaction, and of course people have to search for the forums which fit their needs. Believe me that's not an easy task.

However a brand new approach is emerging. This new concept takes a different approach to tackle the problem and offers a solution by bringing together the people, the place and the subject.

The place is simply any web page on any website.
The people are the users who are viewing that web page.
The subject is the content of that web page.

So if a number of people are seeing the same web page, they are most probably interested in the subject offered there. If they are interested, chances are they either agree or disagree and probably they would like to say something about it and discuss it with others who are viewing the same web page as well.