codinpsycho

So this happened at Video Game Fest 16 Pune. Thanks to the awesome folks at LXG India TV where we talked about what we do, why we do and how we will be doing it.

#holi #trekking #camping #mountains #gopro #epic #journey #india #hills

Getting such a tomb raider kinda feeling #trekking #camping #tents #mountains #journey #gopro #hills #india #calmness #happiness

Finally its here .. so wanted to read this #pixar #touch #book #happy (at iit bombay)

When internets down people do some cool stuff #wallart #nointernet #art #painting #graffiti #streetart Done by shubhajit and girish (at IIT Bombay)

omg .. real life 8-bit pixelated shadows :p #graphics #gamedev #programmer #rendering #awesome (at IIT Bombay)

Koenig Lookup/ Argument -Dependent Lookup lets suppose the following scenario --> //Trivial namespace for testing purpose namespace test { class A { }; //Empty Class void f(int x) {  cout< //simply ouputs the integer value passd int f(A obj) { cout<<"OBJECT"; } //Prints OBJECT and takes an object of class A } int main() { //Inside main() i make a simple function call f(10); } Now what will happen is that the compiler will search the global/free functions for  similar signature, but wont find one because there aint one. The function  void f(int x) is the namespace test and is inaccesible there until we use  using namespace test; Now if i add a function  int f(int x) { cout< int main() { //Inside main() i make a simple function call f(10); } just before main() i.e in the global region, then the compiler will find a match when  called through main(). This is all so simple and obvious, isnt it?  Now a similar case --> //Trivial namespace for testing purpose namespace test { class A { }; //Empty Class void f(int x) {  cout< //simply ouputs the integer value passd int f(A obj) { cout<<"OBJECT"; } //Prints OBJECT and takes an object of class A } int f(test::A obj) { cout<<"ANOTHER OBJECT"; } //Similar to function inside namespace //but this one is just in global scope int main() { //Inside main() i make a simple function call test::A obj; f(obj); } Now what will happen in this case. the obvious answer would be that global f() would be  called and ANOTHER OBJECT will be printed. but heres the truth guyz, the compiler will  deflect slightly from usual name-lookup and will use another kind of name-lookup because  the parameter you passed to the function is an object of a class/structure. This kind of name-lookup is called KOENIG LOOKUP/ARGUMENT DEPENDENT LOOKUP. and it would lead to an ambiguous call, the compiler would get confused between test::f(A obj) and global int f(test::A obj) although theres no using directive used. The compiler will follow this rule ---> "If the parameter passed to a function is an object of a class/structure then the compiler  would also include those namespaces in which that class/structure or its object is  defined." Well you would be thinking that whats the use of namespaces then, the namespaces are  still functional and continue to serve their purpose, but this is just one rare case in which  the compiler crosses the namespace boundary. This kind of lookup called KOENIG LOOKUP was named after Andrew Koenig who nailed  its proper definition.

The Infamous pimpl idiom C++ Pimpl standing for Private Implementation is a famous C++ idiom  particularly popularized in Herb Sutter's Guru of the week column (www.gotw.ca). It describes a way for hiding your class's private members,by making them invisible from your Header file. Remeber this fact that whenever compiler sees your class, it only sees the header file (.h) and not the implementation file (.cpp). So what this basically does is that it removes all your private members from your header file(.h) and adds them to your implementation file (.cpp). Additional advantage of this technique is that it makes your class immune to changes meaning that you dont need to recompile it again and again if you change the private memebers. Also it keeps you public interface clean, and the client programmer doesn't need to be aware of you private members. It achieves this by using an opaque pointer, which is a pointer to a forward declared class or structure. Eg: struct B_impl; //Forward declared structure class A { B-impl *my_Impl; //Opaque pointer } Here Structure B-impl is only forward declared so the pointer my_Impl is an opaque pointer. Now lets jump directly into action and see how pimpl is implemented : This is our class : //file A.h //So many header files increases compile time :( #include #include #include #include #include class A { B objB; C objC; vector vlist; } Now lets implement pimp idiom ---> //file A.h //What happened to all the header files.....?? strcut pimpl; //forward declared structure  class A { pimpl *my_impl; //opaque pointer to implement pimpl } //file A.cpp #include strcut pimpl { B objB; C objC; vector vlist; } So this is how we implement pimpl : 1. forward declare some structure/class 2. Make a pointer of that strcutrure/class known as opaque pointer 3. Declare all the private members in the .cpp file inside the structure/class. Now the big question is that what should go inside the pimpl strcuture/class....?? Remember some basic points in mind while designing pimpl idiom. ---> Take all your non-virtual private members (variables + functions) ---> Never take protected members, because they were made protected at the first place so that the derived class can see them, if you hide them then whats the point of making them protected in the first place...?? ---> Make your pimpl structure/class exactly as your class A would have been and make your class A just as a plain easy to use public interface with forwarding functions. But finally the question arrives "was the pimpl implementation worth the pain..."?? the question will always depend on the programmer who is implementing it. For what class he is implemeting it.

How to reduce compile time dependencies The main culprit behind compile time dependencies is the huge amount of header files that are included by the compiler. Header files that are required in the code will obviously be added, but some programmers out of just habit include some useless header files as well. For eg : In this code few header file will not be reqired //Header files: #include #include #nclude #nclude #nclude claas A { B *obj; C *obj;  virtual std::ostream& print( std::ostream& ) const; } From the above code we can remove B.h and C.h straight away and use forward declaration instead of includeing those header files. Now what the hell is this FORWARD DECLARATION...?? Forward declaration is when we just declare and dont define. Suppose we are just using references or pointers to B or C, then we can get away with forward declaration and dont need to include the header files.   class B ; //Forward declaration only no need to include      class A {     private:       B* fPtrB ;     public:       void mymethod(const& B) const ;   } ; But if we derive from B or C or uses objects of B or C, then we need to include their header files. #include //Header file included   class A : public B{      } ;      class C {     private:       B objB ;     public:       void mymethod(B par) ;      } Also we can remove #include as well, dont be confused with the word stream, its not necessary that whenever you encounter the word stream you include . Here ostream is used and when can use #include only and it will suffice. So after clearing all the unwanted header files, heres what our code looks like : //Header files: #include #nclude claas A { B *obj; C *obj;  virtual std::ostream& print( std::ostream& ) const; } One more thing we can do here is that we can use instead of , what it will do is forward declare all the necessary things for ostream. Some of you might also be wondering that whats the difference between function prototype and forward declaration. In writing a function prototype you don't need to define parameter names, just their data type will suffice int add( int, int ); but in forward declaration you need to specify their name as well,tough both will fulfill you requirements. 1 more thing that might interest you guys is that, think what will happen when you only declare the function and don't define it and then call it.........??? int add(int a, int b) int main() { cout<<"Sum of 5 and 10 is "<

Like in this image you want to get to a specific point like you have to move from A --> B Then A will have some cordinates and it will be a vector, similarly B will be another vector So now we have co-ordinates,speed but we dont know the direction, for that  B - A = C Normalizing that vector C will give us the direction, which we can then use in our movement fformula. The point to remember is that if A has to move to point B, then B - A will be done, if B has to move to A, then A - B will be done. To make it even more useful and realistic you can include more variables like FRICTION ACCELERATION GRAVITY,etc. Try this thing by actually coding it up and get first hand experience. An explaination including actual code will follow soon.

Here's some technical details : 1.Used Visual C++ 2005 2.Game Engine : Haaf's Game Engine 3. irrKlang Sound library 4.Implemented State Design pattern for the architecture of the game. 5.Tilemaaping for placing different objects in the levels. 6.AI implemented through Finite State machine 7.Approximately more than 15000 lines of Code Note : 1366*768 resolution has been hard coded into it,if your monitors native resolution is not 1366*768, then please run the windowed version. JUMP is through "b". Hope you the enjoy the game and don't forget to give feedback

