Changeset 323 for trunk/src

Timestamp:

08/26/14 04:03:10 (11 years ago)

Author:

epyon

Message:

• nova now compiles again under all three compilers with -Winsane and no warnings

Location:

trunk/src

Files:

• curses/curses_terminal.cc (modified) (1 diff)
• engine/particle_engine.cc (modified) (3 diffs)
• engine/program_manager.cc (modified) (1 diff)
• engine/resource_system.cc (modified) (1 diff)
• formats/assimp_loader.cc (modified) (7 diffs)
• formats/md3_loader.cc (modified) (8 diffs)
• formats/md5_loader.cc (modified) (5 diffs)
• formats/nmd_loader.cc (modified) (1 diff)
• gfx/image.cc (modified) (1 diff)
• gfx/mesh_creator.cc (modified) (7 diffs)
• gfx/skeletal_mesh.cc (modified) (2 diffs)
• gl/gl_device.cc (modified) (1 diff)
• gl/gl_enum.cc (modified) (1 diff)
• gl/gl_window.cc (modified) (2 diffs)
• lib/gl.cc (modified) (5 diffs)
• lua/lua_map_tile.cc (modified) (4 diffs)
• lua/lua_nova.cc (modified) (5 diffs)

trunk/src/curses/curses_terminal.cc

@@ -58 +58 @@
         if ( color > 7 )
         {
-                attrset((static_cast<uint32>(color-7) << 24)  & 0xff000000ul | 0x00800000ul);
+                attrset((static_cast<uint32>(color-7) << 24)  & ( 0xff000000ul | 0x00800000ul ) );
         }
         else

trunk/src/engine/particle_engine.cc

@@ -577 +577 @@
         case particle_origin::CENTER        : break;
         case particle_origin::TOP_LEFT      : lb = vec2(0.f,-1.f); rt = vec2(1.f,0.f);  break;
-        case particle_origin::TOP_CENTER    : lb.y = -1.f; rt.y = 0.f; break;  break;
+        case particle_origin::TOP_CENTER    : lb.y = -1.f; rt.y = 0.f; break;
         case particle_origin::TOP_RIGHT     : lb = vec2(-1.f,-1.f); rt = vec2(); break;
         case particle_origin::CENTER_LEFT   : lb.x = 0.f; rt.x = 1.f; break;
