CGAME

Are any games written in pure C? Even K&R mentions that C lends itself to graphics. Why are they all written in C++ if C is so much better?

Diablo was written in C

And why is C so much better? It all depends on the task

Quake.

pre-Doom 3 id games.
Looks like id turned to shit when they switched to C++.

>>1
OpenGL is C
DirectX is C

>>5
You really think the early Id Tech engines are GOOD?

I mean, Tremulous runs fine on modern computers, but damn, no one has been able to match the grandiosity and pomp of the Unreal 1 or 2 engine, though the engine used for Morrowind is incredibly close, and the refits they made to Source for Portal 2 make it bearable.

Games are better when they are written in Lisp

>>8
I agree.

C is shit when the program hits critical mass.
C++ is shit if you use the STL.

Diablo was written in C, and it never crashes.

>>9

c is only shit when it hits critical mass because polymorphism ends up getting implemented as a bunch of switch statements on a type flag, and the code for each type gets scattered throughout the entire project.

>>6
DirectX is C
U MENA SEPPLES

>>11
Would you happen to know any practical alternatives?

>>13

there isn't really. Just sayin, that's the hardest thing about maintaining a large c project that uses polymorphism. In the past, I've written implementations for each type:


void water_dragon_attack(animal_p self, animal_p target);
void snake_attack(animal_p self, animal_p target);
void falcon_attack(animal_p self, animal_p target);

and then I'll write a single generic function, that switches to one of the others:


void animal_attack(animal_p self, animal_p target) {
  switch(self->type) {
    case WATER_DRAGON: water_dragon_attack(self, target); break;
    case SNAKE: snake_attack(self, target); break;
    case FALCON: falcon_attack(self, target); break;
  }
}

So that way, code for the falcon can stay inside of falcon.c.
This switch statement style can do multiple dispatch too, by doing a nested switch off of target->type. The only issue as that the switch statements in the generic functions start to get really big.

>>14
I wrote my UI interface like that. Worked really nice, the switches got long after adding alot of widget types but it was easy to maintain

>>15
The you switched to Common Lisp and CLOS took away the pain?

>>15
cool, it's good to hear that it worked well for you. The last time I did it, I wasn't that competent of a programmer, and C was pretty much all I knew, so things got ugly fast.

Question, prog, if I made an extension of C that would recognize a few new keywords like 1337_define_type and 1337_define_method, and then compile C code using generic with multiple dispatch to code like >>14, using generated source files and name mangling, would you use it as a substitute to seeples? seeples has no multiple dispatch, and this wouldn't be that difficult to implement. It could probably even be a perl script.

>>16
I'm afraid i don't know CS or CLOS

would you like to provide an example?

>>18
(defgeneric animal-attack (self target))

(defmethod animal-attack ((self water-dragon) target) (...))
(defmethod animal-attack ((self snake) target) (...))
(defmethod animal-attack ((self falcon) target) (...))
(defmethod animal-attack ((self falcon) (target snake)) (...)) ; dispatch on both types

Also, subclassing.

>>18

When seeples calls a virtual function, it only takes into account what type the this object is. In CLOS (^{COMMON LISP OBJECT SYSTEM}) it can call a different function based upon what the types of the following arguments are. So multiple types can influence what function is called, at run time. Seeples has function overloading, which lets you have a function of a single name take arguments of varying types, but the distinction between the types must be made at compile time. It isn't as flexible as the previous thing I described, which people call dynamic dispatch.

>>19

oh yeah, I forgot about the sub classing.

>>19
so it's just a smarter function overloading?

>>19
I thought lisp was functional, i guess i'll be taking a look into this master race then afterall

>>22
No, it happens at runtime.

>>23

Its a very a multi-paradigm language, but it is loaded with parens and it assumes dynamic typing.

>>25
why do people hate lisp again?
sounds like the god of all languages.

>>26
Because it doesn't use the god-given Algol-like syntax.

>>26
They don't; they're all trolls. Lisp is truly the language with which the gods brought about the universe.

>>26
Nobody hates Lisp or Haskell in /prog/. Those who do, are either from /g/, reddit, or russia.

>>25
For parens you can get off your lazy ass and write a whatever-to-sexp preprocessor.

As for dynamic typing, it's definitely a plus. Static typing is the worst shit ever.

>>29
I fucking hate Haskell and I'm not from /g/, reddit nor Russia.

>>31
Your loss.

>>32
My dubz.

>>33
WE HAVE A WINNER!!!

Bumping this shit. Also Lisp is the only language.

>>34
I only agree to this because I've written a oddball-to-sexp preprocessor that makes Lisp readable.

http://yustas.com/jj/obama/20.jpg

>>36
You're really ugly.

>>37
Chechens are usually ugly.

>>37>>38
Your mum looks like http://yustas.com/jj/obama/20.jpg
cuz you're a jew.

᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈​᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈​᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈​᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈​᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈​᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈​᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈​᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈​᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈​᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈​᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈​᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈​᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈​᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈​᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈​᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈​᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈​᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈​᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈​᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈​᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈ ᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈᷈