smashthewindow

July 6, 2012

I see how this whole thread kinda sidetracked to dissing about Unity...

No offense and this is purely my opinion Josh but I think your saying too much about comparing or discussing other engines. (Other engine forums such as C4 moderates the discussion of other engines.)

Just release your product with what you think the client wants the most. If they like it, they will buy it.

After all, this is a development forum, not an investment discussion group.

July 6, 2012

However it "only" runs with 1200 FPS, while the one comming with the SDK (Engine.exe) runs at 1800 FPS on the same resolution.

This is a bit sidetracked, but WOW.

I get like 200 FPS ony my laptop on a fresh project.

July 5, 2012

My advice is 'just buy it' ... it's an excellent tool and well worth the money. I only ever use Brad's web site to download new versions, but I have to say I've never experienced any problems with it.

I think you're in the States if I'm not mistaken, so you'll have no problems purchasing it. Brad does operate a rather strange policy of not selling his software into lots of countries and checks prior to, or following, purchase. So you can find yourself unable to complete the purchase transaction or the money is just refunded with no warning or explanation if you're unfortunate to live in one of those countries!

Right now I'm in Japan for two weeks, and I'll be going to South Korea next week amd won't be back in the States till like August (when school break emds...).

I remember it didn't load properly in the U.S either, and I just tried to log on using a VPN but still fails.

July 5, 2012