Pointers are generally the most feared part in a programming language. The only concept which many programmers doesnt seem to get. Well just get over the fact that pointers are somrthing terrifying build only to make prgrammers like us have horrifying nighmares....!! Heres the truth about pointers....!! POINTERS ARE NOTHING MORE THAN A VARIABLE...!! but the twist here is that they are a special kind of variables that stores special kind of info and that special info is the ADDRESS of another variable. See just like an int variable can store only int values and a float can store only float values, same is the case with the pointers. An int pointer stores the address of an integer variable only and not a float variable. So in 1 line a pointer is : SIMPLY A VRAIABLE THAT STORES ADDRESSES OF ANOTHER VARIABLE OF SAME DATA TYPE. DEFINING A POINTER defining a pointer is a little different than defining variables. int* x; /*we just declared an integer pointer which means that it vil only store addresses of integer variables.*/ dont be confused with the star (*)...u can also do lyk int *x or int * x...its all d same....!! Similarly to create a float or a char pointer just change the data type float* x; char* x; now store something in the pointer. REMEMBER : The variable that the pointer is pointing to is called a "POINTEE". int pointee; int* pointer; pointer = &pointee; //Now wat the hell is "&" for.. >:) this is known as "address of" operator it takes a variable and returns its address. for eg: &pointee will give you the address of pointee, remember that pointers only store addresses so if we want pointer to point to pointee we will give the address of pointee So pointer is pointing to pointee now so wat.....?? Now we can access pointee through a dereference operater(*)... int pointee = 10; int* pointer; like cout<<*pointer; vil give 10. Suppose address of pointee is 1000 and value is 10. So pointer vil store 1000 as its value and when *pointer is done, it will go to the address conatined by pointer which is 1000 as of now and vill access d value storesd at that address. So *pointer is now the same as pointee. doing *pointer = 20; or pointee = 20 //is the same thing Suppose there is another int pointer  int* another_pointer ; now we want this new pointer to point to the same location that pointer is pointing to. so we vil do lyk: another_pointer = pointer; //another pointer vil now also point to pointee; So now the final programme to illustrate the concepts: int main() { int pointee = 10; int *pointer1, *pointer2; //u cant do lyk int* pointer1,pointer2,here pointer2 vil be pointer1 = &pointee; //a simple int cout< cout<<*pointer1; //value of pointee i.e 10 pointer2 = pointer1; //pointer2 now points also points to pointee  *pointer2 = 20; //value of pointee chngd to 20 cout< cout< cout<<*pointer2; //value of pointee which is now 20 cout<<*pointer1; //value os pointee which is now 20 I hope this vil settle all the dust about baiscs of POINTERS and now we can start understandin the intricate details about pointers and their GOTCAHS....!! This is just a very breif intro to POINTERS and Theres still a lot to learn about pointers so keep writing code and experimenting....!!

What is a macro ? A macro is a piece of code that was labeled with a name. Whenever the preprocessor encounters it, the label is replaced by the associated code. Basically there are two kinds of macros : object-like macros (resemble data objects when used) and function-like macros (resemble function calls). Example for object-like macros: #include #define HELLO "Hello World Macro!" int main(){ printf(HELLO); return 0; } In the above example the label is HELLO and the associated data is “Hello World Macro!“ . Before compile-time the preprocessor will replace the label with the associated code. I think the results are pretty obvious. Example for function-like macros: #include #define MAX(a, b) ((a) > (b)) ? (a) : (b) int main(){ printf("%dn", MAX(1,3)); return 0; } In the case above MAX works exactly as a function that receives two arguments a, b and returns the maximum of the two . Note that the arguments are generic and appear to be typeless, the preprocessor is not performing any validation on types (that’s the compiler job) – this an advantage and also a disadvantage.

Continuing my post on INHERITANCE to INHERITANCE AND POLYMORPHISM Hope u guys hav read dat if not den plz read dat before reding dis....!! Inheritance is powerful but still u vil think dat v can do without it. Obviously yes .... v can, v have been doing without it coz v still use C language. But introucing d concept of POLYMORPHISM with inheritance takes d power to the next level. So remember INHERITANCE + POLYMORPHISM = VERY POWERFUL We introduce d concept of polymorphism by introducing VIRTUAL FUNCTIONS. So u should first understand d concept of Virtual functions. For eg: We create an ENEMY class and we have 20 different types of ENEMIES class enemy { public: void Attack(); } So dis becomes our base class for all enemies now if we have like 20 diff. enemies in our game and all of dem have different attacks. So without using Virtual functions we make 20 classes for diff enemies and all of dem inherit from base class enemy. den enemy obj = new badEnemy(); enemy obj1 = new BadAssEnemy(); enemy obj2 = new RealBadAssEnemy(); but when we call attack() of all three objects it will call d attack() of base class.....:( so bad na same kind of attack for every enemy makes ur game a dull game, UNTIL we make dat attack() function "VIRTUAL". Now each enemy class vil have different implementation for their attack() which vil actually make dem different. like badenemy attack() simply fires a pistol at you while BadAssEnemy's attack() fires a machine gun at you and RealBadAssEnemy's attack() fires rocket launcher at u..!! Hope ur following d point..it gives us d power to implement d function differently for every class.

INHERITANCE..... inheritance is a feature which allows us to easily create new class based on already created classes. By deriving from dem and adding more functionality. suppose we just finished creating our class for ENEMY which takes care of enemies animations, health and ai. we use dese enemies in d whole level and wen d ending of d level comes v hav to create a boss for d level. so instead of creating a new class boss we inherit d ENEMY class and add some more functionality because even the boss vil hv animations ,health and ai. So we dnt hv to write d code again for dese thngs. Inheritance is a very powerful tool but u shud use it wisely.... Rules wether to inherit or not. Rule 1. should be "Is a" relationship and not "Has a" relationship derived class should follow IS A model...like BOSS is an ENEMY so it can inherit enemy class. "has a" relationship should be followed when conatinment is to be applied. For eg: we have a class for weapons. So should weapon class inherit enemy class? NO..coz a weapon is not an enemy we can also hav a weapon. But an ENEMY has a WEAPON so it follows HAS A relationship. hence enemy class vil hav an object of WEAPON class inside it as its member. Rule 2. There should be beahvioral change and not only data change For eg: our boss class satisfies d 1st rule but suppose our boss is dumb and acts and looks xactly d same with only difference being its health. suppose normal enemy int health = 100; Boss health = 200; so dere is only chnge in data bt nt in d beahvior of boss so it fails d inheritance eligibility. But suppose our BOSS is very powerful and can also attack us from air where as normal enemy can only attack from land. Then there is also behavioral change.Then we should inherit d enemy class. while designing architectures inheritance shud be used carefully it can either simplify ur design or make ur nights sleepless. These are d 2 thumb rules that u shud always consider while deciding wether to inherit or not.

‎#include is a header file which enables us to pass multiple arguments to a function.You can pass multiple arguments by using "..." after d last variable. for eg: avg(int num,...); so this function avg(int num,...) vil take variable no of arguments and 1 integer arguments for num. it has 1 type : va_list to hold info abt variable arguments and 3 functions 1. va_start 2. va_arg 3. va_end va_start is used to start iterating by passing it 2 arguments : an object of type va_list and second parameter is d last named parameter of d function for eg: avg(int num,...) den va_list l; va_start(l,num); //dis initializes d list of variable arguments now to use individual arguments we use va_arg() it accepts va_list as first argument and type of d argument in the list. i.e va_arg(l,int); it returns d arguments in d same order in which dey were passed to the function...!! when we r done we use va_end to free d memory used by our list. In c it is mandatory to give 1 normal parameter but in c++ its nt mandatory....!!