gosu 0.10.9.pre1 → 0.11.0

data/src/FileUnix.cpp

@@ -1,100 +1,94 @@
+#include <Gosu/Platform.hpp>
+#if !defined(GOSU_IS_WIN)
+
 #include <Gosu/IO.hpp>
 #include <Gosu/Utility.hpp>
-#include <stdexcept>
 #include <cstring>
 #include <fcntl.h>
-#include <unistd.h>
-#include <sys/types.h>
+#include <stdexcept>
 #include <sys/mman.h>
+#include <sys/types.h>
+#include <unistd.h>
 
 #ifdef HAVE_SYS_STAT_H
 #include <sys/stat.h>
 #endif
 
-namespace
-{
-    // According to my man page, Unix folks just don't trust the 0, it's got to be a crippled -1.
-    void* const noMapping = reinterpret_cast<void*>(-1);
-}
-
 struct Gosu::File::Impl
 {
-    int fd;
-    void* mapping;
+    int fd = -1;
+    void* mapping = MAP_FAILED;
     
-    Impl() : fd(-1), mapping(noMapping) {}
     ~Impl()
     {
-        if (fd > 0)
+        if (fd >= 0) {
             close(fd);
+        }
     }
 };
 
-Gosu::File::File(const std::wstring& filename, FileMode mode)
+Gosu::File::File(const std::string& filename, FileMode mode)
 : pimpl(new Impl)
 {
     int flags;
 
-    switch (mode)
-    {
-    case fmRead:
+    switch (mode) {
+    case FM_READ:
         flags = O_RDONLY;
         break;
-    case fmReplace:
+    case FM_REPLACE:
         flags = O_RDWR | O_TRUNC | O_CREAT;
         break;
-    case fmAlter:
+    case FM_ALTER:
         flags = O_RDWR | O_CREAT;
         break;
     }
 
     // TODO: Locking flags?
 
-    pimpl->fd = open(narrow(filename).c_str(), flags,
-        S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);
-    if (pimpl->fd < 0)
-        throw std::runtime_error("Cannot open file " + narrow(filename));
+    pimpl->fd = open(filename.c_str(), flags, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);
+    if (pimpl->fd < 0) {
+        throw std::runtime_error("Cannot open file " + filename);
+    }
     
-    if (mode == fmRead && size() > 0)
-        pimpl->mapping = mmap(0, size(), PROT_READ, 0, pimpl->fd, 0);
+    if (mode == FM_READ && size() > 0) {
+        pimpl->mapping = mmap(nullptr, size(), PROT_READ, 0, pimpl->fd, 0);
+    }
 }
 
 Gosu::File::~File()
 {
-    if (pimpl->mapping != noMapping)
+    if (pimpl->mapping != MAP_FAILED) {
         munmap(pimpl->mapping, size());
+    }
 }
 
 std::size_t Gosu::File::size() const
 {
-    // IMPR: Error checking?
+    // TODO: Error checking?
     return lseek(pimpl->fd, 0, SEEK_END);
 }
 
-void Gosu::File::resize(std::size_t newSize)
-{
-    ftruncate(pimpl->fd, newSize);
-}
+void Gosu::File::resize(std::size_t new_size) { ftruncate(pimpl->fd, new_size); }
 
-void Gosu::File::read(std::size_t offset, std::size_t length,
-    void* destBuffer) const
+void Gosu::File::read(std::size_t offset, std::size_t length, void* dest_buffer) const
 {
-    // TODO: err checking
-    if (pimpl->mapping != noMapping)
-    {
-        std::memcpy(destBuffer, static_cast<const char*>(pimpl->mapping) + offset, length);
-        return;
+    // TODO: Bounds checks?
+    if (pimpl->mapping != MAP_FAILED) {
+        std::memcpy(dest_buffer, static_cast<const char*>(pimpl->mapping) + offset, length);
+    }
+    else {
+        // TODO: Error checking?
+        lseek(pimpl->fd, offset, SEEK_SET);
+        ::read(pimpl->fd, dest_buffer, length);
     }
-    
-    // IMPR: Error checking?
-    lseek(pimpl->fd, offset, SEEK_SET);
-    ::read(pimpl->fd, destBuffer, length);
 }
 
-void Gosu::File::write(std::size_t offset, std::size_t length,
-    const void* sourceBuffer)
+void Gosu::File::write(std::size_t offset, std::size_t length, const void* source_buffer)
 {
-    // IMPR: Error checking?
+    // TODO: Error checking?
     lseek(pimpl->fd, offset, SEEK_SET);
-    ::write(pimpl->fd, sourceBuffer, length);
+    ::write(pimpl->fd, source_buffer, length);
 }
+
+#endif

data/src/FileWin.cpp

@@ -1,51 +1,52 @@
+#include <Gosu/Platform.hpp>
+#if defined(GOSU_IS_WIN)
+
+#include "WinUtility.hpp"
 #include <Gosu/IO.hpp>
 #include <Gosu/Utility.hpp>
-#include "WinUtility.hpp"
 #include <windows.h>
 
-// IMPR: Error checking
+// TODO: Error checking
 
 struct Gosu::File::Impl
 {
-    HANDLE handle;
-
-    Impl()
-    : handle(INVALID_HANDLE_VALUE)
-    {
-    }
+    HANDLE handle = INVALID_HANDLE_VALUE;
 
     ~Impl()
     {
-        if (handle != INVALID_HANDLE_VALUE)
-            ::CloseHandle(handle);
+        if (handle != INVALID_HANDLE_VALUE) {
+            CloseHandle(handle);
+        }
     }
 };
 
-Gosu::File::File(const std::wstring& filename, FileMode mode)
+Gosu::File::File(const std::string& filename, FileMode mode)
 : pimpl(new Impl)
 {
     DWORD access;
-    switch (mode)
-    {
-    case fmRead:
+    switch (mode) {
+    case FM_READ:
         access = GENERIC_READ;
         break;
-    case fmReplace:
+    case FM_REPLACE:
         access = GENERIC_WRITE;
         break;
-    case fmAlter:
+    case FM_ALTER:
         access = GENERIC_READ | GENERIC_WRITE;
         break;
     }
-    DWORD shareMode = FILE_SHARE_READ;
-    DWORD creationDisp = (mode == fmRead) ? OPEN_EXISTING : OPEN_ALWAYS;
+    DWORD share_mode = FILE_SHARE_READ;
+    DWORD creation_disp = (mode == FM_READ) ? OPEN_EXISTING : OPEN_ALWAYS;
 
-    pimpl->handle = ::CreateFile(filename.c_str(), access, shareMode, 0,
-        creationDisp, FILE_ATTRIBUTE_NORMAL, 0);
-    if (pimpl->handle == INVALID_HANDLE_VALUE)
-        Win::throwLastError("opening " + Gosu::narrow(filename));
-    if (mode == fmReplace)
+    std::wstring wfilename = utf8_to_wstring(filename);
+    pimpl->handle = CreateFileW(wfilename.c_str(), access, share_mode, 0, creation_disp,
+                                FILE_ATTRIBUTE_NORMAL, 0);
+    if (pimpl->handle == INVALID_HANDLE_VALUE) {
+        throw_last_winapi_error("opening " + filename);
+    }
+    if (mode == FM_REPLACE) {
         resize(0);
+    }
 }
 
 Gosu::File::~File()
@@ -54,30 +55,33 @@ Gosu::File::~File()
 
 std::size_t Gosu::File::size() const
 {
-    return ::GetFileSize(pimpl->handle, 0);
+    return GetFileSize(pimpl->handle, 0);
 }
 
-void Gosu::File::resize(std::size_t newSize)
+void Gosu::File::resize(std::size_t new_size)
 {
-    if (::SetFilePointer(pimpl->handle, newSize, 0, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
-        Win::throwLastError("setting the file pointer");
-    Win::check(::SetEndOfFile(pimpl->handle), "resizing a file");
+    if (SetFilePointer(pimpl->handle, new_size, 0, FILE_BEGIN) == INVALID_SET_FILE_POINTER) {
+        throw_last_winapi_error("setting the file pointer");
+    }
+    winapi_check(SetEndOfFile(pimpl->handle), "resizing a file");
 }
 
-void Gosu::File::read(std::size_t offset, std::size_t length,
-    void* destBuffer) const
+void Gosu::File::read(std::size_t offset, std::size_t length, void* dest_buffer) const
 {
-    if (::SetFilePointer(pimpl->handle, offset, 0, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
-        Win::throwLastError("setting the file pointer");
+    if (SetFilePointer(pimpl->handle, offset, 0, FILE_BEGIN) == INVALID_SET_FILE_POINTER) {
+        throw_last_winapi_error("setting the file pointer");
+    }
     DWORD dummy;
-    Win::check(::ReadFile(pimpl->handle, destBuffer, length, &dummy, 0));
+    winapi_check(ReadFile(pimpl->handle, dest_buffer, length, &dummy, 0));
 }
 
-void Gosu::File::write(std::size_t offset, std::size_t length,
-    const void* sourceBuffer)
+void Gosu::File::write(std::size_t offset, std::size_t length, const void* source_buffer)
 {
-    if (::SetFilePointer(pimpl->handle, offset, 0, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
-        Win::throwLastError("setting the file pointer");
+    if (SetFilePointer(pimpl->handle, offset, 0, FILE_BEGIN) == INVALID_SET_FILE_POINTER) {
+        throw_last_winapi_error("setting the file pointer");
+    }
     DWORD dummy;
-    Win::check(::WriteFile(pimpl->handle, sourceBuffer, length, &dummy, 0));
+    winapi_check(WriteFile(pimpl->handle, source_buffer, length, &dummy, 0));
 }
+
+#endif

data/src/Font.cpp

@@ -0,0 +1,165 @@
+#include "FormattedString.hpp"
+#include "GraphicsImpl.hpp"
+#include <Gosu/Font.hpp>
+#include <Gosu/Graphics.hpp>
+#include <Gosu/Image.hpp>
+#include <Gosu/Math.hpp>
+#include <Gosu/Text.hpp>
+#include <array>
+#include <cassert>
+#include <map>
+using namespace std;
+
+struct Gosu::Font::Impl
+{
+    string name;
+    unsigned height, flags;
+
+    // Unicode planes of 2^16 characters each. On Windows, where wchar_t is only 16 bits wide, only
+    // the first plane will ever be touched.
+    struct CharInfo
+    {
+        std::unique_ptr<Image> image;
+        double factor;
+    };
+    typedef array<CharInfo, 65536> Plane;
+    std::unique_ptr<Plane> planes[16][FF_COMBINATIONS];
+    
+    map<string, shared_ptr<Image>> entity_cache;
+    
+    CharInfo& char_info(wchar_t wc, unsigned flags)
+    {
+        size_t plane_index = wc / 65536;
+        size_t char_index  = wc % 65536;
+        
+        if (plane_index >= 16) throw invalid_argument("Unicode plane out of reach");
+        if (flags >= FF_COMBINATIONS) throw invalid_argument("Font flags out of range");
+        
+        if (!planes[plane_index][flags].get()) {
+            planes[plane_index][flags].reset(new Plane);
+        }
+        return (*planes[plane_index][flags])[char_index];
+    }
+    
+    const Image& image_at(const FormattedString& fs, unsigned i)
+    {
+        if (const char* entity = fs.entity_at(i)) {
+            shared_ptr<Image>& ptr = entity_cache[entity];
+            if (!ptr) {
+                ptr.reset(new Image(entity_bitmap(fs.entity_at(i)), IF_SMOOTH));
+            }
+            return *ptr;
+        }
+        
+        wchar_t wc     = fs.char_at(i);
+        unsigned flags = fs.flags_at(i);
+        CharInfo& info = char_info(wc, flags);
+        
+        if (info.image.get()) return *info.image;
+        
+        std::string char_string = wstring_to_utf8(std::wstring(1, wc));
+        // TODO: Would be nice to have.
+        // if (is_formatting_char(wc))
+        //     char_string.clear();
+        unsigned char_width = Gosu::text_width(char_string, name, height, flags);
+        
+        Bitmap bitmap(char_width, height, 0x00ffffff);
+        draw_text(bitmap, char_string, 0, 0, Color::WHITE, name, height, flags);
+        info.image.reset(new Image(bitmap));
+        info.factor = 0.5;
+        return *info.image;
+    }
+    
+    double factor_at(const FormattedString& fs, unsigned index)
+    {
+        if (fs.entity_at(index)) return 1;
+        return char_info(fs.char_at(index), fs.flags_at(index)).factor;
+    }
+};
+
+Gosu::Font::Font(unsigned font_height, const string& font_name, unsigned font_flags)
+: pimpl(new Impl)
+{
+    pimpl->name = font_name;
+    pimpl->height = font_height * 2;
+    pimpl->flags = font_flags;
+}
+
+string Gosu::Font::name() const
+{
+    return pimpl->name;
+}
+
+unsigned Gosu::Font::height() const
+{
+    return pimpl->height / 2;
+}
+
+unsigned Gosu::Font::flags() const
+{
+    return pimpl->flags;
+}
+
+double Gosu::Font::text_width(const string& text, double scale_x) const
+{
+    std::wstring wtext = utf8_to_wstring(text);
+    FormattedString fs(wtext.c_str(), flags());
+    double result = 0;
+    for (unsigned i = 0; i < fs.length(); ++i) {
+        const Image& image = pimpl->image_at(fs, i);
+        double factor = pimpl->factor_at(fs, i);
+        result += image.width() * factor;
+    }
+    return result * scale_x;
+}
+
+void Gosu::Font::draw(const string& text, double x, double y, ZPos z,
+    double scale_x, double scale_y, Color c, AlphaMode mode) const
+{
+    std::wstring wtext = utf8_to_wstring(text);
+    FormattedString fs(wtext.c_str(), flags());
+    
+    for (unsigned i = 0; i < fs.length(); ++i) {
+        const Image& image = pimpl->image_at(fs, i);
+        double factor = pimpl->factor_at(fs, i);
+        Gosu::Color color = fs.entity_at(i)
+                          ? Gosu::Color(fs.color_at(i).alpha() * c.alpha() / 255, 255, 255, 255)
+                          : Gosu::multiply(fs.color_at(i), c);
+        image.draw(x, y, z, scale_x * factor, scale_y * factor, color, mode);
+        x += image.width() * scale_x * factor;
+    }
+}
+
+void Gosu::Font::draw_rel(const string& text, double x, double y, ZPos z,
+    double rel_x, double rel_y, double scale_x, double scale_y, Color c, AlphaMode mode) const
+{
+    x -= text_width(text) * scale_x * rel_x;
+    y -= height() * scale_y * rel_y;
+    
+    draw(text, x, y, z, scale_x, scale_y, c, mode);
+}
+
+void Gosu::Font::set_image(wchar_t wc, const Image& image)
+{
+    for (unsigned flags = 0; flags < FF_COMBINATIONS; ++flags) {
+        set_image(wc, flags, image);
+    }
+}
+
+void Gosu::Font::set_image(wchar_t wc, unsigned font_flags, const Image& image)
+{
+    Impl::CharInfo& ci = pimpl->char_info(wc, font_flags);
+    if (ci.image.get()) {
+        throw logic_error("Cannot set image for the same character twice");
+    }
+    ci.image.reset(new Gosu::Image(image));
+    ci.factor = 1.0;
+}
+
+void Gosu::Font::draw_rot(const string& text, double x, double y, ZPos z, double angle,
+    double scale_x, double scale_y, Color c, AlphaMode mode) const
+{
+    Gosu::Graphics::push_transform(rotate(angle, x, y));
+    draw(text, x, y, z, scale_x, scale_y, c, mode);
+    Gosu::Graphics::pop_transform();
+}

data/src/{Text/FormattedString.hpp → FormattedString.hpp}

@@ -1,10 +1,11 @@
-#ifndef GOSU_SRC_GRAPHICS_TEXTFORMATTING
-#define GOSU_SRC_GRAPHICS_TEXTFORMATTING
+#pragma once
 
+#include "GraphicsImpl.hpp"
 #include <Gosu/Color.hpp>
+#include <Gosu/GraphicsBase.hpp>
 #include <Gosu/Utility.hpp>
-#include <Gosu/TR1.hpp>
 #include <cassert>
+#include <cstdint>
 #include <cwchar>
 #include <cwctype>
 #include <stdexcept>
@@ -20,26 +21,26 @@ namespace Gosu
             wchar_t wc;
             Gosu::Color color;
             unsigned flags;
-            std::wstring entity;
+            std::string entity;
             
-            bool sameStyleAs(const FormattedChar& other) const
+            bool same_style_as(const FormattedChar& other) const
             {
                 return wc && other.wc && color == other.color && flags == other.flags;
             }
         };
         
         // If characters.empty(), use these for the whole string.
-        std::wstring simpleString;
-        unsigned simpleFlags;
+        std::wstring simple_string;
+        unsigned simple_flags;
         // If not characters.empty(), ignore above fields and use this.
         std::vector<FormattedChar> characters;
         
         static unsigned flags(int b, int u, int i)
         {
             unsigned flags = 0;
-            if (b > 0) flags |= ffBold;
-            if (u > 0) flags |= ffUnderline;
-            if (i > 0) flags |= ffItalic;
+            if (b > 0) flags |= FF_BOLD;
+            if (u > 0) flags |= FF_UNDERLINE;
+            if (i > 0) flags |= FF_ITALIC;
             return flags;
         }
         
@@ -48,17 +49,17 @@ namespace Gosu
         {
         }
         
-        explicit FormattedString(const wchar_t* html, unsigned baseFlags)
+        explicit FormattedString(const wchar_t* html, unsigned base_flags)
         {
             // Remove \r characters if existent. Avoid a copy if we don't need one.
             std::wstring unixified;
             if (std::wcschr(html, L'\r')) {
                 unixified.resize(std::wcslen(html));
                 unsigned pos = 0;
-                while (*html)
-                {
-                    if (*html != '\r')
+                while (*html) {
+                    if (*html != '\r') {
                         unixified[pos++] = *html;
+                    }
                     ++html;
                 }
                 unixified.resize(pos);
@@ -68,127 +69,114 @@ namespace Gosu
             std::size_t len = std::wcslen(html);
             
             // Just skip all this if there are entities or formatting tags in the string.
-            if (std::wcscspn(html, L"<&") == len)
-            {
-                simpleString = html;
-                simpleFlags = baseFlags;
+            if (std::wcscspn(html, L"<&") == len) {
+                simple_string = html;
+                simple_flags = base_flags;
                 return;
             }
             
             unsigned pos = 0;
-            int b = (baseFlags & ffBold) ? 1 : 0,
-                u = (baseFlags & ffUnderline) ? 1 : 0,
-                i = (baseFlags & ffItalic) ? 1 : 0;
+            int b = (base_flags & FF_BOLD) ? 1 : 0,
+                u = (base_flags & FF_UNDERLINE) ? 1 : 0,
+                i = (base_flags & FF_ITALIC) ? 1 : 0;
             std::vector<Gosu::Color> c;
             c.push_back(0xffffffff);
-            while (pos < len)
-            {
-                if (!std::wcsncmp(html + pos, L"<b>", 3))
-                {
+            while (pos < len) {
+                if (!std::wcsncmp(html + pos, L"<b>", 3)) {
                     b += 1;
                     pos += 3;
                     continue;
                 }
-                if (!std::wcsncmp(html + pos, L"</b>", 4))
-                {
+                if (!std::wcsncmp(html + pos, L"</b>", 4)) {
                     b -= 1;
                     pos += 4;
                     continue;
                 }
-                if (!std::wcsncmp(html + pos, L"<u>", 3))
-                {
+                if (!std::wcsncmp(html + pos, L"<u>", 3)) {
                     u += 1;
                     pos += 3;
                     continue;
                 }
-                if (!std::wcsncmp(html + pos, L"</u>", 4))
-                {
+                if (!std::wcsncmp(html + pos, L"</u>", 4)) {
                     u -= 1;
                     pos += 4;
                     continue;
                 }
-                if (!std::wcsncmp(html + pos, L"<i>", 3))
-                {
+                if (!std::wcsncmp(html + pos, L"<i>", 3)) {
                     i += 1;
                     pos += 3;
                     continue;
                 }
-                if (!std::wcsncmp(html + pos, L"</i>", 4))
-                {
+                if (!std::wcsncmp(html + pos, L"</i>", 4)) {
                     i -= 1;
                     pos += 4;
                     continue;
                 }
-                if (!std::wcsncmp(html + pos, L"<c=", 3) &&
-                    len >= pos + 10 && html[pos + 9] == L'>')
-                {
+                if (!std::wcsncmp(html + pos, L"<c=", 3) && len >= pos + 10
+                    && html[pos + 9] == L'>') {
                     using namespace std;
-                    unsigned rgb = static_cast<std::tr1::uint32_t>(wcstoul(html + pos + 3, 0, 16));
+                    unsigned rgb = static_cast<std::uint32_t>(wcstoul(html + pos + 3, 0, 16));
                     c.push_back(0xff000000 | rgb);
                     pos += 10;
                     continue;
                 }
-                if (!std::wcsncmp(html + pos, L"<c=", 3) &&
-                    len >= pos + 12 && html[pos + 11] == L'>')
-                {
+                if (!std::wcsncmp(html + pos, L"<c=", 3) && len >= pos + 12
+                    && html[pos + 11] == L'>') {
                     using namespace std;
-                    unsigned argb = static_cast<std::tr1::uint32_t>(wcstoul(html + pos + 3, 0, 16));
+                    unsigned argb = static_cast<std::uint32_t>(wcstoul(html + pos + 3, 0, 16));
                     c.push_back(argb);
                     pos += 12;
                     continue;
                 }
-                if (!std::wcsncmp(html + pos, L"</c>", 4))
-                {
-                    if (c.size() > 1)
+                if (!std::wcsncmp(html + pos, L"</c>", 4)) {
+                    if (c.size() > 1) {
                         c.pop_back();
+                    }
                     pos += 4;
                     continue;
                 }
-                if (!std::wcsncmp(html + pos, L"&lt;", 4))
-                {
-                    FormattedChar fc = { L'<', c.back(), flags(b,u,i) };
+                if (!std::wcsncmp(html + pos, L"&lt;", 4)) {
+                    FormattedChar fc = { L'<', c.back(), flags(b, u, i) };
                     characters.push_back(fc);
                     pos += 4;
                     continue;
                 }
-                if (!std::wcsncmp(html + pos, L"&gt;", 4))
-                {
-                    FormattedChar fc = { L'>', c.back(), flags(b,u,i) };
+                if (!std::wcsncmp(html + pos, L"&gt;", 4)) {
+                    FormattedChar fc = { L'>', c.back(), flags(b, u, i) };
                     characters.push_back(fc);
                     pos += 4;
                     continue;
                 }
-                if (!std::wcsncmp(html + pos, L"&amp;", 5))
-                {
-                    FormattedChar fc = { L'&', c.back(), flags(b,u,i) };
+                if (!std::wcsncmp(html + pos, L"&amp;", 5)) {
+                    FormattedChar fc = { L'&', c.back(), flags(b, u, i) };
                     characters.push_back(fc);
                     pos += 5;
                     continue;
                 }
-                if (html[pos] == L'&' && html[pos + 1])
-                {
-                    int endOfEntity = pos + 1;
-                    while (html[endOfEntity] != L';')
-                    {
-                        // Never know where the wchar_t stuff is...what a mess!
+                if (html[pos] == L'&' && html[pos + 1]) {
+                    int end_of_entity = pos + 1;
+                    while (html[end_of_entity] != L';') {
                         using namespace std;
-                        using namespace std::tr1;
-                        if (!iswalnum(static_cast<wint_t>(html[endOfEntity])))
-                            goto normalCharacter;
-                        endOfEntity += 1;
-                        if (endOfEntity >= len)
-                            goto normalCharacter;
+                        if (!iswalnum(static_cast<wint_t>(html[end_of_entity]))) {
+                            goto normal_character;
+                        }
+                        end_of_entity += 1;
+                        if (end_of_entity >= len) {
+                            goto normal_character;
+                        }
+                    }
+                    std::wstring entity(html + pos + 1, html + end_of_entity);
+                    FormattedChar fc = { 0, c.back(), 0, wstring_to_utf8(entity) };
+                    if (!is_entity(fc.entity)) {
+                        goto normal_character;
                     }
-                    FormattedChar fc = { 0, c.back(), 0, std::wstring(html + pos + 1, html + endOfEntity) };
-                    if (!isEntity(fc.entity))
-                        goto normalCharacter;
                     characters.push_back(fc);
-                    pos = endOfEntity + 1;
+                    pos = end_of_entity + 1;
                     continue;
                 }
-                
-            normalCharacter:                
-                FormattedChar fc = { html[pos], c.back(), flags(b,u,i) };
+
+            normal_character:
+                FormattedChar fc = { html[pos], c.back(), flags(b, u, i) };
                 characters.push_back(fc);
                 pos += 1;
             }
@@ -196,103 +184,115 @@ namespace Gosu
         
         std::wstring unformat() const
         {
-            if (characters.empty())
-                return simpleString;
+            if (characters.empty()) {
+                return simple_string;
+            }
             
             std::wstring result(characters.size(), 0);
-            for (int i = 0; i < characters.size(); ++i)
+            for (int i = 0; i < characters.size(); ++i) {
                 result[i] = characters[i].wc;
+            }
             return result;
         }
         
-        const wchar_t* entityAt(unsigned index) const
+        const char* entity_at(unsigned index) const
         {
-            if (characters.empty())
-                return 0;
+            if (characters.empty()) {
+                return nullptr;
+            }
             
-            assert (index <= characters.size());
+            if (characters[index].wc != 0 || characters[index].entity.empty()) {
+                return nullptr;
+            }
             
-            if (characters[index].wc != 0 || characters[index].entity.empty())
-                return 0;
             return characters[index].entity.c_str();
         }
         
-        wchar_t charAt(unsigned index) const
+        wchar_t char_at(unsigned index) const
         {
-            if (characters.empty())
-                return simpleString[index];
-            else
+            if (characters.empty()) {
+                return simple_string[index];
+            }
+            else {
                 return characters[index].wc;
+            }
         }
         
-        unsigned flagsAt(unsigned index) const
+        unsigned flags_at(unsigned index) const
         {
-            if (characters.empty())
-                return simpleFlags;
-            else
+            if (characters.empty()) {
+                return simple_flags;
+            }
+            else {
                 return characters[index].flags;
+            }
         }
         
-        Gosu::Color colorAt(unsigned index) const
+        Gosu::Color color_at(unsigned index) const
         {
-            if (characters.empty())
+            if (characters.empty()) {
                 return Color::WHITE;
-            else
+            }
+            else {
                 return characters[index].color;
+            }
         }
         
         std::size_t length() const
         {
-            if (std::size_t len = characters.size())
+            if (std::size_t len = characters.size()) {
                 return len;
-            else
-                return simpleString.length();
+            }
+            else {
+                return simple_string.length();
+            }
         }
         
         FormattedString range(std::size_t begin, std::size_t end) const
         {
             FormattedString result;
-            if (characters.empty())
-            {
-                result.simpleString.assign(simpleString.begin() + begin, simpleString.begin() + end);
-                result.simpleFlags = simpleFlags;
+            if (characters.empty()) {
+                result.simple_string.assign(simple_string.begin() + begin,
+                                            simple_string.begin() + end);
+                result.simple_flags = simple_flags;
+            }
+            else {
+                result.characters.assign(characters.begin() + begin,
+                                         characters.begin() + end);
             }
-            else
-                result.characters.assign(characters.begin() + begin, characters.begin() + end);
             return result;
         }
         
-        std::vector<FormattedString> splitLines() const
+        std::vector<FormattedString> split_lines() const
         {
             std::vector<FormattedString> result;
             unsigned begin = 0;
-            for (unsigned cur = 0; cur < length(); ++cur)
-                if (charAt(cur) == L'\n')
-                {
+            for (unsigned cur = 0; cur < length(); ++cur) {
+                if (char_at(cur) == L'\n') {
                     result.push_back(range(begin, cur));
                     begin = cur + 1;
                 }
+            }
             result.push_back(range(begin, length()));
             return result;
         }
         
-        std::vector<FormattedString> splitParts() const
+        std::vector<FormattedString> split_parts() const
         {
-            if (characters.empty())
+            if (characters.empty()) {
                 return std::vector<FormattedString>(1, *this);
+            }
             
             std::vector<FormattedString> result;
             unsigned begin = 0;
-            for (unsigned cur = 1; cur < length(); ++cur)
-                if (!characters[begin].sameStyleAs(characters[cur]))
-                {
+            for (unsigned cur = 1; cur < length(); ++cur) {
+                if (!characters[begin].same_style_as(characters[cur])) {
                     result.push_back(range(begin, cur));
                     begin = cur;
                 }
+            }
             result.push_back(range(begin, length()));
             return result;
         }
     };
 }
-
-#endif