@@ -663 +663 @@
 {
         if ( info->count > 0 )
-                for ( sint32 i = info->count-1; i >= 0; --i )
+                for ( sint32 i = (sint32)info->count-1; i >= 0; --i )
                 {
                         particle& pinfo = info->particles[i];
@@ -723 +723 @@
                                         {
                                                 float emission_angle = glm::radians( edata.angle );
-                                                float cos_theta = r.frange( cos( emission_angle ), 1.0f );
+                                                float cos_theta = r.frange( glm::cos( emission_angle ), 1.0f );
                                                 float sin_theta = glm::sqrt(1.0f - cos_theta * cos_theta );
                                                 float phi       = r.frange( 0.0f, 2*glm::pi<float>() );

trunk/src/engine/program_manager.cc

@@ -57 +57 @@
                 for ( uint32 i = 1; i <= count; ++i )
                 {
-                        std::string include( inctable.get<std::string,int>(i) );
+                        std::string include( inctable.get<std::string,uint32>(i) );
                         if ( i == count ) out += "#line 1\n";
                         out += nv::slurp( include );

trunk/src/engine/resource_system.cc

@@ -29 +29 @@
         clear();
         lua::table_guard table( m_lua, get_storage_name() );
-        uint32 count = table.get_integer( "__counter" );
+        uint32 count = table.get_unsigned( "__counter" );
         for ( auto i : range( count ) )
         {

trunk/src/formats/assimp_loader.cc

@@ -14 +14 @@
 using namespace nv;
 
-const int MAX_BONES = 64;
+const unsigned MAX_BONES = 64;
 
 struct assimp_plain_vtx 
@@ -90 +90 @@
         m_mesh_count = 0;
         NV_LOG( nv::LOG_NOTICE, "AssImp loading file..." );
-        int size = (int)source.size();
+        size_t size = source.size();
         char* data  = new char[ size ];
         source.read( data, size, 1 );
@@ -159 +159 @@
                                         if ( v.boneweight[i] <= 0.0f ) 
                                         {
-                                                v.boneindex[i] = m;
+                                                v.boneindex[i]  = (int)m;
                                                 v.boneweight[i] = bone->mWeights[w].mWeight;
                                                 found = true;
@@ -289 +289 @@
         for ( unsigned int m = 0; m < m_mesh_count; ++m )
         {
-                sint16 translate[MAX_BONES];
+                uint16 translate[MAX_BONES];
                 std::vector< mesh_node_data > bones;
                 const aiMesh*  mesh  = scene->mMeshes[ m ];
@@ -304 +304 @@
                                 {
                                         NV_ASSERT( final_bones.size() < MAX_BONES, "Too many bones to merge!" );
-                                        sint16 index = (sint16)final_bones.size();
+                                        uint16 index = (uint16)final_bones.size();
                                         final_bones.push_back( bone );
                                         names[ bone.name ] = index;
@@ -311 +311 @@
                                 else
                                 {
-                                        translate[b] = (sint16)iname->second;
+                                        translate[b] = iname->second;
                                 }
                         }
@@ -326 +326 @@
                                                 if ( vertex.boneweight[i] > 0.0f ) 
                                                 {
-                                                        vertex.boneindex[i] = translate[vertex.boneindex[i]];
+                                                        vertex.boneindex[i] = (int)translate[vertex.boneindex[i]];
                                                 }
                                         }

trunk/src/formats/md3_loader.cc

@@ -234 +234 @@
 
 md3_loader::md3_loader( bool merge_all )
-        : m_md3( nullptr ), m_merge_all( merge_all )
+        : m_merge_all( merge_all ), m_md3( nullptr )
 {
         if ( !s_normal_ready )
@@ -286 +286 @@
 {
         md3_t* md3 = (md3_t*)m_md3;
-        key_raw_channel* result = key_raw_channel::create<md3_key>( md3->header.num_frames );
+        key_raw_channel* result = key_raw_channel::create<md3_key>( (uint32)md3->header.num_frames );
         // TODO: is this brain damaged in efficiency (loop nest order) or what?
         for ( sint32 f = 0; f < md3->header.num_frames; ++f )
@@ -322 +322 @@
 {
         mesh_data* data = new mesh_data;
-        release_mesh_frame( data, -1, index );
+        release_mesh_frame( data, -1, (sint32)index );
         return data;
 }
@@ -329 +329 @@
 {
         md3_t* md3 = (md3_t*)m_md3;
-        sint32 num_surfaces  = md3->header.num_surfaces;
-        sint32 num_verts     = 0;
-        sint32 current_frame = ( frame == -1 ? 0 : frame );
-        sint32 frame_count   = ( frame == -1 ? md3->header.num_frames : 1 );
-        sint32 current_surf  = ( surface == -1 ? 0 : surface );
-        sint32 surf_count    = ( surface == -1 ? md3->header.num_surfaces : 1 );
-        sint32 index_count   = 0;
+        uint32 num_surfaces  = (uint32)md3->header.num_surfaces;
+        uint32 num_verts     = 0;
+        uint32 current_frame = ( frame == -1 ? 0 : (uint32)frame );
+        uint32 frame_count   = ( frame == -1 ? (uint32)md3->header.num_frames : 1 );
+        uint32 current_surf  = ( surface == -1 ? 0 : (uint32)surface );
+        uint32 surf_count    = ( surface == -1 ? (uint32)md3->header.num_surfaces : 1 );
+        uint32 index_count   = 0;
 
         if ( surface >= 0 )
         {
-                index_count = md3->surfaces[surface].header.num_triangles * 3;
-                num_verts   = md3->surfaces[surface].header.num_verts;
+                index_count = (uint32)md3->surfaces[(uint32)surface].header.num_triangles * 3;
+                num_verts   = (uint32)md3->surfaces[(uint32)surface].header.num_verts;
         }
         else
-                for ( sint32 i = 0; i < num_surfaces; ++i )
-                {
-                        index_count += md3->surfaces[i].header.num_triangles * 3;
-                        num_verts   += md3->surfaces[i].header.num_verts;
+                for ( uint32 i = 0; i < num_surfaces; ++i )
+                {
+                        index_count += (uint32)md3->surfaces[i].header.num_triangles * 3;
+                        num_verts   += (uint32)md3->surfaces[i].header.num_verts;
                 }
 
@@ -362 +362 @@
         while ( surf_count > 0 )
         {
-                const md3_surface_t& surface = md3->surfaces[ current_surf ];
-                const uint32         vcount  = static_cast< uint32 >( surface.header.num_verts );
-                const uint32         tcount  = static_cast< uint32 >( surface.header.num_triangles );
+                const md3_surface_t& sface  = md3->surfaces[ current_surf ];
+                const uint32         vcount = static_cast< uint32 >( sface.header.num_verts );
+                const uint32         tcount = static_cast< uint32 >( sface.header.num_triangles );
 
                 for (uint32 j = 0; j < vcount; ++j )
                 {
-                        vtx_t[index++].texcoord = md3_texcoord( surface.st[j] );
+                        vtx_t[index++].texcoord = md3_texcoord( sface.st[j] );
                 }
 
                 for (size_t j = 0; j < tcount; ++j )
                 {
-                        const md3_triangle_t& t = surface.triangles[j];
+                        const md3_triangle_t& t = sface.triangles[j];
                         icp[iindex++] = static_cast< uint16 >( index_base + t.indexes[0] );
                         icp[iindex++] = static_cast< uint16 >( index_base + t.indexes[1] );
                         icp[iindex++] = static_cast< uint16 >( index_base + t.indexes[2] );
                 }
-                index_base += surface.header.num_verts;
+                index_base += sface.header.num_verts;
                 ++current_surf;
                 --surf_count;
@@ -386 +386 @@
         while ( frame_count > 0 )
         {
-                current_surf  = ( surface == -1 ? 0 : surface );
-                surf_count    = ( surface == -1 ? md3->header.num_surfaces : 1 );
+                current_surf  = ( surface == -1 ? 0 : (uint32)surface );
+                surf_count    = ( surface == -1 ? (uint32)md3->header.num_surfaces : 1 );
 
                 while ( surf_count > 0 )
                 {
-                        md3_surface_t& surface = md3->surfaces[current_surf];
-                        sint32         vcount  = surface.header.num_verts;
-                        sint32         offset  = vcount * current_frame;
-                        sint32         limit   = vcount + offset;
-                        for (sint32 j = offset; j < limit; ++j )
+                        md3_surface_t& sface  = md3->surfaces[current_surf];
+                        uint32         vcount = (uint32)sface.header.num_verts;
+                        uint32         offset = vcount * current_frame;
+                        uint32         limit  = vcount + offset;
+                        for (uint32 j = offset; j < limit; ++j )
                         {
-                                md3_vertex_t& v = surface.vertices[j];
+                                md3_vertex_t& v = sface.vertices[j];
                                 vtx_pn[index].position = vec3( v.x * MD3_XYZ_SCALE, v.z * MD3_XYZ_SCALE, v.y * MD3_XYZ_SCALE );
                                 vtx_pn[index].normal   = s_normal_cache[ v.normal ];
@@ -418 +418 @@
 {
         md3_t* md3 = (md3_t*)m_md3;
-        uint32 node_count = md3->header.num_tags;
+        uint32 node_count = (uint32)md3->header.num_tags;
         if ( node_count == 0 ) return nullptr;;
         mesh_node_data* nodes = new mesh_node_data[ node_count ];
@@ -451 +451 @@
         else
         {
-                count = md3->header.num_surfaces;
+                count = (uint32)md3->header.num_surfaces;
                 data = new mesh_data[ count ];
                 for ( uint32 i = 0; i < count; ++i )
                 {
-                        release_mesh_frame( &data[i], -1, i );
+                        release_mesh_frame( &data[i], -1, (sint32)i );
                         data[i].set_name( (char*)md3->surfaces[i].header.name );
                 }

trunk/src/formats/md5_loader.cc

@@ -135 +135 @@
                         mesh_data* mesh = new mesh_data("md5_mesh");
 
-                        int num_verts   = 0;
-                        int num_tris    = 0;
-                        int num_weights = 0;
+                        uint32 num_verts   = 0;
+                        uint32 num_tris    = 0;
+                        uint32 num_weights = 0;
 
                         discard( sstream, "{" );
@@ -170 +170 @@
                                         next_line( sstream );
                                         std::string line;
-                                        for ( int i = 0; i < num_verts; ++i )
+                                        for ( uint32 i = 0; i < num_verts; ++i )
                                         {
                                                 size_t weight_count;
@@ -194 +194 @@
                                         next_line( sstream );
                                         std::string line;
-                                        for ( int i = 0; i < num_tris; ++i )
+                                        for ( uint32 i = 0; i < num_tris; ++i )
                                         {
                                                 size_t ti0;
@@ -214 +214 @@
                                         next_line( sstream );
                                         std::string line;
-                                        for ( int i = 0; i < num_weights; ++i )
+                                        for ( uint32 i = 0; i < num_weights; ++i )
                                         {
                                                 md5_weight weight;
@@ -368 +368 @@
                         if ( j < weight_count )
                         {
-                                vdata.boneindex[j]  = weights[start_weight + j].joint_id;
+                                vdata.boneindex[j]  = (int)weights[start_weight + j].joint_id;
                                 vdata.boneweight[j] = weights[start_weight + j].bias;
                         }

trunk/src/formats/nmd_loader.cc

@@ -242 +242 @@
 
                 nmd_node_header nheader;
-                nheader.parent_id = (uint16)node->parent_id;
+                nheader.parent_id = node->parent_id;
                 nheader.transform = node->transform;
                 stream_out.write( &nheader, sizeof( nheader ), 1 );

trunk/src/gfx/image.cc

@@ -89 +89 @@
         fill( r, 255 );
 
-        sint32 bpos       = (r.pos.y*m_size.x + r.pos.x ) * static_cast<sint32>( m_depth );
-        sint32 bline      = m_size.x*static_cast<sint32>( m_depth );
+        uint32 bpos       = static_cast< uint32 >( r.pos.y*m_size.x + r.pos.x ) * m_depth;
+        uint32 bline      = static_cast< uint32 >( m_size.x ) * m_depth;
 
+        uint32 rsizex     = static_cast< uint32 >( r.size.x );
+        uint32 rsizey     = static_cast< uint32 >( r.size.y );
         const uint8* data = idata->get_data();
-        sint32 depth      = idata->get_depth();
-        sint32 dstride    = r.size.x * static_cast<sint32>( depth );
+        size_t depth      = idata->get_depth();
+        uint32 dstride    = rsizex * depth;
 
-        for( int y = 0; y < r.size.y; ++y )
+        for( uint32 y = 0; y < rsizey; ++y )
         {
-                sint32 pos = bpos + bline * y;
-                for( int x = 0; x < r.size.x; ++x )
+                uint32 pos = bpos + bline * y;
+                for( uint32 x = 0; x < rsizex; ++x )
                 {
-                        sint32 xy = pos + x * m_depth;
-                        for( int e = 0; e < depth; ++e )
+                        uint32 xy = pos + x * m_depth;
+                        for( size_t e = 0; e < depth; ++e )
                         {
                                 m_data[ xy + e ] = data[ y*dstride + x * depth + e ];

trunk/src/gfx/mesh_creator.cc

@@ -128 +128 @@
                 const vertex_descriptor& desc   = channel->desc;
                 uint8* raw_data = channel->data;
-                int vtx_size = desc.size;
+                uint32 vtx_size = desc.size;
                 int p_offset = -1;
                 int n_offset = -1;
@@ -135 +135 @@
                         switch ( desc.slots[i].vslot )
                         {
-                                case slot::POSITION : if ( desc.slots[i].etype == FLOAT_VECTOR_3 ) p_offset = desc.slots[i].offset; break;
-                                case slot::NORMAL   : if ( desc.slots[i].etype == FLOAT_VECTOR_3 ) n_offset = desc.slots[i].offset; break;
-                                case slot::TANGENT  : if ( desc.slots[i].etype == FLOAT_VECTOR_4 ) t_offset = desc.slots[i].offset; break;
+                                case slot::POSITION : if ( desc.slots[i].etype == FLOAT_VECTOR_3 ) p_offset = (int)desc.slots[i].offset; break;
+                                case slot::NORMAL   : if ( desc.slots[i].etype == FLOAT_VECTOR_3 ) n_offset = (int)desc.slots[i].offset; break;
+                                case slot::TANGENT  : if ( desc.slots[i].etype == FLOAT_VECTOR_4 ) t_offset = (int)desc.slots[i].offset; break;
                                 default             : break;
                         }
@@ -173 +173 @@
         size_t n_offset = 0;
         if ( ch_n == -1 ) return;
-        mesh_raw_channel* channel = m_data->m_channels[ch_n];
+        mesh_raw_channel* channel = m_data->m_channels[ (unsigned) ch_n ];
         for ( uint32 i = 0; i < channel->desc.count; ++i )
                 if ( channel->desc.slots[i].vslot == slot::NORMAL )
@@ -211 +211 @@
                                 if ( desc.slots[i].etype == FLOAT_VECTOR_3 ) 
                                 {
-                                        p_offset  = desc.slots[i].offset; 
+                                        p_offset  = (int)desc.slots[i].offset; 
                                         p_channel = channel;
                                 }
@@ -217 +217 @@
                         case slot::NORMAL   : if ( desc.slots[i].etype == FLOAT_VECTOR_3 ) 
                                 {
-                                        n_offset  = desc.slots[i].offset; 
+                                        n_offset  = (int)desc.slots[i].offset; 
                                         n_channel = m_data->m_channels[ c ];
                                         n_channel_index = c;
@@ -224 +224 @@
                         case slot::TEXCOORD : if ( desc.slots[i].etype == FLOAT_VECTOR_2 ) 
                                 {
-                                        t_offset  = desc.slots[i].offset; 
+                                        t_offset  = (int)desc.slots[i].offset; 
                                         t_channel = channel;
                                 }
@@ -420 +420 @@
         int och_ti = other->get_channel_index( slot::TEXCOORD );
         if ( ch_pi == -1 || ch_ti == -1 ) return;
-        size_t size   = m_data->m_channels[ ch_ti ]->count;
-        size_t osize  =  other->m_channels[ och_ti ]->count;
-        size_t count  = m_data->m_channels[ ch_pi ]->count;
-        size_t ocount =  other->m_channels[ och_pi ]->count;
+        size_t size   = m_data->m_channels[ (unsigned)ch_ti ]->count;
+        size_t osize  =  other->m_channels[ (unsigned)och_ti ]->count;
+        size_t count  = m_data->m_channels[ (unsigned)ch_pi ]->count;
+        size_t ocount =  other->m_channels[ (unsigned)och_pi ]->count;
         if ( count % size != 0 || ocount % osize != 0 ) return;
         if ( count / size != ocount / osize ) return;

trunk/src/gfx/skeletal_mesh.cc

@@ -53 +53 @@
                                 for ( size_t j = 0; j < 4; ++j )
                                 {
-                                        int   index  = vert.boneindex[j];
-                                        float weight = vert.boneweight[j];
+                                        unsigned index = (unsigned)vert.boneindex[j];
+                                        float weight   = vert.boneweight[j];
                                         const quat& orient      = m_transform[index].get_orientation();
                                         const transform& offset = m_pos_offset[index];
@@ -152 +152 @@
                 if ( bi != bone_names.end() )
                 {
-                        bone_id = bi->second;
+                        bone_id = (sint16)bi->second;
                 }
                 m_bone_ids[n] = bone_id;

trunk/src/gl/gl_device.cc

@@ -132 +132 @@
         texture result = m_textures.create();
         gl_texture_info* info = m_textures.get( result );
-        info->format  = aformat;
-        info->sampler = asampler;
-        info->size    = size;
-        info->glid    = glid;
+        info->format   = aformat;
+        info->tsampler = asampler;
+        info->size     = size;
+        info->glid     = glid;
         return result;
 }

trunk/src/gl/gl_enum.cc

@@ -232 +232 @@
         case BYTE_VECTOR_3  : return GL_INT_VEC3;
         case BYTE_VECTOR_4  : return GL_INT_VEC4;
-        NV_RETURN_COVERED_DEFAULT( 0 );
+        default : return 0; // TODO: throw!
         }
 }

trunk/src/gl/gl_window.cc

@@ -19 +19 @@
 
 #if NV_SDL_VERSION == NV_SDL_20
-        uint32 ucode = ke.keysym.sym;
-#else
-        uint32 ucode = ke.keysym.unicode;
+        uint32 ucode = (uint32)ke.keysym.sym;
+#else
+        uint32 ucode = (uint32)ke.keysym.unicode;
 #endif
 
@@ -34 +34 @@
                         int capslock = !!(ke.keysym.mod & KMOD_CAPS);
                         if ((shifted ^ capslock) != 0) {
-                                kevent.key.ascii = (char8)SDL_toupper(ucode);
+                                kevent.key.ascii = (char8)SDL_toupper((int)ucode);
                         }
                 }

trunk/src/lib/gl.cc

@@ -19 +19 @@
 // for wgl support
 #if NV_PLATFORM == NV_WINDOWS
-#    ifndef WIN32_LEAN_AND_MEAN
-#      define WIN32_LEAN_AND_MEAN 1
-#    endif
 #include <windows.h>
-#    undef WIN32_LEAN_AND_MEAN
-#endif
-
-// extern added for wgl needs only!
-#define NV_GL_FUN( rtype, fname, fparams ) extern "C" rtype (NV_GL_APIENTRY *fname) fparams = nullptr;
-#define NV_GL_FUN_REN( rtype, fname, rname, fparams ) extern "C" rtype (NV_GL_APIENTRY *rname) fparams = nullptr;
+#endif
+
+#define NV_GL_FUN( rtype, fname, fparams ) rtype (NV_GL_APIENTRY *fname) fparams = nullptr;
+#define NV_GL_FUN_REN( rtype, fname, rname, fparams ) rtype (NV_GL_APIENTRY *rname) fparams = nullptr;
 #define NV_GL_FUN_EXT NV_GL_FUN
 #include <nv/lib/detail/gl_functions.inc>
@@ -41 +36 @@
 static nv::library gl_library;
 static nv::gl_extensions gl_loaded_extensions = nv::gl_extensions(0);
-extern "C" void* (NV_GL_APIENTRY *gl_ext_loader) ( const char* ) = nullptr;
+static void* (NV_GL_APIENTRY *gl_ext_loader) ( const char* ) = nullptr;
 static bool gl_library_loaded = false;
 static bool wgl_library_loaded = false;
@@ -52 +47 @@
 };
 
-static const char *gl_extension_ids[] = {
-        "UNKNOWN",
-#define NV_GL_EXTENSION( count, id, name ) #id,
-#include <nv/lib/detail/gl_ext/gl_ext_info.inc>
-#undef NV_GL_EXTENSION
-};
+// static const char *gl_extension_ids[] = {
+//      "UNKNOWN",
+// #define NV_GL_EXTENSION( count, id, name ) #id,
+// #include <nv/lib/detail/gl_ext/gl_ext_info.inc>
+// #undef NV_GL_EXTENSION
+// };
 
 
@@ -184 +179 @@
         wndClass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
 
-        DWORD err = GetLastError();
+        /*DWORD err = */GetLastError();
         RegisterClass(&wndClass);
-        err = GetLastError();
+        /*err = */GetLastError();
 
 
@@ -235 +230 @@
 }
 
-
 bool nv::load_gl_extension( gl_extensions extension )
 {

trunk/src/lua/lua_map_tile.cc

@@ -27 +27 @@
 
 
-bool nlua_is_map_tile( lua_State* L, int index )
-{
-        return luaL_testudata( L, index, NLUA_MAP_TILE_METATABLE ) != 0;
-}
-
-map_tile nlua_to_map_tile( lua_State* L, int index )
-{
-        return *(map_tile*)luaL_checkudata( L, index, NLUA_MAP_TILE_METATABLE );
-}
-
-map_tile* nlua_to_pmap_tile( lua_State* L, int index )
+// static bool nlua_is_map_tile( lua_State* L, int index )
+// {
+//      return luaL_testudata( L, index, NLUA_MAP_TILE_METATABLE ) != 0;
+// }
+// 
+// static map_tile nlua_to_map_tile( lua_State* L, int index )
+// {
+//      return *(map_tile*)luaL_checkudata( L, index, NLUA_MAP_TILE_METATABLE );
+// }
+
+static map_tile* nlua_to_pmap_tile( lua_State* L, int index )
 {
         return (map_tile*)luaL_checkudata( L, index, NLUA_MAP_TILE_METATABLE );
 }
 
-void nlua_push_map_tile( lua_State* L, const map_tile& tile )
+static void nlua_push_map_tile( lua_State* L, const map_tile& tile )
 {
         map_tile* result = (map_tile*)lua_newuserdata( L, sizeof(map_tile) );
@@ -79 +79 @@
                         if ( lua_isstring( L, -2 ) && lua_objlen( L, -2 ) == 1 )
                         {
-                                translation[ lua_tostring( L, -2 )[0] ] = nv::uint8( map_area->string_to_id( lua_tostring( L, -1 ) ) );
+                                translation[ (nv::uint8)( lua_tostring( L, -2 )[0] ) ] = nv::uint8( map_area->string_to_id( lua_tostring( L, -1 ) ) );
                         }
                         // removes 'value'; keeps 'key' for next iteration */
@@ -86 +86 @@
         }
 
-        for ( int line = 0; line < tile.size_x; line++ )
-                for ( int row = 0; row < tile.size_y; row++ )
-                {
-                        nv::char8 gylph = code[ row * ( tile.size_x + 1 ) + line ];
+        for ( nv::uint16 line = 0; line < tile.size_x; line++ )
+                for ( nv::uint16 row = 0; row < tile.size_y; row++ )
+                {
+                        nv::char8 gylph = (nv::char8)code[ row * ( tile.size_x + 1 ) + line ];
                         // TODO: check for errors
                         tile.data[ row * tile.size_x + line ] = translation[ gylph ];
@@ -203 +203 @@
         switch ( nv::random::get().urand( 4 ) )
         {
-        case 1 : nlua_map_tile_flip_x( L );
-        case 2 : nlua_map_tile_flip_y( L );
-        case 3 : nlua_map_tile_flip_xy( L );
+        case 1 : nlua_map_tile_flip_x( L ); break;
+        case 2 : nlua_map_tile_flip_y( L ); break;
+        case 3 : nlua_map_tile_flip_xy( L ); break;
         default:
                 break;

trunk/src/lua/lua_nova.cc

@@ -9 +9 @@
 #include "nv/lua/lua_raw.hh"
 
-const char* NV_STATE      = "NV_STATE";
-const char* NV_BLUEPRINTS = "NV_BLUEPRINTS";
+static const char* NV_STATE      = "NV_STATE";
+static const char* NV_BLUEPRINTS = "NV_BLUEPRINTS";
 
 // static nv::lua::state* nova_get_state( lua_State * L )
@@ -73 +73 @@
                         return true;
                 }
+                break;
         case LUA_TSTRING :
                 if ( lua_type( L, ivalue ) != LUA_TTABLE )
@@ -86 +87 @@
                 lua_concat( L, 3 );
                 lua_call( L, 3, 0 );
+                break;
         case LUA_TNUMBER :
                 if (lua_tointeger( L, itype ) != lua_type( L, ivalue ) && lua_tointeger( L, itype ) > 0)
@@ -91 +93 @@
                         luaL_error( L, "lua.nova - \"%s.%s\" - type mismatch, %s expected, %s found!", lua_tolstring( L, iid, 0 ), lua_tolstring( L, ifield, 0 ), lua_typename( L, lua_tointeger( L, itype ) ), lua_typename( L, lua_type( L, ivalue ) ) );
                 }
-
+                break;
+        default : return false;
         }
         return false;
@@ -784 +787 @@
 
 
-int luaopen_nova( lua_State * L )
+static int luaopen_nova( lua_State * L )
 {
         lua_createtable( L, 0, 0 );