If you have some money to spend i recommend buying UU3D(you won't regret it).

I want to buy it but their website is **** and doesn't load any pages properly.

July 2, 2012

Hey guys,

Recently I'm thinking of buying a new laptop since I travel a lot.

I'm thinking of buying a 15-inch Macbook Pro and using bootcamp on it,

but I don't know much about computer hardware.

What kind of system configuration would allow Leadwerks to run smoothly?

I've an Alienware M15X which I can do all the system intense graphics stuff - I'm only planning to write code & test on the new machine.

Thanks for reading.

June 30, 2012

I really like these kinds of story telling games.

Did you check out Dear Esther before? I think you would love it too.

June 28, 2012

Looks a lot different to my Content Factory but it looks fine to me. However, if you are loading from .sbx then I guess it makes it more difficult to register entities to the factory.. Unless you either make your own scene loader that parses the .sbx file (which is just a .txt file) and loads things as appropriate use databases..

ActorRegistration objects are created once globally at application initialization and it registers the appropriate constructor and the actor_type ID to the factory. I find this was a lot more easy to maintain than adding switch cases to call constructors. (I've actually got this idea from the book Game Engine Gems and Source Engine.)

June 28, 2012

It sounds like a bit of a dodgy work around to me. (sorry no offense)

I think it's better if you just have a content factory class to keep tabs on all of your entities and free them and create them as needed. That way all the entities themselves are in one place and the other appropriate classes have access to the content factory.

Yep, I've coded with templates for the fourth time now... Here's my factory .

class ActorRegistrationBase
{
public:
ActorRegistrationBase() { ActorFactory::getInstance()->registerBuilder(this); }
virtual ~ActorRegistrationBase() { ActorFactory::getInstance()->deregisterBuilder(this); }

virtual int getType() = 0;
virtual Actor* createActor( LE::TEntity entity_ ) = 0;
private:
};

class ActorFactory : public Singleton< ActorFactory >
{
public:
typedef std::map<int,ActorRegistrationBase*> Container;

void registerBuilder(ActorRegistrationBase* item_)
{
items.insert(std::pair<int,ActorRegistrationBase*>(item_->getType(),item_));
}

void deregisterBuilder(ActorRegistrationBase* item_)
{
Container::iterator iter_ = items.find(item_->getType());
items.erase( iter_ );
if(items.empty())
{
destroyInstance();
}
}

Actor* createActor( LE::TEntity entity_, int actor_key_ = 0 )
{
if( actor_key_ == 0 )
{
actor_key_ = ctoi( LE::GetEntityKey(entity_,"actor_key","0" ) );
}

Container::iterator iter_ = items.find( actor_key_ );
if( iter_ != items.end() )
{
return iter_->second->createActor( entity_ );
}
else
{
TRACE("ActorRegistrationBase for actor_key %i doesn't exists.", actor_key_ );
ASSERT(true);
}
}

private:
friend class Singleton<ActorFactory>;

ActorFactory(void);
~ActorFactory(void);

Container items;
};

template<typename T>
class ActorRegistration : public ActorRegistrationBase
{
public:
ActorRegistration( int actor_key_ ) : ActorRegistrationBase(),
key( actor_key_ )
{
}

virtual int getType()
{
return type;
}

virtual Actor* createActor( LE::TEntity entity_ )
{
Actor* actor_ = new T( entity_ );
MemoryMgr::getInstance()->addActor( actor_ );
return actor_;
}

private:
int key;
};

June 28, 2012

If you want to I think you could make a pivot and make it the parent to all entities you load. Then free the pivot and all other entities will be freed also, I think.

That's what I've tried with the pivot returned from the LE::LoadScene command but that also causes memory problems (specifically a 1-byte memory shift if located under a debugger). I'm thinking that the garbage collection mechanism doesn't go well with C++, and is just better to free them myself.

June 28, 2012

I was looking for somewhat a semi-automatic way to manage memory utilizing the garbage collector but your method would be better if the ResetFramework is buggy.

I hope there is better management in Le3D.

Thanks for the replies.

June 27, 2012

Yeah, blew up for me. I've never used ResetFramework() but seems like it may have a bug to it.

So you keep track of all your LE::TEntity instances?

June 27, 2012

Ohh. Sorry guys, I made a small mistake in a line.

In the main loop,

if( LE::KeyHit( LE::KEY_0 ) )
{
LE::FreeEntity( mesh );
//LE::ResetFramework();
}

that should be

if( LE::KeyHit( LE::KEY_0 ) )
{
//LE::FreeEntity( mesh );
LE::ResetFramework();
}

This throws an exception at LE::ResetFramework() when in debug mode.

Could anyone check this again?

This may seem trivial, but the crash tends to lead to more memory problems when I do stuff that are more complex in the game.

June 27, 2012

That is very weird... I'll have to investigate further.

Did you test on both debug and release?

June 27, 2012

In the attached file, there is a very simplified system of how I set up my entity system and abstraction.

As you see, if you build the project I've provided and press 0 during in game, the game crashes at ResetFramework() (Whether in debug or release).

Below is a small description of how I do things.

Actor is a class that modifies an entity in some way. Bombs, traps, characters etc inherits from this class.

CallbackRegistration class registers callbacks to the actors. For the base Actor class, FreeEntityCallbackRegistration is inherited as the Actor C++ object needs to be deleted when the entity is freed.

Download & change VC dir & compile, and tell me what you think.

I'm looking for some quick explanation on why the program crashes and some ways I could fix this.

Thank you for all those who are trying to help me.

EDIT: File attached. Forgot to press "Attach This File" button. (Why can't I attach 7z archive? Smaller size... )

June 27, 2012

Well... if you logged into leadwerks forum and you are using the profile you used to buy leadwerks (would be odd if you weren't) then you can find your keys under 'Client Area' in your profile drop down thingy...

Not if you bought it before last year then it doesn't show up.

June 25, 2012

I think STL::list is faster than a self-made simple list with pointers. I noticed that when I made one in Fortran, but I haven't speed tested yet how much speed difference there is in C++.

There's been a speed test between STL classes and Doom 3's implementation of the respective classes, STL's classes showed significantly faster speed.

I would suggest to use STL for primitive containers such as lists or vectors, which are probably the fastest implementation out there.

June 24, 2012

Very nice.

June 22, 2012

As long as this thing is just used internally within the engine I wouldn't mind (Do your magic Josh, you're the genius.).

But for the users I think it would be a lot better to use the STL, creating a new system would make it difficult for new users to adapt.

June 22, 2012

I wrote my own LinkedList class that is a lot simpler than messing around with STL iterators.

Why not just use STL?

Using STL interator isn't that hard, and I find that a lot more people will be familiar with it. (Not sure about that but I'm pretty sure I would be.)

April 29, 2012

I took a break from coding due to heavy workload on school life, but I finally got to work.

I went to finishing the renderer was like the first thing I done when I got back, so here it is.

I had to rely on a few OpenGL functions but it's not that heavy.

#ifndef GWEN_RENDERERS_LEADWERKS_H
#define GWEN_RENDERERS_LEADWERKS_H
#include <Gwen/Gwen.h>
#include <Gwen/BaseRender.h>
#include <engine.h>
#include <glGL.h>
#include <glGLU.h>
namespace Gwen
{
namespace Renderer
{
 class Leadwerks : public Gwen::Renderer::Base
 {
 public:
  Leadwerks();
  ~Leadwerks();
  virtual void Begin();
  virtual void End();
  virtual void SetDrawColor( Color color );
  virtual void DrawFilledRect( Gwen::Rect rect );
  virtual void LoadTexture( Gwen::Texture* pTexture );
  virtual void FreeTexture( Gwen::Texture* pTexture );
  virtual void DrawTexturedRect( Gwen::Texture* pTexture, Gwen::Rect pTargetRect, float u1=0.0f, float v1=0.0f, float u2=1.0f, float v2=1.0f );
  virtual void LoadFont( Gwen::Font* pFont );
  virtual void FreeFont( Gwen::Font* pFont );
  virtual void RenderText( Gwen::Font* pFont, Gwen::Point pos, const Gwen::UnicodeString& text );
  virtual Gwen::Point MeasureText( Gwen::Font* pFont, const Gwen::UnicodeString& text );
  virtual void DrawPixel( int x, int y );
  virtual void DrawLinedRect( Gwen::Rect rect );
  virtual Gwen::Point MeasureText( Gwen::Font* pFont, const Gwen::String& text );
  virtual void RenderText( Gwen::Font* pFont, Gwen::Point pos, const Gwen::String& text );
 private:
  enum CullMode
  {
CULL_NONE,
CULL_DRAW_CCW,
CULL_DRAW_CW
  };
  void leglBegin   (TCamera camera = NULL, float zoom = 1.0f, CullMode cm = CULL_DRAW_CCW);
  void leglEnd  (bool was3D = false);
  void leglBindTexture(TTexture texture);
 };
}
}
#endif

#include "Renderer.h"
#include <GwenUtility.h>
#include <GwenTexture.h>
#include <engine.h>
namespace Gwen
{
namespace Renderer
{
 Leadwerks::Leadwerks() {
 }
 Leadwerks::~Leadwerks() {
 }
 void Leadwerks::Begin() {
  LE::SetBlend(1);
 }
 void Leadwerks::End() {
  LE::SetBlend(0);
 }
 void Leadwerks::SetDrawColor( Color color ) {
  LE::TVec4 c;
  c.X = color.r/255;
  c.Y = color.g/255;
  c.Z = color.b/255;
  c.W = color.a/255;
  LE::SetColor( c );
 }
 void Leadwerks::DrawFilledRect( Gwen::Rect rect ) {
  Translate( rect );
  if( rect.w == 1 && rect.h == 1 )
  {
LE::Plot( rect.x, rect.y );
return;
  }
  if( rect.w == 1 ) {
LE::DrawLine( rect.x, rect.y, rect.x, rect.y + rect.h );
return;
  }
  if( rect.h == 1 ) {
LE::DrawLine( rect.x, rect.y, rect.x + rect.w, rect.y );
return;
  }
  LE::DrawRect( rect.x, rect.y, rect.w, rect.h );
 }
 void Leadwerks::LoadTexture( Gwen::Texture* pTexture ) {
  BP tex = LE::LoadTexture( pTexture->name.Get().c_str() );
  pTexture->data = tex;
  pTexture->failed = (tex == nullptr);
  if( tex != nullptr )
  {
pTexture->width = LE::TextureWidth( tex );
pTexture->height = LE::TextureHeight( tex );
  }
 }
 void Leadwerks::FreeTexture( Gwen::Texture* pTexture ) {
  LE::FreeTexture( (BP)pTexture->data );
 }
 void Leadwerks::DrawTexturedRect( Gwen::Texture* pTexture, Gwen::Rect pTargetRect, float u1, float v1, float u2, float v2 ) {
  Translate( pTargetRect );
  leglBegin();
  leglBindTexture( (BP)pTexture->data );
  glBegin( GL_QUADS );
  glTexCoord2f(u2, v2); glVertex2i(pTargetRect.x + pTargetRect.w, pTargetRect.y + pTargetRect.h);
  glTexCoord2f(u2, v1); glVertex2i(pTargetRect.x + pTargetRect.w, pTargetRect.y);
  glTexCoord2f(u1, v1); glVertex2i(pTargetRect.x, pTargetRect.y );
  glTexCoord2f(u1, v2); glVertex2i(pTargetRect.x, pTargetRect.y + pTargetRect.h );
  glEnd();

  leglBindTexture(NULL);
  leglEnd();
 }
 void Leadwerks::LoadFont( Gwen::Font* pFont ) {
  if(  Gwen::Utility::UnicodeToString(pFont->facename) != "Default" )
  {
TFont font = LE::LoadFont( Gwen::Utility::UnicodeToString(pFont->facename).c_str() );
LE::SetFont(font);
pFont->data = font;
  }
  pFont->size = LE::FontHeight();
 }
 void Leadwerks::FreeFont( Gwen::Font* pFont ) {
  if( pFont->data ) LE::FreeFont( (BP)pFont->data );
 }
 void Leadwerks::RenderText( Gwen::Font* pFont, Gwen::Point pos, const Gwen::UnicodeString& text ) {
  RenderText( pFont, pos, Gwen::Utility::UnicodeToString(text) );
 }
 Gwen::Point Leadwerks::MeasureText( Gwen::Font* pFont, const Gwen::UnicodeString& text ) {
  return MeasureText( pFont, Gwen::Utility::UnicodeToString(text) );
 }
 void Leadwerks::DrawLinedRect( Gwen::Rect rect )
 {
  Translate( rect );
  LE::DrawLine( rect.x + 1, rect.y, rect.x + rect.w - 1, rect.y );
  LE::DrawLine( rect.x + rect.w, rect.y, rect.x + rect.w, rect.y + rect.h );
  LE::DrawLine( rect.x + rect.w - 1, rect.y + rect.h, rect.x + 1, rect.y + rect.h );
  LE::DrawLine( rect.x, rect.y + rect.h, rect.x, rect.y );
 }
 void Leadwerks::DrawPixel( int x, int y ) {
  Translate( x, y );
  LE::Plot( x, y );
 }
 Gwen::Point Leadwerks::MeasureText( Gwen::Font* pFont, const Gwen::String& text ) {
  if( pFont->data ) LoadFont( pFont );
  return Gwen::Point( LE::TextWidth( text.c_str()), LE::FontHeight() );
 }
 void Leadwerks::RenderText( Gwen::Font* pFont, Gwen::Point pos, const Gwen::String& text ) {
  Translate( pos.x, pos.y );
  if( pFont->data ) LoadFont( pFont );
  LE::DrawTextA( pos.x, pos.y, text.c_str() );
 }
 void Leadwerks::leglBegin(TCamera camera, float zoom, CullMode cm)
 {
  // Setup projetion according to argument
  if (NULL != camera)
  {
// Save current projection matrix. Then reset
glMatrixMode(GL_PROJECTION); glPushMatrix();
glLoadIdentity();
// Calculate the view frustum
float nearRange, farRange; GetCameraRange(camera, nearRange, farRange);
float theta = 1.0f / zoom; // tan(45°) = 1.0f
float aspect = float(BufferWidth(CurrentBuffer()))/BufferHeight(CurrentBuffer());
glFrustum (-nearRange*theta, nearRange*theta, -nearRange/aspect*theta, nearRange/aspect*theta, nearRange,farRange);
// Reset transformation
glMatrixMode(GL_MODELVIEW); glPushMatrix();
glLoadIdentity();
// LE uses a differently handed coordinate system than ogl does
glScalef(1.0f, 1.0f, -1.0f);
// Calculate the LookAt vectors (camera direction and up vector)...
TVec3 from = EntityPosition(camera, true);
TVec3 to = {0,0,-1}; to = TFormVector(to, camera, NULL); to += from;
TVec3 up = {0,1,0}; up = TFormVector(up, camera, NULL);
// Set LookAt
gluLookAt(from.X, from.Y, from.Z, to.X, to.Y , to.Z, up.X, up.Y, up.Z);
  }
  else
  {
glPushMatrix();
// Set orthographic projection (used for 2D drawing)
// Get the current viewport/buffer size.
int vPort[4]; glGetIntegerv(GL_VIEWPORT, vPort);
// Set the projection
gluOrtho2D(0, vPort[2], vPort[3], 0); // like glOrtho(0, vPort[2], vPort[3], 0, -1, 1);
// Reset transformation
glMatrixMode(GL_MODELVIEW); glPushMatrix();
glLoadIdentity();
  }
  // Setup default drawing settings.
  // Alpha blending.
  glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  // Backface culling.
  if (CULL_NONE != cm)glEnable(GL_CULL_FACE);
  if (NULL != camera)glCullFace((CULL_DRAW_CCW == cm) ? GL_BACK : GL_FRONT);
  else glCullFace((CULL_DRAW_CCW == cm) ? GL_FRONT : GL_BACK);
  // Depth test for 3D projection
  if (NULL != camera)glEnable(GL_DEPTH_TEST);
  // Drawing color.
  glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
 }

 // Use NULL (0) for the texture to reset (bind no texture)
 void Leadwerks::leglBindTexture(TTexture texture)
 {
  if(NULL != texture)
  {
glEnable(GL_TEXTURE_2D);
BindTexture(texture, 0); // LE command.
  }
  else
  {
glBindTexture(GL_TEXTURE_2D, NULL);
glDisable(GL_TEXTURE_2D);
  }
 }
 // End drawing. Set "was3D" to true if you specified a camera at leglBegin (= used 3D projection).
 void Leadwerks::leglEnd(bool was3D)
 {
  // Undo changes only made in 3D mode (camera != NULL)
  if (was3D)
  {
glMatrixMode(GL_PROJECTION); glPopMatrix();
glDisable(GL_DEPTH_TEST);
  }
  else
glPopMatrix();
  // Reset transformation.
  glMatrixMode(GL_MODELVIEW); glPopMatrix();
  // Undo changed settings.
  glDisable(GL_BLEND);
  glCullFace(GL_BACK); glDisable(GL_CULL_FACE);
  glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
  leglBindTexture(NULL);
 }
}
}

/*
GWEN
Copyright (c) 2011 Facepunch Studios
See license in Gwen.h
*/
#ifndef GWEN_INPUT_LEADWERKS_H
#define GWEN_INPUT_LEADWERKS_H
#include "Gwen/InputHandler.h"
#include "Gwen/Gwen.h"
#include "Gwen/Controls/Canvas.h"
#include <engine.h>
namespace Gwen
{
namespace Input
{
 class Leadwerks
 {
  public:
Leadwerks()
{
 m_Canvas = NULL;
 m_MouseX = 0;
 m_MouseY = 0;
 m_MouseZ = 0;
 m_LMouseDown = false;
 m_RMouseDown = false;
 m_MMouseDown = false;
}
void Initialize( Gwen::Controls::Canvas* c )
{
 m_Canvas = c;
}
bool ProcessMessage( void )
{
 if ( !m_Canvas ) return false;
 if( m_MouseX != LE::MouseX() ||
  m_MouseY != LE::MouseY() )
 {
  int dx = LE::MouseX() - m_MouseX;
  int dy = LE::MouseY() - m_MouseY;
  m_MouseX = LE::MouseX();
  m_MouseY = LE::MouseY();
  return m_Canvas->InputMouseMoved( LE::MouseX(), LE::MouseY(), dx, dy );
 }
 //TODO:: Charatcer input
 if( m_MouseZ != LE::MouseZ() )
 {
  int dz = LE::MouseZ() - m_MouseZ;
  return m_Canvas->InputMouseWheel( dz );
 }
 if( m_LMouseDown != LE::MouseDown( LE::MOUSE_LEFT ) )
 {
  m_LMouseDown = LE::MouseDown( LE::MOUSE_LEFT );
  return m_Canvas->InputMouseButton( 0, m_LMouseDown );
 }
 if( m_RMouseDown != LE::MouseDown( LE::MOUSE_RIGHT ) )
 {
  m_RMouseDown = LE::MouseDown( LE::MOUSE_RIGHT );
  return m_Canvas->InputMouseButton( 1, m_RMouseDown );
 }
 if( m_MMouseDown != LE::MouseDown( LE::MOUSE_MIDDLE ) )
 {
  m_MMouseDown = LE::MouseDown( LE::MOUSE_MIDDLE );
  return m_Canvas->InputMouseButton( 2, m_MMouseDown );
 }
 //KEY INPUT
 if( LE::KeyHit( LE::KEY_RSHIFT ) ||
  LE::KeyHit( LE::KEY_LSHIFT ) )
 {
  bool down = LE::KeyDown( LE::KEY_RSHIFT ) || LE::KeyDown( LE::KEY_LSHIFT );
  return m_Canvas->InputKey( Gwen::Key::Shift, down );
 }
 if( LE::KeyHit( LE::KEY_ENTER ) )
 {
  bool down = LE::KeyDown( LE::KEY_ENTER );
  return m_Canvas->InputKey( Gwen::Key::Return, down );
 }
 if( LE::KeyHit( LE::KEY_BACKSPACE ) )
 {
  bool down = LE::KeyDown( LE::KEY_BACKSPACE );
  return m_Canvas->InputKey( Gwen::Key::Backspace, down );
 }
 if( LE::KeyHit( LE::KEY_DELETE ) )
 {
  bool down = LE::KeyDown( LE::KEY_DELETE );
  return m_Canvas->InputKey( Gwen::Key::Delete, down );
 }
 if( LE::KeyHit( LE::KEY_LEFT ) )
 {
  bool down = LE::KeyDown( LE::KEY_LEFT );
  return m_Canvas->InputKey( Gwen::Key::Left, down );
 }
 if( LE::KeyHit( LE::KEY_RIGHT ) )
 {
  bool down = LE::KeyDown( LE::KEY_RIGHT );
  return m_Canvas->InputKey( Gwen::Key::Right, down );
 }
 if( LE::KeyHit( LE::KEY_TAB ) )
 {
  bool down = LE::KeyDown( LE::KEY_TAB );
  return m_Canvas->InputKey( Gwen::Key::Tab, down );
 }
 if( LE::KeyHit( LE::KEY_SPACE ) )
 {
  bool down = LE::KeyDown( LE::KEY_SPACE );
  return m_Canvas->InputKey( Gwen::Key::Space, down );
 }
 if( LE::KeyHit( LE::KEY_HOME ) )
 {
  bool down = LE::KeyDown( LE::KEY_HOME );
  return m_Canvas->InputKey( Gwen::Key::Home, down );
 }
 if( LE::KeyHit( LE::KEY_END ) )
 {
  bool down = LE::KeyDown( LE::KEY_END );
  return m_Canvas->InputKey( Gwen::Key::End, down );
 }
 if( LE::KeyHit( LE::KEY_RCONTROL ) ||
  LE::KeyHit( LE::KEY_LCONTROL ) )
 {
  bool down = LE::KeyDown( LE::KEY_RCONTROL ) ||
   LE::KeyDown( LE::KEY_LCONTROL );
  return m_Canvas->InputKey( Gwen::Key::Control, down );
 }
 if( LE::KeyHit( LE::KEY_UP ) )
 {
  bool down = LE::KeyDown( LE::KEY_UP );
  return m_Canvas->InputKey( Gwen::Key::Up, down );
 }
 if( LE::KeyHit( LE::KEY_DOWN ) )
 {
  bool down = LE::KeyDown( LE::KEY_DOWN );
  return m_Canvas->InputKey( Gwen::Key::Down, down );
 }
 return false;
}
protected:
 Gwen::Controls::Canvas* m_Canvas;
 int m_MouseX;
 int m_MouseY;
 int m_MouseZ;
 bool m_LMouseDown;
 bool m_RMouseDown;
 bool m_MMouseDown;
 };
}
}
#endif

Big thanks to Masterxilo who wrote the OpenGL tutorial over here.

April 25, 2012

Some of my friends were using it for quite some time, but I really never got interested in it.

I downloaded the app after I found out Facebook bought the company, and the filters are just amazing!

Quick and easy way to make cool photos. Here are my first few shots around my dorm:

What other cool photo editing apps are out there?

April 16, 2012

If you know what you're doing, sure go ahead, use inline ASM. (It would probably make it unreadable to other programmers though.)

I have a bit of reverse-engineering background, so I use IDA/OllyDbg frequently to investigate calls & gain understanding of what's happening. (But I never use inline ASM to actually code stuff.)

April 15, 2012

If you main game is going to be in C++, I would suggest that you program every major part of the game (characters, events etc) in C++.

Lua should be used to program smaller, additional behaviours (opening doors, etc).

March 29, 2012

Thanks for all your replies!

March 29, 2012

What are those? They look pretty finished to me.

Sign In

Blogs

Forums

Store

Gallery

Videos

Posts posted by smashthewindow