From acd47d9f91e68a7e25eeb2a477ccb97aef06c952 Mon Sep 17 00:00:00 2001
From: Michael Hansen <zrax0111@gmail.com>
Date: Wed, 25 Jan 2012 19:20:44 -0800
Subject: [PATCH 01/11] Re-add plString with some cleanup

---
 Sources/Plasma/CoreLib/CMakeLists.txt |  13 +
 Sources/Plasma/CoreLib/plString.cpp   | 662 ++++++++++++++++++++++++++
 Sources/Plasma/CoreLib/plString.h     | 387 +++++++++++++++
 3 files changed, 1062 insertions(+)
 create mode 100644 Sources/Plasma/CoreLib/plString.cpp
 create mode 100644 Sources/Plasma/CoreLib/plString.h

diff --git a/Sources/Plasma/CoreLib/CMakeLists.txt b/Sources/Plasma/CoreLib/CMakeLists.txt
index 2196d9a6..c6ad4945 100644
--- a/Sources/Plasma/CoreLib/CMakeLists.txt
+++ b/Sources/Plasma/CoreLib/CMakeLists.txt
@@ -1,5 +1,16 @@
 add_definitions(-D_LIB)
 
+if(NOT WCHAR_BYTES)
+    include(CheckTypeSize)
+
+    check_type_size("wchar_t" WCHAR_BYTES)
+    if(NOT WCHAR_BYTES)
+        message(FATAL_ERROR "Could not determine sizeof(wchar_t)")
+        set(WCHAR_BYTES 0)
+    endif(NOT WCHAR_BYTES)
+endif(NOT WCHAR_BYTES)
+add_definitions(-DWCHAR_BYTES=${WCHAR_BYTES})
+
 set(CoreLib_SOURCES
     HeadSpin.cpp
     hsBitVector.cpp
@@ -26,6 +37,7 @@ set(CoreLib_SOURCES
     pcSmallRect.cpp
     plGeneric.cpp
     plLoadMask.cpp
+    plString.cpp
     plViewTransform.cpp
 )
 
@@ -82,6 +94,7 @@ set(CoreLib_HEADERS
     plLoadMask.h
     plQuality.h
     plRefCnt.h
+    plString.h
     plTweak.h
     plViewTransform.h
 )
diff --git a/Sources/Plasma/CoreLib/plString.cpp b/Sources/Plasma/CoreLib/plString.cpp
new file mode 100644
index 00000000..9db20ea8
--- /dev/null
+++ b/Sources/Plasma/CoreLib/plString.cpp
@@ -0,0 +1,662 @@
+/*==LICENSE==*
+
+CyanWorlds.com Engine - MMOG client, server and tools
+Copyright (C) 2011  Cyan Worlds, Inc.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+You can contact Cyan Worlds, Inc. by email legal@cyan.com
+ or by snail mail at:
+      Cyan Worlds, Inc.
+      14617 N Newport Hwy
+      Mead, WA   99021
+
+*==LICENSE==*/
+
+#include "plString.h"
+
+#include <cstring>
+#include <cstdlib>
+
+const plString plString::Null;
+
+#if !defined(WCHAR_BYTES) || (WCHAR_BYTES != 2) && (WCHAR_BYTES != 4)
+#error "WCHAR_BYTES must be either 2 (16-bit) or 4 (32-bit)!"
+#endif
+
+#if WCHAR_BYTES == 2
+#define u16slen(str, max) wcsnlen((const wchar_t *)(str), (max))
+#else
+static inline size_t u16slen(const UInt16 *ustr, size_t max)
+{
+    size_t length = 0;
+    for ( ; *ustr++ && max--; ++length)
+        ;
+    return length;
+}
+#endif
+
+#define BADCHAR_REPLACEMENT (0xFFFDul)
+
+void plString::IConvertFromUtf8(const char *utf8, size_t size, bool steal)
+{
+    if ((long)size < 0)
+        size = strnlen(utf8, -(long)size);
+
+#ifdef _DEBUG
+    // Check to make sure the string is actually valid UTF-8
+    const char *sp = utf8;
+    while (sp < utf8 + size) {
+        unsigned char unichar = *sp++;
+        if ((unichar & 0xF8) == 0xF0) {
+            // Four bytes
+            hsAssert((*sp++) & 0x80, "Invalid UTF-8 sequence byte (1)");
+            hsAssert((*sp++) & 0x80, "Invalid UTF-8 sequence byte (2)");
+            hsAssert((*sp++) & 0x80, "Invalid UTF-8 sequence byte (3)");
+        } else if ((unichar & 0xF0) == 0xE0) {
+            // Three bytes
+            hsAssert((*sp++) & 0x80, "Invalid UTF-8 sequence byte (1)");
+            hsAssert((*sp++) & 0x80, "Invalid UTF-8 sequence byte (2)");
+        } else if ((unichar & 0xE0) == 0xC0) {
+            // Two bytes
+            hsAssert((*sp++) & 0x80, "Invalid UTF-8 sequence byte (1)");
+        } else if ((unichar & 0xC0) == 0x80) {
+            hsAssert(0, "Invalid UTF-8 marker byte");
+        } else if ((unichar & 0x80) != 0) {
+            hsAssert(0, "UTF-8 character out of range");
+        }
+    }
+#endif
+
+    fUtf8Buffer = steal ? plStringBuffer<char>::Steal(utf8, size)
+                        : plStringBuffer<char>(utf8, size);
+}
+
+void plString::IConvertFromUtf16(const UInt16 *utf16, size_t size)
+{
+    if ((long)size < 0)
+        size = u16slen(utf16, -(long)size);
+
+    // Calculate the UTF-8 size
+    size_t convlen = 0;
+    const UInt16 *sp = utf16;
+    while (sp < utf16 + size) {
+        if (*sp >= 0xD800 && *sp <= 0xDFFF) {
+            // Surrogate pair
+            convlen += 4;
+            ++sp;
+        }
+        else if (*sp > 0x7FF)
+            convlen += 3;
+        else if (*sp > 0x7F)
+            convlen += 2;
+        else
+            convlen += 1;
+        ++sp;
+    }
+
+    // And perform the actual conversion
+    char *utf8 = TRACKED_NEW char[convlen + 1];
+    char *dp = utf8;
+    sp = utf16;
+    while (sp < utf16 + size) {
+        if (*sp >= 0xD800 && *sp <= 0xDFFF) {
+            // Surrogate pair
+            unsigned int unichar = 0x10000;
+
+            if (sp + 1 >= utf16 + size) {
+                hsAssert(0, "Incomplete surrogate pair in UTF-16 data");
+                unichar = BADCHAR_REPLACEMENT;
+            } else if (*sp < 0xDC00) {
+                unichar += (*sp++ & 0x3FF) << 10;
+                hsAssert(*sp >= 0xDC00 && *sp <= 0xDFFF,
+                         "Invalid surrogate pair in UTF-16 data");
+                unichar += (*sp   & 0x3FF);
+            } else {
+                unichar += (*sp++ & 0x3FF);
+                hsAssert(*sp >= 0xD800 && *sp <  0xDC00,
+                         "Invalid surrogate pair in UTF-16 data");
+                unichar += (*sp   & 0x3FF) << 10;
+            }
+            *dp++ = 0xF0 | ((unichar >> 18) & 0x07);
+            *dp++ = 0x80 | ((unichar >> 12) & 0x3F);
+            *dp++ = 0x80 | ((unichar >>  6) & 0x3F);
+            *dp++ = 0x80 | ((unichar      ) & 0x3F);
+        } else if (*sp > 0x7FF) {
+            *dp++ = 0xF0 | ((*sp >> 12) & 0x0F);
+            *dp++ = 0x80 | ((*sp >>  6) & 0x3F);
+            *dp++ = 0x80 | ((*sp      ) & 0x3F);
+        } else if (*sp > 0x7F) {
+            *dp++ = 0xF0 | ((*sp >>  6) & 0x1F);
+            *dp++ = 0x80 | ((*sp      ) & 0x3F);
+        } else {
+            *dp++ = (char)(*sp);
+        }
+        ++sp;
+    }
+    utf8[convlen] = 0;
+
+    fUtf8Buffer = plStringBuffer<char>::Steal(utf8, convlen);
+}
+
+void plString::IConvertFromWchar(const wchar_t *wstr, size_t size)
+{
+#if WCHAR_BYTES == 2
+    // We assume that if sizeof(wchar_t) == 2, the data is UTF-16 already
+    IConvertFromUtf16((const UInt16 *)wstr, size);
+#else
+    if ((long)size < 0)
+        size = wcsnlen(wstr, -(long)size);
+
+    // Calculate the UTF-8 size
+    size_t convlen = 0;
+    const wchar_t *sp = wstr;
+    while (sp < wstr + size) {
+        if (*sp > 0x10FFFF) {
+            hsAssert(0, "UCS-4 character out of range");
+            convlen += 3;   // Use U+FFFD for release builds
+        }
+        else if (*sp > 0xFFFF)
+            convlen += 4;
+        else if (*sp > 0x7FF)
+            convlen += 3;
+        else if (*sp > 0x7F)
+            convlen += 2;
+        else
+            convlen += 1;
+        ++sp;
+    }
+
+    // And perform the actual conversion
+    char *utf8 = TRACKED_NEW char[convlen + 1];
+    char *dp = utf8;
+    sp = wstr;
+    while (sp < wstr + size) {
+        if (*sp > 0x10FFFF) {
+            // Character out of range; Use U+FFFD instead
+            *dp++ = 0xE0 | ((BADCHAR_REPLACEMENT >> 12) & 0x0F);
+            *dp++ = 0x80 | ((BADCHAR_REPLACEMENT >>  6) & 0x3F);
+            *dp++ = 0x80 | ((BADCHAR_REPLACEMENT      ) & 0x3F);
+        } else if (*sp > 0xFFFF) {
+            *dp++ = 0xF0 | ((*sp >> 18) & 0x07);
+            *dp++ = 0x80 | ((*sp >> 12) & 0x3F);
+            *dp++ = 0x80 | ((*sp >>  6) & 0x3F);
+            *dp++ = 0x80 | ((*sp      ) & 0x3F);
+        } else if (*sp > 0x7FF) {
+            *dp++ = 0xF0 | ((*sp >> 12) & 0x0F);
+            *dp++ = 0x80 | ((*sp >>  6) & 0x3F);
+            *dp++ = 0x80 | ((*sp      ) & 0x3F);
+        } else if (*sp > 0x7F) {
+            *dp++ = 0xF0 | ((*sp >>  6) & 0x1F);
+            *dp++ = 0x80 | ((*sp      ) & 0x3F);
+        } else {
+            *dp++ = (char)(*sp);
+        }
+        ++sp;
+    }
+    utf8[convlen] = 0;
+
+    fUtf8Buffer = plStringBuffer<char>::Steal(utf8, convlen);
+#endif
+}
+
+void plString::IConvertFromIso8859_1(const char *astr, size_t size)
+{
+    if ((long)size < 0)
+        size = strnlen(astr, -(long)size);
+
+    // Calculate the UTF-8 size
+    size_t convlen = 0;
+    const char *sp = astr;
+    while (sp < astr + size) {
+        if ((*sp++) & 0x80)
+            convlen += 2;
+        else
+            convlen += 1;
+    }
+
+    // And perform the actual conversion
+    char *utf8 = TRACKED_NEW char[convlen + 1];
+    char *dp = utf8;
+    sp = astr;
+    while (sp < astr + size) {
+        if (*astr & 0x80) {
+            *dp++ = 0xC0 | ((*sp >> 6) & 0x1F);
+            *dp++ = 0x80 | ((*sp     ) & 0x3F);
+        } else {
+            *dp++ = *sp;
+        }
+        ++sp;
+    }
+    utf8[convlen] = 0;
+
+    fUtf8Buffer = plStringBuffer<char>::Steal(utf8, convlen);
+}
+
+plStringBuffer<UInt16> plString::ToUtf16() const
+{
+    if (IsNull())
+        return plStringBuffer<UInt16>();
+
+    // Calculate the UTF-16 size
+    size_t convlen = 0;
+    const char *utf8 = fUtf8Buffer.GetData();
+    const char *sp = utf8;
+    size_t srcSize = fUtf8Buffer.GetSize();
+    while (sp < utf8 + srcSize) {
+        if ((*sp & 0xF8) == 0xF0) {
+            // Will require a surrogate pair
+            ++convlen;
+            sp += 4;
+        }
+        else if ((*sp & 0xF0) == 0xE0) 
+            sp += 3;
+        else if ((*sp & 0xE0) == 0xC0)
+            sp += 2;
+        else
+            sp += 1;
+        ++convlen;
+    }
+
+    // And perform the actual conversion
+    UInt16 *ustr = TRACKED_NEW UInt16[convlen + 1];
+    UInt16 *dp = ustr;
+    sp = utf8;
+    while (sp < utf8 + srcSize) {
+        unsigned int unichar;
+        if ((*sp & 0xF8) == 0xF0) {
+            unichar  = (*sp++ & 0x07) << 18;
+            unichar |= (*sp++ & 0x3F) << 12;
+            unichar |= (*sp++ & 0x3F) << 6;
+            unichar |= (*sp++ & 0x3F);
+
+            *dp++ = 0xD800 | ((unichar >> 10) & 0x3FF);
+            *dp++ = 0xDC00 | ((unichar      ) & 0x3FF);
+        } else if ((*sp & 0xF0) == 0xE0) {
+            unichar  = (*sp++ & 0x0F) << 12;
+            unichar |= (*sp++ & 0x3F) << 6;
+            unichar |= (*sp++ & 0x3F);
+            *dp++ = unichar;
+        } else if ((*sp & 0xE0) == 0xC0) {
+            unichar  = (*sp++ & 0x1F) << 6;
+            unichar |= (*sp++ & 0x3F);
+            *dp++ = unichar;
+        } else {
+            *dp++ = *sp++;
+        }
+    }
+    ustr[convlen] = 0;
+
+    return plStringBuffer<UInt16>::Steal(ustr, convlen);
+}
+
+plStringBuffer<wchar_t> plString::ToWchar() const
+{
+#if WCHAR_BYTES == 2
+    // We assume that if sizeof(wchar_t) == 2, the data is UTF-16 already
+    plStringBuffer<UInt16> utf16 = ToUtf16();
+    return *reinterpret_cast<plStringBuffer<wchar_t>*>(&utf16);
+#else
+    if (IsNull())
+        return plStringBuffer<wchar_t>();
+
+    // Calculate the UCS-4 size
+    size_t convlen = 0;
+    const char *utf8 = fUtf8Buffer.GetData();
+    const char *sp = utf8;
+    size_t srcSize = fUtf8Buffer.GetSize();
+    while (sp < utf8 + srcSize) {
+        if ((*sp & 0xF8) == 0xF0)
+            sp += 4;
+        else if ((*sp & 0xF0) == 0xE0)
+            sp += 3;
+        else if ((*sp & 0xE0) == 0xC0)
+            sp += 2;
+        else
+            sp += 1;
+        ++convlen;
+    }
+
+    // And perform the actual conversion
+    wchar_t *wstr = TRACKED_NEW wchar_t[convlen + 1];
+    wchar_t *dp = wstr;
+    sp = utf8;
+    while (sp < utf8 + srcSize) {
+        unsigned int unichar;
+        if ((*sp & 0xF8) == 0xF0) {
+            unichar  = (*sp++ & 0x07) << 18;
+            unichar |= (*sp++ & 0x3F) << 12;
+            unichar |= (*sp++ & 0x3F) << 6;
+            unichar |= (*sp++ & 0x3F);
+        } else if ((*sp & 0xF0) == 0xE0) {
+            unichar  = (*sp++ & 0x0F) << 12;
+            unichar |= (*sp++ & 0x3F) << 6;
+            unichar |= (*sp++ & 0x3F);
+        } else if ((*sp & 0xE0) == 0xC0) {
+            unichar  = (*sp++ & 0x1F) << 6;
+            unichar |= (*sp++ & 0x3F);
+        } else {
+            unichar = *sp++;
+        }
+        *dp++ = unichar;
+    }
+    wstr[convlen] = 0;
+
+    return plStringBuffer<wchar_t>::Steal(wstr, convlen);
+#endif
+}
+
+plStringBuffer<char> plString::ToIso8859_1() const
+{
+    if (IsNull())
+        return plStringBuffer<char>();
+
+    // Calculate the ASCII size
+    size_t convlen = 0;
+    const char *utf8 = fUtf8Buffer.GetData();
+    const char *sp = utf8;
+    size_t srcSize = fUtf8Buffer.GetSize();
+    while (sp < utf8 + srcSize) {
+        if ((*sp & 0xF8) == 0xF0)
+            sp += 4;
+        else if ((*sp & 0xF0) == 0xE0)
+            sp += 3;
+        else if ((*sp & 0xE0) == 0xC0)
+            sp += 2;
+        else
+            sp += 1;
+        ++convlen;
+    }
+
+    // And perform the actual conversion
+    char *astr = TRACKED_NEW char[convlen + 1];
+    char *dp = astr;
+    sp = utf8;
+    while (sp < utf8 + srcSize) {
+        unsigned int unichar;
+        if ((*sp & 0xF8) == 0xF0) {
+            unichar  = (*sp++ & 0x07) << 18;
+            unichar |= (*sp++ & 0x3F) << 12;
+            unichar |= (*sp++ & 0x3F) << 6;
+            unichar |= (*sp++ & 0x3F);
+        } else if ((*sp & 0xF0) == 0xE0) {
+            unichar  = (*sp++ & 0x0F) << 12;
+            unichar |= (*sp++ & 0x3F) << 6;
+            unichar |= (*sp++ & 0x3F);
+        } else if ((*sp & 0xE0) == 0xC0) {
+            unichar  = (*sp++ & 0x1F) << 6;
+            unichar |= (*sp++ & 0x3F);
+        } else {
+            unichar = *sp++;
+        }
+        *dp++ = (unichar < 0xFF) ? unichar : '?';
+    }
+    astr[convlen] = 0;
+
+    return plStringBuffer<char>::Steal(astr, convlen);
+}
+
+plStringBuffer<UniChar> plString::GetUnicodeArray() const
+{
+    static UniChar empty[1] = {0};
+
+    if (IsNull())
+        return plStringBuffer<UniChar>(empty, 0);
+
+    size_t convlen = GetUniCharCount();
+    UniChar *ustr = new UniChar[convlen + 1];
+    iterator iter = GetIterator();
+    size_t dp = 0;
+    while (!iter.AtEnd())
+        ustr[dp++] = *iter++;
+    ustr[convlen] = 0;
+    return plStringBuffer<UniChar>::Steal(ustr, convlen);
+}
+
+int plString::ToInt(int base) const
+{
+    return static_cast<int>(strtol(s_str(), nil, base));
+}
+
+unsigned int plString::ToUInt(int base) const
+{
+    return static_cast<unsigned int>(strtoul(s_str(), nil, base));
+}
+
+float plString::ToFloat() const
+{
+    // strtof is C99, which MS doesn't support...
+    return (float)strtod(s_str(), nil);
+}
+
+double plString::ToDouble() const
+{
+    return strtod(s_str(), nil);
+}
+
+// Microsoft doesn't provide this for us
+#ifdef _MSC_VER
+#define va_copy(dest, src)  (dest) = (src)
+#endif
+
+plString plString::IFormat(const char *fmt, va_list vptr)
+{
+    char buffer[256];
+    va_list vptr_save;
+    va_copy(vptr_save, vptr);
+
+    int chars = vsnprintf(buffer, 256, fmt, vptr);
+    if (chars < 0) {
+        // We will need to try this multiple times until we get a
+        // large enough buffer :(
+        int size = 4096;
+        for ( ;; ) {
+            va_copy(vptr, vptr_save);
+            char *bigbuffer = TRACKED_NEW char[size];
+            chars = vsnprintf(bigbuffer, size, fmt, vptr);
+            if (chars >= 0)
+                return plString::Steal(bigbuffer);
+
+            delete [] bigbuffer;
+            size *= 2;
+        }
+    } else if (chars >= 256) {
+        va_copy(vptr, vptr_save);
+        char *bigbuffer = TRACKED_NEW char[chars+1];
+        vsnprintf(bigbuffer, chars+1, fmt, vptr);
+        return plString::Steal(bigbuffer);
+    }
+
+    return plString::FromUtf8(buffer);
+}
+
+plString plString::Format(const char *fmt, ...)
+{
+    va_list vptr;
+    va_start(vptr, fmt);
+    plString str = IFormat(fmt, vptr);
+    va_end(vptr);
+    return str;
+}
+
+int plString::Find(char ch, CaseSense sense) const
+{
+    if (sense == kCaseSensitive) {
+        const char *cp = strchr(s_str(), ch);
+        return cp ? (cp - c_str()) : -1;
+    } else {
+        // No need to check for null, since s_str() will return { 0 } if it is null
+        const char *cp = s_str();
+        while (*cp) {
+            if (tolower(*cp) == tolower(ch))
+                return cp - c_str();
+        }
+        return -1;
+    }
+}
+
+int plString::FindReverse(char ch, CaseSense sense) const
+{
+    if (IsEmpty())
+        return -1;
+
+    if (sense == kCaseSensitive) {
+        const char *cp = strrchr(s_str(), ch);
+        return cp ? (cp - c_str()) : -1;
+    } else {
+        const char *cp = c_str();
+        cp += strlen(cp);
+
+        while (--cp >= c_str()) {
+            if (tolower(*cp) == tolower(ch))
+                return cp - c_str();
+        }
+        return -1;
+    }
+}
+
+static bool in_set(char key, const char *charset)
+{
+    for (const char *cs = charset; *cs; ++cs) {
+        if (*cs == key)
+            return true;
+    }
+    return false;
+}
+
+plString plString::TrimLeft(const char *charset) const
+{
+    if (IsEmpty())
+        return Null;
+
+    const char *cp = c_str();
+    while (*cp && in_set(*cp, charset))
+        ++cp;
+
+    return Substr(cp - c_str());
+}
+
+plString plString::TrimRight(const char *charset) const
+{
+    if (IsEmpty())
+        return Null;
+
+    const char *cp = c_str();
+    cp += strlen(cp);
+
+    while (--cp >= c_str() && in_set(*cp, charset))
+        ;
+
+    return Substr(0, cp - c_str() + 1);
+}
+
+plString plString::Trim(const char *charset) const
+{
+    if (IsEmpty())
+        return Null;
+
+    const char *lp = c_str();
+    const char *rp = lp + strlen(lp);
+
+    while (*lp && in_set(*lp, charset))
+        ++lp;
+    while (--rp >= lp && in_set(*rp, charset))
+        ;
+
+    return Substr(lp - c_str(), rp - lp + 1);
+}
+
+plString plString::Substr(int start, size_t size) const
+{
+    size_t maxSize = GetSize();
+
+    if (start > maxSize)
+        return Null;
+    if (start < 0)
+        start = 0;
+    if (start + size > maxSize)
+        size = maxSize - start;
+
+    if (start == 0 && size == maxSize)
+        return *this;
+
+    char *substr = TRACKED_NEW char[size + 1];
+    memcpy(substr, c_str() + start, size);
+    substr[size] = 0;
+
+    // Don't re-check UTF-8 on this
+    plString str;
+    str.fUtf8Buffer.Steal(substr, size);
+    return str;
+}
+
+plString &plString::operator+=(const plString &str)
+{
+    size_t catsize = GetSize() + str.GetSize();
+    char *catstr = TRACKED_NEW char[catsize + 1];
+    memcpy(catstr, s_str(), GetSize());
+    memcpy(catstr + GetSize(), str.s_str(), str.GetSize());
+    catstr[catsize] = 0;
+    fUtf8Buffer.Steal(catstr, catsize);
+    return *this;
+}
+
+plString operator+(const plString &left, const plString &right)
+{
+    size_t catsize = left.GetSize() + right.GetSize();
+    char *catstr = TRACKED_NEW char[catsize + 1];
+    memcpy(catstr, left.s_str(), left.GetSize());
+    memcpy(catstr + left.GetSize(), right.s_str(), right.GetSize());
+    catstr[catsize] = 0;
+
+    // Don't re-check UTF-8 on this
+    plString str;
+    str.fUtf8Buffer.Steal(catstr, catsize);
+    return str;
+}
+
+plStringStream &plStringStream::operator<<(const char *text)
+{
+    size_t length = strlen(text);
+    if (fLength + length > fBufSize) {
+        char *bigger = new char[fBufSize * 2];
+        memcpy(bigger, fBuffer, fBufSize);
+        delete [] fBuffer;
+        fBuffer = bigger;
+        fBufSize *= 2;
+    }
+    memcpy(fBuffer + fLength, text, length);
+    fLength += length;
+    return *this;
+}
+
+plStringStream &plStringStream::operator<<(int num)
+{
+    char buffer[12];
+    snprintf(buffer, 12, "%d", num);
+    return operator<<(buffer);
+}
+
+plStringStream &plStringStream::operator<<(unsigned int num)
+{
+    char buffer[12];
+    snprintf(buffer, 12, "%u", num);
+    return operator<<(buffer);
+}
+
+plStringStream &plStringStream::operator<<(char ch)
+{
+    char buffer[2] = { ch, 0 };
+    return operator<<(buffer);
+}
diff --git a/Sources/Plasma/CoreLib/plString.h b/Sources/Plasma/CoreLib/plString.h
new file mode 100644
index 00000000..368b4a96
--- /dev/null
+++ b/Sources/Plasma/CoreLib/plString.h
@@ -0,0 +1,387 @@
+/*==LICENSE==*
+
+CyanWorlds.com Engine - MMOG client, server and tools
+Copyright (C) 2011  Cyan Worlds, Inc.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+You can contact Cyan Worlds, Inc. by email legal@cyan.com
+ or by snail mail at:
+      Cyan Worlds, Inc.
+      14617 N Newport Hwy
+      Mead, WA   99021
+
+*==LICENSE==*/
+
+#ifndef plString_Defined
+#define plString_Defined
+
+#include "hsTypes.h"
+#include "hsUtils.h"
+#include <stddef.h>
+#include <vector>
+#include <functional>
+
+#define _TEMP_CONVERT_FROM_LITERAL(x)   plString::FromUtf8((x))
+#define _TEMP_CONVERT_FROM_WCHAR_T(x)   plString::FromWchar((x))
+
+typedef unsigned int UniChar;
+
+template <typename _Ch>
+class plStringBuffer
+{
+private:
+    struct StringRef
+    {
+        unsigned int fRefs;
+        const _Ch *fStringData;
+        const size_t fSize;
+
+        StringRef(const _Ch *data, const size_t size)
+            : fRefs(1), fStringData(data), fSize(size) { }
+
+        inline void AddRef() { ++fRefs; }
+        inline void DecRef()
+        {
+            if (--fRefs == 0) {
+                delete [] fStringData;
+                delete this;
+            }
+        }
+    };
+
+    StringRef *fData;
+
+public:
+    plStringBuffer() : fData(0) { }
+
+    plStringBuffer(const plStringBuffer<_Ch> &copy)
+    {
+        fData = copy.fData;
+        if (fData)
+            fData->AddRef();
+    }
+
+    plStringBuffer(const _Ch *data, size_t size)
+    {
+        _Ch *copyData = new _Ch[size + 1];
+        memcpy(copyData, data, size);
+        copyData[size] = 0;
+
+        fData = new StringRef(copyData, size);
+    }
+
+    ~plStringBuffer<_Ch>()
+    {
+        if (fData)
+            fData->DecRef();
+    }
+
+    static plStringBuffer<_Ch> Steal(const _Ch *data, size_t size)
+    {
+        plStringBuffer<_Ch> string;
+        string.fData = new StringRef(data, size);
+        return string;
+    }
+
+    plStringBuffer<_Ch> &operator=(const plStringBuffer<_Ch> &copy)
+    {
+        if (copy.fData)
+            copy.fData->AddRef();
+        if (fData)
+            fData->DecRef();
+        fData = copy.fData;
+        return *this;
+    }
+
+    const _Ch *GetData() const { return fData ? fData->fStringData : 0; }
+    const size_t GetSize() const { return fData ? fData->fSize : 0; }
+};
+
+
+class plString
+{
+#pragma warning(push)
+#pragma warning(disable : 4146)
+    enum {
+        kSizeAuto = (size_t)(-2147483648L)
+    };
+#pragma warning(pop)
+
+    enum CaseSense {
+        kCaseSensitive, kCaseInsensitive
+    };
+
+public:
+    static const plString Null;
+
+private:
+    plStringBuffer<char> fUtf8Buffer;
+
+    void IConvertFromUtf8(const char *utf8, size_t size, bool steal);
+    void IConvertFromUtf16(const UInt16 *utf16, size_t size);
+    void IConvertFromWchar(const wchar_t *wstr, size_t size);
+    void IConvertFromIso8859_1(const char *astr, size_t size);
+
+public:
+    plString() { }
+
+    //plString(const char *utf8) { IConvertFromUtf8(utf8, kSizeAuto, false); }
+    //plString(const wchar_t *wstr) { IConvertFromWchar(wstr, kSizeAuto); }
+    plString(const plString &copy) : fUtf8Buffer(copy.fUtf8Buffer) { }
+
+    //plString &operator=(const char *utf8) { IConvertFromUtf8(utf8, kSizeAuto, false); return *this; }
+    //plString &operator=(const wchar_t *wstr) { IConvertFromWchar(wstr, kSizeAuto); return *this; }
+    plString &operator=(const plString &copy) { fUtf8Buffer = copy.fUtf8Buffer; return *this; }
+
+    plString &operator+=(const plString &str);
+
+    static inline plString FromUtf8(const char *utf8, size_t size = kSizeAuto)
+    {
+        plString str;
+        str.IConvertFromUtf8(utf8, size, false);
+        return str;
+    }
+
+    static inline plString FromUtf16(const UInt16 *utf16, size_t size = kSizeAuto)
+    {
+        plString str;
+        str.IConvertFromUtf16(utf16, size);
+        return str;
+    }
+
+    static inline plString FromWchar(const wchar_t *wstr, size_t size = kSizeAuto)
+    {
+        plString str;
+        str.IConvertFromWchar(wstr, size);
+        return str;
+    }
+
+    static inline plString FromIso8859_1(const char *astr, size_t size = kSizeAuto)
+    {
+        plString str;
+        str.IConvertFromIso8859_1(astr, size);
+        return str;
+    }
+
+    const char *c_str() const { return fUtf8Buffer.GetData(); }
+    const char *s_str() const { return c_str() ? c_str() : ""; }
+    plStringBuffer<char> ToUtf8() const { return fUtf8Buffer; }
+    plStringBuffer<UInt16> ToUtf16() const;
+    plStringBuffer<wchar_t> ToWchar() const;
+    plStringBuffer<char> ToIso8859_1() const;
+
+    // For use in displaying characters in a GUI
+    plStringBuffer<UniChar> GetUnicodeArray() const;
+
+    size_t GetSize() const { return fUtf8Buffer.GetSize(); }
+    bool IsEmpty() const { return fUtf8Buffer.GetSize() == 0; }
+    bool IsNull() const { return fUtf8Buffer.GetData() == 0; }
+
+    int ToInt(int base = 0) const;
+    unsigned int ToUInt(int base = 0) const;
+    float ToFloat() const;
+    double ToDouble() const;
+
+    static plString Format(const char *fmt, ...);
+    static plString IFormat(const char *fmt, va_list vptr);
+    static plString Steal(const char *utf8, size_t size = kSizeAuto)
+    {
+        plString str;
+        str.IConvertFromUtf8(utf8, size, true);
+        return str;
+    }
+
+    int Compare(const plString &str, CaseSense sense = kCaseSensitive) const
+    {
+        return (sense == kCaseSensitive) ? strcmp(s_str(), str.s_str())
+                                         : stricmp(s_str(), str.s_str());
+    }
+
+    int Compare(const char *str, CaseSense sense = kCaseSensitive) const
+    {
+        return (sense == kCaseSensitive) ? strcmp(s_str(), str)
+                                         : stricmp(s_str(), str);
+    }
+
+    bool operator==(const plString &other) const { return Compare(other) == 0; }
+    bool operator!=(const plString &other) const { return Compare(other) != 0; }
+
+    int Find(char ch, CaseSense sense = kCaseSensitive) const;
+    int FindReverse(char ch, CaseSense sense = kCaseSensitive) const;
+
+    plString TrimLeft(const char *charset = " \t\n\r") const;
+    plString TrimRight(const char *charset = " \t\n\r") const;
+    plString Trim(const char *charset = " \t\n\r") const;
+
+    plString Substr(int start, size_t size = kSizeAuto) const;
+    plString Left(size_t size) const { return Substr(0, size); }
+    plString Right(size_t size) const { return Substr(GetSize() - size, size); }
+
+public:
+    struct less : public std::binary_function<plString, plString, bool>
+    {
+        bool operator()(const plString &_L, const plString &_R) const
+        { return _L.Compare(_R, kCaseSensitive) < 0; }
+    };
+
+    struct less_i : public std::binary_function<plString, plString, bool>
+    {
+        bool operator()(const plString &_L, const plString &_R) const
+        { return _L.Compare(_R, kCaseInsensitive) < 0; }
+    };
+
+    struct equal : public std::binary_function<plString, plString, bool>
+    {
+        bool operator()(const plString &_L, const plString &_R) const
+        { return _L.Compare(_R, kCaseSensitive) == 0; }
+    };
+
+    struct equal_i : public std::binary_function<plString, plString, bool>
+    {
+        bool operator()(const plString &_L, const plString &_R) const
+        { return _L.Compare(_R, kCaseInsensitive) == 0; }
+    };
+
+public:
+    struct iterator
+    {
+        iterator() : m_ptr(nil), m_end(nil) { }
+        iterator(const iterator &copy) : m_ptr(copy.m_ptr), m_end(copy.m_end) { }
+
+        iterator &operator=(const iterator &copy)
+        { m_ptr = copy.m_ptr; m_end = copy.m_end; return *this; }
+
+        iterator &operator++()
+        {
+            if ((*m_ptr & 0xF8) == 0xF0)
+                m_ptr += 4;
+            else if ((*m_ptr & 0xF0) == 0xE0)
+                m_ptr += 3;
+            else if ((*m_ptr & 0xE0) == 0xC0)
+                m_ptr += 2;
+            else
+                m_ptr += 1;
+            return *this;
+        }
+
+        iterator &operator+=(size_t delta)
+        {
+            while (delta) {
+                operator++();
+                --delta;
+            }
+            return *this;
+        }
+
+        iterator operator+(size_t delta) const
+        {
+            iterator copy(*this);
+            copy += delta;
+            return copy;
+        }
+
+        int operator-(const iterator &other) const
+        {
+            return (int)(m_ptr - other.m_ptr);
+        }
+
+        bool operator==(const iterator &other) const { return m_ptr == other.m_ptr; }
+        bool operator!=(const iterator &other) const { return m_ptr != other.m_ptr; }
+        bool operator<(const iterator &other) const { return m_ptr < other.m_ptr; }
+        bool operator>(const iterator &other) const { return m_ptr > other.m_ptr; }
+        bool operator<=(const iterator &other) const { return m_ptr <= other.m_ptr; }
+        bool operator>=(const iterator &other) const { return m_ptr >= other.m_ptr; }
+
+        UniChar operator*() const
+        {
+            UniChar ch;
+            if ((*m_ptr & 0xF8) == 0xF0) {
+                ch  = (m_ptr[0] & 0x07) << 18;
+                ch |= (m_ptr[1] & 0x3F) << 12;
+                ch |= (m_ptr[2] & 0x3F) << 6;
+                ch |= (m_ptr[3] & 0x3F);
+            } else if ((*m_ptr & 0xF0) == 0xE0) {
+                ch  = (m_ptr[0] & 0x0F) << 12;
+                ch |= (m_ptr[1] & 0x3F) << 6;
+                ch |= (m_ptr[2] & 0x3F);
+            } else if ((*m_ptr & 0xE0) == 0xC0) {
+                ch  = (m_ptr[0] & 0x1F) << 6;
+                ch |= (m_ptr[1] & 0x3F);
+            } else {
+                ch = m_ptr[0];
+            }
+            return ch;
+        }
+
+        bool AtEnd() const { return m_ptr >= m_end; }
+        bool IsValid() const { return m_ptr != 0; }
+
+    private:
+        friend class plString;
+        iterator(const char *ptr, size_t size) : m_ptr(ptr), m_end(ptr + size) { }
+
+        const char *m_ptr;
+        const char *m_end;
+    };
+
+    iterator GetIterator() const { return iterator(s_str(), GetSize()); }
+
+    size_t GetUniCharCount() const
+    {
+        iterator iter = GetIterator();
+        size_t count = 0;
+        while (!iter.AtEnd()) {
+            ++iter;
+            ++count;
+        }
+        return count;
+    }
+
+private:
+    friend plString operator+(const plString &left, const plString &right);
+};
+
+plString operator+(const plString &left, const plString &right);
+
+
+class plStringStream
+{
+public:
+    plStringStream() : fBufSize(256), fLength(0)
+    {
+        fBuffer = new char[fBufSize];
+    }
+    ~plStringStream() { delete [] fBuffer; }
+
+    plStringStream &operator<<(const char *text);
+    plStringStream &operator<<(int num);
+    plStringStream &operator<<(unsigned int num);
+    plStringStream &operator<<(char ch);
+
+    plStringStream &operator<<(const plString &text)
+    {
+        return operator<<(text.s_str());
+    }
+
+    size_t GetLength() const { return fLength; }
+    plString GetString() { return plString::FromUtf8(fBuffer, fLength); }
+
+private:
+    char *fBuffer;
+    size_t fBufSize;
+    size_t fLength;
+};
+
+#endif //plString_Defined

From a1852ad385ea5c18c1c1b8cbd53d94acc9014678 Mon Sep 17 00:00:00 2001
From: Michael Hansen <zrax0111@gmail.com>
Date: Wed, 25 Jan 2012 21:17:35 -0800
Subject: [PATCH 02/11] Convert plUUID and its cascade of dependencies to
 plString

---
 Sources/Plasma/CoreLib/hsStream.h             |  1 +
 .../FeatureLib/pfPython/pyAgeInfoStruct.cpp   | 12 ++---
 .../FeatureLib/pfPython/pyAgeInfoStruct.h     |  9 ++--
 .../pfPython/pyNetServerSessionInfo.h         |  4 +-
 .../Plasma/NucleusLib/pnMessage/plMessage.cpp | 28 ++++++++++
 .../Plasma/NucleusLib/pnMessage/plMessage.h   |  5 ++
 Sources/Plasma/NucleusLib/pnUUID/pnUUID.cpp   | 13 +++--
 Sources/Plasma/NucleusLib/pnUUID/pnUUID.h     |  9 ++--
 .../Plasma/NucleusLib/pnUUID/pnUUID_Win32.cpp | 11 ++--
 .../PubUtilLib/plNetCommon/plClientGuid.cpp   | 27 +++++-----
 .../PubUtilLib/plNetCommon/plClientGuid.h     | 18 +++----
 .../plNetCommon/plNetServerSessionInfo.cpp    | 32 ++++++------
 .../plNetCommon/plNetServerSessionInfo.h      |  8 +--
 .../PubUtilLib/plNetMessage/plNetMessage.cpp  | 15 ++----
 .../PubUtilLib/plNetMessage/plNetMessage.h    | 52 +++++++------------
 .../plNetMessage/plNetMsgHelpers.cpp          |  2 +-
 16 files changed, 135 insertions(+), 111 deletions(-)

diff --git a/Sources/Plasma/CoreLib/hsStream.h b/Sources/Plasma/CoreLib/hsStream.h
index 6e0bfdeb..32b390d6 100644
--- a/Sources/Plasma/CoreLib/hsStream.h
+++ b/Sources/Plasma/CoreLib/hsStream.h
@@ -46,6 +46,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 
 #include "hsTypes.h"
 #include "hsMemory.h"
+#include "plString.h"
 
 namespace hsPackFileSys {
 struct FileEntry;
diff --git a/Sources/Plasma/FeatureLib/pfPython/pyAgeInfoStruct.cpp b/Sources/Plasma/FeatureLib/pfPython/pyAgeInfoStruct.cpp
index 84a5dec3..d7aa3e49 100644
--- a/Sources/Plasma/FeatureLib/pfPython/pyAgeInfoStruct.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/pyAgeInfoStruct.cpp
@@ -117,7 +117,7 @@ void pyAgeInfoStruct::SetAgeDescription( const char * v )
 
 const char * pyAgeInfoStruct::GetAgeInstanceGuid() const
 {
-    fAgeInstanceGuidStr = fAgeInfo.GetAgeInstanceGuid()->AsStdString();
+    fAgeInstanceGuidStr = fAgeInfo.GetAgeInstanceGuid()->AsString();
     return fAgeInstanceGuidStr.c_str();
 }
 
@@ -161,9 +161,9 @@ const char * pyAgeInfoStruct::GetDisplayName() const
 {
     Int32 seq = GetAgeSequenceNumber();
     if ( seq>0 )
-        xtl::format( fDisplayName, "%s (%d) %s", GetAgeUserDefinedName(), seq, GetAgeInstanceName() );
+        fDisplayName = plString::Format( "%s (%d) %s", GetAgeUserDefinedName(), seq, GetAgeInstanceName() );
     else
-        xtl::format( fDisplayName, "%s %s", GetAgeUserDefinedName(), GetAgeInstanceName() );
+        fDisplayName = plString::Format( "%s %s", GetAgeUserDefinedName(), GetAgeInstanceName() );
     return fDisplayName.c_str();
 }
 
@@ -214,7 +214,7 @@ void pyAgeInfoStructRef::SetAgeUserDefinedName( const char * v )
 
 const char * pyAgeInfoStructRef::GetAgeInstanceGuid() const
 {
-    fAgeInstanceGuidStr = fAgeInfo.GetAgeInstanceGuid()->AsStdString();
+    fAgeInstanceGuidStr = fAgeInfo.GetAgeInstanceGuid()->AsString();
     return fAgeInstanceGuidStr.c_str();
 }
 
@@ -237,8 +237,8 @@ const char * pyAgeInfoStructRef::GetDisplayName() const
 {
     Int32 seq = GetAgeSequenceNumber();
     if ( seq>0 )
-        xtl::format( fDisplayName, "%s (%d) %s", GetAgeUserDefinedName(), seq, GetAgeInstanceName() );
+        fDisplayName = plString::Format( "%s (%d) %s", GetAgeUserDefinedName(), seq, GetAgeInstanceName() );
     else
-        xtl::format( fDisplayName, "%s %s", GetAgeUserDefinedName(), GetAgeInstanceName() );
+        fDisplayName = plString::Format( "%s %s", GetAgeUserDefinedName(), GetAgeInstanceName() );
     return fDisplayName.c_str();
 }
diff --git a/Sources/Plasma/FeatureLib/pfPython/pyAgeInfoStruct.h b/Sources/Plasma/FeatureLib/pfPython/pyAgeInfoStruct.h
index 73ec698b..37834c5b 100644
--- a/Sources/Plasma/FeatureLib/pfPython/pyAgeInfoStruct.h
+++ b/Sources/Plasma/FeatureLib/pfPython/pyAgeInfoStruct.h
@@ -57,14 +57,15 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 
 class pyVaultAgeInfoNode;
 class pyAgeInfoStructRef;
+class plString;
 
 
 class pyAgeInfoStruct
 {
 private:
     plAgeInfoStruct fAgeInfo;
-    mutable std::string fAgeInstanceGuidStr;    // for getting Age Instance GUID
-    mutable std::string fDisplayName;           // used by GetDisplayName()
+    mutable plString fAgeInstanceGuidStr;    // for getting Age Instance GUID
+    mutable plString fDisplayName;           // used by GetDisplayName()
 
 protected:
     pyAgeInfoStruct();
@@ -112,8 +113,8 @@ private:
     static plAgeInfoStruct fDefaultAgeInfo; // created so a default constructor could be made for python. Do NOT use
 
     plAgeInfoStruct & fAgeInfo;
-    mutable std::string fAgeInstanceGuidStr;    // for getting Age Instance GUID
-    mutable std::string fDisplayName;           // used by GetDisplayName()
+    mutable plString fAgeInstanceGuidStr;   // for getting Age Instance GUID
+    mutable plString fDisplayName;          // used by GetDisplayName()
 
 protected:
     pyAgeInfoStructRef(): fAgeInfo( fDefaultAgeInfo ) {} // only here for the python glue... do NOT call directly
diff --git a/Sources/Plasma/FeatureLib/pfPython/pyNetServerSessionInfo.h b/Sources/Plasma/FeatureLib/pfPython/pyNetServerSessionInfo.h
index f6320204..ebe01c10 100644
--- a/Sources/Plasma/FeatureLib/pfPython/pyNetServerSessionInfo.h
+++ b/Sources/Plasma/FeatureLib/pfPython/pyNetServerSessionInfo.h
@@ -92,7 +92,7 @@ public:
     UInt8           GetServerType() const { return fInfo.GetServerType(); }
     const char *    GetServerAddr() const { return fInfo.GetServerAddr(); }
     UInt16          GetServerPort() const { return fInfo.GetServerPort(); }
-    const char *    GetServerGuid() const { fServerGuid.CopyFrom( fInfo.GetServerGuid() ); return fServerGuid.AsString(); }
+    const char *    GetServerGuid() const { fServerGuid.CopyFrom( fInfo.GetServerGuid() ); return fServerGuid.AsString().c_str(); }
 };
 
 
@@ -132,7 +132,7 @@ public:
     UInt8           GetServerType() const { return fInfo.GetServerType(); }
     const char *    GetServerAddr() const { return fInfo.GetServerAddr(); }
     UInt16          GetServerPort() const { return fInfo.GetServerPort(); }
-    const char *    GetServerGuid() const { fServerGuid.CopyFrom( fInfo.GetServerGuid() ); return fServerGuid.AsString(); }
+    const char *    GetServerGuid() const { fServerGuid.CopyFrom( fInfo.GetServerGuid() ); return fServerGuid.AsString().c_str(); }
 };
 
 
diff --git a/Sources/Plasma/NucleusLib/pnMessage/plMessage.cpp b/Sources/Plasma/NucleusLib/pnMessage/plMessage.cpp
index cc4177e6..86b7abff 100644
--- a/Sources/Plasma/NucleusLib/pnMessage/plMessage.cpp
+++ b/Sources/Plasma/NucleusLib/pnMessage/plMessage.cpp
@@ -256,6 +256,18 @@ int plMsgStdStringHelper::PokeBig(const char * buf, UInt32 bufsz, hsStream* stre
     return stream->GetPosition();
 }
 
+int plMsgStdStringHelper::Poke(const plString & stringref, hsStream* stream, const UInt32 peekOptions)
+{
+    std::string temp = stringref.c_str();
+    return Poke(temp, stream, peekOptions);
+}
+
+int plMsgStdStringHelper::PokeBig(const plString & stringref, hsStream* stream, const UInt32 peekOptions)
+{
+    std::string temp = stringref.c_str();
+    return PokeBig(temp, stream, peekOptions);
+}
+
 // STATIC
 int plMsgStdStringHelper::Peek(std::string  & stringref, hsStream* stream, const UInt32 peekOptions)
 {
@@ -301,6 +313,22 @@ int plMsgStdStringHelper::PeekBig(std::string  & stringref, hsStream* stream, co
     return stream->GetPosition();
 }
 
+int plMsgStdStringHelper::Peek(plString  & stringref, hsStream* stream, const UInt32 peekOptions)
+{
+    std::string temp;
+    int pos = Peek(temp, stream, peekOptions);
+    stringref = plString::FromIso8859_1(temp.c_str(), temp.size());
+    return pos;
+}
+
+int plMsgStdStringHelper::PeekBig(plString  & stringref, hsStream* stream, const UInt32 peekOptions)
+{
+    std::string temp;
+    int pos = PeekBig(temp, stream, peekOptions);
+    stringref = plString::FromIso8859_1(temp.c_str(), temp.size());
+    return pos;
+}
+
 /////////////////////////////////////////////////////////////////
 
 // STATIC
diff --git a/Sources/Plasma/NucleusLib/pnMessage/plMessage.h b/Sources/Plasma/NucleusLib/pnMessage/plMessage.h
index b5b31709..6a53a8d0 100644
--- a/Sources/Plasma/NucleusLib/pnMessage/plMessage.h
+++ b/Sources/Plasma/NucleusLib/pnMessage/plMessage.h
@@ -50,6 +50,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 
 class plKey;
 class hsStream;
+class plString;
 
 // Base class for messages only has enough info to route it
 // and send it over the wire (Read/Write).
@@ -171,8 +172,12 @@ struct plMsgStdStringHelper
     static int PokeBig(const std::string & stringref, hsStream* stream, const UInt32 peekOptions=0);
     static int Poke(const char * buf, UInt32 bufsz, hsStream* stream, const UInt32 peekOptions=0);
     static int PokeBig(const char * buf, UInt32 bufsz, hsStream* stream, const UInt32 peekOptions=0);
+    static int Poke(const plString & stringref, hsStream* stream, const UInt32 peekOptions=0);
+    static int PokeBig(const plString & stringref, hsStream* stream, const UInt32 peekOptions=0);
     static int Peek(std::string & stringref, hsStream* stream, const UInt32 peekOptions=0);
     static int PeekBig(std::string & stringref, hsStream* stream, const UInt32 peekOptions=0);
+    static int Peek(plString & stringref, hsStream* stream, const UInt32 peekOptions=0);
+    static int PeekBig(plString & stringref, hsStream* stream, const UInt32 peekOptions=0);
 };
 
 /////////////////////////////////////////////////////////////////
diff --git a/Sources/Plasma/NucleusLib/pnUUID/pnUUID.cpp b/Sources/Plasma/NucleusLib/pnUUID/pnUUID.cpp
index f6c6073e..b447b508 100644
--- a/Sources/Plasma/NucleusLib/pnUUID/pnUUID.cpp
+++ b/Sources/Plasma/NucleusLib/pnUUID/pnUUID.cpp
@@ -47,6 +47,11 @@ plUUID::plUUID()
     Clear();
 }
 
+plUUID::plUUID( const plString & s )
+{
+    FromString( s );
+}
+
 plUUID::plUUID( const char * s )
 {
     FromString( s );
@@ -68,8 +73,8 @@ void plUUID::Write( hsStream * s)
     s->Write( sizeof( fData ), (const void*)fData );
 }
 
-const char * plUUID::AsString() const {
-    static std::string str;
-    ToStdString(str);
-    return str.c_str();
+plString plUUID::AsString() const {
+    plString str;
+    ToString(str);
+    return str;
 }
diff --git a/Sources/Plasma/NucleusLib/pnUUID/pnUUID.h b/Sources/Plasma/NucleusLib/pnUUID/pnUUID.h
index 7d1a21af..4a580b0c 100644
--- a/Sources/Plasma/NucleusLib/pnUUID/pnUUID.h
+++ b/Sources/Plasma/NucleusLib/pnUUID/pnUUID.h
@@ -64,6 +64,7 @@ public:
 
     plUUID();
     plUUID( const char * s );
+    plUUID( const plString & s );
     plUUID( const plUUID & other );
 #ifdef HS_BUILD_FOR_WIN32
     plUUID( const Uuid & uuid );
@@ -76,12 +77,12 @@ public:
     int     CompareTo( const plUUID * v ) const;
     bool    IsEqualTo( const plUUID * v ) const;
     bool    FromString( const char * str );
-    bool    ToStdString( std::string & out ) const;
-    inline std::string AsStdString() const { return AsString(); }
-    const char * AsString() const; // returns static buffer
+    bool    FromString( const plString & str );
+    bool    ToString( plString & out ) const;
+    plString AsString() const;
     void    Read( hsStream * s );
     void    Write( hsStream * s );
-    operator std::string ( void ) const { return AsStdString();}
+    operator plString ( void ) const { return AsString();}
     bool    operator==( const plUUID & other ) const { return IsEqualTo( &other ); }
     bool    operator!=( const plUUID & other ) const { return !IsEqualTo( &other ); }
     int     operator <( const plUUID & other ) const { return CompareTo( &other ); }
diff --git a/Sources/Plasma/NucleusLib/pnUUID/pnUUID_Win32.cpp b/Sources/Plasma/NucleusLib/pnUUID/pnUUID_Win32.cpp
index 47fcde9e..dce63a21 100644
--- a/Sources/Plasma/NucleusLib/pnUUID/pnUUID_Win32.cpp
+++ b/Sources/Plasma/NucleusLib/pnUUID/pnUUID_Win32.cpp
@@ -101,15 +101,20 @@ bool plUUID::FromString( const char * str )
     return RPC_S_OK == UuidFromString( (unsigned char *)str, (GUID *)this );
 }
 
-bool plUUID::ToStdString( std::string & out ) const
+bool plUUID::FromString( const plString & str )
 {
-    out = "";
+    return FromString( str.c_str() );
+}
+
+bool plUUID::ToString( plString & out ) const
+{
+    out = _TEMP_CONVERT_FROM_LITERAL("");
     unsigned char * ubuf;
     RPC_STATUS s;
     s = UuidToString( (GUID *) this, &ubuf );
     bool success = ( s==RPC_S_OK );
     if ( success )
-        out = (char*)ubuf;
+        out = plString::FromIso8859_1( (char*)ubuf );
     RpcStringFree( &ubuf );
     return success;
 }
diff --git a/Sources/Plasma/PubUtilLib/plNetCommon/plClientGuid.cpp b/Sources/Plasma/PubUtilLib/plNetCommon/plClientGuid.cpp
index ffc45360..e5d86f59 100644
--- a/Sources/Plasma/PubUtilLib/plNetCommon/plClientGuid.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetCommon/plClientGuid.cpp
@@ -41,7 +41,6 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 *==LICENSE==*/
 #include "plClientGuid.h"
 #include "hsStream.h"
-#include <sstream>
 #include "plNetCommon.h"
 #include "pnMessage/plMessage.h"
 #include "plSockets/plNet.h"
@@ -105,10 +104,10 @@ void plClientGuid::SetTempPlayerID(UInt32 id)
     }
 }
 
-void plClientGuid::SetPlayerName( const char * v )
+void plClientGuid::SetPlayerName( const plString & v )
 {
-    fPlayerName = v?v:"";
-    if ( fPlayerName.size() )
+    fPlayerName = v;
+    if ( !fPlayerName.IsEmpty() )
         fFlags|=kPlayerName;
     else
         fFlags&=~kPlayerName;
@@ -155,10 +154,10 @@ void plClientGuid::SetReserved(bool b)
     fFlags |= kReserved;
 }
 
-void plClientGuid::SetClientKey(const std::string& key)
+void plClientGuid::SetClientKey(const plString& key)
 {
     fClientKey = key;
-    if ( fClientKey.size() )
+    if ( !fClientKey.IsEmpty() )
         fFlags|=kClientKey;
     else
         fFlags&=~kClientKey;
@@ -171,13 +170,13 @@ const char * plClientGuid::GetSrcAddrStr() const
     return foo;
 }
 
-std::string plClientGuid::AsStdString() const
+plString plClientGuid::AsString() const
 {
 #define kComma  ","
 #define kEmpty  ""
     const char * spacer = kEmpty;
 
-    std::stringstream ss;
+    plStringStream ss;
 
     ss << "[";
 
@@ -222,7 +221,7 @@ std::string plClientGuid::AsStdString() const
     }
     if (IsFlagSet(kAccountUUID))
     {
-        ss << spacer << "plUUID:" << fAccountUUID.AsStdString();
+        ss << spacer << "plUUID:" << fAccountUUID.AsString();
         spacer = kComma;
     }
     if ( IsFlagSet(kReserved))
@@ -237,19 +236,19 @@ std::string plClientGuid::AsStdString() const
     }
     ss  << "]";
 
-    return ss.str().c_str();
+    return ss.GetString();
 }
 
-std::string plClientGuid::AsLogString() const
+plString plClientGuid::AsLogString() const
 {
 #define kSemicolon  ";"
     const char* spacer = kSemicolon;
 
-    std::stringstream ss;
+    plStringStream ss;
 
     if (IsFlagSet(kAccountUUID))
     {
-        ss << "AcctUUID=" << fAccountUUID.AsStdString();
+        ss << "AcctUUID=" << fAccountUUID.AsString();
         ss << spacer;
     }
     if (IsFlagSet(kPlayerID))
@@ -298,7 +297,7 @@ std::string plClientGuid::AsLogString() const
         ss << spacer;
     }
 
-    return ss.str().c_str();
+    return ss.GetString();
 }
 
 void plClientGuid::Read(hsStream * s, hsResMgr* mgr)
diff --git a/Sources/Plasma/PubUtilLib/plNetCommon/plClientGuid.h b/Sources/Plasma/PubUtilLib/plNetCommon/plClientGuid.h
index 9e04b5d0..b1a3e860 100644
--- a/Sources/Plasma/PubUtilLib/plNetCommon/plClientGuid.h
+++ b/Sources/Plasma/PubUtilLib/plNetCommon/plClientGuid.h
@@ -55,11 +55,11 @@ class plClientGuid : public plCreatable
     UInt8   fCCRLevel;
     bool    fProtectedLogin;
     UInt8   fBuildType;     // see plNetCommon.h
-    std::string fPlayerName;
+    plString fPlayerName;
     UInt32  fSrcAddr;
     UInt16  fSrcPort;
     bool    fReserved;
-    std::string fClientKey;
+    plString fClientKey;
 
 public:
     enum Flags // 16 bits.
@@ -80,8 +80,8 @@ public:
     CLASSNAME_REGISTER( plClientGuid );
     GETINTERFACE_ANY( plClientGuid, plCreatable );
 
-    std::string AsStdString() const;
-    std::string AsLogString() const;
+    plString AsString() const;
+    plString AsLogString() const;
     void    Clear();
     void    CopyFrom(const plClientGuid * other);
     void    UpdateFrom(const plClientGuid * other);
@@ -94,7 +94,7 @@ public:
 
     bool    HasAccountUUID() const { return (fFlags&kAccountUUID&&!fAccountUUID.IsNull())?true:false;}
     bool    HasPlayerID() const { return (fFlags&kPlayerID&&fPlayerID>0)?true:false;}
-    bool    HasPlayerName() const { return (fFlags&kPlayerName&&fPlayerName.size())?true:false; }
+    bool    HasPlayerName() const { return (fFlags&kPlayerName&&!fPlayerName.IsEmpty())?true:false; }
     bool    HasCCRLevel() const { return (fFlags&kCCRLevel)?true:false;}
     bool    HasProtectedLogin() const { return (fFlags&kProtectedLogin)?true:false;}
     bool    HasBuildType() const { return (fFlags&kBuildType)?true:false;}
@@ -105,7 +105,7 @@ public:
     
     const plUUID * GetAccountUUID() const { return &fAccountUUID;}
     UInt32  GetPlayerID() const { return fPlayerID;}
-    const char * GetPlayerName() const { return fPlayerName.c_str(); }
+    const plString & GetPlayerName() const { return fPlayerName; }
     UInt8   GetCCRLevel() const { return fCCRLevel; }
     bool    GetProtectedLogin() const { return ( fProtectedLogin!=0 ); }
     UInt8   GetFlags() const { return (UInt8)fFlags;}
@@ -114,12 +114,12 @@ public:
     const char * GetSrcAddrStr() const;
     UInt16  GetSrcPort() const { return fSrcPort; }
     bool    IsReserved() const { return fReserved!=0; }
-    const std::string& GetClientKey() const { return fClientKey; }
+    const plString& GetClientKey() const { return fClientKey; }
 
     void    SetAccountUUID(const plUUID * v);
     void    SetAccountUUID(const plUUID & v);
     void    SetPlayerID(UInt32 v);
-    void    SetPlayerName( const char * v );
+    void    SetPlayerName( const plString & v );
     void    SetCCRLevel(UInt8 v);
     void    SetProtectedLogin(bool v);
     void    SetBuildType(UInt8 v);
@@ -127,7 +127,7 @@ public:
     void    SetSrcAddrFromStr( const char * s );
     void    SetSrcPort( UInt16 v );
     void    SetReserved( bool v );
-    void    SetClientKey( const std::string& key );
+    void    SetClientKey( const plString& key );
     // When a client hasn't selected a player yet,
     // we need to uniquely identify them in the lobby server.
     // We do this by stuffing a temp value into the fPlayerID
diff --git a/Sources/Plasma/PubUtilLib/plNetCommon/plNetServerSessionInfo.cpp b/Sources/Plasma/PubUtilLib/plNetCommon/plNetServerSessionInfo.cpp
index acadfe3f..01ced3e2 100644
--- a/Sources/Plasma/PubUtilLib/plNetCommon/plNetServerSessionInfo.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetCommon/plNetServerSessionInfo.cpp
@@ -47,8 +47,6 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 #include "plNetCommon.h"
 #include "plVault/plVault.h"
 
-#include <sstream>
-
 #define SAFE(s) ((s)?(s):"(nil)")
 #define kComma  ","
 #define kEmpty  ""
@@ -177,11 +175,11 @@ void plAgeInfoStruct::CopyFrom(const NetAgeInfo & info) {
 }
 
 //============================================================================
-std::string plAgeInfoStruct::AsStdString() const
+plString plAgeInfoStruct::AsString() const
 {
     const char * spacer = kEmpty;
 
-    std::stringstream ss;
+    plStringStream ss;
 
     ss << "[";
 
@@ -236,7 +234,7 @@ std::string plAgeInfoStruct::AsStdString() const
     }
     ss  << "]";
 
-    return ss.str().c_str();
+    return ss.GetString();
 }
 
 
@@ -495,11 +493,11 @@ void plAgeLinkStruct::Clear()
     fAmCCR = false;
 }
 
-std::string plAgeLinkStruct::AsStdString() const
+plString plAgeLinkStruct::AsString() const
 {
     const char * spacer = kEmpty;
 
-    std::stringstream ss;
+    plStringStream ss;
 
     ss << "[";
 
@@ -507,7 +505,7 @@ std::string plAgeLinkStruct::AsStdString() const
     {
         ss  << spacer
             << "Nfo:"
-            << fAgeInfo.AsStdString();
+            << fAgeInfo.AsString();
         spacer = kComma;
     }
     if (HasLinkingRules())
@@ -533,7 +531,7 @@ std::string plAgeLinkStruct::AsStdString() const
     }
     ss  << "]";
 
-    return ss.str().c_str();
+    return ss.GetString();
 }
 
 
@@ -615,11 +613,11 @@ void plNetServerSessionInfo::CopyFrom(const plNetServerSessionInfo * other)
     }
 }
 
-std::string plNetServerSessionInfo::AsStdString() const
+plString plNetServerSessionInfo::AsString() const
 {
     const char * spacer = kEmpty;
 
-    std::stringstream ss;
+    plStringStream ss;
 
     ss << "[";
 
@@ -656,19 +654,19 @@ std::string plNetServerSessionInfo::AsStdString() const
     }
     ss  << "]";
 
-    return ss.str().c_str();
+    return ss.GetString();
 }
 
-std::string plNetServerSessionInfo::AsLogString() const
+plString plNetServerSessionInfo::AsLogString() const
 {
     const char* spacer = kSemicolon;
 
-    std::stringstream ss;
-    std::string typeName = "";
+    plStringStream ss;
+    plString typeName = _TEMP_CONVERT_FROM_LITERAL("");
 
     if (HasServerType())
     {
-        typeName = plNetServerConstants::GetServerTypeStr(fServerType);
+        typeName = _TEMP_CONVERT_FROM_LITERAL(plNetServerConstants::GetServerTypeStr(fServerType));
     }
 
     if (HasServerName())
@@ -699,7 +697,7 @@ std::string plNetServerSessionInfo::AsLogString() const
         ss << spacer;
     }
 
-    return ss.str().c_str();
+    return ss.GetString();
 }
 
 bool plNetServerSessionInfo::IsEqualTo(const plNetServerSessionInfo * other) const
diff --git a/Sources/Plasma/PubUtilLib/plNetCommon/plNetServerSessionInfo.h b/Sources/Plasma/PubUtilLib/plNetCommon/plNetServerSessionInfo.h
index 6a31d56d..e1708f42 100644
--- a/Sources/Plasma/PubUtilLib/plNetCommon/plNetServerSessionInfo.h
+++ b/Sources/Plasma/PubUtilLib/plNetCommon/plNetServerSessionInfo.h
@@ -147,7 +147,7 @@ public:
 
     const char * GetDisplayName() const;
 
-    std::string AsStdString() const;
+    plString AsString() const;
 };
 
 ////////////////////////////////////////////////////////////////////
@@ -220,7 +220,7 @@ public:
     void    Read( hsStream * s, hsResMgr* );
     void    Write( hsStream * s, hsResMgr* );
 
-    std::string AsStdString() const;
+    plString AsString() const;
 };
 
 
@@ -291,8 +291,8 @@ public:
     void Clear();
     void CopyFrom(const plNetServerSessionInfo * other);
     bool IsEqualTo(const plNetServerSessionInfo * other) const;
-    virtual std::string AsStdString() const;
-    virtual std::string AsLogString() const;
+    virtual plString AsString() const;
+    virtual plString AsLogString() const;
 
     void Read(hsStream* s, hsResMgr* mgr=nil);
     void Write(hsStream* s, hsResMgr* mgr=nil);
diff --git a/Sources/Plasma/PubUtilLib/plNetMessage/plNetMessage.cpp b/Sources/Plasma/PubUtilLib/plNetMessage/plNetMessage.cpp
index ea91c3b7..13f08f47 100644
--- a/Sources/Plasma/PubUtilLib/plNetMessage/plNetMessage.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetMessage/plNetMessage.cpp
@@ -700,19 +700,12 @@ void plNetMsgStreamedObject::WriteVersion(hsStream* s, hsResMgr* mgr)
 
 ////////////////////////////////////////////////////////////////////
 // debug
-std::string plNetMsgSDLState::AsStdString() const
+plString plNetMsgSDLState::AsString() const
 {
-    std::string s;
-
     ISetDescName();     // set desc name for debug if necessary
 
-//  xtl::format(s,"object:%s, SDL:%s, initial:%d, %s",
-//      ObjectInfo()->GetObjectName(), fDescName.c_str(), fIsInitialState, plNetMsgStreamedObject::AsStdString().c_str() );
-
-    xtl::format(s,"object:%s, initial:%d, %s",
-        ObjectInfo()->GetObjectName(), fIsInitialState, plNetMsgStreamedObject::AsStdString().c_str() );
-
-    return s;
+    return plString::Format("object:%s, initial:%d, %s",
+        ObjectInfo()->GetObjectName(), fIsInitialState, plNetMsgStreamedObject::AsString().c_str() );
 }
 
 //
@@ -1119,7 +1112,7 @@ int plNetMsgMemberUpdate::IPokeBuffer(hsStream* stream, UInt32 peekOptions)
     if (bytes)
     {
         // FIX ME to something nice
-        fMemberInfo.GetClientGuid()->SetClientKey("");
+        fMemberInfo.GetClientGuid()->SetClientKey(_TEMP_CONVERT_FROM_LITERAL(""));
         fMemberInfo.GetClientGuid()->SetAccountUUID(plUUID());
         fMemberInfo.Poke(stream, peekOptions);
         stream->WriteByte(fAddMember);
diff --git a/Sources/Plasma/PubUtilLib/plNetMessage/plNetMessage.h b/Sources/Plasma/PubUtilLib/plNetMessage/plNetMessage.h
index ad0d7820..937591e6 100644
--- a/Sources/Plasma/PubUtilLib/plNetMessage/plNetMessage.h
+++ b/Sources/Plasma/PubUtilLib/plNetMessage/plNetMessage.h
@@ -65,8 +65,6 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 
 #include "pnNetBase/pnNetBase.h"
 
-#include <sstream>
-
 class plMessage;
 class plUUID;
 
@@ -246,11 +244,11 @@ public:
     void InitReplyFieldsFrom(plNetMessage * msg);
 
     // debug
-    virtual std::string AsStdString() const
+    virtual plString AsString() const
     {
         const char* delim = "";
 
-        std::stringstream ss;
+        plStringStream ss;
         if ( GetHasPlayerID() )
         {
             ss << delim << "p:" << GetPlayerID();
@@ -263,7 +261,7 @@ public:
         }
         if ( GetHasAcctUUID() )
         {
-            ss << delim << "a:" << GetAcctUUID()->AsStdString();
+            ss << delim << "a:" << GetAcctUUID()->AsString();
             delim = ",";
         }
         if ( IsBitSet(kHasVersion) )
@@ -272,7 +270,7 @@ public:
             delim = ",";
         }
 
-        return ss.str().c_str();
+        return ss.GetString();
     }
 };
 
@@ -331,12 +329,10 @@ public:
     void WriteVersion(hsStream* s, hsResMgr* mgr);
 
     // debug
-    std::string AsStdString() const
+    plString AsString() const
     {
-        std::string s;
         char tmp[256];
-        xtl::format(s,"object=%s, %s",fObjectHelper.GetUoid().StringIze(tmp), plNetMessage::AsStdString().c_str());
-        return s;
+        return plString::Format("object=%s, %s",fObjectHelper.GetUoid().StringIze(tmp), plNetMessage::AsString().c_str());
     }
 
 };
@@ -409,7 +405,7 @@ public:
     void SetIsAvatarState(bool b) { fIsAvatarState = b; }
     
     // debug
-    std::string AsStdString() const;
+    plString AsString() const;
     bool IsInitialState() const {return fIsInitialState!=0; }
     void SetIsInitialState( bool v ) { fIsInitialState=v; }
 
@@ -509,12 +505,10 @@ public:
     void WriteVersion(hsStream* s, hsResMgr* mgr);
 
     // debug
-    std::string AsStdString() const
+    plString AsString() const
     {
-        std::string s;
         const char* noc=plFactory::GetTheFactory()->GetNameOfClass(StreamInfo()->GetStreamType());
-        xtl::format(s,"%s %s",plNetMsgStream::AsStdString().c_str(), noc ? noc : "?");
-        return s;
+        return plString::Format("%s %s",plNetMsgStream::AsString().c_str(), noc ? noc : "?");
     }
 };
 
@@ -562,13 +556,11 @@ public:
 
 
     // debug
-    std::string AsStdString() const
+    plString AsString() const
     {
-        std::string s;
         char tmp[256];
-        xtl::format(s,"object=%s initial=%d, %s",fObjectHelper.GetUoid().StringIze(tmp), fIsInitialState,
-            plNetMsgGameMessage::AsStdString().c_str());
-        return s;
+        return plString::Format("object=%s initial=%d, %s",fObjectHelper.GetUoid().StringIze(tmp), fIsInitialState,
+            plNetMsgGameMessage::AsString().c_str());
     }
 };
 
@@ -805,11 +797,9 @@ public:
     void WriteVersion(hsStream* s, hsResMgr* mgr);
 
     // debug
-    std::string AsStdString() const
+    plString AsStdString() const
     {
-        std::string s;
-        xtl::format(s,"lockReq=%d, %s",fLockRequest, plNetMsgStreamedObject::AsStdString().c_str());
-        return s;
+        return plString::Format("lockReq=%d, %s",fLockRequest, plNetMsgStreamedObject::AsString().c_str());
     }
 };
 
@@ -991,18 +981,16 @@ public:
     const hsBitVector& GetRegionsICareAbout() const { return fRegionsICareAbout;    }
     const hsBitVector& GetRegionsImIn() const       { return fRegionsImIn;  }
 
-    std::string AsStdString() const
+    plString AsStdString() const
     {
-        std::string s;
-        std::string b1, b2;
+        plString b1, b2;
         int i;
         for(i=0;i<fRegionsImIn.GetNumBitVectors(); i++)
-            b1 += xtl::format("0x%x ", fRegionsImIn.GetBitVector(i)).c_str();
+            b1 += plString::Format("0x%x ", fRegionsImIn.GetBitVector(i));
         for(i=0;i<fRegionsICareAbout.GetNumBitVectors(); i++)
-            b2 += xtl::format("0x%x ", fRegionsICareAbout.GetBitVector(i)).c_str();
-        xtl::format( s, "rgnsImIn:%s, rgnsICareAbout:%s, %s",
-            b1.c_str(), b2.c_str(), plNetMessage::AsStdString().c_str() );
-        return s;
+            b2 += plString::Format("0x%x ", fRegionsICareAbout.GetBitVector(i));
+        return plString::Format("rgnsImIn:%s, rgnsICareAbout:%s, %s",
+            b1.c_str(), b2.c_str(), plNetMessage::AsString().c_str() );
     }
 };
 
diff --git a/Sources/Plasma/PubUtilLib/plNetMessage/plNetMsgHelpers.cpp b/Sources/Plasma/PubUtilLib/plNetMessage/plNetMsgHelpers.cpp
index b02277a4..ec2a5ce8 100644
--- a/Sources/Plasma/PubUtilLib/plNetMessage/plNetMsgHelpers.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetMessage/plNetMsgHelpers.cpp
@@ -505,7 +505,7 @@ int plNetMsgMemberListHelper::Poke(hsStream* stream, const UInt32 peekOptions)
     int i;
     for(i=0;i<numMembers;i++)
     {
-        fMembers[i]->GetClientGuid()->SetClientKey("");
+        fMembers[i]->GetClientGuid()->SetClientKey(_TEMP_CONVERT_FROM_LITERAL(""));
         fMembers[i]->GetClientGuid()->SetAccountUUID(plUUID());
         fMembers[i]->Poke(stream, peekOptions);
     }

From 442a733fbb9691289be5f1aa540b5bb8dfe4137d Mon Sep 17 00:00:00 2001
From: Michael Hansen <zrax0111@gmail.com>
Date: Wed, 25 Jan 2012 22:43:18 -0800
Subject: [PATCH 03/11] Add more temporary hack macros to help speed up
 conversion and testing

---
 Sources/Plasma/CoreLib/plString.h             | 15 ++++--
 .../Plasma/FeatureLib/pfConsole/pfConsole.cpp | 14 +++---
 .../pfConsole/pfConsoleCommandsNet.cpp        | 10 ++--
 Sources/Plasma/FeatureLib/pfPython/cyMisc.cpp | 11 ++---
 .../FeatureLib/pfPython/plPythonFileMod.cpp   |  2 +-
 .../pfPython/plPythonSDLModifier.cpp          |  3 +-
 .../Plasma/FeatureLib/pfPython/pyVault.cpp    | 20 ++++----
 .../pnKeyedObject/hsKeyedObject.cpp           |  7 +--
 .../NucleusLib/pnKeyedObject/plUoid.cpp       | 10 ++--
 .../Plasma/NucleusLib/pnKeyedObject/plUoid.h  |  5 +-
 .../Plasma/NucleusLib/pnNetCommon/plNetApp.h  |  2 +-
 .../PubUtilLib/plInputCore/plInputDevice.h    |  2 +
 .../plInputCore/plSceneInputInterface.cpp     |  4 +-
 .../PubUtilLib/plNetClient/plNetClientMgr.cpp | 36 +++++++--------
 .../PubUtilLib/plNetClient/plNetClientMgr.h   |  6 +--
 .../plNetClient/plNetClientMgrLoad.cpp        |  3 +-
 .../plNetClient/plNetClientMgrSend.cpp        |  2 +-
 .../plNetClient/plNetClientMgrShow.cpp        | 18 ++++----
 .../plNetClient/plNetClientMsgHandler.cpp     |  2 +-
 .../plNetClient/plNetLinkingMgr.cpp           | 46 +++++++++----------
 .../PubUtilLib/plNetCommon/plNetMember.h      |  3 +-
 .../PubUtilLib/plNetMessage/plNetMessage.h    |  6 +--
 .../plNetTransport/plNetTransport.cpp         | 10 ++--
 .../plNetTransport/plNetTransportMember.cpp   |  4 +-
 .../plNetTransport/plNetTransportMember.h     | 11 +++--
 .../PubUtilLib/plResMgr/plResManager.cpp      |  7 ++-
 Sources/Tools/plResBrowser/plResTreeView.cpp  |  2 +-
 27 files changed, 130 insertions(+), 131 deletions(-)

diff --git a/Sources/Plasma/CoreLib/plString.h b/Sources/Plasma/CoreLib/plString.h
index 368b4a96..7537bc07 100644
--- a/Sources/Plasma/CoreLib/plString.h
+++ b/Sources/Plasma/CoreLib/plString.h
@@ -33,8 +33,15 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 #include <vector>
 #include <functional>
 
-#define _TEMP_CONVERT_FROM_LITERAL(x)   plString::FromUtf8((x))
-#define _TEMP_CONVERT_FROM_WCHAR_T(x)   plString::FromWchar((x))
+/* NOTE & TODO:
+ *   These macros are intentionally annoyingly named, to mark what code
+ *   needs to be cleaned up after a larger portion of Plasma is converted
+ *   to plString.
+ */
+#define _TEMP_CONVERT_FROM_LITERAL(x)       plString::FromUtf8((x))
+#define _TEMP_CONVERT_FROM_WCHAR_T(x)       plString::FromWchar((x))
+#define _TEMP_CONVERT_TO_CONST_CHAR(x)      (x).c_str()
+#define _TEMP_CONVERT_TO_CONST_CHAR_S(x)    (x).s_str()
 
 typedef unsigned int UniChar;
 
@@ -176,7 +183,9 @@ public:
     }
 
     const char *c_str() const { return fUtf8Buffer.GetData(); }
-    const char *s_str() const { return c_str() ? c_str() : ""; }
+    const char *s_str(const char *safe = "") const { return c_str() ? c_str() : safe; }
+    char CharAt(size_t position) const { return c_str()[position]; }
+
     plStringBuffer<char> ToUtf8() const { return fUtf8Buffer; }
     plStringBuffer<UInt16> ToUtf16() const;
     plStringBuffer<wchar_t> ToWchar() const;
diff --git a/Sources/Plasma/FeatureLib/pfConsole/pfConsole.cpp b/Sources/Plasma/FeatureLib/pfConsole/pfConsole.cpp
index 2a4556f7..33313010 100644
--- a/Sources/Plasma/FeatureLib/pfConsole/pfConsole.cpp
+++ b/Sources/Plasma/FeatureLib/pfConsole/pfConsole.cpp
@@ -333,8 +333,8 @@ hsBool  pfConsole::MsgReceive( plMessage *msg )
             // InviteReceived           
             case kSrv2Cli_GameMgr_InviteReceived: {
                 const Srv2Cli_GameMgr_InviteReceived & gmMsg = *(const Srv2Cli_GameMgr_InviteReceived *)gameMgrMsg->netMsg;
-                const char * inviterName = plNetClientMgr::GetInstance()->GetPlayerNameById(gmMsg.inviterId);
-                AddLineF("[GameMgr] Invite received: %S, %u. Inviter: %s", pfGameMgr::GetInstance()->GetGameNameByTypeId(gmMsg.gameTypeId), gmMsg.newGameId, inviterName ? inviterName : "<Unknown>");
+                const plString & inviterName = plNetClientMgr::GetInstance()->GetPlayerNameById(gmMsg.inviterId);
+                AddLineF("[GameMgr] Invite received: %S, %u. Inviter: %s", pfGameMgr::GetInstance()->GetGameNameByTypeId(gmMsg.gameTypeId), gmMsg.newGameId, inviterName.s_str("<Unknown>"));
             }
             return true;
 
@@ -342,8 +342,8 @@ hsBool  pfConsole::MsgReceive( plMessage *msg )
             // InviteRevoked            
             case kSrv2Cli_GameMgr_InviteRevoked: {
                 const Srv2Cli_GameMgr_InviteRevoked & gmMsg = *(const Srv2Cli_GameMgr_InviteRevoked *)gameMgrMsg->netMsg;
-                const char * inviterName = plNetClientMgr::GetInstance()->GetPlayerNameById(gmMsg.inviterId);
-                AddLineF("[GameMgr] Invite revoked: %S, %u. Inviter: %s", pfGameMgr::GetInstance()->GetGameNameByTypeId(gmMsg.gameTypeId), gmMsg.newGameId, inviterName ? inviterName : "<Unknown>");
+                const plString & inviterName = plNetClientMgr::GetInstance()->GetPlayerNameById(gmMsg.inviterId);
+                AddLineF("[GameMgr] Invite revoked: %S, %u. Inviter: %s", pfGameMgr::GetInstance()->GetGameNameByTypeId(gmMsg.gameTypeId), gmMsg.newGameId, inviterName.s_str("<Unknown>"));
             }
             return true;
             
@@ -372,7 +372,7 @@ hsBool  pfConsole::MsgReceive( plMessage *msg )
                     cli->GetName(),
                     cli->GetGameId(),
                     netMsg.playerId
-                        ? plNetClientMgr::GetInstance()->GetPlayerNameById(netMsg.playerId)
+                        ? plNetClientMgr::GetInstance()->GetPlayerNameById(netMsg.playerId).c_str()
                         : "Computer"
                 );
             }
@@ -387,7 +387,7 @@ hsBool  pfConsole::MsgReceive( plMessage *msg )
                     cli->GetName(),
                     cli->GetGameId(),
                     netMsg.playerId
-                        ? plNetClientMgr::GetInstance()->GetPlayerNameById(netMsg.playerId)
+                        ? plNetClientMgr::GetInstance()->GetPlayerNameById(netMsg.playerId).c_str()
                         : "Computer"
                 );
             }
@@ -503,7 +503,7 @@ hsBool  pfConsole::MsgReceive( plMessage *msg )
                     const Srv2Cli_TTT_MoveMade & netMsg = *(const Srv2Cli_TTT_MoveMade *)gameCliMsg->netMsg;
                     const char * playerName
                         = netMsg.playerId
-                            ? plNetClientMgr::GetInstance()->GetPlayerNameById(netMsg.playerId)
+                            ? plNetClientMgr::GetInstance()->GetPlayerNameById(netMsg.playerId).c_str()
                             : "Computer";
                     AddLineF(
                         "[Game %s:%u] %s moved:",
diff --git a/Sources/Plasma/FeatureLib/pfConsole/pfConsoleCommandsNet.cpp b/Sources/Plasma/FeatureLib/pfConsole/pfConsoleCommandsNet.cpp
index d9db6b2f..4268604a 100644
--- a/Sources/Plasma/FeatureLib/pfConsole/pfConsoleCommandsNet.cpp
+++ b/Sources/Plasma/FeatureLib/pfConsole/pfConsoleCommandsNet.cpp
@@ -229,13 +229,13 @@ PF_CONSOLE_CMD( Net,        // groupName
                "broadcast chat msg" )   // helpString
 {
     // send chat text
-    std::string text=plNetClientMgr::GetInstance()->GetPlayerName();
-    text += ":";
+    plString text=plNetClientMgr::GetInstance()->GetPlayerName();
+    text += _TEMP_CONVERT_FROM_LITERAL(":");
     int i;
     for(i=0;i<numParams;i++)
     {
-        text += (char*)params[i];
-        text += " ";
+        text += plString::FromUtf8( (char*)params[i] );
+        text += _TEMP_CONVERT_FROM_LITERAL(" ");
     }
     plConsoleMsg    *cMsg = TRACKED_NEW plConsoleMsg( plConsoleMsg::kAddLine, text.c_str() );
     cMsg->SetBCastFlag(plMessage::kNetPropagate | plMessage::kNetForce);
@@ -1014,7 +1014,7 @@ PF_CONSOLE_CMD(
         return;
     }
 
-    if (unsigned playerId = plNetClientMgr::GetInstance()->GetPlayerIdByName((const char *)params[1])) {
+    if (unsigned playerId = plNetClientMgr::GetInstance()->GetPlayerIdByName(plString::FromUtf8((const char *)params[1]))) {
         ttt->InvitePlayer(playerId);
         PrintStringF(PrintString, "Sent invite to playerId %u", playerId);
     }
diff --git a/Sources/Plasma/FeatureLib/pfPython/cyMisc.cpp b/Sources/Plasma/FeatureLib/pfPython/cyMisc.cpp
index f7e935cd..27d33639 100644
--- a/Sources/Plasma/FeatureLib/pfPython/cyMisc.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/cyMisc.cpp
@@ -455,8 +455,7 @@ hsBool cyMisc::WasLocallyNotified(pyKey &selfkey)
 //
 const char* cyMisc::GetClientName(pyKey &avKey)
 {
-    const char* ret=plNetClientMgr::GetInstance()->GetPlayerName(avKey.getKey());
-    return (ret==nil) ? "" : ret;
+    return plNetClientMgr::GetInstance()->GetPlayerName(avKey.getKey()).s_str();
 }
 
 PyObject* cyMisc::GetAvatarKeyFromClientID(int clientID)
@@ -549,7 +548,7 @@ hsBool cyMisc::ValidateKey(pyKey& key)
 //
 const char* cyMisc::GetLocalClientName()
 {
-    return plNetClientMgr::GetInstance()->GetPlayerName();
+    return plNetClientMgr::GetInstance()->GetPlayerName().c_str();
 }
 
 
@@ -946,7 +945,7 @@ PyObject* cyMisc::GetLocalAvatar()
 PyObject* cyMisc::GetLocalPlayer()
 {
     return pyPlayer::New(plNetClientMgr::GetInstance()->GetLocalPlayerKey(),
-                        plNetClientMgr::GetInstance()->GetPlayerName(),
+                        plNetClientMgr::GetInstance()->GetPlayerName().c_str(),
                         plNetClientMgr::GetInstance()->GetPlayerID(),
                         0.0 );
 }
@@ -1003,7 +1002,7 @@ std::vector<PyObject*> cyMisc::GetPlayerList()
             // only non-ignored people in list and not in ignore list
             if ( !VaultAmIgnoringPlayer ( mbr->GetPlayerID()) )
             {
-                PyObject* playerObj = pyPlayer::New(avkey, mbr->GetPlayerName(), mbr->GetPlayerID(), mbr->GetDistSq());
+                PyObject* playerObj = pyPlayer::New(avkey, mbr->GetPlayerName().c_str(), mbr->GetPlayerID(), mbr->GetDistSq());
                 pyPlayer* player = pyPlayer::ConvertFrom(playerObj); // accesses internal pyPlayer object
 
                 // modifies playerObj
@@ -1038,7 +1037,7 @@ std::vector<PyObject*> cyMisc::GetPlayerListDistanceSorted()
                 // only non-ignored people in list and not in ignore list
                 if ( !VaultAmIgnoringPlayer ( mbr->GetPlayerID()) )
                 {
-                    PyObject* playerObj = pyPlayer::New(avkey, mbr->GetPlayerName(), mbr->GetPlayerID(), mbr->GetDistSq());
+                    PyObject* playerObj = pyPlayer::New(avkey, mbr->GetPlayerName().c_str(), mbr->GetPlayerID(), mbr->GetDistSq());
                     pyPlayer* player = pyPlayer::ConvertFrom(playerObj); // accesses internal pyPlayer object
 
                     // modifies playerObj
diff --git a/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.cpp b/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.cpp
index 29c3304c..9b0df979 100644
--- a/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.cpp
@@ -1965,7 +1965,7 @@ hsBool plPythonFileMod::MsgReceive(plMessage* msg)
                 if ( mbrIndex != -1 )
                 {
                     plNetTransportMember *mbr = plNetClientMgr::GetInstance()->TransportMgr().GetMember( mbrIndex );
-                    player = pyPlayer::New(mbr->GetAvatarKey(), mbr->GetPlayerName(), mbr->GetPlayerID(), mbr->GetDistSq());
+                    player = pyPlayer::New(mbr->GetAvatarKey(), mbr->GetPlayerName().c_str(), mbr->GetPlayerID(), mbr->GetDistSq());
                 }
                 else
                 {
diff --git a/Sources/Plasma/FeatureLib/pfPython/plPythonSDLModifier.cpp b/Sources/Plasma/FeatureLib/pfPython/plPythonSDLModifier.cpp
index 31cd3202..f6a7ed07 100644
--- a/Sources/Plasma/FeatureLib/pfPython/plPythonSDLModifier.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/plPythonSDLModifier.cpp
@@ -609,9 +609,8 @@ const plPythonSDLModifier* plPythonSDLModifier::FindAgeSDL()
             }
             else
             {
-                char str[256];
                 if (!key)
-                    plNetClientApp::StaticErrorMsg("nil key %s for age sdl %s", ageName, oid.StringIze(str));
+                    plNetClientApp::StaticErrorMsg("nil key %s for age sdl %s", ageName, oid.StringIze().c_str());
                 else
                 if (!key->ObjectIsLoaded())
                     plNetClientApp::StaticErrorMsg("key %s not loaded for age sdl %s", 
diff --git a/Sources/Plasma/FeatureLib/pfPython/pyVault.cpp b/Sources/Plasma/FeatureLib/pfPython/pyVault.cpp
index 0efa47cc..85ac40c1 100644
--- a/Sources/Plasma/FeatureLib/pfPython/pyVault.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/pyVault.cpp
@@ -652,24 +652,24 @@ void pyVault::CreateNeighborhood()
     link.GetAgeInfo()->SetAgeFilename(kNeighborhoodAgeFilename);
     link.GetAgeInfo()->SetAgeInstanceName(kNeighborhoodAgeInstanceName);
 
-    std::string title;
-    std::string desc;
+    plString title;
+    plString desc;
 
-    unsigned nameLen = StrLen(nc->GetPlayerName());
-    if (nc->GetPlayerName()[nameLen - 1] == 's' || nc->GetPlayerName()[nameLen - 1] == 'S')
+    unsigned nameLen = nc->GetPlayerName().GetSize();
+    if (nc->GetPlayerName().CharAt(nameLen - 1) == 's' || nc->GetPlayerName().CharAt(nameLen - 1) == 'S')
     {
-        xtl::format( title, "%s'", nc->GetPlayerName() );
-        xtl::format( desc, "%s' %s", nc->GetPlayerName(), link.GetAgeInfo()->GetAgeInstanceName() );
+        title = plString::Format( "%s'", nc->GetPlayerName().c_str() );
+        desc = plString::Format( "%s' %s", nc->GetPlayerName().c_str(), link.GetAgeInfo()->GetAgeInstanceName() );
     }
     else
     {
-        xtl::format( title, "%s's", nc->GetPlayerName() );
-        xtl::format( desc, "%s's %s", nc->GetPlayerName(), link.GetAgeInfo()->GetAgeInstanceName() );
+        title = plString::Format( "%s's", nc->GetPlayerName().c_str() );
+        desc = plString::Format( "%s's %s", nc->GetPlayerName().c_str(), link.GetAgeInfo()->GetAgeInstanceName() );
     }
 
     link.GetAgeInfo()->SetAgeInstanceGuid(&plUUID(GuidGenerate()));
-    link.GetAgeInfo()->SetAgeUserDefinedName( title.c_str() );
-    link.GetAgeInfo()->SetAgeDescription( desc.c_str() );
+    link.GetAgeInfo()->SetAgeUserDefinedName( _TEMP_CONVERT_TO_CONST_CHAR(title) );
+    link.GetAgeInfo()->SetAgeDescription( _TEMP_CONVERT_TO_CONST_CHAR(desc) );
 
     VaultRegisterOwnedAge(&link);
 }
diff --git a/Sources/Plasma/NucleusLib/pnKeyedObject/hsKeyedObject.cpp b/Sources/Plasma/NucleusLib/pnKeyedObject/hsKeyedObject.cpp
index 2853a272..233baa92 100644
--- a/Sources/Plasma/NucleusLib/pnKeyedObject/hsKeyedObject.cpp
+++ b/Sources/Plasma/NucleusLib/pnKeyedObject/hsKeyedObject.cpp
@@ -143,12 +143,9 @@ void hsKeyedObject::UnRegisterAsManual(plUoid& inUoid)
         if (!(inUoid == myUoid))
         {
 #if !HS_BUILD_FOR_UNIX      // disable for unix servers
-            char inStr[255], myStr[255];
-            inUoid.StringIze(inStr);
-            myUoid.StringIze(myStr);
             hsAssert(false,
-                xtl::format("Request to Unregister wrong FixedKey, keyName=%s, inUoid=%s, myUoid=%s",
-                fpKey->GetName() ? fpKey->GetName() : "?", inStr, myStr).c_str());
+                plString::Format("Request to Unregister wrong FixedKey, keyName=%s, inUoid=%s, myUoid=%s",
+                fpKey->GetName() ? fpKey->GetName() : "?", inUoid.StringIze().c_str(), myUoid.StringIze().c_str()).c_str());
 #endif
         }
         ((plKeyImp*)fpKey)->UnRegister();
diff --git a/Sources/Plasma/NucleusLib/pnKeyedObject/plUoid.cpp b/Sources/Plasma/NucleusLib/pnKeyedObject/plUoid.cpp
index d870b6f7..f70d4a49 100644
--- a/Sources/Plasma/NucleusLib/pnKeyedObject/plUoid.cpp
+++ b/Sources/Plasma/NucleusLib/pnKeyedObject/plUoid.cpp
@@ -118,10 +118,9 @@ hsBool plLocation::IsVirtual() const
 }
 
 // THIS SHOULD BE FOR DEBUGGING ONLY <hint hint>
-char* plLocation::StringIze(char* str)  const // Format to displayable string
+plString plLocation::StringIze()  const // Format to displayable string
 {
-    sprintf(str, "S0x%xF0x%x", fSequenceNumber, int(fFlags));
-    return str;
+    return plString::Format("S0x%xF0x%x", fSequenceNumber, int(fFlags));
 }
 
 plLocation plLocation::MakeReserved(UInt32 number)
@@ -272,13 +271,12 @@ plUoid& plUoid::operator=(const plUoid& rhs)
 }
 
 // THIS SHOULD BE FOR DEBUGGING ONLY <hint hint>
-char* plUoid::StringIze(char* str) const // Format to displayable string
+plString plUoid::StringIze() const // Format to displayable string
 {
-    sprintf(str, "(0x%x:0x%x:%s:C:[%u,%u])", 
+    return plString::Format("(0x%x:0x%x:%s:C:[%u,%u])",
         fLocation.GetSequenceNumber(), 
         int(fLocation.GetFlags()), 
         fObjectName, 
         GetClonePlayerID(), 
         GetCloneID());
-    return str;
 }
diff --git a/Sources/Plasma/NucleusLib/pnKeyedObject/plUoid.h b/Sources/Plasma/NucleusLib/pnKeyedObject/plUoid.h
index 08cd7f56..fa11c0f8 100644
--- a/Sources/Plasma/NucleusLib/pnKeyedObject/plUoid.h
+++ b/Sources/Plasma/NucleusLib/pnKeyedObject/plUoid.h
@@ -59,6 +59,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 #include "plLoadMask.h"
 
 class hsStream;
+class plString;
 
 //// plLocation //////////////////////////////////////////////////////////////
 
@@ -124,7 +125,7 @@ public:
     bool operator<(const plLocation& loc ) const { return fSequenceNumber < loc.fSequenceNumber; }
 
     // THIS SHOULD BE FOR DEBUGGING ONLY <hint hint>
-    char* StringIze(char* str) const;  // Format to displayable string. Returns the same string for convenience
+    plString StringIze() const;  // Format to displayable string.
 
     static plLocation MakeReserved(UInt32 number);
     static plLocation MakeNormal(UInt32 number);
@@ -174,7 +175,7 @@ public:
     void SetObjectID(UInt32 id) { fObjectID = id; }
 
     // THIS SHOULD BE FOR DEBUGGING ONLY <hint hint>
-    char* StringIze(char* str) const;  // Format to displayable string
+    plString StringIze() const;  // Format to displayable string
 
 protected:
     enum ContentsFlags  // for read/write functions
diff --git a/Sources/Plasma/NucleusLib/pnNetCommon/plNetApp.h b/Sources/Plasma/NucleusLib/pnNetCommon/plNetApp.h
index bd8a2c34..ea9cb586 100644
--- a/Sources/Plasma/NucleusLib/pnNetCommon/plNetApp.h
+++ b/Sources/Plasma/NucleusLib/pnNetCommon/plNetApp.h
@@ -178,7 +178,7 @@ public:
     // functions that all net client apps should implement
     virtual int SendMsg(plNetMessage* msg) = 0;
     virtual UInt32 GetPlayerID() const = 0;
-    virtual const char * GetPlayerName( const plKey avKey=nil ) const = 0;
+    virtual plString GetPlayerName( const plKey avKey=nil ) const = 0;
 
     // commonly used net client app functions
     virtual float GetCurrentAgeTimeOfDayPercent() const { hsAssert(false, "stub"); return 0.; }
diff --git a/Sources/Plasma/PubUtilLib/plInputCore/plInputDevice.h b/Sources/Plasma/PubUtilLib/plInputCore/plInputDevice.h
index c0cfe58c..5dd26d57 100644
--- a/Sources/Plasma/PubUtilLib/plInputCore/plInputDevice.h
+++ b/Sources/Plasma/PubUtilLib/plInputCore/plInputDevice.h
@@ -52,6 +52,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 #include "pnInputCore/plKeyDef.h"
 #include "hsBitVector.h"
 #include "hsTemplates.h"
+#include "plString.h"
 class plMessage;
 struct plMouseInfo;
 class plPipeline;
@@ -189,6 +190,7 @@ public:
     static bool GetInverted() { return plMouseDevice::bInverted; }
     static void SetInverted(bool inverted) { plMouseDevice::bInverted = inverted; }
     static void AddNameToCursor(const char* name);
+    static void AddNameToCursor(const plString& name) { AddNameToCursor(_TEMP_CONVERT_TO_CONST_CHAR(name)); }
     static void AddIDNumToCursor(UInt32 idNum);
     static void AddCCRToCursor();
     
diff --git a/Sources/Plasma/PubUtilLib/plInputCore/plSceneInputInterface.cpp b/Sources/Plasma/PubUtilLib/plInputCore/plSceneInputInterface.cpp
index 30725e7e..c44be7b0 100644
--- a/Sources/Plasma/PubUtilLib/plInputCore/plSceneInputInterface.cpp
+++ b/Sources/Plasma/PubUtilLib/plInputCore/plSceneInputInterface.cpp
@@ -837,8 +837,8 @@ void plSceneInputInterface::ILinkOffereeToAge()
         std::string title;
         std::string desc;
         
-        unsigned nameLen = StrLen(plNetClientMgr::GetInstance()->GetPlayerName());
-        if (plNetClientMgr::GetInstance()->GetPlayerName()[nameLen - 1] == 's' || plNetClientMgr::GetInstance()->GetPlayerName()[nameLen - 1] == 'S') {
+        unsigned nameLen = plNetClientMgr::GetInstance()->GetPlayerName().GetSize();
+        if (plNetClientMgr::GetInstance()->GetPlayerName().CharAt(nameLen - 1) == 's' || plNetClientMgr::GetInstance()->GetPlayerName().CharAt(nameLen - 1) == 'S') {
             xtl::format( title, "%s'", plNetClientMgr::GetInstance()->GetPlayerName() );
             xtl::format( desc, "%s' %s", plNetClientMgr::GetInstance()->GetPlayerName(), link.GetAgeInfo()->GetAgeInstanceName() );
         }
diff --git a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgr.cpp b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgr.cpp
index f8462da7..5bed98b7 100644
--- a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgr.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgr.cpp
@@ -619,9 +619,8 @@ void plNetClientMgr::ICheckPendingStateLoad(double secs)
                 if ( !hsgResMgr::ResMgr()->FindKey( tmpUoid ) )
                 {
                     // discard the state if object not found in dataset.
-                    char tmp[256];
                     hsLogEntry( DebugMsg( "Failed to find object %s in dataset. Discarding pending state '%s'",
-                        tmpUoid.StringIze(tmp),
+                        tmpUoid.StringIze().c_str(),
                         pl->fSDRec->GetDescriptor()->GetName() ) );
                     delete pl;
                     it = fPendingLoads.erase(it);
@@ -663,7 +662,6 @@ void plNetClientMgr::ICheckPendingStateLoad(double secs)
                 double rawSecs = hsTimer::GetSeconds();
                 if ((rawSecs - pl->fQueuedTime) > 60.f /*secs*/)
                 {
-                    char tmp[256], tmp2[256];
                     if (pl->fQueueTimeResets >= 5)
                     {
                         // if this is our fifth time in here then we've been queued
@@ -671,7 +669,7 @@ void plNetClientMgr::ICheckPendingStateLoad(double secs)
 
                         WarningMsg( "Pending state '%s' for object [uoid:%s,key:%s] has been queued for about %f secs. Removing...",
                             pl->fSDRec && pl->fSDRec->GetDescriptor() ? pl->fSDRec->GetDescriptor()->GetName() : "?",
-                            pl->fUoid.StringIze(tmp2), pl->fKey ? pl->fKey->GetUoid().StringIze(tmp) : "?",
+                            pl->fUoid.StringIze().c_str(), pl->fKey ? pl->fKey->GetUoid().StringIze().c_str() : "?",
                             ( rawSecs - pl->fQueuedTime ) * pl->fQueueTimeResets);
 
                         delete pl;
@@ -681,7 +679,7 @@ void plNetClientMgr::ICheckPendingStateLoad(double secs)
 
                     WarningMsg( "Pending state '%s' for object [uoid:%s,key:%s] has been queued for about %f secs. %s",
                         pl->fSDRec && pl->fSDRec->GetDescriptor() ? pl->fSDRec->GetDescriptor()->GetName() : "?",
-                        pl->fUoid.StringIze(tmp2), pl->fKey ? pl->fKey->GetUoid().StringIze(tmp) : "?",
+                        pl->fUoid.StringIze().c_str(), pl->fKey ? pl->fKey->GetUoid().StringIze().c_str() : "?",
                         ( rawSecs - pl->fQueuedTime ) * pl->fQueueTimeResets,
                         so ? "(not loaded)" : "(not final)" );
                     // reset queue time so we don't spew too many log msgs.
@@ -938,8 +936,7 @@ hsBool plNetClientMgr::MsgReceive( plMessage* msg )
         {
             hsAssert(fAgeSDLObjectKey==nil, "already have a ref to age sdl hook");
             fAgeSDLObjectKey = ref->GetRef()->GetKey();
-            char tmp[256];
-            DebugMsg("Age SDL hook object created, uoid=%s", fAgeSDLObjectKey->GetUoid().StringIze(tmp));
+            DebugMsg("Age SDL hook object created, uoid=%s", fAgeSDLObjectKey->GetUoid().StringIze().c_str());
         }
         else
         {
@@ -1149,34 +1146,34 @@ bool plNetClientMgr::CanSendMsg(plNetMessage * msg)
 // Return the net client (account) name of the player whose avatar
 // key is provided.  If avKey is nil, returns local client name.
 //
-const char* plNetClientMgr::GetPlayerName(const plKey avKey) const
+plString plNetClientMgr::GetPlayerName(const plKey avKey) const
 {
     // local case
     if (!avKey || avKey==GetLocalPlayerKey())
-        return NetCommGetPlayer()->playerNameAnsi;
+        return plString::FromIso8859_1(NetCommGetPlayer()->playerNameAnsi);
     
     plNetTransportMember* mbr=TransportMgr().GetMember(TransportMgr().FindMember(avKey));
-    return mbr ? mbr->GetPlayerName() : nil;
+    return mbr ? mbr->GetPlayerName() : plString::Null;
 }
 
-const char * plNetClientMgr::GetPlayerNameById (unsigned playerId) const {
+plString plNetClientMgr::GetPlayerNameById (unsigned playerId) const {
     // local case
     if (NetCommGetPlayer()->playerInt == playerId)
-        return NetCommGetPlayer()->playerNameAnsi;
+        return plString::FromIso8859_1(NetCommGetPlayer()->playerNameAnsi);
         
     plNetTransportMember * mbr = TransportMgr().GetMember(TransportMgr().FindMember(playerId));
-    return mbr ? mbr->GetPlayerName() : nil;
+    return mbr ? mbr->GetPlayerName() : plString::Null;
 }
 
-unsigned plNetClientMgr::GetPlayerIdByName (const char name[]) const {
+unsigned plNetClientMgr::GetPlayerIdByName (const plString & name) const {
     // local case
-    if (0 == StrCmp(name, NetCommGetPlayer()->playerNameAnsi, (unsigned)-1))
+    if (0 == name.Compare(NetCommGetPlayer()->playerNameAnsi))
         NetCommGetPlayer()->playerInt;
     
     unsigned n = TransportMgr().GetNumMembers();
     for (unsigned i = 0; i < n; ++i)
         if (plNetTransportMember * member = TransportMgr().GetMember(i))
-            if (0 == StrCmp(name, member->GetPlayerName(), (unsigned)-1))
+            if (0 == name.Compare(member->GetPlayerName()))
                 return member->GetPlayerID();
     return 0;
 }
@@ -1483,10 +1480,9 @@ void plNetClientMgr::AddPendingLoad(PendingLoad *pl)
     pl->fKey = hsgResMgr::ResMgr()->FindKey(pl->fUoid);
 
     // check for age SDL state
-    char tmp[256];
     if (pl->fUoid.GetObjectName() && !strcmp(pl->fUoid.GetObjectName(), plSDL::kAgeSDLObjectName))
     {
-        DebugMsg("Recv SDL state for age hook object, uoid=%s", pl->fUoid.StringIze(tmp));
+        DebugMsg("Recv SDL state for age hook object, uoid=%s", pl->fUoid.StringIze().c_str());
         if (!pl->fKey)
             WarningMsg("Can't find age hook object, nil key!");
         else
@@ -1499,12 +1495,12 @@ void plNetClientMgr::AddPendingLoad(PendingLoad *pl)
         if (!pl->fKey->ObjectIsLoaded())
         {
             WarningMsg("Object %s not loaded, withholding SDL state", 
-                pl->fKey->GetUoid().StringIze(tmp));
+                pl->fKey->GetUoid().StringIze().c_str());
         }
         else if (!pl->fKey->ObjectIsLoaded()->IsFinal())
         {
             WarningMsg("Object %s is not FINAL, withholding SDL state", 
-                pl->fKey->GetUoid().StringIze(tmp));            
+                pl->fKey->GetUoid().StringIze().c_str());
         }
     }
 
diff --git a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgr.h b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgr.h
index a3d8447e..64992cdf 100644
--- a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgr.h
+++ b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgr.h
@@ -288,9 +288,9 @@ public:
     
     // getters
     UInt32              GetPlayerID( void ) const;
-    const char *        GetPlayerName( const plKey avKey=nil ) const;
-    const char *        GetPlayerNameById (unsigned playerId) const;
-    unsigned            GetPlayerIdByName(const char name[]) const;
+    plString            GetPlayerName( const plKey avKey=nil ) const;
+    plString            GetPlayerNameById (unsigned playerId) const;
+    unsigned            GetPlayerIdByName(const plString & name) const;
 
     UInt8 GetJoinOrder()                const { return fJoinOrder; }    // only valid at join time
 
diff --git a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrLoad.cpp b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrLoad.cpp
index 24943cbf..ac075455 100644
--- a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrLoad.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrLoad.cpp
@@ -107,8 +107,7 @@ plKey plNetClientMgr::ILoadClone(plLoadCloneMsg *pCloneMsg)
     {
         if (cloneKey->ObjectIsLoaded())
         {
-            char tmp[256];
-            DebugMsg("ILoadClone: object %s is already loaded, ignoring", cloneKey->GetUoid().StringIze(tmp));
+            DebugMsg("ILoadClone: object %s is already loaded, ignoring", cloneKey->GetUoid().StringIze().c_str());
             return cloneKey;
         }
 
diff --git a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrSend.cpp b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrSend.cpp
index fa2233ba..4ac812ff 100644
--- a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrSend.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrSend.cpp
@@ -159,7 +159,7 @@ void plNetClientMgr::ISendCCRPetition(plCCRPetitionMsg* petMsg)
     char buffy[20];
     sprintf( buffy, "%lu", GetPlayerID() );
     info.AddValue( "Petition", "PlayerID", buffy );
-    info.AddValue( "Petition", "PlayerName", GetPlayerName() );
+    info.AddValue( "Petition", "PlayerName", _TEMP_CONVERT_TO_CONST_CHAR(GetPlayerName()) );
 
     // write config info formatted like an ini file to a buffer
     hsRAMStream ram;
diff --git a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrShow.cpp b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrShow.cpp
index c32aad73..ad63ead4 100644
--- a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrShow.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrShow.cpp
@@ -103,7 +103,7 @@ void plNetClientMgr::IShowLists()
         sprintf(str, "%s%s %s p2p=%d dist=%.1f",
             mbr->GetTransportFlags() & plNetTransportMember::kSendingVoice ? "V" : " ",
             mbr->GetTransportFlags() & plNetTransportMember::kSendingActions ? "A" : " ",
-            mbr->AsStdString().c_str(),
+            mbr->AsString().c_str(),
             mbr->IsPeerToPeer(),
             mbr->GetDistSq() != hsScalarMax ? hsSquareRoot(mbr->GetDistSq()) :-1.f);
         txt.DrawString(x,y,str);
@@ -121,7 +121,7 @@ void plNetClientMgr::IShowLists()
     y+=yOff;
     for(i=0;i<GetListenList()->GetNumMembers();i++)
     {
-        sprintf(str, "name=%s", GetListenList()->GetMember(i)->AsStdString().c_str());
+        sprintf(str, "name=%s", GetListenList()->GetMember(i)->AsString().c_str());
         txt.DrawString(x,y,str);
         y+=yOff;
     }
@@ -133,7 +133,7 @@ void plNetClientMgr::IShowLists()
     y+=yOff;
     for(i=0;i<GetTalkList()->GetNumMembers();i++)
     {
-        sprintf(str, "name=%s", GetTalkList()->GetMember(i)->AsStdString().c_str());
+        sprintf(str, "name=%s", GetTalkList()->GetMember(i)->AsString().c_str());
         txt.DrawString(x,y,str);
         y+=yOff;
     }
@@ -231,8 +231,8 @@ void plNetClientMgr::IShowRelevanceRegions()
     //
     UInt32 maxPlayerName = 0;
 
-    txt.DrawString(x, y, GetPlayerName());
-    maxPlayerName = hsMaximum(maxPlayerName, txt.CalcStringWidth(GetPlayerName()));
+    txt.DrawString(x, y, _TEMP_CONVERT_TO_CONST_CHAR(GetPlayerName()));
+    maxPlayerName = hsMaximum(maxPlayerName, txt.CalcStringWidth(_TEMP_CONVERT_TO_CONST_CHAR(GetPlayerName())));
     y += yOff;
 
     int i;
@@ -243,9 +243,9 @@ void plNetClientMgr::IShowRelevanceRegions()
         if (mbr->IsServer())
             continue;
 
-        const char* name = mbr->GetPlayerName();
-        txt.DrawString(x, y, name);
-        maxPlayerName = hsMaximum(maxPlayerName, txt.CalcStringWidth(name));
+        const plString& name = mbr->GetPlayerName();
+        txt.DrawString(x, y, _TEMP_CONVERT_TO_CONST_CHAR(name));
+        maxPlayerName = hsMaximum(maxPlayerName, txt.CalcStringWidth(_TEMP_CONVERT_TO_CONST_CHAR(name)));
         y += yOff;
     }
 
@@ -359,7 +359,7 @@ void plNetClientMgr::IShowAvatars()
         ori = (player ? player->GetLocalToWorld() * hsVector3(0, -1, 0) : hsVector3(0, 0, 0));
 
         sprintf(str, "%s: pos(%.2f, %.2f, %.2f) ori(%.2f, %.2f, %.2f)",
-                mbr->AsStdString().c_str(), pos.fX, pos.fY, pos.fZ, ori.fX, ori.fY, ori.fZ);
+                mbr->AsString().c_str(), pos.fX, pos.fY, pos.fZ, ori.fX, ori.fY, ori.fZ);
         txt.DrawString(x,y,str);
         y+=yOff;
     
diff --git a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMsgHandler.cpp b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMsgHandler.cpp
index aedc731b..2c5b911b 100644
--- a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMsgHandler.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMsgHandler.cpp
@@ -487,7 +487,7 @@ MSG_HANDLER_DEFN(plNetClientMsgHandler,plNetMsgMembersList)
     {
         plNetTransportMember* mbr = TRACKED_NEW plNetTransportMember(nc);
         IFillInTransportMember(m->MemberListInfo()->GetMember(i), mbr);
-        hsLogEntry(nc->DebugMsg("\tAdding transport member, name=%s, p2p=%d, plrID=%d\n", mbr->AsStdString().c_str(), mbr->IsPeerToPeer(), mbr->GetPlayerID()));
+        hsLogEntry(nc->DebugMsg("\tAdding transport member, name=%s, p2p=%d, plrID=%d\n", mbr->AsString().c_str(), mbr->IsPeerToPeer(), mbr->GetPlayerID()));
         int idx=nc->fTransport.AddMember(mbr);
         hsAssert(idx>=0, "Failed adding member?");
             
diff --git a/Sources/Plasma/PubUtilLib/plNetClient/plNetLinkingMgr.cpp b/Sources/Plasma/PubUtilLib/plNetClient/plNetLinkingMgr.cpp
index 89d0d1d2..dc4efb5f 100644
--- a/Sources/Plasma/PubUtilLib/plNetClient/plNetLinkingMgr.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetClient/plNetLinkingMgr.cpp
@@ -932,23 +932,23 @@ UInt8 plNetLinkingMgr::IPreProcessLink(void)
                     if (!info->HasAgeUserDefinedName())
                     {
                         // set user-defined name
-                        std::string title;
-                        unsigned nameLen = StrLen(nc->GetPlayerName());
-                        if (nc->GetPlayerName()[nameLen - 1] == 's' || nc->GetPlayerName()[nameLen - 1] == 'S')
-                            xtl::format(title, "%s'", nc->GetPlayerName());
+                        plString title;
+                        unsigned nameLen = nc->GetPlayerName().GetSize();
+                        if (nc->GetPlayerName().CharAt(nameLen - 1) == 's' || nc->GetPlayerName().CharAt(nameLen - 1) == 'S')
+                            title = plString::Format("%s'", nc->GetPlayerName());
                         else
-                            xtl::format(title, "%s's", nc->GetPlayerName());
-                        info->SetAgeUserDefinedName(title.c_str());
+                            title = plString::Format("%s's", nc->GetPlayerName());
+                        info->SetAgeUserDefinedName(_TEMP_CONVERT_TO_CONST_CHAR(title));
                     }
                     if (!info->HasAgeDescription())
                     {
                         // set description
-                        std::string desc;
-                        unsigned nameLen = StrLen(nc->GetPlayerName());
-                        if (nc->GetPlayerName()[nameLen - 1] == 's' || nc->GetPlayerName()[nameLen - 1] == 'S')
-                            xtl::format(desc, "%s' %s", nc->GetPlayerName(), info->GetAgeInstanceName());
+                        plString desc;
+                        unsigned nameLen = nc->GetPlayerName().GetSize();
+                        if (nc->GetPlayerName().CharAt(nameLen - 1) == 's' || nc->GetPlayerName().CharAt(nameLen - 1) == 'S')
+                            desc = plString::Format("%s' %s", nc->GetPlayerName().c_str(), info->GetAgeInstanceName());
                         else
-                            xtl::format(desc, "%s's %s", nc->GetPlayerName(), info->GetAgeInstanceName());
+                            desc = plString::Format("%s's %s", nc->GetPlayerName().c_str(), info->GetAgeInstanceName());
                         info->SetAgeDescription(desc.c_str());
                     }
                     if (!info->HasAgeInstanceGuid()) {
@@ -970,25 +970,25 @@ UInt8 plNetLinkingMgr::IPreProcessLink(void)
                             if (!info->HasAgeUserDefinedName())
                             {
                                 // set user-defined name
-                                std::string title;
-                                unsigned nameLen = StrLen(nc->GetPlayerName());
-                                if (nc->GetPlayerName()[nameLen - 1] == 's' || nc->GetPlayerName()[nameLen - 1] == 'S')
-                                    xtl::format(title, "%s'", nc->GetPlayerName());
+                                plString title;
+                                unsigned nameLen = nc->GetPlayerName().GetSize();
+                                if (nc->GetPlayerName().CharAt(nameLen - 1) == 's' || nc->GetPlayerName().CharAt(nameLen - 1) == 'S')
+                                    title = plString::Format("%s'", nc->GetPlayerName().c_str());
                                 else
-                                    xtl::format(title, "%s's", nc->GetPlayerName());
-                                info->SetAgeUserDefinedName(title.c_str());
+                                    title = plString::Format("%s's", nc->GetPlayerName().c_str());
+                                info->SetAgeUserDefinedName(_TEMP_CONVERT_TO_CONST_CHAR(title));
                             }
 
                             if (!info->HasAgeDescription())
                             {
                                 // set description
-                                std::string desc;
-                                unsigned nameLen = StrLen(nc->GetPlayerName());
-                                if (nc->GetPlayerName()[nameLen - 1] == 's' || nc->GetPlayerName()[nameLen - 1] == 'S')
-                                    xtl::format(desc, "%s' %s", nc->GetPlayerName(), info->GetAgeInstanceName());
+                                plString desc;
+                                unsigned nameLen = nc->GetPlayerName().GetSize();
+                                if (nc->GetPlayerName().CharAt(nameLen - 1) == 's' || nc->GetPlayerName().CharAt(nameLen - 1) == 'S')
+                                    desc = plString::Format("%s' %s", nc->GetPlayerName().c_str(), info->GetAgeInstanceName());
                                 else
-                                    xtl::format(desc, "%s's %s", nc->GetPlayerName(), info->GetAgeInstanceName());
-                                info->SetAgeDescription( desc.c_str() );
+                                    desc = plString::Format("%s's %s", nc->GetPlayerName().c_str(), info->GetAgeInstanceName());
+                                info->SetAgeDescription( _TEMP_CONVERT_TO_CONST_CHAR(desc) );
                             }
 
                             if (!info->HasAgeInstanceGuid()) {
diff --git a/Sources/Plasma/PubUtilLib/plNetCommon/plNetMember.h b/Sources/Plasma/PubUtilLib/plNetCommon/plNetMember.h
index 0ae7f338..49e49dc2 100644
--- a/Sources/Plasma/PubUtilLib/plNetCommon/plNetMember.h
+++ b/Sources/Plasma/PubUtilLib/plNetCommon/plNetMember.h
@@ -49,6 +49,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 
 class plNetApp;
 class plNetGenericServer;
+class plString;
 ////////////////////////////////
 // A participant (peer) who we can send and recv messages from/to
 ////////////////////////////////
@@ -93,7 +94,7 @@ public:
     Int32 GetPeerID() const { return fPeerID; }
     UInt32 GetFlags() const { return fFlags; }
     plNetApp* GetNetApp() { return fNetApp; }
-    virtual std::string AsStdString() const = 0;
+    virtual plString AsString() const = 0;
 
     // setters
     void SetFlags(UInt32 f) { fFlags=f; }
diff --git a/Sources/Plasma/PubUtilLib/plNetMessage/plNetMessage.h b/Sources/Plasma/PubUtilLib/plNetMessage/plNetMessage.h
index 937591e6..e02a3b4b 100644
--- a/Sources/Plasma/PubUtilLib/plNetMessage/plNetMessage.h
+++ b/Sources/Plasma/PubUtilLib/plNetMessage/plNetMessage.h
@@ -331,8 +331,7 @@ public:
     // debug
     plString AsString() const
     {
-        char tmp[256];
-        return plString::Format("object=%s, %s",fObjectHelper.GetUoid().StringIze(tmp), plNetMessage::AsString().c_str());
+        return plString::Format("object=%s, %s",fObjectHelper.GetUoid().StringIze().c_str(), plNetMessage::AsString().c_str());
     }
 
 };
@@ -558,8 +557,7 @@ public:
     // debug
     plString AsString() const
     {
-        char tmp[256];
-        return plString::Format("object=%s initial=%d, %s",fObjectHelper.GetUoid().StringIze(tmp), fIsInitialState,
+        return plString::Format("object=%s initial=%d, %s",fObjectHelper.GetUoid().StringIze().c_str(), fIsInitialState,
             plNetMsgGameMessage::AsString().c_str());
     }
 };
diff --git a/Sources/Plasma/PubUtilLib/plNetTransport/plNetTransport.cpp b/Sources/Plasma/PubUtilLib/plNetTransport/plNetTransport.cpp
index d0378d8c..17fbc48e 100644
--- a/Sources/Plasma/PubUtilLib/plNetTransport/plNetTransport.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetTransport/plNetTransport.cpp
@@ -61,7 +61,7 @@ int plNetTransport::AddMember(plNetTransportMember* mbr)
     if (FindMember(mbr)==-1)
     {
         fMembers.push_back(mbr);
-        hsLogEntry( plNetClientMgr::GetInstance()->DebugMsg("Adding member %s", mbr->AsStdString().c_str()) );
+        hsLogEntry( plNetClientMgr::GetInstance()->DebugMsg("Adding member %s", mbr->AsString().c_str()) );
         plNetClientMgr::GetInstance()->GetListenList()->AddMember(mbr);
         plNetClientMgr::GetInstance()->GetTalkList()->AddMember(mbr);
         DumpState();
@@ -86,7 +86,7 @@ void plNetTransport::IRemoveMember(plNetTransportMember* mbr)
     if (!mbr)
         return;
 
-    hsLogEntry( plNetClientMgr::GetInstance()->DebugMsg("Removing member %s", mbr->AsStdString().c_str()) );
+    hsLogEntry( plNetClientMgr::GetInstance()->DebugMsg("Removing member %s", mbr->AsString().c_str()) );
 
 //  plNetClientMgr::GetInstance()->GetNetCore()->RemovePeer(mbr->GetPeerID());
     plNetClientMgr::GetInstance()->GetTalkList()->RemoveMember(mbr);
@@ -100,7 +100,7 @@ void plNetTransport::IRemoveMember(plNetTransportMember* mbr)
     // remove member from master list
     fMembers.erase(it);
 
-    hsLogEntry( plNetClientMgr::GetInstance()->DebugMsg("Done Removing member %s", mbr->AsStdString().c_str()) );
+    hsLogEntry( plNetClientMgr::GetInstance()->DebugMsg("Done Removing member %s", mbr->AsString().c_str()) );
     DumpState();
     
     delete mbr;
@@ -319,7 +319,7 @@ void plNetTransport::DumpState()
         for(j=0; j<mList->size();j++)
         {
             plNetTransportMember * mbr = (*mList)[j];
-            hsLogEntry( nc->DebugMsg("\t\tMbr %s\n",(*mList)[j]->AsStdString().c_str()) );
+            hsLogEntry( nc->DebugMsg("\t\tMbr %s\n",(*mList)[j]->AsString().c_str()) );
         }
     }
 
@@ -328,7 +328,7 @@ void plNetTransport::DumpState()
     {
         plNetTransportMember * mbr = GetMember(i);
         hsLogEntry (nc->DebugMsg("\tMbr %d, name=%s, plyrID=%lu, subs=%d", 
-            i,mbr->AsStdString().c_str(),mbr->GetPlayerID(),mbr->GetNumSubscriptions()) );
+            i,mbr->AsString().c_str(),mbr->GetPlayerID(),mbr->GetNumSubscriptions()) );
         int j;
         for(j=0;j<mbr->GetNumSubscriptions();j++)
         {
diff --git a/Sources/Plasma/PubUtilLib/plNetTransport/plNetTransportMember.cpp b/Sources/Plasma/PubUtilLib/plNetTransport/plNetTransportMember.cpp
index 0663e808..34eaad5c 100644
--- a/Sources/Plasma/PubUtilLib/plNetTransport/plNetTransportMember.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetTransport/plNetTransportMember.cpp
@@ -73,11 +73,11 @@ int plNetTransportMember::FindSubscription(int chan)
     return (it==fSubscriptions.end()) ? -1 : (it-fSubscriptions.begin());
 }
 
-std::string plNetTransportMember::AsStdString() const
+plString plNetTransportMember::AsString() const
 {
     if (IsServer())
     {
-        return "(server)";
+        return _TEMP_CONVERT_FROM_LITERAL("(server)");
     }
     else
     {
diff --git a/Sources/Plasma/PubUtilLib/plNetTransport/plNetTransportMember.h b/Sources/Plasma/PubUtilLib/plNetTransport/plNetTransportMember.h
index 9594eaed..50a497a9 100644
--- a/Sources/Plasma/PubUtilLib/plNetTransport/plNetTransportMember.h
+++ b/Sources/Plasma/PubUtilLib/plNetTransport/plNetTransportMember.h
@@ -45,7 +45,8 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 #include "hsConfig.h"
 #include "hsStlUtils.h"
 #include "plNetCommon/plNetMember.h"
-#include "pnKeyedObject/plKey.h" 
+#include "pnKeyedObject/plKey.h"
+#include "plString.h"
 
 //
 // This represents a participant in the game, ie. another 
@@ -64,7 +65,7 @@ public:
     };
 protected:
     plKey           fAvatarKey;
-    std::string     fPlayerName;
+    plString        fPlayerName;
     UInt32          fPlayerID;
     std::vector<int> fSubscriptions;    // list of channelGrp subscriptions
     UInt32          fTransportFlags;
@@ -88,8 +89,8 @@ public:
         {
             fAvatarKey=k;
         }
-    void SetPlayerName(const char * value) { fPlayerName=value;}
-    const char * GetPlayerName() const { return fPlayerName.c_str();}
+    void SetPlayerName(const plString & value) { fPlayerName=value;}
+    plString GetPlayerName() const { return fPlayerName;}
     void SetPlayerID(UInt32 value) { fPlayerID=value;}
     UInt32 GetPlayerID() const { return fPlayerID;}
     void SetIsServer(bool value) { (value)?SetFlags(GetFlags()|kIsServer):SetFlags(GetFlags()&!kIsServer);}
@@ -108,7 +109,7 @@ public:
     UInt32 GetTransportFlags() const { return fTransportFlags; }
 
     bool IsPeerToPeer() const { return hsCheckBits(fFlags, kRequestP2P); }
-    std::string AsStdString() const;
+    plString AsString() const;
     bool IsEqualTo(const plNetMember * other) const
     {
         const plNetTransportMember * o = plNetTransportMember::ConvertNoRef(other);
diff --git a/Sources/Plasma/PubUtilLib/plResMgr/plResManager.cpp b/Sources/Plasma/PubUtilLib/plResMgr/plResManager.cpp
index e1fb12cd..4d828293 100644
--- a/Sources/Plasma/PubUtilLib/plResMgr/plResManager.cpp
+++ b/Sources/Plasma/PubUtilLib/plResMgr/plResManager.cpp
@@ -314,8 +314,7 @@ hsBool plResManager::ReadObject(plKeyImp* key)
     // it will just inc/dec the open/close count during its read, and not actually 
     // close the stream, so we don't lose our place, lose our file handle, and thrash.
 
-    char locstr[64];
-    kResMgrLog(4, ILog(4, "   ...Opening page data stream for location %s...", key->GetUoid().GetLocation().StringIze(locstr)));
+    kResMgrLog(4, ILog(4, "   ...Opening page data stream for location %s...", key->GetUoid().GetLocation().StringIze().c_str()));
     plRegistryPageNode *pageNode = FindPage(key->GetUoid().GetLocation());
     if (!pageNode)
     {
@@ -1576,14 +1575,14 @@ static void sIReportLeak(plKeyImp* key, plRegistryPageNode* page)
     if (refsLeft == 0)
         return;
 
-    char tempStr[256], tempStr2[128];
+    char tempStr2[128];
     if (key->ObjectIsLoaded() == nil)
         sprintf(tempStr2, "(key only, %d refs left)", refsLeft);
     else
         sprintf(tempStr2, "- %d bytes - %d refs left", key->GetDataLen(), refsLeft);
 
     hsStatusMessageF("    %s: %s %s\n", plFactory::GetNameOfClass(key->GetUoid().GetClassType()), 
-                                                key->GetUoid().StringIze(tempStr), tempStr2);
+                                                key->GetUoid().StringIze().c_str(), tempStr2);
 }
 
 //// UnloadPageObjects ///////////////////////////////////////////////////////
diff --git a/Sources/Tools/plResBrowser/plResTreeView.cpp b/Sources/Tools/plResBrowser/plResTreeView.cpp
index 6700f0c5..b7838971 100644
--- a/Sources/Tools/plResBrowser/plResTreeView.cpp
+++ b/Sources/Tools/plResBrowser/plResTreeView.cpp
@@ -396,7 +396,7 @@ void    plResTreeView::UpdateInfoDlg( HWND treeCtrl )
                 SetDlgItemText( fInfoDlg, IDC_AGE, pageInfo.GetAge() );
                 SetDlgItemText( fInfoDlg, IDC_PAGE, pageInfo.GetPage() );
 
-                SetDlgItemText( fInfoDlg, IDC_LOCATION, pageInfo.GetLocation().StringIze( tempStr ) );
+                SetDlgItemText( fInfoDlg, IDC_LOCATION, pageInfo.GetLocation().StringIze().c_str() );
 
                 CheckDlgButton(fInfoDlg, IDC_RESERVED,   (pageInfo.GetLocation().GetFlags() & plLocation::kReserved) ? BST_CHECKED : BST_UNCHECKED);
                 CheckDlgButton(fInfoDlg, IDC_BUILTIN,    (pageInfo.GetLocation().GetFlags() & plLocation::kBuiltIn) ? BST_CHECKED : BST_UNCHECKED);

From e34414889f0d8304ecb16d1273cfda1d7333ec4b Mon Sep 17 00:00:00 2001
From: Michael Hansen <zrax0111@gmail.com>
Date: Sat, 28 Jan 2012 16:24:20 -0800
Subject: [PATCH 04/11] Convert plUoid's object name to a plString

---
 Sources/Plasma/Apps/plClient/plClient.cpp     |  13 +-
 Sources/Plasma/Apps/plPageInfo/plPageInfo.cpp |   2 +-
 Sources/Plasma/CoreLib/hsStream.cpp           |  27 +++
 Sources/Plasma/CoreLib/hsStream.h             |   9 +-
 Sources/Plasma/CoreLib/plString.cpp           |  24 ++-
 Sources/Plasma/CoreLib/plString.h             |  39 +++-
 .../pfAnimation/plAnimDebugList.cpp           |   8 +-
 .../FeatureLib/pfAnimation/plAnimDebugList.h  |   4 +-
 .../FeatureLib/pfAnimation/plFollowMod.cpp    |   4 +-
 .../pfAnimation/plLineFollowMod.cpp           |   4 +-
 .../pfAnimation/plViewFaceModifier.cpp        |   4 +-
 .../Plasma/FeatureLib/pfAudio/plListener.cpp  |  18 +-
 .../FeatureLib/pfCamera/plCameraBrain.cpp     |   4 +-
 .../FeatureLib/pfCamera/plVirtualCamNeu.cpp   |   4 +-
 .../FeatureLib/pfCamera/plVirtualCamNeu.h     |   2 +-
 .../FeatureLib/pfCharacter/pfMarkerInfo.cpp   |   4 +-
 .../pfConsole/pfAvatarConsoleCommands.cpp     |  16 +-
 .../pfConsole/pfConsoleCommands.cpp           | 204 +++++++++---------
 .../pfConsole/pfConsoleCommandsNet.cpp        |   8 +-
 .../FeatureLib/pfConsole/pfDispatchLog.cpp    |   5 +-
 .../pfGameGUIMgr/pfGUIControlMod.cpp          |   4 +-
 .../pfGameGUIMgr/pfGUICtrlGenerator.cpp       |  10 +-
 .../pfGameGUIMgr/pfGUICtrlGenerator.h         |   2 +-
 .../pfGameGUIMgr/pfGUIListElement.cpp         |   3 +-
 .../pfGameGUIMgr/pfGUIPopUpMenu.cpp           |   3 +-
 .../pfJournalBook/pfJournalBook.cpp           |  85 ++++----
 .../FeatureLib/pfJournalBook/pfJournalBook.h  |  18 +-
 Sources/Plasma/FeatureLib/pfPython/cyMisc.cpp |  59 +++--
 Sources/Plasma/FeatureLib/pfPython/cyMisc.h   |  18 +-
 .../Plasma/FeatureLib/pfPython/cyMiscGlue.cpp |   4 +-
 .../FeatureLib/pfPython/cyMiscGlue3.cpp       |   4 +-
 .../FeatureLib/pfPython/cyMiscGlue4.cpp       |  34 +--
 .../FeatureLib/pfPython/plPythonFileMod.cpp   |  65 +++---
 .../FeatureLib/pfPython/plPythonFileMod.h     |  16 +-
 .../pfPython/plPythonSDLModifier.cpp          |   6 +-
 .../Plasma/FeatureLib/pfPython/pyImage.cpp    |   7 +-
 .../FeatureLib/pfPython/pyJournalBook.cpp     |  21 +-
 .../FeatureLib/pfPython/pyJournalBook.h       |  18 +-
 .../FeatureLib/pfPython/pyJournalBookGlue.cpp |  14 +-
 Sources/Plasma/FeatureLib/pfPython/pyKey.h    |   3 +-
 .../FeatureLib/pfPython/pySceneObject.cpp     |  10 +-
 .../FeatureLib/pfPython/pySceneObject.h       |   4 +-
 .../FeatureLib/pfPython/pySceneObjectGlue.cpp |   4 +-
 .../FeatureLib/pfPython/pyVaultImageNode.cpp  |   3 +-
 .../FeatureLib/pfSurface/plLayerMovie.cpp     |   3 +-
 Sources/Plasma/NucleusLib/inc/hsResMgr.h      |   4 +-
 .../NucleusLib/pnDispatch/plDispatch.cpp      |   4 +-
 .../pnKeyedObject/hsKeyedObject.cpp           |   6 +-
 .../NucleusLib/pnKeyedObject/hsKeyedObject.h  |   4 +-
 .../NucleusLib/pnKeyedObject/plFixedKey.cpp   |  81 +++----
 .../Plasma/NucleusLib/pnKeyedObject/plKey.h   |   3 +-
 .../NucleusLib/pnKeyedObject/plKeyImp.cpp     |   6 +-
 .../NucleusLib/pnKeyedObject/plKeyImp.h       |   2 +-
 .../pnKeyedObject/plMsgForwarder.cpp          |   4 +-
 .../NucleusLib/pnKeyedObject/plUoid.cpp       |  24 +--
 .../Plasma/NucleusLib/pnKeyedObject/plUoid.h  |  10 +-
 .../Plasma/NucleusLib/pnMessage/plMessage.cpp |  18 +-
 .../Plasma/NucleusLib/pnMessage/plMessage.h   |   5 +-
 .../plAgeLoader/plAgeLoaderPaging.cpp         |   8 +-
 .../PubUtilLib/plAudible/plWinAudible.cpp     |   6 +-
 .../PubUtilLib/plAudio/plAudioSystem.cpp      |   4 +-
 Sources/Plasma/PubUtilLib/plAudio/plSound.cpp |   8 +-
 .../Plasma/PubUtilLib/plAudio/plVoiceChat.cpp |   3 +-
 .../plAudio/plWin32GroupedSound.cpp           |  16 +-
 .../PubUtilLib/plAudio/plWin32Sound.cpp       |   2 +-
 .../PubUtilLib/plAudio/plWin32StaticSound.cpp |   5 +-
 .../PubUtilLib/plAvatar/plAGMasterMod.cpp     |   4 +-
 .../plAvatar/plAGMasterSDLModifier.cpp        |   4 +-
 .../PubUtilLib/plAvatar/plArmatureMod.cpp     |  23 +-
 .../PubUtilLib/plAvatar/plAvatarClothing.cpp  |   7 +-
 .../PubUtilLib/plAvatar/plAvatarMgr.cpp       |  40 ++--
 .../Plasma/PubUtilLib/plAvatar/plAvatarMgr.h  |   8 +-
 .../PubUtilLib/plAvatar/plCoopCoordinator.cpp |  10 +-
 .../plDrawable/plDrawableGenerator.cpp        |   3 +-
 .../PubUtilLib/plDrawable/plDrawableSpans.cpp |   4 +-
 .../plDrawable/plDrawableSpansExport.cpp      |  16 +-
 .../PubUtilLib/plDrawable/plDynaDecalMgr.cpp  |   9 +-
 .../PubUtilLib/plDrawable/plProxyGen.cpp      |  22 +-
 .../PubUtilLib/plDrawable/plWaveSet7.cpp      |  85 +++-----
 .../PubUtilLib/plGImage/plFontCache.cpp       |   4 +-
 .../PubUtilLib/plGLight/plLightInfo.cpp       |   6 +-
 .../PubUtilLib/plGLight/plShadowCaster.cpp    |   4 +-
 .../PubUtilLib/plGLight/plShadowMaster.cpp    |   4 +-
 .../plModifier/plCloneSpawnModifier.cpp       |   2 +-
 .../plModifier/plResponderModifier.cpp        |   2 +-
 .../plNetClient/plNetCliAgeJoiner.cpp         |   2 +-
 .../PubUtilLib/plNetClient/plNetClientMgr.cpp |   2 +-
 .../plNetClient/plNetObjectDebugger.cpp       |   2 +-
 .../PubUtilLib/plNetClient/plNetVoiceList.cpp |   8 +-
 .../plNetCommon/plNetMsgScreener.cpp          |   4 +-
 .../PubUtilLib/plNetMessage/plNetMessage.cpp  |  14 +-
 .../PubUtilLib/plNetMessage/plNetMessage.h    |   8 +-
 .../plNetMessage/plNetMsgHelpers.cpp          |   2 +-
 .../PubUtilLib/plNetMessage/plNetMsgHelpers.h |   2 +-
 .../plParticleSystem/plParticleEmitter.cpp    |   4 +-
 .../plParticleSystem/plParticleSystem.cpp     |   4 +-
 .../PubUtilLib/plPhysX/plPXPhysical.cpp       |  12 +-
 .../PubUtilLib/plPhysX/plSimulationMgr.cpp    |  12 +-
 .../PubUtilLib/plPipeline/plCaptureRender.cpp |   6 +-
 .../PubUtilLib/plPipeline/plDXDeviceRefs.cpp  |   2 +-
 .../PubUtilLib/plPipeline/plDXPipeline.cpp    |  16 +-
 .../PubUtilLib/plPipeline/plDynamicEnvMap.cpp |   8 +-
 .../Plasma/PubUtilLib/plPipeline/plPlates.cpp |  13 +-
 .../PubUtilLib/plResMgr/plKeyFinder.cpp       |  45 ++--
 .../Plasma/PubUtilLib/plResMgr/plKeyFinder.h  |  16 +-
 .../PubUtilLib/plResMgr/plRegistryKeyList.cpp |  12 +-
 .../PubUtilLib/plResMgr/plRegistryKeyList.h   |   4 +-
 .../PubUtilLib/plResMgr/plRegistryNode.cpp    |   5 +-
 .../PubUtilLib/plResMgr/plRegistryNode.h      |   2 +-
 .../PubUtilLib/plResMgr/plResManager.cpp      |  18 +-
 .../Plasma/PubUtilLib/plResMgr/plResManager.h |   4 +-
 Sources/Plasma/PubUtilLib/plSDL/plSDL.h       |   4 +-
 .../PubUtilLib/plSDL/plStateDataRecord.cpp    |  28 +--
 .../PubUtilLib/plSDL/plStateVariable.cpp      |   6 +-
 .../PubUtilLib/plScene/plPageTreeMgr.cpp      |   4 +-
 .../PubUtilLib/plScene/plPostEffectMod.cpp    |   4 +-
 .../PubUtilLib/plScene/plRelevanceMgr.cpp     |  24 +--
 .../PubUtilLib/plScene/plRelevanceMgr.h       |   4 +-
 .../PubUtilLib/plStatGather/plAutoProfile.cpp |  28 +--
 .../PubUtilLib/plSurface/hsGMaterial.cpp      |  12 +-
 .../PubUtilLib/plSurface/plGrassShaderMod.cpp |   6 +-
 Sources/Tools/plResBrowser/plResTreeView.cpp  |   6 +-
 122 files changed, 811 insertions(+), 843 deletions(-)

diff --git a/Sources/Plasma/Apps/plClient/plClient.cpp b/Sources/Plasma/Apps/plClient/plClient.cpp
index c39c3b68..283feaed 100644
--- a/Sources/Plasma/Apps/plClient/plClient.cpp
+++ b/Sources/Plasma/Apps/plClient/plClient.cpp
@@ -632,7 +632,7 @@ hsBool plClient::MsgReceive(plMessage* msg)
         {
         case plClientRefMsg::kLoadRoom :
             #ifndef PLASMA_EXTERNAL_RELEASE
-            plStatusLog::AddLineS( "pageouts.log", ".. ClientRefMsg received for room %s", pRefMsg->GetRef() != nil ? pRefMsg->GetRef()->GetKey()->GetUoid().GetObjectName() : "nilref" );
+            plStatusLog::AddLineS( "pageouts.log", ".. ClientRefMsg received for room %s", pRefMsg->GetRef() != nil ? pRefMsg->GetRef()->GetKey()->GetUoid().GetObjectName().c_str() : "nilref" );
             #endif
 
             // was it that the room was loaded?
@@ -782,11 +782,10 @@ hsBool plClient::MsgReceive(plMessage* msg)
     plEventCallbackMsg* callback = plEventCallbackMsg::ConvertNoRef(msg);
     if( callback )
     {
-        char str[256];
-        sprintf(str, "Callback event from %s\n", callback->GetSender()
-                    ? callback->GetSender()->GetName()
-                    : "Unknown");
-        hsStatusMessage(str);
+        plString str = plString::Format("Callback event from %s\n", callback->GetSender()
+                        ? callback->GetSender()->GetName().c_str()
+                        : "Unknown");
+        hsStatusMessage(str.c_str());
         static int gotten = 0;
         if( ++gotten > 5 )
         {
@@ -1282,7 +1281,7 @@ void plClient::IRoomUnloaded(plSceneNode* node)
 
 void plClient::IReadKeyedObjCallback(plKey key)
 {
-    fInstance->IIncProgress(1, key->GetName());
+    fInstance->IIncProgress(1, _TEMP_CONVERT_TO_CONST_CHAR(key->GetName()));
 }
 
 //============================================================================
diff --git a/Sources/Plasma/Apps/plPageInfo/plPageInfo.cpp b/Sources/Plasma/Apps/plPageInfo/plPageInfo.cpp
index 77ea680f..219a2d88 100644
--- a/Sources/Plasma/Apps/plPageInfo/plPageInfo.cpp
+++ b/Sources/Plasma/Apps/plPageInfo/plPageInfo.cpp
@@ -230,7 +230,7 @@ public:
     {
         plKeyImp* imp = (plKey)key;
 
-        fStream.WriteString(imp->GetName());
+        fStream.WriteString_TEMP(imp->GetName());
         fStream.WriteString(",");
 
         fStream.WriteString(plFactory::GetNameOfClass(imp->GetUoid().GetClassType()));
diff --git a/Sources/Plasma/CoreLib/hsStream.cpp b/Sources/Plasma/CoreLib/hsStream.cpp
index 8593ca4b..5bac2757 100644
--- a/Sources/Plasma/CoreLib/hsStream.cpp
+++ b/Sources/Plasma/CoreLib/hsStream.cpp
@@ -322,6 +322,33 @@ wchar_t *hsStream::ReadSafeWString()
     return retVal;
 }
 
+UInt32  hsStream::WriteSafeString_TEMP(const plString &string)
+{
+    return WriteSafeString(string.c_str());
+}
+
+UInt32  hsStream::WriteSafeWString_TEMP(const plString &string)
+{
+    plStringBuffer<wchar_t> wbuffer = string.ToWchar();
+    return WriteSafeWString(wbuffer.GetData());
+}
+
+plString    hsStream::ReadSafeString_TEMP()
+{
+    char *buffer = ReadSafeString();
+    plString result = plString::FromIso8859_1(buffer);
+    delete [] buffer;
+    return result;
+}
+
+plString    hsStream::ReadSafeWString_TEMP()
+{
+    wchar_t *wbuffer = ReadSafeWString();
+    plString result = plString::FromWchar(wbuffer);
+    delete [] wbuffer;
+    return result;
+}
+
 hsBool  hsStream::Read4Bytes(void *pv)  // Virtual, faster version in sub classes
 {
     int knt = this->Read(sizeof(UInt32), pv);
diff --git a/Sources/Plasma/CoreLib/hsStream.h b/Sources/Plasma/CoreLib/hsStream.h
index 32b390d6..1ed46bd7 100644
--- a/Sources/Plasma/CoreLib/hsStream.h
+++ b/Sources/Plasma/CoreLib/hsStream.h
@@ -59,7 +59,8 @@ struct FileEntry;
 #ifndef STREAM_LOGGER
 #define hsReadOnlyLoggingStream hsReadOnlyStream
 #define LogRead(byteCount, buffer, desc) Read(byteCount, buffer)
-#define LogReadSafeString() ReadSafeString();
+#define LogReadSafeString() ReadSafeString()
+#define LogReadSafeString_TEMP() ReadSafeString_TEMP()
 #define LogReadSafeStringLong() ReadSafeStringLong();
 #define LogSkip(deltaByteCount, desc) Skip(deltaByteCount)
 #define LogReadLE(value, desc) ReadLE(value)
@@ -130,6 +131,7 @@ public:
     virtual hsBool  IsCompressed() { return false; }
 
     UInt32          WriteString(const char cstring[]);
+    UInt32          WriteString_TEMP(const plString & string) { return WriteString(string.c_str()); }
     UInt32          WriteFmt(const char * fmt, ...);
     UInt32          WriteFmtV(const char * fmt, va_list av);
 
@@ -143,6 +145,11 @@ public:
     char *          ReadSafeString();
     wchar_t *       ReadSafeWString();
 
+    UInt32          WriteSafeString_TEMP(const plString &string);        // uses 2 bytes for length
+    UInt32          WriteSafeWString_TEMP(const plString &string);
+    plString        ReadSafeString_TEMP();
+    plString        ReadSafeWString_TEMP();
+
     hsBool          GetToken(char *s, UInt32 maxLen=UInt32(-1), const char beginComment=kComment, const char endComment=kEolnCode);
     hsBool          ReadLn(char* s, UInt32 maxLen=UInt32(-1), const char beginComment=kComment, const char endComment=kEolnCode);
     
diff --git a/Sources/Plasma/CoreLib/plString.cpp b/Sources/Plasma/CoreLib/plString.cpp
index 9db20ea8..6bbadc99 100644
--- a/Sources/Plasma/CoreLib/plString.cpp
+++ b/Sources/Plasma/CoreLib/plString.cpp
@@ -490,7 +490,7 @@ plString plString::Format(const char *fmt, ...)
     return str;
 }
 
-int plString::Find(char ch, CaseSense sense) const
+int plString::Find(char ch, CaseSensitivity sense) const
 {
     if (sense == kCaseSensitive) {
         const char *cp = strchr(s_str(), ch);
@@ -506,7 +506,7 @@ int plString::Find(char ch, CaseSense sense) const
     }
 }
 
-int plString::FindReverse(char ch, CaseSense sense) const
+int plString::FindLast(char ch, CaseSensitivity sense) const
 {
     if (IsEmpty())
         return -1;
@@ -526,6 +526,26 @@ int plString::FindReverse(char ch, CaseSense sense) const
     }
 }
 
+int plString::Find(const char *str, CaseSensitivity sense) const
+{
+    if (!str || !str[0])
+        return -1;
+
+    if (sense == kCaseSensitive) {
+        const char *cp = strstr(s_str(), str);
+        return cp ? (cp - c_str()) : -1;
+    } else {
+        // The easy way
+        size_t len = strlen(str);
+        const char *cp = c_str();
+        while (*cp) {
+            if (strnicmp(cp, str, len) == 0)
+                return cp - c_str();
+            ++cp;
+        }
+    }
+}
+
 static bool in_set(char key, const char *charset)
 {
     for (const char *cs = charset; *cs; ++cs) {
diff --git a/Sources/Plasma/CoreLib/plString.h b/Sources/Plasma/CoreLib/plString.h
index 7537bc07..fc821c5c 100644
--- a/Sources/Plasma/CoreLib/plString.h
+++ b/Sources/Plasma/CoreLib/plString.h
@@ -126,10 +126,6 @@ class plString
     };
 #pragma warning(pop)
 
-    enum CaseSense {
-        kCaseSensitive, kCaseInsensitive
-    };
-
 public:
     static const plString Null;
 
@@ -212,23 +208,50 @@ public:
         return str;
     }
 
-    int Compare(const plString &str, CaseSense sense = kCaseSensitive) const
+    enum CaseSensitivity {
+        kCaseSensitive, kCaseInsensitive
+    };
+
+    int Compare(const plString &str, CaseSensitivity sense = kCaseSensitive) const
     {
+        if (c_str() == str.c_str())
+            return 0;
+
         return (sense == kCaseSensitive) ? strcmp(s_str(), str.s_str())
                                          : stricmp(s_str(), str.s_str());
     }
 
-    int Compare(const char *str, CaseSense sense = kCaseSensitive) const
+    int Compare(const char *str, CaseSensitivity sense = kCaseSensitive) const
     {
         return (sense == kCaseSensitive) ? strcmp(s_str(), str)
                                          : stricmp(s_str(), str);
     }
 
+    int CompareN(const plString &str, size_t count, CaseSensitivity sense = kCaseSensitive) const
+    {
+        if (c_str() == str.c_str())
+            return 0;
+
+        return (sense == kCaseSensitive) ? strncmp(s_str(), str.s_str(), count)
+                                         : strnicmp(s_str(), str.s_str(), count);
+    }
+
+    int CompareN(const char *str, size_t count, CaseSensitivity sense = kCaseSensitive) const
+    {
+        return (sense == kCaseSensitive) ? strncmp(s_str(), str, count)
+                                         : strnicmp(s_str(), str, count);
+    }
+
+    bool operator<(const plString &other) const { return Compare(other) < 0; }
     bool operator==(const plString &other) const { return Compare(other) == 0; }
     bool operator!=(const plString &other) const { return Compare(other) != 0; }
 
-    int Find(char ch, CaseSense sense = kCaseSensitive) const;
-    int FindReverse(char ch, CaseSense sense = kCaseSensitive) const;
+    int Find(char ch, CaseSensitivity sense = kCaseSensitive) const;
+    int FindLast(char ch, CaseSensitivity sense = kCaseSensitive) const;
+
+    int Find(const char *str, CaseSensitivity sense = kCaseSensitive) const;
+    int Find(const plString &str, CaseSensitivity sense = kCaseSensitive) const
+    { return Find(str.c_str(), sense); }
 
     plString TrimLeft(const char *charset = " \t\n\r") const;
     plString TrimRight(const char *charset = " \t\n\r") const;
diff --git a/Sources/Plasma/FeatureLib/pfAnimation/plAnimDebugList.cpp b/Sources/Plasma/FeatureLib/pfAnimation/plAnimDebugList.cpp
index 671153df..0e51d048 100644
--- a/Sources/Plasma/FeatureLib/pfAnimation/plAnimDebugList.cpp
+++ b/Sources/Plasma/FeatureLib/pfAnimation/plAnimDebugList.cpp
@@ -53,7 +53,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 #include "plResMgr/plKeyFinder.h"
 #include "plPipeline/plDebugText.h"
 
-void plAnimDebugList::AddObjects(char *subString)
+void plAnimDebugList::AddObjects(const plString &subString)
 {
     std::vector<plKey> keys;
     std::vector<plKey>::iterator i;
@@ -79,18 +79,18 @@ void plAnimDebugList::AddObjects(char *subString)
     }
 }
 
-void plAnimDebugList::RemoveObjects(char *subString)
+void plAnimDebugList::RemoveObjects(const plString &subString)
 {
     int i;
     for (i = fMaterialKeys.GetCount() - 1; i >= 0; i--)
     {
-        if (strstr(fMaterialKeys[i]->GetName(), subString))
+        if (fMaterialKeys[i]->GetName().Find(subString) >= 0)
             fMaterialKeys.Remove(i);
     }
 
     for (i = fSOKeys.GetCount() - 1; i >= 0; i--)
     {
-        if (strstr(fSOKeys[i]->GetName(), subString))
+        if (fSOKeys[i]->GetName().Find(subString) >= 0)
             fSOKeys.Remove(i);
     }
 }
diff --git a/Sources/Plasma/FeatureLib/pfAnimation/plAnimDebugList.h b/Sources/Plasma/FeatureLib/pfAnimation/plAnimDebugList.h
index 5c9a02bd..5cd5cc9b 100644
--- a/Sources/Plasma/FeatureLib/pfAnimation/plAnimDebugList.h
+++ b/Sources/Plasma/FeatureLib/pfAnimation/plAnimDebugList.h
@@ -55,8 +55,8 @@ public:
     plAnimDebugList() : fEnabled(false) {}
     ~plAnimDebugList() {}
 
-    void AddObjects(char *subString);
-    void RemoveObjects(char *subString);
+    void AddObjects(const plString &subString);
+    void RemoveObjects(const plString &subString);
     void ShowReport();
 };
 
diff --git a/Sources/Plasma/FeatureLib/pfAnimation/plFollowMod.cpp b/Sources/Plasma/FeatureLib/pfAnimation/plFollowMod.cpp
index 0ca112bb..c0b627cd 100644
--- a/Sources/Plasma/FeatureLib/pfAnimation/plFollowMod.cpp
+++ b/Sources/Plasma/FeatureLib/pfAnimation/plFollowMod.cpp
@@ -69,11 +69,11 @@ hsBool plFollowMod::MsgReceive(plMessage* msg)
     plRenderMsg* rend = plRenderMsg::ConvertNoRef(msg);
     if( rend )
     {
-        plProfile_BeginLap(FollowMod, this->GetKey()->GetUoid().GetObjectName());
+        plProfile_BeginLap(FollowMod, this->GetKey()->GetUoid().GetObjectName().c_str());
         fLeaderL2W = rend->Pipeline()->GetCameraToWorld();
         fLeaderW2L = rend->Pipeline()->GetWorldToCamera();
         fLeaderSet = true;
-        plProfile_EndLap(FollowMod, this->GetKey()->GetUoid().GetObjectName());
+        plProfile_EndLap(FollowMod, this->GetKey()->GetUoid().GetObjectName().c_str());
         return true;
     }
     plListenerMsg* list = plListenerMsg::ConvertNoRef(msg);
diff --git a/Sources/Plasma/FeatureLib/pfAnimation/plLineFollowMod.cpp b/Sources/Plasma/FeatureLib/pfAnimation/plLineFollowMod.cpp
index dd0c8f23..7bb48ac4 100644
--- a/Sources/Plasma/FeatureLib/pfAnimation/plLineFollowMod.cpp
+++ b/Sources/Plasma/FeatureLib/pfAnimation/plLineFollowMod.cpp
@@ -257,11 +257,11 @@ hsBool plLineFollowMod::MsgReceive(plMessage* msg)
     plRenderMsg* rend = plRenderMsg::ConvertNoRef(msg);
     if( rend )
     {
-        plProfile_BeginLap(LineFollow, this->GetKey()->GetUoid().GetObjectName());
+        plProfile_BeginLap(LineFollow, this->GetKey()->GetUoid().GetObjectName().c_str());
         hsPoint3 oldPos = fSearchPos;
         fSearchPos = rend->Pipeline()->GetViewPositionWorld();
         ICheckForPop(oldPos, fSearchPos);
-        plProfile_EndLap(LineFollow, this->GetKey()->GetUoid().GetObjectName());
+        plProfile_EndLap(LineFollow, this->GetKey()->GetUoid().GetObjectName().c_str());
         return true;
     }
     plListenerMsg* list = plListenerMsg::ConvertNoRef(msg);
diff --git a/Sources/Plasma/FeatureLib/pfAnimation/plViewFaceModifier.cpp b/Sources/Plasma/FeatureLib/pfAnimation/plViewFaceModifier.cpp
index 39a43aba..c96a543a 100644
--- a/Sources/Plasma/FeatureLib/pfAnimation/plViewFaceModifier.cpp
+++ b/Sources/Plasma/FeatureLib/pfAnimation/plViewFaceModifier.cpp
@@ -278,7 +278,7 @@ hsBool plViewFaceModifier::MsgReceive(plMessage* msg)
 
     if( rend )
     {
-        plProfile_BeginLap(ViewFace, this->GetKey()->GetUoid().GetObjectName());
+        plProfile_BeginLap(ViewFace, this->GetKey()->GetUoid().GetObjectName().c_str());
 
         if( HasFlag(kFaceCam) )
         {
@@ -314,7 +314,7 @@ hsBool plViewFaceModifier::MsgReceive(plMessage* msg)
 
         IFacePoint(rend->Pipeline(), fFacePoint);
         
-        plProfile_EndLap(ViewFace, this->GetKey()->GetUoid().GetObjectName());
+        plProfile_EndLap(ViewFace, this->GetKey()->GetUoid().GetObjectName().c_str());
         return true;
     }
     plArmatureUpdateMsg* armMsg = plArmatureUpdateMsg::ConvertNoRef(msg);
diff --git a/Sources/Plasma/FeatureLib/pfAudio/plListener.cpp b/Sources/Plasma/FeatureLib/pfAudio/plListener.cpp
index d098520a..bd6de81b 100644
--- a/Sources/Plasma/FeatureLib/pfAudio/plListener.cpp
+++ b/Sources/Plasma/FeatureLib/pfAudio/plListener.cpp
@@ -182,21 +182,21 @@ hsBool plListener::IEval(double secs, hsScalar del, UInt32 dirty)
 
     if( fPrintDbgInfo ) 
     {
-        char str[ 256 ];
-        sprintf( str, "Direction: (%3.2f,%3.2f,%3.2f) from %s", dir.fX, dir.fY, dir.fZ, ( facingType == kObject ) ? pRefObject->GetKey()->GetUoid().GetObjectName() : "VCam" );
-        plDebugText::Instance().DrawString( x, y, str, (UInt32)0xffffffff );
+        plString str;
+        str = plString::Format( "Direction: (%3.2f,%3.2f,%3.2f) from %s", dir.fX, dir.fY, dir.fZ, ( facingType == kObject ) ? pRefObject->GetKey()->GetUoid().GetObjectName().c_str() : "VCam" );
+        plDebugText::Instance().DrawString( x, y, str.c_str(), (UInt32)0xffffffff );
         y += 12;
 
-        sprintf( str, "Up: (%3.2f,%3.2f,%3.2f) from %s", up.fX, up.fY, up.fZ, ( facingType == kObject ) ? pRefObject->GetKey()->GetUoid().GetObjectName() : "VCam" );
-        plDebugText::Instance().DrawString( x, y, str, (UInt32)0xffffffff );
+        str = plString::Format( "Up: (%3.2f,%3.2f,%3.2f) from %s", up.fX, up.fY, up.fZ, ( facingType == kObject ) ? pRefObject->GetKey()->GetUoid().GetObjectName().c_str() : "VCam" );
+        plDebugText::Instance().DrawString( x, y, str.c_str(), (UInt32)0xffffffff );
         y += 12;
 
-        sprintf( str, "Position: (%3.2f,%3.2f,%3.2f) from %s", position.fX, position.fY, position.fZ, ( posType == kObject ) ? pRefObject->GetKey()->GetUoid().GetObjectName() : "VCam" );
-        plDebugText::Instance().DrawString( x, y, str, (UInt32)0xffffffff );
+        str = plString::Format( "Position: (%3.2f,%3.2f,%3.2f) from %s", position.fX, position.fY, position.fZ, ( posType == kObject ) ? pRefObject->GetKey()->GetUoid().GetObjectName().c_str() : "VCam" );
+        plDebugText::Instance().DrawString( x, y, str.c_str(), (UInt32)0xffffffff );
         y += 12;
 
-        sprintf( str, "Velocity: (%3.2f,%3.2f,%3.2f) from %s", velocity.fX, velocity.fY, velocity.fZ, ( velType == kObject ) ? pRefObject->GetKey()->GetUoid().GetObjectName() : "VCam" );
-        plDebugText::Instance().DrawString( x, y, str, (UInt32)0xffffffff );
+        str = plString::Format( "Velocity: (%3.2f,%3.2f,%3.2f) from %s", velocity.fX, velocity.fY, velocity.fZ, ( velType == kObject ) ? pRefObject->GetKey()->GetUoid().GetObjectName().c_str() : "VCam" );
+        plDebugText::Instance().DrawString( x, y, str.c_str(), (UInt32)0xffffffff );
         y += 12;
     }
     plgDispatch::MsgSend( msg );
diff --git a/Sources/Plasma/FeatureLib/pfCamera/plCameraBrain.cpp b/Sources/Plasma/FeatureLib/pfCamera/plCameraBrain.cpp
index 50cf05f4..4fcc277f 100644
--- a/Sources/Plasma/FeatureLib/pfCamera/plCameraBrain.cpp
+++ b/Sources/Plasma/FeatureLib/pfCamera/plCameraBrain.cpp
@@ -1318,8 +1318,8 @@ hsBool plCameraBrain1_FirstPerson::MsgReceive(plMessage* msg)
                         plSceneObject* child = (plSceneObject*)ci->GetChild(i)->GetOwner();
                         if (child)
                         {
-                            const char* name = child->GetKeyName();
-                            if (stricmp(name, "FPCameraOrigin") == 0)
+                            const plString& name = child->GetKeyName();
+                            if (name.Compare("FPCameraOrigin", plString::kCaseInsensitive) == 0)
                             {
                                 fPosNode = child;
                                 SetOffset(hsVector3(0,0,0));
diff --git a/Sources/Plasma/FeatureLib/pfCamera/plVirtualCamNeu.cpp b/Sources/Plasma/FeatureLib/pfCamera/plVirtualCamNeu.cpp
index 4028d296..5dc81326 100644
--- a/Sources/Plasma/FeatureLib/pfCamera/plVirtualCamNeu.cpp
+++ b/Sources/Plasma/FeatureLib/pfCamera/plVirtualCamNeu.cpp
@@ -533,11 +533,11 @@ void plVirtualCam1::SetRender(hsBool render)
 }
 
 // hack, hack, hack
-hsBool plVirtualCam1::RestoreFromName(const char* name)
+hsBool plVirtualCam1::RestoreFromName(const plString& name)
 {
     for(int i = 0; i < fCamerasLoaded.Count(); i++)
     {
-        if (strcmp(name, fCamerasLoaded[i]->GetKeyName()) == 0)
+        if (name.Compare(fCamerasLoaded[i]->GetKeyName()) == 0)
         {
             RebuildStack(fCamerasLoaded[i]->GetKey());
             return true;
diff --git a/Sources/Plasma/FeatureLib/pfCamera/plVirtualCamNeu.h b/Sources/Plasma/FeatureLib/pfCamera/plVirtualCamNeu.h
index b615b902..12b08b69 100644
--- a/Sources/Plasma/FeatureLib/pfCamera/plVirtualCamNeu.h
+++ b/Sources/Plasma/FeatureLib/pfCamera/plVirtualCamNeu.h
@@ -170,7 +170,7 @@ public:
     void ClearStack();
 
     void AddCameraLoaded(plSceneObject* pCam) { fCamerasLoaded.Append(pCam); }
-    hsBool RestoreFromName(const char* name);
+    hsBool RestoreFromName(const plString& name);
     void StartUnPan();
     // these are for console access
     static hsBool fUseAccelOverride, freeze, alwaysCutForColin, WalkPan3rdPerson,StayInFirstPersonForever;
diff --git a/Sources/Plasma/FeatureLib/pfCharacter/pfMarkerInfo.cpp b/Sources/Plasma/FeatureLib/pfCharacter/pfMarkerInfo.cpp
index 270c96b0..28b27400 100644
--- a/Sources/Plasma/FeatureLib/pfCharacter/pfMarkerInfo.cpp
+++ b/Sources/Plasma/FeatureLib/pfCharacter/pfMarkerInfo.cpp
@@ -77,7 +77,7 @@ void pfMarkerInfo::Init()
     plLocation markerLoc = plKeyFinder::Instance().FindLocation("GlobalMarkers", "Markers");
 
     if (markerLoc.IsValid())
-        fMarkerUoid = plUoid(markerLoc, plSceneObject::Index(), "MarkerRoot");
+        fMarkerUoid = plUoid(markerLoc, plSceneObject::Index(), _TEMP_CONVERT_FROM_LITERAL("MarkerRoot"));
     else
         fMarkerUoid.Invalidate();
 }
@@ -101,7 +101,7 @@ void pfMarkerInfo::Spawn(MarkerType type)
         plLocation markerLoc = plKeyFinder::Instance().FindLocation("GlobalMarkers", "Markers");
 
         if (markerLoc.IsValid())
-            fMarkerUoid = plUoid(markerLoc, plSceneObject::Index(), "MarkerRoot");
+            fMarkerUoid = plUoid(markerLoc, plSceneObject::Index(), _TEMP_CONVERT_FROM_LITERAL("MarkerRoot"));
         else
         {
             hsAssert(false, "Unable to spawn markers because the marker age was not loaded or found");
diff --git a/Sources/Plasma/FeatureLib/pfConsole/pfAvatarConsoleCommands.cpp b/Sources/Plasma/FeatureLib/pfConsole/pfAvatarConsoleCommands.cpp
index 0de829d5..6a502831 100644
--- a/Sources/Plasma/FeatureLib/pfConsole/pfAvatarConsoleCommands.cpp
+++ b/Sources/Plasma/FeatureLib/pfConsole/pfAvatarConsoleCommands.cpp
@@ -112,9 +112,9 @@ PF_CONSOLE_FILE_DUMMY(Avatar)
 //
 /////////////////////////////////////////////////////////////////
 
-plKey FindSceneObjectByName(const char* name, const char* ageName, char* statusStr, bool subString=false);
-plKey FindObjectByName(const char* name, int type, const char* ageName, char* statusStr, bool subString=false);
-plKey FindObjectByNameAndType(const char* name, const char* typeName, const char* ageName, 
+plKey FindSceneObjectByName(const plString& name, const char* ageName, char* statusStr, bool subString=false);
+plKey FindObjectByName(const plString& name, int type, const char* ageName, char* statusStr, bool subString=false);
+plKey FindObjectByNameAndType(const plString& name, const char* typeName, const char* ageName,
                                char* statusStr, bool subString=false);
 void PrintStringF(void pfun(const char *),const char * fmt, ...);
 
@@ -353,7 +353,7 @@ PF_CONSOLE_CMD( Avatar_Turn, SetMouseTurnSensitivity, "float sensitivity", "Set
 PF_CONSOLE_CMD( Avatar_Multistage, Trigger, "string multiComp", "Triggers the named Multistage Animation component")
 {
     char str[256];
-    plKey key = FindObjectByNameAndType((const char*)params[0], "plMultistageBehMod", nil, str, true);
+    plKey key = FindObjectByNameAndType(plString::FromUtf8(params[0]), "plMultistageBehMod", nil, str, true);
     PrintString(str);
 
     if (key)
@@ -464,8 +464,8 @@ PF_CONSOLE_CMD( Avatar,
                "Mark whether avatars in regionA want updates on those on regionB" )
 {
     plRelevanceMgr *mgr = plRelevanceMgr::Instance();
-    char *regA = params[0];
-    char *regB = params[1];
+    plString regA = plString::FromUtf8(params[0]);
+    plString regB = plString::FromUtf8(params[1]);
     mgr->MarkRegion(mgr->GetIndex(regA), mgr->GetIndex(regB), params[2]);
 }
 
@@ -484,7 +484,7 @@ PF_CONSOLE_CMD( Avatar,
 
 PF_CONSOLE_CMD( Avatar, SeekPoint, "string seekpoint", "Move to the given seekpoint.")
 {
-    char *spName = params[0];
+    plString spName = plString::FromUtf8(params[0]);
     
     plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
     
@@ -586,7 +586,7 @@ PF_CONSOLE_CMD( Avatar, ClickToTurn, "bool b", "Set click-to-turn functionality.
 
 PF_CONSOLE_CMD( Avatar, FakeLinkToObj, "string objName", "Pseudo-Link the avatar to the specified object's location")
 {
-    char *spName = params[0];
+    plString spName = plString::FromUtf8(params[0]);
     char buff[256];
     plKey seekKey = FindSceneObjectByName(spName, nil, buff);
     if (!seekKey)
diff --git a/Sources/Plasma/FeatureLib/pfConsole/pfConsoleCommands.cpp b/Sources/Plasma/FeatureLib/pfConsole/pfConsoleCommands.cpp
index b7093521..be242d4c 100644
--- a/Sources/Plasma/FeatureLib/pfConsole/pfConsoleCommands.cpp
+++ b/Sources/Plasma/FeatureLib/pfConsole/pfConsoleCommands.cpp
@@ -267,9 +267,9 @@ PF_CONSOLE_FILE_DUMMY(Main)
 // utility functions
 //
 //////////////////////////////////////////////////////////////////////////////
-plKey FindSceneObjectByName(const char* name, const char* ageName, char* statusStr, bool subString=false);
-plKey FindObjectByName(const char* name, int type, const char* ageName, char* statusStr, bool subString=false);
-plKey FindObjectByNameAndType(const char* name, const char* typeName, const char* ageName, 
+plKey FindSceneObjectByName(const plString& name, const char* ageName, char* statusStr, bool subString=false);
+plKey FindObjectByName(const plString& name, int type, const char* ageName, char* statusStr, bool subString=false);
+plKey FindObjectByNameAndType(const plString& name, const char* typeName, const char* ageName,
                                char* statusStr, bool subString=false);
 void PrintStringF(void pfun(const char *),const char * fmt, ...);
 
@@ -277,9 +277,9 @@ void PrintStringF(void pfun(const char *),const char * fmt, ...);
 // Find an object from name, type (int), and optionally age.
 // Name can be an alias specified by saying $foo
 //
-plKey FindObjectByName(const char* name, int type, const char* ageName, char* statusStr, bool subString)
+plKey FindObjectByName(const plString& name, int type, const char* ageName, char* statusStr, bool subString)
 {
-    if (!name)
+    if (name.IsNull())
     {
         if (statusStr)
             sprintf(statusStr, "Object name is nil");
@@ -338,10 +338,10 @@ plKey FindObjectByName(const char* name, int type, const char* ageName, char* st
 // Name can be an alias specified by saying $foo.
 // Will load the object if necessary.
 //
-plKey FindSceneObjectByName(const char* name, const char* ageName, char* statusStr, bool subString)
+plKey FindSceneObjectByName(const plString& name, const char* ageName, char* statusStr, bool subString)
 {
     plKey key=FindObjectByName(name, plSceneObject::Index(), ageName, statusStr, subString);
-    
+
     if (!plSceneObject::ConvertNoRef(key ? key->ObjectIsLoaded() : nil))
     {
         if (statusStr)
@@ -356,7 +356,7 @@ plKey FindSceneObjectByName(const char* name, const char* ageName, char* statusS
 // Find an object from name, type (string) and optionally age.
 // Name can be an alias specified by saying $foo
 //
-plKey FindObjectByNameAndType(const char* name, const char* typeName, const char* ageName, 
+plKey FindObjectByNameAndType(const plString& name, const char* typeName, const char* ageName,
                                char* statusStr, bool subString)
 {
     if (!typeName)
@@ -1628,7 +1628,7 @@ PF_CONSOLE_CMD( Graphics_Renderer, GrabCubeMap,
                "Take cubemap from sceneObject's position and name it prefix_XX.jpg")
 {
     char str[512];
-    const char* objName = params[0];
+    plString objName = plString::FromUtf8(params[0]);
     plKey key = FindSceneObjectByName(objName, nil, str);
     PrintString( str );
     if( !key )
@@ -1892,7 +1892,7 @@ PF_CONSOLE_CMD( Graphics_Show, SingleSound,
 
     const char *ageName = plAgeLoader::GetInstance()->GetCurrAgeDesc().GetAgeName();
 
-    plKey key = FindSceneObjectByName( params[ 0 ], ageName, str, true );
+    plKey key = FindSceneObjectByName( plString::FromUtf8( params[ 0 ] ), ageName, str, true );
     plSceneObject *obj = ( key != nil ) ? plSceneObject::ConvertNoRef( key->GetObjectPtr() ) : nil;
     if( !obj )
     {
@@ -2224,7 +2224,7 @@ PF_CONSOLE_CMD( App,
 {
 
     char str[256];
-    plKey key = FindSceneObjectByName(params[0], nil, str);
+    plKey key = FindSceneObjectByName(plString::FromUtf8(params[0]), nil, str);
     plSceneObject* obj = plSceneObject::ConvertNoRef(key->GetObjectPtr());
     if( !obj )
     {
@@ -2301,7 +2301,7 @@ PF_CONSOLE_CMD( App,
 {
 
     char str[256];
-    plKey key = FindSceneObjectByName(params[0], nil, str);
+    plKey key = FindSceneObjectByName(plString::FromUtf8(params[0]), nil, str);
     plSceneObject* obj = plSceneObject::ConvertNoRef(key->GetObjectPtr());
     if( !obj )
     {
@@ -2355,18 +2355,18 @@ PF_CONSOLE_CMD( App,
                 "Enable/Disable/Toggle display of named CamView object" )
 {
     char str[256];
-    char* name = params[0];
+    plString name = plString::FromUtf8(params[0]);
     plKey key = FindSceneObjectByName(name, nil, str);
     if( !key )
     {
-        sprintf(str, "%s - Not Found!", name);
+        sprintf(str, "%s - Not Found!", name.c_str());
         PrintString(str);
         return;
     }
     plSceneObject* obj = plSceneObject::ConvertNoRef(key->GetObjectPtr());
     if( !obj )
     {
-        sprintf(str, "%s - Not Found!", name);
+        sprintf(str, "%s - Not Found!", name.c_str());
         PrintString(str);
         return;
     }
@@ -2379,11 +2379,11 @@ PF_CONSOLE_CMD( App,
     }
     if( i >= obj->GetNumModifiers() )
     {
-        sprintf(str, "%s - No CamView Modifier found!", name);
+        sprintf(str, "%s - No CamView Modifier found!", name.c_str());
         PrintString(str);
         return;
     }
-    strcpy(str, name);
+    strcpy(str, name.c_str());
 
     plAnimCmdMsg* cmd = TRACKED_NEW plAnimCmdMsg(nil, obj->GetModifier(i)->GetKey(), nil);
 
@@ -2818,7 +2818,7 @@ PF_CONSOLE_CMD( Registry, ListRefs, "string keyType, string keyName", "For the g
                "the objects who currently have active refs on it." )
 {
     char result[ 256 ];
-    plKey obj = FindObjectByNameAndType( params[ 1 ], params[ 0 ], nil, result);
+    plKey obj = FindObjectByNameAndType( plString::FromUtf8( params[ 1 ] ), params[ 0 ], nil, result);
     if( obj == nil )
     {
         PrintString( result );
@@ -2994,8 +2994,7 @@ PF_CONSOLE_CMD( Camera,     // groupName
 PF_CONSOLE_CMD( Camera, SwitchTo, "string cameraName", "Switch to the named camera")
 {
     char str[256];
-    char foo[256];
-    sprintf(foo, "%s_", (const char*)params[0]);
+    plString foo = plString::Format("%s_", plString::FromUtf8(params[0]));
     plKey key = FindObjectByNameAndType(foo, "plCameraModifier1", nil, str, true);
     PrintString(str);
 
@@ -3119,7 +3118,7 @@ PF_CONSOLE_CMD( Camera,     // groupName
 
 PF_CONSOLE_GROUP( Logic )
 
-static plLogicModBase *FindLogicMod(const char *name)
+static plLogicModBase *FindLogicMod(const plString &name)
 {
     char str[256];
     plKey key = FindObjectByNameAndType(name, "plLogicModifier", nil, str, true);
@@ -3133,7 +3132,7 @@ static plLogicModBase *FindLogicMod(const char *name)
 
 PF_CONSOLE_CMD( Logic, TriggerDetectorNum, "int detectorNum", "Triggers the detector with this number (from ListDetectors)")
 {
-    std::vector<std::string> activatorNames;
+    std::vector<plString> activatorNames;
     plKeyFinder::Instance().GetActivatorNames(activatorNames);
 
     int activatorNum = params[0];
@@ -3143,21 +3142,21 @@ PF_CONSOLE_CMD( Logic, TriggerDetectorNum, "int detectorNum", "Triggers the dete
         return;
     }
 
-    plLogicModBase *mod = FindLogicMod(activatorNames[activatorNum-1].c_str());
+    plLogicModBase *mod = FindLogicMod(activatorNames[activatorNum-1]);
     if (mod)
         mod->ConsoleTrigger(plNetClientMgr::GetInstance()->GetLocalPlayerKey());
 }
 
 PF_CONSOLE_CMD( Logic, TriggerDetector, "string detectorComp", "Triggers the named detector component")
 {
-    plLogicModBase *mod = FindLogicMod((const char*)params[0]);
+    plLogicModBase *mod = FindLogicMod(plString::FromUtf8(params[0]));
     if (mod)
         mod->ConsoleTrigger(plNetClientMgr::GetInstance()->GetLocalPlayerKey());
 }
 
 PF_CONSOLE_CMD(Logic, EnableDetector, "string detectorComp, bool enable", "Enables/disables the named detector component")
 {
-    plLogicModBase *mod = FindLogicMod((const char*)params[0]);
+    plLogicModBase *mod = FindLogicMod(plString::FromUtf8(params[0]));
     if (mod)
     {
         plEnableMsg* enableMsg = TRACKED_NEW plEnableMsg;
@@ -3202,7 +3201,7 @@ PF_CONSOLE_CMD( Logic, TriggerResponderNum, "int responderNum, ...", "Triggers t
         return;
     }
 
-    std::vector<std::string> responderNames;
+    std::vector<plString> responderNames;
     plKeyFinder::Instance().GetResponderNames(responderNames);
 
     int responderNum = params[0];
@@ -3219,7 +3218,7 @@ PF_CONSOLE_CMD( Logic, TriggerResponderNum, "int responderNum, ...", "Triggers t
     }
 
     char str[256];
-    plKey key = FindObjectByNameAndType(responderNames[responderNum-1].c_str(), "plResponderModifier", nil, str, true);
+    plKey key = FindObjectByNameAndType(responderNames[responderNum-1], "plResponderModifier", nil, str, true);
     PrintString(str);
 
     if (key)
@@ -3235,7 +3234,7 @@ PF_CONSOLE_CMD( Logic, TriggerResponder, "string responderComp, ...", "Triggers
     }
     
     char str[256];
-    plKey key = FindObjectByNameAndType(params[0], "plResponderModifier", nil, str, true);
+    plKey key = FindObjectByNameAndType(plString::FromUtf8(params[0]), "plResponderModifier", nil, str, true);
     PrintString(str);
 
     int responderState = -1;
@@ -3257,7 +3256,7 @@ PF_CONSOLE_CMD( Logic, FastForwardResponder, "string responderComp, ...", "Fastf
     }
     
     char str[256];
-    plKey key = FindObjectByNameAndType(params[0], "plResponderModifier", nil, str, true);
+    plKey key = FindObjectByNameAndType(plString::FromUtf8(params[0]), "plResponderModifier", nil, str, true);
     PrintString(str);
 
     int responderState = -1;
@@ -3272,7 +3271,7 @@ PF_CONSOLE_CMD( Logic, FastForwardResponder, "string responderComp, ...", "Fastf
 
 PF_CONSOLE_CMD(Logic, ListDetectors, "", "Prints the names of the loaded detectors to the console")
 {
-    std::vector<std::string> activatorNames;
+    std::vector<plString> activatorNames;
     plKeyFinder::Instance().GetActivatorNames(activatorNames);
 
     for (int i = 0; i < activatorNames.size(); i++)
@@ -3285,7 +3284,7 @@ PF_CONSOLE_CMD(Logic, ListDetectors, "", "Prints the names of the loaded detecto
 
 PF_CONSOLE_CMD(Logic, ListResponders, "", "Prints the names of the loaded responders to the console")
 {
-    std::vector<std::string> responderNames;
+    std::vector<plString> responderNames;
     plKeyFinder::Instance().GetResponderNames(responderNames);
 
     for (int i = 0; i < responderNames.size(); i++)
@@ -3568,7 +3567,7 @@ PF_CONSOLE_CMD( Audio, SetVolume,
                 "string obj, float vol", "Sets the volume on a given object. 1 is max volume, 0 is silence" )
 {
     char    str[ 256 ];
-    plKey key = FindSceneObjectByName(params[ 0 ], nil, str);
+    plKey key = FindSceneObjectByName(plString::FromUtf8(params[ 0 ]), nil, str);
     if( key == nil )
         return;
 
@@ -3597,7 +3596,7 @@ PF_CONSOLE_CMD( Audio, IsolateSound,
     plKey           key;
     plAudioSysMsg   *asMsg;
 
-    key = FindSceneObjectByName( params[ 0 ], nil, str );
+    key = FindSceneObjectByName( plString::FromUtf8( params[ 0 ] ), nil, str );
     if( key == nil )
     {
         sprintf( str, "Cannot find sound %s", (char *)params[ 0 ] );
@@ -4020,7 +4019,7 @@ PF_CONSOLE_CMD( Nav, UnloadPlayer,  // Group name, Function name
                 "unloads a named player" )  // Help string
 {
     char str[256];
-    plKey key = FindSceneObjectByName(params[0], nil, str);
+    plKey key = FindSceneObjectByName(plString::FromUtf8(params[0]), nil, str);
     PrintString("UnloadPlayer (console version) is currently broken. Hassle Matt.");
     // plNetClientMgr::UnloadPlayer(key);
 }
@@ -4038,12 +4037,12 @@ PF_CONSOLE_CMD( Nav, MovePlayer,    // Group name, Function name
                 "moves a player from one paging unit to another" )  // Help string
 {
     char str[256];
-    plKey playerKey = FindSceneObjectByName(params[0], nil, str);
+    plKey playerKey = FindSceneObjectByName(plString::FromUtf8(params[0]), nil, str);
     PrintString(str);
     if( !playerKey )
         return;
 
-    plKey nodeKey = FindObjectByName(params[1], plSceneNode::Index(), nil, str);
+    plKey nodeKey = FindObjectByName(plString::FromUtf8(params[1]), plSceneNode::Index(), nil, str);
     PrintString(str);
     if( !nodeKey )
         return;
@@ -4348,9 +4347,8 @@ PF_CONSOLE_CMD( Access,
                    "Set the weight for a morphMod" )
 {
     char str[256];
-    char name[256];
     char* preFix = params[0];
-    sprintf(name, "%s_plMorphSequence_0", preFix);
+    plString name = plString::Format("%s_plMorphSequence_0", preFix);
     plKey key = FindObjectByName(name, plMorphSequence::Index(), nil, str);
     PrintString(str);
     if (!key)
@@ -4374,9 +4372,8 @@ PF_CONSOLE_CMD( Access,
                    "Activate a morphMod" )
 {
     char str[256];
-    char name[256];
     char* preFix = params[0];
-    sprintf(name, "%s_plMorphSequence_2", preFix);
+    plString name = plString::Format("%s_plMorphSequence_2", preFix);
     plKey key = FindObjectByName(name, plMorphSequence::Index(), nil, str);
     PrintString(str);
     if (!key)
@@ -4396,9 +4393,8 @@ PF_CONSOLE_CMD( Access,
                    "Activate a morphMod" )
 {
     char str[256];
-    char name[256];
     char* preFix = params[0];
-    sprintf(name, "%s_plMorphSequence_2", preFix);
+    plString name = plString::Format("%s_plMorphSequence_2", preFix);
     plKey key = FindObjectByName(name, plMorphSequence::Index(), nil, str);
     PrintString(str);
     if (!key)
@@ -4623,7 +4619,7 @@ PF_CONSOLE_CMD( Access,
                    "Test fading on visibility" )
 {
     char str[256];
-    plKey key = FindSceneObjectByName(params[0], nil, str);
+    plKey key = FindSceneObjectByName(plString::FromUtf8(params[0]), nil, str);
     PrintString(str);
     if( !key )
         return;
@@ -4655,7 +4651,7 @@ PF_CONSOLE_CMD( Access,
                    "Set the los test marker" )
 {
     char str[256];
-    plKey key = FindSceneObjectByName(params[0], nil, str);
+    plKey key = FindSceneObjectByName(plString::FromUtf8(params[0]), nil, str);
     PrintString(str);
     if( !key )
         return;
@@ -4669,7 +4665,7 @@ PF_CONSOLE_CMD( Access,
                    "Set the Los hack marker" )
 {
     char str[256];
-    plKey key = FindSceneObjectByName(params[0], nil, str);
+    plKey key = FindSceneObjectByName(plString::FromUtf8(params[0]), nil, str);
     PrintString(str);
 
     plSceneObject* so = nil;
@@ -4744,7 +4740,7 @@ PF_CONSOLE_CMD( Access,
                    "Fire shot along gun's z-axis, creating decal of radius <radius>, with optional max-range (def 1000)" )
 {
     char str[256];
-    plKey key = FindSceneObjectByName(params[0], nil, str);
+    plKey key = FindSceneObjectByName(plString::FromUtf8(params[0]), nil, str);
     PrintString(str);
     if( !key )
         return;
@@ -4825,7 +4821,7 @@ PF_CONSOLE_CMD( Access,
                "Add particle system <psys> to bulletMgr <bull>")
 {
     char str[256];
-    plKey bullKey = FindObjectByName(params[0], plDynaBulletMgr::Index(), nil, str, false);
+    plKey bullKey = FindObjectByName(plString::FromUtf8(params[0]), plDynaBulletMgr::Index(), nil, str, false);
     PrintString(str);
     if( !(bullKey && bullKey->GetObjectPtr()) )
     {
@@ -4833,7 +4829,7 @@ PF_CONSOLE_CMD( Access,
         return;
     }
 
-    plKey sysKey = FindSceneObjectByName(params[1], nil, str);
+    plKey sysKey = FindSceneObjectByName(plString::FromUtf8(params[1]), nil, str);
     if( !(sysKey && sysKey->GetObjectPtr()) )
     {
         PrintString("Psys not found");
@@ -5030,7 +5026,7 @@ static void IDisplayWaveVal(PrintFunk PrintString, plWaveSet7* wave, plWaveCmd::
     PrintString(buff);
 }
 
-static plWaveSet7* IGetWaveSet(PrintFunk PrintString, const char* name)
+static plWaveSet7* IGetWaveSet(PrintFunk PrintString, const plString& name)
 {
     char str[256];
     plKey waveKey = FindObjectByName(name, plWaveSet7::Index(), nil, str, false);
@@ -5046,7 +5042,7 @@ static plWaveSet7* IGetWaveSet(PrintFunk PrintString, const char* name)
     return waveSet;
 }
 
-static plWaveSet7* ICheckWaveParams(PrintFunk PrintString, const char* name, int numParams, int n, plWaveCmd::Cmd cmd)
+static plWaveSet7* ICheckWaveParams(PrintFunk PrintString, const plString& name, int numParams, int n, plWaveCmd::Cmd cmd)
 {
     if( !numParams )
     {
@@ -5083,7 +5079,7 @@ static hsScalar LimitVal(hsScalar val, hsScalar lo, hsScalar hi, PrintFunk Print
 
 static bool ISendWaveCmd1f(PrintFunk PrintString, pfConsoleCmdParam* params, int numParams, plWaveCmd::Cmd cmd)
 {
-    plWaveSet7* wave = ICheckWaveParams(PrintString, params[0], numParams, 2, cmd);
+    plWaveSet7* wave = ICheckWaveParams(PrintString, plString::FromUtf8(params[0]), numParams, 2, cmd);
     if( !wave )
         return false;
 
@@ -5162,7 +5158,7 @@ static bool ISendWaveCmd1f(PrintFunk PrintString, pfConsoleCmdParam* params, int
 
 static bool ISendWaveCmd2f(PrintFunk PrintString, pfConsoleCmdParam* params, int numParams, plWaveCmd::Cmd cmd)
 {
-    plWaveSet7* wave = ICheckWaveParams(PrintString, params[0], numParams, 3, cmd);
+    plWaveSet7* wave = ICheckWaveParams(PrintString, plString::FromUtf8(params[0]), numParams, 3, cmd);
     if( !wave )
         return false;
 
@@ -5205,7 +5201,7 @@ static bool ISendWaveCmd2f(PrintFunk PrintString, pfConsoleCmdParam* params, int
 
 static bool ISendWaveCmd3f(PrintFunk PrintString, pfConsoleCmdParam* params, int numParams, plWaveCmd::Cmd cmd)
 {
-    plWaveSet7* wave = ICheckWaveParams(PrintString, params[0], numParams, 4, cmd);
+    plWaveSet7* wave = ICheckWaveParams(PrintString, plString::FromUtf8(params[0]), numParams, 4, cmd);
     if( !wave )
         return false;
 
@@ -5243,7 +5239,7 @@ static bool ISendWaveCmd3f(PrintFunk PrintString, pfConsoleCmdParam* params, int
 
 static bool ISendWaveCmd4c(PrintFunk PrintString, pfConsoleCmdParam* params, int numParams, plWaveCmd::Cmd cmd)
 {
-    plWaveSet7* wave = ICheckWaveParams(PrintString, params[0], numParams, 4, cmd);
+    plWaveSet7* wave = ICheckWaveParams(PrintString, plString::FromUtf8(params[0]), numParams, 4, cmd);
     if( !wave )
         return false;
 
@@ -5279,7 +5275,7 @@ PF_CONSOLE_CMD( Wave, Log,  // Group name, Function name
                 "string waveSet",           // Params none
                 "Toggle logging for waves" )    // Help string
 {
-    const char* name = params[0];
+    plString name = plString::FromUtf8(params[0]);
     plWaveSet7* waveSet = IGetWaveSet(PrintString, name);
     if( waveSet )
     {
@@ -5290,7 +5286,7 @@ PF_CONSOLE_CMD( Wave, Log,  // Group name, Function name
             waveSet->StopLog();
 
         char buff[256];
-        sprintf(buff, "Logging for %s now %s", name, logging ? "on" : "off");
+        sprintf(buff, "Logging for %s now %s", name.c_str(), logging ? "on" : "off");
         PrintString(buff);
     }
 }
@@ -5299,7 +5295,7 @@ PF_CONSOLE_CMD( Wave, Graph,    // Group name, Function name
                 "string waveSet",           // Params none
                 "Toggle graphing lens for waves" )  // Help string
 {
-    const char* name = params[0];
+    plString name = plString::FromUtf8(params[0]);
     plWaveSet7* waveSet = IGetWaveSet(PrintString, name);
     if( waveSet )
     {
@@ -5310,7 +5306,7 @@ PF_CONSOLE_CMD( Wave, Graph,    // Group name, Function name
             waveSet->StopGraph();
 
         char buff[256];
-        sprintf(buff, "Graphing for %s now %s", name, graphing ? "on" : "off");
+        sprintf(buff, "Graphing for %s now %s", name.c_str(), graphing ? "on" : "off");
         PrintString(buff);
     }
 }
@@ -5514,7 +5510,7 @@ PF_CONSOLE_CMD( SceneObject_SetEnable, Drawable,    // Group name, Function name
                 "Enable or disable drawing of a sceneobject" )  // Help string
 {
     char str[256];
-    plKey key = FindSceneObjectByName(params[0], nil, str);
+    plKey key = FindSceneObjectByName(plString::FromUtf8(params[0]), nil, str);
     PrintString(str);
     if (!key)
         return;
@@ -5533,7 +5529,7 @@ PF_CONSOLE_CMD( SceneObject_SetEnable, Physical,    // Group name, Function name
                 "Enable or disable the physical of a sceneobject" ) // Help string
 {
     char str[256];
-    plKey key = FindSceneObjectByName(params[0], nil, str);
+    plKey key = FindSceneObjectByName(plString::FromUtf8(params[0]), nil, str);
     PrintString(str);
     if (!key)
         return;
@@ -5575,7 +5571,7 @@ PF_CONSOLE_CMD( SceneObject_SetEnable, Audible,     // Group name, Function name
                 "Enable or disable the audible of a sceneobject" )  // Help string
 {
     char str[256];
-    plKey key = FindSceneObjectByName(params[0], nil, str);
+    plKey key = FindSceneObjectByName(plString::FromUtf8(params[0]), nil, str);
     PrintString(str);
     if (!key)
         return;
@@ -5594,7 +5590,7 @@ PF_CONSOLE_CMD( SceneObject_SetEnable, All,         // Group name, Function name
                 "Enable or disable all fxns of a sceneobject" ) // Help string
 {
     char str[256];
-    plKey key = FindSceneObjectByName(params[0], nil, str);
+    plKey key = FindSceneObjectByName(plString::FromUtf8(params[0]), nil, str);
     PrintString(str);
     if (!key)
         return;
@@ -5614,8 +5610,8 @@ PF_CONSOLE_CMD( SceneObject, Attach,            // Group name, Function name
 {
     char str[256];
 
-    const char* childName = params[0];
-    const char* parentName = params[1];
+    plString childName = plString::FromUtf8(params[0]);
+    plString parentName = plString::FromUtf8(params[1]);
 
     plKey childKey = FindSceneObjectByName(childName, nil, str);
     if( !childKey )
@@ -5641,7 +5637,7 @@ PF_CONSOLE_CMD( SceneObject, Attach,            // Group name, Function name
     plAttachMsg* attMsg = TRACKED_NEW plAttachMsg(parentKey, child, plRefMsg::kOnRequest, nil);
     plgDispatch::MsgSend(attMsg);
 
-    sprintf(str, "%s now child of %s", childName, parentName);
+    sprintf(str, "%s now child of %s", childName.c_str(), parentName.c_str());
     PrintString(str);
 
 }
@@ -5652,7 +5648,7 @@ PF_CONSOLE_CMD( SceneObject, Detach,            // Group name, Function name
 {
     char str[256];
 
-    const char* childName = params[0];
+    plString childName = plString::FromUtf8(params[0]);
 
     plKey childKey = FindSceneObjectByName(childName, nil, str);
     if( !childKey )
@@ -5677,13 +5673,13 @@ PF_CONSOLE_CMD( SceneObject, Detach,            // Group name, Function name
         plAttachMsg* attMsg = TRACKED_NEW plAttachMsg(parentKey, child, plRefMsg::kOnRemove, nil);
         plgDispatch::MsgSend(attMsg);
 
-        sprintf(str, "%s detached from %s", childName, parentKey->GetName());
+        sprintf(str, "%s detached from %s", childName.c_str(), parentKey->GetName().c_str());
         PrintString(str);
         return;
     }
     else
     {
-        sprintf(str, "%s not attached to anything", childName);
+        sprintf(str, "%s not attached to anything", childName.c_str());
         PrintString(str);
         return;
     }
@@ -6238,7 +6234,7 @@ PF_CONSOLE_CMD( Age, SetSDLBool, "string varName, bool value, int index", "Set t
 
 PF_CONSOLE_GROUP( ParticleSystem ) // Defines a main command group
 
-void UpdateParticleParam(char *objName, Int32 paramID, hsScalar value, void (*PrintString)(const char *))
+void UpdateParticleParam(const plString &objName, Int32 paramID, hsScalar value, void (*PrintString)(const char *))
 {
     char str[256];
     plKey key = FindSceneObjectByName(objName, nil, str);
@@ -6267,7 +6263,7 @@ PF_CONSOLE_CMD( ParticleSystem,                 // Group name
                 "string objName, float value",  // Params
                 "Set the particles-per-second generated" )  // Help string
 {
-    UpdateParticleParam(params[0], plParticleUpdateMsg::kParamParticlesPerSecond, params[1], PrintString);
+    UpdateParticleParam(plString::FromUtf8(params[0]), plParticleUpdateMsg::kParamParticlesPerSecond, params[1], PrintString);
 }
 
 PF_CONSOLE_CMD( ParticleSystem,                 // Group name
@@ -6275,7 +6271,7 @@ PF_CONSOLE_CMD( ParticleSystem,                 // Group name
                 "string objName, float value",  // Params
                 "Set the initial range of pitch of generated particles" )   // Help string
 {
-    UpdateParticleParam(params[0], plParticleUpdateMsg::kParamInitPitchRange, params[1], PrintString);
+    UpdateParticleParam(plString::FromUtf8(params[0]), plParticleUpdateMsg::kParamInitPitchRange, params[1], PrintString);
 }
 
 PF_CONSOLE_CMD( ParticleSystem,                 // Group name
@@ -6283,7 +6279,7 @@ PF_CONSOLE_CMD( ParticleSystem,                 // Group name
                 "string objName, float value",  // Params
                 "Set the initial range of yaw of generated particles" ) // Help string
 {
-    UpdateParticleParam(params[0], plParticleUpdateMsg::kParamInitYawRange, params[1], PrintString);
+    UpdateParticleParam(plString::FromUtf8(params[0]), plParticleUpdateMsg::kParamInitYawRange, params[1], PrintString);
 }
 
 PF_CONSOLE_CMD( ParticleSystem,                 // Group name
@@ -6291,7 +6287,7 @@ PF_CONSOLE_CMD( ParticleSystem,                 // Group name
                 "string objName, float value",  // Params
                 "Set the minimum initial velocity of generated particles" ) // Help string
 {
-    UpdateParticleParam(params[0], plParticleUpdateMsg::kParamVelMin, params[1], PrintString);
+    UpdateParticleParam(plString::FromUtf8(params[0]), plParticleUpdateMsg::kParamVelMin, params[1], PrintString);
 }
 
 PF_CONSOLE_CMD( ParticleSystem,                 // Group name
@@ -6299,7 +6295,7 @@ PF_CONSOLE_CMD( ParticleSystem,                 // Group name
                 "string objName, float value",  // Params
                 "Set the maximum initial velocity of generated particles" ) // Help string
 {
-    UpdateParticleParam(params[0], plParticleUpdateMsg::kParamVelMax, params[1], PrintString);
+    UpdateParticleParam(plString::FromUtf8(params[0]), plParticleUpdateMsg::kParamVelMax, params[1], PrintString);
 }
 
 PF_CONSOLE_CMD( ParticleSystem,                 // Group name
@@ -6307,7 +6303,7 @@ PF_CONSOLE_CMD( ParticleSystem,                 // Group name
                 "string objName, float value",  // Params
                 "Set the width of generated particles" )    // Help string
 {
-    UpdateParticleParam(params[0], plParticleUpdateMsg::kParamXSize, params[1], PrintString);
+    UpdateParticleParam(plString::FromUtf8(params[0]), plParticleUpdateMsg::kParamXSize, params[1], PrintString);
 }
 
 PF_CONSOLE_CMD( ParticleSystem,                 // Group name
@@ -6315,7 +6311,7 @@ PF_CONSOLE_CMD( ParticleSystem,                 // Group name
                 "string objName, float value",  // Params
                 "Set the height of generated particles" )   // Help string
 {
-    UpdateParticleParam(params[0], plParticleUpdateMsg::kParamYSize, params[1], PrintString);
+    UpdateParticleParam(plString::FromUtf8(params[0]), plParticleUpdateMsg::kParamYSize, params[1], PrintString);
 }
 
 PF_CONSOLE_CMD( ParticleSystem,                 // Group name
@@ -6323,7 +6319,7 @@ PF_CONSOLE_CMD( ParticleSystem,                 // Group name
                 "string objName, float value",  // Params
                 "Set the minimum width/height scaling of generated particles" ) // Help string
 {
-    UpdateParticleParam(params[0], plParticleUpdateMsg::kParamScaleMin, params[1], PrintString);
+    UpdateParticleParam(plString::FromUtf8(params[0]), plParticleUpdateMsg::kParamScaleMin, params[1], PrintString);
 }
 
 PF_CONSOLE_CMD( ParticleSystem,                 // Group name
@@ -6331,7 +6327,7 @@ PF_CONSOLE_CMD( ParticleSystem,                 // Group name
                 "string objName, float value",  // Params
                 "Set the maximum width/height scaling of generated particles" ) // Help string
 {
-    UpdateParticleParam(params[0], plParticleUpdateMsg::kParamScaleMax, params[1], PrintString);
+    UpdateParticleParam(plString::FromUtf8(params[0]), plParticleUpdateMsg::kParamScaleMax, params[1], PrintString);
 }
 
 PF_CONSOLE_CMD( ParticleSystem,                 // Group name
@@ -6339,7 +6335,7 @@ PF_CONSOLE_CMD( ParticleSystem,                 // Group name
                 "string objName, float value",  // Params
                 "Set the remaining life of the particle generator" )    // Help string
 {
-    UpdateParticleParam(params[0], plParticleUpdateMsg::kParamGenLife, params[1], PrintString);
+    UpdateParticleParam(plString::FromUtf8(params[0]), plParticleUpdateMsg::kParamGenLife, params[1], PrintString);
 }
 
 PF_CONSOLE_CMD( ParticleSystem,                 // Group name
@@ -6347,7 +6343,7 @@ PF_CONSOLE_CMD( ParticleSystem,                 // Group name
                 "string objName, float value",  // Params
                 "Set the minimum lifespan of generated particles (negative values make them immortal)" )    // Help string
 {
-    UpdateParticleParam(params[0], plParticleUpdateMsg::kParamPartLifeMin, params[1], PrintString);
+    UpdateParticleParam(plString::FromUtf8(params[0]), plParticleUpdateMsg::kParamPartLifeMin, params[1], PrintString);
 }
 
 PF_CONSOLE_CMD( ParticleSystem,                 // Group name
@@ -6355,7 +6351,7 @@ PF_CONSOLE_CMD( ParticleSystem,                 // Group name
                 "string objName, float value",  // Params
                 "Set the max lifespan of generated particles" ) // Help string
 {
-    UpdateParticleParam(params[0], plParticleUpdateMsg::kParamPartLifeMax, params[1], PrintString);
+    UpdateParticleParam(plString::FromUtf8(params[0]), plParticleUpdateMsg::kParamPartLifeMax, params[1], PrintString);
 }
 
 PF_CONSOLE_CMD( ParticleSystem,
@@ -6364,7 +6360,7 @@ PF_CONSOLE_CMD( ParticleSystem,
                "Creates a system (if necessary) on the avatar, and transfers particles" )
 {
     char str[256];
-    plKey key = FindSceneObjectByName(params[0], nil, str);
+    plKey key = FindSceneObjectByName(plString::FromUtf8(params[0]), nil, str);
     if (key == nil) 
         return;
     
@@ -6383,7 +6379,7 @@ PF_CONSOLE_CMD( ParticleSystem,
                "Flag some particles for death." )
 {
     char str[256];
-    plKey key = FindSceneObjectByName(params[0], nil, str);
+    plKey key = FindSceneObjectByName(plString::FromUtf8(params[0]), nil, str);
     if (key == nil) 
         return;
     
@@ -6402,7 +6398,7 @@ PF_CONSOLE_CMD( ParticleSystem,
 
 PF_CONSOLE_SUBGROUP( ParticleSystem, Flock )
 
-static plParticleFlockEffect *FindFlock(char *objName)
+static plParticleFlockEffect *FindFlock(const plString &objName)
 {
     char str[256];
     plKey key = FindSceneObjectByName(objName, nil, str);
@@ -6430,7 +6426,7 @@ PF_CONSOLE_CMD( ParticleSystem_Flock,
                "string objName, float x, float y, float z",
                "Set the flock's goal to be an offset from its sceneObject")
 {
-    plParticleEffect *flock = FindFlock(params[0]);
+    plParticleEffect *flock = FindFlock(plString::FromUtf8(params[0]));
     if (flock)
     {
         (TRACKED_NEW plParticleFlockMsg(nil, flock->GetKey(), 0, plParticleFlockMsg::kFlockCmdSetOffset, params[1], params[2], params[3]))->Send();
@@ -6442,7 +6438,7 @@ PF_CONSOLE_CMD( ParticleSystem_Flock,
                "string objName, float x, float y, float z",
                "Set the goal for particles that leave the flock")
 {
-    plParticleEffect *flock = FindFlock(params[0]);
+    plParticleEffect *flock = FindFlock(plString::FromUtf8(params[0]));
     if (flock)
     {
         (TRACKED_NEW plParticleFlockMsg(nil, flock->GetKey(), 0, plParticleFlockMsg::kFlockCmdSetDissentPoint, params[1], params[2], params[3]))->Send();
@@ -6454,7 +6450,7 @@ PF_CONSOLE_CMD( ParticleSystem_Flock,
                "string objName, float value",
                "")
 {
-    plParticleFlockEffect *flock = FindFlock(params[0]);
+    plParticleFlockEffect *flock = FindFlock(plString::FromUtf8(params[0]));
     if (flock)
         flock->SetInfluenceAvgRadius(params[1]);
     else
@@ -6466,7 +6462,7 @@ PF_CONSOLE_CMD( ParticleSystem_Flock,
                "string objName, float value",
                "")
 {
-    plParticleFlockEffect *flock = FindFlock(params[0]);
+    plParticleFlockEffect *flock = FindFlock(plString::FromUtf8(params[0]));
     if (flock)
         flock->SetInfluenceRepelRadius(params[1]);
     else
@@ -6478,7 +6474,7 @@ PF_CONSOLE_CMD( ParticleSystem_Flock,
                "string objName, float value",
                "")
 {
-    plParticleFlockEffect *flock = FindFlock(params[0]);
+    plParticleFlockEffect *flock = FindFlock(plString::FromUtf8(params[0]));
     if (flock)
         flock->SetGoalRadius(params[1]);
     else
@@ -6490,7 +6486,7 @@ PF_CONSOLE_CMD( ParticleSystem_Flock,
                "string objName, float value",
                "")
 {
-    plParticleFlockEffect *flock = FindFlock(params[0]);
+    plParticleFlockEffect *flock = FindFlock(plString::FromUtf8(params[0]));
     if (flock)
         flock->SetFullChaseRadius(params[1]);
     else
@@ -6502,7 +6498,7 @@ PF_CONSOLE_CMD( ParticleSystem_Flock,
                "string objName, float value",
                "")
 {
-    plParticleFlockEffect *flock = FindFlock(params[0]);
+    plParticleFlockEffect *flock = FindFlock(plString::FromUtf8(params[0]));
     if (flock)
         flock->SetConformStr(params[1]);
     else
@@ -6514,7 +6510,7 @@ PF_CONSOLE_CMD( ParticleSystem_Flock,
                "string objName, float value",
                "")
 {
-    plParticleFlockEffect *flock = FindFlock(params[0]);
+    plParticleFlockEffect *flock = FindFlock(plString::FromUtf8(params[0]));
     if (flock)
         flock->SetRepelStr(params[1]);
     else
@@ -6526,7 +6522,7 @@ PF_CONSOLE_CMD( ParticleSystem_Flock,
                "string objName, float value",
                "")
 {
-    plParticleFlockEffect *flock = FindFlock(params[0]);
+    plParticleFlockEffect *flock = FindFlock(plString::FromUtf8(params[0]));
     if (flock)
         flock->SetGoalOrbitStr(params[1]);
     else
@@ -6538,7 +6534,7 @@ PF_CONSOLE_CMD( ParticleSystem_Flock,
                "string objName, float value",
                "")
 {
-    plParticleFlockEffect *flock = FindFlock(params[0]);
+    plParticleFlockEffect *flock = FindFlock(plString::FromUtf8(params[0]));
     if (flock)
         flock->SetGoalChaseStr(params[1]);
     else
@@ -6550,7 +6546,7 @@ PF_CONSOLE_CMD( ParticleSystem_Flock,
                "string objName, float value",
                "")
 {
-    plParticleFlockEffect *flock = FindFlock(params[0]);
+    plParticleFlockEffect *flock = FindFlock(plString::FromUtf8(params[0]));
     if (flock)
         flock->SetMaxOrbitSpeed(params[1]);
     else
@@ -6562,7 +6558,7 @@ PF_CONSOLE_CMD( ParticleSystem_Flock,
                "string objName, float value",
                "")
 {
-    plParticleFlockEffect *flock = FindFlock(params[0]);
+    plParticleFlockEffect *flock = FindFlock(plString::FromUtf8(params[0]));
     if (flock)
         flock->SetMaxChaseSpeed(params[1]);
     else
@@ -6580,7 +6576,7 @@ PF_CONSOLE_CMD( ParticleSystem_Flock,
 
 PF_CONSOLE_GROUP( Animation ) // Defines a main command group
 
-void SendAnimCmdMsg(char *objName, plMessage *msg)
+void SendAnimCmdMsg(const plString &objName, plMessage *msg)
 {
     char str[256];
     plKey key = FindSceneObjectByName(objName, nil, str);
@@ -6603,7 +6599,7 @@ PF_CONSOLE_CMD( Animation,                          // Group name
     msg->SetCmd(plAnimCmdMsg::kContinue);
     msg->SetAnimName(nil);
     msg->SetBCastFlag(plMessage::kPropagateToModifiers);
-    SendAnimCmdMsg(params[0], msg);
+    SendAnimCmdMsg(plString::FromUtf8(params[0]), msg);
 }
 
 PF_CONSOLE_CMD( Animation,                          // Group name
@@ -6615,7 +6611,7 @@ PF_CONSOLE_CMD( Animation,                          // Group name
     msg->SetCmd(plAnimCmdMsg::kStop);
     msg->SetAnimName(nil);
     msg->SetBCastFlag(plMessage::kPropagateToModifiers);
-    SendAnimCmdMsg(params[0], msg);
+    SendAnimCmdMsg(plString::FromUtf8(params[0]), msg);
 }
 
 PF_CONSOLE_CMD( Animation,                          // Group name
@@ -6629,7 +6625,7 @@ PF_CONSOLE_CMD( Animation,                          // Group name
     msg->fBlendRate = params[3];
     msg->SetAnimName(params[1]);
     msg->SetBCastFlag(plMessage::kPropagateToModifiers);
-    SendAnimCmdMsg(params[0], msg);
+    SendAnimCmdMsg(plString::FromUtf8(params[0]), msg);
 }
 
 PF_CONSOLE_CMD( Animation,                          // Group name
@@ -6643,7 +6639,7 @@ PF_CONSOLE_CMD( Animation,                          // Group name
     msg->fAmpRate = params[3];
     msg->SetAnimName(params[1]);
     msg->SetBCastFlag(plMessage::kPropagateToModifiers);
-    SendAnimCmdMsg(params[0], msg);
+    SendAnimCmdMsg(plString::FromUtf8(params[0]), msg);
 }
 
 PF_CONSOLE_CMD( Animation,                          // Group name
@@ -6657,7 +6653,7 @@ PF_CONSOLE_CMD( Animation,                          // Group name
     msg->fSpeedChangeRate = params[3];
     msg->SetAnimName(params[1]);
     msg->SetBCastFlag(plMessage::kPropagateToModifiers);
-    SendAnimCmdMsg(params[0], msg);
+    SendAnimCmdMsg(plString::FromUtf8(params[0]), msg);
 }
 
 PF_CONSOLE_CMD( Animation,
@@ -6667,7 +6663,7 @@ PF_CONSOLE_CMD( Animation,
 {
     plAnimDebugList *adl = plClient::GetInstance()->fAnimDebugList;
     if (adl) 
-        adl->AddObjects(params[0]);
+        adl->AddObjects(plString::FromUtf8(params[0]));
 }
 
 PF_CONSOLE_CMD( Animation,
@@ -6677,7 +6673,7 @@ PF_CONSOLE_CMD( Animation,
 {
     plAnimDebugList *adl = plClient::GetInstance()->fAnimDebugList;
     if (adl)
-        adl->RemoveObjects(params[0]);
+        adl->RemoveObjects(plString::FromUtf8(params[0]));
 }
 
 PF_CONSOLE_CMD( Animation,
diff --git a/Sources/Plasma/FeatureLib/pfConsole/pfConsoleCommandsNet.cpp b/Sources/Plasma/FeatureLib/pfConsole/pfConsoleCommandsNet.cpp
index 4268604a..27f2ea12 100644
--- a/Sources/Plasma/FeatureLib/pfConsole/pfConsoleCommandsNet.cpp
+++ b/Sources/Plasma/FeatureLib/pfConsole/pfConsoleCommandsNet.cpp
@@ -196,9 +196,9 @@ PF_CONSOLE_FILE_DUMMY(Net)
 // utility functions
 //
 //////////////////////////////////////////////////////////////////////////////
-plKey FindSceneObjectByName(const char* name, const char* ageName, char* statusStr, bool subString=false);
-plKey FindObjectByName(const char* name, int type, const char* ageName, char* statusStr, bool subString=false);
-plKey FindObjectByNameAndType(const char* name, const char* typeName, const char* ageName, 
+plKey FindSceneObjectByName(const plString& name, const char* ageName, char* statusStr, bool subString=false);
+plKey FindObjectByName(const plString& name, int type, const char* ageName, char* statusStr, bool subString=false);
+plKey FindObjectByNameAndType(const plString& name, const char* typeName, const char* ageName,
                                char* statusStr, bool subString=false);
 void PrintStringF(void pfun(const char *),const char * fmt, ...);
 
@@ -508,7 +508,7 @@ PF_CONSOLE_CMD( Net,            // groupName
                "Instructs the server to only send me updates about this object periodically" )  // helpString
 {   
     char str[256];
-    plKey key = FindSceneObjectByName(params[0], nil, str);
+    plKey key = FindSceneObjectByName(plString::FromUtf8(params[0]), nil, str);
     PrintString(str);
     if (!key)
         return;
diff --git a/Sources/Plasma/FeatureLib/pfConsole/pfDispatchLog.cpp b/Sources/Plasma/FeatureLib/pfConsole/pfDispatchLog.cpp
index 7abc9027..9761f828 100644
--- a/Sources/Plasma/FeatureLib/pfConsole/pfDispatchLog.cpp
+++ b/Sources/Plasma/FeatureLib/pfConsole/pfDispatchLog.cpp
@@ -45,6 +45,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 #include "pnMessage/plMessage.h"
 #include "pnKeyedObject/plKey.h"
 #include "hsWindows.h"
+#include "plString.h"
 
 static bool DumpSpecificMsgInfo(plMessage* msg, std::string& info);
 
@@ -137,9 +138,9 @@ void plDispatchLog::DumpMsg(plMessage* msg, int numReceivers, int sendTimeMs, In
 
     fLog->AddLineF("%sDispatched (%d) %d ms: time=%d CName=%s, sndr=%s, rcvr(%d)=%s, flags=0x%lx, tstamp=%f\n",
         indentStr, numReceivers, sendTimeMs,
-        int(sendTime), msg->ClassName(), msg->fSender?msg->fSender->GetName():"nil",
+        int(sendTime), msg->ClassName(), msg->fSender?msg->fSender->GetName().c_str():"nil",
         msg->GetNumReceivers(), msg->GetNumReceivers() && msg->GetReceiver(0)
-            ? msg->GetReceiver(0)->GetName():"nil",
+            ? msg->GetReceiver(0)->GetName().c_str():"nil",
         msg->fBCastFlags, msg->fTimeStamp);
 
     lastTime=curTime;
diff --git a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIControlMod.cpp b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIControlMod.cpp
index 7fc3ebda..3b4ace00 100644
--- a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIControlMod.cpp
+++ b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIControlMod.cpp
@@ -587,11 +587,11 @@ hsBool  pfGUIControlMod::MsgReceive( plMessage *msg )
 
     if( rend )
     {
-        plProfile_BeginLap(GUITime, this->GetKey()->GetUoid().GetObjectName());
+        plProfile_BeginLap(GUITime, this->GetKey()->GetUoid().GetObjectName().c_str());
         // Only need it once
         if( ISetUpDynTextMap( rend->Pipeline() ) )
             plgDispatch::Dispatch()->UnRegisterForExactType( plRenderMsg::Index(), GetKey() );
-        plProfile_EndLap(GUITime, this->GetKey()->GetUoid().GetObjectName());
+        plProfile_EndLap(GUITime, this->GetKey()->GetUoid().GetObjectName().c_str());
         return true;
     }
 
diff --git a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUICtrlGenerator.cpp b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUICtrlGenerator.cpp
index 78aba3a6..58aff8dd 100644
--- a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUICtrlGenerator.cpp
+++ b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUICtrlGenerator.cpp
@@ -122,22 +122,20 @@ pfGUICtrlGenerator  &pfGUICtrlGenerator::Instance( void )
 
 //// IGetNextKeyName /////////////////////////////////////////////////////////
 
-void    pfGUICtrlGenerator::IGetNextKeyName( char *name, const char *prefix )
+plString pfGUICtrlGenerator::IGetNextKeyName( const char *prefix )
 {
     static UInt32 keyCount = 0;
 
-
-    sprintf( name, "%s%d", prefix, keyCount++ );
+    return plString::Format( "%s%d", prefix, keyCount++ );
 }
 
 //// IAddKey /////////////////////////////////////////////////////////////////
 
 plKey pfGUICtrlGenerator::IAddKey( hsKeyedObject *ko, const char *prefix )
 {
-    char    keyName[ 128 ];
-
+    plString keyName;
 
-    IGetNextKeyName( keyName, prefix );
+    keyName = IGetNextKeyName( prefix );
     return hsgResMgr::ResMgr()->NewKey( keyName, ko, plLocation::kGlobalFixedLoc );
 }
 
diff --git a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUICtrlGenerator.h b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUICtrlGenerator.h
index 123d12d6..628b5da6 100644
--- a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUICtrlGenerator.h
+++ b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUICtrlGenerator.h
@@ -85,7 +85,7 @@ class pfGUICtrlGenerator
 
 
         plKey       IAddKey( hsKeyedObject *ko, const char *prefix );
-        void        IGetNextKeyName( char *name, const char *prefix );
+        plString    IGetNextKeyName( const char *prefix );
 
         hsGMaterial *ICreateSolidMaterial( hsColorRGBA &color );
 
diff --git a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIListElement.cpp b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIListElement.cpp
index 1376c87a..1a97d260 100644
--- a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIListElement.cpp
+++ b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIListElement.cpp
@@ -221,8 +221,7 @@ pfGUIListPicture::pfGUIListPicture( plKey mipKey, hsBool respectAlpha ) : pfGUIL
     {
         // Gotta make and grab an uncompressed one
         plMipmap *uncompBuffer = hsCodecManager::Instance().CreateUncompressedMipmap( mip, hsCodecManager::k32BitDepth );
-        char str[ 512 ];
-        sprintf( str, "%s_uncomp", mip->GetKeyName() );
+        plString str = plString::Format( "%s_uncomp", mip->GetKeyName() );
         fMipmapKey = hsgResMgr::ResMgr()->NewKey( str, uncompBuffer, fMipmapKey->GetUoid().GetLocation() );
         fMipmapKey->RefObject();
     }
diff --git a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIPopUpMenu.cpp b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIPopUpMenu.cpp
index 777066eb..7efd73c6 100644
--- a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIPopUpMenu.cpp
+++ b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIPopUpMenu.cpp
@@ -97,8 +97,7 @@ class pfPopUpKeyGenerator
 
         plKey   CreateKey( hsKeyedObject *ko )
         {
-            char name[ 256 ];
-            sprintf( name, "%s-%d", fPrefix, fKeyCount++ );
+            plString name = plString::Format( "%s-%d", fPrefix, fKeyCount++ );
 
             return hsgResMgr::ResMgr()->NewKey( name, ko, fLoc );
         }
diff --git a/Sources/Plasma/FeatureLib/pfJournalBook/pfJournalBook.cpp b/Sources/Plasma/FeatureLib/pfJournalBook/pfJournalBook.cpp
index 91a40e62..de0fae63 100644
--- a/Sources/Plasma/FeatureLib/pfJournalBook/pfJournalBook.cpp
+++ b/Sources/Plasma/FeatureLib/pfJournalBook/pfJournalBook.cpp
@@ -446,7 +446,7 @@ public:
 
 //// Book data class /////////////////////////////////////////////////////////
 
-pfBookData::pfBookData(const char *guiName /* = nil */)
+pfBookData::pfBookData(const plString &guiName /* = nil */)
 {
     fCurrBook = nil;
     fDialog = nil;
@@ -470,10 +470,10 @@ pfBookData::pfBookData(const char *guiName /* = nil */)
     fEditable = false;
     fAdjustCursorTo = -1;
     
-    if (guiName)
+    if (!guiName.IsEmpty())
         fGUIName = guiName;
     else
-        fGUIName = "BkBook";
+        fGUIName = _TEMP_CONVERT_FROM_LITERAL("BkBook");
 }
 
 pfBookData::~pfBookData()
@@ -1137,18 +1137,18 @@ void pfBookData::EnableEditGUI(hsBool enable/* =true */)
 //// Our Singleton Stuff /////////////////////////////////////////////////////
 
 //pfJournalBook *pfJournalBook::fInstance = nil;
-std::map<std::string,pfBookData*> pfJournalBook::fBookGUIs;
+std::map<plString,pfBookData*> pfJournalBook::fBookGUIs;
 
 void    pfJournalBook::SingletonInit( void )
 {
-    fBookGUIs["BkBook"] = TRACKED_NEW pfBookData(); // load the default book data object
-    hsgResMgr::ResMgr()->NewKey("BkBook",fBookGUIs["BkBook"],pfGameGUIMgr::GetInstance()->GetKey()->GetUoid().GetLocation());
-    fBookGUIs["BkBook"]->LoadGUI();
+    fBookGUIs[_TEMP_CONVERT_FROM_LITERAL("BkBook")] = TRACKED_NEW pfBookData(); // load the default book data object
+    hsgResMgr::ResMgr()->NewKey(_TEMP_CONVERT_FROM_LITERAL("BkBook"),fBookGUIs[_TEMP_CONVERT_FROM_LITERAL("BkBook")],pfGameGUIMgr::GetInstance()->GetKey()->GetUoid().GetLocation());
+    fBookGUIs[_TEMP_CONVERT_FROM_LITERAL("BkBook")]->LoadGUI();
 }
 
 void    pfJournalBook::SingletonShutdown( void )
 {
-    std::map<std::string,pfBookData*>::iterator i = fBookGUIs.begin();
+    std::map<plString,pfBookData*>::iterator i = fBookGUIs.begin();
     while (i != fBookGUIs.end())
     {
         pfBookData *bookData = i->second;
@@ -1159,7 +1159,7 @@ void    pfJournalBook::SingletonShutdown( void )
     fBookGUIs.clear();
 }
 
-void    pfJournalBook::LoadGUI( const char *guiName )
+void    pfJournalBook::LoadGUI( const plString &guiName )
 {
     if (fBookGUIs.find(guiName) == fBookGUIs.end()) // is it already loaded?
     { // nope, load it
@@ -1169,11 +1169,11 @@ void    pfJournalBook::LoadGUI( const char *guiName )
     }
 }
 
-void    pfJournalBook::UnloadGUI( const char *guiName )
+void    pfJournalBook::UnloadGUI( const plString &guiName )
 {
-    if (strcmp(guiName,"BkBook")==0)
+    if (guiName.Compare("BkBook")==0)
         return; // do not allow people to unload the default book gui
-    std::map<std::string,pfBookData*>::iterator loc = fBookGUIs.find(guiName);
+    std::map<plString,pfBookData*>::iterator loc = fBookGUIs.find(guiName);
     if (loc != fBookGUIs.end()) // make sure it's loaded
     {
         fBookGUIs[guiName]->GetKey()->UnRefObject();
@@ -1184,17 +1184,17 @@ void    pfJournalBook::UnloadGUI( const char *guiName )
 
 void    pfJournalBook::UnloadAllGUIs()
 {
-    std::map<std::string,pfBookData*>::iterator i = fBookGUIs.begin();
-    std::vector<std::string> names;
+    std::map<plString,pfBookData*>::iterator i = fBookGUIs.begin();
+    std::vector<plString> names;
     while (i != fBookGUIs.end())
     {
-        std::string name = i->first;
+        plString name = i->first;
         names.push_back(name); // store a list of keys
         i++;
     }
     int idx;
     for (idx = 0; idx < names.size(); idx++)
-        UnloadGUI(names[idx].c_str()); // UnloadGUI won't unload BkBook
+        UnloadGUI(names[idx]); // UnloadGUI won't unload BkBook
 }
 
 //// Constructor /////////////////////////////////////////////////////////////
@@ -1203,16 +1203,16 @@ void    pfJournalBook::UnloadAllGUIs()
 // key is the keyed object to send event messages to (see <img> tag).
 
 pfJournalBook::pfJournalBook( const char *esHTMLSource, plKey coverImageKey, plKey callbackKey /*= nil*/, 
-                                const plLocation &hintLoc /* = plLocation::kGlobalFixedLoc */, const char *guiName /* = nil */ )
+                                const plLocation &hintLoc /* = plLocation::kGlobalFixedLoc */, const plString &guiName /* = nil */ )
 {
-    if (guiName && (strcmp(guiName,"") != 0))
+    if (!guiName.IsEmpty())
         fCurBookGUI = guiName;
     else
-        fCurBookGUI = "BkBook";
+        fCurBookGUI = _TEMP_CONVERT_FROM_LITERAL("BkBook");
     if (fBookGUIs.find(fCurBookGUI) == fBookGUIs.end())
     {
-        fBookGUIs[fCurBookGUI] = TRACKED_NEW pfBookData(fCurBookGUI.c_str());
-        hsgResMgr::ResMgr()->NewKey(fCurBookGUI.c_str(),fBookGUIs[fCurBookGUI],pfGameGUIMgr::GetInstance()->GetKey()->GetUoid().GetLocation());
+        fBookGUIs[fCurBookGUI] = TRACKED_NEW pfBookData(fCurBookGUI);
+        hsgResMgr::ResMgr()->NewKey(fCurBookGUI,fBookGUIs[fCurBookGUI],pfGameGUIMgr::GetInstance()->GetKey()->GetUoid().GetLocation());
         fBookGUIs[fCurBookGUI]->LoadGUI();
     }
     
@@ -1239,16 +1239,16 @@ pfJournalBook::pfJournalBook( const char *esHTMLSource, plKey coverImageKey, plK
 }
 
 pfJournalBook::pfJournalBook( const wchar_t *esHTMLSource, plKey coverImageKey, plKey callbackKey /*= nil*/, 
-                                const plLocation &hintLoc /* = plLocation::kGlobalFixedLoc */, const char *guiName /* = nil */ )
+                                const plLocation &hintLoc /* = plLocation::kGlobalFixedLoc */, const plString &guiName /* = nil */ )
 {
-    if (guiName && (strcmp(guiName,"") != 0))
+    if (!guiName.IsEmpty())
         fCurBookGUI = guiName;
     else
-        fCurBookGUI = "BkBook";
+        fCurBookGUI = _TEMP_CONVERT_FROM_LITERAL("BkBook");
     if (fBookGUIs.find(fCurBookGUI) == fBookGUIs.end())
     {
-        fBookGUIs[fCurBookGUI] = TRACKED_NEW pfBookData(fCurBookGUI.c_str());
-        hsgResMgr::ResMgr()->NewKey(fCurBookGUI.c_str(),fBookGUIs[fCurBookGUI],pfGameGUIMgr::GetInstance()->GetKey()->GetUoid().GetLocation());
+        fBookGUIs[fCurBookGUI] = TRACKED_NEW pfBookData(fCurBookGUI);
+        hsgResMgr::ResMgr()->NewKey(fCurBookGUI,fBookGUIs[fCurBookGUI],pfGameGUIMgr::GetInstance()->GetKey()->GetUoid().GetLocation());
         fBookGUIs[fCurBookGUI]->LoadGUI();
     }
     
@@ -1288,12 +1288,12 @@ hsBool  pfJournalBook::MsgReceive( plMessage *pMsg )
     return hsKeyedObject::MsgReceive( pMsg );
 }
 
-void    pfJournalBook::SetGUI( const char *guiName )
+void    pfJournalBook::SetGUI( const plString &guiName )
 {
-    if (guiName && (strcmp(guiName,"") != 0))
+    if (!guiName.IsEmpty())
         fCurBookGUI = guiName;
     if (fBookGUIs.find(fCurBookGUI) == fBookGUIs.end())
-        fCurBookGUI = "BkBook"; // requested GUI isn't loaded, so use default GUI
+        fCurBookGUI = _TEMP_CONVERT_FROM_LITERAL("BkBook"); // requested GUI isn't loaded, so use default GUI
     SetEditable(fWantEditing); // make sure that if we want editing, to set it
     ICompileSource(fUncompiledSource.c_str(), fDefLoc); // recompile the source to be safe
 }
@@ -2501,20 +2501,19 @@ void    pfJournalBook::IFreeSource( void )
 
 plKey   pfJournalBook::IGetMipmapKey( const wchar_t *name, const plLocation &loc )
 {
-    char *cName = hsWStringToString(name);
+    plString cName = plString::FromWchar(name);
 #ifndef PLASMA_EXTERNAL_RELEASE
-    if( strchr( cName, '/' ) != nil || strchr( cName, '\\' ) != nil )
+    if( cName.Find( '/' ) >= 0 || cName.Find( '\\' ) >= 0 )
     {
         // For internal use only--allow local path names of PNG and JPEG images, to
         // facilitate fast prototyping
         plMipmap *mip;
-        if( strstr( cName, ".png" ) != nil )
-            mip = plPNG::Instance().ReadFromFile( cName );
+        if( cName.Find( ".png" ) >= 0 )
+            mip = plPNG::Instance().ReadFromFile( _TEMP_CONVERT_TO_CONST_CHAR( cName ) );
         else
-            mip = plJPEG::Instance().ReadFromFile( cName );
+            mip = plJPEG::Instance().ReadFromFile( _TEMP_CONVERT_TO_CONST_CHAR( cName ) );
 
         hsgResMgr::ResMgr()->NewKey( cName, mip, loc );
-        delete [] cName;
         return mip->GetKey();
     }
 #endif
@@ -2524,7 +2523,6 @@ plKey   pfJournalBook::IGetMipmapKey( const wchar_t *name, const plLocation &loc
     plKey key = hsgResMgr::ResMgr()->FindKey( myUoid );
     if( key != nil )
     {
-        delete [] cName;
         return key;
     }
 
@@ -2535,7 +2533,6 @@ plKey   pfJournalBook::IGetMipmapKey( const wchar_t *name, const plLocation &loc
     key = hsgResMgr::ResMgr()->FindKey( myUoid );
     if( key != nil )
     {
-        delete [] cName;
         return key;
     }
 
@@ -2548,13 +2545,11 @@ plKey   pfJournalBook::IGetMipmapKey( const wchar_t *name, const plLocation &loc
             key = plKeyFinder::Instance().StupidSearch( thisAge, nil, plMipmap::Index(), cName, true );
             if( key != nil )
             {
-                delete [] cName;
                 return key;
             }
         }
     }
 
-    delete [] cName;
     return nil;
 }
 
@@ -3043,13 +3038,13 @@ plLayerBink *pfJournalBook::IMakeMovieLayer(pfEsHTMLChunk *chunk, UInt16 x, UInt
 
         // We'll need a unique name. This is a hack, but an effective hack.
         static int uniqueSuffix = 0;
-        char buff[256];
+        plString buff;
 
-        sprintf(buff, "%s_%d_ml", GetKey()->GetName(), uniqueSuffix);
+        buff = plString::Format("%s_%d_ml", GetKey()->GetName().c_str(), uniqueSuffix);
         layer = TRACKED_NEW plLayer;
         hsgResMgr::ResMgr()->NewKey(buff, layer, GetKey()->GetUoid().GetLocation());
 
-        sprintf(buff, "%s_%d_m", GetKey()->GetName(), uniqueSuffix++);
+        buff = plString::Format("%s_%d_m", GetKey()->GetName().c_str(), uniqueSuffix++);
         movieLayer = TRACKED_NEW plLayerBink;
         hsgResMgr::ResMgr()->NewKey(buff, movieLayer, GetKey()->GetUoid().GetLocation());
         movieLayer->GetKey()->RefObject(); // we want to own a ref so we can nuke it at will
@@ -3192,8 +3187,7 @@ plLayerInterface *pfJournalBook::IMakeBaseLayer(plMipmap *image)
 
     // We'll need a unique name. This is a hack, but an effective hack.
     static int uniqueSuffix = 0;
-    char buff[256];
-    sprintf(buff, "%s_%d", GetKey()->GetName(), uniqueSuffix++);
+    plString buff = plString::Format("%s_%d", GetKey()->GetName().c_str(), uniqueSuffix++);
 
     plLayer* layer = TRACKED_NEW plLayer;
     hsgResMgr::ResMgr()->NewKey(buff, layer, GetKey()->GetUoid().GetLocation());
@@ -3247,8 +3241,7 @@ plLayerInterface *pfJournalBook::IMakeDecalLayer(pfEsHTMLChunk *decalChunk, plMi
 
     // We'll need a unique name. This is a hack, but an effective hack.
     static int uniqueSuffix = 0;
-    char buff[256];
-    sprintf(buff, "%s_%d_d", GetKey()->GetName(), uniqueSuffix++);
+    plString buff = plString::Format("%s_%d_d", GetKey()->GetName().c_str(), uniqueSuffix++);
 
     plLayer* layer = TRACKED_NEW plLayer;
     hsgResMgr::ResMgr()->NewKey(buff, layer, GetKey()->GetUoid().GetLocation());
diff --git a/Sources/Plasma/FeatureLib/pfJournalBook/pfJournalBook.h b/Sources/Plasma/FeatureLib/pfJournalBook/pfJournalBook.h
index 6be8fc27..affa289a 100644
--- a/Sources/Plasma/FeatureLib/pfJournalBook/pfJournalBook.h
+++ b/Sources/Plasma/FeatureLib/pfJournalBook/pfJournalBook.h
@@ -211,7 +211,7 @@ public:
         kTurnBackPage
     };
     
-    pfBookData(const char *guiName = nil);
+    pfBookData(const plString &guiName = plString::Null);
     virtual ~pfBookData();
 
     void LoadGUI(); // need this seperate because the plKey isn't setup until the constructor is done
@@ -284,7 +284,7 @@ protected:
         kRefDefaultCover
     };
 
-    std::string         fGUIName;
+    plString            fGUIName;
 
     // The pointer to our dialog
     pfGUIDialogMod      *fDialog;
@@ -362,8 +362,8 @@ class pfJournalBook : public hsKeyedObject
         // The constructor takes in the esHTML source for the journal, along with
         // the name of the mipmap to use as the cover of the book. The callback
         // key is the keyed object to send event messages to (see <img> tag).
-        pfJournalBook( const char *esHTMLSource, plKey coverImageKey = nil, plKey callbackKey = nil, const plLocation &hintLoc = plLocation::kGlobalFixedLoc, const char *guiName = nil );
-        pfJournalBook( const wchar_t *esHTMLSource, plKey coverImageKey = nil, plKey callbackKey = nil, const plLocation &hintLoc = plLocation::kGlobalFixedLoc, const char *guiName = nil );
+        pfJournalBook( const char *esHTMLSource, plKey coverImageKey = nil, plKey callbackKey = nil, const plLocation &hintLoc = plLocation::kGlobalFixedLoc, const plString &guiName = plString::Null );
+        pfJournalBook( const wchar_t *esHTMLSource, plKey coverImageKey = nil, plKey callbackKey = nil, const plLocation &hintLoc = plLocation::kGlobalFixedLoc, const plString &guiName = plString::Null );
 
         virtual ~pfJournalBook();
 
@@ -380,15 +380,15 @@ class pfJournalBook : public hsKeyedObject
         static void SingletonShutdown( void );
         
         // loads a gui
-        static void LoadGUI( const char *guiName );
+        static void LoadGUI( const plString &guiName );
 
         // unloads a gui if we don't need it any more and want to free up memory
-        static void UnloadGUI( const char *guiName );
+        static void UnloadGUI( const plString &guiName );
 
         // unloads all GUIs except for the default
         static void UnloadAllGUIs();
 
-        void    SetGUI( const char *guiName );
+        void    SetGUI( const plString &guiName );
 
         // Shows the book, optionally starting open or closed
         void    Show( hsBool startOpened = false );
@@ -505,8 +505,8 @@ class pfJournalBook : public hsKeyedObject
         // Current list of linkable image chunks we have visible on the screen, for quick hit testing
         hsTArray<pfEsHTMLChunk *>   fVisibleLinks;
 
-        static std::map<std::string,pfBookData*> fBookGUIs;
-        std::string fCurBookGUI;
+        static std::map<plString,pfBookData*> fBookGUIs;
+        plString fCurBookGUI;
 
         enum Refs
         {
diff --git a/Sources/Plasma/FeatureLib/pfPython/cyMisc.cpp b/Sources/Plasma/FeatureLib/pfPython/cyMisc.cpp
index 27d33639..a48ce09e 100644
--- a/Sources/Plasma/FeatureLib/pfPython/cyMisc.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/cyMisc.cpp
@@ -194,12 +194,12 @@ void cyMisc::ConsoleNet(const char* command, hsBool netForce)
 //  PURPOSE    : Execute a console command from a python script,
 //                  optionally propagate over the net
 //
-PyObject* cyMisc::FindSceneObject(const char* name, const char* ageName)
+PyObject* cyMisc::FindSceneObject(const plString& name, const char* ageName)
 {
     // assume that we won't find the sceneobject (key is equal to nil)
     plKey key=nil;
 
-    if ( name || name[0] != 0)
+    if ( !name.IsEmpty() )
     {
         const char* theAge = ageName;
         if ( ageName[0] == 0 )
@@ -209,18 +209,17 @@ PyObject* cyMisc::FindSceneObject(const char* name, const char* ageName)
 
     if ( key == nil )
     {
-        char errmsg[256];
-        sprintf(errmsg,"Sceneobject %s not found",name);
-        PyErr_SetString(PyExc_NameError, errmsg);
+        plString errmsg = plString::Format("Sceneobject %s not found",name.c_str());
+        PyErr_SetString(PyExc_NameError, errmsg.c_str());
         return nil; // return nil cause we errored
     }
     return pySceneObject::New(key);
 }
 
-PyObject* cyMisc::FindActivator(const char* name)
+PyObject* cyMisc::FindActivator(const plString& name)
 {
     plKey key = nil;
-    if (name && strlen(name) > 0)
+    if (!name.IsEmpty())
     {
         std::vector<plKey> keylist;
         plKeyFinder::Instance().ReallyStupidActivatorSearch(name, keylist);
@@ -453,9 +452,9 @@ hsBool cyMisc::WasLocallyNotified(pyKey &selfkey)
 //  PURPOSE    : Return the net client (account) name of the player whose avatar
 //              key is provided.
 //
-const char* cyMisc::GetClientName(pyKey &avKey)
+plString cyMisc::GetClientName(pyKey &avKey)
 {
-    return plNetClientMgr::GetInstance()->GetPlayerName(avKey.getKey()).s_str();
+    return plNetClientMgr::GetInstance()->GetPlayerName(avKey.getKey());
 }
 
 PyObject* cyMisc::GetAvatarKeyFromClientID(int clientID)
@@ -546,9 +545,9 @@ hsBool cyMisc::ValidateKey(pyKey& key)
 //
 //  PURPOSE    : Return the local net client (account) name
 //
-const char* cyMisc::GetLocalClientName()
+plString cyMisc::GetLocalClientName()
 {
-    return plNetClientMgr::GetInstance()->GetPlayerName().c_str();
+    return plNetClientMgr::GetInstance()->GetPlayerName();
 }
 
 
@@ -1910,7 +1909,7 @@ int cyMisc::GetNumParticles(pyKey& host)
 }
 
 
-void cyMisc::SetLightColorValue(pyKey& light, std::string lightName, hsScalar r, hsScalar g, hsScalar b, hsScalar a)
+void cyMisc::SetLightColorValue(pyKey& light, const plString& lightName, hsScalar r, hsScalar g, hsScalar b, hsScalar a)
 {
     // lightName is the name of the light object attached to the light that we want to talk to
     // for the bug lights, this would be "RTOmni-BugLightTest"
@@ -1958,7 +1957,7 @@ void cyMisc::SetLightColorValue(pyKey& light, std::string lightName, hsScalar r,
 }
 
 #include "pnMessage/plEnableMsg.h"
-void cyMisc::SetLightAnimationOn(pyKey& light, std::string lightName, hsBool start)
+void cyMisc::SetLightAnimationOn(pyKey& light, const plString& lightName, hsBool start)
 {
     // lightName is the name of the light object attached to the light that we want to talk to
     // for the bug lights, this would be "RTOmni-BugLightTest"
@@ -2449,28 +2448,26 @@ const char* cyMisc::GetCameraNumber(int number)
     plCameraModifier1* pCam = plVirtualCam1::Instance()->GetCameraNumber(number-1);
     if (pCam->GetTarget())
     {
-        const char* ret = pCam->GetTarget()->GetKeyName();
+        const char* ret = pCam->GetTarget()->GetKeyName().c_str();
         (ret==nil) ? "empty" : ret;
-        char str[256];
-        sprintf(str, "saving camera named %s to chronicle\n",ret);
-        plVirtualCam1::Instance()->AddMsgToLog(str);
+        plString str = plString::Format("saving camera named %s to chronicle\n",ret);
+        plVirtualCam1::Instance()->AddMsgToLog(str.c_str());
         return ret;
     }
     plVirtualCam1::Instance()->AddMsgToLog("sending empty to camera chronicle\n");
     return "empty";
 }
 
-void cyMisc::RebuildCameraStack(const char* name, const char* ageName)
+void cyMisc::RebuildCameraStack(const plString& name, const char* ageName)
 {
     plKey key=nil;
-    char str[256];
-    sprintf(str, "attempting to restore camera named %s from chronicle\n",name);
-    plVirtualCam1::Instance()->AddMsgToLog(str);
-        
-    if (strcmp(name, "empty") == 0)
+    plString str = plString::Format("attempting to restore camera named %s from chronicle\n",name.c_str());
+    plVirtualCam1::Instance()->AddMsgToLog(str.c_str());
+
+    if (name.Compare("empty") == 0)
         return;
 
-    if ( name || name[0] != 0)
+    if ( !name.IsEmpty() )
     {
         key=plKeyFinder::Instance().StupidSearch(nil,nil,plSceneObject::Index(), name, false);
     }
@@ -2481,9 +2478,8 @@ void cyMisc::RebuildCameraStack(const char* name, const char* ageName)
         {
             // give up and force built in 3rd person
             plVirtualCam1::Instance()->PushThirdPerson();
-            char errmsg[256];
-            sprintf(errmsg,"Sceneobject %s not found",name);
-            PyErr_SetString(PyExc_NameError, errmsg);
+            plString errmsg = plString::Format("Sceneobject %s not found",name.c_str());
+            PyErr_SetString(PyExc_NameError, errmsg.c_str());
         }
     }
     else
@@ -2506,9 +2502,8 @@ void cyMisc::RebuildCameraStack(const char* name, const char* ageName)
             }
         }
         plVirtualCam1::Instance()->PushThirdPerson();
-        char errmsg[256];
-        sprintf(errmsg,"Sceneobject %s has no camera modifier",name);
-        PyErr_SetString(PyExc_NameError, errmsg);
+        plString errmsg = plString::Format("Sceneobject %s has no camera modifier",name.c_str());
+        PyErr_SetString(PyExc_NameError, errmsg.c_str());
     }
     
 }
@@ -2670,10 +2665,10 @@ void cyMisc::FakeLinkToObject(pyKey& avatar, pyKey& object)
     plgDispatch::MsgSend(msg);
 }
 
-void cyMisc::FakeLinkToObjectNamed(const char* name)
+void cyMisc::FakeLinkToObjectNamed(const plString& name)
 {
     plKey key = nil;
-    if ( name || name[0] != 0)
+    if ( !name.IsEmpty() )
     {
         key = plKeyFinder::Instance().StupidSearch(nil,nil,plSceneObject::Index(), name, false);
     }
diff --git a/Sources/Plasma/FeatureLib/pfPython/cyMisc.h b/Sources/Plasma/FeatureLib/pfPython/cyMisc.h
index d2afdd0a..706a70a6 100644
--- a/Sources/Plasma/FeatureLib/pfPython/cyMisc.h
+++ b/Sources/Plasma/FeatureLib/pfPython/cyMisc.h
@@ -142,8 +142,8 @@ public:
     //  PURPOSE    : Execute a console command from a python script,
     //                  optionally propagate over the net
     //
-    static PyObject* FindSceneObject(const char* name, const char* ageName); // returns pySceneObject
-    static PyObject* FindActivator(const char* name); // returns pyKey
+    static PyObject* FindSceneObject(const plString& name, const char* ageName); // returns pySceneObject
+    static PyObject* FindActivator(const plString& name); // returns pyKey
 
     /////////////////////////////////////////////////////////////////////////////
     //
@@ -252,7 +252,7 @@ public:
     //  PURPOSE    : Return the net client (account) name of the player whose avatar
     //              key is provided.
     //
-    static const char* GetClientName(pyKey &avKey);
+    static plString GetClientName(pyKey &avKey);
 
     static PyObject* GetAvatarKeyFromClientID(int clientID); // returns pyKey
     static int GetLocalClientID();
@@ -268,7 +268,7 @@ public:
     //
     //  PURPOSE    : Return the local net client (account) name
     //
-    static const char* GetLocalClientName();
+    static plString GetLocalClientName();
 
 
     //
@@ -697,8 +697,8 @@ public:
     static void SetParticleOffset(float x, float y, float z, pyKey& particles);
     static void KillParticles(float time, float pct, pyKey& particles);
     static int  GetNumParticles(pyKey& host);
-    static void SetLightColorValue(pyKey& light, std::string lightName, hsScalar r, hsScalar g, hsScalar b, hsScalar a);
-    static void SetLightAnimationOn(pyKey& light, std::string lightName, hsBool start);
+    static void SetLightColorValue(pyKey& light, const plString& lightName, hsScalar r, hsScalar g, hsScalar b, hsScalar a);
+    static void SetLightAnimationOn(pyKey& light, const plString& lightName, hsBool start);
     //////////////////////////////////////////////////////////////////////////////
     //
     // Function   : RegisterForControlEventMessages
@@ -799,7 +799,7 @@ public:
 
     static int GetNumCameras();
     static const char* GetCameraNumber(int number);
-    static void RebuildCameraStack(const char* name, const char* ageName);
+    static void RebuildCameraStack(const plString& name, const char* ageName);
     static void PyClearCameraStack();
     static void RecenterCamera();
     static bool IsFirstPerson();
@@ -877,8 +877,8 @@ public:
     // PURPOSE    : takes an avatar key and an object key and fake-links the avatar
     //              to that object's position.  appears to be a link to other players
     //
-    static void FakeLinkToObject(pyKey& avatar, pyKey& object); 
-    static void FakeLinkToObjectNamed(const char* name);    
+    static void FakeLinkToObject(pyKey& avatar, pyKey& object);
+    static void FakeLinkToObjectNamed(const plString& name);
     
     //////////////////////////////////////////////////////////////////////////////
     //
diff --git a/Sources/Plasma/FeatureLib/pfPython/cyMiscGlue.cpp b/Sources/Plasma/FeatureLib/pfPython/cyMiscGlue.cpp
index b63e276f..2ff81a00 100644
--- a/Sources/Plasma/FeatureLib/pfPython/cyMiscGlue.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/cyMiscGlue.cpp
@@ -112,10 +112,10 @@ PYTHON_GLOBAL_METHOD_DEFINITION(PtGetClientName, args, "Params: avatarKey=None\n
             PYTHON_RETURN_ERROR;
         }
         pyKey* key = pyKey::ConvertFrom(keyObj);
-        return PyString_FromString(cyMisc::GetClientName(*key));
+        return PyString_FromString(cyMisc::GetClientName(*key).s_str());
     }
     else
-        return PyString_FromString(cyMisc::GetLocalClientName());
+        return PyString_FromString(cyMisc::GetLocalClientName().c_str());
 }
 
 PYTHON_GLOBAL_METHOD_DEFINITION_NOARGS(PtGetLocalAvatar, "This will return a ptSceneobject of the local avatar\n"
diff --git a/Sources/Plasma/FeatureLib/pfPython/cyMiscGlue3.cpp b/Sources/Plasma/FeatureLib/pfPython/cyMiscGlue3.cpp
index c6e3b396..1cf5b4bd 100644
--- a/Sources/Plasma/FeatureLib/pfPython/cyMiscGlue3.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/cyMiscGlue3.cpp
@@ -183,7 +183,7 @@ PYTHON_GLOBAL_METHOD_DEFINITION(PtFindSceneobject, args, "Params: name,ageName\n
         PyErr_SetString(PyExc_TypeError, "PtFindSceneobject expects two strings");
         PYTHON_RETURN_ERROR;
     }
-    return cyMisc::FindSceneObject(name, ageName);
+    return cyMisc::FindSceneObject(plString::FromUtf8(name), ageName);
 }
 
 PYTHON_GLOBAL_METHOD_DEFINITION(PtFindActivator, args, "Params: name\nThis will try to find an activator based on its name\n"
@@ -197,7 +197,7 @@ PYTHON_GLOBAL_METHOD_DEFINITION(PtFindActivator, args, "Params: name\nThis will
         PYTHON_RETURN_ERROR;
     }
 
-    return cyMisc::FindActivator(name);
+    return cyMisc::FindActivator(plString::FromUtf8(name));
 }
 
 PYTHON_BASIC_GLOBAL_METHOD_DEFINITION(PtClearCameraStack, cyMisc::ClearCameraStack, "Clears the camera stack")
diff --git a/Sources/Plasma/FeatureLib/pfPython/cyMiscGlue4.cpp b/Sources/Plasma/FeatureLib/pfPython/cyMiscGlue4.cpp
index b049face..3897bc3e 100644
--- a/Sources/Plasma/FeatureLib/pfPython/cyMiscGlue4.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/cyMiscGlue4.cpp
@@ -141,23 +141,17 @@ PYTHON_GLOBAL_METHOD_DEFINITION(PtSetLightValue, args, "Params: key,name,r,g,b,a
         PYTHON_RETURN_ERROR;
     }
     pyKey* key = pyKey::ConvertFrom(keyObj);
-    std::string name = "";
+    plString name;
     if (PyUnicode_Check(nameObj))
     {
-        int strLen = PyUnicode_GetSize(nameObj);
-        wchar_t* text = TRACKED_NEW wchar_t[strLen + 1];
-        PyUnicode_AsWideChar((PyUnicodeObject*)nameObj, text, strLen);
-        text[strLen] = L'\0';
-        char* cText = hsWStringToString(text);
-        name = cText;
-        delete [] cText;
-        delete [] text;
+        PyObject* utf8 = PyUnicode_AsUTF8String(nameObj);
+        name = plString::FromUtf8(PyString_AsString(utf8));
+        Py_DECREF(utf8);
     }
     else if (PyString_Check(nameObj))
     {
         // we'll allow this, just in case something goes weird
-        char* text = PyString_AsString(nameObj);
-        name = text;
+        name = plString::FromUtf8(PyString_AsString(nameObj));
     }
     else
     {
@@ -184,23 +178,17 @@ PYTHON_GLOBAL_METHOD_DEFINITION(PtSetLightAnimStart, args, "Params: key,name,sta
         PYTHON_RETURN_ERROR;
     }
     pyKey* key = pyKey::ConvertFrom(keyObj);
-    std::string name = "";
+    plString name;
     if (PyUnicode_Check(nameObj))
     {
-        int strLen = PyUnicode_GetSize(nameObj);
-        wchar_t* text = TRACKED_NEW wchar_t[strLen + 1];
-        PyUnicode_AsWideChar((PyUnicodeObject*)nameObj, text, strLen);
-        text[strLen] = L'\0';
-        char* cText = hsWStringToString(text);
-        name = cText;
-        delete [] cText;
-        delete [] text;
+        PyObject* utf8 = PyUnicode_AsUTF8String(nameObj);
+        name = plString::FromUtf8(PyString_AsString(utf8));
+        Py_DECREF(utf8);
     }
     else if (PyString_Check(nameObj))
     {
         // we'll allow this, just in case something goes weird
-        char* text = PyString_AsString(nameObj);
-        name = text;
+        name = plString::FromUtf8(PyString_AsString(nameObj));
     }
     else
     {
@@ -363,7 +351,7 @@ PYTHON_GLOBAL_METHOD_DEFINITION(PtRebuildCameraStack, args, "Params: name,ageNam
         PyErr_SetString(PyExc_TypeError, "PtRebuildCameraStack expects two strings");
         PYTHON_RETURN_ERROR;
     }
-    cyMisc::RebuildCameraStack(name, ageName);
+    cyMisc::RebuildCameraStack(plString::FromUtf8(name), ageName);
     PYTHON_RETURN_NONE;
 }
 
diff --git a/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.cpp b/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.cpp
index 9b0df979..360e05f6 100644
--- a/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.cpp
@@ -331,7 +331,6 @@ hsBool plPythonFileMod::fAtConvertTime = false;
 plPythonFileMod::plPythonFileMod()
 {
     fPythonFile = nil;
-    fModuleName = nil;
     fModule = nil;
     fLocalNotify= true;
     fIsFirstTimeEval = true;
@@ -404,15 +403,15 @@ plPythonFileMod::~plPythonFileMod()
     }
     // then get rid of this module
     //  NOTE: fModule shouldn't be made in the plugin, only at runtime
-    if ( fModuleName && fModule )
+    if ( !fModuleName.IsNull() && fModule )
     {
         //_PyModule_Clear(fModule);
         PyObject *m;
         PyObject *modules = PyImport_GetModuleDict();
-        if( modules && (m = PyDict_GetItemString(modules, fModuleName)) && PyModule_Check(m))
+        if( modules && (m = PyDict_GetItemString(modules, fModuleName.c_str())) && PyModule_Check(m))
         {
             hsStatusMessageF("Module %s removed from python dictionary",fModuleName);
-            PyDict_DelItemString(modules, fModuleName);
+            PyDict_DelItemString(modules, fModuleName.c_str());
         }
         else
         {
@@ -422,8 +421,7 @@ plPythonFileMod::~plPythonFileMod()
         // we need to set our pointer to nil to make sure we don't try to use it
         fModule = nil;
     }
-    delete [] fModuleName;
-    fModuleName = nil;
+    fModuleName = plString::Null;
 }
 
 #include "plPythonPack.h"
@@ -510,11 +508,8 @@ void plPythonFileMod::AddTarget(plSceneObject* sobj)
             {
                 plKey pkey = sobj->GetKey();
                 // nope, must be the first object. Then use it as the basis for the module
-                char modulename[256];
-                IMakeModuleName(modulename,sobj);
-                delete [] fModuleName;
-                fModuleName = StrDup(modulename);
-                fModule = PythonInterface::CreateModule(modulename);
+                fModuleName = IMakeModuleName(sobj);
+                fModule = PythonInterface::CreateModule(fModuleName.c_str());
 
                 // if we can't create the instance then there is nothing to do here
                 if (!ILoadPythonCode())
@@ -634,17 +629,16 @@ void plPythonFileMod::AddTarget(plSceneObject* sobj)
                                             NamedComponent comp;
                                             comp.isActivator = (isNamedAttr == 1);
                                             comp.id = parameter.fID;
-                                            comp.name = TRACKED_NEW char[strlen(parameter.datarecord.fString) + 1];
-                                            strcpy(comp.name, parameter.datarecord.fString);
+                                            comp.name = plString::FromUtf8(parameter.datarecord.fString);
                                             
                                             fNamedCompQueue.Append(comp);
                                         }
                                         else
                                         {
                                             if (isNamedAttr == 1)
-                                                IFindActivatorAndAdd(parameter.datarecord.fString, parameter.fID);
+                                                IFindActivatorAndAdd(plString::FromUtf8(parameter.datarecord.fString), parameter.fID);
                                             else
-                                                IFindResponderAndAdd(parameter.datarecord.fString, parameter.fID);
+                                                IFindResponderAndAdd(plString::FromUtf8(parameter.datarecord.fString), parameter.fID);
                                         }
                                     }
                                 }
@@ -951,7 +945,7 @@ void    plPythonFileMod::HandleDiscardedKey( plKeyEventMsg *msg )
 //
 // NOTE: This modifier wasn't intended to have multiple targets
 //
-void plPythonFileMod::IMakeModuleName(char* modulename,plSceneObject* sobj)
+plString plPythonFileMod::IMakeModuleName(plSceneObject* sobj)
 {
     // Forgive my general crapulance...
     // This strips underscores out of module names 
@@ -960,13 +954,14 @@ void plPythonFileMod::IMakeModuleName(char* modulename,plSceneObject* sobj)
     plKey pKey = GetKey();
     plKey sKey = sobj->GetKey();
 
-    const char* pKeyName = pKey->GetName(); 
-    const char* pSobjName = sKey->GetName(); 
+    const char* pKeyName = pKey->GetName().c_str();
+    const char* pSobjName = sKey->GetName().c_str();
 
-    UInt16 len = hsStrlen(pKeyName);
-    UInt16 slen = hsStrlen(pSobjName);
+    UInt16 len = pKey->GetName().GetSize();
+    UInt16 slen = sKey->GetName().GetSize();
 
     hsAssert(len+slen < 256, "Warning: String length exceeds 256 characters.");
+    char modulename[256];
     
     int i, k = 0;
     for(i = 0; i < slen; i++)
@@ -983,6 +978,7 @@ void plPythonFileMod::IMakeModuleName(char* modulename,plSceneObject* sobj)
     }
 
     modulename[k] = '\0';
+    plString name = plString::FromUtf8(modulename);
 
     // check to see if we are attaching to a clone?
     plKeyImp* pKeyImp = (plKeyImp*)(sKey);
@@ -992,7 +988,7 @@ void plPythonFileMod::IMakeModuleName(char* modulename,plSceneObject* sobj)
         // add the cloneID to the end of the module name
         // and set the fIAmAClone flag
         UInt32 cloneID = pKeyImp->GetUoid().GetCloneID();
-        sprintf(modulename,"%s%d",modulename,cloneID);
+        name += plString::Format("%d", cloneID);
         fAmIAttachedToClone = true;
     }
 
@@ -1001,8 +997,10 @@ void plPythonFileMod::IMakeModuleName(char* modulename,plSceneObject* sobj)
     {
         // if not unique then add the sequence number to the end of the modulename
         UInt32 seqID = pKeyImp->GetUoid().GetLocation().GetSequenceNumber();
-        sprintf(modulename,"%s%d",modulename,seqID);
+        name += plString::Format("%d", seqID);
     }
+
+    return name;
 }
 
 /////////////////////////////////////////////////////////////////////////////
@@ -1047,9 +1045,9 @@ void plPythonFileMod::ISetKeyValue(const plKey& key, Int32 id)
 //  PURPOSE    : find a responder by name in all age and page locations
 //             : and add to the Parameter list
 //
-void plPythonFileMod::IFindResponderAndAdd(const char *responderName, Int32 id)
+void plPythonFileMod::IFindResponderAndAdd(const plString &responderName, Int32 id)
 {
-    if ( responderName != nil )
+    if ( !responderName.IsNull() )
     {
         std::vector<plKey> keylist;
         const plLocation &loc = GetKey()->GetUoid().GetLocation();
@@ -1075,9 +1073,9 @@ void plPythonFileMod::IFindResponderAndAdd(const char *responderName, Int32 id)
 //  PURPOSE    : find a responder by name in all age and page locations
 //             : and add to the Parameter list
 //
-void plPythonFileMod::IFindActivatorAndAdd(const char *activatorName, Int32 id)
+void plPythonFileMod::IFindActivatorAndAdd(const plString &activatorName, Int32 id)
 {
-    if ( activatorName != nil )
+    if ( !activatorName.IsNull() )
     {
         std::vector<plKey> keylist;
         const plLocation &loc = GetKey()->GetUoid().GetLocation();
@@ -1236,8 +1234,6 @@ hsBool plPythonFileMod::MsgReceive(plMessage* msg)
                 IFindActivatorAndAdd(comp.name, comp.id);
             else
                 IFindResponderAndAdd(comp.name, comp.id);
-
-            delete [] comp.name;
         }
 
         fNamedCompQueue.Reset();
@@ -1756,9 +1752,9 @@ hsBool plPythonFileMod::MsgReceive(plMessage* msg)
         {
             // yes...
             // call it
-            char* roomname = "";
+            const char* roomname = "";
             if ( pRLNMsg->GetRoom() != nil )
-                roomname = (char*)pRLNMsg->GetRoom()->GetName();
+                roomname = pRLNMsg->GetRoom()->GetName().c_str();
 
             plProfile_BeginTiming(PythonUpdate);
             PyObject* retVal = PyObject_CallMethod(
@@ -2837,11 +2833,10 @@ hsBool plPythonFileMod::MsgReceive(plMessage* msg)
 //
 void plPythonFileMod::ReportError()
 {
-    char objectName[128];
-    StrCopy(objectName, this->GetKeyName(), arrsize(objectName));
-    StrPack(objectName, " - ", arrsize(objectName));
+    plString objectName = this->GetKeyName();
+    objectName += _TEMP_CONVERT_FROM_LITERAL(" - ");
 
-    PythonInterface::WriteToStdErr(objectName);
+    PythonInterface::WriteToStdErr(objectName.c_str());
 
     PyErr_Print();      // make sure the error is printed
     PyErr_Clear();      // clear the error
@@ -2984,4 +2979,4 @@ void plPythonFileMod::Write(hsStream* stream, hsResMgr* mgr)
 //// kGlobalNameKonstant /////////////////////////////////////////////////
 //  My continued attempt to spread the CORRECT way to spell konstant. -mcn
 
-char plPythonFileMod::kGlobalNameKonstant[] = "VeryVerySpecialPythonFileMod";
+plString plPythonFileMod::kGlobalNameKonstant = _TEMP_CONVERT_FROM_LITERAL("VeryVerySpecialPythonFileMod");
diff --git a/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.h b/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.h
index e4ee6fa9..7a0a36a5 100644
--- a/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.h
+++ b/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.h
@@ -74,10 +74,10 @@ protected:
 
     hsBool IEval(double secs, hsScalar del, UInt32 dirty);
 
-    void IMakeModuleName(char* modulename,plSceneObject* sobj);
+    plString IMakeModuleName(plSceneObject* sobj);
 
     char*       fPythonFile;
-    char*       fModuleName;
+    plString    fModuleName;
 
     // the list of receivers that want to be notified
     hsTArray<plKey>         fReceivers;
@@ -104,15 +104,15 @@ protected:
 
     struct NamedComponent
     {
-        char*   name;
-        Int32   id;
-        bool    isActivator;
+        plString    name;
+        Int32       id;
+        bool        isActivator;
     };
 
     hsTArray<NamedComponent> fNamedCompQueue;
 
-    virtual void IFindResponderAndAdd(const char *responderName, Int32 id);
-    virtual void IFindActivatorAndAdd(const char *activatorName, Int32 id);
+    virtual void IFindResponderAndAdd(const plString &responderName, Int32 id);
+    virtual void IFindActivatorAndAdd(const plString &activatorName, Int32 id);
     void ISetKeyValue(const plKey& key, Int32 id);
 
     bool ILoadPythonCode();
@@ -210,7 +210,7 @@ public:
     static const char* fFunctionNames[];
 
     // The konstant hard-coded name to be used for all global pythonFileMods
-    static char kGlobalNameKonstant[];
+    static plString kGlobalNameKonstant;
 
     // API for processing discarded keys as the deafult key catcher
     void    HandleDiscardedKey( plKeyEventMsg *msg );
diff --git a/Sources/Plasma/FeatureLib/pfPython/plPythonSDLModifier.cpp b/Sources/Plasma/FeatureLib/pfPython/plPythonSDLModifier.cpp
index f6a7ed07..d814b0c8 100644
--- a/Sources/Plasma/FeatureLib/pfPython/plPythonSDLModifier.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/plPythonSDLModifier.cpp
@@ -605,7 +605,7 @@ const plPythonSDLModifier* plPythonSDLModifier::FindAgeSDL()
                     return sdlMod;
                 
                 plNetClientApp::StaticErrorMsg("pfmod %s has a nil python SDL modifier for age sdl %s", 
-                    pfmod->GetKeyName() ? pfmod->GetKeyName() : "?", ageName);              
+                    pfmod->GetKeyName().s_str("?"), ageName);
             }
             else
             {
@@ -614,11 +614,11 @@ const plPythonSDLModifier* plPythonSDLModifier::FindAgeSDL()
                 else
                 if (!key->ObjectIsLoaded())
                     plNetClientApp::StaticErrorMsg("key %s not loaded for age sdl %s", 
-                        key->GetName() ? key->GetName() : "?", ageName);
+                        key->GetName().s_str("?"), ageName);
                 else
                 if (!plPythonFileMod::ConvertNoRef(key->ObjectIsLoaded()))
                     plNetClientApp::StaticErrorMsg("key %s is not a python file mod for age sdl %s", 
-                        key->GetName() ? key->GetName() : "?", ageName);
+                        key->GetName().s_str("?"), ageName);
             }
         }
         else
diff --git a/Sources/Plasma/FeatureLib/pfPython/pyImage.cpp b/Sources/Plasma/FeatureLib/pfPython/pyImage.cpp
index 762f7d24..e78dab5d 100644
--- a/Sources/Plasma/FeatureLib/pfPython/pyImage.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/pyImage.cpp
@@ -200,7 +200,7 @@ PyObject* pyImage::LoadJPEGFromDisk(const wchar* filename, UInt16 width, UInt16
         }
 
         // let's create a nice name for this thing based on the filename
-        std::string name = "PtImageFromDisk_";
+        plString name = _TEMP_CONVERT_FROM_LITERAL("PtImageFromDisk_");
         const wchar* i = filename;
         int charsChecked = 0;
 
@@ -219,10 +219,9 @@ PyObject* pyImage::LoadJPEGFromDisk(const wchar* filename, UInt16 width, UInt16
             i++;
         }
 
-        char* cName = hsWStringToString(i);
-        name = name + cName;
+        name += plString::FromWchar(i);
 
-        hsgResMgr::ResMgr()->NewKey(name.c_str(), theMipmap, plLocation::kGlobalFixedLoc);
+        hsgResMgr::ResMgr()->NewKey(name, theMipmap, plLocation::kGlobalFixedLoc);
         
         return pyImage::New( theMipmap );
     }
diff --git a/Sources/Plasma/FeatureLib/pfPython/pyJournalBook.cpp b/Sources/Plasma/FeatureLib/pfPython/pyJournalBook.cpp
index 874e6e6e..d526ba6b 100644
--- a/Sources/Plasma/FeatureLib/pfPython/pyJournalBook.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/pyJournalBook.cpp
@@ -58,8 +58,7 @@ UInt32  pyJournalBook::fNextKeyID = 0;
 
 void    pyJournalBook::IMakeNewKey( void )
 {
-    char name[ 128 ];
-    sprintf( name, "pyJournalBook-%d", fNextKeyID++ );
+    plString name = plString::Format( "pyJournalBook-%d", fNextKeyID++ );
     hsgResMgr::ResMgr()->NewKey( name, fBook, plLocation::kGlobalFixedLoc );
     
     fBook->GetKey()->RefObject();
@@ -96,14 +95,14 @@ pyJournalBook::pyJournalBook( std::wstring esHTMLSource, pyImage &coverImage, py
     IMakeNewKey();
 }
 
-pyJournalBook::pyJournalBook( const char *esHTMLSource, pyImage &coverImage, pyKey callbackKey, const char *guiName )
+pyJournalBook::pyJournalBook( const char *esHTMLSource, pyImage &coverImage, pyKey callbackKey, const plString &guiName )
 {
     fBook = TRACKED_NEW pfJournalBook( esHTMLSource, coverImage.GetKey(), callbackKey.getKey(), 
                                 callbackKey.getKey() != nil ? callbackKey.getKey()->GetUoid().GetLocation() : plLocation::kGlobalFixedLoc, guiName );
     IMakeNewKey();
 }
 
-pyJournalBook::pyJournalBook( std::wstring esHTMLSource, pyImage &coverImage, pyKey callbackKey, const char *guiName )
+pyJournalBook::pyJournalBook( std::wstring esHTMLSource, pyImage &coverImage, pyKey callbackKey, const plString &guiName )
 {
     fBook = TRACKED_NEW pfJournalBook( esHTMLSource.c_str(), coverImage.GetKey(), callbackKey.getKey(), 
                                 callbackKey.getKey() != nil ? callbackKey.getKey()->GetUoid().GetLocation() : plLocation::kGlobalFixedLoc, guiName );
@@ -135,7 +134,7 @@ pyJournalBook::~pyJournalBook()
     }
 }
 
-void pyJournalBook::MakeBook(std::string esHTMLSource, plKey coverImageKey /* = nil */, plKey callbackKey /* = nil */, std::string guiName /* = "" */)
+void pyJournalBook::MakeBook(std::string esHTMLSource, plKey coverImageKey /* = nil */, plKey callbackKey /* = nil */, plString guiName /* = "" */)
 {
     if (fBook)
         fBook->GetKey()->UnRefObject();
@@ -144,11 +143,11 @@ void pyJournalBook::MakeBook(std::string esHTMLSource, plKey coverImageKey /* =
     if (callbackKey != nil)
         loc = callbackKey->GetUoid().GetLocation();
 
-    fBook = TRACKED_NEW pfJournalBook(esHTMLSource.c_str(), coverImageKey, callbackKey, loc, guiName.c_str());
+    fBook = TRACKED_NEW pfJournalBook(esHTMLSource.c_str(), coverImageKey, callbackKey, loc, guiName);
     IMakeNewKey();
 }
 
-void pyJournalBook::MakeBook(std::wstring esHTMLSource, plKey coverImageKey /* = nil */, plKey callbackKey /* = nil */, std::string guiName /* = "" */)
+void pyJournalBook::MakeBook(std::wstring esHTMLSource, plKey coverImageKey /* = nil */, plKey callbackKey /* = nil */, plString guiName /* = "" */)
 {
     if (fBook)
         fBook->GetKey()->UnRefObject();
@@ -157,7 +156,7 @@ void pyJournalBook::MakeBook(std::wstring esHTMLSource, plKey coverImageKey /* =
     if (callbackKey != nil)
         loc = callbackKey->GetUoid().GetLocation();
 
-    fBook = TRACKED_NEW pfJournalBook(esHTMLSource.c_str(), coverImageKey, callbackKey, loc, guiName.c_str());
+    fBook = TRACKED_NEW pfJournalBook(esHTMLSource.c_str(), coverImageKey, callbackKey, loc, guiName);
     IMakeNewKey();
 }
 
@@ -235,18 +234,18 @@ void    pyJournalBook::AllowPageTurning( bool allow )
         fBook->AllowPageTurning(allow);
 }
 
-void    pyJournalBook::SetGUI( const char *guiName )
+void    pyJournalBook::SetGUI( const plString &guiName )
 {
     if (fBook != nil)
         fBook->SetGUI(guiName);
 }
 
-void    pyJournalBook::LoadGUI( const char *guiName )
+void    pyJournalBook::LoadGUI( const plString &guiName )
 {
     pfJournalBook::LoadGUI(guiName);
 }
 
-void    pyJournalBook::UnloadGUI( const char *guiName )
+void    pyJournalBook::UnloadGUI( const plString &guiName )
 {
     pfJournalBook::UnloadGUI(guiName);
 }
diff --git a/Sources/Plasma/FeatureLib/pfPython/pyJournalBook.h b/Sources/Plasma/FeatureLib/pfPython/pyJournalBook.h
index ec764873..0ae43332 100644
--- a/Sources/Plasma/FeatureLib/pfPython/pyJournalBook.h
+++ b/Sources/Plasma/FeatureLib/pfPython/pyJournalBook.h
@@ -78,8 +78,8 @@ protected:
     pyJournalBook( std::wstring esHTMLSource, pyKey callbackKey );
     pyJournalBook( const char *esHTMLSource, pyImage &coverImage, pyKey callbackKey );
     pyJournalBook( std::wstring esHTMLSource, pyImage &coverImage, pyKey callbackKey );
-    pyJournalBook( const char *esHTMLSource, pyImage &coverImage, pyKey callbackKey, const char *guiName );
-    pyJournalBook( std::wstring esHTMLSource, pyImage &coverImage, pyKey callbackKey, const char *guiName );
+    pyJournalBook( const char *esHTMLSource, pyImage &coverImage, pyKey callbackKey, const plString &guiName );
+    pyJournalBook( std::wstring esHTMLSource, pyImage &coverImage, pyKey callbackKey, const plString &guiName );
 
 public:
     virtual ~pyJournalBook();
@@ -88,8 +88,8 @@ public:
 
     // required functions for PyObject interoperability
     PYTHON_CLASS_NEW_FRIEND(ptBook);
-    static PyObject *New(std::string htmlSource, plKey coverImageKey = nil, plKey callbackKey = nil, std::string guiName = "");
-    static PyObject *New(std::wstring htmlSource, plKey coverImageKey = nil, plKey callbackKey = nil, std::string guiName = "");
+    static PyObject *New(std::string htmlSource, plKey coverImageKey = nil, plKey callbackKey = nil, plString guiName = _TEMP_CONVERT_FROM_LITERAL(""));
+    static PyObject *New(std::wstring htmlSource, plKey coverImageKey = nil, plKey callbackKey = nil, plString guiName = _TEMP_CONVERT_FROM_LITERAL(""));
     PYTHON_CLASS_CHECK_DEFINITION; // returns true if the PyObject is a pyJournalBook object
     PYTHON_CLASS_CONVERT_FROM_DEFINITION(pyJournalBook); // converts a PyObject to a pyJournalBook (throws error if not correct type)
 
@@ -98,8 +98,8 @@ public:
     static void AddPlasmaConstantsClasses(PyObject *m);
 
     // Deletes the existing book and re-creates it, for use by the python glue
-    void MakeBook(std::string esHTMLSource, plKey coverImageKey = nil, plKey callbackKey = nil, std::string guiName = "");
-    void MakeBook(std::wstring esHTMLSource, plKey coverImageKey = nil, plKey callbackKey = nil, std::string guiName = "");
+    void MakeBook(std::string esHTMLSource, plKey coverImageKey = nil, plKey callbackKey = nil, plString guiName = _TEMP_CONVERT_FROM_LITERAL(""));
+    void MakeBook(std::wstring esHTMLSource, plKey coverImageKey = nil, plKey callbackKey = nil, plString guiName = _TEMP_CONVERT_FROM_LITERAL(""));
 
     // Interface functions per book
     virtual void    Show( hsBool startOpened );
@@ -117,10 +117,10 @@ public:
 
     virtual void    SetSize( hsScalar width, hsScalar height );
 
-    virtual void    SetGUI( const char *guiName );
+    virtual void    SetGUI( const plString &guiName );
 
-    static void     LoadGUI( const char *guiName );
-    static void     UnloadGUI( const char *guiName );
+    static void     LoadGUI( const plString &guiName );
+    static void     UnloadGUI( const plString &guiName );
     static void     UnloadAllGUIs();
 
     virtual PyObject *GetMovie( UInt8 index ); // returns cyAnimation
diff --git a/Sources/Plasma/FeatureLib/pfPython/pyJournalBookGlue.cpp b/Sources/Plasma/FeatureLib/pfPython/pyJournalBookGlue.cpp
index f778c203..03c058cd 100644
--- a/Sources/Plasma/FeatureLib/pfPython/pyJournalBookGlue.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/pyJournalBookGlue.cpp
@@ -101,9 +101,9 @@ PYTHON_INIT_DEFINITION(ptBook, args, keywords)
         callbackKey = pyKey::ConvertFrom(callbackObj)->getKey();
     }
 
-    std::string guiNameStr = "";
+    plString guiNameStr;
     if (guiName)
-        guiNameStr = guiName;
+        guiNameStr = plString::FromUtf8(guiName);
 
     // convert the sourcecode object
     if (PyUnicode_Check(sourceObj))
@@ -225,7 +225,7 @@ PYTHON_METHOD_DEFINITION(ptBook, setGUI, args)
         PyErr_SetString(PyExc_TypeError, "setGUI expects a string");
         PYTHON_RETURN_ERROR;
     }
-    self->fThis->SetGUI(guiName);
+    self->fThis->SetGUI(plString::FromUtf8(guiName));
     PYTHON_RETURN_NONE;
 }
 
@@ -293,14 +293,14 @@ PYTHON_END_METHODS_TABLE;
 PLASMA_DEFAULT_TYPE(ptBook, "Params: esHTMLSource,coverImage=None,callbackKey=None,guiName=''\nCreates a new book");
 
 // required functions for PyObject interoperability
-PyObject *pyJournalBook::New(std::string htmlSource, plKey coverImageKey /* = nil */, plKey callbackKey /* = nil */, std::string guiName /* = "" */)
+PyObject *pyJournalBook::New(std::string htmlSource, plKey coverImageKey /* = nil */, plKey callbackKey /* = nil */, plString guiName /* = "" */)
 {
     ptBook *newObj = (ptBook*)ptBook_type.tp_new(&ptBook_type, NULL, NULL);
     newObj->fThis->MakeBook(htmlSource, coverImageKey, callbackKey, guiName);
     return (PyObject*)newObj;
 }
 
-PyObject *pyJournalBook::New(std::wstring htmlSource, plKey coverImageKey /* = nil */, plKey callbackKey /* = nil */, std::string guiName /* = "" */)
+PyObject *pyJournalBook::New(std::wstring htmlSource, plKey coverImageKey /* = nil */, plKey callbackKey /* = nil */, plString guiName /* = "" */)
 {
     ptBook *newObj = (ptBook*)ptBook_type.tp_new(&ptBook_type, NULL, NULL);
     newObj->fThis->MakeBook(htmlSource, coverImageKey, callbackKey, guiName);
@@ -329,7 +329,7 @@ PYTHON_GLOBAL_METHOD_DEFINITION(PtLoadBookGUI, args, "Params: guiName\nLoads the
         PyErr_SetString(PyExc_TypeError, "PtLoadBookGUI expects a string");
         PYTHON_RETURN_ERROR;
     }
-    pyJournalBook::LoadGUI(guiName);
+    pyJournalBook::LoadGUI(plString::FromUtf8(guiName));
     PYTHON_RETURN_NONE;
 }
 
@@ -341,7 +341,7 @@ PYTHON_GLOBAL_METHOD_DEFINITION(PtUnloadBookGUI, args, "Params: guiName\nUnloads
         PyErr_SetString(PyExc_TypeError, "PtUnloadBookGUI expects a string");
         PYTHON_RETURN_ERROR;
     }
-    pyJournalBook::UnloadGUI(guiName);
+    pyJournalBook::UnloadGUI(plString::FromUtf8(guiName));
     PYTHON_RETURN_NONE;
 }
 
diff --git a/Sources/Plasma/FeatureLib/pfPython/pyKey.h b/Sources/Plasma/FeatureLib/pfPython/pyKey.h
index 1dc05e89..3e84e7e4 100644
--- a/Sources/Plasma/FeatureLib/pfPython/pyKey.h
+++ b/Sources/Plasma/FeatureLib/pfPython/pyKey.h
@@ -52,6 +52,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 
 #include <Python.h>
 #include "pyGlueHelpers.h"
+#include "plString.h"
 
 class plPythonFileMod;
 class pySceneObject;
@@ -98,7 +99,7 @@ public:
     // getter and setters
     virtual plKey getKey() { return fKey; }
     virtual void setKey(plKey key) { fKey=key; }
-    virtual const char* getName() const { return fKey ? fKey->GetName() : "nil";    }
+    virtual const char* getName() const { return fKey ? fKey->GetName().c_str() : "nil";    }
 #ifndef BUILDING_PYPLASMA
     PyObject* GetPySceneObject();
 
diff --git a/Sources/Plasma/FeatureLib/pfPython/pySceneObject.cpp b/Sources/Plasma/FeatureLib/pfPython/pySceneObject.cpp
index 9035ac64..7f3acac9 100644
--- a/Sources/Plasma/FeatureLib/pfPython/pySceneObject.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/pySceneObject.cpp
@@ -210,21 +210,21 @@ void pySceneObject::SetNetForce(hsBool state)
 }
 
 
-const char* pySceneObject::GetName()
+plString pySceneObject::GetName()
 {
     if ( fSceneObjects.Count() > 0 )
         return fSceneObjects[0]->GetName();
-    return "";
+    return _TEMP_CONVERT_FROM_LITERAL("");
 }
 
-PyObject* pySceneObject::findObj(const char* name)
+PyObject* pySceneObject::findObj(const plString& name)
 {
     PyObject* pSobj = nil;
     // search through the plKeys that we have looking for this name
     int i;
     for ( i=0; i<fSceneObjects.Count(); i++ )
     {
-        if ( hsStrEQ(name,fSceneObjects[i]->GetName()) )
+        if ( name == fSceneObjects[i]->GetName() )
         {
             pSobj = pySceneObject::New(fSceneObjects[i],fPyMod);
             break;
@@ -235,7 +235,7 @@ PyObject* pySceneObject::findObj(const char* name)
     if ( pSobj == nil )
     {
         // throw a Python error, so the coder knows it didn't work
-        PyErr_SetString(PyExc_KeyError, name);
+        PyErr_SetString(PyExc_KeyError, name.c_str());
     }
 
     return pSobj;
diff --git a/Sources/Plasma/FeatureLib/pfPython/pySceneObject.h b/Sources/Plasma/FeatureLib/pfPython/pySceneObject.h
index 84da856f..8bbe0760 100644
--- a/Sources/Plasma/FeatureLib/pfPython/pySceneObject.h
+++ b/Sources/Plasma/FeatureLib/pfPython/pySceneObject.h
@@ -114,9 +114,9 @@ public:
 
     virtual void SetNetForce(hsBool state);
 
-    virtual PyObject* findObj(const char* name); // pySceneObject
+    virtual PyObject* findObj(const plString& name); // pySceneObject
 
-    virtual const char* GetName();
+    virtual plString GetName();
     virtual std::vector<PyObject*> GetResponders(); // pyKey list
     virtual std::vector<PyObject*> GetPythonMods(); // pyKey list
     //
diff --git a/Sources/Plasma/FeatureLib/pfPython/pySceneObjectGlue.cpp b/Sources/Plasma/FeatureLib/pfPython/pySceneObjectGlue.cpp
index df699948..61a9fab4 100644
--- a/Sources/Plasma/FeatureLib/pfPython/pySceneObjectGlue.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/pySceneObjectGlue.cpp
@@ -151,12 +151,12 @@ PYTHON_METHOD_DEFINITION(ptSceneobject, findObject, args)
         PyErr_SetString(PyExc_TypeError, "findObject expects a string");
         PYTHON_RETURN_ERROR;
     }
-    return self->fThis->findObj(name);
+    return self->fThis->findObj(plString::FromUtf8(name));
 }
 
 PYTHON_METHOD_DEFINITION_NOARGS(ptSceneobject, getName)
 {
-    return PyString_FromString(self->fThis->GetName());
+    return PyString_FromString(self->fThis->GetName().c_str());
 }
 
 PYTHON_METHOD_DEFINITION_NOARGS(ptSceneobject, getResponders)
diff --git a/Sources/Plasma/FeatureLib/pfPython/pyVaultImageNode.cpp b/Sources/Plasma/FeatureLib/pfPython/pyVaultImageNode.cpp
index a7c9e325..44a5cb44 100644
--- a/Sources/Plasma/FeatureLib/pfPython/pyVaultImageNode.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/pyVaultImageNode.cpp
@@ -64,8 +64,7 @@ static unsigned s_keyseq;
 
 //============================================================================
 static plKey CreateAndRefImageKey (unsigned nodeId, plMipmap * mipmap) {
-    char keyName[MAX_PATH];
-    StrPrintf(keyName, arrsize(keyName), "VaultImg_%u_%u", nodeId, s_keyseq++);
+    plString keyName = plString::Format("VaultImg_%u_%u", nodeId, s_keyseq++);
 
     plKey key = hsgResMgr::ResMgr()->NewKey(keyName, mipmap, plLocation::kGlobalFixedLoc);
 
diff --git a/Sources/Plasma/FeatureLib/pfSurface/plLayerMovie.cpp b/Sources/Plasma/FeatureLib/pfSurface/plLayerMovie.cpp
index 05af21f2..9f88a822 100644
--- a/Sources/Plasma/FeatureLib/pfSurface/plLayerMovie.cpp
+++ b/Sources/Plasma/FeatureLib/pfSurface/plLayerMovie.cpp
@@ -115,8 +115,7 @@ hsBool plLayerMovie::ISetupBitmap()
         memset(b->GetImage(), 0x10, b->GetHeight() * b->GetRowBytes() );
         b->SetFlags( b->GetFlags() | plMipmap::kDontThrowAwayImage );
 
-        char    name[ 256 ];
-        sprintf( name, "%s_BMap", fMovieName );
+        plString name = plString::Format( "%s_BMap", fMovieName );
         hsgResMgr::ResMgr()->NewKey( name, b, plLocation::kGlobalFixedLoc );
 
         *fTexture = (plBitmap *)b;
diff --git a/Sources/Plasma/NucleusLib/inc/hsResMgr.h b/Sources/Plasma/NucleusLib/inc/hsResMgr.h
index 5bf3cd38..9df9dfc4 100644
--- a/Sources/Plasma/NucleusLib/inc/hsResMgr.h
+++ b/Sources/Plasma/NucleusLib/inc/hsResMgr.h
@@ -105,7 +105,7 @@ public:
     //---------------------------
     // Registry Modification Functions
     //---------------------------
-    virtual plKey NewKey(const char* name, hsKeyedObject* object, const plLocation& loc, const plLoadMask& m = plLoadMask::kAlways)=0;
+    virtual plKey NewKey(const plString& name, hsKeyedObject* object, const plLocation& loc, const plLoadMask& m = plLoadMask::kAlways)=0;
     virtual plKey NewKey(plUoid& newUoid, hsKeyedObject* object)=0;
 
     virtual plDispatchBase* Dispatch()=0;
@@ -118,7 +118,7 @@ protected:
     friend class plKeyImp;
     friend class plArmatureMod; // Temp hack until a findkey/clone issue is fixed. -Bob
 
-    virtual plKey   ReRegister(const char *nm, const plUoid& oid)=0;
+    virtual plKey   ReRegister(const plString& nm, const plUoid& oid)=0;
     virtual hsBool  ReadObject(plKeyImp* key)=0;  // plKeys call this when needed
 
     // Sets a key as used or unused in the registry.  When all keys in a page of a
diff --git a/Sources/Plasma/NucleusLib/pnDispatch/plDispatch.cpp b/Sources/Plasma/NucleusLib/pnDispatch/plDispatch.cpp
index 78814c0d..d064d850 100644
--- a/Sources/Plasma/NucleusLib/pnDispatch/plDispatch.cpp
+++ b/Sources/Plasma/NucleusLib/pnDispatch/plDispatch.cpp
@@ -341,7 +341,7 @@ void plDispatch::IMsgDispatch()
                 UInt32 rcvTicks = hsTimer::GetPrecTickCount();
 
                 // Object could be deleted by this message, so we need to log this stuff now
-                const char* keyname = "(unknown)";
+                plString keyname = _TEMP_CONVERT_FROM_LITERAL("(unknown)");
                 const char* className = "(unknown)";
                 UInt32 clonePlayerID = 0;
                 if (plDispatchLogBase::IsLoggingLong())
@@ -373,7 +373,7 @@ void plDispatch::IMsgDispatch()
                     float rcvTime = (float)(hsTimer::PrecTicksToSecs(rcvTicks) * 1000.f);
                     // If the receiver takes more than 5 ms to process its message, log it
                     if (rcvTime > 5.f)
-                        plDispatchLogBase::GetInstance()->LogLongReceive(keyname, className, clonePlayerID, msg, rcvTime);
+                        plDispatchLogBase::GetInstance()->LogLongReceive(keyname.c_str(), className, clonePlayerID, msg, rcvTime);
                 }
 #endif // PLASMA_EXTERNAL_RELEASE
 
diff --git a/Sources/Plasma/NucleusLib/pnKeyedObject/hsKeyedObject.cpp b/Sources/Plasma/NucleusLib/pnKeyedObject/hsKeyedObject.cpp
index 233baa92..3c7b10d3 100644
--- a/Sources/Plasma/NucleusLib/pnKeyedObject/hsKeyedObject.cpp
+++ b/Sources/Plasma/NucleusLib/pnKeyedObject/hsKeyedObject.cpp
@@ -65,12 +65,12 @@ hsBool hsKeyedObject::SendRef(plRefMsg* refMsg, plRefFlags::Type flags)
     return hsgResMgr::SendRef(key, refMsg, flags);
 }
 
-const char* hsKeyedObject::GetKeyName() const
+plString hsKeyedObject::GetKeyName() const
 {
     if (fpKey)
         return fpKey->GetName();
     else
-        return "(unknown)";
+        return _TEMP_CONVERT_FROM_LITERAL("(unknown)");
 }
 
 hsKeyedObject::~hsKeyedObject()
@@ -123,7 +123,7 @@ void hsKeyedObject::UnRegisterAs(plFixedKeyId fixedKey)
     UnRegisterAsManual(uoid);
 }
 
-plKey hsKeyedObject::RegisterAsManual(plUoid& meUoid, const char* p)
+plKey hsKeyedObject::RegisterAsManual(plUoid& meUoid, const plString& p)
 {
     hsAssert(meUoid.GetClassType() == ClassIndex(),"Registering as wrong type!");
     // Really should be a NewKey() call just for fixed keys, so change this once player rooms behave
diff --git a/Sources/Plasma/NucleusLib/pnKeyedObject/hsKeyedObject.h b/Sources/Plasma/NucleusLib/pnKeyedObject/hsKeyedObject.h
index b6e04440..2efd15b5 100644
--- a/Sources/Plasma/NucleusLib/pnKeyedObject/hsKeyedObject.h
+++ b/Sources/Plasma/NucleusLib/pnKeyedObject/hsKeyedObject.h
@@ -62,7 +62,7 @@ public:
     GETINTERFACE_ANY(hsKeyedObject, plReceiver);
 
     const plKey&    GetKey() const { return fpKey; }
-    const char*     GetKeyName() const;
+    plString        GetKeyName() const;
 
     virtual void Validate();
     virtual hsBool  IsFinal() { return true; };     // experimental; currently "is ready to process Loads"
@@ -85,7 +85,7 @@ public:
     void    UnRegisterAs(plFixedKeyId fixedKey);
 
     // used when manually loading the player room
-    plKey   RegisterAsManual(plUoid& uoid, const char* p); 
+    plKey   RegisterAsManual(plUoid& uoid, const plString& p);
     void    UnRegisterAsManual(plUoid& uoid);
 
     // If you want clone keys to share a type of object, override this function for it.
diff --git a/Sources/Plasma/NucleusLib/pnKeyedObject/plFixedKey.cpp b/Sources/Plasma/NucleusLib/pnKeyedObject/plFixedKey.cpp
index ab4c1b42..4866da6f 100644
--- a/Sources/Plasma/NucleusLib/pnKeyedObject/plFixedKey.cpp
+++ b/Sources/Plasma/NucleusLib/pnKeyedObject/plFixedKey.cpp
@@ -64,11 +64,11 @@ struct plKeySeed
     // NOTE: The following fields are broken out to make adding to the fixed key list easier.
     // However, what they really are, are just the fields of plUoid (including plLocation)
     UInt16      fType;
-    const char  *fObj;
+    plString    fObj;
    
     hsBool Match( plKeySeed *p ) 
     {  
-        if( ( fType == p->fType ) && stricmp( p->fObj, fObj ) == 0 )
+        if( ( fType == p->fType ) && p->fObj.Compare( fObj, plString::kCaseInsensitive ) == 0 )
         {
             return true;
         }
@@ -82,48 +82,50 @@ struct plKeySeed
     // 2) Be sure your ClassIndex CLASS_INDEX(plSceneObject) matches the type of object you want to have the fixedKey
     // 3) Make sure the Obj is unique for this location/Type Combo... (validated at runtime)
 
+#define _TCFL _TEMP_CONVERT_FROM_LITERAL
 plKeySeed SeedList[] = {
         //  Key Enum                    Type                                            Obj
 
-    { kFirst_Fixed_KEY,                 CLASS_INDEX_SCOPED( plSceneObject ),            "kFirst_Fixed_KEY" },
-
-    { kLOSObject_KEY,                   CLASS_INDEX_SCOPED( plLOSDispatch ),            "kLOSObject_KEY",               },
-    { kTimerCallbackManager_KEY,        CLASS_INDEX_SCOPED( plTimerCallbackManager ),   "kTimerCallbackManager_KEY",    },
-    { kConsoleObject_KEY,               CLASS_INDEX_SCOPED( pfConsole ),                "kConsoleObject_KEY",           },
-    { kAudioSystem_KEY,                 CLASS_INDEX_SCOPED( plAudioSystem ),            "kAudioSystem_KEY",             },
-    { kInput_KEY,                       CLASS_INDEX_SCOPED( plInputManager ),           "kInput_KEY",                   },
-    { kClient_KEY,                      CLASS_INDEX_SCOPED( plClient ),                 "kClient_KEY",                  },
-    { kNetClientMgr_KEY,                CLASS_INDEX_SCOPED( plNetClientMgr ),           "kNetClientMgr_KEY",            },
-    { kListenerMod_KEY,                 CLASS_INDEX_SCOPED( plListener ),               "kListenerMod_KEY",             },
-    { kTransitionMgr_KEY,               CLASS_INDEX_SCOPED( plTransitionMgr ),          "kTransitionMgr_KEY",           },
-    { kLinkEffectsMgr_KEY,              CLASS_INDEX_SCOPED( plLinkEffectsMgr ),         "kLinkEffectsMgr_KEY",          },
-    { kGameGUIMgr_KEY,                  CLASS_INDEX_SCOPED( pfGameGUIMgr ),             "kGameGUIMgr_KEY",              },
-    { kGameGUIDynamicDlg_KEY,           CLASS_INDEX_SCOPED( plSceneNode ),              "kGameGUIDynamicDlg_KEY",       },
-    { kVirtualCamera1_KEY,              CLASS_INDEX_SCOPED( plVirtualCam1 ),            "kVirtualCamera_KEY",           },
-    { kDefaultCameraMod1_KEY,           CLASS_INDEX_SCOPED( plCameraModifier1 ),        "kDefaultCameraMod1_KEY",       },
-    { kKIGUIGlue_KEY,                   CLASS_INDEX_SCOPED( pfKI ),                     "kKIGUIGlue_KEY",               },
-    { kClothingMgr_KEY,                 CLASS_INDEX_SCOPED( plClothingMgr ),            "kClothingMgr_KEY",             },
-    { kInputInterfaceMgr_KEY,           CLASS_INDEX_SCOPED( plInputInterfaceMgr ),      "kInputInterfaceMgr_KEY",       },
-    { kAVIWriter_KEY,                   CLASS_INDEX_SCOPED( plAVIWriter ),              "kAVIWriter_KEY",               },
-    { kResManagerHelper_KEY,            CLASS_INDEX_SCOPED( plResManagerHelper ),       "kResManagerHelper_KEY",        },
-    { kAvatarMgr_KEY,                   CLASS_INDEX_SCOPED( plAvatarMgr ),              "kAvatarMgr_KEY",               },
-    { kSimulationMgr_KEY,               CLASS_INDEX_SCOPED( plSimulationMgr ),          "kSimulationMgr_KEY",           },
-    { kTransitionCamera_KEY,            CLASS_INDEX_SCOPED( plCameraModifier1 ),        "kTransitionCamera_KEY",        },
-    { kCCRMgr_KEY,                      CLASS_INDEX_SCOPED( plCCRMgr ),                 "kCCRMgr_KEY",                  },
-    { kNetClientCloneRoom_KEY,          CLASS_INDEX_SCOPED( plSceneNode ),              "kNetClientCloneRoom_KEY",      },
-    { kMarkerMgr_KEY,                   CLASS_INDEX_SCOPED( pfMarkerMgr ),              "kMarkerMgr_KEY",               },
-    { kAutoProfile_KEY,                 CLASS_INDEX_SCOPED( plAutoProfile ),            "kAutoProfile_KEY",             },
-    { kGlobalVisMgr_KEY,                CLASS_INDEX_SCOPED( plVisMgr ),                 "kGlobalVisMgr_KEY",            },
-    { kFontCache_KEY,                   CLASS_INDEX_SCOPED( plFontCache ),              "kFontCache_KEY",               },
-    { kRelevanceMgr_KEY,                CLASS_INDEX_SCOPED( plRelevanceMgr ),           "kRelevanceMgr_KEY",            },
-    { kJournalBookMgr_KEY,              CLASS_INDEX_SCOPED( pfJournalBook ),            "kJournalBookMgr_KEY"           },
-    { kAgeLoader_KEY,                   CLASS_INDEX_SCOPED( plAgeLoader),               "kAgeLoader_KEY"                },
-    { kBuiltIn3rdPersonCamera_KEY,      CLASS_INDEX_SCOPED( plCameraModifier1 ),        "kBuiltIn3rdPersonCamera_KEY",  },
-    { kSecurePreloader_KEY,             CLASS_INDEX_SCOPED( pfSecurePreloader ),        "kSecurePreloader_KEY",         },
+    { kFirst_Fixed_KEY,                 CLASS_INDEX_SCOPED( plSceneObject ),            _TCFL("kFirst_Fixed_KEY")              },
+
+    { kLOSObject_KEY,                   CLASS_INDEX_SCOPED( plLOSDispatch ),            _TCFL("kLOSObject_KEY"),               },
+    { kTimerCallbackManager_KEY,        CLASS_INDEX_SCOPED( plTimerCallbackManager ),   _TCFL("kTimerCallbackManager_KEY"),    },
+    { kConsoleObject_KEY,               CLASS_INDEX_SCOPED( pfConsole ),                _TCFL("kConsoleObject_KEY"),           },
+    { kAudioSystem_KEY,                 CLASS_INDEX_SCOPED( plAudioSystem ),            _TCFL("kAudioSystem_KEY"),             },
+    { kInput_KEY,                       CLASS_INDEX_SCOPED( plInputManager ),           _TCFL("kInput_KEY"),                   },
+    { kClient_KEY,                      CLASS_INDEX_SCOPED( plClient ),                 _TCFL("kClient_KEY"),                  },
+    { kNetClientMgr_KEY,                CLASS_INDEX_SCOPED( plNetClientMgr ),           _TCFL("kNetClientMgr_KEY"),            },
+    { kListenerMod_KEY,                 CLASS_INDEX_SCOPED( plListener ),               _TCFL("kListenerMod_KEY"),             },
+    { kTransitionMgr_KEY,               CLASS_INDEX_SCOPED( plTransitionMgr ),          _TCFL("kTransitionMgr_KEY"),           },
+    { kLinkEffectsMgr_KEY,              CLASS_INDEX_SCOPED( plLinkEffectsMgr ),         _TCFL("kLinkEffectsMgr_KEY"),          },
+    { kGameGUIMgr_KEY,                  CLASS_INDEX_SCOPED( pfGameGUIMgr ),             _TCFL("kGameGUIMgr_KEY"),              },
+    { kGameGUIDynamicDlg_KEY,           CLASS_INDEX_SCOPED( plSceneNode ),              _TCFL("kGameGUIDynamicDlg_KEY"),       },
+    { kVirtualCamera1_KEY,              CLASS_INDEX_SCOPED( plVirtualCam1 ),            _TCFL("kVirtualCamera_KEY"),           },
+    { kDefaultCameraMod1_KEY,           CLASS_INDEX_SCOPED( plCameraModifier1 ),        _TCFL("kDefaultCameraMod1_KEY"),       },
+    { kKIGUIGlue_KEY,                   CLASS_INDEX_SCOPED( pfKI ),                     _TCFL("kKIGUIGlue_KEY"),               },
+    { kClothingMgr_KEY,                 CLASS_INDEX_SCOPED( plClothingMgr ),            _TCFL("kClothingMgr_KEY"),             },
+    { kInputInterfaceMgr_KEY,           CLASS_INDEX_SCOPED( plInputInterfaceMgr ),      _TCFL("kInputInterfaceMgr_KEY"),       },
+    { kAVIWriter_KEY,                   CLASS_INDEX_SCOPED( plAVIWriter ),              _TCFL("kAVIWriter_KEY"),               },
+    { kResManagerHelper_KEY,            CLASS_INDEX_SCOPED( plResManagerHelper ),       _TCFL("kResManagerHelper_KEY"),        },
+    { kAvatarMgr_KEY,                   CLASS_INDEX_SCOPED( plAvatarMgr ),              _TCFL("kAvatarMgr_KEY"),               },
+    { kSimulationMgr_KEY,               CLASS_INDEX_SCOPED( plSimulationMgr ),          _TCFL("kSimulationMgr_KEY"),           },
+    { kTransitionCamera_KEY,            CLASS_INDEX_SCOPED( plCameraModifier1 ),        _TCFL("kTransitionCamera_KEY"),        },
+    { kCCRMgr_KEY,                      CLASS_INDEX_SCOPED( plCCRMgr ),                 _TCFL("kCCRMgr_KEY"),                  },
+    { kNetClientCloneRoom_KEY,          CLASS_INDEX_SCOPED( plSceneNode ),              _TCFL("kNetClientCloneRoom_KEY"),      },
+    { kMarkerMgr_KEY,                   CLASS_INDEX_SCOPED( pfMarkerMgr ),              _TCFL("kMarkerMgr_KEY"),               },
+    { kAutoProfile_KEY,                 CLASS_INDEX_SCOPED( plAutoProfile ),            _TCFL("kAutoProfile_KEY"),             },
+    { kGlobalVisMgr_KEY,                CLASS_INDEX_SCOPED( plVisMgr ),                 _TCFL("kGlobalVisMgr_KEY"),            },
+    { kFontCache_KEY,                   CLASS_INDEX_SCOPED( plFontCache ),              _TCFL("kFontCache_KEY"),               },
+    { kRelevanceMgr_KEY,                CLASS_INDEX_SCOPED( plRelevanceMgr ),           _TCFL("kRelevanceMgr_KEY"),            },
+    { kJournalBookMgr_KEY,              CLASS_INDEX_SCOPED( pfJournalBook ),            _TCFL("kJournalBookMgr_KEY")           },
+    { kAgeLoader_KEY,                   CLASS_INDEX_SCOPED( plAgeLoader),               _TCFL("kAgeLoader_KEY")                },
+    { kBuiltIn3rdPersonCamera_KEY,      CLASS_INDEX_SCOPED( plCameraModifier1 ),        _TCFL("kBuiltIn3rdPersonCamera_KEY"),  },
+    { kSecurePreloader_KEY,             CLASS_INDEX_SCOPED( pfSecurePreloader ),        _TCFL("kSecurePreloader_KEY"),         },
     
 
-    { kLast_Fixed_KEY,                  CLASS_INDEX_SCOPED( plSceneObject ),            "kLast_Fixed_KEY",              }
+    { kLast_Fixed_KEY,                  CLASS_INDEX_SCOPED( plSceneObject ),            _TCFL("kLast_Fixed_KEY"),              }
 };
+#undef _TCFL
 
 
 //// plFixedKeyValidator /////////////////////////////////////////////////////
@@ -166,14 +168,13 @@ plUoid::plUoid(plFixedKeyId fixedkey)
 {
     hsAssert(fixedkey < kLast_Fixed_KEY, "Request for Fixed key is out of Range");
 
-    fObjectName = nil;
     Invalidate();
 
     plKeySeed* p= &SeedList[fixedkey];
 
     fLocation = plLocation::kGlobalFixedLoc;
     fClassType = p->fType;
-    fObjectName = hsStrcpy(p->fObj);
+    fObjectName = p->fObj;
     fObjectID = 0;
     fCloneID = 0;
     fClonePlayerID = 0;
diff --git a/Sources/Plasma/NucleusLib/pnKeyedObject/plKey.h b/Sources/Plasma/NucleusLib/pnKeyedObject/plKey.h
index 9207e0e2..f740db09 100644
--- a/Sources/Plasma/NucleusLib/pnKeyedObject/plKey.h
+++ b/Sources/Plasma/NucleusLib/pnKeyedObject/plKey.h
@@ -55,6 +55,7 @@ class hsBitVector;
 
 class plKeyData;
 class plKeyImp;
+class plString;
 
 class plKey 
 {
@@ -96,7 +97,7 @@ class plKeyData
 {
 public:
     virtual const plUoid&   GetUoid() const=0;
-    virtual const char*     GetName() const=0;
+    virtual const plString& GetName() const=0;
 
     virtual hsKeyedObject*  GetObjectPtr()=0;
     virtual hsKeyedObject*  ObjectIsLoaded() const=0;
diff --git a/Sources/Plasma/NucleusLib/pnKeyedObject/plKeyImp.cpp b/Sources/Plasma/NucleusLib/pnKeyedObject/plKeyImp.cpp
index 40b0bf14..80bc6555 100644
--- a/Sources/Plasma/NucleusLib/pnKeyedObject/plKeyImp.cpp
+++ b/Sources/Plasma/NucleusLib/pnKeyedObject/plKeyImp.cpp
@@ -55,8 +55,8 @@ plProfile_CreateMemCounter("Keys", "Memory", KeyMem);
 static UInt32 CalcKeySize(plKeyImp* key)
 {
     UInt32 nameLen = 0;
-    if (key->GetUoid().GetObjectName())
-        nameLen = strlen(key->GetUoid().GetObjectName()) + 1;
+    if (!key->GetUoid().GetObjectName().IsNull())
+        nameLen = key->GetUoid().GetObjectName().GetSize() + 1;
     return sizeof(plKeyImp) + nameLen;
 }
 
@@ -143,7 +143,7 @@ void plKeyImp::SetUoid(const plUoid& uoid)
 #endif
 }
 
-const char* plKeyImp::GetName() const   
+const plString& plKeyImp::GetName() const
 { 
     return fUoid.GetObjectName(); 
 }
diff --git a/Sources/Plasma/NucleusLib/pnKeyedObject/plKeyImp.h b/Sources/Plasma/NucleusLib/pnKeyedObject/plKeyImp.h
index a054990b..222c80df 100644
--- a/Sources/Plasma/NucleusLib/pnKeyedObject/plKeyImp.h
+++ b/Sources/Plasma/NucleusLib/pnKeyedObject/plKeyImp.h
@@ -59,7 +59,7 @@ public:
     virtual ~plKeyImp();
 
     virtual const plUoid&   GetUoid() const { return fUoid; }
-    virtual const char*     GetName() const;
+    virtual const plString& GetName() const;
 
     virtual hsKeyedObject*  GetObjectPtr();
     virtual hsKeyedObject*  ObjectIsLoaded() const;
diff --git a/Sources/Plasma/NucleusLib/pnKeyedObject/plMsgForwarder.cpp b/Sources/Plasma/NucleusLib/pnKeyedObject/plMsgForwarder.cpp
index 089fdd2c..b8d9a7ed 100644
--- a/Sources/Plasma/NucleusLib/pnKeyedObject/plMsgForwarder.cpp
+++ b/Sources/Plasma/NucleusLib/pnKeyedObject/plMsgForwarder.cpp
@@ -167,7 +167,7 @@ hsBool plMsgForwarder::IForwardCallbackMsg(plMessage *msg)
             if (--fc->fNumCallbacks == 0)
             {
                 hsStatusMessageF("plEventCallbackMsg received, erasing, sender=%s, remoteMsg=%d\n",
-                    msg->GetSender() ? msg->GetSender()->GetName() : "nil", msg->HasBCastFlag(plMessage::kNetNonLocal));
+                    msg->GetSender() ? msg->GetSender()->GetName().c_str() : "nil", msg->HasBCastFlag(plMessage::kNetNonLocal));
 
                 fCallbacks.erase(eventMsg);
 
@@ -190,7 +190,7 @@ hsBool plMsgForwarder::IForwardCallbackMsg(plMessage *msg)
         else
         {
             hsStatusMessageF("! Unknown plEventCallbackMsg received, sender=%s, remoteMsg=%d\n",
-                msg->GetSender() ? msg->GetSender()->GetName() : "nil", msg->HasBCastFlag(plMessage::kNetNonLocal));
+                msg->GetSender() ? msg->GetSender()->GetName().c_str() : "nil", msg->HasBCastFlag(plMessage::kNetNonLocal));
             hsAssert(0, "Unknown plEventCallbackMsg received");
         }
         return true;
diff --git a/Sources/Plasma/NucleusLib/pnKeyedObject/plUoid.cpp b/Sources/Plasma/NucleusLib/pnKeyedObject/plUoid.cpp
index f70d4a49..555633d4 100644
--- a/Sources/Plasma/NucleusLib/pnKeyedObject/plUoid.cpp
+++ b/Sources/Plasma/NucleusLib/pnKeyedObject/plUoid.cpp
@@ -135,21 +135,19 @@ plLocation plLocation::MakeNormal(UInt32 number)
 
 //// plUoid //////////////////////////////////////////////////////////////////
 
-plUoid::plUoid(const plLocation& location, UInt16 classType, const char* objectName, const plLoadMask& m)
+plUoid::plUoid(const plLocation& location, UInt16 classType, const plString& objectName, const plLoadMask& m)
 {
-    fObjectName = nil;
     Invalidate();
 
     fLocation = location;
     fClassType = classType;
-    fObjectName = hsStrcpy(objectName);
+    fObjectName = objectName;
     fLoadMask = m;
     fClonePlayerID = 0;
 }
 
 plUoid::plUoid(const plUoid& src)
 {
-    fObjectName = nil;
     Invalidate();
     *this = src;
 }
@@ -177,7 +175,7 @@ void plUoid::Read(hsStream* s)
     s->LogReadLE(&fClassType, "ClassType");
     s->LogReadLE(&fObjectID, "ObjectID");
     s->LogSubStreamPushDesc("ObjectName");
-    fObjectName = s->LogReadSafeString();
+    fObjectName = s->LogReadSafeString_TEMP();
 
     // conditional cloneIDs read
     if (contents & kHasCloneIDs)
@@ -210,7 +208,7 @@ void plUoid::Write(hsStream* s) const
 
     s->WriteLE( fClassType );
     s->WriteLE( fObjectID );
-    s->WriteSafeString( fObjectName );
+    s->WriteSafeString_TEMP( fObjectName );
 
     // conditional cloneIDs write
     if (contents & kHasCloneIDs)
@@ -228,9 +226,7 @@ void plUoid::Invalidate()
     fCloneID = 0;
     fClonePlayerID = 0;
     fClassType = 0;
-    if (fObjectName)
-        delete [] fObjectName;
-    fObjectName = nil;
+    fObjectName = plString::Null;
     fLocation.Invalidate();
     fLoadMask = plLoadMask::kAlways;
 
@@ -238,7 +234,7 @@ void plUoid::Invalidate()
 
 hsBool plUoid::IsValid() const
 {
-    if (!fLocation.IsValid() || fObjectName == nil)
+    if (!fLocation.IsValid() || fObjectName.IsNull())
         return false;
 
     return true;
@@ -249,7 +245,7 @@ hsBool plUoid::operator==(const plUoid& u) const
     return  fLocation == u.fLocation
             && fLoadMask == u.fLoadMask
             && fClassType == u.fClassType
-            && hsStrEQ(fObjectName, u.fObjectName)
+            && fObjectName == u.fObjectName
             && fObjectID == u.fObjectID
             && fCloneID == u.fCloneID
             && fClonePlayerID == u.fClonePlayerID;
@@ -261,9 +257,7 @@ plUoid& plUoid::operator=(const plUoid& rhs)
     fCloneID = rhs.fCloneID;
     fClonePlayerID = rhs.fClonePlayerID;
     fClassType = rhs.fClassType;
-    if (fObjectName)
-        delete [] fObjectName;
-    fObjectName = hsStrcpy(rhs.fObjectName);
+    fObjectName = rhs.fObjectName;
     fLocation = rhs.fLocation;
     fLoadMask = rhs.fLoadMask;
 
@@ -276,7 +270,7 @@ plString plUoid::StringIze() const // Format to displayable string
     return plString::Format("(0x%x:0x%x:%s:C:[%u,%u])",
         fLocation.GetSequenceNumber(), 
         int(fLocation.GetFlags()), 
-        fObjectName, 
+        fObjectName.c_str(),
         GetClonePlayerID(), 
         GetCloneID());
 }
diff --git a/Sources/Plasma/NucleusLib/pnKeyedObject/plUoid.h b/Sources/Plasma/NucleusLib/pnKeyedObject/plUoid.h
index fa11c0f8..c5458f00 100644
--- a/Sources/Plasma/NucleusLib/pnKeyedObject/plUoid.h
+++ b/Sources/Plasma/NucleusLib/pnKeyedObject/plUoid.h
@@ -57,9 +57,9 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 #include "hsTypes.h"
 #include "plFixedKey.h"
 #include "plLoadMask.h"
+#include "plString.h"
 
 class hsStream;
-class plString;
 
 //// plLocation //////////////////////////////////////////////////////////////
 
@@ -144,15 +144,15 @@ public:
 class plUoid
 {
 public:
-    plUoid() { fObjectName = nil; Invalidate(); }
-    plUoid(const plLocation& location, UInt16 classType, const char* objectName, const plLoadMask& m=plLoadMask::kAlways);
+    plUoid() { Invalidate(); }
+    plUoid(const plLocation& location, UInt16 classType, const plString& objectName, const plLoadMask& m=plLoadMask::kAlways);
     plUoid(plFixedKeyId fixedKey);
     plUoid(const plUoid& src);
     ~plUoid();
 
     const plLocation&   GetLocation() const { return fLocation; }
     UInt16              GetClassType() const { return fClassType; }
-    const char*         GetObjectName() const { return fObjectName; }
+    const plString&     GetObjectName() const { return fObjectName; }
     const plLoadMask&   GetLoadMask() const { return fLoadMask; }
 
     void Read(hsStream* s);
@@ -188,7 +188,7 @@ protected:
     UInt32      fClonePlayerID; // The ID of the player who made this clone
     UInt16      fCloneID;       // The ID of this clone (unique per client)
     UInt16      fClassType;
-    char*       fObjectName;
+    plString    fObjectName;
     plLocation  fLocation;
     plLoadMask  fLoadMask;
 };
diff --git a/Sources/Plasma/NucleusLib/pnMessage/plMessage.cpp b/Sources/Plasma/NucleusLib/pnMessage/plMessage.cpp
index 86b7abff..2eef2b1c 100644
--- a/Sources/Plasma/NucleusLib/pnMessage/plMessage.cpp
+++ b/Sources/Plasma/NucleusLib/pnMessage/plMessage.cpp
@@ -313,7 +313,7 @@ int plMsgStdStringHelper::PeekBig(std::string  & stringref, hsStream* stream, co
     return stream->GetPosition();
 }
 
-int plMsgStdStringHelper::Peek(plString  & stringref, hsStream* stream, const UInt32 peekOptions)
+int plMsgStdStringHelper::Peek(plString & stringref, hsStream* stream, const UInt32 peekOptions)
 {
     std::string temp;
     int pos = Peek(temp, stream, peekOptions);
@@ -321,7 +321,7 @@ int plMsgStdStringHelper::Peek(plString  & stringref, hsStream* stream, const UI
     return pos;
 }
 
-int plMsgStdStringHelper::PeekBig(plString  & stringref, hsStream* stream, const UInt32 peekOptions)
+int plMsgStdStringHelper::PeekBig(plString & stringref, hsStream* stream, const UInt32 peekOptions)
 {
     std::string temp;
     int pos = PeekBig(temp, stream, peekOptions);
@@ -399,6 +399,20 @@ int plMsgCStringHelper::Peek(char *& str, hsStream* stream, const UInt32 peekOpt
     return stream->GetPosition();
 }
 
+int plMsgCStringHelper::Poke(const plString & str, hsStream* stream, const UInt32 peekOptions)
+{
+    return Poke(str.c_str(), stream, peekOptions);
+}
+
+int plMsgCStringHelper::Peek(plString & str, hsStream* stream, const UInt32 peekOptions)
+{
+    char * temp = nil;
+    int pos = Peek(temp, stream, peekOptions);
+    str = plString::FromIso8859_1(temp);
+    delete [] temp;
+    return pos;
+}
+
 
 /////////////////////////////////////////////////////////////////
 
diff --git a/Sources/Plasma/NucleusLib/pnMessage/plMessage.h b/Sources/Plasma/NucleusLib/pnMessage/plMessage.h
index 6a53a8d0..0c602acb 100644
--- a/Sources/Plasma/NucleusLib/pnMessage/plMessage.h
+++ b/Sources/Plasma/NucleusLib/pnMessage/plMessage.h
@@ -190,13 +190,16 @@ struct plMsgXtlStringHelper
 };
 
 /////////////////////////////////////////////////////////////////
-// reads/writes your char * field
+// reads/writes your char * field  (deprecated)
 
 struct plMsgCStringHelper
 {
     static int Poke(const char * str, hsStream* stream, const UInt32 peekOptions=0);
     // deletes str and reallocates. you must delete [] str;
     static int Peek(char *& str, hsStream* stream, const UInt32 peekOptions=0);
+
+    static int Poke(const plString & str, hsStream* stream, const UInt32 peekOptions=0);
+    static int Peek(plString & str, hsStream* stream, const UInt32 peekOptions=0);
 };
 
 /////////////////////////////////////////////////////////////////
diff --git a/Sources/Plasma/PubUtilLib/plAgeLoader/plAgeLoaderPaging.cpp b/Sources/Plasma/PubUtilLib/plAgeLoader/plAgeLoaderPaging.cpp
index 8a882667..fc4ed194 100644
--- a/Sources/Plasma/PubUtilLib/plAgeLoader/plAgeLoaderPaging.cpp
+++ b/Sources/Plasma/PubUtilLib/plAgeLoader/plAgeLoaderPaging.cpp
@@ -69,10 +69,10 @@ bool ReportRoomToServer(const plKey &key)
     plLocation keyLoc=key->GetUoid().GetLocation();
     bool skip=(keyLoc.IsReserved() || keyLoc.IsVirtual() ||
                 // HACK ALERT - replace with new uoid type flags
-                (key->GetName() && 
-                    (!strnicmp(key->GetName(), "global", 6) ||
-                    strstr(key->GetName(), "_Male") ||
-                    strstr(key->GetName(), "_Female") 
+                (!key->GetName().IsNull() &&
+                    (!key->GetName().CompareN("global", 6, plString::kCaseInsensitive) ||
+                    key->GetName().Find("_Male") >= 0 ||
+                    key->GetName().Find("_Female") >= 0
                     )
                 )
             );  
diff --git a/Sources/Plasma/PubUtilLib/plAudible/plWinAudible.cpp b/Sources/Plasma/PubUtilLib/plAudible/plWinAudible.cpp
index 72ec8bcc..a9a655f4 100644
--- a/Sources/Plasma/PubUtilLib/plAudible/plWinAudible.cpp
+++ b/Sources/Plasma/PubUtilLib/plAudible/plWinAudible.cpp
@@ -473,9 +473,7 @@ void plWinAudible::Read(hsStream* s, hsResMgr* mgr)
 
 void plWinAudible::IAssignSoundKey( plSound *sound, const char *name, UInt32 i )
 {
-    char    keyName[ 256 ];
-
-    sprintf( keyName, "%s_%d", name, i );
+    plString keyName = plString::Format( "%s_%d", name, i );
     hsgResMgr::ResMgr()->NewKey( keyName, sound, GetKey() ? GetKey()->GetUoid().GetLocation() : plLocation::kGlobalFixedLoc );
 }
 
@@ -607,7 +605,7 @@ int plWinAudible::GetSoundIndex(const char *keyname) const
     for( int i = 0; i < fSoundObjs.Count(); i++)
     {
         if(!fSoundObjs[i]) continue;
-        if(!strcmp(fSoundObjs[i]->GetKeyName(), keyname ))
+        if(!fSoundObjs[i]->GetKeyName().Compare( keyname ))
         {
             return i;
         }
diff --git a/Sources/Plasma/PubUtilLib/plAudio/plAudioSystem.cpp b/Sources/Plasma/PubUtilLib/plAudio/plAudioSystem.cpp
index dd4aa736..bd80bcde 100644
--- a/Sources/Plasma/PubUtilLib/plAudio/plAudioSystem.cpp
+++ b/Sources/Plasma/PubUtilLib/plAudio/plAudioSystem.cpp
@@ -934,7 +934,7 @@ hsBool plAudioSystem::MsgReceive(plMessage* msg)
     {
         //if( fListener )
         {
-            plProfile_BeginLap(AudioUpdate, this->GetKey()->GetUoid().GetObjectName());
+            plProfile_BeginLap(AudioUpdate, this->GetKey()->GetUoid().GetObjectName().c_str());
             if(hsTimer::GetMilliSeconds() - fLastUpdateTimeMs > UPDATE_TIME_MS)
             {
                 IUpdateSoftSounds( fCurrListenerPos );
@@ -947,7 +947,7 @@ hsBool plAudioSystem::MsgReceive(plMessage* msg)
                 }
                 //fCommittedListenerPos = fCurrListenerPos;
             }
-            plProfile_EndLap(AudioUpdate, this->GetKey()->GetUoid().GetObjectName());
+            plProfile_EndLap(AudioUpdate, this->GetKey()->GetUoid().GetObjectName().c_str());
         }
         
         return true;
diff --git a/Sources/Plasma/PubUtilLib/plAudio/plSound.cpp b/Sources/Plasma/PubUtilLib/plAudio/plSound.cpp
index bbc8e58a..e63f29d8 100644
--- a/Sources/Plasma/PubUtilLib/plAudio/plSound.cpp
+++ b/Sources/Plasma/PubUtilLib/plAudio/plSound.cpp
@@ -141,10 +141,10 @@ void plSound::IPrintDbgMessage( const char *msg, hsBool isError )
 
     if( isError )
 //      ourLog->AddLineF( plStatusLog::kRed, "ERROR: %s (%s)", msg, GetKey() ? GetKeyName() : "unkeyed" );
-        ourLog->AddLineS( "audio.log", plStatusLog::kRed, "ERROR: %s (%s)", msg, GetKey() ? GetKeyName() : "unkeyed" );
+        ourLog->AddLineS( "audio.log", plStatusLog::kRed, "ERROR: %s (%s)", msg, GetKey() ? GetKeyName().c_str() : "unkeyed" );
     else
 //      ourLog->AddLineF( "%s (%s)", msg, GetKey() ? GetKeyName() : "unkeyed" );
-        ourLog->AddLineS( "audio.log", "%s (%s)", msg, GetKey() ? GetKeyName() : "unkeyed" );
+        ourLog->AddLineS( "audio.log", "%s (%s)", msg, GetKey() ? GetKeyName().c_str() : "unkeyed" );
 }
 
 ///////////////////////////////////////////////////////////
@@ -163,7 +163,7 @@ void plSound::IUpdateDebugPlate( void )
             fDebugPlate->SetPosition( -0.5, 0 );
             fDebugPlate->SetDataRange( 0, 100, 100 );
             fDebugPlate->SetColors( 0x80202000 );
-            fDebugPlate->SetTitle( (char *)GetKeyName() );      // Bleah
+            fDebugPlate->SetTitle( _TEMP_CONVERT_TO_CONST_CHAR( GetKeyName() ) );      // Bleah
             fDebugPlate->SetLabelText( "Desired", "Curr", "Soft", "Dist" );
         }
 
@@ -190,7 +190,7 @@ void plSound::SetCurrDebugPlate( const plKey soundKey )
         {
             fDebugPlate->ClearData();
             fDebugPlate->SetVisible( true );
-            fDebugPlate->SetTitle( (char *)fCurrDebugPlateSound->GetKeyName() );        // Bleah
+            fDebugPlate->SetTitle( _TEMP_CONVERT_TO_CONST_CHAR( fCurrDebugPlateSound->GetKeyName() ) );        // Bleah
         }
     }
 }
diff --git a/Sources/Plasma/PubUtilLib/plAudio/plVoiceChat.cpp b/Sources/Plasma/PubUtilLib/plAudio/plVoiceChat.cpp
index 5321bcec..4a806811 100644
--- a/Sources/Plasma/PubUtilLib/plAudio/plVoiceChat.cpp
+++ b/Sources/Plasma/PubUtilLib/plAudio/plVoiceChat.cpp
@@ -410,8 +410,7 @@ plVoiceSound::plVoiceSound()
     fEAXSettings.SetRoomParams(-1200, -100, 0, 0);
     fLastUpdate = 0;
 
-    char keyName[32];
-    snprintf(keyName, arrsize(keyName), "VoiceSound_%d", fCount);
+    plString keyName = plString::Format("VoiceSound_%d", fCount);
     fCount++;
     hsgResMgr::ResMgr()->NewKey(keyName, this, plLocation::kGlobalFixedLoc);
 }
diff --git a/Sources/Plasma/PubUtilLib/plAudio/plWin32GroupedSound.cpp b/Sources/Plasma/PubUtilLib/plAudio/plWin32GroupedSound.cpp
index 08a5bc45..b24e8a2e 100644
--- a/Sources/Plasma/PubUtilLib/plAudio/plWin32GroupedSound.cpp
+++ b/Sources/Plasma/PubUtilLib/plAudio/plWin32GroupedSound.cpp
@@ -160,9 +160,8 @@ hsBool  plWin32GroupedSound::LoadSound( hsBool is3D )
     // We need it to be resident to read in
     if( retVal == plSoundBuffer::kError) 
     {
-        char str[ 256 ];
-        sprintf( str, "Unable to open .wav file %s", fDataBufferKey ? fDataBufferKey->GetName() : "nil");
-        IPrintDbgMessage( str, true );
+        plString str = plString::Format("Unable to open .wav file %s", fDataBufferKey ? fDataBufferKey->GetName().c_str() : "nil");
+        IPrintDbgMessage( str.c_str(), true );
         fFailed = true;
         return false;
     }
@@ -229,9 +228,8 @@ hsBool  plWin32GroupedSound::LoadSound( hsBool is3D )
     IFillCurrentSound( 0 );
 
     // Logging
-    char str[ 256 ];
-    sprintf( str, "   Grouped %s %s allocated (%d msec).", buffer->GetFileName() != nil ? "file" : "buffer", 
-                                            buffer->GetFileName() != nil ? buffer->GetFileName() : buffer->GetKey()->GetUoid().GetObjectName(),
+    plString str = plString::Format("   Grouped %s %s allocated (%d msec).", buffer->GetFileName() != nil ? "file" : "buffer",
+                                            buffer->GetFileName() != nil ? buffer->GetFileName() : buffer->GetKey()->GetUoid().GetObjectName().c_str(),
                                             //fDSoundBuffer->IsHardwareAccelerated() ? "hardware" : "software",
                                             //fDSoundBuffer->IsStaticVoice() ? "static" : "dynamic",
 #ifdef PL_PROFILE_ENABLED
@@ -239,11 +237,11 @@ hsBool  plWin32GroupedSound::LoadSound( hsBool is3D )
 #else
                                             0 );
 #endif
-    IPrintDbgMessage( str );
-    if( GetKey() != nil && GetKeyName() != nil && strstr( GetKeyName(), "Footstep" ) != nil )
+    IPrintDbgMessage( str.c_str() );
+    if( GetKey() != nil && GetKeyName().Find( "Footstep" ) >= 0 )
         ;
     else
-        plStatusLog::AddLineS( "audioTimes.log", "%s (%s)", str, GetKey() ? GetKeyName() : "unkeyed" );
+        plStatusLog::AddLineS( "audioTimes.log", "%s (%s)", str, GetKey() ? GetKeyName().c_str() : "unkeyed" );
 
     fTotalBytes = bufferSize;
 
diff --git a/Sources/Plasma/PubUtilLib/plAudio/plWin32Sound.cpp b/Sources/Plasma/PubUtilLib/plAudio/plWin32Sound.cpp
index cd61403f..e64aaf31 100644
--- a/Sources/Plasma/PubUtilLib/plAudio/plWin32Sound.cpp
+++ b/Sources/Plasma/PubUtilLib/plAudio/plWin32Sound.cpp
@@ -168,7 +168,7 @@ void plWin32Sound::IActuallyStop()
     {
         if( fDSoundBuffer != nil && fDSoundBuffer->IsPlaying() )
         {
-            plStatusLog::AddLineS( "audio.log", 0xffff0000, "WARNING: BUFFER FLAGGED AS STOPPED BUT NOT STOPPED - %s", GetKey() ? GetKeyName() : nil );
+            plStatusLog::AddLineS( "audio.log", 0xffff0000, "WARNING: BUFFER FLAGGED AS STOPPED BUT NOT STOPPED - %s", GetKey() ? GetKeyName().c_str() : nil );
             fDSoundBuffer->Stop();
         }
     }
diff --git a/Sources/Plasma/PubUtilLib/plAudio/plWin32StaticSound.cpp b/Sources/Plasma/PubUtilLib/plAudio/plWin32StaticSound.cpp
index 46a1ba15..77c4d7a9 100644
--- a/Sources/Plasma/PubUtilLib/plAudio/plWin32StaticSound.cpp
+++ b/Sources/Plasma/PubUtilLib/plAudio/plWin32StaticSound.cpp
@@ -115,9 +115,8 @@ hsBool plWin32StaticSound::LoadSound( hsBool is3D )
 
         if( retVal == plSoundBuffer::kError )
         {
-            char str[ 256 ];
-            sprintf( str, "Unable to open .wav file %s", fDataBufferKey ? fDataBufferKey->GetName() : "nil");
-            IPrintDbgMessage( str, true );
+            plString str = plString::Format( "Unable to open .wav file %s", fDataBufferKey ? fDataBufferKey->GetName().c_str() : "nil");
+            IPrintDbgMessage( str.c_str(), true );
             fFailed = true;
             return false;
         }
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAGMasterMod.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plAGMasterMod.cpp
index 75dfb149..b1148b8a 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAGMasterMod.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAGMasterMod.cpp
@@ -241,7 +241,7 @@ hsBool plAGMasterMod::IEval(double secs, hsScalar del, UInt32 dirty)
 // APPLYANIMATIONS
 void plAGMasterMod::ApplyAnimations(double time, hsScalar elapsed)
 {
-    plProfile_BeginLap(ApplyAnimation, this->GetKey()->GetUoid().GetObjectName());
+    plProfile_BeginLap(ApplyAnimation, this->GetKey()->GetUoid().GetObjectName().c_str());
 
     // update any fades
     for (int i = 0; i < fAnimInstances.size(); i++)
@@ -251,7 +251,7 @@ void plAGMasterMod::ApplyAnimations(double time, hsScalar elapsed)
     
     AdvanceAnimsToTime(time);
 
-    plProfile_EndLap(ApplyAnimation,this->GetKey()->GetUoid().GetObjectName());
+    plProfile_EndLap(ApplyAnimation,this->GetKey()->GetUoid().GetObjectName().c_str());
 }
 
 void plAGMasterMod::AdvanceAnimsToTime(double time)
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAGMasterSDLModifier.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plAGMasterSDLModifier.cpp
index 461ebd70..3779e5d3 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAGMasterSDLModifier.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAGMasterSDLModifier.cpp
@@ -57,10 +57,10 @@ char plAGMasterSDLModifier::AGMasterVarNames::kStrBlends[]="blends";
 UInt32 plAGMasterSDLModifier::IApplyModFlags(UInt32 sendFlags)
 {
     // ugly hack so bug light animation state isn't stored on the server
-    if (stricmp(GetTarget()->GetKeyName(), "RTOmni-BugLightTest") == 0)
+    if (GetTarget()->GetKeyName().Compare("RTOmni-BugLightTest", plString::kCaseInsensitive) == 0)
         return (sendFlags | plSynchedObject::kDontPersistOnServer | plSynchedObject::kIsAvatarState);
     // ditto for the KI light
-    if (stricmp(GetTarget()->GetKeyName(), "RTOmniKILight") == 0)
+    if (GetTarget()->GetKeyName().Compare("RTOmniKILight", plString::kCaseInsensitive) == 0)
         return (sendFlags | plSynchedObject::kDontPersistOnServer | plSynchedObject::kIsAvatarState);
 
     return sendFlags;
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plArmatureMod.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plArmatureMod.cpp
index 0b750b84..d10d43e4 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plArmatureMod.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plArmatureMod.cpp
@@ -809,11 +809,8 @@ int plArmatureMod::IFindSpawnOverride( void )
     plAvatarMgr *mgr = plAvatarMgr::GetInstance();
     for( i = 0; i < mgr->NumSpawnPoints(); i++ )
     {
-        char    str2[ 256 ];
-        strcpy(str2, mgr->GetSpawnPoint( i )->GetTarget(0)->GetKeyName());
-        strlwr(str2);
-
-        if (strstr(str2, fSpawnPointOverride) != nil)
+        const plString &name = mgr->GetSpawnPoint( i )->GetTarget(0)->GetKeyName();
+        if (name.Find(fSpawnPointOverride, plString::kCaseInsensitive) >= 0)
             return i; // Found it!
     }
     return -1;
@@ -1792,33 +1789,33 @@ void plArmatureMod::Read(hsStream * stream, hsResMgr *mgr)
         if (gLoc.IsValid())
         {
             const plUoid &myUoid = GetKey()->GetUoid();
-            plUoid SOUoid(gLoc, plSceneObject::Index(), "FootstepSoundObject");
+            plUoid SOUoid(gLoc, plSceneObject::Index(), _TEMP_CONVERT_FROM_LITERAL("FootstepSoundObject"));
             fFootSoundSOKey = mgr->FindKey(SOUoid);
             if (fFootSoundSOKey)
             {
                 // So it exists... but FindKey won't properly create our clone. So we do.
                 SOUoid.SetClone(myUoid.GetClonePlayerID(), myUoid.GetCloneID());
-                fFootSoundSOKey = mgr->ReRegister(nil, SOUoid);
+                fFootSoundSOKey = mgr->ReRegister(plString::Null, SOUoid);
             }
 
             // Add the effect to our effects manager
-            plUoid effectUoid(gLoc, plArmatureEffectFootSound::Index(), "FootstepSounds" );
+            plUoid effectUoid(gLoc, plArmatureEffectFootSound::Index(), _TEMP_CONVERT_FROM_LITERAL("FootstepSounds") );
             plKey effectKey = mgr->FindKey(effectUoid);
             if (effectKey)
             {
                 effectUoid.SetClone(myUoid.GetClonePlayerID(), myUoid.GetCloneID());
-                effectKey = mgr->ReRegister(nil, effectUoid);
+                effectKey = mgr->ReRegister(plString::Null, effectUoid);
             }
             if (effectKey != nil)
                 mgr->AddViaNotify(effectKey, TRACKED_NEW plGenRefMsg(effectMgrKey, plRefMsg::kOnCreate, -1, -1), plRefFlags::kActiveRef);
 
             // Get the linking sound
-            plUoid LinkUoid(gLoc, plSceneObject::Index(), "LinkSoundSource");
+            plUoid LinkUoid(gLoc, plSceneObject::Index(), _TEMP_CONVERT_FROM_LITERAL("LinkSoundSource"));
             fLinkSoundSOKey = mgr->FindKey(LinkUoid);
             if (fLinkSoundSOKey)
             {
                 LinkUoid.SetClone(myUoid.GetClonePlayerID(), myUoid.GetCloneID());
-                fLinkSoundSOKey = mgr->ReRegister(nil, LinkUoid);
+                fLinkSoundSOKey = mgr->ReRegister(plString::Null, LinkUoid);
             }
         }
     }
@@ -2060,7 +2057,7 @@ hsBool plArmatureMod::ValidateMesh()
                 hsgResMgr::ResMgr()->SendRef(meshObj->GetKey(), refMsg, plRefFlags::kPassiveRef); 
             }
         }
-        if (!strcmp(GetTarget(0)->GetKeyName(), "Yeesha"))
+        if (!GetTarget(0)->GetKeyName().Compare("Yeesha"))
             ISetTransparentDrawOrder(true);
         else
             ISetTransparentDrawOrder(false);
@@ -2704,7 +2701,7 @@ void plArmatureMod::DumpToDebugDisplay(int &x, int &y, int lineHeight, char *str
         plKey world = nil;
         if (fController)
             world = fController->GetSubworld();
-        sprintf(strBuf, "In world: %s  Frozen: %s", world ? world->GetName() : "nil", frozen);
+        sprintf(strBuf, "In world: %s  Frozen: %s", world ? world->GetName().c_str() : "nil", frozen);
         debugTxt.DrawString(x,y, strBuf);
         y+= lineHeight;
 
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAvatarClothing.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plAvatarClothing.cpp
index 6689bdc7..1435a233 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAvatarClothing.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAvatarClothing.cpp
@@ -276,13 +276,12 @@ void plClothingItem::Write(hsStream *s, hsResMgr *mgr)
     plKey accessoryKey = nil;
     if (fAccessoryName)
     {
-        char strBuf[512];
-        sprintf(strBuf, "CItm_%s", fAccessoryName);
+        plString strBuf = plString::Format("CItm_%s", fAccessoryName);
         accessoryKey = plKeyFinder::Instance().StupidSearch("GlobalClothing", nil, plClothingItem::Index(), strBuf);
         if (accessoryKey == nil)
         {
-            sprintf(strBuf, "Couldn't find accessory \"%s\". It won't show at runtime.", fAccessoryName);
-            hsMessageBox(strBuf, GetKeyName(), hsMessageBoxNormal);
+            strBuf = plString::Format("Couldn't find accessory \"%s\". It won't show at runtime.", fAccessoryName);
+            hsMessageBox(strBuf.c_str(), GetKeyName().c_str(), hsMessageBoxNormal);
         }
     }
     mgr->WriteKey(s, accessoryKey);
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAvatarMgr.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plAvatarMgr.cpp
index 6c0f168b..3c3655b1 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAvatarMgr.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAvatarMgr.cpp
@@ -134,10 +134,6 @@ void plAvatarMgr::IReset()
 {
     fSeekPoints.clear();
 
-    // Oneshots have copies of strings in their maps. I'm assuming the others should be the same, but until
-    // I hear otherwise...
-    for( plOneShotMap::iterator it = fOneShots.begin(); it != fOneShots.end(); it++ )
-        delete [] (char *)it->first;
     fOneShots.clear();
     fAvatars.clear();
     fSpawnPoints.clear();
@@ -203,9 +199,9 @@ plKey plAvatarMgr::LoadAvatar(const char *name, const char *accountName, bool is
         const plLocation& loc = (globalLoc.IsValid() ? globalLoc : custLoc.IsValid() ? custLoc : maleLoc);
 #endif
 
-        const char* theName = name;
+        plString theName = _TEMP_CONVERT_FROM_LITERAL(name);
         if ( loc == maleLoc )
-            theName = "Male";
+            theName = _TEMP_CONVERT_FROM_LITERAL("Male");
 
         if (loc.IsValid())
         {
@@ -561,15 +557,14 @@ void plAvatarMgr::AddSeekPoint(plSeekPointMod *seekPoint)
 {
     if(seekPoint)
     {
-        const char *name = seekPoint->GetTarget(0)->GetKey()->GetName();
-        char *ourName = hsStrcpy(name);
+        plString name = seekPoint->GetTarget(0)->GetKey()->GetName();
         plSeekPointMod *alreadyThere = FindSeekPoint(name);
-        
+
         /// hsAssert( ! alreadyThere, "Tried to add a seek point with duplicate name. Ignoring second seek point.");
 
         if ( ! alreadyThere)
         {
-            fSeekPoints[ourName] = seekPoint;
+            fSeekPoints[name] = seekPoint;
         }
     }
 }
@@ -579,21 +574,19 @@ void plAvatarMgr::RemoveSeekPoint(plSeekPointMod *seekPoint)
 {
     if(seekPoint)
     {
-        const char *name = seekPoint->GetTarget(0)->GetKey()->GetName();
+        plString name = seekPoint->GetTarget(0)->GetKey()->GetName();
 
         plSeekPointMap::iterator found = fSeekPoints.find(name);
 
         if(found != fSeekPoints.end())
         {
-            const char *oldName = (*found).first;
             fSeekPoints.erase(found);
-            delete[] const_cast<char *>(oldName);   // retarded language, this is...
         }
     }
 }
 
 // FINDSEEKPOINT
-plSeekPointMod * plAvatarMgr::FindSeekPoint(const char *name)
+plSeekPointMod * plAvatarMgr::FindSeekPoint(const plString &name)
 {
     plSeekPointMap::iterator found = fSeekPoints.find(name);
     
@@ -610,8 +603,7 @@ void plAvatarMgr::AddOneShot(plOneShotMod *oneshot)
 {
     if(oneshot)
     {
-        // allocate a copy of the target name to use as a key
-        char * name = hsStrcpy(oneshot->GetTarget(0)->GetKey()->GetName());
+        plString name = oneshot->GetTarget(0)->GetKey()->GetName();
         plOneShotMod *alreadyThere = FindOneShot(name);
         
 
@@ -619,8 +611,6 @@ void plAvatarMgr::AddOneShot(plOneShotMod *oneshot)
         {
             fOneShots[name] = oneshot;
         }
-        else
-            delete [] name;
     }
 }
 
@@ -631,14 +621,12 @@ void plAvatarMgr::RemoveOneShot(plOneShotMod *oneshot)
 
     while (i != fOneShots.end())
     {
-        char * name = (*i).first;
+        plString name = (*i).first;
         plOneShotMod *thisOneshot = (*i).second;
 
         if(oneshot == thisOneshot)
         {
             i = fOneShots.erase(i);
-            // destroy our copy of the target name
-            delete[] name;
         } else {
             i++;
         }
@@ -646,7 +634,7 @@ void plAvatarMgr::RemoveOneShot(plOneShotMod *oneshot)
 }
 
 // FINDONESHOT
-plOneShotMod *plAvatarMgr::FindOneShot(char *name)
+plOneShotMod *plAvatarMgr::FindOneShot(const plString &name)
 {
     plOneShotMap::iterator found = fOneShots.find(name);
     
@@ -756,7 +744,7 @@ plArmatureMod *plAvatarMgr::FindAvatarByModelName(char *name)
     for (it = fAvatars.begin(); it != fAvatars.end(); ++it)
     {
         plArmatureMod* armature = plArmatureMod::ConvertNoRef((*it)->ObjectIsLoaded());
-        if (armature && (!strcmp(armature->GetTarget(0)->GetKeyName(), name)))
+        if (armature && (!armature->GetTarget(0)->GetKeyName().Compare(name)))
             return armature;
     }
     
@@ -769,7 +757,7 @@ void plAvatarMgr::FindAllAvatarsByModelName(const char* name, plArmatureModPtrVe
     for (it = fAvatars.begin(); it != fAvatars.end(); ++it)
     {
         plArmatureMod* armature = plArmatureMod::ConvertNoRef((*it)->ObjectIsLoaded());
-        if (armature && (!strcmp(armature->GetTarget(0)->GetKeyName(), name)))
+        if (armature && (!armature->GetTarget(0)->GetKeyName().Compare(name)))
             outVec.push_back(armature);
     }
 }
@@ -807,8 +795,8 @@ int plAvatarMgr::FindSpawnPoint( const char *name ) const
     for( i = 0; i < fSpawnPoints.size(); i++ )
     {
         if( fSpawnPoints[ i ] != nil && 
-            (strstr( fSpawnPoints[ i ]->GetKey()->GetUoid().GetObjectName(), name ) != nil ||
-             strstr( fSpawnPoints[i]->GetTarget(0)->GetKeyName(), name) != nil))
+            ( fSpawnPoints[ i ]->GetKey()->GetUoid().GetObjectName().Find( name ) >= 0 ||
+              fSpawnPoints[ i ]->GetTarget(0)->GetKeyName().Find( name ) >= 0 ))
             return i;
     }
 
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAvatarMgr.h b/Sources/Plasma/PubUtilLib/plAvatar/plAvatarMgr.h
index 26fa62f1..8d2cb8a7 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAvatarMgr.h
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAvatarMgr.h
@@ -101,7 +101,7 @@ public:
         do away with this bookeeping entirely. */
     void AddSeekPoint(plSeekPointMod *seekpoint);
     void RemoveSeekPoint(plSeekPointMod *seekpoint);
-    plSeekPointMod *FindSeekPoint(const char *name);
+    plSeekPointMod *FindSeekPoint(const plString &name);
     // \}
 
     // \{
@@ -109,7 +109,7 @@ public:
         scripting only. */
     void AddOneShot(plOneShotMod *oneshot);
     void RemoveOneShot(plOneShotMod *oneshot);
-    plOneShotMod *FindOneShot(char *name);
+    plOneShotMod *FindOneShot(const plString &name);
     // \}
     
     plKey LoadPlayer(const char* name, const char *account);
@@ -200,10 +200,10 @@ protected:
 
     static plAvatarMgr* fInstance;      // the single instance of the avatar manager
 
-    typedef std::map<const char *, plSeekPointMod *, stringISorter> plSeekPointMap;
+    typedef std::map<plString, plSeekPointMod *, plString::less_i> plSeekPointMap;
     plSeekPointMap fSeekPoints;
 
-    typedef std::map<char *, plOneShotMod *, stringISorter> plOneShotMap;
+    typedef std::map<plString, plOneShotMod *, plString::less_i> plOneShotMap;
     plOneShotMap fOneShots;
 
     typedef std::map<plKey, plMessage *> DeferredInits;
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plCoopCoordinator.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plCoopCoordinator.cpp
index 45119c8c..f737ba04 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plCoopCoordinator.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plCoopCoordinator.cpp
@@ -111,22 +111,14 @@ plCoopCoordinator::plCoopCoordinator(plKey host, plKey guest,
   fGuestAccepted(false),
   fGuestLinked(false)
 {
-    const char * hostName = host->GetName();
-    const char * guestName = guest->GetName();
     static int serial = 0;
 
-    int len = strlen(hostName) + strlen(guestName) + 3 /* serial num */ + 1;
-
-    char *newName = TRACKED_NEW char[len];
-
     serial = serial % 999;
 
-    sprintf(newName, "%s%s%3i\x000", hostName, guestName, serial++);
+    plString newName = plString::Format("%s%s%3i\x000", host->GetName().c_str(), guest->GetName().c_str(), serial++);
     
     plKey newKey = hsgResMgr::ResMgr()->NewKey(newName, this, host->GetUoid().GetLocation());
 
-    delete[] newName;
-
     fSynchBone = hsStrcpy(synchBone);
 
     plKey avMgrKey = plAvatarMgr::GetInstance()->GetKey();
diff --git a/Sources/Plasma/PubUtilLib/plDrawable/plDrawableGenerator.cpp b/Sources/Plasma/PubUtilLib/plDrawable/plDrawableGenerator.cpp
index 4a8465ee..fb170bc2 100644
--- a/Sources/Plasma/PubUtilLib/plDrawable/plDrawableGenerator.cpp
+++ b/Sources/Plasma/PubUtilLib/plDrawable/plDrawableGenerator.cpp
@@ -259,8 +259,7 @@ plDrawableSpans *plDrawableGenerator::GenerateDrawable( UInt32 vertCount, hsPoin
         }
 
         static int nameIdx = 0;
-        char buff[256];
-        sprintf(buff, "%s_%d", "GenDrawable", nameIdx++);
+        plString buff = plString::Format( "GenDrawable_%d", nameIdx++ );
         hsgResMgr::ResMgr()->NewKey( buff, newDraw, plLocation::kGlobalFixedLoc );
     }
 
diff --git a/Sources/Plasma/PubUtilLib/plDrawable/plDrawableSpans.cpp b/Sources/Plasma/PubUtilLib/plDrawable/plDrawableSpans.cpp
index adb532b6..60ce5b17 100644
--- a/Sources/Plasma/PubUtilLib/plDrawable/plDrawableSpans.cpp
+++ b/Sources/Plasma/PubUtilLib/plDrawable/plDrawableSpans.cpp
@@ -1320,7 +1320,7 @@ hsBool plDrawableSpans::MsgReceive( plMessage* msg )
     }
     else if( plRenderMsg::ConvertNoRef( msg ) )
     {
-        plProfile_BeginLap(PalletteHack, this->GetKey()->GetUoid().GetObjectName());
+        plProfile_BeginLap(PalletteHack, this->GetKey()->GetUoid().GetObjectName().c_str());
     
         IUpdateMatrixPaletteBoundsHack();
 
@@ -1331,7 +1331,7 @@ hsBool plDrawableSpans::MsgReceive( plMessage* msg )
         // The pipeline will then clear out those bits as it blends them, and then we simply
         // re-set them here, since plRenderMsg is sent once before all the rendering is done :)
         fFakeBlendingSpanVector = fBlendingSpanVector;
-        plProfile_EndLap(PalletteHack, this->GetKey()->GetUoid().GetObjectName());
+        plProfile_EndLap(PalletteHack, this->GetKey()->GetUoid().GetObjectName().c_str());
     
         return true;
     }
diff --git a/Sources/Plasma/PubUtilLib/plDrawable/plDrawableSpansExport.cpp b/Sources/Plasma/PubUtilLib/plDrawable/plDrawableSpansExport.cpp
index 444233df..bd5866e5 100644
--- a/Sources/Plasma/PubUtilLib/plDrawable/plDrawableSpansExport.cpp
+++ b/Sources/Plasma/PubUtilLib/plDrawable/plDrawableSpansExport.cpp
@@ -387,7 +387,7 @@ static void ILogSpan(plStatusLog* statusLog, plGeometrySpan* geo, plVertexSpan*
 
             statusLog->AddLineF("From obj <%s> mat <%s> size %d bytes grp=%d (%d offset)",
                 geo->fMaxOwner ? geo->fMaxOwner : "<unknown>",
-                geo->fMaterial ? geo->fMaterial->GetKey()->GetName() : "<unknown>",
+                geo->fMaterial ? geo->fMaterial->GetKey()->GetName().c_str() : "<unknown>",
                 geo->GetVertexSize(geo->fFormat) * geo->fNumVerts + sizeof(UInt16) * geo->fNumIndices,
                 span->fGroupIdx,
                 ptr
@@ -405,7 +405,7 @@ static void ILogSpan(plStatusLog* statusLog, plGeometrySpan* geo, plVertexSpan*
         {
             statusLog->AddLineF("Instanced obj <%s> mat <%s> grp=%d (%d/%d/%d/%d/%d/%d/%d/%d)",
                 geo->fMaxOwner ? geo->fMaxOwner : "<unknown>",
-                geo->fMaterial ? geo->fMaterial->GetKey()->GetName() : "<unknown>",
+                geo->fMaterial ? geo->fMaterial->GetKey()->GetName().c_str() : "<unknown>",
                 span->fGroupIdx,
                 span->fVBufferIdx,
                 span->fCellIdx,
@@ -424,7 +424,7 @@ static void ILogSpan(plStatusLog* statusLog, plGeometrySpan* geo, plVertexSpan*
         {
             statusLog->AddLineF("From obj <%s> mat <%s> size %d bytes grp=%d (%d/%d/%d/%d/%d)",
                 geo->fMaxOwner ? geo->fMaxOwner : "<unknown>",
-                geo->fMaterial ? geo->fMaterial->GetKey()->GetName() : "<unknown>",
+                geo->fMaterial ? geo->fMaterial->GetKey()->GetName().c_str() : "<unknown>",
                 geo->GetVertexSize(geo->fFormat) * geo->fNumVerts + sizeof(UInt16) * geo->fNumIndices,
                 span->fGroupIdx,
                 span->fVBufferIdx,
@@ -438,7 +438,7 @@ static void ILogSpan(plStatusLog* statusLog, plGeometrySpan* geo, plVertexSpan*
         {
             statusLog->AddLineF("Instanced obj <%s> mat <%s> grp=%d (%d/%d/%d/%d/%d)",
                 geo->fMaxOwner ? geo->fMaxOwner : "<unknown>",
-                geo->fMaterial ? geo->fMaterial->GetKey()->GetName() : "<unknown>",
+                geo->fMaterial ? geo->fMaterial->GetKey()->GetName().c_str() : "<unknown>",
                 span->fGroupIdx,
                 span->fVBufferIdx,
                 span->fCellIdx,
@@ -755,18 +755,18 @@ short   plDrawableSpans::ICompareSpans( plGeometrySpan *span1, plGeometrySpan *s
         else if( t1 == nil && t2 == nil )
             break;  // Textures equal up to here--keep going with rest of tests
         
-        if( t1->GetKeyName() != nil && t2->GetKeyName() != nil )
+        if( !t1->GetKeyName().IsNull() && !t2->GetKeyName().IsNull() )
         {
-            j = stricmp( t1->GetKeyName(), t2->GetKeyName() );
+            j = t1->GetKeyName().Compare( t2->GetKeyName(), plString::kCaseInsensitive );
             if( j != 0 )
                 return (short)j;
         }
     }
 
     // Finally, by material itself.
-    if( span1->fMaterial->GetKeyName() != nil && span2->fMaterial->GetKeyName() != nil )
+    if( !span1->fMaterial->GetKeyName().IsNull() && !span2->fMaterial->GetKeyName().IsNull() )
     {
-        j = stricmp( span1->fMaterial->GetKeyName(), span2->fMaterial->GetKeyName() );
+        j = span1->fMaterial->GetKeyName().Compare( span2->fMaterial->GetKeyName(), plString::kCaseInsensitive );
         if( j != 0 )
             return (short)j;
     }
diff --git a/Sources/Plasma/PubUtilLib/plDrawable/plDynaDecalMgr.cpp b/Sources/Plasma/PubUtilLib/plDrawable/plDynaDecalMgr.cpp
index 69f00005..c26edde4 100644
--- a/Sources/Plasma/PubUtilLib/plDrawable/plDynaDecalMgr.cpp
+++ b/Sources/Plasma/PubUtilLib/plDrawable/plDynaDecalMgr.cpp
@@ -1578,21 +1578,20 @@ hsGMaterial* plDynaDecalMgr::IConvertToEnvMap(hsGMaterial* mat, plBitmap* envMap
     oldMip->SetCurrLevel(0);
 
     hsGMaterial* newMat = TRACKED_NEW hsGMaterial;
-    char buff[256];
-    sprintf(buff, "%s_%s", GetKey()->GetName(), "EnvMat");
+    plString buff = plString::Format("%s_EnvMat", GetKey()->GetName().c_str());
     hsgResMgr::ResMgr()->NewKey(buff, newMat, GetKey()->GetUoid().GetLocation());
 
     static plTweak<hsScalar> kSmooth(1.f);
     plMipmap* bumpMap = plBumpMapGen::QikNormalMap(nil, oldMip, 0xffffffff, plBumpMapGen::kBubbleTest, kSmooth);
 //  plMipmap* bumpMap = plBumpMapGen::QikNormalMap(nil, oldMip, 0xffffffff, plBumpMapGen::kNormalize, kSmooth);
 //  plMipmap* bumpMap = plBumpMapGen::QikNormalMap(nil, oldMip, 0xffffffff, 0, 0);
-    sprintf(buff, "%s_%s", GetKey()->GetName(), "BumpMap");
+    buff = plString::Format("%s_BumpMap", GetKey()->GetName().c_str());
     hsgResMgr::ResMgr()->NewKey(buff, bumpMap, GetKey()->GetUoid().GetLocation());
 
     bumpMap->SetFlags(bumpMap->GetFlags() | plMipmap::kBumpEnvMap | plMipmap::kForceNonCompressed);
 
     plLayer* bumpLay = TRACKED_NEW plLayer;
-    sprintf(buff, "%s_%s_%d", GetKey()->GetName(), "BumpMap", 0);
+    buff = plString::Format("%s_BumpMap_0", GetKey()->GetName().c_str());
     hsgResMgr::ResMgr()->NewKey(buff, bumpLay, GetKey()->GetUoid().GetLocation());
 
     bumpLay->SetState(oldLay->GetState());
@@ -1614,7 +1613,7 @@ hsGMaterial* plDynaDecalMgr::IConvertToEnvMap(hsGMaterial* mat, plBitmap* envMap
     newMat->AddLayerViaNotify(bumpLay);
 
     plLayer* envLay = TRACKED_NEW plLayer;
-    sprintf(buff, "%s_%s_%d", GetKey()->GetName(), "EnvMap", 0);
+    buff = plString::Format("%s_EnvMap_0", GetKey()->GetName().c_str());
     hsgResMgr::ResMgr()->NewKey(buff, envLay, GetKey()->GetUoid().GetLocation());
 
     envLay->SetBlendFlags(hsGMatState::kBlendMult);
diff --git a/Sources/Plasma/PubUtilLib/plDrawable/plProxyGen.cpp b/Sources/Plasma/PubUtilLib/plDrawable/plProxyGen.cpp
index 7ee07026..09ba523d 100644
--- a/Sources/Plasma/PubUtilLib/plDrawable/plProxyGen.cpp
+++ b/Sources/Plasma/PubUtilLib/plDrawable/plProxyGen.cpp
@@ -80,16 +80,16 @@ void plProxyGen::Init(const hsKeyedObject* owner)
 {
     if( !GetKey() )
     {
-        char buff[256];
+        plString buff;
         plLocation loc;
         if( owner->GetKey() )
         {
-            sprintf(buff, "%s_%s_%d_%d", owner->GetKey()->GetName(), "ProxyGen", owner->GetKey()->GetUoid().GetClonePlayerID(), fProxyKeyCounter++);
+            buff = plString::Format("%s_ProxyGen_%d_%d", owner->GetKey()->GetName().c_str(), owner->GetKey()->GetUoid().GetClonePlayerID(), fProxyKeyCounter++);
             loc = owner->GetKey()->GetUoid().GetLocation();
         }
         else
         {
-            sprintf( buff, "ProxyGen%d", fProxyKeyCounter++ );
+            buff = plString::Format( "ProxyGen%d", fProxyKeyCounter++ );
             loc = plLocation::kGlobalFixedLoc;
         }
 
@@ -157,11 +157,11 @@ hsGMaterial* plProxyGen::IMakeProxyMaterial() const
 
     hsGMaterial* retVal = TRACKED_NEW hsGMaterial();
 
-    char buff[256];
-    if( GetKey()->GetName() )
-        sprintf(buff, "%s_%s", GetKey()->GetName(), "Material");
+    plString buff;
+    if( !GetKey()->GetName().IsNull() )
+        buff = plString::Format("%s_Material", GetKey()->GetName().c_str());
     else
-        strcpy(buff, "ProxyMaterial");
+        buff = _TEMP_CONVERT_FROM_LITERAL("ProxyMaterial");
     hsgResMgr::ResMgr()->NewKey( buff, retVal, GetKey() ? GetKey()->GetUoid().GetLocation() : plLocation::kGlobalFixedLoc );
 
     plLayer *lay = retVal->MakeBaseLayer();
@@ -232,11 +232,11 @@ void plProxyGen::IGenerateProxy()
 
     if( fProxyDrawables[idx] && !fProxyDrawables[idx]->GetKey() )
     {
-        char buff[256];
-        if( GetKey()->GetName() )
-            sprintf(buff, "%s_%s", GetKey()->GetName(), "ProxyDrawable");
+        plString buff;
+        if( !GetKey()->GetName().IsNull() )
+            buff = plString::Format("%s_ProxyDrawable", GetKey()->GetName().c_str());
         else
-            strcpy(buff, "ProxyDrawable");
+            buff = _TEMP_CONVERT_FROM_LITERAL("ProxyDrawable");
 
         hsgResMgr::ResMgr()->NewKey( buff, fProxyDrawables[ idx ], GetKey() ? GetKey()->GetUoid().GetLocation() : plLocation::kGlobalFixedLoc );
     }
diff --git a/Sources/Plasma/PubUtilLib/plDrawable/plWaveSet7.cpp b/Sources/Plasma/PubUtilLib/plDrawable/plWaveSet7.cpp
index 895f4767..3928916b 100644
--- a/Sources/Plasma/PubUtilLib/plDrawable/plWaveSet7.cpp
+++ b/Sources/Plasma/PubUtilLib/plDrawable/plWaveSet7.cpp
@@ -1617,8 +1617,7 @@ plMipmap* plWaveSet7::ICreateBiasNoiseMap()
         plMipmap::kUncompressed,
         plMipmap::UncompressedInfo::kRGB8888);
 
-    char buff[256];
-    sprintf(buff, "%s_%s", GetKey()->GetName(), "BiasBitPS");
+    plString buff = plString::Format("%s_BiasBitPS", GetKey()->GetName().c_str());
     hsgResMgr::ResMgr()->NewKey(buff, mipMap, GetKey()->GetUoid().GetLocation());
 
     int i;
@@ -1663,8 +1662,7 @@ plMipmap* plWaveSet7::ICreateBumpMipmapPS()
         plMipmap::kUncompressed,
         plMipmap::UncompressedInfo::kRGB8888);
 
-        char buff[256];
-        sprintf(buff, "%s_%s", GetKey()->GetName(), "BumpBitPS");
+        plString buff = plString::Format("%s_BumpBitPS", GetKey()->GetName().c_str());
         hsgResMgr::ResMgr()->NewKey(buff, mipMap, GetKey()->GetUoid().GetLocation());
 
         hsgResMgr::ResMgr()->SendRef(mipMap->GetKey(), TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnRequest, 0, kRefCosineLUT), plRefFlags::kActiveRef);
@@ -1716,8 +1714,7 @@ void plWaveSet7::IAddBumpBiasLayer(hsGMaterial* mat)
         for( i = 0; i < 2; i++ )
         {
             plLayer* layer = TRACKED_NEW plLayer;
-            char buff[256];
-            sprintf(buff, "%s_%s_%d", GetKey()->GetName(), "Bias", i);
+            plString buff = plString::Format("%s_Bias_%d", GetKey()->GetName().c_str(), i);
             hsgResMgr::ResMgr()->NewKey(buff, layer, GetKey()->GetUoid().GetLocation());
 
             layer->SetBlendFlags(hsGMatState::kBlendAdd);
@@ -1752,8 +1749,7 @@ void plWaveSet7::IAddBumpBiasLayer(hsGMaterial* mat)
 plLayer* plWaveSet7::ICreateBumpLayerPS(plMipmap* mipMap, hsGMaterial* bumpMat, int which)
 {
     plLayer* layer = TRACKED_NEW plLayer;
-    char buff[256];
-    sprintf(buff, "%s_%s_%d", GetKey()->GetName(), "BumpLayerPS", which);
+    plString buff = plString::Format("%s_BumpLayerPS_%d", GetKey()->GetName().c_str(), which);
     hsgResMgr::ResMgr()->NewKey(buff, layer, GetKey()->GetUoid().GetLocation());
 
     layer->SetBlendFlags(which ? hsGMatState::kBlendAdd : 0);
@@ -1810,8 +1806,7 @@ hsGMaterial* plWaveSet7::ICreateBumpLayersPS()
 
     // Create a blank material
     hsGMaterial* bumpMat = TRACKED_NEW hsGMaterial;
-    char buff[256];
-    sprintf(buff, "%s_%s", GetKey()->GetName(), "BumpMatPS");
+    plString buff = plString::Format("%s_BumpMatPS", GetKey()->GetName());
     hsgResMgr::ResMgr()->NewKey(buff, bumpMat, GetKey()->GetUoid().GetLocation());
 
     plMipmap* mipMap = ICreateBumpMipmapPS();
@@ -1852,8 +1847,7 @@ void plWaveSet7::IAddBumpBiasShaders(plLayer* layer)
     {
         plShader* vShader = TRACKED_NEW plShader;
 
-        char buff[256];
-        sprintf(buff, "%s_BiasVS", GetKey()->GetName());
+        plString buff = plString::Format("%s_BiasVS", GetKey()->GetName().c_str());
         hsgResMgr::ResMgr()->NewKey(buff, vShader, GetKey()->GetUoid().GetLocation());
         vShader->SetIsPixelShader(false);
         
@@ -1916,8 +1910,7 @@ void plWaveSet7::IAddBumpBiasShaders(plLayer* layer)
     {
         plShader* pShader = TRACKED_NEW plShader;
 
-        char buff[256];
-        sprintf(buff, "%s_BiasPS", GetKey()->GetName());
+        plString buff = plString::Format("%s_BiasPS", GetKey()->GetName().c_str());
         hsgResMgr::ResMgr()->NewKey(buff, pShader, GetKey()->GetUoid().GetLocation());
         pShader->SetIsPixelShader(true);
         
@@ -1950,8 +1943,7 @@ void plWaveSet7::IAddBumpVertexShader(hsGMaterial* mat, int iShader, int iFirst,
             int iShader = iBase / kBumpPerPass;
 
             plShader* vShader = TRACKED_NEW plShader;
-            char buff[256];
-            sprintf(buff, "%s_BumpVS_%d", GetKey()->GetName(), iShader);
+            plString buff = plString::Format("%s_BumpVS_%d", GetKey()->GetName().c_str(), iShader);
             hsgResMgr::ResMgr()->NewKey(buff, vShader, GetKey()->GetUoid().GetLocation());
             vShader->SetIsPixelShader(false);
             
@@ -1996,8 +1988,7 @@ void plWaveSet7::IAddBumpPixelShader(hsGMaterial* mat, int iShader, int iFirst,
             int iShader = iBase / kBumpPerPass;
 
             plShader* pShader = TRACKED_NEW plShader;
-            char buff[256];
-            sprintf(buff, "%s_BumpPS_%d", GetKey()->GetName(), iShader);
+            plString buff = plString::Format("%s_BumpPS_%d", GetKey()->GetName().c_str(), iShader);
             hsgResMgr::ResMgr()->NewKey(buff, pShader, GetKey()->GetUoid().GetLocation());
             pShader->SetIsPixelShader(true);
             
@@ -2039,8 +2030,7 @@ void plWaveSet7::IAddBumpPixelShader(hsGMaterial* mat, int iShader, int iFirst,
 plDrawableSpans* plWaveSet7::ICreateBumpDrawable()
 {
     fBumpDraw = TRACKED_NEW plDrawableSpans;
-    char buff[256];
-    sprintf(buff, "%s_BumpDraw", GetKey()->GetName());
+    plString buff = plString::Format("%s_BumpDraw", GetKey()->GetName().c_str());
     hsgResMgr::ResMgr()->NewKey(buff, fBumpDraw, GetKey()->GetUoid().GetLocation());
 
     ICreateClearDrawable(fBumpDraw, fBumpMat);
@@ -2155,8 +2145,7 @@ plRenderTarget* plWaveSet7::ICreateTransferRenderTarget(const char* name, int si
     
     plRenderTarget* rt = TRACKED_NEW plRenderTarget(flags, size, size, bitDepth, zDepth, stencilDepth);
 
-    char buff[256];
-    sprintf(buff, "%s_%s", GetKey()->GetName(), name);
+    plString buff = plString::Format("%s_%s", GetKey()->GetName().c_str(), name);
     hsgResMgr::ResMgr()->NewKey(buff, rt, GetKey()->GetUoid().GetLocation());
 
     return rt;
@@ -2168,8 +2157,7 @@ plLayer* plWaveSet7::ICreateTotalLayer(plBitmap* bm, hsGMaterial* mat, int which
     if( !layer )
     {
         layer = TRACKED_NEW plLayer;
-        char buff[256];
-        sprintf(buff, "%s_%sLayerPS_%d", GetKey()->GetName(), suff, which);
+        plString buff = plString::Format("%s_%sLayerPS_%d", GetKey()->GetName().c_str(), suff, which);
         hsgResMgr::ResMgr()->NewKey(buff, layer, GetKey()->GetUoid().GetLocation());
 
         layer->SetAmbientColor(hsColorRGBA().Set(0.f, 0.f, 0.f, 1.f));
@@ -2203,8 +2191,7 @@ plLayer* plWaveSet7::ICreateTotalLayer(plBitmap* bm, hsGMaterial* mat, int which
 plLayer* plWaveSet7::ICreateTotalEnvLayer(plBitmap* envMap, hsGMaterial* mat, int which, const char* pref)
 {
     plLayer* layer = TRACKED_NEW plLayer;
-    char buff[256];
-    sprintf(buff, "%s_%s_%s_%d", GetKey()->GetName(), pref, "EnvLayerPS", which);
+    plString buff = plString::Format("%s_%s_EnvLayerPS_%d", GetKey()->GetName().c_str(), pref, which);
     hsgResMgr::ResMgr()->NewKey(buff, layer, GetKey()->GetUoid().GetLocation());
 
     layer->SetBlendFlags(which ? hsGMatState::kBlendAddSigned : 0);
@@ -2304,8 +2291,7 @@ void plWaveSet7::IAddShoreVertexShader(hsGMaterial* mat)
 
         plShader* vShader = TRACKED_NEW plShader;
 
-        char buff[256];
-        sprintf(buff, "%s_ShoreVS", GetKey()->GetName());
+        plString buff = plString::Format("%s_ShoreVS", GetKey()->GetName().c_str());
         hsgResMgr::ResMgr()->NewKey(buff, vShader, GetKey()->GetUoid().GetLocation());
         vShader->SetIsPixelShader(false);
         
@@ -2358,8 +2344,7 @@ void plWaveSet7::IAddShorePixelShader(hsGMaterial* mat)
     {
         plShader* pShader = TRACKED_NEW plShader;
 
-        char buff[256];
-        sprintf(buff, "%s_ShorePS", GetKey()->GetName());
+        plString buff = plString::Format("%s_ShorePS", GetKey()->GetName().c_str());
         hsgResMgr::ResMgr()->NewKey(buff, pShader, GetKey()->GetUoid().GetLocation());
         pShader->SetIsPixelShader(true);
 
@@ -2382,8 +2367,7 @@ void plWaveSet7::IAddFixedVertexShader(hsGMaterial* mat, const int numUVWs)
 
         plShader* vShader = TRACKED_NEW plShader;
 
-        char buff[256];
-        sprintf(buff, "%s_FixedVS", GetKey()->GetName());
+        plString buff = plString::Format("%s_FixedVS", GetKey()->GetName().c_str());
         hsgResMgr::ResMgr()->NewKey(buff, vShader, GetKey()->GetUoid().GetLocation());
         vShader->SetIsPixelShader(false);
         
@@ -2452,8 +2436,7 @@ void plWaveSet7::IAddFixedPixelShader(hsGMaterial* mat)
     if( !fFixedPShader )
     {
         plShader* pShader = TRACKED_NEW plShader;
-        char buff[256];
-        sprintf(buff, "%s_FixedPS", GetKey()->GetName());
+        plString buff = plString::Format("%s_FixedPS", GetKey()->GetName().c_str());
         hsgResMgr::ResMgr()->NewKey(buff, pShader, GetKey()->GetUoid().GetLocation());
         pShader->SetIsPixelShader(true);
         
@@ -2481,8 +2464,7 @@ void plWaveSet7::IAddRipVertexShader(hsGMaterial* mat, const plRipVSConsts& ripC
     if( !fRipVShader )
     {
         plShader* vShader = TRACKED_NEW plShader;
-        char buff[256];
-        sprintf(buff, "%s_RipVS", GetKey()->GetName());
+        plString buff = plString::Format("%s_RipVS", GetKey()->GetName().c_str());
         hsgResMgr::ResMgr()->NewKey(buff, vShader, GetKey()->GetUoid().GetLocation());
         vShader->SetIsPixelShader(false);
         
@@ -2567,8 +2549,7 @@ void plWaveSet7::IAddRipPixelShader(hsGMaterial* mat, const plRipVSConsts& ripCo
     if( !fRipPShader )
     {
         plShader* pShader = TRACKED_NEW plShader;
-        char buff[256];
-        sprintf(buff, "%s_RipPS", GetKey()->GetName());
+        plString buff = plString::Format("%s_RipPS", GetKey()->GetName().c_str());
         hsgResMgr::ResMgr()->NewKey(buff, pShader, GetKey()->GetUoid().GetLocation());
         pShader->SetIsPixelShader(true);
         
@@ -2627,8 +2608,7 @@ plShader* plWaveSet7::ICreateDecalVShader(DecalVType t)
 
 
         plShader* vShader = TRACKED_NEW plShader;
-        char buff[256];
-        sprintf(buff, "%s_%s", GetKey()->GetName(), fname[t]);
+        plString buff = plString::Format("%s_%s", GetKey()->GetName().c_str(), fname[t]);
         hsgResMgr::ResMgr()->NewKey(buff, vShader, GetKey()->GetUoid().GetLocation());
         vShader->SetIsPixelShader(false);
         
@@ -2756,8 +2736,7 @@ plShader* plWaveSet7::ICreateDecalPShader(DecalPType t)
 
         plShader* pShader = TRACKED_NEW plShader;
 
-        char buff[256];
-        sprintf(buff, "%s_%s", GetKey()->GetName(), fname[t]);
+        plString buff = plString::Format("%s_%s", GetKey()->GetName().c_str(), fname[t]);
         hsgResMgr::ResMgr()->NewKey(buff, pShader, GetKey()->GetUoid().GetLocation());
         pShader->SetIsPixelShader(true);
 
@@ -3698,8 +3677,7 @@ plDrawableSpans* plWaveSet7::ICreateGraphDrawable(plDrawableSpans* drawable, hsG
 plDrawableSpans* plWaveSet7::ICreateEmptyGraphDrawable(const char* name, UInt32 ref, int which)
 {
     plDrawableSpans* drawable = TRACKED_NEW plDrawableSpans;
-    char buff[256];
-    sprintf(buff, "%s_%s_%d", GetKey()->GetName(), name, which);
+    plString buff = plString::Format("%s_%s_%d", GetKey()->GetName().c_str(), name, which);
     hsgResMgr::ResMgr()->NewKey(buff, drawable, GetKey()->GetUoid().GetLocation());
 
     hsgResMgr::ResMgr()->SendRef(drawable->GetKey(), TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnRequest, which, (Int8)ref), plRefFlags::kActiveRef);
@@ -3711,8 +3689,7 @@ hsGMaterial* plWaveSet7::ICreateEmptyMaterial(const char* name, UInt32 ref, int
 {
     hsGMaterial* mat = TRACKED_NEW hsGMaterial;
 
-    char buff[256];
-    sprintf(buff, "%s_%s_%d", GetKey()->GetName(), name, which);
+    plString buff = plString::Format("%s_%s_%d", GetKey()->GetName().c_str(), name, which);
     hsgResMgr::ResMgr()->NewKey(buff, mat, GetKey()->GetUoid().GetLocation());
 
     hsgResMgr::ResMgr()->SendRef(mat->GetKey(), TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnRequest, which, (Int8)ref), plRefFlags::kActiveRef);
@@ -3723,8 +3700,7 @@ hsGMaterial* plWaveSet7::ICreateEmptyMaterial(const char* name, UInt32 ref, int
 plLayer* plWaveSet7::ICreateBlankLayer(const char* name, int suff)
 {
     plLayer* lay = TRACKED_NEW plLayer;
-    char buff[256];
-    sprintf(buff, "%s_%s_%d", GetKey()->GetName(), name, suff);
+    plString buff = plString::Format("%s_%s_%d", GetKey()->GetName().c_str(), name, suff);
     hsgResMgr::ResMgr()->NewKey(buff, lay, GetKey()->GetUoid().GetLocation());
 
     return lay;
@@ -3739,8 +3715,7 @@ plMipmap* plWaveSet7::ICreateBlankTex(const char* name, int width, int height, U
         plMipmap::kUncompressed,
         plMipmap::UncompressedInfo::kRGB8888);
 
-    char buff[256];
-    sprintf(buff, "%s_%s", GetKey()->GetName(), name);
+    plString buff = plString::Format("%s_%s", GetKey()->GetName().c_str(), name);
     hsgResMgr::ResMgr()->NewKey(buff, mipMap, GetKey()->GetUoid().GetLocation());
 
     hsgResMgr::ResMgr()->SendRef(mipMap->GetKey(), TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnRequest, 0, (Int8)ref), plRefFlags::kActiveRef);
@@ -4146,8 +4121,7 @@ void plWaveSet7::IAddGraphVShader(hsGMaterial* mat, int iPass)
     if( !fGraphVShader[iPass] )
     {
         plShader* vShader = TRACKED_NEW plShader;
-        char buff[256];
-        sprintf(buff, "%s_GraphVS_%d", GetKey()->GetName(), iPass);
+        plString buff = plString::Format("%s_GraphVS_%d", GetKey()->GetName().c_str(), iPass);
         hsgResMgr::ResMgr()->NewKey(buff, vShader, GetKey()->GetUoid().GetLocation());
         vShader->SetIsPixelShader(false);
 
@@ -4181,8 +4155,7 @@ void plWaveSet7::IAddGraphPShader(hsGMaterial* mat, int iPass)
     if( !fGraphPShader[iPass] )
     {
         plShader* pShader = TRACKED_NEW plShader;
-        char buff[256];
-        sprintf(buff, "%s_GraphPS_%d", GetKey()->GetName(), iPass);
+        plString buff = plString::Format("%s_GraphPS_%d", GetKey()->GetName().c_str(), iPass);
         hsgResMgr::ResMgr()->NewKey(buff, pShader, GetKey()->GetUoid().GetLocation());
         pShader->SetIsPixelShader(true);
         
@@ -4252,11 +4225,11 @@ void plWaveSet7::ISetupGraphShore(hsGMaterial* mat)
 
 void plWaveSet7::IMakeShoreLayer(hsGMaterial* mat, int which)
 {
-    char name[512];
+    plString name;
     if( which >= mat->GetNumLayers() )
     {
         plLayer* lay = TRACKED_NEW plLayer;
-        sprintf(name, "%s_lay_%d", mat->GetKey()->GetName(), which);
+        name = plString::Format("%s_lay_%d", mat->GetKey()->GetName().c_str(), which);
         hsgResMgr::ResMgr()->NewKey(name, lay, GetKey()->GetUoid().GetLocation());
 
         lay->SetAmbientColor(hsColorRGBA().Set(0.f, 0.f, 0.f, 1.f));
diff --git a/Sources/Plasma/PubUtilLib/plGImage/plFontCache.cpp b/Sources/Plasma/PubUtilLib/plGImage/plFontCache.cpp
index f18149e0..4cf08662 100644
--- a/Sources/Plasma/PubUtilLib/plGImage/plFontCache.cpp
+++ b/Sources/Plasma/PubUtilLib/plGImage/plFontCache.cpp
@@ -179,10 +179,10 @@ void    plFontCache::ILoadCustomFonts( void )
             delete font;
         else
         {
-            char keyName[ 512 ];
+            plString keyName;
             if( font->GetKey() == nil )
             {
-                sprintf( keyName, "%s-%d", font->GetFace(), font->GetSize() );
+                keyName = plString::Format( "%s-%d", font->GetFace(), font->GetSize() );
                 hsgResMgr::ResMgr()->NewKey( keyName, font, plLocation::kGlobalFixedLoc );
             }
 
diff --git a/Sources/Plasma/PubUtilLib/plGLight/plLightInfo.cpp b/Sources/Plasma/PubUtilLib/plGLight/plLightInfo.cpp
index e2a3b8ff..03896355 100644
--- a/Sources/Plasma/PubUtilLib/plGLight/plLightInfo.cpp
+++ b/Sources/Plasma/PubUtilLib/plGLight/plLightInfo.cpp
@@ -373,7 +373,7 @@ hsBool plLightInfo::MsgReceive(plMessage* msg)
     plRenderMsg* rendMsg = plRenderMsg::ConvertNoRef(msg);
     if( rendMsg )
     {
-        plProfile_BeginLap(LightInfo, this->GetKey()->GetUoid().GetObjectName());
+        plProfile_BeginLap(LightInfo, this->GetKey()->GetUoid().GetObjectName().c_str());
 
         if( !fDeviceRef && !GetProperty(kLPShadowOnly) )
         {
@@ -382,7 +382,7 @@ hsBool plLightInfo::MsgReceive(plMessage* msg)
 
         ICheckMaxStrength();
 
-        plProfile_EndLap(LightInfo, this->GetKey()->GetUoid().GetObjectName());
+        plProfile_EndLap(LightInfo, this->GetKey()->GetUoid().GetObjectName().c_str());
         return true;
     }
     plGenRefMsg* refMsg = plGenRefMsg::ConvertNoRef(msg);
@@ -395,7 +395,7 @@ hsBool plLightInfo::MsgReceive(plMessage* msg)
             case kProjection:
                 fProjection = plLayerInterface::ConvertNoRef(refMsg->GetRef());
                 {
-                    if( GetKey() && GetKey()->GetName() && !strncmp(GetKey()->GetName(), "RTPatternLight", strlen("RTPatternLight")) )
+                    if( GetKey() && !GetKey()->GetName().CompareN("RTPatternLight", strlen("RTPatternLight")) )
                         SetProperty(kLPForceProj, true);
                 }
                 break;
diff --git a/Sources/Plasma/PubUtilLib/plGLight/plShadowCaster.cpp b/Sources/Plasma/PubUtilLib/plGLight/plShadowCaster.cpp
index 2c89532b..28cc7f5b 100644
--- a/Sources/Plasma/PubUtilLib/plGLight/plShadowCaster.cpp
+++ b/Sources/Plasma/PubUtilLib/plGLight/plShadowCaster.cpp
@@ -214,9 +214,9 @@ hsBool plShadowCaster::MsgReceive(plMessage* msg)
     plRenderMsg* rendMsg = plRenderMsg::ConvertNoRef(msg);
     if( rendMsg )
     {
-        plProfile_BeginLap(ShadowCaster, this->GetKey()->GetUoid().GetObjectName());
+        plProfile_BeginLap(ShadowCaster, this->GetKey()->GetUoid().GetObjectName().c_str());
         IOnRenderMsg(rendMsg);
-        plProfile_EndLap(ShadowCaster, this->GetKey()->GetUoid().GetObjectName());
+        plProfile_EndLap(ShadowCaster, this->GetKey()->GetUoid().GetObjectName().c_str());
         return true;
     }
 
diff --git a/Sources/Plasma/PubUtilLib/plGLight/plShadowMaster.cpp b/Sources/Plasma/PubUtilLib/plGLight/plShadowMaster.cpp
index c6b68fa3..098d9f10 100644
--- a/Sources/Plasma/PubUtilLib/plGLight/plShadowMaster.cpp
+++ b/Sources/Plasma/PubUtilLib/plGLight/plShadowMaster.cpp
@@ -180,9 +180,9 @@ hsBool plShadowMaster::MsgReceive(plMessage* msg)
     plRenderMsg* rendMsg = plRenderMsg::ConvertNoRef(msg);
     if( rendMsg )
     {
-        plProfile_BeginLap(ShadowMaster, this->GetKey()->GetUoid().GetObjectName());
+        plProfile_BeginLap(ShadowMaster, this->GetKey()->GetUoid().GetObjectName().c_str());
         IBeginRender();
-        plProfile_EndLap(ShadowMaster, this->GetKey()->GetUoid().GetObjectName());
+        plProfile_EndLap(ShadowMaster, this->GetKey()->GetUoid().GetObjectName().c_str());
         return true;
     }
 
diff --git a/Sources/Plasma/PubUtilLib/plModifier/plCloneSpawnModifier.cpp b/Sources/Plasma/PubUtilLib/plModifier/plCloneSpawnModifier.cpp
index c75c616b..88e36511 100644
--- a/Sources/Plasma/PubUtilLib/plModifier/plCloneSpawnModifier.cpp
+++ b/Sources/Plasma/PubUtilLib/plModifier/plCloneSpawnModifier.cpp
@@ -106,7 +106,7 @@ plKey plCloneSpawnModifier::SpawnClone(const char* cloneName, const char* cloneA
     const plLocation& loc = plKeyFinder::Instance().FindLocation(cloneAge, "BuiltIn");
 
     // Find the clone template key
-    plUoid objUoid(loc, plSceneObject::Index(), cloneName);
+    plUoid objUoid(loc, plSceneObject::Index(), _TEMP_CONVERT_FROM_LITERAL(cloneName));
     plKey key = resMgr->FindKey(objUoid);
 
     if (key)
diff --git a/Sources/Plasma/PubUtilLib/plModifier/plResponderModifier.cpp b/Sources/Plasma/PubUtilLib/plModifier/plResponderModifier.cpp
index a27c8cdd..d0e62679 100644
--- a/Sources/Plasma/PubUtilLib/plModifier/plResponderModifier.cpp
+++ b/Sources/Plasma/PubUtilLib/plModifier/plResponderModifier.cpp
@@ -775,7 +775,7 @@ void plResponderModifier::ILog(UInt32 color, const char* format, ...)
     if (!format || *format == '\0')
         return;
 
-    const char* keyName = GetKeyName();
+    const char* keyName = _TEMP_CONVERT_TO_CONST_CHAR(GetKeyName());
 
     // Make sure this key isn't in our list of keys to deny
     for (int i = 0; i < gNoLogStrings.size(); i++)
diff --git a/Sources/Plasma/PubUtilLib/plNetClient/plNetCliAgeJoiner.cpp b/Sources/Plasma/PubUtilLib/plNetClient/plNetCliAgeJoiner.cpp
index f5955522..73941f36 100644
--- a/Sources/Plasma/PubUtilLib/plNetClient/plNetCliAgeJoiner.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetClient/plNetCliAgeJoiner.cpp
@@ -181,7 +181,7 @@ void plNCAgeJoiner::IDispatchMsgReceiveCallback () {
 void plNCAgeJoiner::IResMgrProgressBarCallback (plKey key) {
 #ifndef PLASMA_EXTERNAL_RELEASE
     if (s_instance)
-        s_instance->progressBar->SetStatusText(key->GetName());
+        s_instance->progressBar->SetStatusText(_TEMP_CONVERT_TO_CONST_CHAR(key->GetName()));
 #endif
 }
 
diff --git a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgr.cpp b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgr.cpp
index 5bed98b7..6c374809 100644
--- a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgr.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgr.cpp
@@ -1480,7 +1480,7 @@ void plNetClientMgr::AddPendingLoad(PendingLoad *pl)
     pl->fKey = hsgResMgr::ResMgr()->FindKey(pl->fUoid);
 
     // check for age SDL state
-    if (pl->fUoid.GetObjectName() && !strcmp(pl->fUoid.GetObjectName(), plSDL::kAgeSDLObjectName))
+    if (!pl->fUoid.GetObjectName().IsNull() && !pl->fUoid.GetObjectName().Compare(plSDL::kAgeSDLObjectName))
     {
         DebugMsg("Recv SDL state for age hook object, uoid=%s", pl->fUoid.StringIze().c_str());
         if (!pl->fKey)
diff --git a/Sources/Plasma/PubUtilLib/plNetClient/plNetObjectDebugger.cpp b/Sources/Plasma/PubUtilLib/plNetClient/plNetObjectDebugger.cpp
index 1350adac..2eb22fef 100644
--- a/Sources/Plasma/PubUtilLib/plNetClient/plNetObjectDebugger.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetClient/plNetObjectDebugger.cpp
@@ -130,7 +130,7 @@ bool plNetObjectDebugger::DebugObject::ObjectMatches(const hsKeyedObject* obj)
     if ((fFlags & kPageMatch)==0)
     {
         // match based on object name only
-        return StringMatches(obj->GetKeyName());
+        return StringMatches(_TEMP_CONVERT_TO_CONST_CHAR(obj->GetKeyName()));
     }
 
     return (obj->GetKey()->GetUoid().GetLocation()==fLoc);
diff --git a/Sources/Plasma/PubUtilLib/plNetClient/plNetVoiceList.cpp b/Sources/Plasma/PubUtilLib/plNetClient/plNetVoiceList.cpp
index 833facbf..edcc33af 100644
--- a/Sources/Plasma/PubUtilLib/plNetClient/plNetVoiceList.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetClient/plNetVoiceList.cpp
@@ -88,7 +88,7 @@ void plNetTalkList::AddMember(plNetTransportMember* e)
 { 
     if (FindMember(e)==-1)
     {
-        plStatusLog::AddLineS("voice.log", "Adding %s to talk list", e->AsStdString().c_str());
+        plStatusLog::AddLineS("voice.log", "Adding %s to talk list", e->AsString().c_str());
         fMembers.push_back(e);
     }
     fFlags |= kDirty;   
@@ -99,7 +99,7 @@ void plNetTalkList::RemoveMember(plNetTransportMember* e)
     int idx=FindMember(e);
     if (idx!=-1)
     {
-        plStatusLog::AddLineS("voice.log", "Removing %s from talklist", e->AsStdString().c_str());
+        plStatusLog::AddLineS("voice.log", "Removing %s from talklist", e->AsString().c_str());
         fMembers.erase(fMembers.begin()+idx);
     }
     fFlags |= kDirty; 
@@ -122,7 +122,7 @@ void plNetListenList::AddMember(plNetTransportMember* e)
 {
     if (FindMember(e)==-1)
     {
-        plStatusLog::AddLineS("voice.log", "Adding %s to listen list ", e->AsStdString().c_str());
+        plStatusLog::AddLineS("voice.log", "Adding %s to listen list ", e->AsString().c_str());
         fMembers.push_back(e);
     
 #if 0   
@@ -146,7 +146,7 @@ void plNetListenList::RemoveMember(plNetTransportMember* e)
     if (idx!=-1)
     {
         fMembers.erase(fMembers.begin()+idx);
-        plStatusLog::AddLineS("voice.log", "Removing %s from listen list", e->AsStdString().c_str());
+        plStatusLog::AddLineS("voice.log", "Removing %s from listen list", e->AsString().c_str());
 #if 0
         // call the new member's win audible and set talk icon parameters
 
diff --git a/Sources/Plasma/PubUtilLib/plNetCommon/plNetMsgScreener.cpp b/Sources/Plasma/PubUtilLib/plNetCommon/plNetMsgScreener.cpp
index e1e93b19..6d2a6d51 100644
--- a/Sources/Plasma/PubUtilLib/plNetCommon/plNetMsgScreener.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetCommon/plNetMsgScreener.cpp
@@ -76,8 +76,8 @@ void plNetMsgScreener::IRejectLogMsg(Int16 classIndex, const char* desc, const p
 //
 void plNetMsgScreener::IRejectLogMsg(const plMessage* msg, const char* desc, const plNetGameMember* gm) const
 {
-    const char* senderName = msg->GetSender() ? msg->GetSender()->GetUoid().GetObjectName() : "?";
-    const char* rcvrName = msg->GetNumReceivers() && msg->GetReceiver(0) ? msg->GetReceiver(0)->GetUoid().GetObjectName() : "?";
+    const char* senderName = msg->GetSender() ? msg->GetSender()->GetUoid().GetObjectName().c_str() : "?";
+    const char* rcvrName = msg->GetNumReceivers() && msg->GetReceiver(0) ? msg->GetReceiver(0)->GetUoid().GetObjectName().c_str() : "?";
 
     DebugMsg("Message %s was rejected, reason:%s, age:%s, client:%s, msgSndr:%s, msgRcvr:%s", 
         msg->ClassName(), desc, IGetAgeName(), IGetSenderName(gm),
diff --git a/Sources/Plasma/PubUtilLib/plNetMessage/plNetMessage.cpp b/Sources/Plasma/PubUtilLib/plNetMessage/plNetMessage.cpp
index 13f08f47..49d7248d 100644
--- a/Sources/Plasma/PubUtilLib/plNetMessage/plNetMessage.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetMessage/plNetMessage.cpp
@@ -828,13 +828,6 @@ void plNetMsgSDLStateBCast::WriteVersion(hsStream* s, hsResMgr* mgr)
 ////////////////////////////////////////////////////////
 // plNetMsgRoomsList
 ////////////////////////////////////////////////////////
-plNetMsgRoomsList::~plNetMsgRoomsList()
-{
-    int i;
-    for(i=0;i<GetNumRooms();i++)
-        delete [] fRoomNames[i];
-}
-
 int plNetMsgRoomsList::IPokeBuffer(hsStream* stream, UInt32 peekOptions)
 {
     int bytes=plNetMessage::IPokeBuffer(stream, peekOptions);
@@ -871,7 +864,6 @@ int plNetMsgRoomsList::IPeekBuffer(hsStream* stream, UInt32 peekOptions)
             loc.Read(stream);
             fRooms[i]=loc;
             // read room name for debugging
-            delete [] fRoomNames[i];
             stream->LogSubStreamPushDesc("RoomList");
             plMsgCStringHelper::Peek(fRoomNames[i],stream,peekOptions);
         }
@@ -884,13 +876,13 @@ int plNetMsgRoomsList::IPeekBuffer(hsStream* stream, UInt32 peekOptions)
 void plNetMsgRoomsList::AddRoom(plKey rmKey)
 {
     fRooms.push_back(rmKey->GetUoid().GetLocation());
-    fRoomNames.push_back(hsStrcpy(rmKey->GetName()));
+    fRoomNames.push_back(rmKey->GetName());
 }
 
-void plNetMsgRoomsList::AddRoomLocation(plLocation loc, const char* rmName)
+void plNetMsgRoomsList::AddRoomLocation(plLocation loc, const plString& rmName)
 {
     fRooms.push_back(loc);
-    fRoomNames.push_back(rmName ? hsStrcpy(rmName) : nil);
+    fRoomNames.push_back(rmName);
 }
 
 int plNetMsgRoomsList::FindRoomLocation(plLocation loc)
diff --git a/Sources/Plasma/PubUtilLib/plNetMessage/plNetMessage.h b/Sources/Plasma/PubUtilLib/plNetMessage/plNetMessage.h
index e02a3b4b..d815c2ba 100644
--- a/Sources/Plasma/PubUtilLib/plNetMessage/plNetMessage.h
+++ b/Sources/Plasma/PubUtilLib/plNetMessage/plNetMessage.h
@@ -451,24 +451,24 @@ class plNetMsgRoomsList : public plNetMessage
 {
 protected:
     std::vector<plLocation> fRooms; 
-    std::vector<char*> fRoomNames;      // for debug usage only
+    std::vector<plString> fRoomNames;      // for debug usage only
 
     int IPokeBuffer(hsStream* stream, UInt32 peekOptions=0);
     int IPeekBuffer(hsStream* stream, UInt32 peekOptions=0);
 public:
     plNetMsgRoomsList() {}
-    ~plNetMsgRoomsList();
+    ~plNetMsgRoomsList() {};
 
     CLASSNAME_REGISTER( plNetMsgRoomsList );
     GETINTERFACE_ANY( plNetMsgRoomsList, plNetMessage );
 
     void AddRoom(plKey rmKey);
-    void AddRoomLocation(plLocation loc, const char* rmName);
+    void AddRoomLocation(plLocation loc, const plString& rmName);
     int FindRoomLocation(plLocation loc);
 
     int GetNumRooms() const { return fRooms.size(); }
     plLocation GetRoomLoc(int i) const { return fRooms[i]; }
-    const char* GetRoomName(int i) const { return fRoomNames[i]; }      // debug
+    plString GetRoomName(int i) const { return fRoomNames[i]; }      // debug
 };
 
 //
diff --git a/Sources/Plasma/PubUtilLib/plNetMessage/plNetMsgHelpers.cpp b/Sources/Plasma/PubUtilLib/plNetMessage/plNetMsgHelpers.cpp
index ec2a5ce8..ca8b0b2b 100644
--- a/Sources/Plasma/PubUtilLib/plNetMessage/plNetMsgHelpers.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetMessage/plNetMsgHelpers.cpp
@@ -364,7 +364,7 @@ int plNetMsgObjectHelper::Peek(hsStream* stream, const UInt32 peekOptions)
 
 hsBool plNetMsgObjectHelper::SetFromKey(const plKey &key)
 {
-    if (!key || !key->GetName())
+    if (!key || key->GetName().IsNull())
         return false;
     
     fUoid = key->GetUoid();
diff --git a/Sources/Plasma/PubUtilLib/plNetMessage/plNetMsgHelpers.h b/Sources/Plasma/PubUtilLib/plNetMessage/plNetMsgHelpers.h
index 0707936f..2d1aa53d 100644
--- a/Sources/Plasma/PubUtilLib/plNetMessage/plNetMsgHelpers.h
+++ b/Sources/Plasma/PubUtilLib/plNetMessage/plNetMsgHelpers.h
@@ -213,7 +213,7 @@ public:
     void SetUoid(const plUoid &u) { fUoid=u; }
     
     // getters
-    const char* GetObjectName() const { return fUoid.GetObjectName(); }
+    const plString& GetObjectName() const { return fUoid.GetObjectName(); }
     UInt32      GetPageID() const { return fUoid.GetLocation().GetSequenceNumber(); }
     const plUoid& GetUoid() const { return fUoid; }
     
diff --git a/Sources/Plasma/PubUtilLib/plParticleSystem/plParticleEmitter.cpp b/Sources/Plasma/PubUtilLib/plParticleSystem/plParticleEmitter.cpp
index fe865742..ae200e97 100644
--- a/Sources/Plasma/PubUtilLib/plParticleSystem/plParticleEmitter.cpp
+++ b/Sources/Plasma/PubUtilLib/plParticleSystem/plParticleEmitter.cpp
@@ -324,7 +324,7 @@ void plParticleEmitter::IUpdateParticles(hsScalar delta)
     
     if ((fGenerator != nil) && (fTimeToLive >= 0))
     {
-        plProfile_BeginLap(ParticleGenerate, fSystem->GetKeyName());
+        plProfile_BeginLap(ParticleGenerate, fSystem->GetKeyName().c_str());
         if (!fGenerator->AddAutoParticles(this, delta))
         {
             delete fGenerator;
@@ -332,7 +332,7 @@ void plParticleEmitter::IUpdateParticles(hsScalar delta)
         }
         if( (fTimeToLive > 0) && ((fTimeToLive -= delta) <= 0) )
             fTimeToLive = -1.f;
-        plProfile_EndLap(ParticleGenerate, fSystem->GetKeyName());
+        plProfile_EndLap(ParticleGenerate, fSystem->GetKeyName().c_str());
     }
 
     fTargetInfo.fContext = fSystem->fContext;
diff --git a/Sources/Plasma/PubUtilLib/plParticleSystem/plParticleSystem.cpp b/Sources/Plasma/PubUtilLib/plParticleSystem/plParticleSystem.cpp
index c07c9492..96c88d73 100644
--- a/Sources/Plasma/PubUtilLib/plParticleSystem/plParticleSystem.cpp
+++ b/Sources/Plasma/PubUtilLib/plParticleSystem/plParticleSystem.cpp
@@ -486,9 +486,9 @@ hsBool plParticleSystem::MsgReceive(plMessage* msg)
 
     if ((rend = plRenderMsg::ConvertNoRef(msg)))
     {
-        plProfile_BeginLap(ParticleSys, this->GetKey()->GetUoid().GetObjectName());
+        plProfile_BeginLap(ParticleSys, this->GetKey()->GetUoid().GetObjectName().c_str());
         IHandleRenderMsg(rend->Pipeline());
-        plProfile_EndLap(ParticleSys, this->GetKey()->GetUoid().GetObjectName());
+        plProfile_EndLap(ParticleSys, this->GetKey()->GetUoid().GetObjectName().c_str());
         return true;
     }
     else if ((refMsg = plGenRefMsg::ConvertNoRef(msg)))
diff --git a/Sources/Plasma/PubUtilLib/plPhysX/plPXPhysical.cpp b/Sources/Plasma/PubUtilLib/plPhysX/plPXPhysical.cpp
index 99a210df..c46a8b05 100644
--- a/Sources/Plasma/PubUtilLib/plPhysX/plPXPhysical.cpp
+++ b/Sources/Plasma/PubUtilLib/plPhysX/plPXPhysical.cpp
@@ -493,7 +493,7 @@ hsBool plPXPhysical::Init(PhysRecipe& recipe)
     }
 
     actorDesc.userData = this;
-    actorDesc.name = GetKeyName();
+    actorDesc.name = GetKeyName().c_str();
 
     // Put the dynamics into actor group 1.  The actor groups are only used for
     // deciding who we get contact reports for.
@@ -617,7 +617,7 @@ hsBool plPXPhysical::HandleRefMsg(plGenRefMsg* refMsg)
     plKey ourKey = GetKey();
     PhysRefType refType = PhysRefType(refMsg->fType);
 
-    const char* refKeyName = refKey ? refKey->GetName() : "MISSING";
+    plString refKeyName = refKey ? refKey->GetName() : _TEMP_CONVERT_FROM_LITERAL("MISSING");
 
     if (refType == kPhysRefWorld)
     {
@@ -695,11 +695,11 @@ plPhysical& plPXPhysical::SetProperty(int prop, hsBool status)
         case plSimulationInterface::kNoSynchronize:     propName = "kNoSynchronize";        break;
         }
 
-        const char* name = "(unknown)";
+        plString name = _TEMP_CONVERT_FROM_LITERAL("(unknown)");
         if (GetKey())
             name = GetKeyName();
         if (plSimulationMgr::fExtraProfile)
-            plSimulationMgr::Log("Warning: Redundant physical property set (property %s, value %s) on %s", propName, status ? "true" : "false", name);
+            plSimulationMgr::Log("Warning: Redundant physical property set (property %s, value %s) on %s", propName, status ? "true" : "false", name.c_str());
     }
 
     switch (prop)
@@ -786,7 +786,7 @@ void plPXPhysical::SendNewLocation(hsBool synchTransform, hsBool isSynchUpdate)
             if (!CompareMatrices(curl2w, fCachedLocal2World, .0001f))
             {
                 plProfile_Inc(LocationsSent);
-                plProfile_BeginLap(PhysicsUpdates, GetKeyName());
+                plProfile_BeginLap(PhysicsUpdates, GetKeyName().c_str());
 
                 // quick peek at the translation...last time it was corrupted because we applied a non-unit quaternion
 //              hsAssert(real_finite(fCachedLocal2World.fMap[0][3]) &&
@@ -808,7 +808,7 @@ void plPXPhysical::SendNewLocation(hsBool synchTransform, hsBool isSynchUpdate)
                 pCorrMsg->Send();
                 if (fProxyGen)
                     fProxyGen->SetTransform(fCachedLocal2World, w2l);
-                plProfile_EndLap(PhysicsUpdates, GetKeyName());
+                plProfile_EndLap(PhysicsUpdates, GetKeyName().c_str());
             }
         }
     }
diff --git a/Sources/Plasma/PubUtilLib/plPhysX/plSimulationMgr.cpp b/Sources/Plasma/PubUtilLib/plPhysX/plSimulationMgr.cpp
index 52d5320e..df15e972 100644
--- a/Sources/Plasma/PubUtilLib/plPhysX/plSimulationMgr.cpp
+++ b/Sources/Plasma/PubUtilLib/plPhysX/plSimulationMgr.cpp
@@ -208,7 +208,7 @@ class SensorReport : public NxUserTriggerReport
     void SendCollisionMsg(plKey receiver, plKey hitter, hsBool entering)
     {
         DetectorLogYellow("Collision: %s was triggered by %s. Sending an %s msg", receiver->GetName(), 
-                          hitter ? hitter->GetName() : "(nil)" , entering ? "'enter'" : "'exit'");
+                          hitter ? hitter->GetName().c_str() : "(nil)" , entering ? "'enter'" : "'exit'");
         plCollideMsg* msg = TRACKED_NEW plCollideMsg;
         msg->fOtherKey = hitter;
         msg->fEntering = entering;
@@ -537,8 +537,8 @@ void plSimulationMgr::ReleaseScene(plKey world)
 
 void plSimulationMgr::ISendCollisionMsg(plKey receiver, plKey hitter, hsBool entering)
 {
-    DetectorLogYellow("Collision: %s is inside %s. Sending an %s msg", hitter ? hitter->GetName() : "(nil)",
-                      receiver->GetName(), entering ? "'enter'" : "'exit'");
+    DetectorLogYellow("Collision: %s is inside %s. Sending an %s msg", hitter ? hitter->GetName().c_str() : "(nil)",
+                      receiver->GetName().c_str(), entering ? "'enter'" : "'exit'");
     plCollideMsg* msg = TRACKED_NEW plCollideMsg;
     msg->fOtherKey = hitter;
     msg->fEntering = entering;
@@ -740,10 +740,10 @@ void plSimulationMgr::ISendUpdates()
                     const plKey physKey = physical->GetKey();
                     if (physKey)
                     {
-                        const char *physName = physical->GetKeyName();
-                        if (physName)
+                        const plString &physName = physical->GetKeyName();
+                        if (!physName.IsNull())
                         {
-                            plSimulationMgr::Log("Removing physical <%s> because of missing scene node.\n", physName);
+                            plSimulationMgr::Log("Removing physical <%s> because of missing scene node.\n", physName.c_str());
                         }
                     }
 //                  Remove(physical);
diff --git a/Sources/Plasma/PubUtilLib/plPipeline/plCaptureRender.cpp b/Sources/Plasma/PubUtilLib/plPipeline/plCaptureRender.cpp
index c0a2284a..5f5abe5a 100644
--- a/Sources/Plasma/PubUtilLib/plPipeline/plCaptureRender.cpp
+++ b/Sources/Plasma/PubUtilLib/plPipeline/plCaptureRender.cpp
@@ -138,8 +138,7 @@ hsBool plCaptureRender::Capture(const plKey& ack, UInt16 width, UInt16 height)
     plRenderTarget* rt = TRACKED_NEW plRenderTarget(flags, width, height, bitDepth, zDepth, stencilDepth);
 
     static int idx=0;
-    char buff[32];
-    sprintf(buff, "tRT%d", idx++);
+    plString buff = plString::Format("tRT%d", idx++);
     hsgResMgr::ResMgr()->NewKey(buff, rt, ack->GetUoid().GetLocation());
 
 
@@ -181,8 +180,7 @@ hsBool plCaptureRender::IProcess(plPipeline* pipe, const plKey& ack, plRenderTar
     static int currentCapIndex = 0;
 
     // Mipmap isn't created with a key so let's give it one now
-    char buff[512];
-    sprintf(buff, "CaptureRender_%d", currentCapIndex++);
+    plString buff = plString::Format("CaptureRender_%d", currentCapIndex++);
 
     hsgResMgr::ResMgr()->NewKey(buff, mipMap, plLocation::kGlobalFixedLoc);
     mipMap->Ref();
diff --git a/Sources/Plasma/PubUtilLib/plPipeline/plDXDeviceRefs.cpp b/Sources/Plasma/PubUtilLib/plPipeline/plDXDeviceRefs.cpp
index c589e264..db79af42 100644
--- a/Sources/Plasma/PubUtilLib/plPipeline/plDXDeviceRefs.cpp
+++ b/Sources/Plasma/PubUtilLib/plPipeline/plDXDeviceRefs.cpp
@@ -235,7 +235,7 @@ void    plDXTextureRef::Release( void )
 {
     plProfile_DelMem(MemTexture, fDataSize + sizeof(plDXTextureRef));
     plProfile_Extern(ManagedMem);
-    PROFILE_POOL_MEM(D3DPOOL_MANAGED, fDataSize, false, (fOwner ? fOwner->GetKey() ? fOwner->GetKey()->GetUoid().GetObjectName() : "(UnknownTexture)" : "(UnknownTexture)"));
+    PROFILE_POOL_MEM(D3DPOOL_MANAGED, fDataSize, false, (fOwner ? fOwner->GetKey() ? fOwner->GetKey()->GetUoid().GetObjectName().c_str() : "(UnknownTexture)" : "(UnknownTexture)"));
     plDXPipeline::FreeManagedTexture(fDataSize);
     fDataSize = 0;
 
diff --git a/Sources/Plasma/PubUtilLib/plPipeline/plDXPipeline.cpp b/Sources/Plasma/PubUtilLib/plPipeline/plDXPipeline.cpp
index 347c0fad..7a8fb12c 100644
--- a/Sources/Plasma/PubUtilLib/plPipeline/plDXPipeline.cpp
+++ b/Sources/Plasma/PubUtilLib/plPipeline/plDXPipeline.cpp
@@ -1333,10 +1333,10 @@ hsBool  plDXPipeline::ICreateDeviceObjects()
     /// Ok, we're done now
 #if MCN_BOUNDS_SPANS
     fBoundsSpans = TRACKED_NEW plDrawableSpans();
-    hsgResMgr::ResMgr()->NewKey( "BoundsSpans", fBoundsSpans, plLocation::kGlobalFixedLoc );
+    hsgResMgr::ResMgr()->NewKey( _TEMP_CONVERT_FROM_LITERAL("BoundsSpans"), fBoundsSpans, plLocation::kGlobalFixedLoc );
     fBoundsSpans->SetNativeProperty( plDrawable::kPropVolatile, true );
     fBoundsMat = TRACKED_NEW hsGMaterial();
-    hsgResMgr::ResMgr()->NewKey( "BoundsMaterial", fBoundsMat, plLocation::kGlobalFixedLoc );
+    hsgResMgr::ResMgr()->NewKey( _TEMP_CONVERT_FROM_LITERAL("BoundsMaterial"), fBoundsMat, plLocation::kGlobalFixedLoc );
     plLayer *lay = fBoundsMat->MakeBaseLayer();
     lay->SetMiscFlags( hsGMatState::kMiscWireFrame | hsGMatState::kMiscTwoSided );
     lay->SetShadeFlags( lay->GetShadeFlags() | hsGMatState::kShadeWhite );
@@ -8304,11 +8304,11 @@ IDirect3DTexture9   *plDXPipeline::IMakeD3DTexture( plDXTextureRef *ref, D3DFORM
         IGetD3DError();
         plStatusLog::AddLineS( "pipeline.log", 0xffff0000, "Unable to create texture (%s) Owner: %s "
                                             "Size: %d x %d NumLvls: %d Flags: %x",
-                                            fSettings.fErrorStr, ref->fOwner ? ref->fOwner->GetKey() ? ref->fOwner->GetKey()->GetUoid().GetObjectName() : "" : "",
+                                            fSettings.fErrorStr, ref->fOwner ? ref->fOwner->GetKey() ? ref->fOwner->GetKey()->GetUoid().GetObjectName().c_str() : "" : "",
                                             ref->fMaxWidth, ref->fMaxHeight, ref->fMMLvs, ref->GetFlags() );
         return nil;
     }
-    PROFILE_POOL_MEM(poolType, ref->fDataSize, true, (ref->fOwner ? ref->fOwner->GetKey() ? ref->fOwner->GetKey()->GetUoid().GetObjectName() : "(UnknownTexture)" : "(UnknownTexture)"));
+    PROFILE_POOL_MEM(poolType, ref->fDataSize, true, (ref->fOwner ? ref->fOwner->GetKey() ? ref->fOwner->GetKey()->GetUoid().GetObjectName().c_str() : "(UnknownTexture)" : "(UnknownTexture)"));
     fTexManaged += ref->fDataSize;
 
     return texPtr;
@@ -8326,7 +8326,7 @@ void    plDXPipeline::IFillD3DTexture( plDXTextureRef *ref )
     if( pTexDat == nil )
     {
         plStatusLog::AddLineS( "pipeline.log", 0xffff0000, "Unable to fill texture ref (data is nil) Owner: %s",
-                                            ref->fOwner ? ref->fOwner->GetKey() ? ref->fOwner->GetKey()->GetUoid().GetObjectName() : "" : "" );
+                                            ref->fOwner ? ref->fOwner->GetKey() ? ref->fOwner->GetKey()->GetUoid().GetObjectName().c_str() : "" : "" );
         return;
     }
 
@@ -8341,7 +8341,7 @@ void    plDXPipeline::IFillD3DTexture( plDXTextureRef *ref )
             IGetD3DError();
             plStatusLog::AddLineS( "pipeline.log", 0xffff0000, "Unable to lock texture level %d for filling (%s) Owner: %s "
                                                 "Size: %d x %d NumLvls: %d Flags: %x",
-                                                i, fSettings.fErrorStr, ref->fOwner ? ref->fOwner->GetKey() ? ref->fOwner->GetKey()->GetUoid().GetObjectName() : "" : "",
+                                                i, fSettings.fErrorStr, ref->fOwner ? ref->fOwner->GetKey() ? ref->fOwner->GetKey()->GetUoid().GetObjectName().c_str() : "" : "",
                                                 ref->fMaxWidth, ref->fMaxHeight, ref->fMMLvs, ref->GetFlags() );
             return;
         }
@@ -8361,7 +8361,7 @@ IDirect3DCubeTexture9   *plDXPipeline::IMakeD3DCubeTexture( plDXTextureRef *ref,
     IDirect3DCubeTexture9   *texPtr = nil;
     fManagedAlloced = true;
     WEAK_ERROR_CHECK(fD3DDevice->CreateCubeTexture( ref->fMaxWidth, ref->fMMLvs, 0, formatType, poolType, &texPtr, NULL));
-    PROFILE_POOL_MEM(poolType, ref->fDataSize, true, (ref->fOwner ? ref->fOwner->GetKey() ? ref->fOwner->GetKey()->GetUoid().GetObjectName() : "(UnknownTexture)" : "(UnknownTexture)"));
+    PROFILE_POOL_MEM(poolType, ref->fDataSize, true, (ref->fOwner ? ref->fOwner->GetKey() ? ref->fOwner->GetKey()->GetUoid().GetObjectName().c_str() : "(UnknownTexture)" : "(UnknownTexture)"));
     fTexManaged += ref->fDataSize;
     return texPtr;
 }
@@ -9367,7 +9367,7 @@ void plDXPipeline::IMakeOcclusionSnap()
         ident.Reset();
 
         hsGMaterial* mat = TRACKED_NEW hsGMaterial;
-        hsgResMgr::ResMgr()->NewKey( "OcclusionSnapMat", mat, plLocation::kGlobalFixedLoc );
+        hsgResMgr::ResMgr()->NewKey( _TEMP_CONVERT_FROM_LITERAL("OcclusionSnapMat"), mat, plLocation::kGlobalFixedLoc );
         plLayer *lay = mat->MakeBaseLayer();
         lay->SetZFlags(hsGMatState::kZNoZWrite);
         lay->SetPreshadeColor(hsColorRGBA().Set(1.f, 0.5f, 0.5f, 1.f));
diff --git a/Sources/Plasma/PubUtilLib/plPipeline/plDynamicEnvMap.cpp b/Sources/Plasma/PubUtilLib/plPipeline/plDynamicEnvMap.cpp
index 3d4489dd..4982d066 100644
--- a/Sources/Plasma/PubUtilLib/plPipeline/plDynamicEnvMap.cpp
+++ b/Sources/Plasma/PubUtilLib/plPipeline/plDynamicEnvMap.cpp
@@ -439,9 +439,7 @@ void plDynamicEnvMap::Read(hsStream* s, hsResMgr* mgr)
     nVis = s->ReadLE32();
     for( i = 0; i < nVis; i++)
     {
-        char *name = s->ReadSafeString();
-        plKey key = plKeyFinder::Instance().StupidSearch(nil, nil, plVisRegion::Index(), name);
-        delete[] name;
+        plKey key = plKeyFinder::Instance().StupidSearch(nil, nil, plVisRegion::Index(), s->ReadSafeString_TEMP());
         if (key)
             hsgResMgr::ResMgr()->AddViaNotify(key, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, -1, kRefVisSet), plRefFlags::kActiveRef);
     }
@@ -910,9 +908,7 @@ void plDynamicCamMap::Read(hsStream* s, hsResMgr* mgr)
     nVis = s->ReadLE32();
     for( i = 0; i < nVis; i++)
     {
-        char *name = s->ReadSafeString();
-        plKey key = plKeyFinder::Instance().StupidSearch(nil, nil, plVisRegion::Index(), name);
-        delete[] name;
+        plKey key = plKeyFinder::Instance().StupidSearch(nil, nil, plVisRegion::Index(), s->ReadSafeString_TEMP());
         if (key)
             hsgResMgr::ResMgr()->AddViaNotify(key, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, -1, kRefVisSet), plRefFlags::kActiveRef);
     }
diff --git a/Sources/Plasma/PubUtilLib/plPipeline/plPlates.cpp b/Sources/Plasma/PubUtilLib/plPipeline/plPlates.cpp
index 119742e4..46e30bcf 100644
--- a/Sources/Plasma/PubUtilLib/plPipeline/plPlates.cpp
+++ b/Sources/Plasma/PubUtilLib/plPipeline/plPlates.cpp
@@ -164,10 +164,10 @@ void plPlate::SetTexture(plBitmap *texture)
 {
     plLayer         *layer;
     hsGMaterial     *material;
-    char            keyName[ 128 ];
+    plString        keyName;
 
     material = TRACKED_NEW hsGMaterial();
-    sprintf( keyName, "PlateBlank#%d", fMagicUniqueKeyInt++ );
+    keyName = plString::Format( "PlateBlank#%d", fMagicUniqueKeyInt++ );
     hsgResMgr::ResMgr()->NewKey( keyName, material, plLocation::kGlobalFixedLoc );
     layer = material->MakeBaseLayer();
     layer->SetShadeFlags( layer->GetShadeFlags() | hsGMatState::kShadeNoShade | hsGMatState::kShadeWhite | hsGMatState::kShadeReallyNoFog );
@@ -202,7 +202,7 @@ plMipmap    *plPlate::CreateMaterial( UInt32 width, UInt32 height, hsBool withAl
 {
     plLayer         *layer;
     hsGMaterial     *material;
-    char            keyName[ 128 ];
+    plString        keyName;
 
 
     if (texture)
@@ -214,14 +214,14 @@ plMipmap    *plPlate::CreateMaterial( UInt32 width, UInt32 height, hsBool withAl
         /// Create a new bitmap
         fMipmap = TRACKED_NEW plMipmap( width, height, withAlpha ? plMipmap::kARGB32Config : plMipmap::kRGB32Config, 1 );
         memset( fMipmap->GetImage(), 0xff, height * fMipmap->GetRowBytes() );
-        sprintf( keyName, "PlateBitmap#%d", fMagicUniqueKeyInt++ );
+        keyName = plString::Format( "PlateBitmap#%d", fMagicUniqueKeyInt++ );
         hsgResMgr::ResMgr()->NewKey( keyName, fMipmap, plLocation::kGlobalFixedLoc );
         fMipmap->SetFlags( fMipmap->GetFlags() | plMipmap::kDontThrowAwayImage );
     }
 
     /// NOW create a layer wrapper and a material for that layer
     material = TRACKED_NEW hsGMaterial();
-    sprintf( keyName, "PlateBlank#%d", fMagicUniqueKeyInt++ );
+    keyName = plString::Format( "PlateBlank#%d", fMagicUniqueKeyInt++ );
     hsgResMgr::ResMgr()->NewKey( keyName, material, plLocation::kGlobalFixedLoc );
     layer = material->MakeBaseLayer();
     layer->SetShadeFlags( layer->GetShadeFlags() | hsGMatState::kShadeNoShade | hsGMatState::kShadeWhite | hsGMatState::kShadeReallyNoFog );
@@ -252,8 +252,7 @@ void plPlate::CreateFromResource(const char *resName)
         plMipmap* resTexture = TRACKED_NEW plMipmap;
         resTexture->CopyFrom(plClientResMgr::Instance().getResource(resName));
 
-        char keyName[128];
-        sprintf( keyName, "PlateResource#%d", fMagicUniqueKeyInt++ );
+        plString keyName = plString::Format( "PlateResource#%d", fMagicUniqueKeyInt++ );
         hsgResMgr::ResMgr()->NewKey(keyName, resTexture, plLocation::kGlobalFixedLoc);
         CreateMaterial(resTexture->GetWidth(), resTexture->GetHeight(), true, resTexture);
     }
diff --git a/Sources/Plasma/PubUtilLib/plResMgr/plKeyFinder.cpp b/Sources/Plasma/PubUtilLib/plResMgr/plKeyFinder.cpp
index 45476472..6d559308 100644
--- a/Sources/Plasma/PubUtilLib/plResMgr/plKeyFinder.cpp
+++ b/Sources/Plasma/PubUtilLib/plResMgr/plKeyFinder.cpp
@@ -109,12 +109,7 @@ hsBool NameMatches(const char* obName, const char* pKName, hsBool subString)
     }
     else
     {
-        char oCopy[256], pCopy[256];
-        strcpy(oCopy, o);
-        strcpy(pCopy, p);
-        hsStrLower(oCopy);
-        hsStrLower(pCopy);
-        if (strstr(pCopy, oCopy))
+        if (plString(_TEMP_CONVERT_FROM_LITERAL(p)).Find(p, plString::kCaseInsensitive) >= 0)
             return true;
     }
 
@@ -122,7 +117,7 @@ hsBool NameMatches(const char* obName, const char* pKName, hsBool subString)
 }
 
 plKey plKeyFinder::StupidSearch(const char * age, const char * rm, 
-                                 const char *className, const char *obName, hsBool subString)
+                                 const char *className, const plString &obName, hsBool subString)
 {
     UInt16 ty = plFactory::FindClassIndex(className);
     return StupidSearch(age, rm, ty, obName, subString);
@@ -132,7 +127,7 @@ class plKeyFinderIter : public plRegistryKeyIterator, public plRegistryPageItera
 {
 protected:
     UInt16      fClassType;
-    const char  *fObjName;
+    plString    fObjName;
     hsBool      fSubstr;
     plKey       fFoundKey;
     const char  *fAgeName;
@@ -140,17 +135,17 @@ protected:
 public:
     plKey   GetFoundKey( void ) const { return fFoundKey; }
 
-    plKeyFinderIter( UInt16 classType, const char *obName, hsBool substr ) 
+    plKeyFinderIter( UInt16 classType, const plString &obName, hsBool substr )
             : fFoundKey( nil ), fClassType( classType ), fObjName( obName ), fSubstr( substr ) { }
 
-    plKeyFinderIter( UInt16 classType, const char *obName, hsBool substr, const char *ageName ) 
+    plKeyFinderIter( UInt16 classType, const plString &obName, hsBool substr, const char *ageName )
         : fFoundKey( nil ), fClassType( classType ), fObjName( obName ), fSubstr( substr ),
             fAgeName( ageName ) {}
 
     virtual hsBool  EatKey( const plKey& key )
     {
         if( key->GetUoid().GetClassType() == fClassType &&
-            NameMatches( fObjName, key->GetUoid().GetObjectName(), fSubstr ) )
+            NameMatches( fObjName.c_str(), key->GetUoid().GetObjectName().c_str(), fSubstr ) )
         {
             fFoundKey = key;
             return false;
@@ -187,9 +182,9 @@ public:
 };
 
 plKey plKeyFinder::StupidSearch(const char * age, const char * rm, 
-                                 UInt16 classType, const char *obName, hsBool subString)
+                                 UInt16 classType, const plString &obName, hsBool subString)
 {
-    if (!obName)
+    if (obName.IsNull())
         return nil;
 
     plUoid newOid;
@@ -239,12 +234,12 @@ plKey plKeyFinder::StupidSearch(const char * age, const char * rm,
     return nil;
 }
 
-void plKeyFinder::ReallyStupidResponderSearch(const char *name, std::vector<plKey>& foundKeys, const plLocation &hintLocation )
+void plKeyFinder::ReallyStupidResponderSearch(const plString &name, std::vector<plKey>& foundKeys, const plLocation &hintLocation )
 {
     ReallyStupidSubstringSearch(name, CLASS_INDEX_SCOPED(plResponderModifier), foundKeys, hintLocation);
 }
 
-void plKeyFinder::ReallyStupidActivatorSearch(const char *name, std::vector<plKey>& foundKeys, const plLocation &hintLocation)
+void plKeyFinder::ReallyStupidActivatorSearch(const plString &name, std::vector<plKey>& foundKeys, const plLocation &hintLocation)
 {
     // use the createable macro so we don't have to pull in all of Python
     ReallyStupidSubstringSearch(name, CLASS_INDEX_SCOPED(plLogicModifier), foundKeys, hintLocation);
@@ -252,7 +247,7 @@ void plKeyFinder::ReallyStupidActivatorSearch(const char *name, std::vector<plKe
     ReallyStupidSubstringSearch(name, CLASS_INDEX_SCOPED(plSittingModifier), foundKeys, hintLocation);
 }
 
-void plKeyFinder::IGetNames(std::vector<std::string>& names, const char* searchName, int index)
+void plKeyFinder::IGetNames(std::vector<plString>& names, const plString& searchName, int index)
 {
     // Not really searching for any particular key, just need all the logic mods
     std::vector<plKey> keys;
@@ -267,14 +262,14 @@ void plKeyFinder::IGetNames(std::vector<std::string>& names, const char* searchN
     }
 }
 
-void plKeyFinder::GetResponderNames(std::vector<std::string>& names)
+void plKeyFinder::GetResponderNames(std::vector<plString>& names)
 {
-    IGetNames(names, "", CLASS_INDEX_SCOPED(plResponderModifier));
+    IGetNames(names, _TEMP_CONVERT_FROM_LITERAL(""), CLASS_INDEX_SCOPED(plResponderModifier));
 }
 
-void plKeyFinder::GetActivatorNames(std::vector<std::string>& names)
+void plKeyFinder::GetActivatorNames(std::vector<plString>& names)
 {
-    IGetNames(names, "", CLASS_INDEX_SCOPED(plLogicModifier));
+    IGetNames(names, _TEMP_CONVERT_FROM_LITERAL(""), CLASS_INDEX_SCOPED(plLogicModifier));
 }
 
 class plKeyFinderIterator : public plRegistryKeyIterator, public plRegistryPageIterator
@@ -282,19 +277,19 @@ class plKeyFinderIterator : public plRegistryKeyIterator, public plRegistryPageI
     protected:
 
         UInt16      fClassType;
-        const char  *fObjName;
+        plString    fObjName;
 
         std::vector<plKey>  &fFoundKeys;
 
     public:
     
-        plKeyFinderIterator( UInt16 classType, const char *obName, std::vector<plKey>& foundKeys ) 
+        plKeyFinderIterator( UInt16 classType, const plString &obName, std::vector<plKey>& foundKeys )
                 : fClassType( classType ), fObjName( obName ), fFoundKeys( foundKeys ) { }
 
         virtual hsBool  EatKey( const plKey& key )
         {
             if( key->GetUoid().IsValid() && key->GetUoid().GetClassType() == fClassType &&
-                strstr( key->GetUoid().GetObjectName(), fObjName ) )
+                key->GetUoid().GetObjectName().Find( fObjName ) >= 0 )
             {
                 fFoundKeys.push_back( key );
             }
@@ -309,9 +304,9 @@ class plKeyFinderIterator : public plRegistryKeyIterator, public plRegistryPageI
         }
 };
 
-void plKeyFinder::ReallyStupidSubstringSearch(const char *name, UInt16 objType, std::vector<plKey>& foundKeys, const plLocation &hintLocation )
+void plKeyFinder::ReallyStupidSubstringSearch(const plString &name, UInt16 objType, std::vector<plKey>& foundKeys, const plLocation &hintLocation )
 {
-    if (!name)
+    if (name.IsNull())
         return;
 
     plKeyFinderIterator collector( objType, name, foundKeys );
diff --git a/Sources/Plasma/PubUtilLib/plResMgr/plKeyFinder.h b/Sources/Plasma/PubUtilLib/plResMgr/plKeyFinder.h
index 858bc108..b11048e0 100644
--- a/Sources/Plasma/PubUtilLib/plResMgr/plKeyFinder.h
+++ b/Sources/Plasma/PubUtilLib/plResMgr/plKeyFinder.h
@@ -89,19 +89,19 @@ public:
     static plKeyFinder& Instance();
 
     // These are Stupid search because they just do string searchs on the objects.
-    plKey StupidSearch(const char * age, const char * rm, const char *className, const char *obName, hsBool subString=false);
-    plKey StupidSearch(const char * age, const char * rm, UInt16 objType, const char *obName, hsBool subString=false);
+    plKey StupidSearch(const char * age, const char * rm, const char *className, const plString &obName, hsBool subString=false);
+    plKey StupidSearch(const char * age, const char * rm, UInt16 objType, const plString &obName, hsBool subString=false);
 
     eErrCodes   GetLastErrorCode() { return fLastError; }
     const char* GetLastErrorString(); // For Console display
 
-    void ReallyStupidResponderSearch(const char* name, std::vector<plKey>& foundKeys, const plLocation& hintLocation = plLocation::kInvalidLoc);
-    void ReallyStupidActivatorSearch(const char* name, std::vector<plKey>& foundKeys, const plLocation& hintLocation = plLocation::kInvalidLoc);
+    void ReallyStupidResponderSearch(const plString& name, std::vector<plKey>& foundKeys, const plLocation& hintLocation = plLocation::kInvalidLoc);
+    void ReallyStupidActivatorSearch(const plString& name, std::vector<plKey>& foundKeys, const plLocation& hintLocation = plLocation::kInvalidLoc);
 
-    void ReallyStupidSubstringSearch(const char* name, UInt16 objType, std::vector<plKey>& foundKeys, const plLocation& hintLocation = plLocation::kInvalidLoc);
+    void ReallyStupidSubstringSearch(const plString& name, UInt16 objType, std::vector<plKey>& foundKeys, const plLocation& hintLocation = plLocation::kInvalidLoc);
 
-    void GetActivatorNames(std::vector<std::string>& names);
-    void GetResponderNames(std::vector<std::string>& names);
+    void GetActivatorNames(std::vector<plString>& names);
+    void GetResponderNames(std::vector<plString>& names);
 
     plKey FindSceneNodeKey(const char* pageOrFullLocName) const;
     plKey FindSceneNodeKey(const char* ageName, const char* pageName) const;
@@ -113,7 +113,7 @@ public:
 protected:
     plKeyFinder() {}
 
-    void IGetNames(std::vector<std::string>& names, const char* name, int index);
+    void IGetNames(std::vector<plString>& names, const plString& name, int index);
     plKey IFindSceneNodeKey(plRegistryPageNode* page) const;
 
     eErrCodes fLastError;
diff --git a/Sources/Plasma/PubUtilLib/plResMgr/plRegistryKeyList.cpp b/Sources/Plasma/PubUtilLib/plResMgr/plRegistryKeyList.cpp
index eaf3c840..88cd3a70 100644
--- a/Sources/Plasma/PubUtilLib/plResMgr/plRegistryKeyList.cpp
+++ b/Sources/Plasma/PubUtilLib/plResMgr/plRegistryKeyList.cpp
@@ -69,11 +69,11 @@ plRegistryKeyList::~plRegistryKeyList()
 class plSearchKeyImp : public plKeyImp
 {
 public:
-    const char* fSearchKeyName;
-    const char* GetName() const { return fSearchKeyName; }
+    plString fSearchKeyName;
+    const plString& GetName() const { return fSearchKeyName; }
 };
 
-plKeyImp* plRegistryKeyList::FindKey(const char* keyName)
+plKeyImp* plRegistryKeyList::FindKey(const plString& keyName)
 {
     static plSearchKeyImp searchKey;
     searchKey.fSearchKeyName = keyName;
@@ -86,7 +86,7 @@ plKeyImp* plRegistryKeyList::FindKey(const char* keyName)
         for (int i = 0; i < fStaticKeys.size(); i++)
         {
             plKeyImp* curKey = fStaticKeys[i];
-            if (curKey && hsStrCaseEQ(keyName, curKey->GetName()))
+            if (curKey && !keyName.Compare(curKey->GetName(), plString::kCaseInsensitive))
                 return curKey;
         }
     }
@@ -94,7 +94,7 @@ plKeyImp* plRegistryKeyList::FindKey(const char* keyName)
     {
         // We're sorted, do a fast lookup
         StaticVec::const_iterator it = std::lower_bound(fStaticKeys.begin(), fStaticKeys.end(), &searchKey, KeySorter());
-        if (it != fStaticKeys.end() && hsStrCaseEQ(keyName, (*it)->GetName()))
+        if (it != fStaticKeys.end() && !keyName.Compare((*it)->GetName(), plString::kCaseInsensitive))
             return *it;
     }
 
@@ -124,7 +124,7 @@ plKeyImp* plRegistryKeyList::FindKey(const plUoid& uoid)
         // because of local data. Verify that we have the right key by
         // name, and if it's wrong, do the slower find-by-name.
         plKeyImp *keyImp = fStaticKeys[objectID-1];
-        if (!hsStrCaseEQ(keyImp->GetName(), uoid.GetObjectName()))
+        if (keyImp->GetName().Compare(uoid.GetObjectName(), plString::kCaseInsensitive) != 0)
             return FindKey(uoid.GetObjectName());
         else
             return keyImp;
diff --git a/Sources/Plasma/PubUtilLib/plResMgr/plRegistryKeyList.h b/Sources/Plasma/PubUtilLib/plResMgr/plRegistryKeyList.h
index b1176246..bdad2d71 100644
--- a/Sources/Plasma/PubUtilLib/plResMgr/plRegistryKeyList.h
+++ b/Sources/Plasma/PubUtilLib/plResMgr/plRegistryKeyList.h
@@ -55,7 +55,7 @@ public:
     bool operator() (plKeyImp* k1, plKeyImp* k2) const
     {
         hsAssert(k1 && k2, "Should have valid keys here");
-        return stricmp(k1->GetName(), k2->GetName()) < 0;
+        return k1->GetName().Compare(k2->GetName(), plString::kCaseInsensitive) < 0;
     }
 };
 
@@ -100,7 +100,7 @@ public:
     UInt16 GetClassType() const { return fClassType; }
 
     // Find a key by name (case-insensitive)
-    plKeyImp* FindKey(const char* keyName);
+    plKeyImp* FindKey(const plString& keyName);
     // Find a key by uoid index.
     plKeyImp* FindKey(const plUoid& uoid);
 
diff --git a/Sources/Plasma/PubUtilLib/plResMgr/plRegistryNode.cpp b/Sources/Plasma/PubUtilLib/plResMgr/plRegistryNode.cpp
index 060df37a..08b1b0d4 100644
--- a/Sources/Plasma/PubUtilLib/plResMgr/plRegistryNode.cpp
+++ b/Sources/Plasma/PubUtilLib/plResMgr/plRegistryNode.cpp
@@ -309,7 +309,7 @@ hsBool plRegistryPageNode::IterateKeys(plRegistryKeyIterator* iterator, UInt16 c
     return true;
 }
 
-plKeyImp* plRegistryPageNode::FindKey(UInt16 classType, const char* name) const
+plKeyImp* plRegistryPageNode::FindKey(UInt16 classType, const plString& name) const
 {
     plRegistryKeyList* keys = IGetKeyList(classType);
     if (keys == nil)
@@ -350,8 +350,7 @@ void plRegistryPageNode::AddKey(plKeyImp* key)
         // Attempt recovery
         for (int i = 0; i < 500; i++)
         {
-            char tempName[512];
-            sprintf(tempName, "%s%d", key->GetUoid().GetObjectName(), i);
+            plString tempName = plString::Format("%s%d", key->GetUoid().GetObjectName().c_str(), i);
             if (keys->FindKey(tempName) == nil)
             {
                 plUoid uoid(key->GetUoid().GetLocation(), key->GetUoid().GetClassType(), tempName, key->GetUoid().GetLoadMask());
diff --git a/Sources/Plasma/PubUtilLib/plResMgr/plRegistryNode.h b/Sources/Plasma/PubUtilLib/plResMgr/plRegistryNode.h
index c914d97b..e053ef51 100644
--- a/Sources/Plasma/PubUtilLib/plResMgr/plRegistryNode.h
+++ b/Sources/Plasma/PubUtilLib/plResMgr/plRegistryNode.h
@@ -118,7 +118,7 @@ public:
     void UnloadKeys();  // Frees all our keys
 
     // Find a key by type and name
-    plKeyImp* FindKey(UInt16 classType, const char* name) const;
+    plKeyImp* FindKey(UInt16 classType, const plString& name) const;
     // Find a key by direct uoid lookup (or fallback to name lookup if that doesn't work)
     plKeyImp* FindKey(const plUoid& uoid) const;
     
diff --git a/Sources/Plasma/PubUtilLib/plResMgr/plResManager.cpp b/Sources/Plasma/PubUtilLib/plResMgr/plResManager.cpp
index 4d828293..e30c2c30 100644
--- a/Sources/Plasma/PubUtilLib/plResMgr/plResManager.cpp
+++ b/Sources/Plasma/PubUtilLib/plResMgr/plResManager.cpp
@@ -528,15 +528,15 @@ void plResManager::IPageOutSceneNodes(hsBool forceAll)
 
 inline plKeyImp* IFindKeyLocalized(const plUoid& uoid, plRegistryPageNode* page)
 {
-    const char* objectName = uoid.GetObjectName();
+    const plString& objectName = uoid.GetObjectName();
 
     // If we're running localized, try to find a localized version first
-    if ((objectName != nil) && plLocalization::IsLocalized())
+    if ((!objectName.IsNull()) && plLocalization::IsLocalized())
     {
         char localName[256];
-        if (plLocalization::GetLocalized(objectName, localName))
+        if (plLocalization::GetLocalized(_TEMP_CONVERT_TO_CONST_CHAR(objectName), localName))
         {
-            plKeyImp* localKey = page->FindKey(uoid.GetClassType(), localName);
+            plKeyImp* localKey = page->FindKey(uoid.GetClassType(), _TEMP_CONVERT_FROM_LITERAL(localName));
             if (localKey != nil)
                 return localKey;
         }
@@ -743,9 +743,9 @@ plKey plResManager::ReadKeyNotifyMe(hsStream* stream, plRefMsg* msg, plRefFlags:
 //  Creates a new key and assigns it to the given keyed object, also placing
 //  it into the registry.
 
-plKey plResManager::NewKey(const char* name, hsKeyedObject* object, const plLocation& loc, const plLoadMask& m )
+plKey plResManager::NewKey(const plString& name, hsKeyedObject* object, const plLocation& loc, const plLoadMask& m )
 {
-    hsAssert(name && name[0] != '\0', "No name for new key");
+    hsAssert(!name.IsEmpty(), "No name for new key");
     plUoid newUoid(loc, object->ClassIndex(), name, m);
     return NewKey(newUoid, object);
 }
@@ -764,7 +764,7 @@ plKey plResManager::NewKey(plUoid& newUoid, hsKeyedObject* object)
     return keyPtr;
 }
 
-plKey plResManager::ReRegister(const char* nm, const plUoid& oid)
+plKey plResManager::ReRegister(const plString& nm, const plUoid& oid)
 {
     hsAssert(fInited, "Attempting to reregister a key before we're inited!");
 
@@ -919,7 +919,7 @@ plKey plResManager::ICloneKey(const plUoid& objUoid, UInt32 playerID, UInt32 clo
     fCurCloneID = cloneID;
     fCurClonePlayerID = playerID;
 
-    plKey cloneKey = ReRegister("", objUoid);
+    plKey cloneKey = ReRegister(_TEMP_CONVERT_FROM_LITERAL(""), objUoid);
 
     fCurClonePlayerID = 0;
     fCurCloneID = 0;
@@ -1270,7 +1270,7 @@ public:
     {
         if (stricmp(page->GetPageInfo().GetAge(), fAgeName) == 0)
         {
-            plUoid uoid(page->GetPageInfo().GetLocation(), 0, "");
+            plUoid uoid(page->GetPageInfo().GetLocation(), 0, _TEMP_CONVERT_FROM_LITERAL(""));
             fLocations.push_back(uoid.GetLocation());
         }
         return true;
diff --git a/Sources/Plasma/PubUtilLib/plResMgr/plResManager.h b/Sources/Plasma/PubUtilLib/plResMgr/plResManager.h
index bf587aa2..c632235a 100644
--- a/Sources/Plasma/PubUtilLib/plResMgr/plResManager.h
+++ b/Sources/Plasma/PubUtilLib/plResMgr/plResManager.h
@@ -123,7 +123,7 @@ public:
     //---------------------------
     // Registry Modification Functions
     //---------------------------
-    virtual plKey NewKey(const char* name, hsKeyedObject* object, const plLocation& loc, const plLoadMask& m = plLoadMask::kAlways);
+    virtual plKey NewKey(const plString& name, hsKeyedObject* object, const plLocation& loc, const plLoadMask& m = plLoadMask::kAlways);
     virtual plKey NewKey(plUoid& newUoid, hsKeyedObject* object);
 
     virtual plDispatchBase* Dispatch();
@@ -174,7 +174,7 @@ protected:
     friend class plKeyImp;
     friend class plResManagerHelper;
 
-    virtual plKey   ReRegister(const char* nm, const plUoid& uoid);
+    virtual plKey   ReRegister(const plString& nm, const plUoid& uoid);
     virtual hsBool  ReadObject(plKeyImp* key); // plKeys call this when needed
     virtual hsBool  IReadObject(plKeyImp* pKey, hsStream *stream);  
 
diff --git a/Sources/Plasma/PubUtilLib/plSDL/plSDL.h b/Sources/Plasma/PubUtilLib/plSDL/plSDL.h
index 4daeba0e..3e469a46 100644
--- a/Sources/Plasma/PubUtilLib/plSDL/plSDL.h
+++ b/Sources/Plasma/PubUtilLib/plSDL/plSDL.h
@@ -99,7 +99,7 @@ namespace plSDL
         kDisallowTimeStamping = 0x1,
     };
 
-    extern const char* kAgeSDLObjectName;
+    extern const plString kAgeSDLObjectName;
     void VariableLengthRead(hsStream* s, int size, int* val);
     void VariableLengthWrite(hsStream* s, int size, int val);
 };
@@ -304,7 +304,7 @@ public:
     const plUnifiedTime& GetTimeStamp() const { return fTimeStamp;  }
 
     // Special backdoor so the KI Manager can get the key name without having a ResMgr
-    const char* GetKeyName(int idx=0) const;
+    plString GetKeyName(int idx=0) const;
 
     int GetCount() const { return fVar.GetCount(); }    // helper
     plVarDescriptor* GetVarDescriptor() { return &fVar; }
diff --git a/Sources/Plasma/PubUtilLib/plSDL/plStateDataRecord.cpp b/Sources/Plasma/PubUtilLib/plSDL/plStateDataRecord.cpp
index a597207e..c8777ba2 100644
--- a/Sources/Plasma/PubUtilLib/plSDL/plStateDataRecord.cpp
+++ b/Sources/Plasma/PubUtilLib/plSDL/plStateDataRecord.cpp
@@ -49,7 +49,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 #include "plNetMessage/plNetMessage.h"
 #include "pnNetCommon/plNetApp.h"
 
-const char* plSDL::kAgeSDLObjectName = {"AgeSDLHook"};
+const plString plSDL::kAgeSDLObjectName = _TEMP_CONVERT_FROM_LITERAL("AgeSDLHook");
 
 // static 
 const UInt8 plStateDataRecord::kIOVersion=6;
@@ -734,19 +734,19 @@ void plStateDataRecord::DumpToObjectDebugger(const char* msg, bool dirtyOnly, in
     if (!dbg)
         return;
 
-    std::string pad;
+    plString pad;
     int i;
     for(i=0;i<level; i++)
-        pad += "   ";
+        pad += _TEMP_CONVERT_FROM_LITERAL("   ");
 
     int numVars = dirtyOnly ? GetNumDirtyVars() : GetNumUsedVars();
     int numSDVars = dirtyOnly ? GetNumDirtySDVars() : GetNumUsedSDVars();
 
-    dbg->LogMsg(xtl::format("%s", fAssocObject.IsValid() ? fAssocObject.GetObjectName() : " ").c_str());
+    dbg->LogMsg(plString::Format("%s", fAssocObject.IsValid() ? fAssocObject.GetObjectName().c_str() : " ").c_str());
     if (msg)
-        dbg->LogMsg(xtl::format("%s%s", pad.c_str(),msg).c_str());
+        dbg->LogMsg(plString::Format("%s%s", pad.c_str(),msg).c_str());
 
-    dbg->LogMsg(xtl::format("%sSDR(%p), desc=%s, showDirty=%d, numVars=%d, vol=%d", 
+    dbg->LogMsg(plString::Format("%sSDR(%p), desc=%s, showDirty=%d, numVars=%d, vol=%d",
         pad.c_str(), this, fDescriptor->GetName(), dirtyOnly, numVars+numSDVars, fFlags&kVolatile).c_str());
 
     // dump simple vars
@@ -778,17 +778,17 @@ void plStateDataRecord::DumpToStream(hsStream* stream, const char* msg, bool dir
     int numVars = dirtyOnly ? GetNumDirtyVars() : GetNumUsedVars();
     int numSDVars = dirtyOnly ? GetNumDirtySDVars() : GetNumUsedSDVars();
 
-    std::string logStr = xtl::format("%s", fAssocObject.IsValid() ? fAssocObject.GetObjectName() : " ");
+    plString logStr = plString::Format("%s", fAssocObject.IsValid() ? fAssocObject.GetObjectName().c_str() : " ");
 
-    stream->Write(logStr.length(), logStr.c_str());
+    stream->Write(logStr.GetSize(), logStr.c_str());
     if (msg)
     {
-        logStr = xtl::format("%s%s", pad.c_str(),msg);
-        stream->Write(logStr.length(), logStr.c_str());
+        logStr = plString::Format("%s%s", pad.c_str(),msg);
+        stream->Write(logStr.GetSize(), logStr.c_str());
     }
 
-    logStr = xtl::format("%sSDR(%p), desc=%s, showDirty=%d, numVars=%d, vol=%d", pad.c_str(), this, fDescriptor->GetName(), dirtyOnly, numVars+numSDVars, fFlags&kVolatile);
-    stream->Write(logStr.length(), logStr.c_str());
+    logStr = plString::Format("%sSDR(%p), desc=%s, showDirty=%d, numVars=%d, vol=%d", pad.c_str(), this, fDescriptor->GetName(), dirtyOnly, numVars+numSDVars, fFlags&kVolatile);
+    stream->Write(logStr.GetSize(), logStr.c_str());
 
     // dump simple vars
     for(i=0;i<fVarsList.size(); i++)
@@ -808,8 +808,8 @@ void plStateDataRecord::DumpToStream(hsStream* stream, const char* msg, bool dir
         }
     }
 
-    logStr = '\n';
-    stream->Write(logStr.length(), logStr.c_str());
+    logStr = _TEMP_CONVERT_FROM_LITERAL("\n");
+    stream->Write(logStr.GetSize(), logStr.c_str());
 }
 
 void plStateDataRecord::SetFromDefaults(bool timeStampNow)
diff --git a/Sources/Plasma/PubUtilLib/plSDL/plStateVariable.cpp b/Sources/Plasma/PubUtilLib/plSDL/plStateVariable.cpp
index 89b4485a..63469006 100644
--- a/Sources/Plasma/PubUtilLib/plSDL/plStateVariable.cpp
+++ b/Sources/Plasma/PubUtilLib/plSDL/plStateVariable.cpp
@@ -1719,7 +1719,7 @@ bool plSimpleStateVariable::Get(plKey* value, int idx) const
             if (*value)
             {
                 const plUoid& newUoid = (*value)->GetUoid();
-                if (stricmp(newUoid.GetObjectName(), fU[idx].GetObjectName()) != 0)
+                if (newUoid.GetObjectName().Compare(fU[idx].GetObjectName(), plString::kCaseInsensitive) != 0)
                 {
                     // uoid names don't match... chances are the key changed in the local data after the key was written to the sdl
                     // do a search by name, which takes longer, to get the correct key
@@ -1780,7 +1780,7 @@ bool plSimpleStateVariable::Get(plCreatable** value, int idx) const
 
 /////////////////////////////////////////////////////////////
 
-const char* plSimpleStateVariable::GetKeyName(int idx) const
+plString plSimpleStateVariable::GetKeyName(int idx) const
 {
     if (fVar.GetAtomicType()==plVarDescriptor::kKey)
     {
@@ -1790,7 +1790,7 @@ const char* plSimpleStateVariable::GetKeyName(int idx) const
         }
     }
     hsAssert(false, "passing wrong value type to SDL variable"); 
-    return "(nil)";
+    return _TEMP_CONVERT_FROM_LITERAL("(nil)");
 }
 
 #pragma optimize( "g", off )    // disable float optimizations
diff --git a/Sources/Plasma/PubUtilLib/plScene/plPageTreeMgr.cpp b/Sources/Plasma/PubUtilLib/plScene/plPageTreeMgr.cpp
index 9ef6a94c..bc46e908 100644
--- a/Sources/Plasma/PubUtilLib/plScene/plPageTreeMgr.cpp
+++ b/Sources/Plasma/PubUtilLib/plScene/plPageTreeMgr.cpp
@@ -211,7 +211,7 @@ int plPageTreeMgr::IRenderVisList(plPipeline* pipe, hsTArray<plDrawVisList>& lev
         plDrawable* p = sortedDrawList[i].fDrawable;
 
 
-        plProfile_BeginLap(DrawableTime, p->GetKey()->GetUoid().GetObjectName());
+        plProfile_BeginLap(DrawableTime, p->GetKey()->GetUoid().GetObjectName().c_str());
     
         if( sortedDrawList[i].fDrawable->GetNativeProperty(plDrawable::kPropSortSpans) )
         {
@@ -229,7 +229,7 @@ int plPageTreeMgr::IRenderVisList(plPipeline* pipe, hsTArray<plDrawVisList>& lev
 
         }
 
-        plProfile_EndLap(DrawableTime, p->GetKey()->GetUoid().GetObjectName());
+        plProfile_EndLap(DrawableTime, p->GetKey()->GetUoid().GetObjectName().c_str());
     }
 
     return numDrawn;
diff --git a/Sources/Plasma/PubUtilLib/plScene/plPostEffectMod.cpp b/Sources/Plasma/PubUtilLib/plScene/plPostEffectMod.cpp
index 3614ee09..b9e4b911 100644
--- a/Sources/Plasma/PubUtilLib/plScene/plPostEffectMod.cpp
+++ b/Sources/Plasma/PubUtilLib/plScene/plPostEffectMod.cpp
@@ -245,9 +245,9 @@ hsBool plPostEffectMod::MsgReceive(plMessage* msg)
     plRenderMsg* rend = plRenderMsg::ConvertNoRef(msg);
     if( rend && IIsEnabled() )
     {
-        plProfile_BeginLap(PostEffect, this->GetKey()->GetUoid().GetObjectName());
+        plProfile_BeginLap(PostEffect, this->GetKey()->GetUoid().GetObjectName().c_str());
         ISubmitRequest();
-        plProfile_EndLap(PostEffect, this->GetKey()->GetUoid().GetObjectName());
+        plProfile_EndLap(PostEffect, this->GetKey()->GetUoid().GetObjectName().c_str());
 
         return true;
     }
diff --git a/Sources/Plasma/PubUtilLib/plScene/plRelevanceMgr.cpp b/Sources/Plasma/PubUtilLib/plScene/plRelevanceMgr.cpp
index 1b91dd6c..50e6946f 100644
--- a/Sources/Plasma/PubUtilLib/plScene/plRelevanceMgr.cpp
+++ b/Sources/Plasma/PubUtilLib/plScene/plRelevanceMgr.cpp
@@ -149,12 +149,12 @@ hsBool plRelevanceMgr::MsgReceive(plMessage* msg)
     return hsKeyedObject::MsgReceive(msg);
 }
 
-UInt32 plRelevanceMgr::GetIndex(char *regionName)
+UInt32 plRelevanceMgr::GetIndex(const plString &regionName)
 {
     int i;
     for (i = 0; i < fRegions.GetCount(); i++)
     {
-        if (fRegions[i] && !stricmp(regionName, fRegions[i]->GetKeyName()))
+        if (fRegions[i] && !regionName.Compare(fRegions[i]->GetKeyName(), plString::kCaseInsensitive))
             return i + 1;
     }
 
@@ -222,7 +222,7 @@ void plRelevanceMgr::ParseCsvInput(hsStream *s)
                 plRegionInfo *info = TRACKED_NEW plRegionInfo;
                 regions.Append(info);
                 info->fName = hsStrcpy(buff);
-                info->fIndex = GetIndex(buff);
+                info->fIndex = GetIndex(_TEMP_CONVERT_FROM_LITERAL(buff));
             }
         }
         else // parsing actual settings.
@@ -231,7 +231,7 @@ void plRelevanceMgr::ParseCsvInput(hsStream *s)
             if (!toke.Next(buff, kBufSize))
                 continue;
             
-            int rowIndex = GetIndex(buff);
+            int rowIndex = GetIndex(_TEMP_CONVERT_FROM_LITERAL(buff));
             int column = 0;
             while (toke.Next(buff, kBufSize) && column < regions.GetCount())
             {
@@ -248,24 +248,24 @@ void plRelevanceMgr::ParseCsvInput(hsStream *s)
         delete regions[i];
 }
 
-std::string plRelevanceMgr::GetRegionNames(hsBitVector regions)
+plString plRelevanceMgr::GetRegionNames(hsBitVector regions)
 {
-    std::string retVal = "";
+    plString retVal;
     if (regions.IsBitSet(0))
-        retVal = "-Nowhere (0)-";
+        retVal = _TEMP_CONVERT_FROM_LITERAL("-Nowhere (0)-");
 
     for (int i = 0; i < fRegions.GetCount(); ++i)
     {
         if (regions.IsBitSet(i + 1))
         {
-            if (retVal.length() != 0)
-                retVal += ", ";
+            if (!retVal.IsEmpty())
+                retVal += _TEMP_CONVERT_FROM_LITERAL(", ");
             if (fRegions[i])
                 retVal += fRegions[i]->GetKeyName();
         }
     }
 
-    if (retVal.length() == 0)
-        retVal = "<NONE>";
+    if (retVal.IsEmpty())
+        retVal = _TEMP_CONVERT_FROM_LITERAL("<NONE>");
     return retVal;
-}
\ No newline at end of file
+}
diff --git a/Sources/Plasma/PubUtilLib/plScene/plRelevanceMgr.h b/Sources/Plasma/PubUtilLib/plScene/plRelevanceMgr.h
index 24b545b8..c11b2ce2 100644
--- a/Sources/Plasma/PubUtilLib/plScene/plRelevanceMgr.h
+++ b/Sources/Plasma/PubUtilLib/plScene/plRelevanceMgr.h
@@ -80,13 +80,13 @@ public:
     hsBool GetEnabled() { return fEnabled; }
     void SetEnabled(hsBool val) { fEnabled = val; }
 
-    UInt32 GetIndex(char *regionName);
+    UInt32 GetIndex(const plString &regionName);
     void MarkRegion(UInt32 localIdx, UInt32 remoteIdx, hsBool doICare);
     void SetRegionVectors(const hsPoint3 &pos, hsBitVector &regionsImIn, hsBitVector &regionsICareAbout);
     UInt32 GetNumRegions() const; // includes the secret 0 region in its count
     void ParseCsvInput(hsStream *s);
 
-    std::string GetRegionNames(hsBitVector regions);
+    plString GetRegionNames(hsBitVector regions);
 };
 
 #endif // plRelevanceMgr_inc
diff --git a/Sources/Plasma/PubUtilLib/plStatGather/plAutoProfile.cpp b/Sources/Plasma/PubUtilLib/plStatGather/plAutoProfile.cpp
index 75adcc44..dbe53715 100644
--- a/Sources/Plasma/PubUtilLib/plStatGather/plAutoProfile.cpp
+++ b/Sources/Plasma/PubUtilLib/plStatGather/plAutoProfile.cpp
@@ -81,7 +81,7 @@ protected:
     plStringList fAges;
     int fNextAge;
     int fNextSpawnPoint;
-    const char* fLastSpawnPointName;
+    plString fLastSpawnPointName;
     // For profiling a single age
     std::string fAgeName;
     bool fLinkedToSingleAge;
@@ -89,7 +89,7 @@ protected:
 
     UInt64 fLinkTime;
 
-    std::string fStatusMessage;
+    plString fStatusMessage;
 
     void INextProfile();
     bool INextAge();
@@ -115,7 +115,7 @@ plAutoProfile* plAutoProfile::Instance()
 
 ////////////////////////////////////////////////////////////////////////////////
 
-plAutoProfileImp::plAutoProfileImp() : fNextAge(0), fNextSpawnPoint(0), fLastSpawnPointName(nil), fLinkedToSingleAge(false), fJustLinkToAges(false)
+plAutoProfileImp::plAutoProfileImp() : fNextAge(0), fNextSpawnPoint(0), fLinkedToSingleAge(false), fJustLinkToAges(false)
 {
 }
 
@@ -216,10 +216,10 @@ void plAutoProfileImp::INextProfile()
     else
     {
         // Log the stats for this spawn point
-        if (fLastSpawnPointName)
+        if (!fLastSpawnPointName.IsNull())
         {
             const char * ageName = NetCommGetAge()->ageDatasetName;
-            plProfileManagerFull::Instance().LogStats(ageName, fLastSpawnPointName);
+            plProfileManagerFull::Instance().LogStats(ageName, _TEMP_CONVERT_TO_CONST_CHAR(fLastSpawnPointName));
 
             plMipmap mipmap;
             if (plClient::GetInstance()->GetPipeline()->CaptureScreen(&mipmap))
@@ -233,7 +233,7 @@ void plAutoProfileImp::INextProfile()
                 plJPEG::Instance().WriteToFile(fileName, &mipmap);
             }
 
-            fLastSpawnPointName = nil;
+            fLastSpawnPointName = plString::Null;
         }
 
         // Try to go to the next spawn point
@@ -277,8 +277,8 @@ bool plAutoProfileImp::INextAge()
     link.SetLinkingRules(plNetCommon::LinkingRules::kBasicLink);
     plNetLinkingMgr::GetInstance()->LinkToAge(&link);
 
-    fStatusMessage = "Linking to age ";
-    fStatusMessage += ageName;
+    fStatusMessage = _TEMP_CONVERT_FROM_LITERAL("Linking to age ");
+    fStatusMessage += _TEMP_CONVERT_FROM_LITERAL(ageName);
 
     return true;
 }
@@ -298,9 +298,9 @@ bool plAutoProfileImp::INextSpawnPoint()
         const plSpawnModifier* spawnMod = plAvatarMgr::GetInstance()->GetSpawnPoint(fNextSpawnPoint);
         fLastSpawnPointName = spawnMod->GetKeyName();
 
-        if (strncmp(fLastSpawnPointName, kPerfSpawnPrefix, kPerfSpawnLen) == 0)
+        if (fLastSpawnPointName.CompareN(kPerfSpawnPrefix, kPerfSpawnLen) == 0)
         {
-            fStatusMessage = "Profiling spawn point ";
+            fStatusMessage = _TEMP_CONVERT_FROM_LITERAL("Profiling spawn point ");
             fStatusMessage += fLastSpawnPointName;
 
             foundGood = true;
@@ -312,8 +312,8 @@ bool plAutoProfileImp::INextSpawnPoint()
 
     if (!foundGood)
     {
-        fLastSpawnPointName = nil;
-        fStatusMessage = "No profile spawn point found";
+        fLastSpawnPointName = plString::Null;
+        fStatusMessage = _TEMP_CONVERT_FROM_LITERAL("No profile spawn point found");
         return false;
     }
 
@@ -337,7 +337,7 @@ hsBool plAutoProfileImp::MsgReceive(plMessage* msg)
     plEvalMsg* evalMsg = plEvalMsg::ConvertNoRef(msg);
     if (evalMsg)
     {
-        if (fStatusMessage.length() > 0)
+        if (fStatusMessage.GetSize() > 0)
             plDebugText::Instance().DrawString(10, 10, fStatusMessage.c_str());
     }
 
@@ -369,7 +369,7 @@ hsBool plAutoProfileImp::MsgReceive(plMessage* msg)
                 ms);
         }
 
-        fStatusMessage = "Age loaded.  Preparing to profile.";
+        fStatusMessage = _TEMP_CONVERT_FROM_LITERAL("Age loaded.  Preparing to profile.");
 
         // Age is loaded, start profiling in 5 seconds (to make sure the avatar is linked in all the way)
         plTimerCallbackMsg* timerMsg = TRACKED_NEW plTimerCallbackMsg(GetKey());
diff --git a/Sources/Plasma/PubUtilLib/plSurface/hsGMaterial.cpp b/Sources/Plasma/PubUtilLib/plSurface/hsGMaterial.cpp
index fc738d65..ff9b8f45 100644
--- a/Sources/Plasma/PubUtilLib/plSurface/hsGMaterial.cpp
+++ b/Sources/Plasma/PubUtilLib/plSurface/hsGMaterial.cpp
@@ -132,11 +132,11 @@ plLayer* hsGMaterial::MakeBaseLayer()
     
     hsAssert(GetKey(), "All materials need a key (or temp key)");
 
-    char buff[256];
-    if( GetKey()->GetName() )
-        sprintf(buff, "%s_%s", GetKey()->GetName(), "Layer");
+    plString buff;
+    if( !GetKey()->GetName().IsNull() )
+        buff = plString::Format("%s_Layer", GetKey()->GetName().c_str());
     else
-        strcpy(buff, "Layer");
+        buff = _TEMP_CONVERT_FROM_LITERAL("Layer");
     hsgResMgr::ResMgr()->NewKey( buff, newLay, GetKey() != nil ? GetKey()->GetUoid().GetLocation() : plLocation::kGlobalFixedLoc );
 
     // Add layer so we have it now.
@@ -278,7 +278,7 @@ void hsGMaterial::Read(hsStream *stream, hsResMgr *group)
 
 void hsGMaterial::Eval(double secs, UInt32 frame)
 {
-    plProfile_BeginLap(MaterialAnims, GetKeyName());
+    plProfile_BeginLap(MaterialAnims, GetKeyName().c_str());
 
     int i;
     for( i = 0; i < GetNumLayers(); i++ )
@@ -292,7 +292,7 @@ void hsGMaterial::Eval(double secs, UInt32 frame)
             fPiggyBacks[i]->Eval(secs, frame, 0);
     }
 
-    plProfile_EndLap(MaterialAnims, GetKeyName());
+    plProfile_EndLap(MaterialAnims, GetKeyName().c_str());
 }
 
 void hsGMaterial::Reset()
diff --git a/Sources/Plasma/PubUtilLib/plSurface/plGrassShaderMod.cpp b/Sources/Plasma/PubUtilLib/plSurface/plGrassShaderMod.cpp
index 0f3f3c5f..01ec71e9 100644
--- a/Sources/Plasma/PubUtilLib/plSurface/plGrassShaderMod.cpp
+++ b/Sources/Plasma/PubUtilLib/plSurface/plGrassShaderMod.cpp
@@ -226,8 +226,7 @@ void plGrassShaderMod::ISetupShaders()
     if (!fVShader)
     {
         plShader* vShader = TRACKED_NEW plShader;
-        char buff[256];
-        sprintf(buff, "%s_GrassVS", GetKey()->GetName());
+        plString buff = plString::Format("%s_GrassVS", GetKey()->GetName().c_str());
         hsgResMgr::ResMgr()->NewKey(buff, vShader, GetKey()->GetUoid().GetLocation());
         vShader->SetIsPixelShader(false);
         vShader->SetInputFormat(1);
@@ -250,8 +249,7 @@ void plGrassShaderMod::ISetupShaders()
     if (!fPShader)
     {
         plShader* pShader = TRACKED_NEW plShader;
-        char buff[256];
-        sprintf(buff, "%s_GrassPS", GetKey()->GetName());
+        plString buff = plString::Format("%s_GrassPS", GetKey()->GetName().c_str());
         hsgResMgr::ResMgr()->NewKey(buff, pShader, GetKey()->GetUoid().GetLocation());
         pShader->SetIsPixelShader(true);
         pShader->SetNumConsts(0);
diff --git a/Sources/Tools/plResBrowser/plResTreeView.cpp b/Sources/Tools/plResBrowser/plResTreeView.cpp
index b7838971..c0900700 100644
--- a/Sources/Tools/plResBrowser/plResTreeView.cpp
+++ b/Sources/Tools/plResBrowser/plResTreeView.cpp
@@ -164,7 +164,7 @@ class plResDlgLoader : public plRegistryPageIterator, public plRegistryKeyIterat
             }
 
             if( !fFilter )
-                AddLeaf( fTree, fCurrTypeItem, key->GetUoid().GetObjectName(), new plKeyInfo( key, fCurrPage ) );
+                AddLeaf( fTree, fCurrTypeItem, key->GetUoid().GetObjectName().c_str(), new plKeyInfo( key, fCurrPage ) );
             return true;
         }
 };
@@ -236,7 +236,7 @@ void    plResTreeView::IFindNextObject( HWND tree )
         plKeyInfo *keyInfo = (plKeyInfo *)itemInfo.lParam;
         if( keyInfo != nil && keyInfo->fKey != nil )
         {
-            if( StrStrI( keyInfo->fKey->GetUoid().GetObjectName(), gSearchString ) != nil )
+            if( keyInfo->fKey->GetUoid().GetObjectName().Compare( gSearchString, plString::kCaseInsensitive ) >= 0 )
             {
                 /// FOUND
                 TreeView_SelectItem( tree, fFoundItem );
@@ -415,7 +415,7 @@ void    plResTreeView::UpdateInfoDlg( HWND treeCtrl )
                 char    str[ 128 ];
 
 
-                SetDlgItemText( fInfoDlg, IDC_NAME, info->fKey->GetUoid().GetObjectName() );
+                SetDlgItemText( fInfoDlg, IDC_NAME, info->fKey->GetUoid().GetObjectName().c_str() );
 
                 const char *name = plFactory::GetNameOfClass( info->fKey->GetUoid().GetClassType() );
                 sprintf( str, "%s (%d)", name != nil ? name : "<unknown>", info->fKey->GetUoid().GetClassType() );

From 77a31686da5401754eae452a0bc32d3e024bf1c7 Mon Sep 17 00:00:00 2001
From: Michael Hansen <zrax0111@gmail.com>
Date: Sat, 28 Jan 2012 17:36:05 -0800
Subject: [PATCH 05/11] Fix the plString stuff that didn't get caught in the
 merge

---
 Sources/Plasma/CoreLib/hsStream.cpp           |  8 ++--
 Sources/Plasma/CoreLib/plString.cpp           | 40 +++++++++----------
 Sources/Plasma/CoreLib/plString.h             |  9 ++---
 .../Plasma/NucleusLib/pnMessage/plMessage.cpp | 12 +++---
 4 files changed, 34 insertions(+), 35 deletions(-)

diff --git a/Sources/Plasma/CoreLib/hsStream.cpp b/Sources/Plasma/CoreLib/hsStream.cpp
index 9641e57d..18071430 100644
--- a/Sources/Plasma/CoreLib/hsStream.cpp
+++ b/Sources/Plasma/CoreLib/hsStream.cpp
@@ -322,18 +322,18 @@ wchar_t *hsStream::ReadSafeWString()
     return retVal;
 }
 
-UInt32  hsStream::WriteSafeString_TEMP(const plString &string)
+uint32_t hsStream::WriteSafeString_TEMP(const plString &string)
 {
     return WriteSafeString(string.c_str());
 }
 
-UInt32  hsStream::WriteSafeWString_TEMP(const plString &string)
+uint32_t hsStream::WriteSafeWString_TEMP(const plString &string)
 {
     plStringBuffer<wchar_t> wbuffer = string.ToWchar();
     return WriteSafeWString(wbuffer.GetData());
 }
 
-plString    hsStream::ReadSafeString_TEMP()
+plString hsStream::ReadSafeString_TEMP()
 {
     char *buffer = ReadSafeString();
     plString result = plString::FromIso8859_1(buffer);
@@ -341,7 +341,7 @@ plString    hsStream::ReadSafeString_TEMP()
     return result;
 }
 
-plString    hsStream::ReadSafeWString_TEMP()
+plString hsStream::ReadSafeWString_TEMP()
 {
     wchar_t *wbuffer = ReadSafeWString();
     plString result = plString::FromWchar(wbuffer);
diff --git a/Sources/Plasma/CoreLib/plString.cpp b/Sources/Plasma/CoreLib/plString.cpp
index 6bbadc99..da9e7c30 100644
--- a/Sources/Plasma/CoreLib/plString.cpp
+++ b/Sources/Plasma/CoreLib/plString.cpp
@@ -38,7 +38,7 @@ const plString plString::Null;
 #if WCHAR_BYTES == 2
 #define u16slen(str, max) wcsnlen((const wchar_t *)(str), (max))
 #else
-static inline size_t u16slen(const UInt16 *ustr, size_t max)
+static inline size_t u16slen(const uint16_t *ustr, size_t max)
 {
     size_t length = 0;
     for ( ; *ustr++ && max--; ++length)
@@ -83,14 +83,14 @@ void plString::IConvertFromUtf8(const char *utf8, size_t size, bool steal)
                         : plStringBuffer<char>(utf8, size);
 }
 
-void plString::IConvertFromUtf16(const UInt16 *utf16, size_t size)
+void plString::IConvertFromUtf16(const uint16_t *utf16, size_t size)
 {
     if ((long)size < 0)
         size = u16slen(utf16, -(long)size);
 
     // Calculate the UTF-8 size
     size_t convlen = 0;
-    const UInt16 *sp = utf16;
+    const uint16_t *sp = utf16;
     while (sp < utf16 + size) {
         if (*sp >= 0xD800 && *sp <= 0xDFFF) {
             // Surrogate pair
@@ -107,7 +107,7 @@ void plString::IConvertFromUtf16(const UInt16 *utf16, size_t size)
     }
 
     // And perform the actual conversion
-    char *utf8 = TRACKED_NEW char[convlen + 1];
+    char *utf8 = new char[convlen + 1];
     char *dp = utf8;
     sp = utf16;
     while (sp < utf16 + size) {
@@ -154,7 +154,7 @@ void plString::IConvertFromWchar(const wchar_t *wstr, size_t size)
 {
 #if WCHAR_BYTES == 2
     // We assume that if sizeof(wchar_t) == 2, the data is UTF-16 already
-    IConvertFromUtf16((const UInt16 *)wstr, size);
+    IConvertFromUtf16((const uint16_t *)wstr, size);
 #else
     if ((long)size < 0)
         size = wcsnlen(wstr, -(long)size);
@@ -179,7 +179,7 @@ void plString::IConvertFromWchar(const wchar_t *wstr, size_t size)
     }
 
     // And perform the actual conversion
-    char *utf8 = TRACKED_NEW char[convlen + 1];
+    char *utf8 = new char[convlen + 1];
     char *dp = utf8;
     sp = wstr;
     while (sp < wstr + size) {
@@ -227,7 +227,7 @@ void plString::IConvertFromIso8859_1(const char *astr, size_t size)
     }
 
     // And perform the actual conversion
-    char *utf8 = TRACKED_NEW char[convlen + 1];
+    char *utf8 = new char[convlen + 1];
     char *dp = utf8;
     sp = astr;
     while (sp < astr + size) {
@@ -244,10 +244,10 @@ void plString::IConvertFromIso8859_1(const char *astr, size_t size)
     fUtf8Buffer = plStringBuffer<char>::Steal(utf8, convlen);
 }
 
-plStringBuffer<UInt16> plString::ToUtf16() const
+plStringBuffer<uint16_t> plString::ToUtf16() const
 {
     if (IsNull())
-        return plStringBuffer<UInt16>();
+        return plStringBuffer<uint16_t>();
 
     // Calculate the UTF-16 size
     size_t convlen = 0;
@@ -270,8 +270,8 @@ plStringBuffer<UInt16> plString::ToUtf16() const
     }
 
     // And perform the actual conversion
-    UInt16 *ustr = TRACKED_NEW UInt16[convlen + 1];
-    UInt16 *dp = ustr;
+    uint16_t *ustr = new uint16_t[convlen + 1];
+    uint16_t *dp = ustr;
     sp = utf8;
     while (sp < utf8 + srcSize) {
         unsigned int unichar;
@@ -298,14 +298,14 @@ plStringBuffer<UInt16> plString::ToUtf16() const
     }
     ustr[convlen] = 0;
 
-    return plStringBuffer<UInt16>::Steal(ustr, convlen);
+    return plStringBuffer<uint16_t>::Steal(ustr, convlen);
 }
 
 plStringBuffer<wchar_t> plString::ToWchar() const
 {
 #if WCHAR_BYTES == 2
     // We assume that if sizeof(wchar_t) == 2, the data is UTF-16 already
-    plStringBuffer<UInt16> utf16 = ToUtf16();
+    plStringBuffer<uint16_t> utf16 = ToUtf16();
     return *reinterpret_cast<plStringBuffer<wchar_t>*>(&utf16);
 #else
     if (IsNull())
@@ -329,7 +329,7 @@ plStringBuffer<wchar_t> plString::ToWchar() const
     }
 
     // And perform the actual conversion
-    wchar_t *wstr = TRACKED_NEW wchar_t[convlen + 1];
+    wchar_t *wstr = new wchar_t[convlen + 1];
     wchar_t *dp = wstr;
     sp = utf8;
     while (sp < utf8 + srcSize) {
@@ -380,7 +380,7 @@ plStringBuffer<char> plString::ToIso8859_1() const
     }
 
     // And perform the actual conversion
-    char *astr = TRACKED_NEW char[convlen + 1];
+    char *astr = new char[convlen + 1];
     char *dp = astr;
     sp = utf8;
     while (sp < utf8 + srcSize) {
@@ -463,7 +463,7 @@ plString plString::IFormat(const char *fmt, va_list vptr)
         int size = 4096;
         for ( ;; ) {
             va_copy(vptr, vptr_save);
-            char *bigbuffer = TRACKED_NEW char[size];
+            char *bigbuffer = new char[size];
             chars = vsnprintf(bigbuffer, size, fmt, vptr);
             if (chars >= 0)
                 return plString::Steal(bigbuffer);
@@ -473,7 +473,7 @@ plString plString::IFormat(const char *fmt, va_list vptr)
         }
     } else if (chars >= 256) {
         va_copy(vptr, vptr_save);
-        char *bigbuffer = TRACKED_NEW char[chars+1];
+        char *bigbuffer = new char[chars+1];
         vsnprintf(bigbuffer, chars+1, fmt, vptr);
         return plString::Steal(bigbuffer);
     }
@@ -611,7 +611,7 @@ plString plString::Substr(int start, size_t size) const
     if (start == 0 && size == maxSize)
         return *this;
 
-    char *substr = TRACKED_NEW char[size + 1];
+    char *substr = new char[size + 1];
     memcpy(substr, c_str() + start, size);
     substr[size] = 0;
 
@@ -624,7 +624,7 @@ plString plString::Substr(int start, size_t size) const
 plString &plString::operator+=(const plString &str)
 {
     size_t catsize = GetSize() + str.GetSize();
-    char *catstr = TRACKED_NEW char[catsize + 1];
+    char *catstr = new char[catsize + 1];
     memcpy(catstr, s_str(), GetSize());
     memcpy(catstr + GetSize(), str.s_str(), str.GetSize());
     catstr[catsize] = 0;
@@ -635,7 +635,7 @@ plString &plString::operator+=(const plString &str)
 plString operator+(const plString &left, const plString &right)
 {
     size_t catsize = left.GetSize() + right.GetSize();
-    char *catstr = TRACKED_NEW char[catsize + 1];
+    char *catstr = new char[catsize + 1];
     memcpy(catstr, left.s_str(), left.GetSize());
     memcpy(catstr + left.GetSize(), right.s_str(), right.GetSize());
     catstr[catsize] = 0;
diff --git a/Sources/Plasma/CoreLib/plString.h b/Sources/Plasma/CoreLib/plString.h
index fc821c5c..081e1d60 100644
--- a/Sources/Plasma/CoreLib/plString.h
+++ b/Sources/Plasma/CoreLib/plString.h
@@ -27,8 +27,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 #ifndef plString_Defined
 #define plString_Defined
 
-#include "hsTypes.h"
-#include "hsUtils.h"
+#include "HeadSpin.h"
 #include <stddef.h>
 #include <vector>
 #include <functional>
@@ -133,7 +132,7 @@ private:
     plStringBuffer<char> fUtf8Buffer;
 
     void IConvertFromUtf8(const char *utf8, size_t size, bool steal);
-    void IConvertFromUtf16(const UInt16 *utf16, size_t size);
+    void IConvertFromUtf16(const uint16_t *utf16, size_t size);
     void IConvertFromWchar(const wchar_t *wstr, size_t size);
     void IConvertFromIso8859_1(const char *astr, size_t size);
 
@@ -157,7 +156,7 @@ public:
         return str;
     }
 
-    static inline plString FromUtf16(const UInt16 *utf16, size_t size = kSizeAuto)
+    static inline plString FromUtf16(const uint16_t *utf16, size_t size = kSizeAuto)
     {
         plString str;
         str.IConvertFromUtf16(utf16, size);
@@ -183,7 +182,7 @@ public:
     char CharAt(size_t position) const { return c_str()[position]; }
 
     plStringBuffer<char> ToUtf8() const { return fUtf8Buffer; }
-    plStringBuffer<UInt16> ToUtf16() const;
+    plStringBuffer<uint16_t> ToUtf16() const;
     plStringBuffer<wchar_t> ToWchar() const;
     plStringBuffer<char> ToIso8859_1() const;
 
diff --git a/Sources/Plasma/NucleusLib/pnMessage/plMessage.cpp b/Sources/Plasma/NucleusLib/pnMessage/plMessage.cpp
index daa1395e..5796fe6a 100644
--- a/Sources/Plasma/NucleusLib/pnMessage/plMessage.cpp
+++ b/Sources/Plasma/NucleusLib/pnMessage/plMessage.cpp
@@ -256,13 +256,13 @@ int plMsgStdStringHelper::PokeBig(const char * buf, uint32_t bufsz, hsStream* st
     return stream->GetPosition();
 }
 
-int plMsgStdStringHelper::Poke(const plString & stringref, hsStream* stream, const UInt32 peekOptions)
+int plMsgStdStringHelper::Poke(const plString & stringref, hsStream* stream, const uint32_t peekOptions)
 {
     std::string temp = stringref.c_str();
     return Poke(temp, stream, peekOptions);
 }
 
-int plMsgStdStringHelper::PokeBig(const plString & stringref, hsStream* stream, const UInt32 peekOptions)
+int plMsgStdStringHelper::PokeBig(const plString & stringref, hsStream* stream, const uint32_t peekOptions)
 {
     std::string temp = stringref.c_str();
     return PokeBig(temp, stream, peekOptions);
@@ -313,7 +313,7 @@ int plMsgStdStringHelper::PeekBig(std::string  & stringref, hsStream* stream, co
     return stream->GetPosition();
 }
 
-int plMsgStdStringHelper::Peek(plString & stringref, hsStream* stream, const UInt32 peekOptions)
+int plMsgStdStringHelper::Peek(plString & stringref, hsStream* stream, const uint32_t peekOptions)
 {
     std::string temp;
     int pos = Peek(temp, stream, peekOptions);
@@ -321,7 +321,7 @@ int plMsgStdStringHelper::Peek(plString & stringref, hsStream* stream, const UIn
     return pos;
 }
 
-int plMsgStdStringHelper::PeekBig(plString & stringref, hsStream* stream, const UInt32 peekOptions)
+int plMsgStdStringHelper::PeekBig(plString & stringref, hsStream* stream, const uint32_t peekOptions)
 {
     std::string temp;
     int pos = PeekBig(temp, stream, peekOptions);
@@ -399,12 +399,12 @@ int plMsgCStringHelper::Peek(char *& str, hsStream* stream, const uint32_t peekO
     return stream->GetPosition();
 }
 
-int plMsgCStringHelper::Poke(const plString & str, hsStream* stream, const UInt32 peekOptions)
+int plMsgCStringHelper::Poke(const plString & str, hsStream* stream, const uint32_t peekOptions)
 {
     return Poke(str.c_str(), stream, peekOptions);
 }
 
-int plMsgCStringHelper::Peek(plString & str, hsStream* stream, const UInt32 peekOptions)
+int plMsgCStringHelper::Peek(plString & str, hsStream* stream, const uint32_t peekOptions)
 {
     char * temp = nil;
     int pos = Peek(temp, stream, peekOptions);

From bb0ed04a52a3a65b6665a62c542e64b0ee55b3c0 Mon Sep 17 00:00:00 2001
From: Michael Hansen <zrax0111@gmail.com>
Date: Sun, 29 Jan 2012 17:00:13 -0800
Subject: [PATCH 06/11] Fix some things which got missed from debug builds

---
 Sources/Plasma/CoreLib/plString.cpp           |  2 ++
 Sources/Plasma/CoreLib/plString.h             |  7 +++++++
 .../pfGameGUIMgr/pfGUIDialogMod.cpp           |  2 +-
 .../NucleusLib/pnDispatch/plDispatch.cpp      |  2 +-
 .../pnKeyedObject/hsKeyedObject.cpp           |  2 +-
 .../Plasma/NucleusLib/pnKeyedObject/plKey.h   |  4 ++--
 .../NucleusLib/pnKeyedObject/plKeyImp.cpp     |  1 -
 .../NucleusLib/pnKeyedObject/plUoid.cpp       |  2 +-
 .../pnNetCommon/plSynchedObject.cpp           |  2 +-
 Sources/Plasma/NucleusLib/pnUUID/pnUUID.h     |  1 +
 .../Plasma/PubUtilLib/plGImage/plMipmap.cpp   |  6 +++---
 Sources/Plasma/PubUtilLib/plGImage/plMipmap.h | 19 ++++++++++---------
 .../PubUtilLib/plNetClient/plNetClientMgr.cpp |  2 +-
 .../plNetClient/plNetClientMgrVoice.cpp       |  2 +-
 .../PubUtilLib/plResMgr/plResManager.cpp      |  8 ++++----
 15 files changed, 36 insertions(+), 26 deletions(-)

diff --git a/Sources/Plasma/CoreLib/plString.cpp b/Sources/Plasma/CoreLib/plString.cpp
index da9e7c30..e58e204f 100644
--- a/Sources/Plasma/CoreLib/plString.cpp
+++ b/Sources/Plasma/CoreLib/plString.cpp
@@ -543,6 +543,8 @@ int plString::Find(const char *str, CaseSensitivity sense) const
                 return cp - c_str();
             ++cp;
         }
+
+        return -1;
     }
 }
 
diff --git a/Sources/Plasma/CoreLib/plString.h b/Sources/Plasma/CoreLib/plString.h
index 081e1d60..212a0d5a 100644
--- a/Sources/Plasma/CoreLib/plString.h
+++ b/Sources/Plasma/CoreLib/plString.h
@@ -307,6 +307,13 @@ public:
             return *this;
         }
 
+        iterator operator++(int)
+        {
+            iterator iter_save = *this;
+            (void) operator++();
+            return iter_save;
+        }
+
         iterator &operator+=(size_t delta)
         {
             while (delta) {
diff --git a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIDialogMod.cpp b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIDialogMod.cpp
index 0171f9a1..fb12c0da 100644
--- a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIDialogMod.cpp
+++ b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIDialogMod.cpp
@@ -498,7 +498,7 @@ static bool     showBounds = false;
 if( showBounds )
 {
     const hsBounds3 &bnds = fMousedCtrl->GetBounds();
-    plDebugText::Instance().DrawString( (uint16_t)(bnds.GetMins().fX), (uint16_t)(bnds.GetMins().fY), fMousedCtrl->GetKeyName(), (uint32_t)0xffffff00 );
+    plDebugText::Instance().DrawString( (uint16_t)(bnds.GetMins().fX), (uint16_t)(bnds.GetMins().fY), _TEMP_CONVERT_TO_CONST_CHAR( fMousedCtrl->GetKeyName() ), (uint32_t)0xffffff00 );
 }
 #endif
 
diff --git a/Sources/Plasma/NucleusLib/pnDispatch/plDispatch.cpp b/Sources/Plasma/NucleusLib/pnDispatch/plDispatch.cpp
index 4b3a2b3d..59b3cd81 100644
--- a/Sources/Plasma/NucleusLib/pnDispatch/plDispatch.cpp
+++ b/Sources/Plasma/NucleusLib/pnDispatch/plDispatch.cpp
@@ -332,7 +332,7 @@ void plDispatch::IMsgDispatch()
                         {
                             hsLogEntry(plNetObjectDebuggerBase::GetInstance()->LogMsg(
                                 xtl::format("<RCV> object:%s, GameMessage %s st=%.3f rt=%.3f", 
-                                ko->GetKeyName(), msg->ClassName(), hsTimer::GetSysSeconds(), hsTimer::GetSeconds()).c_str()));
+                                ko->GetKeyName().c_str(), msg->ClassName(), hsTimer::GetSysSeconds(), hsTimer::GetSeconds()).c_str()));
                         }
                     }
                 }
diff --git a/Sources/Plasma/NucleusLib/pnKeyedObject/hsKeyedObject.cpp b/Sources/Plasma/NucleusLib/pnKeyedObject/hsKeyedObject.cpp
index 3c7b10d3..2562d456 100644
--- a/Sources/Plasma/NucleusLib/pnKeyedObject/hsKeyedObject.cpp
+++ b/Sources/Plasma/NucleusLib/pnKeyedObject/hsKeyedObject.cpp
@@ -145,7 +145,7 @@ void hsKeyedObject::UnRegisterAsManual(plUoid& inUoid)
 #if !HS_BUILD_FOR_UNIX      // disable for unix servers
             hsAssert(false,
                 plString::Format("Request to Unregister wrong FixedKey, keyName=%s, inUoid=%s, myUoid=%s",
-                fpKey->GetName() ? fpKey->GetName() : "?", inUoid.StringIze().c_str(), myUoid.StringIze().c_str()).c_str());
+                    fpKey->GetName().s_str("?"), inUoid.StringIze().c_str(), myUoid.StringIze().c_str()).c_str());
 #endif
         }
         ((plKeyImp*)fpKey)->UnRegister();
diff --git a/Sources/Plasma/NucleusLib/pnKeyedObject/plKey.h b/Sources/Plasma/NucleusLib/pnKeyedObject/plKey.h
index 23360925..5e8c1ebc 100644
--- a/Sources/Plasma/NucleusLib/pnKeyedObject/plKey.h
+++ b/Sources/Plasma/NucleusLib/pnKeyedObject/plKey.h
@@ -44,6 +44,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 
 #include "HeadSpin.h"
 #include "plRefFlags.h"
+#include "plString.h"
 
 class hsKeyedObject;
 class plRefMsg;
@@ -55,7 +56,6 @@ class hsBitVector;
 
 class plKeyData;
 class plKeyImp;
-class plString;
 
 class plKey 
 {
@@ -131,7 +131,7 @@ protected:
 
 #ifdef HS_DEBUGGING
     // Debugging info fields
-    const char* fIDName;
+    plString    fIDName;
     const char* fClassType;
 #endif
 
diff --git a/Sources/Plasma/NucleusLib/pnKeyedObject/plKeyImp.cpp b/Sources/Plasma/NucleusLib/pnKeyedObject/plKeyImp.cpp
index b0fb1193..7400f8a3 100644
--- a/Sources/Plasma/NucleusLib/pnKeyedObject/plKeyImp.cpp
+++ b/Sources/Plasma/NucleusLib/pnKeyedObject/plKeyImp.cpp
@@ -81,7 +81,6 @@ plKeyImp::plKeyImp() :
     fCloneOwner(nil)
 {
 #ifdef HS_DEBUGGING
-    fIDName = nil;
     fClassType = nil;
 #endif
 }
diff --git a/Sources/Plasma/NucleusLib/pnKeyedObject/plUoid.cpp b/Sources/Plasma/NucleusLib/pnKeyedObject/plUoid.cpp
index 9d15390d..c1ebce7e 100644
--- a/Sources/Plasma/NucleusLib/pnKeyedObject/plUoid.cpp
+++ b/Sources/Plasma/NucleusLib/pnKeyedObject/plUoid.cpp
@@ -159,7 +159,7 @@ plUoid::~plUoid()
 
 void plUoid::Read(hsStream* s)
 {
-    hsAssert(fObjectName == nil, "Reading over an old uoid? You're just asking for trouble, aren't you?");
+    hsAssert(fObjectName.IsNull(), "Reading over an old uoid? You're just asking for trouble, aren't you?");
 
     // first read contents flags
     uint8_t contents = s->ReadByte();
diff --git a/Sources/Plasma/NucleusLib/pnNetCommon/plSynchedObject.cpp b/Sources/Plasma/NucleusLib/pnNetCommon/plSynchedObject.cpp
index 5e650637..7c9750d3 100644
--- a/Sources/Plasma/NucleusLib/pnNetCommon/plSynchedObject.cpp
+++ b/Sources/Plasma/NucleusLib/pnNetCommon/plSynchedObject.cpp
@@ -236,7 +236,7 @@ hsBool plSynchedObject::DirtySynchState(const char* SDLStateName, uint32_t synch
         {
             if (plNetClientApp::GetInstance())
                 plNetClientApp::GetInstance()->DebugMsg("Queueing SDL state with 'maybe' ownership, obj %s, sdl %s",
-                    GetKeyName(), SDLStateName);
+                    GetKeyName().c_str(), SDLStateName);
         }
     }
     
diff --git a/Sources/Plasma/NucleusLib/pnUUID/pnUUID.h b/Sources/Plasma/NucleusLib/pnUUID/pnUUID.h
index 48afd3be..dd2aed4a 100644
--- a/Sources/Plasma/NucleusLib/pnUUID/pnUUID.h
+++ b/Sources/Plasma/NucleusLib/pnUUID/pnUUID.h
@@ -49,6 +49,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 #endif
 
 class hsStream;
+class plString;
 
 class plUUID
 {
diff --git a/Sources/Plasma/PubUtilLib/plGImage/plMipmap.cpp b/Sources/Plasma/PubUtilLib/plGImage/plMipmap.cpp
index 0db6ed19..9da2f81b 100644
--- a/Sources/Plasma/PubUtilLib/plGImage/plMipmap.cpp
+++ b/Sources/Plasma/PubUtilLib/plGImage/plMipmap.cpp
@@ -2121,7 +2121,7 @@ hsBool  plMipmap::ResizeNicely( uint16_t newWidth, uint16_t newHeight, plMipmap:
 //// Debug Mipmap Memory Leak Tracker /////////////////////////////////////////
 
 plMipmap::plRecord  *plMipmap::fRecords = nil;
-uint32_t              plMipmap::fNumMipmaps = 0;
+uint32_t            plMipmap::fNumMipmaps = 0;
 
 void    plMipmap::IAddToMemRecord( plMipmap *mip, plRecord::Method method )
 {
@@ -2136,9 +2136,9 @@ void    plMipmap::IAddToMemRecord( plMipmap *mip, plRecord::Method method )
     newRecord->fNumLevels = mip->fNumLevels;
     newRecord->fRowBytes = mip->fRowBytes;
     if( mip->GetKey() )
-        strcpy( newRecord->fKeyName, mip->GetKeyName() );
+        newRecord->fKeyName = mip->GetKeyName();
     else
-        strcpy( newRecord->fKeyName, "<noKey>" );
+        newRecord->fKeyName = _TEMP_CONVERT_FROM_LITERAL( "<noKey>" );
     if( mip->fCompressionType != kDirectXCompression )
         newRecord->fUncompressedInfo.fType = mip->fUncompressedInfo.fType;
     else
diff --git a/Sources/Plasma/PubUtilLib/plGImage/plMipmap.h b/Sources/Plasma/PubUtilLib/plGImage/plMipmap.h
index 64fd1b91..b2e5fab1 100644
--- a/Sources/Plasma/PubUtilLib/plGImage/plMipmap.h
+++ b/Sources/Plasma/PubUtilLib/plGImage/plMipmap.h
@@ -55,6 +55,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 #define _plMipmap_h
 
 #include "plBitmap.h"
+#include "plString.h"
 
 #ifdef HS_DEBUGGING
     #define ASSERT_PIXELSIZE(bitmap, pixelsize)     hsAssert((bitmap)->fPixelSize == (pixelsize), "pixelSize mismatch")
@@ -291,13 +292,13 @@ class plMipmap : public plBitmap
         //// Protected Members ////
 
         void        *fImage;
-        uint32_t      fWidth, fHeight, fRowBytes, fTotalSize;
-        uint8_t       fNumLevels;
-        uint32_t      *fLevelSizes;
+        uint32_t    fWidth, fHeight, fRowBytes, fTotalSize;
+        uint8_t     fNumLevels;
+        uint32_t    *fLevelSizes;
 
         void        *fCurrLevelPtr;
-        uint8_t       fCurrLevel;
-        uint32_t      fCurrLevelWidth, fCurrLevelHeight, fCurrLevelRowBytes;
+        uint8_t     fCurrLevel;
+        uint32_t    fCurrLevelWidth, fCurrLevelHeight, fCurrLevelRowBytes;
 
         void    IReadRawImage( hsStream *stream );
         void    IWriteRawImage( hsStream *stream );
@@ -335,11 +336,11 @@ class plMipmap : public plBitmap
                 plRecord    *fNext;
                 plRecord    **fBackPtr;
 
-                char        fKeyName[ 256 ];
+                plString    fKeyName;
                 void        *fImage;
-                uint32_t      fWidth, fHeight, fRowBytes;
-                uint8_t       fNumLevels; 
-                uint8_t       fCompressionType;
+                uint32_t    fWidth, fHeight, fRowBytes;
+                uint8_t     fNumLevels;
+                uint8_t     fCompressionType;
                 union 
                 {
                     DirectXInfo         fDirectXInfo;
diff --git a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgr.cpp b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgr.cpp
index 1a0fb70a..4550df92 100644
--- a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgr.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgr.cpp
@@ -1390,7 +1390,7 @@ bool plNetClientMgr::IHandlePlayerPageMsg(plPlayerPageMsg *playerMsg)
                 if( idx != -1 )
                 {
                     hsAssert(playerKey, "NIL KEY?");
-                    hsAssert(playerKey->GetName(), "UNNAMED KEY");
+                    hsAssert(!playerKey->GetName().IsNull(), "UNNAMED KEY");
                     fTransport.GetMember(idx)->SetAvatarKey(playerKey);
                 }
                 else
diff --git a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrVoice.cpp b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrVoice.cpp
index c4f1fffc..e02efb53 100644
--- a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrVoice.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrVoice.cpp
@@ -194,7 +194,7 @@ hsBool plNetClientMgr::IApplyNewListenList(std::vector<DistSqInfo>& newListenLis
             GetListenList()->AddMember(newListenList[i].fMbr);
 #ifdef HS_DEBUGGING
             DebugMsg("\tLL Member %d, name=%s, cNum=%d, dist=%f\n", 
-                i, newListenList[i].fMbr->AsStdString().c_str(), 
+                i, newListenList[i].fMbr->AsString().c_str(),
                 newListenList[i].fMbr->GetPlayerID(), newListenList[i].fDistSq);
 #endif
         }
diff --git a/Sources/Plasma/PubUtilLib/plResMgr/plResManager.cpp b/Sources/Plasma/PubUtilLib/plResMgr/plResManager.cpp
index b522ee12..f2be393e 100644
--- a/Sources/Plasma/PubUtilLib/plResMgr/plResManager.cpp
+++ b/Sources/Plasma/PubUtilLib/plResMgr/plResManager.cpp
@@ -370,7 +370,7 @@ hsBool plResManager::IReadObject(plKeyImp* pKey, hsStream *stream)
     if (pKey->GetStartPos() == uint32_t(-1) || pKey->GetDataLen() == uint32_t(-1))
         return false; // Try to recover from this by just not reading an object
 
-    kResMgrLog(3, ILog(3, "   Reading object %s::%s", plFactory::GetNameOfClass(pKey->GetUoid().GetClassType()), pKey->GetUoid().GetObjectName()));
+    kResMgrLog(3, ILog(3, "   Reading object %s::%s", plFactory::GetNameOfClass(pKey->GetUoid().GetClassType()), pKey->GetUoid().GetObjectName().c_str()));
 
     const plUoid& uoid = pKey->GetUoid();
 
@@ -440,7 +440,7 @@ hsBool plResManager::IReadObject(plKeyImp* pKey, hsStream *stream)
         fCurCloneID = 0;
     }
 
-    kResMgrLog(4, ILog(4, "   ...Read complete for object %s::%s", plFactory::GetNameOfClass(pKey->GetUoid().GetClassType()), pKey->GetUoid().GetObjectName()));
+    kResMgrLog(4, ILog(4, "   ...Read complete for object %s::%s", plFactory::GetNameOfClass(pKey->GetUoid().GetClassType()), pKey->GetUoid().GetObjectName().c_str()));
 
     if (fLogReadTimes)
     {
@@ -449,7 +449,7 @@ hsBool plResManager::IReadObject(plKeyImp* pKey, hsStream *stream)
         ourTime -= childTime;
 
         plStatusLog::AddLineS("readtimings.log", plStatusLog::kWhite, "%s, %s, %u, %.1f",
-            pKey->GetUoid().GetObjectName(),
+            pKey->GetUoid().GetObjectName().c_str(),
             plFactory::GetNameOfClass(pKey->GetUoid().GetClassType()),
             pKey->GetDataLen(),
             hsTimer::FullTicksToMs(ourTime));
@@ -722,7 +722,7 @@ plKey plResManager::ReadKeyNotifyMe(hsStream* stream, plRefMsg* msg, plRefFlags:
     }
     if(key->GetUoid().GetLoadMask().DontLoad())
     {
-        hsStatusMessageF("%s being skipped because of load mask", key->GetName());
+        hsStatusMessageF("%s being skipped because of load mask", key->GetName().c_str());
         hsRefCnt_SafeUnRef(msg);
         return nil;
     }

From be4b0732d54d1275742b86daa958e267ef8c98ef Mon Sep 17 00:00:00 2001
From: Michael Hansen <zrax0111@gmail.com>
Date: Sun, 5 Feb 2012 21:53:54 -0800
Subject: [PATCH 07/11] Fix string usage that was broken from enabling the Max
 plugin build

---
 Sources/Plasma/CoreLib/hsStream.cpp           |   9 +-
 Sources/Plasma/CoreLib/hsStream.h             |   4 +-
 Sources/Plasma/CoreLib/plString.cpp           |  21 +++
 Sources/Plasma/CoreLib/plString.h             |   6 +-
 .../pfConsole/pfAvatarConsoleCommands.cpp     |  18 +-
 .../pfConsole/pfConsoleCommands.cpp           |  10 +-
 .../pfGameGUIMgr/pfGUIButtonMod.cpp           |  34 +---
 .../FeatureLib/pfGameGUIMgr/pfGUIButtonMod.h  |   9 +-
 .../pfGameGUIMgr/pfGUICheckBoxCtrl.cpp        |  19 +-
 .../pfGameGUIMgr/pfGUICheckBoxCtrl.h          |   7 +-
 .../FeatureLib/pfGameGUIMgr/pfGUIKnobCtrl.cpp |  19 +-
 .../FeatureLib/pfGameGUIMgr/pfGUIKnobCtrl.h   |  11 +-
 .../pfGameGUIMgr/pfGUIProgressCtrl.cpp        |  19 +-
 .../pfGameGUIMgr/pfGUIProgressCtrl.h          |   9 +-
 .../pfJournalBook/pfJournalBook.cpp           |   4 +-
 .../Plasma/FeatureLib/pfPython/cyAvatar.cpp   |   6 +-
 Sources/Plasma/FeatureLib/pfPython/cyAvatar.h |   4 +-
 .../FeatureLib/pfPython/cyAvatarGlue.cpp      |   6 +-
 .../FeatureLib/pfPython/plPythonFileMod.cpp   |  10 +-
 .../FeatureLib/pfPython/plPythonParameter.h   |  37 ++--
 .../FeatureLib/pfPython/pyCritterBrain.cpp    |   8 +-
 .../FeatureLib/pfPython/pyCritterBrain.h      |   2 +-
 .../NucleusLib/pnKeyedObject/plUoid.cpp       |   2 +-
 .../NucleusLib/pnUtils/Private/pnUtSubst.cpp  |   3 +-
 .../Plasma/PubUtilLib/plAvatar/plAGAnim.cpp   |  78 ++++----
 Sources/Plasma/PubUtilLib/plAvatar/plAGAnim.h |  48 ++---
 .../PubUtilLib/plAvatar/plAGAnimInstance.cpp  |  18 +-
 .../PubUtilLib/plAvatar/plAGAnimInstance.h    |   8 +-
 .../PubUtilLib/plAvatar/plAGApplicator.cpp    |  19 +-
 .../PubUtilLib/plAvatar/plAGApplicator.h      |  15 +-
 .../PubUtilLib/plAvatar/plAGChannel.cpp       |   4 +-
 .../Plasma/PubUtilLib/plAvatar/plAGChannel.h  |   7 +-
 .../PubUtilLib/plAvatar/plAGMasterMod.cpp     |  38 ++--
 .../PubUtilLib/plAvatar/plAGMasterMod.h       |  16 +-
 .../PubUtilLib/plAvatar/plAGModifier.cpp      |  19 +-
 .../Plasma/PubUtilLib/plAvatar/plAGModifier.h |  12 +-
 .../PubUtilLib/plAvatar/plAnimStage.cpp       |   2 +-
 .../PubUtilLib/plAvatar/plArmatureMod.cpp     |  92 +++++-----
 .../PubUtilLib/plAvatar/plArmatureMod.h       |  24 +--
 .../PubUtilLib/plAvatar/plAvBehaviors.cpp     |   4 +-
 .../PubUtilLib/plAvatar/plAvBrainClimb.cpp    |   4 +-
 .../PubUtilLib/plAvatar/plAvBrainCritter.cpp  |   8 +-
 .../PubUtilLib/plAvatar/plAvBrainCritter.h    |   2 +-
 .../PubUtilLib/plAvatar/plAvBrainHuman.cpp    |  17 +-
 .../PubUtilLib/plAvatar/plAvTaskSeek.cpp      |   2 +-
 .../PubUtilLib/plAvatar/plAvatarMgr.cpp       |   2 +-
 .../PubUtilLib/plAvatar/plAvatarTasks.cpp     |  67 +++----
 .../PubUtilLib/plAvatar/plAvatarTasks.h       |  26 ++-
 .../PubUtilLib/plAvatar/plCoopCoordinator.cpp |  14 +-
 .../PubUtilLib/plAvatar/plCoopCoordinator.h   |   5 +-
 .../PubUtilLib/plAvatar/plOneShotMod.cpp      |   3 +-
 .../PubUtilLib/plAvatar/plSittingModifier.cpp |   6 +-
 .../plDrawable/plDrawableSpansExport.cpp      |   8 +-
 .../PubUtilLib/plDrawable/plGeometrySpan.cpp  |   2 +-
 .../PubUtilLib/plDrawable/plGeometrySpan.h    |  36 ++--
 .../PubUtilLib/plMessage/plAnimCmdMsg.cpp     |  41 ++---
 .../PubUtilLib/plMessage/plAnimCmdMsg.h       |  38 ++--
 .../PubUtilLib/plMessage/plAvatarMsg.cpp      |  12 +-
 .../Plasma/PubUtilLib/plMessage/plAvatarMsg.h |   4 +-
 .../plMessage/plOneShotCallbacks.cpp          |   9 +-
 .../PubUtilLib/plMessage/plOneShotCallbacks.h |   6 +-
 .../plModifier/plAxisAnimModifier.cpp         |   8 +-
 .../plModifier/plAxisAnimModifier.h           |   7 +-
 .../PubUtilLib/plSurface/plLayerAnimation.cpp |   4 +-
 .../PubUtilLib/plSurface/plLayerAnimation.h   |  12 +-
 Sources/Tools/MaxComponent/plAGComponents.cpp |  26 +--
 Sources/Tools/MaxComponent/plAnimCompProc.cpp |   7 +-
 .../Tools/MaxComponent/plAnimComponent.cpp    |  43 ++---
 Sources/Tools/MaxComponent/plAnimComponent.h  |   4 +-
 .../MaxComponent/plAnimEventComponent.cpp     |  36 ++--
 .../Tools/MaxComponent/plAnimObjInterface.h   |   3 +-
 .../Tools/MaxComponent/plAudioComponents.cpp  |  44 ++---
 Sources/Tools/MaxComponent/plAutoUIParams.cpp |   4 +-
 .../Tools/MaxComponent/plAvatarComponent.cpp  |  22 +--
 .../MaxComponent/plClickDragComponent.cpp     |   6 +-
 .../Tools/MaxComponent/plComponentBase.cpp    |  10 +-
 Sources/Tools/MaxComponent/plComponentBase.h  |   2 +-
 .../Tools/MaxComponent/plComponentTools.cpp   |   6 +-
 Sources/Tools/MaxComponent/plComponentTools.h |  12 +-
 .../MaxComponent/plFootstepComponent.cpp      |   2 +-
 .../Tools/MaxComponent/plGUIComponents.cpp    |   8 +-
 .../MaxComponent/plInventoryObjComponent.cpp  |   3 +-
 Sources/Tools/MaxComponent/plMaxAnimUtils.cpp |  31 ++--
 Sources/Tools/MaxComponent/plMaxAnimUtils.h   |   9 +-
 .../Tools/MaxComponent/plNotetrackAnim.cpp    |  48 ++---
 Sources/Tools/MaxComponent/plNotetrackAnim.h  |  22 +--
 Sources/Tools/MaxComponent/plNotetrackDlg.cpp |  14 +-
 .../MaxComponent/plObjectFlockerComponent.cpp |   2 +-
 .../MaxComponent/plParticleComponents.cpp     |   6 +-
 .../MaxComponent/plPhysicalComponents.cpp     |   6 +-
 .../MaxComponent/plPythonFileComponent.cpp    |  22 +--
 .../Tools/MaxComponent/plResponderAnim.cpp    |  22 +--
 Sources/Tools/MaxComponent/plResponderCmd.h   |   6 +-
 .../MaxComponent/plResponderComponent.cpp     |   6 +-
 .../Tools/MaxComponent/plResponderLink.cpp    |   2 +-
 Sources/Tools/MaxComponent/plResponderMtl.cpp |  46 +++--
 Sources/Tools/MaxComponent/plResponderMtl.h   |   6 +-
 .../Tools/MaxComponent/plResponderWait.cpp    |   6 +-
 Sources/Tools/MaxComponent/plResponderWait.h  |   3 +-
 .../MaxComponent/plSoftVolumeComponent.cpp    |   8 +-
 .../Tools/MaxComponent/plTypesComponents.cpp  |   9 +-
 .../MaxComponent/plVolumeGadgetComponent.cpp  |  11 +-
 .../Tools/MaxComponent/plWaterComponent.cpp   |   4 +-
 .../Tools/MaxConvert/hsControlConverter.cpp   |   2 +-
 Sources/Tools/MaxConvert/hsConverterUtils.cpp |   2 +-
 .../Tools/MaxConvert/hsMaterialConverter.cpp  | 168 +++++++++---------
 .../Tools/MaxConvert/hsMaterialConverter.h    |  31 ++--
 Sources/Tools/MaxConvert/plBitmapCreator.cpp  |  17 +-
 Sources/Tools/MaxConvert/plBitmapCreator.h    |   2 +-
 Sources/Tools/MaxConvert/plClusterUtil.cpp    |   3 +-
 Sources/Tools/MaxConvert/plLayerConverter.cpp |  45 +++--
 Sources/Tools/MaxConvert/plLayerConverter.h   |  11 +-
 Sources/Tools/MaxConvert/plLightMapGen.cpp    |  15 +-
 Sources/Tools/MaxMain/plCommonObjLib.cpp      |   4 +-
 Sources/Tools/MaxMain/plCommonObjLib.h        |   4 +-
 Sources/Tools/MaxMain/plMaxNode.cpp           |  75 ++++----
 Sources/Tools/MaxMain/plMaxNode.h             |   4 +-
 Sources/Tools/MaxMain/plPluginResManager.cpp  |   3 +-
 Sources/Tools/MaxMain/plTextureExportLog.cpp  |   2 +-
 .../MaxPlasmaMtls/Layers/plPlasmaMAXLayer.cpp |   5 +-
 .../Materials/plAnimStealthConvert.cpp        |  29 ++-
 .../Materials/plAnimStealthNode.cpp           |  25 ++-
 .../Materials/plAnimStealthNode.h             |  28 +--
 .../MaxPlasmaMtls/Materials/plBumpMtl.cpp     |   2 +-
 .../MaxPlasmaMtls/Materials/plDecalMtl.cpp    |   2 +-
 .../Materials/plPassAnimDlgProc.cpp           |   2 +-
 .../MaxPlasmaMtls/Materials/plPassMtl.cpp     |   2 +-
 .../MaxPlasmaMtls/Materials/plPassMtlBase.cpp |  22 +--
 .../MaxPlasmaMtls/Materials/plPassMtlBase.h   |   5 +-
 129 files changed, 952 insertions(+), 1109 deletions(-)

diff --git a/Sources/Plasma/CoreLib/hsStream.cpp b/Sources/Plasma/CoreLib/hsStream.cpp
index 18071430..257511bf 100644
--- a/Sources/Plasma/CoreLib/hsStream.cpp
+++ b/Sources/Plasma/CoreLib/hsStream.cpp
@@ -322,15 +322,14 @@ wchar_t *hsStream::ReadSafeWString()
     return retVal;
 }
 
-uint32_t hsStream::WriteSafeString_TEMP(const plString &string)
+uint32_t hsStream::WriteSafeString(const plString &string)
 {
-    return WriteSafeString(string.c_str());
+    return WriteSafeString(_TEMP_CONVERT_TO_CONST_CHAR(string));
 }
 
-uint32_t hsStream::WriteSafeWString_TEMP(const plString &string)
+uint32_t hsStream::WriteSafeWString(const plString &string)
 {
-    plStringBuffer<wchar_t> wbuffer = string.ToWchar();
-    return WriteSafeWString(wbuffer.GetData());
+    return WriteSafeWString(_TEMP_CONVERT_TO_WCHAR_T(string));
 }
 
 plString hsStream::ReadSafeString_TEMP()
diff --git a/Sources/Plasma/CoreLib/hsStream.h b/Sources/Plasma/CoreLib/hsStream.h
index cf0c5599..3ae694d4 100644
--- a/Sources/Plasma/CoreLib/hsStream.h
+++ b/Sources/Plasma/CoreLib/hsStream.h
@@ -145,8 +145,8 @@ public:
     char *          ReadSafeString();
     wchar_t *       ReadSafeWString();
 
-    uint32_t        WriteSafeString_TEMP(const plString &string);        // uses 2 bytes for length
-    uint32_t        WriteSafeWString_TEMP(const plString &string);
+    uint32_t        WriteSafeString(const plString &string);        // uses 2 bytes for length
+    uint32_t        WriteSafeWString(const plString &string);
     plString        ReadSafeString_TEMP();
     plString        ReadSafeWString_TEMP();
 
diff --git a/Sources/Plasma/CoreLib/plString.cpp b/Sources/Plasma/CoreLib/plString.cpp
index e58e204f..c4ba50f0 100644
--- a/Sources/Plasma/CoreLib/plString.cpp
+++ b/Sources/Plasma/CoreLib/plString.cpp
@@ -28,6 +28,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 
 #include <cstring>
 #include <cstdlib>
+#include <wchar.h>
 
 const plString plString::Null;
 
@@ -51,6 +52,11 @@ static inline size_t u16slen(const uint16_t *ustr, size_t max)
 
 void plString::IConvertFromUtf8(const char *utf8, size_t size, bool steal)
 {
+    if (utf8 == nil) {
+        fUtf8Buffer = plStringBuffer<char>();
+        return;
+    }
+
     if ((long)size < 0)
         size = strnlen(utf8, -(long)size);
 
@@ -85,6 +91,11 @@ void plString::IConvertFromUtf8(const char *utf8, size_t size, bool steal)
 
 void plString::IConvertFromUtf16(const uint16_t *utf16, size_t size)
 {
+    if (utf16 == nil) {
+        fUtf8Buffer = plStringBuffer<char>();
+        return;
+    }
+
     if ((long)size < 0)
         size = u16slen(utf16, -(long)size);
 
@@ -156,6 +167,11 @@ void plString::IConvertFromWchar(const wchar_t *wstr, size_t size)
     // We assume that if sizeof(wchar_t) == 2, the data is UTF-16 already
     IConvertFromUtf16((const uint16_t *)wstr, size);
 #else
+    if (wstr == nil) {
+        fUtf8Buffer = plStringBuffer<char>();
+        return;
+    }
+
     if ((long)size < 0)
         size = wcsnlen(wstr, -(long)size);
 
@@ -213,6 +229,11 @@ void plString::IConvertFromWchar(const wchar_t *wstr, size_t size)
 
 void plString::IConvertFromIso8859_1(const char *astr, size_t size)
 {
+    if (astr == nil) {
+        fUtf8Buffer = plStringBuffer<char>();
+        return;
+    }
+
     if ((long)size < 0)
         size = strnlen(astr, -(long)size);
 
diff --git a/Sources/Plasma/CoreLib/plString.h b/Sources/Plasma/CoreLib/plString.h
index 212a0d5a..f2a4d4b8 100644
--- a/Sources/Plasma/CoreLib/plString.h
+++ b/Sources/Plasma/CoreLib/plString.h
@@ -39,8 +39,8 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
  */
 #define _TEMP_CONVERT_FROM_LITERAL(x)       plString::FromUtf8((x))
 #define _TEMP_CONVERT_FROM_WCHAR_T(x)       plString::FromWchar((x))
-#define _TEMP_CONVERT_TO_CONST_CHAR(x)      (x).c_str()
-#define _TEMP_CONVERT_TO_CONST_CHAR_S(x)    (x).s_str()
+#define _TEMP_CONVERT_TO_CONST_CHAR(x)      ((x).c_str())
+#define _TEMP_CONVERT_TO_WCHAR_T(x)         ((x).ToWchar().GetData())
 
 typedef unsigned int UniChar;
 
@@ -70,7 +70,7 @@ private:
     StringRef *fData;
 
 public:
-    plStringBuffer() : fData(0) { }
+    plStringBuffer() : fData(nil) { }
 
     plStringBuffer(const plStringBuffer<_Ch> &copy)
     {
diff --git a/Sources/Plasma/FeatureLib/pfConsole/pfAvatarConsoleCommands.cpp b/Sources/Plasma/FeatureLib/pfConsole/pfAvatarConsoleCommands.cpp
index f31f4553..0069cc7a 100644
--- a/Sources/Plasma/FeatureLib/pfConsole/pfAvatarConsoleCommands.cpp
+++ b/Sources/Plasma/FeatureLib/pfConsole/pfAvatarConsoleCommands.cpp
@@ -632,11 +632,11 @@ PF_CONSOLE_CMD( Avatar_Physics, TogglePhysical, "", "Disable/enable physics on t
 
 PF_CONSOLE_CMD( Avatar_Anim, BlendAnim, "string Animation, float blendFactor", "Blend the given animation with the current animation.")
 {
-    char *animationName = params[0];
+    plString animationName = plString::FromUtf8(params[0]);
     float blendFactor = params[1];
     plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
 
-    if (avatar && animationName)
+    if (avatar && !animationName.IsNull())
     {
         plAGAnim * anim = plAGAnim::FindAnim(animationName);
         if(anim)
@@ -650,12 +650,12 @@ PF_CONSOLE_CMD( Avatar_Anim, BlendAnim, "string Animation, float blendFactor", "
 
 PF_CONSOLE_CMD( Avatar_Anim, BlendAnimPri, "string Animation, float blendFactor, int priority", "Blend animation using priority.")
 {
-    char *animationName = params[0];
+    plString animationName = plString::FromUtf8(params[0]);
     float blendFactor = params[1];
     int priority = params[2];
     plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
 
-    if (avatar && animationName)
+    if (avatar && !animationName.IsNull())
     {
         plAGAnim * anim = plAGAnim::FindAnim(animationName);
         if(anim)
@@ -671,15 +671,15 @@ PF_CONSOLE_CMD( Avatar_Anim, PlaySimpleAnim, "string AvatarName, string Animatio
 {
     plArmatureMod *avatar = plAvatarMgr::GetInstance()->FindAvatarByModelName(params[0]);
     if (avatar)
-        avatar->PlaySimpleAnim(params[1]);
+        avatar->PlaySimpleAnim(plString::FromUtf8(params[1]));
 }
 
 PF_CONSOLE_CMD( Avatar_Anim, DetachAnim, "string Animation", "Remove the given animation from the avatar.")
 {
-    char *animationName = params[0];
+    plString animationName = plString::FromUtf8(params[0]);
     plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
 
-    if (avatar && animationName)
+    if (avatar && !animationName.IsNull())
     {
         plAGAnimInstance * instance = avatar->FindAnimInstance(animationName);
         if(instance)
@@ -691,11 +691,11 @@ PF_CONSOLE_CMD( Avatar_Anim, DetachAnim, "string Animation", "Remove the given a
 
 PF_CONSOLE_CMD( Avatar_Anim, SetBlend, "string Animation, float blend", "Set the blend of the given animation.")
 {
-    char *animationName = params[0];
+    plString animationName = plString::FromUtf8(params[0]);
     float blend = params[1];
     plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
 
-    if (avatar && animationName)
+    if (avatar && !animationName.IsNull())
     {
         plAGAnimInstance *anim = avatar->FindAnimInstance(animationName);
         if(anim)
diff --git a/Sources/Plasma/FeatureLib/pfConsole/pfConsoleCommands.cpp b/Sources/Plasma/FeatureLib/pfConsole/pfConsoleCommands.cpp
index a53e5fd8..0499522d 100644
--- a/Sources/Plasma/FeatureLib/pfConsole/pfConsoleCommands.cpp
+++ b/Sources/Plasma/FeatureLib/pfConsole/pfConsoleCommands.cpp
@@ -6548,7 +6548,7 @@ PF_CONSOLE_CMD( Animation,                          // Group name
 {
     plAnimCmdMsg *msg = new plAnimCmdMsg();
     msg->SetCmd(plAnimCmdMsg::kContinue);
-    msg->SetAnimName(nil);
+    msg->SetAnimName(plString::Null);
     msg->SetBCastFlag(plMessage::kPropagateToModifiers);
     SendAnimCmdMsg(plString::FromUtf8(params[0]), msg);
 }
@@ -6560,7 +6560,7 @@ PF_CONSOLE_CMD( Animation,                          // Group name
 {
     plAnimCmdMsg *msg = new plAnimCmdMsg();
     msg->SetCmd(plAnimCmdMsg::kStop);
-    msg->SetAnimName(nil);
+    msg->SetAnimName(plString::Null);
     msg->SetBCastFlag(plMessage::kPropagateToModifiers);
     SendAnimCmdMsg(plString::FromUtf8(params[0]), msg);
 }
@@ -6574,7 +6574,7 @@ PF_CONSOLE_CMD( Animation,                          // Group name
     msg->SetCmd(plAGCmdMsg::kSetBlend);
     msg->fBlend = params[2];
     msg->fBlendRate = params[3];
-    msg->SetAnimName(params[1]);
+    msg->SetAnimName(plString::FromUtf8(params[1]));
     msg->SetBCastFlag(plMessage::kPropagateToModifiers);
     SendAnimCmdMsg(plString::FromUtf8(params[0]), msg);
 }
@@ -6588,7 +6588,7 @@ PF_CONSOLE_CMD( Animation,                          // Group name
     msg->SetCmd(plAGCmdMsg::kSetAmp);
     msg->fAmp = params[2];
     msg->fAmpRate = params[3];
-    msg->SetAnimName(params[1]);
+    msg->SetAnimName(plString::FromUtf8(params[1]));
     msg->SetBCastFlag(plMessage::kPropagateToModifiers);
     SendAnimCmdMsg(plString::FromUtf8(params[0]), msg);
 }
@@ -6602,7 +6602,7 @@ PF_CONSOLE_CMD( Animation,                          // Group name
     msg->SetCmd(plAnimCmdMsg::kSetSpeed);
     msg->fSpeed = params[2];
     msg->fSpeedChangeRate = params[3];
-    msg->SetAnimName(params[1]);
+    msg->SetAnimName(plString::FromUtf8(params[1]));
     msg->SetBCastFlag(plMessage::kPropagateToModifiers);
     SendAnimCmdMsg(plString::FromUtf8(params[0]), msg);
 }
diff --git a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIButtonMod.cpp b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIButtonMod.cpp
index 5225d19d..d31af392 100644
--- a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIButtonMod.cpp
+++ b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIButtonMod.cpp
@@ -150,8 +150,6 @@ void    pfGUIButtonMod::StartDragging( void )
 
 pfGUIButtonMod::pfGUIButtonMod()
 {
-    fAnimName = nil;
-    fMouseOverAnimName = nil;
     fDraggable = nil;
     fOrigHandler = nil;
 
@@ -161,12 +159,6 @@ pfGUIButtonMod::pfGUIButtonMod()
     SetFlag( kWantsInterest );
 }
 
-pfGUIButtonMod::~pfGUIButtonMod()
-{
-    delete [] fAnimName;
-    delete [] fMouseOverAnimName;
-}
-
 //// IEval ///////////////////////////////////////////////////////////////////
 
 hsBool  pfGUIButtonMod::IEval( double secs, float del, uint32_t dirty )
@@ -204,13 +196,13 @@ void    pfGUIButtonMod::Read( hsStream *s, hsResMgr *mgr )
     uint32_t i, count = s->ReadLE32();
     for( i = 0; i < count; i++ )
         fAnimationKeys.Append( mgr->ReadKey( s ) );
-    fAnimName = s->ReadSafeString();
+    fAnimName = s->ReadSafeString_TEMP();
 
     fMouseOverAnimKeys.Reset();
     count = s->ReadLE32();
     for( i = 0; i < count; i++ )
         fMouseOverAnimKeys.Append( mgr->ReadKey( s ) );
-    fMouseOverAnimName = s->ReadSafeString();
+    fMouseOverAnimName = s->ReadSafeString_TEMP();
 
     fNotifyType = s->ReadLE32();
     mgr->ReadKeyNotifyMe( s, new plGenRefMsg( GetKey(), plRefMsg::kOnCreate, -1, kRefDraggable ), plRefFlags::kActiveRef );
@@ -366,30 +358,16 @@ void    pfGUIButtonMod::SetInteresting( hsBool i )
 }
 
 
-void    pfGUIButtonMod::SetAnimationKeys( hsTArray<plKey> &keys, const char *name )
+void    pfGUIButtonMod::SetAnimationKeys( hsTArray<plKey> &keys, const plString &name )
 {
     fAnimationKeys = keys;
-    delete [] fAnimName;
-    if( name != nil )
-    {
-        fAnimName = new char[ strlen( name ) + 1 ];
-        strcpy( fAnimName, name );
-    }
-    else
-        fAnimName = nil;
+    fAnimName = name;
 }
 
-void    pfGUIButtonMod::SetMouseOverAnimKeys( hsTArray<plKey> &keys, const char *name )
+void    pfGUIButtonMod::SetMouseOverAnimKeys( hsTArray<plKey> &keys, const plString &name )
 {
     fMouseOverAnimKeys = keys;
-    delete [] fMouseOverAnimName;
-    if( name != nil )
-    {
-        fMouseOverAnimName = new char[ strlen( name ) + 1 ];
-        strcpy( fMouseOverAnimName, name );
-    }
-    else
-        fMouseOverAnimName = nil;
+    fMouseOverAnimName = name;
 }
 
 
diff --git a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIButtonMod.h b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIButtonMod.h
index faed9a1e..b7f92c36 100644
--- a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIButtonMod.h
+++ b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIButtonMod.h
@@ -60,10 +60,10 @@ class pfGUIButtonMod : public pfGUIControlMod
     protected:
 
         hsTArray<plKey> fAnimationKeys;
-        char            *fAnimName;
+        plString        fAnimName;
 
         hsTArray<plKey> fMouseOverAnimKeys;
-        char            *fMouseOverAnimName;
+        plString        fMouseOverAnimName;
 
         hsBool          fClicking;
         hsBool          fTriggering;
@@ -83,7 +83,6 @@ class pfGUIButtonMod : public pfGUIControlMod
     public:
 
         pfGUIButtonMod();
-        virtual ~pfGUIButtonMod();
 
         CLASSNAME_REGISTER( pfGUIButtonMod );
         GETINTERFACE_ANY( pfGUIButtonMod, pfGUIControlMod );
@@ -130,8 +129,8 @@ class pfGUIButtonMod : public pfGUIControlMod
         void    StopDragging( hsBool cancel );
 
         // Export only
-        void    SetAnimationKeys( hsTArray<plKey> &keys, const char *name );
-        void    SetMouseOverAnimKeys( hsTArray<plKey> &keys, const char *name );
+        void    SetAnimationKeys( hsTArray<plKey> &keys, const plString &name );
+        void    SetMouseOverAnimKeys( hsTArray<plKey> &keys, const plString &name );
 };
 
 #endif // _pfGUIButtonMod_h
diff --git a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUICheckBoxCtrl.cpp b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUICheckBoxCtrl.cpp
index ac43b99b..24b853a2 100644
--- a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUICheckBoxCtrl.cpp
+++ b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUICheckBoxCtrl.cpp
@@ -65,18 +65,12 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 
 pfGUICheckBoxCtrl::pfGUICheckBoxCtrl()
 {
-    fAnimName = nil;
     SetFlag( kWantsInterest );
     fChecked = false;
     fClicking = false;
     fPlaySound = true;
 }
 
-pfGUICheckBoxCtrl::~pfGUICheckBoxCtrl()
-{
-    delete [] fAnimName;
-}
-
 //// IEval ///////////////////////////////////////////////////////////////////
 
 hsBool  pfGUICheckBoxCtrl::IEval( double secs, float del, uint32_t dirty )
@@ -102,7 +96,7 @@ void    pfGUICheckBoxCtrl::Read( hsStream *s, hsResMgr *mgr )
     for( i = 0; i < count; i++ )
         fAnimationKeys.Append( mgr->ReadKey( s ) );
 
-    fAnimName = s->ReadSafeString();
+    fAnimName = s->ReadSafeString_TEMP();
     fChecked = s->ReadBool();
 }
 
@@ -197,17 +191,10 @@ void    pfGUICheckBoxCtrl::SetChecked( hsBool checked, hsBool immediate /*= fals
     }
 }
 
-void    pfGUICheckBoxCtrl::SetAnimationKeys( hsTArray<plKey> &keys, const char *name )
+void    pfGUICheckBoxCtrl::SetAnimationKeys( hsTArray<plKey> &keys, const plString &name )
 {
     fAnimationKeys = keys;
-    delete [] fAnimName;
-    if( name != nil )
-    {
-        fAnimName = new char[ strlen( name ) + 1 ];
-        strcpy( fAnimName, name );
-    }
-    else
-        fAnimName = nil;
+    fAnimName = name;
 }
 
 //// IGetDesiredCursor ///////////////////////////////////////////////////////
diff --git a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUICheckBoxCtrl.h b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUICheckBoxCtrl.h
index c4c3e38e..912e4f1c 100644
--- a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUICheckBoxCtrl.h
+++ b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUICheckBoxCtrl.h
@@ -59,7 +59,7 @@ class pfGUICheckBoxCtrl : public pfGUIControlMod
     protected:
 
         hsTArray<plKey> fAnimationKeys;
-        char            *fAnimName;
+        plString        fAnimName;
         hsBool          fClicking;
 
         hsBool          fChecked;
@@ -72,7 +72,6 @@ class pfGUICheckBoxCtrl : public pfGUIControlMod
     public:
 
         pfGUICheckBoxCtrl();
-        virtual ~pfGUICheckBoxCtrl();
 
         CLASSNAME_REGISTER( pfGUICheckBoxCtrl );
         GETINTERFACE_ANY( pfGUICheckBoxCtrl, pfGUIControlMod );
@@ -94,7 +93,7 @@ class pfGUICheckBoxCtrl : public pfGUIControlMod
         void DontPlaySounds() { fPlaySound = false; } // should the checkbox play sounds?
         
         const hsTArray<plKey>   &GetAnimationKeys( void ) const { return fAnimationKeys; }
-        const char              *GetAnimationName( void ) const { return fAnimName; }
+        plString                GetAnimationName( void ) const { return fAnimName; }
 
         enum SoundEvents
         {
@@ -105,7 +104,7 @@ class pfGUICheckBoxCtrl : public pfGUIControlMod
         };
 
         // Export only
-        void    SetAnimationKeys( hsTArray<plKey> &keys, const char *name );
+        void    SetAnimationKeys( hsTArray<plKey> &keys, const plString &name );
 };
 
 #endif // _pfGUICheckBoxCtrl_h
diff --git a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIKnobCtrl.cpp b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIKnobCtrl.cpp
index 45a2ca64..264ccd07 100644
--- a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIKnobCtrl.cpp
+++ b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIKnobCtrl.cpp
@@ -69,7 +69,6 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 //// Constructor/Destructor //////////////////////////////////////////////////
 
 pfGUIKnobCtrl::pfGUIKnobCtrl() :
-    fAnimName(nil),
     fDragStart(0.f, 0.f, 0.f),
     fDragging(false),
     fAnimStartPos(0.f, 0.f, 0.f),
@@ -83,11 +82,6 @@ pfGUIKnobCtrl::pfGUIKnobCtrl() :
     SetFlag( kWantsInterest );
 }
 
-pfGUIKnobCtrl::~pfGUIKnobCtrl()
-{
-    delete [] fAnimName;
-}
-
 //// IEval ///////////////////////////////////////////////////////////////////
 
 hsBool  pfGUIKnobCtrl::IEval( double secs, float del, uint32_t dirty )
@@ -112,7 +106,7 @@ void    pfGUIKnobCtrl::Read( hsStream *s, hsResMgr *mgr )
     uint32_t i, count = s->ReadLE32();
     for( i = 0; i < count; i++ )
         fAnimationKeys.Append( mgr->ReadKey( s ) );
-    fAnimName = s->ReadSafeString();
+    fAnimName = s->ReadSafeString_TEMP();
 
     fAnimTimesCalced = false;
 
@@ -262,17 +256,10 @@ void    pfGUIKnobCtrl::HandleMouseDrag( hsPoint3 &mousePt, uint8_t modifiers )
 
 //// SetAnimationKeys ////////////////////////////////////////////////////////
 
-void    pfGUIKnobCtrl::SetAnimationKeys( hsTArray<plKey> &keys, const char *name )
+void    pfGUIKnobCtrl::SetAnimationKeys( hsTArray<plKey> &keys, const plString &name )
 {
     fAnimationKeys = keys;
-    delete [] fAnimName;
-    if( name != nil )
-    {
-        fAnimName = new char[ strlen( name ) + 1 ];
-        strcpy( fAnimName, name );
-    }
-    else
-        fAnimName = nil;
+    fAnimName = name;
 }
 
 //// ICalcAnimTimes //////////////////////////////////////////////////////////
diff --git a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIKnobCtrl.h b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIKnobCtrl.h
index c58753c6..006849d9 100644
--- a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIKnobCtrl.h
+++ b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIKnobCtrl.h
@@ -58,17 +58,17 @@ class pfGUIKnobCtrl : public pfGUIValueCtrl
     protected:
 
         hsTArray<plKey> fAnimationKeys;
-        char            *fAnimName;
+        plString        fAnimName;
 
         hsPoint3        fDragStart;
-        float        fDragValue;
+        float           fDragValue;
         hsBool          fDragging;
 
         hsPoint3        fAnimStartPos, fAnimEndPos; // Calculated at export time for kMapToScreenRange
-        float        fDragRangeMin, fDragRangeMax;
+        float           fDragRangeMin, fDragRangeMax;
 
                         // Computed once, once an anim is loaded that we can compute this with
-        float        fAnimBegin, fAnimEnd;
+        float           fAnimBegin, fAnimEnd;
         hsBool          fAnimTimesCalced;
 
         virtual hsBool IEval( double secs, float del, uint32_t dirty ); // called only by owner object's Eval()
@@ -80,7 +80,6 @@ class pfGUIKnobCtrl : public pfGUIValueCtrl
     public:
 
         pfGUIKnobCtrl();
-        virtual ~pfGUIKnobCtrl();
 
         CLASSNAME_REGISTER( pfGUIKnobCtrl );
         GETINTERFACE_ANY( pfGUIKnobCtrl, pfGUIValueCtrl );
@@ -109,7 +108,7 @@ class pfGUIKnobCtrl : public pfGUIValueCtrl
         virtual void    SetCurrValue( float v );
 
         // Export only
-        void    SetAnimationKeys( hsTArray<plKey> &keys, const char *name );
+        void    SetAnimationKeys( hsTArray<plKey> &keys, const plString &name );
         void    SetScreenRange( const hsPoint3 &startPos, const hsPoint3 &endPos ) { fAnimStartPos = startPos; fAnimEndPos = endPos; }
 };
 
diff --git a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIProgressCtrl.cpp b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIProgressCtrl.cpp
index dc0ac095..a8dc6ef0 100644
--- a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIProgressCtrl.cpp
+++ b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIProgressCtrl.cpp
@@ -72,15 +72,9 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 pfGUIProgressCtrl::pfGUIProgressCtrl() : fStopSoundTimer(99)
 {
     fAnimTimesCalced = false;
-    fAnimName = nil;
     fPlaySound = true;
 }
 
-pfGUIProgressCtrl::~pfGUIProgressCtrl()
-{
-    delete [] fAnimName;
-}
-
 //// IEval ///////////////////////////////////////////////////////////////////
 
 hsBool  pfGUIProgressCtrl::IEval( double secs, float del, uint32_t dirty )
@@ -114,7 +108,7 @@ void    pfGUIProgressCtrl::Read( hsStream *s, hsResMgr *mgr )
     uint32_t i, count = s->ReadLE32();
     for( i = 0; i < count; i++ )
         fAnimationKeys.Append( mgr->ReadKey( s ) );
-    fAnimName = s->ReadSafeString();
+    fAnimName = s->ReadSafeString_TEMP();
 
     fAnimTimesCalced = false;
 }
@@ -141,17 +135,10 @@ void    pfGUIProgressCtrl::UpdateBounds( hsMatrix44 *invXformMatrix, hsBool forc
 
 //// SetAnimationKeys ////////////////////////////////////////////////////////
 
-void    pfGUIProgressCtrl::SetAnimationKeys( hsTArray<plKey> &keys, const char *name )
+void    pfGUIProgressCtrl::SetAnimationKeys( hsTArray<plKey> &keys, const plString &name )
 {
     fAnimationKeys = keys;
-    delete [] fAnimName;
-    if( name != nil )
-    {
-        fAnimName = new char[ strlen( name ) + 1 ];
-        strcpy( fAnimName, name );
-    }
-    else
-        fAnimName = nil;
+    fAnimName = name;
 }
 
 //// ICalcAnimTimes //////////////////////////////////////////////////////////
diff --git a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIProgressCtrl.h b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIProgressCtrl.h
index 18c7c50a..9e207c21 100644
--- a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIProgressCtrl.h
+++ b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIProgressCtrl.h
@@ -58,10 +58,10 @@ class pfGUIProgressCtrl : public pfGUIValueCtrl
     protected:
 
         hsTArray<plKey> fAnimationKeys;
-        char            *fAnimName;
+        plString        fAnimName;
 
                         // Computed once, once an anim is loaded that we can compute this with
-        float        fAnimBegin, fAnimEnd;
+        float           fAnimBegin, fAnimEnd;
         hsBool          fAnimTimesCalced;
         hsBool          fPlaySound;
 
@@ -69,12 +69,11 @@ class pfGUIProgressCtrl : public pfGUIValueCtrl
 
         hsBool          ICalcAnimTimes( void );
 
-        const uint32_t    fStopSoundTimer;
+        const uint32_t  fStopSoundTimer;
 
     public:
 
         pfGUIProgressCtrl();
-        virtual ~pfGUIProgressCtrl();
 
         CLASSNAME_REGISTER( pfGUIProgressCtrl );
         GETINTERFACE_ANY( pfGUIProgressCtrl, pfGUIValueCtrl );
@@ -103,7 +102,7 @@ class pfGUIProgressCtrl : public pfGUIValueCtrl
         void DontPlaySounds() { fPlaySound = false; }
 
         // Export only
-        void    SetAnimationKeys( hsTArray<plKey> &keys, const char *name );
+        void    SetAnimationKeys( hsTArray<plKey> &keys, const plString &name );
 };
 
 #endif // _pfGUIProgressCtrl_h
diff --git a/Sources/Plasma/FeatureLib/pfJournalBook/pfJournalBook.cpp b/Sources/Plasma/FeatureLib/pfJournalBook/pfJournalBook.cpp
index 2d6a4698..10bc1176 100644
--- a/Sources/Plasma/FeatureLib/pfJournalBook/pfJournalBook.cpp
+++ b/Sources/Plasma/FeatureLib/pfJournalBook/pfJournalBook.cpp
@@ -867,7 +867,7 @@ void pfBookData::ITriggerPageFlip(hsBool flipBackwards, hsBool immediate)
     // in MAX, we just use a GUI check box to grab them for us, even though we never
     // actually use the functionality of the checkbox itself
     const hsTArray<plKey> &keys = fTurnPageButton->GetAnimationKeys();
-    const char *animName = fTurnPageButton->GetAnimationName();
+    plString animName = fTurnPageButton->GetAnimationName();
 
     plAnimCmdMsg *msg = new plAnimCmdMsg();
     if (immediate)
@@ -1474,7 +1474,7 @@ void    pfJournalBook::ITriggerCloseWithNotify( hsBool closeNotOpen, hsBool imme
     fBookGUIs[fCurBookGUI]->CurrentlyOpen(!closeNotOpen);
 
     const hsTArray<plKey> &keys = fBookGUIs[fCurBookGUI]->CoverButton()->GetAnimationKeys();
-    const char *animName = fBookGUIs[fCurBookGUI]->CoverButton()->GetAnimationName();
+    plString animName = fBookGUIs[fCurBookGUI]->CoverButton()->GetAnimationName();
 
     plAnimCmdMsg *msg = new plAnimCmdMsg();
     if( !immediate )
diff --git a/Sources/Plasma/FeatureLib/pfPython/cyAvatar.cpp b/Sources/Plasma/FeatureLib/pfPython/cyAvatar.cpp
index 6751e1bd..c57afce5 100644
--- a/Sources/Plasma/FeatureLib/pfPython/cyAvatar.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/cyAvatar.cpp
@@ -174,7 +174,7 @@ plKey cyAvatar::IFindArmatureModKey(plKey avKey)
 //  PURPOSE    : oneShot Avatar (must already be there)
 //
 void cyAvatar::OneShot(pyKey &seekKey, float duration, hsBool usePhysics,
-               const char *animName, hsBool drivable, hsBool reversible)
+               const plString &animName, hsBool drivable, hsBool reversible)
 {
     if ( fRecvr.Count() > 0 )
     {
@@ -185,7 +185,7 @@ void cyAvatar::OneShot(pyKey &seekKey, float duration, hsBool usePhysics,
             seekKey.getKey(),   // Mark D told me to do it ...paulg
             duration,  
             usePhysics,  
-            animName, // Constructor will do a copy. -mf- hsStrcpy(animName),
+            animName,
             drivable, 
             reversible);
 
@@ -1586,7 +1586,7 @@ void cyAvatar::ExitSubWorld()
 //
 //  PURPOSE    : Place the Avatar into the subworld of the sceneobject specified
 //
-void cyAvatar::PlaySimpleAnimation(const char* animName)
+void cyAvatar::PlaySimpleAnimation(const plString& animName)
 {
     // make sure that there is atleast one avatar scene object attached (should be)
     if ( fRecvr.Count() > 0)
diff --git a/Sources/Plasma/FeatureLib/pfPython/cyAvatar.h b/Sources/Plasma/FeatureLib/pfPython/cyAvatar.h
index ded3c41e..21281c0b 100644
--- a/Sources/Plasma/FeatureLib/pfPython/cyAvatar.h
+++ b/Sources/Plasma/FeatureLib/pfPython/cyAvatar.h
@@ -103,7 +103,7 @@ public:
 
     // oneShot Avatar (must already be there)
     virtual void OneShot(pyKey &seekKey, float duration, hsBool usePhysics,
-                   const char *animName, hsBool drivable, hsBool reversible);
+                   const plString &animName, hsBool drivable, hsBool reversible);
 
     // oneShot Avatar 
     virtual void RunBehavior(pyKey &behKey, hsBool netForce, hsBool netProp);
@@ -412,7 +412,7 @@ public:
     //
     virtual void ExitSubWorld();
 
-    virtual void PlaySimpleAnimation(const char* animName);
+    virtual void PlaySimpleAnimation(const plString& animName);
 
     /////////////////////////////////////////////////////////////////////////////
     //
diff --git a/Sources/Plasma/FeatureLib/pfPython/cyAvatarGlue.cpp b/Sources/Plasma/FeatureLib/pfPython/cyAvatarGlue.cpp
index feb49db1..20a30ec9 100644
--- a/Sources/Plasma/FeatureLib/pfPython/cyAvatarGlue.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/cyAvatarGlue.cpp
@@ -89,8 +89,7 @@ PYTHON_METHOD_DEFINITION(ptAvatar, oneShot, args)
     }
 
     pyKey* key = pyKey::ConvertFrom(keyObj);
-    std::string animNameStr = animName; // convert to string (for safety)
-    self->fThis->OneShot(*key, duration, usePhysics != 0, animNameStr.c_str(), drivable != 0, reversable != 0);
+    self->fThis->OneShot(*key, duration, usePhysics != 0, plString::FromUtf8(animName), drivable != 0, reversable != 0);
     PYTHON_RETURN_NONE;
 }
 
@@ -592,8 +591,7 @@ PYTHON_METHOD_DEFINITION(ptAvatar, playSimpleAnimation, args)
         PYTHON_RETURN_ERROR;
     }
 
-    std::string animNameStr = animName; // convert to a string (for safety)
-    self->fThis->PlaySimpleAnimation(animNameStr.c_str());
+    self->fThis->PlaySimpleAnimation(plString::FromUtf8(animName));
     PYTHON_RETURN_NONE;
 }
 
diff --git a/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.cpp b/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.cpp
index 156c6475..6d89af14 100644
--- a/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.cpp
@@ -629,23 +629,23 @@ void plPythonFileMod::AddTarget(plSceneObject* sobj)
                                             NamedComponent comp;
                                             comp.isActivator = (isNamedAttr == 1);
                                             comp.id = parameter.fID;
-                                            comp.name = plString::FromUtf8(parameter.datarecord.fString);
+                                            comp.name = parameter.fString;
                                             
                                             fNamedCompQueue.Append(comp);
                                         }
                                         else
                                         {
                                             if (isNamedAttr == 1)
-                                                IFindActivatorAndAdd(plString::FromUtf8(parameter.datarecord.fString), parameter.fID);
+                                                IFindActivatorAndAdd(parameter.fString, parameter.fID);
                                             else
-                                                IFindResponderAndAdd(plString::FromUtf8(parameter.datarecord.fString), parameter.fID);
+                                                IFindResponderAndAdd(parameter.fString, parameter.fID);
                                         }
                                     }
                                 }
                                 // if it wasn't a named string then must be normal string type
                                 if ( isNamedAttr == 0 )
-                                    if ( parameter.datarecord.fString != nil )
-                                        value = PyString_FromString(parameter.datarecord.fString);
+                                    if ( !parameter.fString.IsNull() )
+                                        value = PyString_FromString(parameter.fString.c_str());
                                 break;
                             case plPythonParameter::kSceneObject:
                             case plPythonParameter::kSceneObjectList:
diff --git a/Sources/Plasma/FeatureLib/pfPython/plPythonParameter.h b/Sources/Plasma/FeatureLib/pfPython/plPythonParameter.h
index d77db84f..e22febc8 100644
--- a/Sources/Plasma/FeatureLib/pfPython/plPythonParameter.h
+++ b/Sources/Plasma/FeatureLib/pfPython/plPythonParameter.h
@@ -94,17 +94,16 @@ public:
     // the data of the value
     union
     {
-        int32_t       fIntNumber;
+        int32_t     fIntNumber;
 
-        float    fFloatNumber;
+        float       fFloatNumber;
 
         hsBool      fBool;
 
-        char*       fString;
-
     } datarecord;
 
     plKey       fObjectKey;     // the plKey of the scene object (should be part of the union, but unions don't allow complex types)
+    plString    fString;
 
 
     plPythonParameter()
@@ -147,7 +146,7 @@ public:
                 SetTobool(other.datarecord.fBool);
                 break;
             case kString:
-                SetToString(other.datarecord.fString);
+                SetToString(other.fString);
                 break;
             case kSceneObject:
                 SetToSceneObject(other.fObjectKey);
@@ -174,7 +173,7 @@ public:
                 SetToAnimation(other.fObjectKey);
                 break;
             case kAnimationName:
-                SetToAnimationName(other.datarecord.fString);
+                SetToAnimationName(other.fString);
                 break;
             case kBehavior:
                 SetToBehavior(other.fObjectKey);
@@ -214,10 +213,6 @@ public:
 
     void SetToNone()
     {
-        // remove the string if one was created
-        if ( fValueType == kString || fValueType == kAnimationName )
-            delete [] datarecord.fString;
-
         fValueType = kNone;
     }
 
@@ -239,11 +234,11 @@ public:
         fValueType = kbool;
         datarecord.fBool = state;
     }
-    void SetToString(const char* string)
+    void SetToString(const plString& string)
     {
         SetToNone();
         fValueType = kString;
-        datarecord.fString = hsStrcpy(string);
+        fString = string;
     }
     void SetToSceneObject(plKey key, hsBool list=false)
     {
@@ -302,11 +297,11 @@ public:
         fValueType = kAnimation;
         fObjectKey = key;
     }
-    void SetToAnimationName(const char* string)
+    void SetToAnimationName(const plString& string)
     {
         SetToNone();
         fValueType = kAnimationName;
-        datarecord.fString = hsStrcpy(string);
+        fString = string;
     }
     void SetToBehavior(plKey key)
     {
@@ -380,11 +375,13 @@ public:
                 count = stream->ReadLE32();
                 if ( count != 0 )
                 {
-                    datarecord.fString = new char[count+1];
-                    stream->ReadLE(count,datarecord.fString);
+                    char *buffer = new char[count];
+                    stream->ReadLE(count, buffer);
+                    buffer[count-1] = 0;
+                    fString = plString::Steal(buffer, count);
                 }
                 else
-                    datarecord.fString = nil;
+                    fString = plString::Null;
                 break;
 
             case kSceneObject:
@@ -430,13 +427,13 @@ public:
 
             case kString:
             case kAnimationName:
-                if ( datarecord.fString != nil )
-                    count = hsStrlen(datarecord.fString)+1;
+                if ( !fString.IsNull() )
+                    count = fString.GetSize()+1;
                 else
                     count = 0;
                 stream->WriteLE(count);
                 if ( count != 0 )
-                    stream->WriteLE(count,datarecord.fString);
+                    stream->WriteLE(count, fString.c_str());
                 break;
 
             case kSceneObject:
diff --git a/Sources/Plasma/FeatureLib/pfPython/pyCritterBrain.cpp b/Sources/Plasma/FeatureLib/pfPython/pyCritterBrain.cpp
index b4883bdf..063778de 100644
--- a/Sources/Plasma/FeatureLib/pfPython/pyCritterBrain.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/pyCritterBrain.cpp
@@ -109,24 +109,24 @@ std::string pyCritterBrain::BehaviorName(int behavior) const
     return fBrain->BehaviorName(behavior);
 }
 
-std::string pyCritterBrain::AnimationName(int behavior) const
+plString pyCritterBrain::AnimationName(int behavior) const
 {
     if (!fBrain)
-        return false;
+        return plString::Null;
     return fBrain->AnimationName(behavior);
 }
 
 int pyCritterBrain::CurBehavior() const
 {
     if (!fBrain)
-        return false;
+        return 0;
     return fBrain->CurBehavior();
 }
 
 int pyCritterBrain::NextBehavior() const
 {
     if (!fBrain)
-        return false;
+        return 0;
     return fBrain->NextBehavior();
 }
 
diff --git a/Sources/Plasma/FeatureLib/pfPython/pyCritterBrain.h b/Sources/Plasma/FeatureLib/pfPython/pyCritterBrain.h
index 8f211ae9..28bb3eb4 100644
--- a/Sources/Plasma/FeatureLib/pfPython/pyCritterBrain.h
+++ b/Sources/Plasma/FeatureLib/pfPython/pyCritterBrain.h
@@ -92,7 +92,7 @@ public:
     bool RunningBehavior(const std::string& behaviorName) const;
 
     std::string BehaviorName(int behavior) const;
-    std::string AnimationName(int behavior) const;
+    plString AnimationName(int behavior) const;
     int CurBehavior() const;
     int NextBehavior() const;
 
diff --git a/Sources/Plasma/NucleusLib/pnKeyedObject/plUoid.cpp b/Sources/Plasma/NucleusLib/pnKeyedObject/plUoid.cpp
index c1ebce7e..6b42e130 100644
--- a/Sources/Plasma/NucleusLib/pnKeyedObject/plUoid.cpp
+++ b/Sources/Plasma/NucleusLib/pnKeyedObject/plUoid.cpp
@@ -208,7 +208,7 @@ void plUoid::Write(hsStream* s) const
 
     s->WriteLE( fClassType );
     s->WriteLE( fObjectID );
-    s->WriteSafeString_TEMP( fObjectName );
+    s->WriteSafeString( fObjectName );
 
     // conditional cloneIDs write
     if (contents & kHasCloneIDs)
diff --git a/Sources/Plasma/NucleusLib/pnUtils/Private/pnUtSubst.cpp b/Sources/Plasma/NucleusLib/pnUtils/Private/pnUtSubst.cpp
index 9a671032..c05a93e3 100644
--- a/Sources/Plasma/NucleusLib/pnUtils/Private/pnUtSubst.cpp
+++ b/Sources/Plasma/NucleusLib/pnUtils/Private/pnUtSubst.cpp
@@ -157,8 +157,7 @@ bool IParseForSubst (
         }
 
         // Validate variable name length
-        chartype varBuffer[256];
-        if (varEnd - varStart >= arrsize(varBuffer)) {
+        if (varEnd - varStart >= 256) {
             result = false;
             src = current = varEnd + 1;
             continue;
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAGAnim.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plAGAnim.cpp
index 00bb52db..5b9ccf77 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAGAnim.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAGAnim.cpp
@@ -76,31 +76,24 @@ plAGAnim::plAnimMap plAGAnim::fAllAnims;
 plAGAnim::plAGAnim()
 : plSynchedObject()
 {
-    fName = nil;
 }
 
 // ctor ------------------------------------------------------
 // -----
-plAGAnim::plAGAnim(const char *name, double start, double end)
+plAGAnim::plAGAnim(const plString &name, double start, double end)
 : fStart((float)start),
-  fEnd((float)end)
+  fEnd((float)end),
+  fName(name)
 {
-    if (name == nil)
-        name = "";
-
-    fName = new char[strlen(name) + 1];
-    strcpy(fName, name);
 }
 
 // dtor -------------
 // -----
 plAGAnim::~plAGAnim()
 {
-    if (fName)
+    if (!fName.IsNull())
     {
         RemoveAnim(fName);
-        delete[] fName;
-        fName = nil;
     }
 
     //int numChannels = fChannels.size();
@@ -137,7 +130,7 @@ plAGChannel * plAGAnim::GetChannel(int index) const
 
 // GetChannel --------------------------------------------
 // -----------
-plAGChannel * plAGAnim::GetChannel(const char *name) const
+plAGChannel * plAGAnim::GetChannel(const plString &name) const
 {
     int appCount = fApps.size();
 
@@ -145,9 +138,9 @@ plAGChannel * plAGAnim::GetChannel(const char *name) const
     {
         plAGApplicator *app = fApps[i];
         plAGChannel *channel = app->GetChannel();
-        const char *channelName = app->GetChannelName();
+        plString channelName = app->GetChannelName();
 
-        if(stricmp(name, channelName) == 0)
+        if(name.Compare(channelName, plString::kCaseInsensitive) == 0)
         {
             return channel;
         }
@@ -205,7 +198,7 @@ void plAGAnim::ExtendToLength(float length)
 
 // GetChannelName ------------------------------
 // ---------------
-const char * plAGAnim::GetChannelName(int index)
+plString plAGAnim::GetChannelName(int index)
 {
     hsAssert(index < fApps.size(), "Out of range index for plAGAnim::GetChannelName()");
 
@@ -213,7 +206,7 @@ const char * plAGAnim::GetChannelName(int index)
     {
         return fApps[index]->GetChannel()->GetName();
     } else {
-        return nil;
+        return plString::Null;
     }
 }
 
@@ -224,7 +217,7 @@ void plAGAnim::Read(hsStream *stream, hsResMgr *mgr)
     plSynchedObject::Read(stream, mgr);
 
     // read in the name of the animation itself
-    fName = stream->ReadSafeString();
+    fName = stream->ReadSafeString_TEMP();
 
     fStart = stream->ReadLEScalar();
     fEnd = stream->ReadLEScalar();
@@ -279,11 +272,11 @@ void plAGAnim::ClearAnimationRegistry()
 
 // AddAnim ----------------------------------------------
 // --------
-void plAGAnim::AddAnim(const char * name, plAGAnim *anim)
+void plAGAnim::AddAnim(const plString & name, plAGAnim *anim)
 {
     // Only register the animation if it's got a "real" name. Unnamed animations
     // all get the same standard name.
-    if(strcmp(name, ENTIRE_ANIMATION_NAME) != 0)
+    if(name.Compare(ENTIRE_ANIMATION_NAME) != 0)
     {
         hsAssert(anim, "registering nil anim");
         fAllAnims[name] = anim;
@@ -292,7 +285,7 @@ void plAGAnim::AddAnim(const char * name, plAGAnim *anim)
 
 // FindAnim -----------------------------------
 // ---------
-plAGAnim * plAGAnim::FindAnim(const char *name)
+plAGAnim * plAGAnim::FindAnim(const plString &name)
 {
     plAnimMap::iterator i = fAllAnims.find(name);
 
@@ -306,7 +299,7 @@ plAGAnim * plAGAnim::FindAnim(const char *name)
 
 // RemoveAnim -------------------------------
 // -----------
-hsBool plAGAnim::RemoveAnim(const char *name)
+hsBool plAGAnim::RemoveAnim(const plString &name)
 {
     plAnimMap::iterator i = fAllAnims.find(name);
 
@@ -328,8 +321,8 @@ void plAGAnim::DumpAnimationRegistry()
 
     do {
         plAGAnim *anim = (*i).second;
-        const char *name = anim->GetName();
-        hsStatusMessageF("GLOBAL ANIMS [%d]: <%s>", j++, name);
+        plString name = anim->GetName();
+        hsStatusMessageF("GLOBAL ANIMS [%d]: <%s>", j++, name.c_str());
     } while(++i != fAllAnims.end());
 }
 
@@ -342,7 +335,7 @@ hsBool plAGAnim::SharesPinsWith(const plAGAnim *anim) const
     {
         for (j = 0; j < anim->fApps.size(); j++)
         {
-            if (!strcmp(fApps[i]->GetChannelName(), anim->fApps[j]->GetChannelName()) &&
+            if (!fApps[i]->GetChannelName().Compare(anim->fApps[j]->GetChannelName()) &&
                 fApps[i]->CanBlend(anim->fApps[j]))
             {
                 return true;
@@ -367,7 +360,7 @@ plATCAnim::plATCAnim()
 
 // ctor --------------------------------------------------------
 // -----
-plATCAnim::plATCAnim(const char *name, double start, double end)
+plATCAnim::plATCAnim(const plString &name, double start, double end)
 : plAGAnim(name, start, end),
   fInitial(-1),
   fAutoStart(true),
@@ -389,11 +382,7 @@ plATCAnim::plATCAnim(const char *name, double start, double end)
 // -----
 plATCAnim::~plATCAnim()
 {
-    for (MarkerMap::iterator it = fMarkers.begin(); it != fMarkers.end(); it++)
-        delete [] (char*)it->first;
     fMarkers.clear();
-    for( LoopMap::iterator it2 = fLoops.begin(); it2 != fLoops.end(); it2++ )
-        delete [] (char *)it2->first;
     fLoops.clear();
     fStopPoints.clear();
 }
@@ -423,7 +412,7 @@ void plATCAnim::Read(hsStream *stream, hsResMgr *mgr)
     int numMarkers = stream->ReadLE32();
     for (i = 0; i < numMarkers; i++)
     {
-        char *name = stream->ReadSafeString();
+        plString name = stream->ReadSafeString_TEMP();
         float time = stream->ReadLEFloat();
         fMarkers[name] = time;
     }
@@ -431,7 +420,7 @@ void plATCAnim::Read(hsStream *stream, hsResMgr *mgr)
     int numLoops = stream->ReadLE32();
     for (i = 0; i < numLoops; i++)
     {
-        char *name = stream->ReadSafeString();
+        plString name = stream->ReadSafeString_TEMP();
         float begin = stream->ReadLEScalar();
         float end = stream->ReadLEScalar();
         fLoops[name] = std::pair<float,float>(begin,end);
@@ -498,15 +487,14 @@ void plATCAnim::CheckLoop()
 
 // AddLoop ------------------------------------------------------
 // --------
-void plATCAnim::AddLoop(const char *name, float start, float end)
+void plATCAnim::AddLoop(const plString &name, float start, float end)
 {
-    char *nameCpy = hsStrcpy(name);
-    fLoops[nameCpy] = std::pair<float,float>(start, end);
+    fLoops[name] = std::pair<float,float>(start, end);
 }
 
 // GetLoop --------------------------------------------------------------
 // --------
-bool plATCAnim::GetLoop(const char *name, float &start, float &end) const
+bool plATCAnim::GetLoop(const plString &name, float &start, float &end) const
 {
     LoopMap::const_iterator it = fLoops.find(name);
     if (it != fLoops.end())
@@ -549,15 +537,14 @@ uint32_t plATCAnim::GetNumLoops() const
 
 // AddMarker ------------------------------------------
 // ----------
-void plATCAnim::AddMarker(const char *name, float time)
+void plATCAnim::AddMarker(const plString &name, float time)
 {
-    char *nameCpy = hsStrcpy(name);
-    fMarkers[nameCpy] = time;
+    fMarkers[name] = time;
 }
 
 // GetMarker -------------------------------------
 // ----------
-float plATCAnim::GetMarker(const char *name) const
+float plATCAnim::GetMarker(const plString &name) const
 {
     if (fMarkers.find(name) != fMarkers.end())
         return (*fMarkers.find(name)).second;
@@ -566,13 +553,14 @@ float plATCAnim::GetMarker(const char *name) const
 
 // CopyMarkerNames -------------------------------------
 // ----------------
-void plATCAnim::CopyMarkerNames(std::vector<char*> &out)
+void plATCAnim::CopyMarkerNames(std::vector<plString> &out)
 {
     MarkerMap::iterator it = fMarkers.begin();
 
+    out.reserve(fMarkers.size());
     for (; it != fMarkers.end(); it++)
     {
-        out.push_back(hsStrcpy((*it).first));
+        out.push_back((*it).first);
     }
 }
 
@@ -613,7 +601,7 @@ plEmoteAnim::plEmoteAnim()
 
 // ctor ------------------------------------------------------------------------------
 // -----
-plEmoteAnim::plEmoteAnim(const char *animName, double begin, double end, float fadeIn,
+plEmoteAnim::plEmoteAnim(const plString &animName, double begin, double end, float fadeIn,
                          float fadeOut, BodyUsage bodyUsage)
 : plATCAnim(animName, begin, end),
   fFadeIn(fadeIn),
@@ -682,7 +670,7 @@ plAgeGlobalAnim::plAgeGlobalAnim()
 
 // ctor --------------------------------------------------------------------
 // -----
-plAgeGlobalAnim::plAgeGlobalAnim(const char *name, double start, double end)
+plAgeGlobalAnim::plAgeGlobalAnim(const plString &name, double start, double end)
 : plAGAnim(name, start, end),
   fGlobalVarName(nil)
 {
@@ -729,7 +717,7 @@ void plAgeGlobalAnim::Write(hsStream *stream, hsResMgr *mgr)
 
 // GetStartToEndTransform -----------------------------------------------
 bool GetStartToEndTransform(const plAGAnim *anim, hsMatrix44 *startToEnd,
-                            hsMatrix44 *endToStart, const char *channelName)
+                            hsMatrix44 *endToStart, const plString &channelName)
 {
     double start = 0.0f;    // assumed
     double end = anim->GetEnd();
@@ -740,7 +728,7 @@ bool GetStartToEndTransform(const plAGAnim *anim, hsMatrix44 *startToEnd,
 
 // GetRelativeTransform ---------------------------------------------------
 bool GetRelativeTransform(const plAGAnim *anim, double timeA, double timeB,
-                          hsMatrix44 *a2b, hsMatrix44 *b2a, const char *channelName)
+                          hsMatrix44 *a2b, hsMatrix44 *b2a, const plString &channelName)
 {
     bool result = false;
     plAGChannel *maybeChannel = anim->GetChannel(channelName);
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAGAnim.h b/Sources/Plasma/PubUtilLib/plAvatar/plAGAnim.h
index ef75eced..49eca8aa 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAGAnim.h
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAGAnim.h
@@ -92,7 +92,7 @@ public:
     plAGAnim();
     /** Construct with name, start time, and end time (within the max note track)
      */
-    plAGAnim(const char *name, double begin, double end);
+    plAGAnim(const plString &name, double begin, double end);
     /** Destruct, freeing the underlying animation data. */
     virtual ~plAGAnim();
 
@@ -112,12 +112,12 @@ public:
     /** Get the name of the channel having the given index. Useful for talking to an
         an animation before it is applied and finding out what channels it's going to
         affect. */
-    virtual const char * GetChannelName(int index);
+    virtual plString GetChannelName(int index);
 
     /** Get channel by name. This corresponds to the name of the scene object this channel
         will be attached to when the animation is applied.
         This function is fairly slow and shouldn't be used often. */
-    plAGChannel * GetChannel(const char *name) const;
+    plAGChannel * GetChannel(const plString &name) const;
 
     /** Return the number of applicators held by this animation. An applicator is used
         to attach a channel to a sceneobject. */
@@ -141,7 +141,7 @@ public:
         by the avatar or from script, but most of the functions which take an animation
         name (such as AttachAnimation on the plAGMasterMod) will also take an pointer
         to a plAGAnim. */
-    virtual const char * GetName() const { return fName; }
+    virtual plString GetName() const { return fName; }
 
     /** Return the length of the animation; end - start. */
     virtual float GetLength() const { return fEnd - fStart; }
@@ -176,12 +176,12 @@ public:
     /** Add the animation by name to a global static registry.
         This functionality will possibly be added to the resource
         manager. */
-    static void AddAnim(const char * name, plAGAnim *anim);
+    static void AddAnim(const plString & name, plAGAnim *anim);
     /** See if there is an animation with the given name in the
         global animation registry. */
-    static plAGAnim *FindAnim(const char *name);
+    static plAGAnim *FindAnim(const plString &name);
     /** Remove the given animation from the registry. */
-    static hsBool RemoveAnim(const char *name);
+    static hsBool RemoveAnim(const plString &name);
     /** Clear the animation cache. Used when resetting the client
         to a vanilla state, as when clearing the scene while
         exporting. */
@@ -199,17 +199,17 @@ protected:
     ApplicatorVec fApps;        /// our animation channels
     float fBlend;               /// requested blend factor
 
-    float fStart;            /// the start time of the beginning of the animation (usually 0)
-    float fEnd;              /// the end time of the animation
+    float fStart;               /// the start time of the beginning of the animation (usually 0)
+    float fEnd;                 /// the end time of the animation
 
-    char *fName;                /// the name of our animation
+    plString fName;             /// the name of our animation
 
     // ??? Can this be moved to the resource manager? If it can manage an efficient
     //     string-based namespace per class, we could get rid of this.
-    typedef std::map<const char *, plAGAnim *, stringISorter> plAnimMap;    //
+    typedef std::map<plString, plAGAnim *, plString::less_i> plAnimMap;    //
     static plAnimMap fAllAnims; /// map of animation names to animations
 
-    typedef std::map<const char *, plEmoteAnim *, stringISorter> plEmoteMap;
+    typedef std::map<plString, plEmoteAnim *, plString::less_i> plEmoteMap;
     static plEmoteMap fAllEmotes;
 };
 
@@ -230,7 +230,7 @@ public:
     plATCAnim();
     /** Construct with name, start time, and end time (within the max note track)
         Default is to start automatically, not loop, with no ease curves. */
-    plATCAnim(const char *name, double begin, double end);
+    plATCAnim(const plString &name, double begin, double end);
     /** Destruct, freeing the underlying animation data. */
     virtual ~plATCAnim();
 
@@ -305,11 +305,11 @@ public:
     /** Animations can have multiple defined loop segments; these
         are selected using animation control messages.
         Each loop segment is named using markers in the notetrack. */
-    void AddLoop(const char *name, float start, float end);
+    void AddLoop(const plString &name, float start, float end);
     /** Get the loop having the given name.
         \param start will return the start time of the loop.
         \param end will hold the end time of the loop */
-    bool GetLoop(const char *name, float &start, float &end) const;
+    bool GetLoop(const plString &name, float &start, float &end) const;
     /** Lets you get a loop by index instead of name. */
     bool GetLoop(uint32_t num, float &start, float &end) const;
     /** Returns the number of loops defined on this anim. */
@@ -318,10 +318,10 @@ public:
     /** Add a marker to the animation. Markers can be used
         for callbacks or for goto comands. A marker is a simple
         name/time tuple. */
-    void AddMarker(const char *name, float time);
+    void AddMarker(const plString &name, float time);
     /** Returns the time value of the marker named by name. */
-    float GetMarker(const char *name) const;
-    void CopyMarkerNames(std::vector<char*> &out);
+    float GetMarker(const plString &name) const;
+    void CopyMarkerNames(std::vector<plString> &out);
     /** Add a stop point to the animation. A stop point is a 
         "detent" for playback - if the animation is stopping
         near a stop point and fading out, the stop point will
@@ -363,10 +363,10 @@ protected:
     float fEaseOutMax;       /// maximum (initial) value of our ease-out
 
     // a map from segment names to times
-    typedef std::map<const char *, float, stringSorter> MarkerMap;
+    typedef std::map<plString, float> MarkerMap;
     MarkerMap fMarkers;
 
-    typedef std::map<const char *, std::pair<float,float>, stringSorter> LoopMap;
+    typedef std::map<plString, std::pair<float,float> > LoopMap;
     LoopMap fLoops;
 
     typedef std::vector<float> ScalarMap;
@@ -384,7 +384,7 @@ class plEmoteAnim : public plATCAnim
 public:
     
     plEmoteAnim();
-    plEmoteAnim(const char *animName, double begin, double end, float fadeIn, float fadeOut, BodyUsage bodyUsage);
+    plEmoteAnim(const plString &animName, double begin, double end, float fadeIn, float fadeOut, BodyUsage bodyUsage);
 
     BodyUsage GetBodyUsage() const;
     float GetFadeIn() const;
@@ -417,7 +417,7 @@ public:
     plAgeGlobalAnim();
     /** Construct with name, start time, and end time (within the max note track)
       */
-    plAgeGlobalAnim(const char *name, double begin, double end);
+    plAgeGlobalAnim(const plString &name, double begin, double end);
     /** Destruct, freeing the underlying animation data. */
     virtual ~plAgeGlobalAnim();
     
@@ -438,8 +438,8 @@ protected:
 };
 
 // USEFUL HELPER FUNCTIONS
-bool GetStartToEndTransform(const plAGAnim *anim, hsMatrix44 *startToEnd, hsMatrix44 *endToStart, const char *channelName);
-bool GetRelativeTransform(const plAGAnim *anim, double timeA, double timeB, hsMatrix44 *a2b, hsMatrix44 *b2a, const char *channelName);
+bool GetStartToEndTransform(const plAGAnim *anim, hsMatrix44 *startToEnd, hsMatrix44 *endToStart, const plString &channelName);
+bool GetRelativeTransform(const plAGAnim *anim, double timeA, double timeB, hsMatrix44 *a2b, hsMatrix44 *b2a, const plString &channelName);
 
 
 
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAGAnimInstance.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plAGAnimInstance.cpp
index 2ebd587e..a622cfab 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAGAnimInstance.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAGAnimInstance.cpp
@@ -123,7 +123,7 @@ plAGAnimInstance::plAGAnimInstance(plAGAnim * anim, plAGMasterMod * master,
     fCleanupChannels.push_back(timeChan);
 
 #ifdef SHOW_AG_CHANGES
-    hsStatusMessageF("\nAbout to Attach anim <%s>", GetName());
+    hsStatusMessageF("\nAbout to Attach anim <%s>", GetName().c_str());
     fMaster->DumpAniGraph("bone_pelvis", false, hsTimer::GetSysSeconds());
 #endif
 
@@ -131,7 +131,7 @@ plAGAnimInstance::plAGAnimInstance(plAGAnim * anim, plAGMasterMod * master,
     {
         plAGApplicator * app = fAnimation->GetApplicator(i);
         plAGChannel * inChannel = app->GetChannel();
-        const char * channelName = app->GetChannelName();
+        plString channelName = app->GetChannelName();
         plAGModifier * channelMod = master->GetChannelMod(channelName);
         
         if(channelMod) {
@@ -206,7 +206,7 @@ void plAGAnimInstance::SearchForGlobals()
     }
 }
 
-void plAGAnimInstance::IRegisterDetach(const char *channelName, plAGChannel *channel)
+void plAGAnimInstance::IRegisterDetach(const plString &channelName, plAGChannel *channel)
 {
     plDetachMap::value_type newPair(channelName, channel);
     fManualDetachChannels.insert(newPair);
@@ -243,14 +243,14 @@ void plAGAnimInstance::Detach()
 void plAGAnimInstance::DetachChannels()
 {
 #ifdef SHOW_AG_CHANGES
-    hsStatusMessageF("\nAbout to DETACH anim <%s>", GetName());
+    hsStatusMessageF("\nAbout to DETACH anim <%s>", GetName().c_str());
     fMaster->DumpAniGraph("bone_pelvis", false, hsTimer::GetSysSeconds());
 #endif
     plDetachMap::iterator i = fManualDetachChannels.begin();
 
     while(i != fManualDetachChannels.end())
     {
-        const char *channelName = (*i).first;
+        plString channelName = (*i).first;
         plAGModifier *channelMod = fMaster->GetChannelMod(channelName, true);
 
         if(channelMod)
@@ -274,7 +274,7 @@ void plAGAnimInstance::DetachChannels()
     fCleanupChannels.clear();
 
 #ifdef SHOW_AG_CHANGES
-    hsStatusMessageF("\nFinished DETACHING anim <%s>", GetName());
+    hsStatusMessageF("\nFinished DETACHING anim <%s>", GetName().c_str());
     fMaster->DumpAniGraph("bone_pelvis", false, hsTimer::GetSysSeconds());
 #endif
 }
@@ -323,12 +323,12 @@ float plAGAnimInstance::GetAmplitude()
 
 // GetName -----------------------------
 // --------
-const char * plAGAnimInstance::GetName()
+plString plAGAnimInstance::GetName()
 {
     if(fAnimation)
         return fAnimation->GetName();
     else
-        return nil;
+        return plString::Null;
 }
 
 // SetLoop ----------------------------------
@@ -409,7 +409,7 @@ void plAGAnimInstance::AttachCallbacks(plOneShotCallbacks *callbacks)
             eventMsg->fRepeats = 0;
             eventMsg->fUser = cb.fUser;
 
-            if (cb.fMarker)
+            if (!cb.fMarker.IsNull())
             {
                 float marker = anim->GetMarker(cb.fMarker);
                 hsAssert(marker != -1, "Bad marker name");
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAGAnimInstance.h b/Sources/Plasma/PubUtilLib/plAvatar/plAGAnimInstance.h
index 7c2ffd2d..b6f453f5 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAGAnimInstance.h
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAGAnimInstance.h
@@ -192,7 +192,7 @@ public:
     hsBool IsAtEnd();
 
     /** Get the name of the underlying animation. */
-    const char * GetName();
+    plString GetName();
 
     /** Remove all channels from the master mode and remove us from
         our master modifier.
@@ -224,14 +224,14 @@ protected:
     /** Set up bookkeeping for a fade. */
     void ISetupFade(float goal, float rate, bool detach, uint8_t type);
 
-    void IRegisterDetach(const char *channelName, plAGChannel *channel);
+    void IRegisterDetach(const plString &channelName, plAGChannel *channel);
 
     const plAGAnim * fAnimation;
     plAGMasterMod * fMaster;
 
-    std::map<char *, plAGChannelApplicator *, stringISorter> fChannels;
+    std::map<plString, plAGChannelApplicator *, plString::less_i> fChannels;
 
-    typedef std::multimap<const char *, plAGChannel *> plDetachMap;
+    typedef std::multimap<plString, plAGChannel *> plDetachMap;
     plDetachMap fManualDetachChannels;
 
     std::vector<plAGChannel*> fCleanupChannels;
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAGApplicator.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plAGApplicator.cpp
index 01e4eb0c..f10c94bd 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAGApplicator.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAGApplicator.cpp
@@ -48,24 +48,21 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 // -----
 plAGApplicator::plAGApplicator()
 : fChannel(nil),
-  fChannelName(nil),
   fEnabled(true)
 {
 };
 
 // ctor -------------------------------
 // -----
-plAGApplicator::plAGApplicator(const char *channelName)
+plAGApplicator::plAGApplicator(const plString &channelName)
 : fChannel(nil),
-  fEnabled(true)
+  fEnabled(true),
+  fChannelName(channelName)
 {
-    fChannelName = hsStrcpy(channelName);
 };
 
 plAGApplicator::~plAGApplicator()
 {
-    if(fChannelName)
-        delete[] fChannelName;
 }
 
 void plAGApplicator::Apply(const plAGModifier *mod, double time, hsBool force)
@@ -74,14 +71,14 @@ void plAGApplicator::Apply(const plAGModifier *mod, double time, hsBool force)
         IApply(mod, time);
 }
 
-void plAGApplicator::SetChannelName(const char *name)
+void plAGApplicator::SetChannelName(const plString &name)
 {
-    if(name)
-        fChannelName = hsStrcpy(name);
+    if(!name.IsNull())
+        fChannelName = name;
 };
 
 
-const char * plAGApplicator::GetChannelName()
+plString plAGApplicator::GetChannelName()
 {
     return fChannelName;
 };
@@ -141,7 +138,7 @@ void plAGApplicator::Read(hsStream *stream, hsResMgr *mgr)
 
     fEnabled = stream->ReadBool();
     fChannel = nil; // Whatever is reading this applicator in should know what channel to assign it
-    fChannelName = stream->ReadSafeString();
+    fChannelName = stream->ReadSafeString_TEMP();
 }
 
 // IGETxI
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAGApplicator.h b/Sources/Plasma/PubUtilLib/plAvatar/plAGApplicator.h
index cd346c5d..5eeebc4a 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAGApplicator.h
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAGApplicator.h
@@ -62,6 +62,7 @@ class plAGModifier;
 /////////////////////////////////////////////////////////////////////////////////////////
 #include "pnFactory/plCreatable.h"
 #include "plAvDefs.h"
+#include "plString.h"
 
 /////////////////////////////////////////////////////////////////////////////////////////
 //
@@ -88,7 +89,7 @@ public:
     // -- methods --
     /** Base constructor. */
     plAGApplicator();
-    plAGApplicator(const char *channelName);
+    plAGApplicator(const plString &channelName);
     virtual ~plAGApplicator();
 
     /** Return our single input channel. Applicators only ever
@@ -100,8 +101,12 @@ public:
     /** Set our input channel. Does not free the previous input channel. */
     void SetChannel(plAGChannel *channel) { fChannel = channel; }
 
-    void SetChannelName(const char *name);
-    const char * GetChannelName();
+    void SetChannelName(const plString &name);
+    plString GetChannelName();
+
+    // TEMP plString REVISIT
+    // Because I'm TOO LAZY to keep converting all these calls to SetChannelName
+    void SetChannelName(const char *name) { SetChannelName(_TEMP_CONVERT_FROM_LITERAL(name)); }
 
     /** Optionally suppress the action of this applicator.
         The applicator can still be forced to apply using the force
@@ -167,7 +172,7 @@ protected:
     // -- members --
     plAGChannel *fChannel;
     hsBool fEnabled;
-    char *fChannelName;
+    plString fChannelName;
 };
 
-#endif
\ No newline at end of file
+#endif
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAGChannel.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plAGChannel.cpp
index ef369a75..9aa7dbda 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAGChannel.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAGChannel.cpp
@@ -62,8 +62,6 @@ plAGChannel::plAGChannel()
 #ifdef TRACK_AG_ALLOCS
     fName = gGlobalAnimName;
     RegisterAGAlloc(this, gGlobalChannelName, gGlobalAnimName, this->ClassIndex());
-#else // TRACK_AG_ALLOCS
-    fName = nil;
 #endif // TRACK_AG_ALLOCS
 }
 
@@ -121,7 +119,7 @@ void plAGChannel::Read(hsStream *stream, hsResMgr *mgr)
 {
     plCreatable::Read(stream, mgr);
 
-    fName = stream->ReadSafeString();
+    fName = stream->ReadSafeString_TEMP();
 }
 
 ////////////////////////////////////////////////////////////////////////////////////
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAGChannel.h b/Sources/Plasma/PubUtilLib/plAvatar/plAGChannel.h
index f05752bb..3afaaac8 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAGChannel.h
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAGChannel.h
@@ -101,6 +101,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 /////////////////////////////////////////////////////////////////////////////////////////
 
 #include "pnFactory/plCreatable.h"
+#include "plString.h"
 
 /////////////////////////////////////////////////////////////////////////////////////////
 //
@@ -177,8 +178,8 @@ public:
     // \{
     /** The name of the channel is used to dynamically attach to sub-parts of an
         object. */
-    virtual const char * GetName() { return fName; };
-    virtual void SetName(char * name) { fName = name; };
+    virtual plString GetName() { return fName; };
+    virtual void SetName(const plString & name) { fName = name; };
     // \}
 
     // PLASMA PROTOCOL
@@ -191,7 +192,7 @@ public:
     virtual void Read(hsStream *s, hsResMgr *mgr);
 
 protected:
-    const char * fName;
+    plString fName;
 
 };
 
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAGMasterMod.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plAGMasterMod.cpp
index 8101dfac..f97c87c4 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAGMasterMod.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAGMasterMod.cpp
@@ -301,7 +301,7 @@ void plAGMasterMod::DumpAniGraph(const char *justThisChannel, bool optimized, do
     for(plChannelModMap::iterator j = fChannelMods.begin(); j != end; j++)
     {
         plAGModifier *mod = (*j).second;
-        if(!justThisChannel || stricmp(justThisChannel, mod->GetChannelName()) == 0)
+        if(!justThisChannel || mod->GetChannelName().Compare(justThisChannel, plString::kCaseInsensitive) == 0)
         {
             plAGApplicator *app = mod->GetApplicator(kAGPinTransform);
 
@@ -325,10 +325,10 @@ void plAGMasterMod::DumpAniGraph(const char *justThisChannel, bool optimized, do
 
 // GETCHANNELMOD(name)
 // Get the modifier that controls the channel with the given name
-plAGModifier * plAGMasterMod::GetChannelMod(const char * name, hsBool dontCache ) const
+plAGModifier * plAGMasterMod::GetChannelMod(const plString & name, hsBool dontCache ) const
 {
     plAGModifier * result = nil;
-    std::map<const char *, plAGModifier *, stringSorter>::const_iterator i = fChannelMods.find(name);
+    std::map<plString, plAGModifier *>::const_iterator i = fChannelMods.find(name);
 
     if (i != fChannelMods.end()) {
         result = (*i).second;
@@ -356,7 +356,7 @@ plAGModifier * plAGMasterMod::ICacheChannelMod(plAGModifier *mod) const
 // IFINDAGMOD (sceneObject)
 // See if there's an ag modifier on this sceneobject.
 // Doesn't check for multiples; just returns the first one.
-plAGModifier * plAGMasterMod::IFindChannelMod(const plSceneObject *SO, const char *name) const
+plAGModifier * plAGMasterMod::IFindChannelMod(const plSceneObject *SO, const plString &name) const
 {
     const plCoordinateInterface * CI = SO->GetCoordinateInterface();
 
@@ -365,8 +365,8 @@ plAGModifier * plAGMasterMod::IFindChannelMod(const plSceneObject *SO, const cha
 
     if(mod)
     {
-        const char *modName = mod->GetChannelName();
-        if(stricmp(name, modName) == 0)
+        plString modName = mod->GetChannelName();
+        if(modName.Compare(name, plString::kCaseInsensitive) == 0)
             return mod;
     }
 
@@ -421,7 +421,7 @@ plAGAnimInstance * plAGMasterMod::AttachAnimationBlended(plAGAnim *anim,
 }
 
 // ATTACHANIMATIONBLENDED(name, blend)
-plAGAnimInstance * plAGMasterMod::AttachAnimationBlended(const char *name, float blendFactor /* = 0 */, uint16_t blendPriority, hsBool cache /* = false */)
+plAGAnimInstance * plAGMasterMod::AttachAnimationBlended(const plString &name, float blendFactor /* = 0 */, uint16_t blendPriority, hsBool cache /* = false */)
 {
     plAGAnimInstance *instance = nil;
     plAGAnim *anim = plAGAnim::FindAnim(name);
@@ -433,7 +433,7 @@ plAGAnimInstance * plAGMasterMod::AttachAnimationBlended(const char *name, float
     return instance;
 }
 
-void plAGMasterMod::PlaySimpleAnim(const char *name)
+void plAGMasterMod::PlaySimpleAnim(const plString &name)
 {
     plATCAnim *anim = plATCAnim::ConvertNoRef(plAGAnim::FindAnim(name));
     plAGAnimInstance *instance = nil;
@@ -460,18 +460,18 @@ void plAGMasterMod::PlaySimpleAnim(const char *name)
 // FINDANIMINSTANCE
 // Look for an animation instance of the given name on the modifier.
 // If we need this to be fast, should make it a map rather than a vector
-plAGAnimInstance * plAGMasterMod::FindAnimInstance(const char *name)
+plAGAnimInstance * plAGMasterMod::FindAnimInstance(const plString &name)
 {
     plAGAnimInstance *result = nil;
 
-    if (name)
+    if (!name.IsNull())
     {
         for (int i = 0; i < fAnimInstances.size(); i++)
         {
             plAGAnimInstance *act = fAnimInstances[i];
-            const char *eachName = act->GetName();
+            plString eachName = act->GetName();
 
-            if( stricmp(eachName, name) == 0)
+            if( eachName.Compare(name, plString::kCaseInsensitive) == 0)
             {
                 result = act;
                 break;
@@ -482,7 +482,7 @@ plAGAnimInstance * plAGMasterMod::FindAnimInstance(const char *name)
 }
 
 // FINDORATTACHINSTANCE
-plAGAnimInstance * plAGMasterMod::FindOrAttachInstance(const char *name, float blendFactor)
+plAGAnimInstance * plAGMasterMod::FindOrAttachInstance(const plString &name, float blendFactor)
 {
     plAGAnimInstance *result = FindAnimInstance(name);
     if(result)
@@ -587,7 +587,7 @@ void plAGMasterMod::DetachAnimation(plAGAnimInstance *anim)
 }
 
 // DETACHANIMATION(name)
-void plAGMasterMod::DetachAnimation(const char *name)
+void plAGMasterMod::DetachAnimation(const plString &name)
 {
     plAGAnimInstance *anim = FindAnimInstance(name);
     if(anim) {
@@ -603,10 +603,10 @@ void plAGMasterMod::DumpCurrentAnims(const char *header)
     for(int i = nAnims - 1; i >= 0; i--)
     {
         plAGAnimInstance *inst = fAnimInstances[i];
-        const char *name = inst->GetName();
+        plString name = inst->GetName();
         float blend = inst->GetBlend();
 
-        hsStatusMessageF("%d: %s with blend of %f\n", i, name, blend);
+        hsStatusMessageF("%d: %s with blend of %f\n", i, name.c_str(), blend);
     }
 }
 
@@ -628,10 +628,10 @@ hsBool plAGMasterMod::MsgReceive(plMessage* msg)
 
     if (cmdMsg = plAnimCmdMsg::ConvertNoRef(msg))
     {
-        const char *targetName = cmdMsg->GetAnimName();
+        plString targetName = cmdMsg->GetAnimName();
 
-        if (!targetName)
-            targetName = ENTIRE_ANIMATION_NAME;
+        if (targetName.IsNull())
+            targetName = _TEMP_CONVERT_FROM_LITERAL(ENTIRE_ANIMATION_NAME);
 
         plAGAnimInstance *inst = FindAnimInstance(targetName);
         if (inst != nil)
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAGMasterMod.h b/Sources/Plasma/PubUtilLib/plAvatar/plAGMasterMod.h
index 2ee35d87..35fdb834 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAGMasterMod.h
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAGMasterMod.h
@@ -98,7 +98,7 @@ public:
     virtual ~plAGMasterMod();
 
     /** Find an individual plAGModifier of the given name under our control. */
-    plAGModifier * GetChannelMod(const char * name, hsBool dontCache = false) const;
+    plAGModifier * GetChannelMod(const plString & name, hsBool dontCache = false) const;
 
     /** \name Managing Animations */
     // \{
@@ -112,13 +112,13 @@ public:
 
     /** Look up the given animation by name and attach it
         with the given blend factor. */
-    plAGAnimInstance *AttachAnimationBlended(const char *name, float blendFactor = 0,
+    plAGAnimInstance *AttachAnimationBlended(const plString &name, float blendFactor = 0,
                                              uint16_t blendPriority = kAGMedBlendPriority,
                                              hsBool cache = false);
 
     /** Play a simple anim (one that doesn't affect root) once and auto detach. 
         Intended for Zandi's facial animations that run seperate from the behaviors. */
-    void PlaySimpleAnim(const char *name);
+    void PlaySimpleAnim(const plString &name);
                                              
     /** Detach the given animation instance. Does nothing
         if the instance is not managed by this master mod. */
@@ -128,7 +128,7 @@ public:
     /** Detach the given animation by name. Searches for
         any instances derived from animations with the
         given name and removes them. */
-    void DetachAnimation(const char *name);
+    void DetachAnimation(const plString &name);
     // \}
 
     /** Print the current animation stack to the console.
@@ -139,7 +139,7 @@ public:
 
     /** Find and return any animation instances with the
         given name on this master modifer. */
-    plAGAnimInstance *FindAnimInstance(const char *name);
+    plAGAnimInstance *FindAnimInstance(const plString &name);
 
     /** Return the Ith animation instance, based on blend
         order. Of dubious utility, but, y'know. */
@@ -152,7 +152,7 @@ public:
         attached, it could be anywhere, including buried under
         a bunch of other animations. If it's important that it be
         on top of the stack, you may need to detach it first. */
-    plAGAnimInstance *FindOrAttachInstance(const char *name, float blendFactor);
+    plAGAnimInstance *FindOrAttachInstance(const plString &name, float blendFactor);
 
     /** Return the number of animations available. */
     int GetNumAnimations();
@@ -218,7 +218,7 @@ public:
 protected:
     // -- methods --
     plAGModifier * ICacheChannelMod(plAGModifier *mod) const;
-    plAGModifier * IFindChannelMod(const plSceneObject *obj, const char *name) const;
+    plAGModifier * IFindChannelMod(const plSceneObject *obj, const plString &name) const;
 
     virtual hsBool IEval(double secs, float del, uint32_t dirty);
     
@@ -231,7 +231,7 @@ protected:
     plSceneObject*  fTarget;
 
     // a map from channel names to ag modifiers within our domain
-    typedef std::map<const char *, plAGModifier*, stringSorter> plChannelModMap;
+    typedef std::map<plString, plAGModifier*> plChannelModMap;
     plChannelModMap fChannelMods;
 
     // instances which are currently attached to this master
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAGModifier.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plAGModifier.cpp
index e72e96e2..d5bfacfb 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAGModifier.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAGModifier.cpp
@@ -64,28 +64,21 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 plAGModifier::plAGModifier()
 : plSingleModifier()
 {
-    fChannelName = nil;
     fAutoApply = true;
     fEnabled = true;
 }
 
 // CTOR(name)
-plAGModifier::plAGModifier(const char *name, hsBool autoApply)
+plAGModifier::plAGModifier(const plString &name, hsBool autoApply)
 : plSingleModifier(), fAutoApply(autoApply)
 {
-    fChannelName = hsStrcpy(name);
+    fChannelName = name;
     fEnabled = true;
 }
 
 // DTOR
 plAGModifier::~plAGModifier()
 {
-    if(fChannelName)
-    {
-        delete[] fChannelName;
-        fChannelName = nil;
-    }
-
     int i;
     for (i = 0; i < fApps.size(); i++)
     {
@@ -94,7 +87,7 @@ plAGModifier::~plAGModifier()
 }
 
 // GETCHANNELNAME
-const char * plAGModifier::GetChannelName() const
+plString plAGModifier::GetChannelName() const
 {
     return fChannelName;
 }
@@ -106,9 +99,9 @@ void plAGModifier::Enable(hsBool val)
 }
 
 // SETCHANNELNAME
-void plAGModifier::SetChannelName(char * name)
+void plAGModifier::SetChannelName(const plString & name)
 {
-    fChannelName = hsStrcpy(name);
+    fChannelName = name;
 }
 
 // IAPPLYCHANNELS (time)
@@ -276,7 +269,7 @@ void plAGModifier::Read(hsStream *stream, hsResMgr *mgr)
     plSingleModifier::Read(stream, mgr);
 
     // read in the name of the modifier
-    fChannelName = stream->ReadSafeString();
+    fChannelName = stream->ReadSafeString_TEMP();
 }
 
 // WRITE
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAGModifier.h b/Sources/Plasma/PubUtilLib/plAvatar/plAGModifier.h
index 703ac05b..d08a3711 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAGModifier.h
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAGModifier.h
@@ -89,19 +89,19 @@ public:
         incoming channels with this modifier. You may also supply an
         autoApply parameter, which indicates whether this modifier
         should apply itself every frame, or only when explicitly asked to. */
-    plAGModifier(const char *name, hsBool autoApply = true);
+    plAGModifier(const plString &name, hsBool autoApply = true);
 
     /** It's a destructor. Destroys the name passed into the constructor,
         and a bunch of other stuff you don't need to know anything about. */
     virtual ~plAGModifier();
 
     /** Get the name of the channel controlled by this modifier. */
-    const char * GetChannelName() const;
+    plString GetChannelName() const;
     /** Change the channel name of the modifier. Will delete the previous
         name. Will NOT remove any channels that are already attached, so 
         you could wind up with a modifier named "Fred" and a bunch of
         channels attached to it that were intended for "Lamont." */
-    void SetChannelName(char * name);
+    void SetChannelName(const plString & name);
 
     /** Attach a new applicator to our modifier. Will arbitrate with existing
         modifiers if necessary, based on pin type. May destruct existing applicators. */
@@ -139,9 +139,9 @@ protected:
     typedef std::vector<plAGApplicator*> plAppTable;
     plAppTable fApps;           // the applicators (with respective channels) that we're applying to our scene object
 
-    char *fChannelName;         // name used for matching animation channels to this modifier
-    hsBool  fAutoApply;         // evaluate animation automatically during IEval call
-    hsBool  fEnabled;           // if not enabled, we don't eval any of our anims
+    plString fChannelName;      // name used for matching animation channels to this modifier
+    hsBool   fAutoApply;        // evaluate animation automatically during IEval call
+    hsBool   fEnabled;          // if not enabled, we don't eval any of our anims
 
     // APPLYING THE ANIMATION
     virtual hsBool IEval(double secs, float del, uint32_t dirty);
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAnimStage.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plAnimStage.cpp
index d4408413..37a8dc11 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAnimStage.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAnimStage.cpp
@@ -277,7 +277,7 @@ plAGAnimInstance * plAnimStage::Attach(plArmatureMod *armature, plArmatureBrain
     if(fAnimInstance)
     {
         fAnimInstance->Stop();      // we'll be setting the time directly.
-        fAnimatedHandle = (fAnimInstance->GetAnimation()->GetChannel("Handle") != nil);
+        fAnimatedHandle = (fAnimInstance->GetAnimation()->GetChannel(_TEMP_CONVERT_FROM_LITERAL("Handle")) != nil);
         fAttached = true;
         // this is too early to send the enter notify. we're attached, but we may not
         // have faded in yet.
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plArmatureMod.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plArmatureMod.cpp
index 5b480fd8..266b3de8 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plArmatureMod.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plArmatureMod.cpp
@@ -660,11 +660,11 @@ void plArmatureMod::IInitDefaults()
     fPhysHeight = 0.f;
     fPhysWidth = 0.f;
     fUpdateMsg = nil;
-    fRootName = nil;
+    fRootName = plString::Null;
     fDontPanicLink = false;
     fBodyAgeName = "GlobalAvatars";
     fBodyFootstepSoundPage = "Audio";
-    fAnimationPrefix = "Male";
+    fAnimationPrefix = _TEMP_CONVERT_FROM_LITERAL("Male");
     fUserStr = "";
 }
 
@@ -677,7 +677,6 @@ plArmatureMod::plArmatureMod() : plArmatureModBase()
 plArmatureMod::~plArmatureMod()
 {
     delete fBoneMap;
-    delete [] fRootName;
 
     if (fUpdateMsg)
         fUpdateMsg->UnRef();
@@ -746,7 +745,7 @@ void plArmatureMod::GetPositionAndRotationSim(hsPoint3* position, hsQuat* rotati
     }
 }
 
-const plSceneObject *plArmatureMod::FindBone(const char * name) const
+const plSceneObject *plArmatureMod::FindBone(const plString & name) const
 {
     plSceneObject *result = nil;
 
@@ -1034,14 +1033,12 @@ void plArmatureMod::PanicLink(hsBool playLinkOutAnim /* = true */)
     {
         plAvOneShotLinkTask *task = new plAvOneShotLinkTask;
 
-        char *animName = MakeAnimationName("FallingLinkOut");
+        plString animName = MakeAnimationName("FallingLinkOut");
         task->SetAnimName(animName);
-        task->SetMarkerName("touch");
+        task->SetMarkerName(_TEMP_CONVERT_FROM_LITERAL("touch"));
     
         plAvTaskMsg *taskMsg = new plAvTaskMsg(GetKey(), GetKey(), task);
         taskMsg->Send();
-
-        delete [] animName;
     }
     else
     {
@@ -1059,10 +1056,9 @@ void plArmatureMod::PersonalLink()
     else
     {
         plAvOneShotLinkTask *task = new plAvOneShotLinkTask;
-        char *animName = MakeAnimationName("PersonalLink"); 
+        plString animName = MakeAnimationName("PersonalLink");
         task->SetAnimName(animName);
-        task->SetMarkerName("touch");
-        delete [] animName;
+        task->SetMarkerName(_TEMP_CONVERT_FROM_LITERAL("touch"));
         
         plAvTaskMsg *taskMsg = new plAvTaskMsg(GetKey(), GetKey(), task);
         taskMsg->SetBCastFlag(plMessage::kNetPropagate);    
@@ -1758,7 +1754,7 @@ void plArmatureMod::Read(hsStream * stream, hsResMgr *mgr)
     fMeshKeys.push_back(mgr->ReadKey(stream));
 
     // read the root name string
-    fRootName = stream->ReadSafeString();
+    fRootName = stream->ReadSafeString_TEMP();
 
     // read in the brains
     int nBrains = stream->ReadLE32();
@@ -1825,11 +1821,9 @@ void plArmatureMod::Read(hsStream * stream, hsResMgr *mgr)
     fPhysHeight = stream->ReadLEFloat();
     fPhysWidth = stream->ReadLEFloat();
 
-    char* temp = stream->ReadSafeString();
-    fAnimationPrefix = temp;
-    delete [] temp;
+    fAnimationPrefix = stream->ReadSafeString_TEMP();
 
-    temp = stream->ReadSafeString();
+    char *temp = stream->ReadSafeString();
     fBodyAgeName = temp;
     delete [] temp;
 
@@ -1906,7 +1900,7 @@ void plArmatureMod::ICustomizeApplicator()
 {
     plArmatureModBase::ICustomizeApplicator();
 
-    const plAGModifier *agMod = GetChannelMod("Bone_Root", true);
+    const plAGModifier *agMod = GetChannelMod(_TEMP_CONVERT_FROM_LITERAL("Bone_Root"), true);
     if (agMod)
     {
         // are there any applicators that manipulate the transform?
@@ -2387,35 +2381,31 @@ bool plArmatureMod::FindMatchingGenericBrain(const char *names[], int count)
     return false;
 }
 
-char *plArmatureMod::MakeAnimationName(const char *baseName) const
+plString plArmatureMod::MakeAnimationName(const char *baseName) const
 {
-    std::string temp = fAnimationPrefix + baseName;
-    char *result = hsStrcpy(temp.c_str()); // why they want a new string I'll never know... but hey, too late to change it now
-    return result;
+    return fAnimationPrefix + _TEMP_CONVERT_FROM_LITERAL(baseName);
 }
 
-char *plArmatureMod::GetRootName()
+plString plArmatureMod::GetRootName()
 {
     return fRootName;
 }
 
-void plArmatureMod::SetRootName(const char *name)
+void plArmatureMod::SetRootName(const plString &name)
 {
-    delete [] fRootName;
-    fRootName = hsStrcpy(name);
+    fRootName = name;
 }
 
 plAGAnim *plArmatureMod::FindCustomAnim(const char *baseName) const
 {
-    char *customName = MakeAnimationName(baseName);
+    plString customName = MakeAnimationName(baseName);
     plAGAnim *result = plAGAnim::FindAnim(customName);
-    delete[] customName;
     return result;
 }
 
 void plArmatureMod::ISetupMarkerCallbacks(plATCAnim *anim, plAnimTimeConvert *atc)
 {
-    std::vector<char*> markers;
+    std::vector<plString> markers;
     anim->CopyMarkerNames(markers);
 
     int i;
@@ -2424,12 +2414,12 @@ void plArmatureMod::ISetupMarkerCallbacks(plATCAnim *anim, plAnimTimeConvert *at
         
         float time = -1;
         hsBool isLeft = false;
-        if (strstr(markers[i], "SndLeftFootDown") == markers[i])
+        if (markers[i].Find("SndLeftFootDown") == 0)
         {
             isLeft = true;      
             time = anim->GetMarker(markers[i]);
         }
-        if (strstr(markers[i], "SndRightFootDown") == markers[i])
+        if (markers[i].Find("SndRightFootDown") == 0)
             time = anim->GetMarker(markers[i]);
 
         if (time >= 0)
@@ -2461,40 +2451,38 @@ void plArmatureMod::ISetupMarkerCallbacks(plATCAnim *anim, plAnimTimeConvert *at
             hsRefCnt_SafeUnRef(foot);
             hsRefCnt_SafeUnRef(iMsg);
         }
-
-        delete [] markers[i]; // done with this string, nuke it
     }
 }
 
-const char *plArmatureMod::GetAnimRootName(const char *name)
+plString plArmatureMod::GetAnimRootName(const plString &name)
 {
-    return name + fAnimationPrefix.length();
+    return name.Substr(fAnimationPrefix.GetSize());
 }
 
-int8_t plArmatureMod::AnimNameToIndex(const char *name)
+int8_t plArmatureMod::AnimNameToIndex(const plString &name)
 {
-    const char *rootName = GetAnimRootName(name);
+    plString rootName = GetAnimRootName(name);
     int8_t result = -1;
     
-    if (!strcmp(rootName, "Walk") || !strcmp(rootName, "WalkBack") ||
-        !strcmp(rootName, "LadderDown") || !strcmp(rootName, "LadderDownOn") ||
-        !strcmp(rootName, "LadderDownOff") || !strcmp(rootName, "LadderUp") ||
-        !strcmp(rootName, "LadderUpOn") || !strcmp(rootName, "LadderUpOff") ||
-        !strcmp(rootName, "SwimSlow") || !strcmp(rootName, "SwimBackward") ||
-        !strcmp(rootName, "BallPushWalk"))
+    if (!rootName.Compare("Walk") || !rootName.Compare("WalkBack") ||
+        !rootName.Compare("LadderDown") || !rootName.Compare("LadderDownOn") ||
+        !rootName.Compare("LadderDownOff") || !rootName.Compare("LadderUp") ||
+        !rootName.Compare("LadderUpOn") || !rootName.Compare("LadderUpOff") ||
+        !rootName.Compare("SwimSlow") || !rootName.Compare("SwimBackward") ||
+        !rootName.Compare("BallPushWalk"))
         result = kWalk;
-    else if (!strcmp(rootName, "Run") || !strcmp(rootName, "SwimFast"))
+    else if (!rootName.Compare("Run") || !rootName.Compare("SwimFast"))
         result = kRun;
-    else if (!strcmp(rootName, "TurnLeft") || !strcmp(rootName, "TurnRight") ||
-             !strcmp(rootName, "StepLeft") || !strcmp(rootName, "StepRight") ||
-             !strcmp(rootName, "SideSwimLeft") || !strcmp(rootName, "SideSwimRight") ||
-             !strcmp(rootName, "TreadWaterTurnLeft") || !strcmp(rootName, "TreadWaterTurnRight"))
+    else if (!rootName.Compare("TurnLeft") || !rootName.Compare("TurnRight") ||
+             !rootName.Compare("StepLeft") || !rootName.Compare("StepRight") ||
+             !rootName.Compare("SideSwimLeft") || !rootName.Compare("SideSwimRight") ||
+             !rootName.Compare("TreadWaterTurnLeft") || !rootName.Compare("TreadWaterTurnRight"))
         result = kTurn;
-    else if (!strcmp(rootName, "GroundImpact") || !strcmp(rootName, "RunningImpact"))
+    else if (!rootName.Compare("GroundImpact") || !rootName.Compare("RunningImpact"))
         result = kImpact;
-    else if (strstr(rootName, "Run")) // Critters
+    else if (rootName.Find("Run") >= 0) // Critters
         result = kRun;
-    else if (strstr(rootName, "Idle")) // Critters
+    else if (rootName.Find("Idle") >= 0) // Critters
         result = kWalk;
         
     return result;
@@ -2590,10 +2578,10 @@ plArmatureLODMod::plArmatureLODMod()
 }
 
 // CTOR (physical, name)
-plArmatureLODMod::plArmatureLODMod(const char* root_name)
+plArmatureLODMod::plArmatureLODMod(const plString& root_name)
 : plArmatureMod()
 {
-    fRootName = hsStrcpy(root_name);
+    fRootName = root_name;
 }
 
 plArmatureLODMod::~plArmatureLODMod()
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plArmatureMod.h b/Sources/Plasma/PubUtilLib/plAvatar/plArmatureMod.h
index c89fa1df..a5e445d9 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plArmatureMod.h
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plArmatureMod.h
@@ -221,7 +221,7 @@ public:
 
     hsBool IsLocalAvatar();
     hsBool IsLocalAI();
-    virtual const plSceneObject *FindBone(const char * name) const;
+    virtual const plSceneObject *FindBone(const plString & name) const;
     virtual const plSceneObject *FindBone(uint32_t id) const; // use an id from an appropriate taxonomy, such as plAvBrainHuman::BoneID
     virtual void AddBoneMapping(uint32_t id, const plSceneObject *bone);
     plAGModifier *GetRootAGMod();
@@ -298,15 +298,15 @@ public:
         kSwim,
     };
 
-    const char *GetAnimRootName(const char *name);
-    int8_t AnimNameToIndex(const char *name);
+    plString GetAnimRootName(const plString &name);
+    int8_t AnimNameToIndex(const plString &name);
     void SetBodyType(int type) { fBodyType = type; }
     int  GetBodyType(int type) { return fBodyType; }
     int  GetCurrentGenericType();
     bool FindMatchingGenericBrain(const char *names[], int count);
-    char *MakeAnimationName(const char * baseName) const;
-    char *GetRootName();
-    void SetRootName(const char *name);
+    plString MakeAnimationName(const char * baseName) const;
+    plString GetRootName();
+    void SetRootName(const plString &name);
     
     int  RefreshDebugDisplay();
     void DumpToDebugDisplay(int &x, int &y, int lineHeight, char *strBuf, plDebugText &debugTxt);
@@ -369,7 +369,7 @@ public:
 
     void SetBodyAgeName(const char* ageName) {if (ageName) fBodyAgeName = ageName; else fBodyAgeName = "";}
     void SetBodyFootstepSoundPage(const char* pageName) {if (pageName) fBodyFootstepSoundPage = pageName; else fBodyFootstepSoundPage = "";}
-    void SetAnimationPrefix(const char* prefix) {if (prefix) fAnimationPrefix = prefix; else fAnimationPrefix = "";}
+    void SetAnimationPrefix(const plString& prefix) { fAnimationPrefix = prefix; }
 
     const char* GetUserStr() {return fUserStr.c_str();}
 
@@ -388,16 +388,16 @@ protected:
     void    ISetTransparentDrawOrder(bool val);
     plLayerLinkAnimation *IFindLayerLinkAnim();
     
-    char *fRootName;                        // the name of the player root (from the max file)
+    plString            fRootName;          // the name of the player root (from the max file)
     hsBitVector         fMoveFlags;         // which keys/buttons are currently pressed
     hsBitVector         fMoveFlagsBackup;   // a copy of fMoveFlags
     typedef std::vector<plControlEventMsg*> CtrlMessageVec;
     CtrlMessageVec      fQueuedCtrlMessages;    // input messages we haven't processed
-    float            fMouseFrameTurnStrength; // Sum turnage from mouse delta messages since last eval.
+    float               fMouseFrameTurnStrength; // Sum turnage from mouse delta messages since last eval.
     plKey               fFootSoundSOKey;    // The Scene Object we attach to targets for footstep sounds
     plKey               fLinkSoundSOKey;    // Same thing for linking... wwwwawAWAWAwawa...
     plKey               fLinkInAnimKey;     // Set when we link out, this is the anim to play (backwards) when we link in.
-    static float     fMouseTurnSensitivity;
+    static float        fMouseTurnSensitivity;
     plArmatureUpdateMsg *fUpdateMsg;    
     
     // Trying to be a good lad here and align all our bools and bytes...
@@ -443,7 +443,7 @@ protected:
     // strings for animations, age names, footstep sounds, etc
     std::string fBodyAgeName;
     std::string fBodyFootstepSoundPage;
-    std::string fAnimationPrefix;
+    plString fAnimationPrefix;
 
     // user-defined string assigned to this avatar
     std::string fUserStr;
@@ -457,7 +457,7 @@ class plArmatureLODMod : public plArmatureMod
 public:
     // tors
     plArmatureLODMod();
-    plArmatureLODMod(const char * root_name);
+    plArmatureLODMod(const plString & root_name);
     virtual ~plArmatureLODMod();
 
     CLASSNAME_REGISTER( plArmatureLODMod );
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAvBehaviors.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plAvBehaviors.cpp
index cf6a7ff1..bfbcdf25 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAvBehaviors.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAvBehaviors.cpp
@@ -109,9 +109,9 @@ void plArmatureBehavior::DumpDebug(int &x, int &y, int lineHeight, char *strBuf,
 
     if (fAnim)
     {
-        const char *animName = fAnim->GetName();
+        plString animName = fAnim->GetName();
         float time = fAnim->GetTimeConvert()->CurrentAnimTime();    
-        sprintf(strBuf, "%20s %3s time: %5.2f %s", animName, onOff, time, blendBar);
+        sprintf(strBuf, "%20s %3s time: %5.2f %s", animName.c_str(), onOff, time, blendBar);
     }
     else
         sprintf(strBuf, "         Behavior %2d %3s %s", fIndex, onOff, blendBar);
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAvBrainClimb.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plAvBrainClimb.cpp
index 802d5be3..46a40850 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAvBrainClimb.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAvBrainClimb.cpp
@@ -714,7 +714,7 @@ void plAvBrainClimb::ICalcProbeLengths()
     hsAssert(up, "Couldn't find ClimbUp animation.");
     if(up)
     {
-        GetStartToEndTransform(up, &upMove, nil, "Handle");
+        GetStartToEndTransform(up, &upMove, nil, _TEMP_CONVERT_FROM_LITERAL("Handle"));
         fVerticalProbeLength = upMove.GetTranslate().fZ;
     } else
         fVerticalProbeLength = 4.0f;    // guess
@@ -722,7 +722,7 @@ void plAvBrainClimb::ICalcProbeLengths()
     hsAssert(left, "Couldn't find ClimbLeft animation.");
     if(left)
     {
-        GetStartToEndTransform(left, &leftMove, nil, "Handle");
+        GetStartToEndTransform(left, &leftMove, nil, _TEMP_CONVERT_FROM_LITERAL("Handle"));
         fHorizontalProbeLength = leftMove.GetTranslate().fX;
     } else
         fHorizontalProbeLength = 3.0f;  // guess
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAvBrainCritter.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plAvBrainCritter.cpp
index 88003c14..c0b5fb80 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAvBrainCritter.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAvBrainCritter.cpp
@@ -95,7 +95,7 @@ public:
     void SetAnimTime(float time) {fAnim->SetCurrentTime(time, true);}
 
     std::string Name() const {return fName;}
-    std::string AnimName() const {return fAnimName;}
+    plString AnimName() const {return fAnimName;}
     bool RandomStartPoint() const {return fRandomStartPoint;}
     float FadeInLength() const {return fFadeInLength;}
     float FadeOutLength() const {return fFadeOutLength;}
@@ -117,7 +117,7 @@ protected:
     plAvBrainCritter *fCritterBrain;
 
     std::string fName; // user-created name for this behavior, also used as the index into the brain's behavior map
-    std::string fAnimName; // physical animation's name, for reference
+    plString fAnimName; // physical animation's name, for reference
     bool fRandomStartPoint; // do we want this behavior to start at a random frame every time we start it?
     float fFadeInLength; // how long to fade in this behavior
     float fFadeOutLength; // how long to fade out this behavior
@@ -290,10 +290,10 @@ std::string plAvBrainCritter::BehaviorName(int behavior) const
     return ((CritterBehavior*)fBehaviors[behavior])->Name();
 }
 
-std::string plAvBrainCritter::AnimationName(int behavior) const
+plString plAvBrainCritter::AnimationName(int behavior) const
 {
     if ((behavior >= fBehaviors.Count()) || (behavior < 0))
-        return "";
+        return _TEMP_CONVERT_FROM_LITERAL("");
     return ((CritterBehavior*)fBehaviors[behavior])->AnimName();
 }
 
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAvBrainCritter.h b/Sources/Plasma/PubUtilLib/plAvatar/plAvBrainCritter.h
index 96a0c5f0..dd89f40c 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAvBrainCritter.h
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAvBrainCritter.h
@@ -92,7 +92,7 @@ public:
     bool LocallyControlled() const {return fLocallyControlled;}
 
     std::string BehaviorName(int behavior) const;
-    std::string AnimationName(int behavior) const;
+    plString AnimationName(int behavior) const;
     int CurBehavior() const {return fCurMode;}
     int NextBehavior() const {return fNextMode;}
 
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAvBrainHuman.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plAvBrainHuman.cpp
index 0d1d292b..34581ae7 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAvBrainHuman.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAvBrainHuman.cpp
@@ -309,7 +309,7 @@ void plAvBrainHuman::IInitBoneMap()
     for(int i = 0; i < numTuples; i++)
     {
         HumanBoneID id = tupleMap[i].fID;
-        const char * name = tupleMap[i].fName;
+        plString name = _TEMP_CONVERT_FROM_LITERAL(tupleMap[i].fName);
         
         const plSceneObject * bone = this->fAvMod->FindBone(name);
         if( bone )
@@ -317,7 +317,7 @@ void plAvBrainHuman::IInitBoneMap()
             fAvMod->AddBoneMapping(id, bone);
         }
         else
-            hsStatusMessageF("Couldn't find standard bone %s.", name);
+            hsStatusMessageF("Couldn't find standard bone %s.", name.c_str());
     }
 }
 
@@ -346,9 +346,8 @@ void plAvBrainHuman::Suspend()
     // Kind of hacky... but this is a rather rare case.
     // If the user lets up on the PushToTalk key in another brain
     // we'll miss the message to take off the animation.
-    char *chatAnimName = fAvMod->MakeAnimationName("Talk"); 
+    plString chatAnimName = fAvMod->MakeAnimationName("Talk");
     plAGAnimInstance *anim = fAvMod->FindAnimInstance(chatAnimName);
-    delete [] chatAnimName;
     if (anim)
         anim->FadeAndDetach(0, 1);
 
@@ -699,7 +698,7 @@ void plAvBrainHuman::TurnToPoint(hsPoint3 point)
 
 void plAvBrainHuman::IChatOn()
 {
-    char *chatAnimName = fAvMod->MakeAnimationName("Talk");
+    plString chatAnimName = fAvMod->MakeAnimationName("Talk");
 
     // check that we aren't adding this twice...
     if (!fAvMod->FindAnimInstance(chatAnimName))
@@ -713,13 +712,11 @@ void plAvBrainHuman::IChatOn()
             taskMsg->Send();
         }
     }
-
-    delete [] chatAnimName;
 }
 
 void plAvBrainHuman::IChatOff()
 {
-    char *chatAnimName = fAvMod->MakeAnimationName("Talk");
+    plString chatAnimName = fAvMod->MakeAnimationName("Talk");
     plKey avKey = fAvMod->GetKey();
     plAvAnimTask *animTask = new plAvAnimTask(chatAnimName, -1.0);
     if (animTask)
@@ -728,7 +725,6 @@ void plAvBrainHuman::IChatOff()
         taskMsg->SetBCastFlag(plMessage::kNetPropagate);
         taskMsg->Send();
     }
-    delete[] chatAnimName;
 }
 
 hsBool plAvBrainHuman::IInitAnimations()
@@ -1422,12 +1418,11 @@ bool PushSimpleMultiStage(plArmatureMod *avatar, const char *enterAnim, const ch
 bool AvatarEmote(plArmatureMod *avatar, const char *emoteName)
 {
     bool result = false;
-    char *fullName = avatar->MakeAnimationName(emoteName);
+    plString fullName = avatar->MakeAnimationName(emoteName);
     plAGAnim *anim = plAGAnim::FindAnim(fullName);
     plEmoteAnim *emote = plEmoteAnim::ConvertNoRef(anim);
     hsBool alreadyActive = avatar->FindAnimInstance(fullName) != nil;
     plAvBrainHuman *huBrain = plAvBrainHuman::ConvertNoRef(avatar->FindBrainByClass(plAvBrainHuman::Index()));
-    delete[] fullName;
 
     // XXX
     plAvBrainSwim *swimBrain = plAvBrainSwim::ConvertNoRef(avatar->GetCurrentBrain());
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAvTaskSeek.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plAvTaskSeek.cpp
index a720ab14..ee937f5c 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAvTaskSeek.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAvTaskSeek.cpp
@@ -534,7 +534,7 @@ hsBool plAvTaskSeek::IUpdateObjective(plArmatureMod *avatar)
                 plAGAnim *anim = avatar->FindCustomAnim(fAnimName);
                 // don't need to do this every frame; the animation doesn't change.
                 // *** cache the adjustment;
-                GetStartToEndTransform(anim, nil, &adjustment, "Handle");   // actually getting end-to-start
+                GetStartToEndTransform(anim, nil, &adjustment, _TEMP_CONVERT_FROM_LITERAL("Handle"));   // actually getting end-to-start
                 // ... but we do still need to multiply by the (potentially changed) target
                 targL2W = targL2W * adjustment;
             }
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAvatarMgr.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plAvatarMgr.cpp
index 557e7937..62a0eb18 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAvatarMgr.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAvatarMgr.cpp
@@ -1022,7 +1022,7 @@ void plAvatarMgr::OfferLinkingBook(plKey hostKey, plKey guestKey, plMessage *lin
             
             brainG->AddStage(guestAccept);
             brainG->AddStage(guestAcceptIdle);
-            plCoopCoordinator *coord = new plCoopCoordinator(hostKey, guestKey, brainH, brainG, "Convergence", 1, 1, linkMsg, true);
+            plCoopCoordinator *coord = new plCoopCoordinator(hostKey, guestKey, brainH, brainG, _TEMP_CONVERT_FROM_LITERAL("Convergence"), 1, 1, linkMsg, true);
 
 
             plAvCoopMsg *coMg = new plAvCoopMsg(hostKey, coord);
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAvatarTasks.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plAvatarTasks.cpp
index c614f849..f4be85f8 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAvatarTasks.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAvatarTasks.cpp
@@ -249,7 +249,7 @@ hsBool plAvSeekTask::Start(plArmatureMod *avatar, plArmatureBrain *brain, double
             {
                 hsMatrix44 adjustment;
                 plAGAnim *anim = avatar->FindCustomAnim(fAnimName);
-                GetStartToEndTransform(anim, nil, &adjustment, "Handle");   // actually getting end-to-start
+                GetStartToEndTransform(anim, nil, &adjustment, _TEMP_CONVERT_FROM_LITERAL("Handle"));   // actually getting end-to-start
                 targetL2W = targetL2W * adjustment;
             }
             break;
@@ -334,8 +334,7 @@ void plAvSeekTask::LeaveAge(plArmatureMod *avatar)
 
 // CTOR default
 plAvAnimTask::plAvAnimTask()
-: fAnimName(nil),
-  fInitialBlend(0.0f),
+: fInitialBlend(0.0f),
   fTargetBlend(0.0f),
   fFadeSpeed(0.0f),
   fSetTime(0.0f),
@@ -347,7 +346,7 @@ plAvAnimTask::plAvAnimTask()
 }
 
 // CTOR animName, initialBlend, targetBlend, fadeSpeed, start, loop, attach
-plAvAnimTask::plAvAnimTask(const char *animName,
+plAvAnimTask::plAvAnimTask(const plString &animName,
                            float initialBlend,
                            float targetBlend,
                            float fadeSpeed,
@@ -355,7 +354,8 @@ plAvAnimTask::plAvAnimTask(const char *animName,
                            hsBool start,
                            hsBool loop,
                            hsBool attach)
-: fInitialBlend(initialBlend),
+: fAnimName(animName),
+  fInitialBlend(initialBlend),
   fTargetBlend(targetBlend),
   fFadeSpeed(fadeSpeed),
   fSetTime(setTime),
@@ -364,13 +364,12 @@ plAvAnimTask::plAvAnimTask(const char *animName,
   fAttach(attach),
   fAnimInstance(nil)
 {
-    if(animName)
-        fAnimName = hsStrcpy(animName);
 }
 
 // CTOR animName, fadeSpeed, attach
-plAvAnimTask::plAvAnimTask(const char *animName, float fadeSpeed, hsBool attach)
-: fInitialBlend(0.0f),
+plAvAnimTask::plAvAnimTask(const plString &animName, float fadeSpeed, hsBool attach)
+: fAnimName(animName),
+  fInitialBlend(0.0f),
   fTargetBlend(0.0f),
   fFadeSpeed(fadeSpeed),
   fSetTime(0.0f),
@@ -379,23 +378,11 @@ plAvAnimTask::plAvAnimTask(const char *animName, float fadeSpeed, hsBool attach)
   fAttach(attach),
   fAnimInstance(nil)
 {
-    if(animName)
-        fAnimName = hsStrcpy(animName);
 }
 
 
 
 
-// DTOR
-plAvAnimTask::~plAvAnimTask()
-{
-    if(fAnimName)
-    {
-        delete[] fAnimName;
-        fAnimName = nil;
-    }
-}
-
 // START
 hsBool plAvAnimTask::Start(plArmatureMod *avatar, plArmatureBrain *brain, double time, float elapsed)
 {
@@ -420,7 +407,7 @@ hsBool plAvAnimTask::Start(plArmatureMod *avatar, plArmatureBrain *brain, double
         }
         else
         {
-            hsStatusMessageF("Couldn't find animation <%s> for plAvAnimTask: will try again", fAnimName);
+            hsStatusMessageF("Couldn't find animation <%s> for plAvAnimTask: will try again", fAnimName.c_str());
         }
     }
     else
@@ -480,7 +467,7 @@ void plAvAnimTask::LeaveAge(plArmatureMod *avatar)
 // READ
 void plAvAnimTask::Read(hsStream *stream, hsResMgr *mgr)
 {
-    fAnimName = stream->ReadSafeString();
+    fAnimName = stream->ReadSafeString_TEMP();
     fInitialBlend = stream->ReadLEScalar();
     fTargetBlend = stream->ReadLEScalar();
     fFadeSpeed = stream->ReadLEScalar();
@@ -515,7 +502,6 @@ void plAvOneShotTask::InitDefaults()
     fBackwards = false;
     fDisableLooping = false;
     fDisablePhysics = true;
-    fAnimName = nil;
     fMoveHandle = false;
     fAnimInstance = nil;
     fDrivable = false;
@@ -537,7 +523,7 @@ plAvOneShotTask::plAvOneShotTask()
 // this construct is typically used when you want to create a one-shot task as part of a sequence
 // of tasks
 // it's different than the message-based constructor in that fDetachAnimation and fMoveHandle default to false
-plAvOneShotTask::plAvOneShotTask(const char *animName, hsBool drivable, hsBool reversible, plOneShotCallbacks *callbacks)
+plAvOneShotTask::plAvOneShotTask(const plString &animName, hsBool drivable, hsBool reversible, plOneShotCallbacks *callbacks)
 {
     InitDefaults();
 
@@ -547,7 +533,7 @@ plAvOneShotTask::plAvOneShotTask(const char *animName, hsBool drivable, hsBool r
     
     // we're going to use this sometime in the future, better ref it so someone else doesn't release it
     hsRefCnt_SafeRef(fCallbacks);
-    fAnimName = hsStrcpy(animName);
+    fAnimName = animName;
 }
 
 // CTOR (plAvOneShotMsg, plArmatureMod)
@@ -565,14 +551,12 @@ plAvOneShotTask::plAvOneShotTask (plAvOneShotMsg *msg, plArmatureMod *avatar, pl
 
     // we're going to use this sometime in the future, better ref it so someone else doesn't release it
     hsRefCnt_SafeRef(fCallbacks);
-    fAnimName = hsStrcpy(msg->fAnimName);
+    fAnimName = msg->fAnimName;
 }
 
 // DTOR
 plAvOneShotTask::~plAvOneShotTask()
 {
-    if(fAnimName)
-        delete[] fAnimName;
     hsRefCnt_SafeUnRef(fCallbacks);
 }
 
@@ -640,7 +624,7 @@ hsBool plAvOneShotTask::Start(plArmatureMod *avatar, plArmatureBrain *brain, dou
             plgDispatch::MsgSend( pMsg );   // whoosh... off it goes
         }
 
-        fMoveHandle = (fAnimInstance->GetAnimation()->GetChannel("Handle") != nil);
+        fMoveHandle = (fAnimInstance->GetAnimation()->GetChannel(_TEMP_CONVERT_FROM_LITERAL("Handle")) != nil);
         if(fMoveHandle)
         {
             plMatrixDifferenceApp *differ = avatar->GetRootAnimator();
@@ -654,9 +638,8 @@ hsBool plAvOneShotTask::Start(plArmatureMod *avatar, plArmatureBrain *brain, dou
     }
     else
     {
-        char buf[256];
-        sprintf(buf, "Oneshot: Can't find animation <%s>; all bets are off.", fAnimName);
-        hsAssert(false, buf);
+        plString buf = plString::Format("Oneshot: Can't find animation <%s>; all bets are off.", fAnimName.c_str());
+        hsAssert(false, buf.c_str());
         result = true;
     }
     return result;
@@ -750,10 +733,9 @@ void plAvOneShotTask::LeaveAge(plArmatureMod *avatar)
     fIgnore = true;
 }
 
-void plAvOneShotTask::SetAnimName(char *name)
+void plAvOneShotTask::SetAnimName(const plString &name)
 {
-    delete [] fAnimName;
-    fAnimName = hsStrcpy(name);
+    fAnimName = name;
 }
 
 //////////////////////
@@ -763,7 +745,6 @@ void plAvOneShotTask::SetAnimName(char *name)
 //////////////////////
 
 plAvOneShotLinkTask::plAvOneShotLinkTask() : plAvOneShotTask(), 
-fMarkerName(nil), 
 fMarkerTime(-1),
 fStartTime(0),
 fLinkFired(false)
@@ -773,7 +754,6 @@ fLinkFired(false)
 
 plAvOneShotLinkTask::~plAvOneShotLinkTask()
 {
-    delete [] fMarkerName;
 }
 
 // task protocol
@@ -782,7 +762,7 @@ hsBool plAvOneShotLinkTask::Start(plArmatureMod *avatar, plArmatureBrain *brain,
     hsBool result = plAvOneShotTask::Start(avatar, brain, time, elapsed);
     fStartTime = time;
 
-    if (fAnimInstance && fMarkerName)
+    if (fAnimInstance && !fMarkerName.IsNull())
     {
         const plATCAnim *anim = plATCAnim::ConvertNoRef(fAnimInstance->GetAnimation());
         if (anim)
@@ -824,14 +804,13 @@ void plAvOneShotLinkTask::Write(hsStream *stream, hsResMgr *mgr)
 void plAvOneShotLinkTask::Read(hsStream *stream, hsResMgr *mgr)
 {
     plAvOneShotTask::Read(stream, mgr);
-    fAnimName = stream->ReadSafeString();
-    fMarkerName = stream->ReadSafeString();
+    fAnimName = stream->ReadSafeString_TEMP();
+    fMarkerName = stream->ReadSafeString_TEMP();
 }
 
-void plAvOneShotLinkTask::SetMarkerName(char *name)
+void plAvOneShotLinkTask::SetMarkerName(const plString &name)
 {
-    delete [] fMarkerName;
-    fMarkerName = hsStrcpy(name);
+    fMarkerName = name;
 }
 
 
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAvatarTasks.h b/Sources/Plasma/PubUtilLib/plAvatar/plAvatarTasks.h
index 79b206ea..4ffb275e 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAvatarTasks.h
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAvatarTasks.h
@@ -84,15 +84,13 @@ public:
         \param loop Make the animation loop?
         \param attach Are we attaching or detaching the animation?
     */
-    plAvAnimTask(const char *animName, float initialBlend, float targetBlend, float fadeSpeed,
+    plAvAnimTask(const plString &animName, float initialBlend, float targetBlend, float fadeSpeed,
                  float setTime, hsBool start, hsBool loop, hsBool attach);
 
     /** Canonical constructor form form for detaching
         \param animName The name of the animation we're detaching
         \param fadeSpeed How fast to fade it out. */
-    plAvAnimTask(const char *animName, float fadeSpeed, hsBool attach = false);
-
-    virtual ~plAvAnimTask();
+    plAvAnimTask(const plString &animName, float fadeSpeed, hsBool attach = false);
 
     // task protocol
     virtual hsBool Start(plArmatureMod *avatar, plArmatureBrain *brain, double time, float elapsed);
@@ -108,11 +106,11 @@ public:
 
 protected:
     // public members
-    char* fAnimName;                    // the animation we're operating on
-    float fInitialBlend;             // the blend to establish (attaching only)
-    float fTargetBlend;              // the blend to achieve eventually (attaching only)
-    float fFadeSpeed;                // how fast to achieve the blend
-    float fSetTime;                  // set the animation to this time
+    plString fAnimName;                 // the animation we're operating on
+    float fInitialBlend;                // the blend to establish (attaching only)
+    float fTargetBlend;                 // the blend to achieve eventually (attaching only)
+    float fFadeSpeed;                   // how fast to achieve the blend
+    float fSetTime;                     // set the animation to this time
     hsBool fStart;                      // start the animation playing? (attaching only)
     hsBool fLoop;                       // turn on looping? (attaching only)
     hsBool fAttach;                     // attach? (otherwise detach)
@@ -184,7 +182,7 @@ public:
         \param reversable Unused. Allows the oneshot to be backed up by keyboard input
         \param callbacks A vector of callback messages to be sent at specific times during the animation
         */
-    plAvOneShotTask(const char *animName, hsBool drivable, hsBool reversible, plOneShotCallbacks *callbacks);
+    plAvOneShotTask(const plString &animName, hsBool drivable, hsBool reversible, plOneShotCallbacks *callbacks);
     /** Construct from a oneshot message.
         \param msg The message to copy our parameters from
         \param brain The brain to attach the task to.
@@ -197,7 +195,7 @@ public:
     virtual hsBool Process(plArmatureMod *avatar, plArmatureBrain *brain, double time, float elapsed);
     virtual void LeaveAge(plArmatureMod *avatar);
     
-    void SetAnimName(char *name);
+    void SetAnimName(const plString &name);
     
     static hsBool fForce3rdPerson;
 
@@ -211,7 +209,7 @@ public:
     
     // *** implement reader and writer if needed for network propagation
 protected:
-    char *fAnimName;                    // the name of the one-shot animation we want to use
+    plString fAnimName;                 // the name of the one-shot animation we want to use
     hsBool fMoveHandle;                 // move the handle after the oneshot's done playing?
     plAGAnimInstance *fAnimInstance;    // the animation instance (available only after it starts playing)
     hsBool fDrivable;                   // the user can control the animation with the mouse
@@ -257,10 +255,10 @@ public:
     virtual void Write(hsStream *stream, hsResMgr *mgr);
     virtual void Read(hsStream *stream, hsResMgr *mgr); 
 
-    void SetMarkerName(char *name);
+    void SetMarkerName(const plString &name);
         
 protected:
-    char *fMarkerName;
+    plString fMarkerName;
     double fStartTime;
     float fMarkerTime;
     hsBool fLinkFired;
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plCoopCoordinator.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plCoopCoordinator.cpp
index 9630e592..a408beae 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plCoopCoordinator.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plCoopCoordinator.cpp
@@ -94,7 +94,7 @@ plCoopCoordinator::plCoopCoordinator()
 // ------------------
 plCoopCoordinator::plCoopCoordinator(plKey host, plKey guest,
                                      plAvBrainCoop *hostBrain, plAvBrainCoop *guestBrain,
-                                     const char *synchBone,
+                                     const plString &synchBone,
                                      uint32_t hostOfferStage, uint32_t guestAcceptStage,
                                      plMessage *guestAcceptMsg,
                                      bool autoStartGuest)
@@ -108,6 +108,7 @@ plCoopCoordinator::plCoopCoordinator(plKey host, plKey guest,
   fGuestAcceptStage(guestAcceptStage),
   fGuestAcceptMsg(guestAcceptMsg),
   fAutoStartGuest(autoStartGuest),
+  fSynchBone(synchBone),
   fGuestAccepted(false),
   fGuestLinked(false)
 {
@@ -119,8 +120,6 @@ plCoopCoordinator::plCoopCoordinator(plKey host, plKey guest,
     
     plKey newKey = hsgResMgr::ResMgr()->NewKey(newName, this, host->GetUoid().GetLocation());
 
-    fSynchBone = hsStrcpy(synchBone);
-
     plKey avMgrKey = plAvatarMgr::GetInstance()->GetKey();
 
     guestBrain->SetRecipient(avMgrKey);
@@ -136,13 +135,6 @@ plCoopCoordinator::plCoopCoordinator(plKey host, plKey guest,
     }
 }
 
-// plCoopCoordinator ------------------
-// ------------------
-plCoopCoordinator::~plCoopCoordinator()
-{
-    delete[] fSynchBone;
-}
-
 /////////////////////////////////////////////////////////////////////////////////////////
 //
 // CONSTRUCTORS
@@ -405,7 +397,7 @@ void plCoopCoordinator::Read(hsStream *stream, hsResMgr *mgr)
     else
         fGuestAcceptMsg = nil;
 
-    fSynchBone = stream->ReadSafeString();
+    fSynchBone = stream->ReadSafeString_TEMP();
     fAutoStartGuest = stream->Readbool();
     
     fInitiatorID = fHostBrain->GetInitiatorID();
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plCoopCoordinator.h b/Sources/Plasma/PubUtilLib/plAvatar/plCoopCoordinator.h
index 6a176cc4..04e67aae 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plCoopCoordinator.h
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plCoopCoordinator.h
@@ -79,10 +79,9 @@ public:
     plCoopCoordinator();
     plCoopCoordinator(plKey host, plKey guest,
                       plAvBrainCoop *hostBrain, plAvBrainCoop *guestBrain,
-                      const char *synchBone, uint32_t hostOfferStage, uint32_t guestAcceptStage,
+                      const plString &synchBone, uint32_t hostOfferStage, uint32_t guestAcceptStage,
                       plMessage *guestAcceptMsg,
                       bool autoStartGuest);
-    ~plCoopCoordinator();
 
     virtual hsBool MsgReceive(plMessage *msg);
 
@@ -124,7 +123,7 @@ protected:
 
     plMessage *fGuestAcceptMsg;         // send this when the guest accepts
 
-    char *fSynchBone;
+    plString fSynchBone;
     bool fAutoStartGuest;
     bool fGuestAccepted;
 
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plOneShotMod.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plOneShotMod.cpp
index 16a398b6..4638b5b9 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plOneShotMod.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plOneShotMod.cpp
@@ -130,13 +130,12 @@ hsBool plOneShotMod::MsgReceive(plMessage* msg)
 
                 if(avMod)
                 {
-                    char *animName = avMod->MakeAnimationName(fAnimName);
+                    plString animName = avMod->MakeAnimationName(fAnimName);
 
                     plAvOneShotMsg *avOSmsg = new plAvOneShotMsg(myKey, oneShotMsg->fPlayerKey, objKey,
                                                                  fSeekDuration, (hsBool)fSmartSeek, animName, fDrivable,
                                                                  fReversable);
 
-                    delete [] animName; // AvOneShotMsg constructor copies.
                     avOSmsg->fNoSeek = fNoSeek;
                     avOSmsg->SetBCastFlag(plMessage::kPropagateToModifiers);
                     hsRefCnt_SafeRef(oneShotMsg->fCallbacks);
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plSittingModifier.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plSittingModifier.cpp
index 8fa88342..76e64e9c 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plSittingModifier.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plSittingModifier.cpp
@@ -279,7 +279,7 @@ bool IIsClosestAnim(const char *animName, hsMatrix44 &sitGoal, float &closestDis
         // The first step is to get the transform from the end to the beginning of the
         // animation. That's what this next line is doing. It's a bit unintuitive
         // until you look at the parameter definitions.
-        GetStartToEndTransform(anim, nil, &animEndToStart, "Handle");
+        GetStartToEndTransform(anim, nil, &animEndToStart, _TEMP_CONVERT_FROM_LITERAL("Handle"));
         hsMatrix44 candidateGoal = sitGoal * animEndToStart;
         hsPoint3 distP = candidateGoal.GetTranslate() - curPosition;
         hsVector3 distV(distP.fX, distP.fY, distP.fZ);
@@ -290,9 +290,7 @@ bool IIsClosestAnim(const char *animName, hsMatrix44 &sitGoal, float &closestDis
             return true;
         }
     } else {
-        char buffy[256];
-        sprintf(buffy, "Missing sit animation: %s", animName);
-        hsAssert(false, buffy);
+        hsAssert(false, plString::Format("Missing sit animation: %s", animName).c_str());
     }
     return false;
 }
diff --git a/Sources/Plasma/PubUtilLib/plDrawable/plDrawableSpansExport.cpp b/Sources/Plasma/PubUtilLib/plDrawable/plDrawableSpansExport.cpp
index 4b690152..ad3b410a 100644
--- a/Sources/Plasma/PubUtilLib/plDrawable/plDrawableSpansExport.cpp
+++ b/Sources/Plasma/PubUtilLib/plDrawable/plDrawableSpansExport.cpp
@@ -386,7 +386,7 @@ static void ILogSpan(plStatusLog* statusLog, plGeometrySpan* geo, plVertexSpan*
             uint32_t ptr = cell->fVtxStart + span->fCellOffset * stride;
 
             statusLog->AddLineF("From obj <%s> mat <%s> size %d bytes grp=%d (%d offset)",
-                geo->fMaxOwner ? geo->fMaxOwner : "<unknown>",
+                geo->fMaxOwner.s_str("<unknown>"),
                 geo->fMaterial ? geo->fMaterial->GetKey()->GetName().c_str() : "<unknown>",
                 geo->GetVertexSize(geo->fFormat) * geo->fNumVerts + sizeof(uint16_t) * geo->fNumIndices,
                 span->fGroupIdx,
@@ -404,7 +404,7 @@ static void ILogSpan(plStatusLog* statusLog, plGeometrySpan* geo, plVertexSpan*
         else
         {
             statusLog->AddLineF("Instanced obj <%s> mat <%s> grp=%d (%d/%d/%d/%d/%d/%d/%d/%d)",
-                geo->fMaxOwner ? geo->fMaxOwner : "<unknown>",
+                geo->fMaxOwner.s_str("<unknown>"),
                 geo->fMaterial ? geo->fMaterial->GetKey()->GetName().c_str() : "<unknown>",
                 span->fGroupIdx,
                 span->fVBufferIdx,
@@ -423,7 +423,7 @@ static void ILogSpan(plStatusLog* statusLog, plGeometrySpan* geo, plVertexSpan*
         if( geo->fProps & plGeometrySpan::kFirstInstance )
         {
             statusLog->AddLineF("From obj <%s> mat <%s> size %d bytes grp=%d (%d/%d/%d/%d/%d)",
-                geo->fMaxOwner ? geo->fMaxOwner : "<unknown>",
+                geo->fMaxOwner.s_str("<unknown>"),
                 geo->fMaterial ? geo->fMaterial->GetKey()->GetName().c_str() : "<unknown>",
                 geo->GetVertexSize(geo->fFormat) * geo->fNumVerts + sizeof(uint16_t) * geo->fNumIndices,
                 span->fGroupIdx,
@@ -437,7 +437,7 @@ static void ILogSpan(plStatusLog* statusLog, plGeometrySpan* geo, plVertexSpan*
         else
         {
             statusLog->AddLineF("Instanced obj <%s> mat <%s> grp=%d (%d/%d/%d/%d/%d)",
-                geo->fMaxOwner ? geo->fMaxOwner : "<unknown>",
+                geo->fMaxOwner.s_str("<unknown>"),
                 geo->fMaterial ? geo->fMaterial->GetKey()->GetName().c_str() : "<unknown>",
                 span->fGroupIdx,
                 span->fVBufferIdx,
diff --git a/Sources/Plasma/PubUtilLib/plDrawable/plGeometrySpan.cpp b/Sources/Plasma/PubUtilLib/plDrawable/plGeometrySpan.cpp
index b321337a..eb1b5bc6 100644
--- a/Sources/Plasma/PubUtilLib/plDrawable/plGeometrySpan.cpp
+++ b/Sources/Plasma/PubUtilLib/plDrawable/plGeometrySpan.cpp
@@ -115,7 +115,7 @@ void    plGeometrySpan::IClearMembers( void )
 
     fDecalLevel = 0;
 
-    fMaxOwner = nil;
+    fMaxOwner = plString::Null;
 }
 
 //// ClearBuffers ////////////////////////////////////////////////////////////
diff --git a/Sources/Plasma/PubUtilLib/plDrawable/plGeometrySpan.h b/Sources/Plasma/PubUtilLib/plDrawable/plGeometrySpan.h
index f40615a8..6eb85f20 100644
--- a/Sources/Plasma/PubUtilLib/plDrawable/plGeometrySpan.h
+++ b/Sources/Plasma/PubUtilLib/plDrawable/plGeometrySpan.h
@@ -136,20 +136,20 @@ class plGeometrySpan
         hsBounds3Ext        fWorldBounds;
         plFogEnvironment    *fFogEnviron;
 
-        uint32_t          fBaseMatrix;
-        uint8_t           fNumMatrices;
-        uint16_t          fLocalUVWChans;
-        uint16_t          fMaxBoneIdx;
-        uint32_t          fPenBoneIdx;
+        uint32_t        fBaseMatrix;
+        uint8_t         fNumMatrices;
+        uint16_t        fLocalUVWChans;
+        uint16_t        fMaxBoneIdx;
+        uint32_t        fPenBoneIdx;
 
-        float        fMinDist;
-        float        fMaxDist;
+        float           fMinDist;
+        float           fMaxDist;
 
-        float        fWaterHeight;
+        float           fWaterHeight;
 
-        uint8_t           fFormat;
-        uint32_t          fProps;
-        uint32_t          fNumVerts, fNumIndices;
+        uint8_t         fFormat;
+        uint32_t        fProps;
+        uint32_t        fNumVerts, fNumIndices;
 
         /// Current vertex format:
         ///     float   position[ 3 ];
@@ -158,22 +158,22 @@ class plGeometrySpan
         ///     float   weights[];              // 0-3 blending weights
         ///     uint32_t  weightIndices;          // Only if there are >= 1 blending weights
 
-        uint8_t*          fVertexData;
-        uint16_t*         fIndexData;
-        uint32_t          fDecalLevel;
+        uint8_t*        fVertexData;
+        uint16_t*       fIndexData;
+        uint32_t        fDecalLevel;
 
         hsColorRGBA*    fMultColor;
         hsColorRGBA*    fAddColor;
 
-        uint32_t*         fDiffuseRGBA;
-        uint32_t*         fSpecularRGBA;
+        uint32_t*       fDiffuseRGBA;
+        uint32_t*       fSpecularRGBA;
 
         mutable hsTArray<plGeometrySpan *>* fInstanceRefs;
-        mutable uint32_t                      fInstanceGroupID;       // For writing out/reading in instance refs
+        mutable uint32_t                    fInstanceGroupID;       // For writing out/reading in instance refs
 
         // The following is only used for logging during export. It is never set
         // at runtime. Don't even think about using it for anything.
-        const char*                         fMaxOwner; 
+        plString                            fMaxOwner;
 
         // The following is ONLY used during pack; it's so we can do a reverse lookup
         // from the instanceRefs list to the correct span in the drawable
diff --git a/Sources/Plasma/PubUtilLib/plMessage/plAnimCmdMsg.cpp b/Sources/Plasma/PubUtilLib/plMessage/plAnimCmdMsg.cpp
index 6ee197c5..b3e7dd2b 100644
--- a/Sources/Plasma/PubUtilLib/plMessage/plAnimCmdMsg.cpp
+++ b/Sources/Plasma/PubUtilLib/plMessage/plAnimCmdMsg.cpp
@@ -47,8 +47,6 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 plAnimCmdMsg::~plAnimCmdMsg()
 {
     ClearCmd();
-    delete [] fAnimName;
-    delete [] fLoopName;
 }
 
 
@@ -58,24 +56,22 @@ void plAnimCmdMsg::ClearCmd()
     fCmd.Clear(); 
 }
 
-void plAnimCmdMsg::SetAnimName(const char *name)
+void plAnimCmdMsg::SetAnimName(const plString &name)
 {
-    delete [] fAnimName;
-    fAnimName = hsStrcpy(name);
+    fAnimName = name;
 }
 
-const char *plAnimCmdMsg::GetAnimName()
+plString plAnimCmdMsg::GetAnimName()
 {
     return fAnimName;
 }
 
-void plAnimCmdMsg::SetLoopName(const char *name)
+void plAnimCmdMsg::SetLoopName(const plString &name)
 {
-    delete [] fLoopName;
-    fLoopName = hsStrcpy(name);
+    fLoopName = name;
 }
 
-const char *plAnimCmdMsg::GetLoopName()
+plString plAnimCmdMsg::GetLoopName()
 {
     return fLoopName;
 }
@@ -110,8 +106,8 @@ void plAnimCmdMsg::Read(hsStream* stream, hsResMgr* mgr)
     stream->ReadLE(&fSpeedChangeRate);
     stream->ReadLE(&fTime);
 
-    fAnimName = stream->ReadSafeString();
-    fLoopName = stream->ReadSafeString();
+    fAnimName = stream->ReadSafeString_TEMP();
+    fLoopName = stream->ReadSafeString_TEMP();
 }
 
 void plAnimCmdMsg::Write(hsStream* stream, hsResMgr* mgr)
@@ -136,16 +132,14 @@ void plAnimCmdMsg::Write(hsStream* stream, hsResMgr* mgr)
 plAGCmdMsg::~plAGCmdMsg()
 {
     ClearCmd();
-    delete [] fAnimName;
 }
 
-void plAGCmdMsg::SetAnimName(const char *name)
+void plAGCmdMsg::SetAnimName(const plString &name)
 {
-    delete [] fAnimName;
-    fAnimName = hsStrcpy(name);
+    fAnimName = name;
 }
 
-const char *plAGCmdMsg::GetAnimName()
+plString plAGCmdMsg::GetAnimName()
 {
     return fAnimName;
 }
@@ -160,7 +154,7 @@ void plAGCmdMsg::Read(hsStream* stream, hsResMgr* mgr)
     stream->ReadLE(&fAmp);
     stream->ReadLE(&fAmpRate);
 
-    fAnimName = stream->ReadSafeString();
+    fAnimName = stream->ReadSafeString_TEMP();
 }
 
 void plAGCmdMsg::Write(hsStream* stream, hsResMgr* mgr)
@@ -178,17 +172,12 @@ void plAGCmdMsg::Write(hsStream* stream, hsResMgr* mgr)
 
 /////////////////////////////////////////////////////////////////////////////////////
 
-plAGDetachCallbackMsg::~plAGDetachCallbackMsg()
+void plAGDetachCallbackMsg::SetAnimName(const plString &name)
 {
-    delete [] fAnimName;
+    fAnimName = name;
 }
 
-void plAGDetachCallbackMsg::SetAnimName(const char *name)
-{
-    fAnimName = hsStrcpy(name);
-}
-
-char *plAGDetachCallbackMsg::GetAnimName()
+plString plAGDetachCallbackMsg::GetAnimName()
 {
     return fAnimName;
 }
diff --git a/Sources/Plasma/PubUtilLib/plMessage/plAnimCmdMsg.h b/Sources/Plasma/PubUtilLib/plMessage/plAnimCmdMsg.h
index 219da379..b1ad1a12 100644
--- a/Sources/Plasma/PubUtilLib/plMessage/plAnimCmdMsg.h
+++ b/Sources/Plasma/PubUtilLib/plMessage/plAnimCmdMsg.h
@@ -47,6 +47,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 #include "hsBitVector.h"
 #include "hsTemplates.h"
 #include "hsGeometry3.h"
+#include "plString.h"
 #include "plInterp/plAnimEaseTypes.h"
 #include "plInterp/plAnimTimeConvert.h"
 
@@ -55,11 +56,11 @@ class plAGAnimInstance;
 class plAnimCmdMsg : public plMessageWithCallbacks
 {
 protected:
-    char *fAnimName;
-    char *fLoopName;
+    plString fAnimName;
+    plString fLoopName;
 
 private:
-    void IInit() { fBegin=fEnd=fLoopBegin=fLoopEnd=fSpeed=fSpeedChangeRate=fTime=0; fAnimName=fLoopName=nil;}
+    void IInit() { fBegin=fEnd=fLoopBegin=fLoopEnd=fSpeed=fSpeedChangeRate=fTime=0; fAnimName=fLoopName=plString::Null;}
 public:
     plAnimCmdMsg()
         : plMessageWithCallbacks(nil, nil, nil) { IInit(); }
@@ -110,12 +111,16 @@ public:
     hsBool Cmd(int n) const { return fCmd.IsBitSet(n); }
     void SetCmd(int n) { fCmd.SetBit(n); }
     void ClearCmd();
-    void SetAnimName(const char *name);
-    const char *GetAnimName();
+    void SetAnimName(const plString &name);
+    plString GetAnimName();
     hsBool CmdChangesAnimTime(); // Will this command cause an update to the current anim time?
 
-    void SetLoopName(const char *name);
-    const char *GetLoopName();
+    // TEMP plString REVISIT
+    // Because I'm TOO LAZY to keep converting all these calls to SetAnimName
+    void SetAnimName(const char *name) { SetAnimName(_TEMP_CONVERT_FROM_LITERAL(name)); }
+
+    void SetLoopName(const plString &name);
+    plString GetLoopName();
 
     float fBegin;
     float fEnd;
@@ -136,11 +141,11 @@ public:
 class plAGCmdMsg : public plMessage
 {
 protected:
-    char *fAnimName;
+    plString fAnimName;
 
 private:
     void IInit() { fBlend = fAmp = 0;
-                   fAnimName=nil;}
+                   fAnimName=plString::Null;}
 public:
     plAGCmdMsg()
         : plMessage(nil, nil, nil) { IInit(); }
@@ -165,8 +170,8 @@ public:
     hsBool Cmd(int n) const { return fCmd.IsBitSet(n); }
     void SetCmd(int n) { fCmd.SetBit(n); }
     void ClearCmd() { fCmd.Clear(); }
-    void SetAnimName(const char *name);
-    const char *GetAnimName();
+    void SetAnimName(const plString &name);
+    plString GetAnimName();
 
     float fBlend;
     float fBlendRate;
@@ -199,13 +204,12 @@ public:
 class plAGDetachCallbackMsg : public plEventCallbackMsg
 {
 protected:
-    char *fAnimName;
+    plString fAnimName;
 
 public:
-    plAGDetachCallbackMsg() : plEventCallbackMsg(), fAnimName(nil) {}
+    plAGDetachCallbackMsg() : plEventCallbackMsg() {}
     plAGDetachCallbackMsg(plKey receiver, CallbackEvent e, int idx=0, float t=0, int16_t repeats=-1, uint16_t user=0) :
-                          plEventCallbackMsg(receiver, e, idx, t, repeats, user), fAnimName(nil) {}
-    virtual ~plAGDetachCallbackMsg();
+                          plEventCallbackMsg(receiver, e, idx, t, repeats, user) {}
 
     CLASSNAME_REGISTER( plAGDetachCallbackMsg );
     GETINTERFACE_ANY( plAGDetachCallbackMsg, plEventCallbackMsg );
@@ -214,8 +218,8 @@ public:
     void Read(hsStream* stream, hsResMgr* mgr) {}
     void Write(hsStream* stream, hsResMgr* mgr) {}
     
-    void SetAnimName(const char *name);
-    char *GetAnimName();
+    void SetAnimName(const plString &name);
+    plString GetAnimName();
 };
 
 
diff --git a/Sources/Plasma/PubUtilLib/plMessage/plAvatarMsg.cpp b/Sources/Plasma/PubUtilLib/plMessage/plAvatarMsg.cpp
index 4b4f0c29..8585249b 100644
--- a/Sources/Plasma/PubUtilLib/plMessage/plAvatarMsg.cpp
+++ b/Sources/Plasma/PubUtilLib/plMessage/plAvatarMsg.cpp
@@ -351,18 +351,17 @@ void plAvTaskSeekDoneMsg::Write(hsStream *stream, hsResMgr *mgr)
 
 // CTOR()
 plAvOneShotMsg::plAvOneShotMsg()
-: plAvSeekMsg(), fAnimName(nil), fDrivable(false), fReversible(false), fCallbacks(nil)
+: plAvSeekMsg(), fDrivable(false), fReversible(false), fCallbacks(nil)
 {
 }
 
 // CTOR(sender, receiver, seekKey, time)
 plAvOneShotMsg::plAvOneShotMsg(const plKey &sender, const plKey& receiver,
                          const plKey& seekKey, float duration, hsBool smartSeek,
-                         const char *animName, hsBool drivable, hsBool reversible)
-: plAvSeekMsg(sender, receiver, seekKey, duration, smartSeek),
+                         const plString &animName, hsBool drivable, hsBool reversible)
+: plAvSeekMsg(sender, receiver, seekKey, duration, smartSeek), fAnimName(animName),
   fDrivable(drivable), fReversible(reversible), fCallbacks(nil)
 {
-    fAnimName = hsStrcpy(animName);
 }
 
 // DTOR
@@ -370,8 +369,6 @@ plAvOneShotMsg::~plAvOneShotMsg()
 {
     hsRefCnt_SafeUnRef(fCallbacks);
     fCallbacks = nil;
-
-    delete[] fAnimName;
 }
 
 // READ
@@ -379,8 +376,7 @@ void plAvOneShotMsg::Read(hsStream *stream, hsResMgr *mgr)
 {
     plAvSeekMsg::Read(stream, mgr);
 
-    delete [] fAnimName;
-    fAnimName = stream->ReadSafeString();
+    fAnimName = stream->ReadSafeString_TEMP();
     fDrivable = stream->ReadBool();
     fReversible = stream->ReadBool();
 }
diff --git a/Sources/Plasma/PubUtilLib/plMessage/plAvatarMsg.h b/Sources/Plasma/PubUtilLib/plMessage/plAvatarMsg.h
index e4e6b451..f3966b9b 100644
--- a/Sources/Plasma/PubUtilLib/plMessage/plAvatarMsg.h
+++ b/Sources/Plasma/PubUtilLib/plMessage/plAvatarMsg.h
@@ -247,7 +247,7 @@ public:
     virtual ~plAvOneShotMsg();
     plAvOneShotMsg(const plKey &sender, const plKey& receiver,
                    const plKey& seekKey, float duration, hsBool fSmartSeek,
-                   const char *animName, hsBool drivable, hsBool reversible);
+                   const plString &animName, hsBool drivable, hsBool reversible);
 
     // plasma protocol
     CLASSNAME_REGISTER( plAvOneShotMsg );
@@ -257,7 +257,7 @@ public:
     virtual void Write(hsStream *stream, hsResMgr *mgr);
 
     // public members
-    char * fAnimName;               // the name of the animation we're going to use
+    plString fAnimName;             // the name of the animation we're going to use
     hsBool fDrivable;               // are we animated by time or by mouse movement?
     hsBool fReversible;             // can we play backwards?
     plOneShotCallbacks *fCallbacks; // Callbacks given to us by a one-shot modifier
diff --git a/Sources/Plasma/PubUtilLib/plMessage/plOneShotCallbacks.cpp b/Sources/Plasma/PubUtilLib/plMessage/plOneShotCallbacks.cpp
index bbbe597e..93b27de8 100644
--- a/Sources/Plasma/PubUtilLib/plMessage/plOneShotCallbacks.cpp
+++ b/Sources/Plasma/PubUtilLib/plMessage/plOneShotCallbacks.cpp
@@ -50,15 +50,12 @@ plOneShotCallbacks::plOneShotCallbacks()
 
 plOneShotCallbacks::~plOneShotCallbacks()
 {
-    int size = fCallbacks.size();
-    for (int i = 0; i < size; i++)
-        delete [] fCallbacks[i].fMarker;
     fCallbacks.clear();
 }
 
-void plOneShotCallbacks::AddCallback(const char *marker, plKey &receiver, int16_t user)
+void plOneShotCallbacks::AddCallback(const plString &marker, plKey &receiver, int16_t user)
 {
-    fCallbacks.push_back(plOneShotCallback(hsStrcpy(marker), receiver, user));
+    fCallbacks.push_back(plOneShotCallback(marker, receiver, user));
 }
 
 int plOneShotCallbacks::GetNumCallbacks()
@@ -77,7 +74,7 @@ void plOneShotCallbacks::Read(hsStream* stream, hsResMgr* mgr)
     fCallbacks.reserve(size);
     for (int i = 0; i < size; i++)
     {
-        char *marker = stream->ReadSafeString();
+        plString marker = stream->ReadSafeString_TEMP();
         plKey receiver = mgr->ReadKey(stream);
         int16_t user = stream->ReadLE16();
 
diff --git a/Sources/Plasma/PubUtilLib/plMessage/plOneShotCallbacks.h b/Sources/Plasma/PubUtilLib/plMessage/plOneShotCallbacks.h
index e419eefa..ec46c548 100644
--- a/Sources/Plasma/PubUtilLib/plMessage/plOneShotCallbacks.h
+++ b/Sources/Plasma/PubUtilLib/plMessage/plOneShotCallbacks.h
@@ -59,10 +59,10 @@ public:
     class plOneShotCallback
     {
     public:
-        plOneShotCallback(char *marker, plKey &receiver, int16_t user) :
+        plOneShotCallback(const plString &marker, plKey &receiver, int16_t user) :
           fMarker(marker), fReceiver(receiver) , fUser(user) {}
 
-        char *fMarker;
+        plString fMarker;
         plKey fReceiver;
         int16_t fUser;
     };
@@ -74,7 +74,7 @@ public:
     plOneShotCallbacks();
     ~plOneShotCallbacks();
 
-    void AddCallback(const char *marker, plKey &receiver, int16_t user=0);
+    void AddCallback(const plString &marker, plKey &receiver, int16_t user=0);
     int GetNumCallbacks();
     plOneShotCallback& GetCallback(int i);
 
diff --git a/Sources/Plasma/PubUtilLib/plModifier/plAxisAnimModifier.cpp b/Sources/Plasma/PubUtilLib/plModifier/plAxisAnimModifier.cpp
index 19dfd491..c038e86d 100644
--- a/Sources/Plasma/PubUtilLib/plModifier/plAxisAnimModifier.cpp
+++ b/Sources/Plasma/PubUtilLib/plModifier/plAxisAnimModifier.cpp
@@ -203,7 +203,7 @@ hsBool plAxisAnimModifier::MsgReceive(plMessage* msg)
                 return true;
             plAnimCmdMsg* pMsg = new plAnimCmdMsg;
             pMsg->AddReceiver(fXAnim);
-            pMsg->SetAnimName(fAnimLabel.c_str());
+            pMsg->SetAnimName(fAnimLabel);
         //  pMsg->SetAnimName()
             if (fXPos < pMMsg->GetXPos())
             {
@@ -223,7 +223,7 @@ hsBool plAxisAnimModifier::MsgReceive(plMessage* msg)
                 return true;
             plAnimCmdMsg* pMsg = new plAnimCmdMsg;
             pMsg->AddReceiver(fYAnim);
-            pMsg->SetAnimName(fAnimLabel.c_str());
+            pMsg->SetAnimName(fAnimLabel);
             if (fYPos > pMMsg->GetYPos())
             {
                 if (fAllOrNothing)
@@ -301,7 +301,7 @@ hsBool plAxisAnimModifier::MsgReceive(plMessage* msg)
                 pMsg->SetCmd(plAnimCmdMsg::kAddCallbacks);
                 pMsg->AddCallback(pCall1);
                 pMsg->AddCallback(pCall2);
-                pMsg->SetAnimName(fAnimLabel.c_str());
+                pMsg->SetAnimName(fAnimLabel);
                 pMsg->AddReceiver( fXAnim );
 
                 hsRefCnt_SafeUnRef( pCall1 );
@@ -330,7 +330,7 @@ hsBool plAxisAnimModifier::MsgReceive(plMessage* msg)
                 pMsg->AddCallback(pCall1);
                 pMsg->AddCallback(pCall2);
                 pMsg->AddReceiver( fYAnim );
-                pMsg->SetAnimName(fAnimLabel.c_str());
+                pMsg->SetAnimName(fAnimLabel);
 
                 hsRefCnt_SafeUnRef( pCall1 );
                 hsRefCnt_SafeUnRef( pCall2 );
diff --git a/Sources/Plasma/PubUtilLib/plModifier/plAxisAnimModifier.h b/Sources/Plasma/PubUtilLib/plModifier/plAxisAnimModifier.h
index 4bb981b8..738583bc 100644
--- a/Sources/Plasma/PubUtilLib/plModifier/plAxisAnimModifier.h
+++ b/Sources/Plasma/PubUtilLib/plModifier/plAxisAnimModifier.h
@@ -45,6 +45,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 
 #include "hsStlUtils.h"
 #include "pnModifier/plSingleModifier.h"
+#include "plString.h"
 
 
 class plKey;
@@ -74,7 +75,7 @@ protected:
     int             fIface;
     plNotifyMsg*    fNotify;
     
-    std::string     fAnimLabel;
+    plString        fAnimLabel;
 
     plAxisInputInterface    *fInputIface;
 
@@ -100,8 +101,8 @@ public:
     void SetNotificationKey(plKey k) { fNotificationKey = k; }
     plNotifyMsg* GetNotify() { return fNotify; }
 
-    const char* GetAnimLabel() const {return fAnimLabel.c_str();}
-    void SetAnimLabel(const char* a) {fAnimLabel = a;           }
+    plString GetAnimLabel() const { return fAnimLabel; }
+    void SetAnimLabel(const plString& a) { fAnimLabel = a; }
 
 };
 
diff --git a/Sources/Plasma/PubUtilLib/plSurface/plLayerAnimation.cpp b/Sources/Plasma/PubUtilLib/plSurface/plLayerAnimation.cpp
index 4e84ff9a..cbdba018 100644
--- a/Sources/Plasma/PubUtilLib/plSurface/plLayerAnimation.cpp
+++ b/Sources/Plasma/PubUtilLib/plSurface/plLayerAnimation.cpp
@@ -68,8 +68,7 @@ plLayerAnimationBase::plLayerAnimationBase()
     fOpacityCtl(nil), 
     fTransformCtl(nil),
     fEvalTime(-1.0),
-    fCurrentTime(-1.f),
-    fSegmentID(nil)
+    fCurrentTime(-1.f)
 {
 }
 
@@ -81,7 +80,6 @@ plLayerAnimationBase::~plLayerAnimationBase()
     delete fSpecularColorCtl;
     delete fOpacityCtl;
     delete fTransformCtl;
-    delete [] fSegmentID;
 }
 
 void plLayerAnimationBase::Read(hsStream* s, hsResMgr* mgr)
diff --git a/Sources/Plasma/PubUtilLib/plSurface/plLayerAnimation.h b/Sources/Plasma/PubUtilLib/plSurface/plLayerAnimation.h
index 6e30079b..f789ea5a 100644
--- a/Sources/Plasma/PubUtilLib/plSurface/plLayerAnimation.h
+++ b/Sources/Plasma/PubUtilLib/plSurface/plLayerAnimation.h
@@ -60,10 +60,10 @@ class plSimpleStateVariable;
 class plLayerAnimationBase : public plLayerInterface
 {
 protected:
-    char*                       fSegmentID;
-    double                      fEvalTime;
-    float                    fCurrentTime;
-    float                    fLength;
+    plString        fSegmentID;
+    double          fEvalTime;
+    float           fCurrentTime;
+    float           fLength;
 
     plController*   fPreshadeColorCtl;
     plController*   fRuntimeColorCtl;
@@ -92,8 +92,8 @@ public:
 
     // Specialized
     float GetLength() const { return fLength; }
-    char *GetSegmentID() const { return fSegmentID; }
-    void SetSegmentID(char *ID) { delete fSegmentID; fSegmentID = hsStrcpy(ID); }
+    plString GetSegmentID() const { return fSegmentID; }
+    void SetSegmentID(const plString &ID) { fSegmentID = ID; }
 
     // Export construction functions follow
     void SetPreshadeColorCtl(plController* colCtl);
diff --git a/Sources/Tools/MaxComponent/plAGComponents.cpp b/Sources/Tools/MaxComponent/plAGComponents.cpp
index a58b9052..692ccbf4 100644
--- a/Sources/Tools/MaxComponent/plAGComponents.cpp
+++ b/Sources/Tools/MaxComponent/plAGComponents.cpp
@@ -109,11 +109,11 @@ public:
 
         virtual hsBool Convert(plMaxNode* node, plErrorMsg *pErrMsg);
 
-        virtual plATCAnim * NewAnimation(const char *name, double begin, double end);
+        virtual plATCAnim * NewAnimation(const plString &name, double begin, double end);
 
         hsBool ConvertNode(plMaxNode *node, plErrorMsg *pErrMsg);
         hsBool ConvertNodeSegmentBranch(plMaxNode *node, plAGAnim *mod, plErrorMsg *pErrMsg);
-        hsBool MakePersistent(plMaxNode *node, plAGAnim *anim, const char *animName, plErrorMsg *pErrMsg);
+        hsBool MakePersistent(plMaxNode *node, plAGAnim *anim, const plString &animName, plErrorMsg *pErrMsg);
 
         virtual void CollectNonDrawables(INodeTab& nonDrawables) { AddTargetsToList(nonDrawables); }
 
@@ -218,15 +218,16 @@ hsBool plAnimAvatarComponent::ConvertNode(plMaxNode *node, plErrorMsg *pErrMsg)
     // does this node have any segments specified?
     if (noteAnim.HasNotetracks())
     {
-        // for each segment we found: 
-        while (const char *animName = noteAnim.GetNextAnimName())
+        // for each segment we found:
+        plString animName;
+        while (!(animName = noteAnim.GetNextAnimName()).IsNull())
         {
             plAnimInfo info = noteAnim.GetAnimInfo(animName);
 
             plATCAnim *anim = NewAnimation(info.GetAnimName(), info.GetAnimStart(), info.GetAnimEnd());
 
-            const char *loopName = info.GetNextLoopName();
-            if (loopName)
+            plString loopName = info.GetNextLoopName();
+            if (!loopName.IsNull())
             {
                 anim->SetLoop(true);
                 float loopStart = info.GetLoopStart(loopName);
@@ -234,7 +235,8 @@ hsBool plAnimAvatarComponent::ConvertNode(plMaxNode *node, plErrorMsg *pErrMsg)
                 anim->SetLoopStart(loopStart == -1 ? anim->GetStart() : loopStart);
                 anim->SetLoopEnd(loopEnd == -1 ? anim->GetEnd() : loopEnd);
             }
-            while (const char *marker = info.GetNextMarkerName())
+            plString marker;
+            while (!(marker = info.GetNextMarkerName()).IsNull())
                 anim->AddMarker(marker, info.GetMarkerTime(marker));
 
             ConvertNodeSegmentBranch(node, anim, pErrMsg);
@@ -252,7 +254,7 @@ hsBool plAnimAvatarComponent::ConvertNode(plMaxNode *node, plErrorMsg *pErrMsg)
 
 // NewAnimation -------------------------------------------------------------------------
 // -------------
-plATCAnim * plAnimAvatarComponent::NewAnimation(const char *name, double begin, double end)
+plATCAnim * plAnimAvatarComponent::NewAnimation(const plString &name, double begin, double end)
 {
     return new plATCAnim(name, begin, end); 
 }
@@ -268,7 +270,7 @@ hsBool plAnimAvatarComponent::ConvertNodeSegmentBranch(plMaxNode *node, plAGAnim
 {
     // Check for a suppression marker
     plNotetrackAnim noteAnim(node, pErrMsg);
-    plAnimInfo info = noteAnim.GetAnimInfo(nil);
+    plAnimInfo info = noteAnim.GetAnimInfo(plString::Null);
     hsBool suppressed = info.IsSuppressed(mod->GetName());
 
     // Get the affine parts and the TM Controller
@@ -336,7 +338,7 @@ plKey FindSceneNode(plMaxNode *node)
 // Perform wizardry necessary to make the object save itself.
 //
 //
-hsBool plAnimAvatarComponent::MakePersistent(plMaxNode *node, plAGAnim *anim, const char *animName, plErrorMsg *pErrMsg)
+hsBool plAnimAvatarComponent::MakePersistent(plMaxNode *node, plAGAnim *anim, const plString &animName, plErrorMsg *pErrMsg)
 {
     // new approach: add to the generic pool on the scene node
     plLocation nodeLoc = node->GetLocation();
@@ -379,7 +381,7 @@ public:
 
     plEmoteComponent();
     virtual hsBool Convert(plMaxNode *node, plErrorMsg *pErrMsg);
-    virtual plATCAnim * NewAnimation(const char *name, double begin, double end);
+    virtual plATCAnim * NewAnimation(const plString &name, double begin, double end);
 
 protected:
     float fFadeIn;
@@ -455,7 +457,7 @@ hsBool plEmoteComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
 
 // NewAnimation ----------------------------------------------------------------------
 // -------------
-plATCAnim * plEmoteComponent::NewAnimation(const char *name, double begin, double end)
+plATCAnim * plEmoteComponent::NewAnimation(const plString &name, double begin, double end)
 {
     return new plEmoteAnim(name, begin, end, fFadeIn, fFadeOut, fBodyUsage);
 }
diff --git a/Sources/Tools/MaxComponent/plAnimCompProc.cpp b/Sources/Tools/MaxComponent/plAnimCompProc.cpp
index 150b524a..c1e65fdc 100644
--- a/Sources/Tools/MaxComponent/plAnimCompProc.cpp
+++ b/Sources/Tools/MaxComponent/plAnimCompProc.cpp
@@ -313,11 +313,12 @@ void plMtlAnimProc::ILoadAnimCombo(HWND hWnd, IParamBlock2* pb)
     if (mtl)
     {
         plNotetrackAnim anim(mtl, nil);
-        while (const char* animName = anim.GetNextAnimName())
+        plString animName;
+        while (!(animName = anim.GetNextAnimName()).IsNull())
         {
-            int idx = ComboBox_AddString(hAnim, animName);
+            int idx = ComboBox_AddString(hAnim, animName.c_str());
             ComboBox_SetItemData(hAnim, idx, 1);
-            if (!strcmp(animName, savedName))
+            if (!animName.Compare(savedName))
                 ComboBox_SetCurSel(hAnim, idx);
         }
 
diff --git a/Sources/Tools/MaxComponent/plAnimComponent.cpp b/Sources/Tools/MaxComponent/plAnimComponent.cpp
index cf5b0c31..ab44d51a 100644
--- a/Sources/Tools/MaxComponent/plAnimComponent.cpp
+++ b/Sources/Tools/MaxComponent/plAnimComponent.cpp
@@ -607,12 +607,12 @@ plAnimComponentBase::plAnimComponentBase() : fNeedReset(true)
 }
 
 
-const char *plAnimComponentBase::GetAnimName()
+plString plAnimComponentBase::GetAnimName()
 {
     const char *name = fCompPB->GetStr(kAnimName);
     if (!name || name[0] == '\0')
-        return nil;
-    return name;
+        return plString::Null;
+    return plString::FromUtf8(name);
 }
 
 bool IsSubworld(plMaxNode* node)
@@ -697,7 +697,7 @@ hsBool plAnimComponentBase::PreConvert(plMaxNode *node, plErrorMsg *pErrMsg)
         {
             if (!node->HasAGMod()) // Need to add this before the MasterMod, if it doesn't have one already.
             {
-                node->AddModifier(new plAGModifier(node->GetName()), IGetUniqueName(node));
+                node->AddModifier(new plAGModifier(plString::FromUtf8(node->GetName())), IGetUniqueName(node));
             }
             mod = new plAGMasterMod();
 
@@ -717,9 +717,9 @@ hsBool plAnimComponentBase::PreConvert(plMaxNode *node, plErrorMsg *pErrMsg)
     // we've added all keys during convert. Some cleanup might
     // be necessary in this case.
 
-    const char *animName = fCompPB->GetStr(kAnimName);
-    if (animName == nil || !strcmp(animName, ""))
-        animName = ENTIRE_ANIMATION_NAME;
+    plString animName = plString::FromUtf8(fCompPB->GetStr(kAnimName));
+    if (animName.IsEmpty())
+        animName = _TEMP_CONVERT_FROM_LITERAL(ENTIRE_ANIMATION_NAME);
 
     if (fCompPB->GetInt(ParamID(kAnimUseGlobal)))
     {
@@ -748,7 +748,7 @@ hsBool plAnimComponentBase::PreConvert(plMaxNode *node, plErrorMsg *pErrMsg)
         if (fCompPB->GetInt(kAnimLoop))
         {
             ATCAnim->SetLoop(true);
-            const char *loopName = fCompPB->GetStr(kAnimLoopName);
+            plString loopName = plString::FromUtf8(fCompPB->GetStr(kAnimLoopName));
             float loopStart = info.GetLoopStart(loopName);
             float loopEnd = info.GetLoopEnd(loopName);
 
@@ -756,10 +756,12 @@ hsBool plAnimComponentBase::PreConvert(plMaxNode *node, plErrorMsg *pErrMsg)
             ATCAnim->SetLoopEnd(loopEnd == -1 ? ATCAnim->GetEnd() : loopEnd);
         }
     
-        while (const char *loop = info.GetNextLoopName())
+        plString loop;
+        while (!(loop = info.GetNextLoopName()).IsNull())
             ATCAnim->AddLoop(loop, info.GetLoopStart(loop), info.GetLoopEnd(loop));
 
-        while (const char *marker = info.GetNextMarkerName())
+        plString marker;
+        while (!(marker = info.GetNextMarkerName()).IsNull())
             ATCAnim->AddMarker(marker, info.GetMarkerTime(marker));
 
         float stopPoint = -1;
@@ -790,7 +792,7 @@ hsBool plAnimComponentBase::IAddTMToAnim(plMaxNode *node, plAGAnim *anim, plErro
     hsAffineParts * parts = new hsAffineParts;
     plController* tmc;
 
-    if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
+    if (!anim->GetName().Compare(ENTIRE_ANIMATION_NAME))
         tmc = hsControlConverter::Instance().ConvertTMAnim(obj, node, parts);
     else 
         tmc = hsControlConverter::Instance().ConvertTMAnim(obj, node, parts, anim->GetStart(), anim->GetEnd());
@@ -798,11 +800,11 @@ hsBool plAnimComponentBase::IAddTMToAnim(plMaxNode *node, plAGAnim *anim, plErro
     if (tmc)
     {
         plMatrixChannelApplicator *app = new plMatrixChannelApplicator();
-            app->SetChannelName(node->GetName());
+            app->SetChannelName(plString::FromUtf8(node->GetName()));
         plMatrixControllerChannel *channel = new plMatrixControllerChannel(tmc, parts);
         app->SetChannel(channel);
         anim->AddApplicator(app);
-        if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
+        if (!anim->GetName().Compare(ENTIRE_ANIMATION_NAME))
             anim->ExtendToLength(tmc->GetLength());
         result = true;
     }
@@ -861,7 +863,7 @@ hsBool plAnimComponentBase::IConvertNodeSegmentBranch(plMaxNode *node, plAGAnim
         // It has an animation, we're going to need a plAGMod when loading the anim
         if (!node->HasAGMod())
         {
-            node->AddModifier(new plAGModifier(node->GetName()), IGetUniqueName(node));
+            node->AddModifier(new plAGModifier(plString::FromUtf8(node->GetName())), IGetUniqueName(node));
         }
         madeAnim = true;
     }
@@ -883,8 +885,7 @@ hsBool plAnimComponentBase::IMakePersistent(plMaxNode *node, plAGAnim *anim, plE
     plAGMasterMod *mod = plAGMasterMod::ConvertNoRef(fMods[node]);
     hsAssert(mod != nil, "No MasterMod to make animation persistent!");
 
-    char buffer[256];
-    sprintf(buffer, "%s_%s_anim_%d", node->GetName(), anim->GetName(), mod->GetNumPrivateAnimations());
+    plString buffer = plString::Format("%s_%s_anim_%d", node->GetName(), anim->GetName().c_str(), mod->GetNumPrivateAnimations());
     plLocation nodeLoc = node->GetLocation();
     plKey animKey = hsgResMgr::ResMgr()->NewKey(buffer, anim, nodeLoc);
 
@@ -935,7 +936,7 @@ void plAnimComponentBase::SetupCtl( plAGAnim *anim, plController *ctl, plAGAppli
     plScalarControllerChannel *channel = new plScalarControllerChannel(ctl);
     app->SetChannel(channel);
     anim->AddApplicator(app);
-    if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
+    if (!anim->GetName().Compare(ENTIRE_ANIMATION_NAME))
         anim->ExtendToLength(ctl->GetLength());
 }
 
@@ -989,12 +990,12 @@ void    plAnimComponentBase::PickTargetNode( IParamBlock2 *destPB, ParamID destP
     pick.DoPick();
 }
 
-const char  *plAnimComponentBase::GetIfaceSegmentName( hsBool allowNil )
+plString plAnimComponentBase::GetIfaceSegmentName( hsBool allowNil )
 {
-    const char *name = GetAnimName();
-    if( allowNil || name != nil )
+    plString name = GetAnimName();
+    if( allowNil || !name.IsNull() )
         return name;
-    return ENTIRE_ANIMATION_NAME;
+    return _TEMP_CONVERT_FROM_LITERAL( ENTIRE_ANIMATION_NAME );
 }
 
 //// Hit Callback for Animations /////////////////////////////////////////////
diff --git a/Sources/Tools/MaxComponent/plAnimComponent.h b/Sources/Tools/MaxComponent/plAnimComponent.h
index 5d8626c2..26f0d972 100644
--- a/Sources/Tools/MaxComponent/plAnimComponent.h
+++ b/Sources/Tools/MaxComponent/plAnimComponent.h
@@ -115,7 +115,7 @@ public:
     hsBool DeInit(plMaxNode *node, plErrorMsg *pErrMsg);
 
     virtual plKey GetModKey(plMaxNode *node)=0;
-    const char *GetAnimName();
+    plString GetAnimName();
     static hsBool IsAnimComponent(plComponentBase *comp);
 
     std::map<plMaxNode*, plAGAnim*> fAnims;
@@ -132,7 +132,7 @@ public:
     // plAnimObjInterface functions
     virtual void    PickTargetNode( IParamBlock2 *destPB, ParamID destParamID, ParamID typeID );
     virtual hsBool  IsNodeRestricted( void ) { return true; }
-    virtual const char  *GetIfaceSegmentName( hsBool allowNil );
+    virtual plString GetIfaceSegmentName( hsBool allowNil );
 
 protected:
     hsBool IAddTMToAnim(plMaxNode *node, plAGAnim *anim, plErrorMsg *pErrMsg);
diff --git a/Sources/Tools/MaxComponent/plAnimEventComponent.cpp b/Sources/Tools/MaxComponent/plAnimEventComponent.cpp
index dff4715c..13c98e86 100644
--- a/Sources/Tools/MaxComponent/plAnimEventComponent.cpp
+++ b/Sources/Tools/MaxComponent/plAnimEventComponent.cpp
@@ -183,7 +183,7 @@ hsBool plAnimEventComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
     // Create and setup the callback message
     //
     plKey animKey = animComp->GetModKey(animNode);
-    const char* animName = animComp->GetAnimName();
+    plString animName = animComp->GetAnimName();
 
     plAnimCmdMsg *animMsg = new plAnimCmdMsg;
     animMsg->SetCmd(plAnimCmdMsg::kAddCallbacks);
@@ -209,7 +209,7 @@ hsBool plAnimEventComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
         int numMarkers = fCompPB->Count(kAnimMarkers);
         for (int i = 0; i < numMarkers; i++)
         {
-            const char* marker = fCompPB->GetStr(kAnimMarkers, 0, i);
+            plString marker = plString::FromUtf8(fCompPB->GetStr(kAnimMarkers, 0, i));
             float time = info.GetMarkerTime(marker);
 
             plEventCallbackMsg *eventMsg = CreateCallbackMsg(animMsg, modKey);
@@ -255,12 +255,12 @@ static int ListBox_AddStringData(HWND hList, const char* text, int data)
     return idx;
 }
 
-static bool IsMarkerSelected(IParamBlock2* pb, int paramID, const char* marker, bool remove=false)
+static bool IsMarkerSelected(IParamBlock2* pb, int paramID, const plString& marker, bool remove=false)
 {
     int numMarkers = pb->Count(paramID);
     for (int i = 0; i < numMarkers; i++)
     {
-        if (hsStrEQ(marker, pb->GetStr(paramID, 0, i)))
+        if (marker.Compare(pb->GetStr(paramID, 0, i)) == 0)
         {
             if (remove)
                 pb->Delete(paramID, i, 1);
@@ -279,7 +279,7 @@ static void RemoveDeadMarkers(IParamBlock2* pb, int paramID, plAnimInfo& info)
     int numMarkers = pb->Count(paramID);
     for (int i = numMarkers-1; i >= 0; i--)
     {
-        float time = info.GetMarkerTime(pb->GetStr(paramID, 0, i));
+        float time = info.GetMarkerTime(plString::FromUtf8(pb->GetStr(paramID, 0, i)));
         if (time == -1)
         {
             pb->Delete(paramID, i, 1);
@@ -328,9 +328,10 @@ void plAnimEventProc::ILoadUser(HWND hWnd, IParamBlock2* pb)
         RemoveDeadMarkers(pb, kAnimMarkers, info);
 
         // Get all the markers in this animation
-        while (const char* marker = info.GetNextMarkerName())
+        plString marker;
+        while (!(marker = info.GetNextMarkerName()).IsNull())
         {
-            idx = ListBox_AddStringData(hList, marker, kAnimEventMarker);
+            idx = ListBox_AddStringData(hList, marker.c_str(), kAnimEventMarker);
 
             if (IsMarkerSelected(pb, kAnimMarkers, marker))
                 ListBox_SetSel(hList, TRUE, idx);
@@ -355,16 +356,17 @@ bool plAnimEventProc::IUserCommand(HWND hWnd, IParamBlock2* pb, int cmd, int res
         {
             char buf[256];
             ListBox_GetText(hList, idx, buf);
+            plString text = plString::FromUtf8(buf);
             if (selected)
             {
-                if (!IsMarkerSelected(pb, kAnimMarkers, buf))
+                if (!IsMarkerSelected(pb, kAnimMarkers, text))
                 {
                     TCHAR* name = buf;
                     pb->Append(kAnimMarkers, 1, &name);
                 }
             }
             else
-                IsMarkerSelected(pb, kAnimMarkers, buf, true);
+                IsMarkerSelected(pb, kAnimMarkers, text, true);
         }
 
         return true;
@@ -480,7 +482,7 @@ hsBool plMtlEventComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
 
     Mtl* mtl = fCompPB->GetMtl(kMtlMtl);
     plMaxNodeBase* mtlNode = (plMaxNodeBase*)fCompPB->GetINode(kMtlNode);
-    const char* mtlAnim = fCompPB->GetStr(kMtlAnim);
+    plString mtlAnim = plString::FromUtf8(fCompPB->GetStr(kMtlAnim));
 
     //
     // Create and setup the callback message
@@ -512,7 +514,7 @@ hsBool plMtlEventComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
         int numMarkers = fCompPB->Count(kMtlMarkers);
         for (int i = 0; i < numMarkers; i++)
         {
-            const char* marker = fCompPB->GetStr(kMtlMarkers, 0, i);
+            plString marker = plString::FromUtf8(fCompPB->GetStr(kMtlMarkers, 0, i));
             float time = info.GetMarkerTime(marker);
 
             plEventCallbackMsg *eventMsg = CreateCallbackMsg(animMsg, modKey);
@@ -576,7 +578,7 @@ void plMtlEventProc::ILoadUser(HWND hWnd, IParamBlock2* pb)
 
     if (mtl)
     {
-        const char* mtlAnim = pb->GetStr(kMtlAnim);
+        plString mtlAnim = plString::FromUtf8(pb->GetStr(kMtlAnim));
 
         // Get the shared animations for all the nodes this component is applied to
         plNotetrackAnim anim(mtl, nil);
@@ -585,9 +587,10 @@ void plMtlEventProc::ILoadUser(HWND hWnd, IParamBlock2* pb)
         RemoveDeadMarkers(pb, kMtlMarkers, info);
 
         // Get all the markers in this animation
-        while (const char* marker = info.GetNextMarkerName())
+        plString marker;
+        while (!(marker = info.GetNextMarkerName()).IsNull())
         {
-            idx = ListBox_AddStringData(hList, marker, kAnimEventMarker);
+            idx = ListBox_AddStringData(hList, marker.c_str(), kAnimEventMarker);
 
             if (IsMarkerSelected(pb, kMtlMarkers, marker))
                 ListBox_SetSel(hList, TRUE, idx);
@@ -612,16 +615,17 @@ bool plMtlEventProc::IUserCommand(HWND hWnd, IParamBlock2* pb, int cmd, int resI
         {
             char buf[256];
             ListBox_GetText(hList, idx, buf);
+            plString text = plString::FromUtf8(buf);
             if (selected)
             {
-                if (!IsMarkerSelected(pb, kMtlMarkers, buf))
+                if (!IsMarkerSelected(pb, kMtlMarkers, text))
                 {
                     TCHAR* name = buf;
                     pb->Append(kMtlMarkers, 1, &name);
                 }
             }
             else
-                IsMarkerSelected(pb, kMtlMarkers, buf, true);
+                IsMarkerSelected(pb, kMtlMarkers, text, true);
         }
 
         return true;
diff --git a/Sources/Tools/MaxComponent/plAnimObjInterface.h b/Sources/Tools/MaxComponent/plAnimObjInterface.h
index f7552761..d6d76dad 100644
--- a/Sources/Tools/MaxComponent/plAnimObjInterface.h
+++ b/Sources/Tools/MaxComponent/plAnimObjInterface.h
@@ -51,6 +51,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 #define _plAnimObjInterface_h
 
 #include "hsTemplates.h"
+#include "plString.h"
 
 class plAnimObjInterface
 {
@@ -79,7 +80,7 @@ class plAnimObjInterface
 
         // Return the name of the segment/animation that this interface references. Pass "false" to get the 
         // ENTIRE_ANIMATION_NAME string for entire animations, "true" for nil.
-        virtual const char  *GetIfaceSegmentName( hsBool allowNil ) = 0;
+        virtual plString    GetIfaceSegmentName( hsBool allowNil ) = 0;
 
         // This animation would require (depending on the node restriction) a separate material (i.e. material anim)
         virtual hsBool      MightRequireSeparateMaterial( void ) { return false; }
diff --git a/Sources/Tools/MaxComponent/plAudioComponents.cpp b/Sources/Tools/MaxComponent/plAudioComponents.cpp
index 4cc106c7..eeae85c9 100644
--- a/Sources/Tools/MaxComponent/plAudioComponents.cpp
+++ b/Sources/Tools/MaxComponent/plAudioComponents.cpp
@@ -614,13 +614,16 @@ plSoundBuffer   *plBaseSoundEmitterComponent::GetSourceBuffer( const char *fileN
 plSoundBuffer   *plBaseSoundEmitterComponent::IGetSourceBuffer( const char *fileName, plMaxNode *srcNode, uint32_t srcBufferFlags )
 {
     plKey       key;
-    char        keyName[ MAX_PATH ];
+    plString    keyName;
     char        fullPath[ MAX_PATH ];
 
 
-    strcpy( keyName, fileName );
-    ::PathStripPath( keyName );
-    
+    // ***TEMP plString REVISIT***
+    char        tempPath[ MAX_PATH ];
+    strncpy(tempPath, fileName, MAX_PATH);
+    ::PathStripPath( tempPath );
+    keyName = _TEMP_CONVERT_FROM_LITERAL( tempPath );
+
     // TEMP HACK until we get packed sounds: 
     // Given the source filename, we check to see if it's in our plasma game directory. If not, or if
     // it's out of date, we copy it over. We'll truncate the filename inside plSoundBuffer when we're ready.
@@ -635,7 +638,7 @@ plSoundBuffer   *plBaseSoundEmitterComponent::IGetSourceBuffer( const char *file
         plFileUtils::CreateDir( fullPath );
 
         // Now finish the path...
-        strcat( fullPath, keyName );
+        strcat( fullPath, _TEMP_CONVERT_TO_CONST_CHAR( keyName ) );
 
         // Check filestamp
         WIN32_FILE_ATTRIBUTE_DATA   oldFileAttrib, newFileAttrib;
@@ -664,9 +667,9 @@ plSoundBuffer   *plBaseSoundEmitterComponent::IGetSourceBuffer( const char *file
 
     // Additional info for the keyName--need some flag mangling, specifically for the left/right channel mangling
     if( srcBufferFlags & plSoundBuffer::kOnlyLeftChannel )
-        strcat( keyName, ":L" );
+        keyName += _TEMP_CONVERT_FROM_LITERAL( ":L" );
     else if( srcBufferFlags & plSoundBuffer::kOnlyRightChannel )
-        strcat( keyName, ":R" );
+        keyName += _TEMP_CONVERT_FROM_LITERAL( ":R" );
 
     key = srcNode->FindPageKey( plSoundBuffer::Index(), keyName );  
     if( key != nil )
@@ -890,8 +893,8 @@ void    plBaseSoundEmitterComponent::ISetBaseParameters( plSound *destSound, plE
     {
         destSound->SetProperty( plSound::kPropLooping, true );
 
-        const char *loop = fCompPB->GetStr((ParamID)kSoundLoopName);
-        if (loop && loop[0] != '\0')
+        plString loop = plString::FromUtf8( fCompPB->GetStr((ParamID)kSoundLoopName) );
+        if (!loop.IsEmpty())
         {
             SegmentMap *segMap = GetCompWaveSegmentMap( GetSoundFileName( kBaseSound ) );
             if (segMap && segMap->find(loop) != segMap->end())
@@ -915,7 +918,7 @@ hsBool  plBaseSoundEmitterComponent::AddToAnim( plAGAnim *anim, plMaxNode *node
     hsControlConverter& cc = hsControlConverter::Instance();
 
     float start, end;
-    if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
+    if (!anim->GetName().Compare(ENTIRE_ANIMATION_NAME))
     {
         start = end = -1;
     }
@@ -937,7 +940,7 @@ hsBool  plBaseSoundEmitterComponent::AddToAnim( plAGAnim *anim, plMaxNode *node
 
         std::map<plMaxNode*, int>::iterator i = fIndices.begin();
         plSoundVolumeApplicator *app = new plSoundVolumeApplicator( (*i).second );
-        app->SetChannelName(node->GetName());
+        app->SetChannelName(plString::FromUtf8(node->GetName()));
         plAnimComponentBase::SetupCtl( anim, ctl, app, node );
         result = true;      
     }
@@ -1817,10 +1820,10 @@ public:
             for (SegmentMap::iterator it = segMap->begin(); it != segMap->end(); it++)
             {
                 SegmentSpec *spec = it->second;
-                int idx = SendMessage(hLoop, CB_ADDSTRING, 0, (LPARAM)spec->fName);
+                int idx = SendMessage(hLoop, CB_ADDSTRING, 0, (LPARAM)spec->fName.c_str());
                 SendMessage(hLoop, CB_SETITEMDATA, idx, 1);
 
-                if (!strcmp(spec->fName, loop))
+                if (!spec->fName.Compare(loop))
                     SendMessage(hLoop, CB_SETCURSEL, idx, 0);
             }
 
@@ -2185,8 +2188,7 @@ hsBool plSound3DEmitterComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
     plWinAudible* pAudible = (plWinAudible*)ai->GetAudible();
 
 
-    char    keyName[ 256 ];
-    sprintf( keyName, "%s", GetINode()->GetName());
+    plString keyName = plString::FromUtf8(GetINode()->GetName());
 
     plWin32Sound *sound = nil;
 
@@ -2219,7 +2221,7 @@ hsBool plSound3DEmitterComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
 // Converts an array of components into a single grouped sound
 hsBool  plSound3DEmitterComponent::ConvertGrouped( plMaxNode *baseNode, hsTArray<plBaseSoundEmitterComponent *> &groupArray, plErrorMsg *pErrMsg )
 {
-    char    keyName[ 256 ];
+    plString keyName;
 
 
     if( !fValidNodes[ baseNode ] || !fCreateGrouped )
@@ -2340,7 +2342,7 @@ hsBool  plSound3DEmitterComponent::ConvertGrouped( plMaxNode *baseNode, hsTArray
     if( fIndices.find( baseNode ) != fIndices.end() )
         index = fIndices[ baseNode ];
 
-    sprintf( keyName, "%s_MergedSound", GetINode()->GetName() );
+    keyName = plString::Format( "%s_MergedSound", GetINode()->GetName() );
 
     plKey buffKey = baseNode->FindPageKey( plSoundBuffer::Index(), keyName );   
     if( buffKey != nil )
@@ -2361,7 +2363,7 @@ hsBool  plSound3DEmitterComponent::ConvertGrouped( plMaxNode *baseNode, hsTArray
     const plAudioInterface* ai = baseNode->GetSceneObject()->GetAudioInterface();
     plWinAudible* pAudible = (plWinAudible*)ai->GetAudible();
 
-    sprintf( keyName, "%s", GetINode()->GetName());
+    keyName = plString::FromUtf8(GetINode()->GetName());
     plWin32GroupedSound *sound = new plWin32GroupedSound;
     sound->SetPositionArray( startPoses.GetCount(), startPoses.AcquireArray(), volumes.AcquireArray() );
     sound->SetProperty( plSound::kPropLoadOnlyOnCall, true );
@@ -2508,8 +2510,7 @@ hsBool plBackgroundMusicComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
     if( srcBuffer == nil )
         return false;
 
-    char    keyName[ 256 ];
-    sprintf( keyName, "%s_Win32BgndSnd", GetINode()->GetName() );
+    plString keyName = plString::Format( "%s_Win32BgndSnd", GetINode()->GetName() );
     plWin32Sound *sound = nil;
 
     if( srcBuffer->GetDataLengthInSecs() > 4.f )
@@ -2667,8 +2668,7 @@ hsBool plGUISoundComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
         return false;
     }
 
-    char    keyName[ 256 ];
-    sprintf( keyName, "%s_Win32GUISound", GetINode()->GetName() );
+    plString keyName = plString::Format( "%s_Win32GUISound", GetINode()->GetName() );
 
     plWin32StaticSound *sound = new plWin32StaticSound;
     hsgResMgr::ResMgr()->NewKey(keyName, sound, node->GetLocation(), node->GetLoadMask());
diff --git a/Sources/Tools/MaxComponent/plAutoUIParams.cpp b/Sources/Tools/MaxComponent/plAutoUIParams.cpp
index d586b7f5..963686ce 100644
--- a/Sources/Tools/MaxComponent/plAutoUIParams.cpp
+++ b/Sources/Tools/MaxComponent/plAutoUIParams.cpp
@@ -1605,7 +1605,7 @@ plKey plPickMaterialAnimationButtonParam::GetKey(IParamBlock2 *pb, int idx)
 }
 
 // this is in plResponderMtl.cpp
-extern int GetMatAnimModKey(Mtl* mtl, plMaxNodeBase* node, const char* segName, hsTArray<plKey>& keys);;
+extern int GetMatAnimModKey(Mtl* mtl, plMaxNodeBase* node, const plString& segName, hsTArray<plKey>& keys);;
 
 void plPickMaterialAnimationButtonParam::CreateKeyArray(IParamBlock2* pb)
 {
@@ -1613,7 +1613,7 @@ void plPickMaterialAnimationButtonParam::CreateKeyArray(IParamBlock2* pb)
 
     Mtl* mtl = (Mtl*)pb->GetReferenceTarget(fID);
 
-    int bob = GetMatAnimModKey(mtl, nil, nil, fKeys);
+    int bob = GetMatAnimModKey(mtl, nil, plString::Null, fKeys);
 }
 
 void plPickMaterialAnimationButtonParam::DestroyKeyArray()
diff --git a/Sources/Tools/MaxComponent/plAvatarComponent.cpp b/Sources/Tools/MaxComponent/plAvatarComponent.cpp
index 09883a82..f1bfe28f 100644
--- a/Sources/Tools/MaxComponent/plAvatarComponent.cpp
+++ b/Sources/Tools/MaxComponent/plAvatarComponent.cpp
@@ -264,11 +264,11 @@ hsBool plArmatureComponent::Convert(plMaxNode* node, plErrorMsg *pErrMsg)
     {
         // MakeCharacterHierarchy will attach agmodifiers to all the bones in the hierarchy;
         // have to manually add any for non-bone objects...
-        agMod = new plAGModifier("Handle");     // the player root is known as the handle
+        agMod = new plAGModifier(_TEMP_CONVERT_FROM_LITERAL("Handle"));     // the player root is known as the handle
         node->AddModifier(agMod, IGetUniqueName(node));
     }
 
-    agMod->SetChannelName("Handle");
+    agMod->SetChannelName(_TEMP_CONVERT_FROM_LITERAL("Handle"));
 
     // Get the position and radius of the head and torso physicals
     if (ClassID() == AVATAR_CLASS_ID || ClassID() == LOD_AVATAR_CLASS_ID)
@@ -453,7 +453,7 @@ plAvatarComponent::plAvatarComponent()
 
 void plAvatarComponent::IAttachModifiers(plMaxNode *node, plErrorMsg *pErrMsg)
 {
-    const char *name = node->GetKey()->GetName();
+    plString name = node->GetKey()->GetName();
 
     plMaxNode *meshNode = (plMaxNode *)fCompPB->GetINode(plAvatarComponent::kMeshNode);
     plKey meshKey = meshNode->GetSceneObject()->GetKey();
@@ -476,7 +476,7 @@ void plAvatarComponent::IAttachModifiers(plMaxNode *node, plErrorMsg *pErrMsg)
 
     avMod->SetBodyAgeName(node->GetAgeName());
     avMod->SetBodyFootstepSoundPage(fCompPB->GetStr(ParamID(kBodyFootstepSoundPage)));
-    avMod->SetAnimationPrefix(fCompPB->GetStr(ParamID(kAnimationPrefix)));
+    avMod->SetAnimationPrefix(plString::FromUtf8(fCompPB->GetStr(ParamID(kAnimationPrefix))));
 
     //AddLinkSound(node, node->GetSceneObject()->GetKey(), pErrMsg );
 
@@ -491,7 +491,7 @@ void plAvatarComponent::IAttachModifiers(plMaxNode *node, plErrorMsg *pErrMsg)
 void AddClothingToMod(plMaxNode *node, plArmatureMod *mod, int group, hsGMaterial *mat, plErrorMsg *pErrMsg)
 {
     plGenRefMsg *msg;
-    char keyName[256];
+    plString keyName;
     TSTR sdata;
     hsStringTokenizer toker;
 
@@ -509,11 +509,11 @@ void AddClothingToMod(plMaxNode *node, plArmatureMod *mod, int group, hsGMateria
     }
     else 
         base->SetLayoutName("BasicHuman");
-    sprintf(keyName, "%s_ClothingBase", node->GetName());
+    keyName = plString::Format("%s_ClothingBase", node->GetName());
     hsgResMgr::ResMgr()->NewKey(keyName, base, node->GetLocation());
     plClothingOutfit *outfit = new plClothingOutfit();
     outfit->fGroup = group;
-    sprintf(keyName, "%s_outfit", mod->GetKey()->GetName());
+    keyName = plString::Format("%s_outfit", mod->GetKey()->GetName().c_str());
     hsgResMgr::ResMgr()->NewKey(keyName, outfit, node->GetLocation());
     
     msg = new plGenRefMsg(outfit->GetKey(), plRefMsg::kOnCreate, -1, -1);
@@ -682,10 +682,10 @@ hsBool plCompoundCtrlComponent::SetupProperties(plMaxNode *node, plErrorMsg *pEr
 
 hsBool plCompoundCtrlComponent::Convert(plMaxNode* node, plErrorMsg *pErrMsg)
 {
-    const char *name = node->GetKey()->GetName();
+    plString name = node->GetKey()->GetName();
 
     node->MakeCharacterHierarchy(pErrMsg);
-    node->SetupBonesAliasesRecur(name);
+    node->SetupBonesAliasesRecur(_TEMP_CONVERT_TO_CONST_CHAR(name));
 
 
     // create and register the player modifier
@@ -1052,7 +1052,7 @@ plLODAvatarComponent::plLODAvatarComponent() : fMaterial(nil)
 
 void plLODAvatarComponent::IAttachModifiers(    plMaxNode *node, plErrorMsg *pErrMsg)
 {
-    const char *avatarName = node->GetKey()->GetName();
+    plString avatarName = node->GetKey()->GetName();
     plMaxNode *animRoot = (plMaxNode *)fCompPB->GetINode(plLODAvatarComponent::kRootNodeAddBtn);
     plKey animRootKey = animRoot->GetSceneObject()->GetKey();
     plArmatureLODMod* avMod = new plArmatureLODMod(avatarName);
@@ -1066,7 +1066,7 @@ void plLODAvatarComponent::IAttachModifiers(    plMaxNode *node, plErrorMsg *pEr
 
     avMod->SetBodyAgeName(node->GetAgeName());
     avMod->SetBodyFootstepSoundPage(fCompPB->GetStr(ParamID(kBodyFootstepSoundPage)));
-    avMod->SetAnimationPrefix(fCompPB->GetStr(ParamID(kAnimationPrefix)));
+    avMod->SetAnimationPrefix(plString::FromUtf8(fCompPB->GetStr(ParamID(kAnimationPrefix))));
 
     int iLODCount = fCompPB->Count(plLODAvatarComponent::kMeshNodeTab);
     for (int i = 0; i < iLODCount; i++)
diff --git a/Sources/Tools/MaxComponent/plClickDragComponent.cpp b/Sources/Tools/MaxComponent/plClickDragComponent.cpp
index 50fa6f32..bda40ed3 100644
--- a/Sources/Tools/MaxComponent/plClickDragComponent.cpp
+++ b/Sources/Tools/MaxComponent/plClickDragComponent.cpp
@@ -448,12 +448,12 @@ hsBool plClickDragComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
         pCall2->AddReceiver(axisKey);
 
         plAnimCmdMsg* pMsg = new plAnimCmdMsg;
-        const char *tempAnimName = pAnim->GetAnimName();
-        if (tempAnimName == nil)
+        plString tempAnimName = pAnim->GetAnimName();
+        if (tempAnimName.IsNull())
         {
             //pMsg->SetAnimName(ENTIRE_ANIMATION_NAME);
             pMsg->SetAnimName(pAnim->GetModKey(node)->GetName());
-            pAxis->SetAnimLabel(ENTIRE_ANIMATION_NAME);
+            pAxis->SetAnimLabel(_TEMP_CONVERT_FROM_LITERAL(ENTIRE_ANIMATION_NAME));
         }
         else
         {
diff --git a/Sources/Tools/MaxComponent/plComponentBase.cpp b/Sources/Tools/MaxComponent/plComponentBase.cpp
index f71e8c56..b5662291 100644
--- a/Sources/Tools/MaxComponent/plComponentBase.cpp
+++ b/Sources/Tools/MaxComponent/plComponentBase.cpp
@@ -279,10 +279,8 @@ bool plComponentBase::IsTarget(plMaxNodeBase *node)
     return false;
 }
 
-const char* plComponentBase::IGetUniqueName(plMaxNodeBase* target)
+plString plComponentBase::IGetUniqueName(plMaxNodeBase* target)
 {
-    static char nameBuf[256];
-
     // Make sure we've actually got multiple *used* targets.  (Some could be nil)
     int numUsedTargs = 0;
     int thisTargIdx = -1;
@@ -305,11 +303,9 @@ const char* plComponentBase::IGetUniqueName(plMaxNodeBase* target)
     hsAssert(thisTargIdx != -1, "Bad target for IGetUniqueName");
 
     if (numUsedTargs > 1)
-        _snprintf(nameBuf, sizeof(nameBuf), "%s_%d", GetINode()->GetName(), thisTargIdx);
+        return plString::Format("%s_%d", GetINode()->GetName(), thisTargIdx);
     else
-        strncpy(nameBuf, GetINode()->GetName(), sizeof(nameBuf));
-
-    return nameBuf;
+        return plString::FromUtf8(GetINode()->GetName());
 }
 
 plMaxNodeBase *plComponentBase::GetINode()
diff --git a/Sources/Tools/MaxComponent/plComponentBase.h b/Sources/Tools/MaxComponent/plComponentBase.h
index 274aa485..817a51a9 100644
--- a/Sources/Tools/MaxComponent/plComponentBase.h
+++ b/Sources/Tools/MaxComponent/plComponentBase.h
@@ -70,7 +70,7 @@ protected:
 
     // Get a unique name based on this components name and the index of this target
     // Return value points to a static, so don't try to hold on to it
-    const char* IGetUniqueName(plMaxNodeBase* target);
+    plString IGetUniqueName(plMaxNodeBase* target);
 
 public:
     // Permanent Block ID's
diff --git a/Sources/Tools/MaxComponent/plComponentTools.cpp b/Sources/Tools/MaxComponent/plComponentTools.cpp
index 34181434..bc166c95 100644
--- a/Sources/Tools/MaxComponent/plComponentTools.cpp
+++ b/Sources/Tools/MaxComponent/plComponentTools.cpp
@@ -50,7 +50,7 @@ plKey plComponentTools::AddModifier(plMaxNodeBase *node, plModifier *mod)
     return fAddModFunc(node, mod);
 }
 
-plKey plComponentTools::GetNewKey(const char *name, plModifier *mod, plLocation loc)
+plKey plComponentTools::GetNewKey(const plString &name, plModifier *mod, plLocation loc)
 {
     return fNewKey(name, mod, loc);
 }
@@ -70,12 +70,12 @@ plKey plComponentTools::GetAnimCompLightModKey(plComponentBase *comp, plMaxNodeB
     return fAnimLightKey(comp, node);
 }
 */
-const char *plComponentTools::GetAnimCompAnimName(plComponentBase *comp)
+plString plComponentTools::GetAnimCompAnimName(plComponentBase *comp)
 {
     return fAnimName(comp);
 }
 
-int plComponentTools::GetMaterialAnimModKey(Mtl* mtl, plMaxNodeBase* node, const char *segName, hsTArray<plKey>& keys)
+int plComponentTools::GetMaterialAnimModKey(Mtl* mtl, plMaxNodeBase* node, const plString &segName, hsTArray<plKey>& keys)
 {
     return fMatMod(mtl, node, segName, keys);
 }
diff --git a/Sources/Tools/MaxComponent/plComponentTools.h b/Sources/Tools/MaxComponent/plComponentTools.h
index 600afe84..9e076d1b 100644
--- a/Sources/Tools/MaxComponent/plComponentTools.h
+++ b/Sources/Tools/MaxComponent/plComponentTools.h
@@ -55,11 +55,11 @@ class plComponentBase;
 class plMaxNodeBase;
 
 typedef plKey       (*PAddModFunc) (plMaxNodeBase *, plModifier *);
-typedef plKey       (*PGetNewKeyFunc) (const char*, plModifier*, plLocation);
+typedef plKey       (*PGetNewKeyFunc) (const plString&, plModifier*, plLocation);
 typedef void        (*PSetActivatorKeyFunc) (plMaxNodeBase*, plMaxNodeBase*, plMaxNodeBase*, plResponderModifier*);
 typedef plKey       (*PGetAnimModKeyFunc) (plComponentBase*, plMaxNodeBase*);
-typedef const char* (*PGetAnimNameFunc) (plComponentBase*);
-typedef int         (*PGetMaterialAnimModKeyFunc) (Mtl* mtl, plMaxNodeBase* node, const char *segName, hsTArray<plKey>& keys);
+typedef plString    (*PGetAnimNameFunc) (plComponentBase*);
+typedef int         (*PGetMaterialAnimModKeyFunc) (Mtl* mtl, plMaxNodeBase* node, const plString &segName, hsTArray<plKey>& keys);
 typedef int         (*PGetSoundNameAndIndex) (plComponentBase*, plMaxNodeBase* node, const char*& name);
 
 //
@@ -101,14 +101,14 @@ public:
             {}
 
     plKey AddModifier(plMaxNodeBase *node, plModifier *mod);
-    plKey GetNewKey(const char *name, plModifier *mod, plLocation loc);
+    plKey GetNewKey(const plString &name, plModifier *mod, plLocation loc);
     void SetActivatorKey(plMaxNodeBase *activatorNode, plMaxNodeBase *responderNode, plMaxNodeBase *convertNode, plResponderModifier *responderLogic);
 
-    const char *GetAnimCompAnimName(plComponentBase *comp);
+    plString GetAnimCompAnimName(plComponentBase *comp);
     plKey GetAnimCompModKey(plComponentBase *comp, plMaxNodeBase *node);
 //  plKey GetAnimCompLightModKey(plComponentBase *comp, plMaxNodeBase *node);
 
-    int GetMaterialAnimModKey(Mtl* mtl, plMaxNodeBase* node, const char *segName, hsTArray<plKey>& keys);
+    int GetMaterialAnimModKey(Mtl* mtl, plMaxNodeBase* node, const plString &segName, hsTArray<plKey>& keys);
 
     int GetSoundNameAndIndex(plComponentBase* comp, plMaxNodeBase* node, const char*& name);
 };
diff --git a/Sources/Tools/MaxComponent/plFootstepComponent.cpp b/Sources/Tools/MaxComponent/plFootstepComponent.cpp
index 4c8131b8..71ba371d 100644
--- a/Sources/Tools/MaxComponent/plFootstepComponent.cpp
+++ b/Sources/Tools/MaxComponent/plFootstepComponent.cpp
@@ -115,7 +115,7 @@ hsBool plFootstepSoundComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
     plArmatureEffectFootSound *effect = new plArmatureEffectFootSound();
     
     // Note: MUST be a hard-coded keyname, since we search for same name in plArmatureMod.cpp
-    hsgResMgr::ResMgr()->NewKey( "FootstepSounds", effect, node->GetLocation());
+    hsgResMgr::ResMgr()->NewKey( _TEMP_CONVERT_FROM_LITERAL("FootstepSounds"), effect, node->GetLocation());
 
     int i;
     for (i = 0; i < plArmatureEffectsMgr::kMaxSurface; i++)
diff --git a/Sources/Tools/MaxComponent/plGUIComponents.cpp b/Sources/Tools/MaxComponent/plGUIComponents.cpp
index 10038a33..49c764f3 100644
--- a/Sources/Tools/MaxComponent/plGUIComponents.cpp
+++ b/Sources/Tools/MaxComponent/plGUIComponents.cpp
@@ -1319,7 +1319,7 @@ hsBool plGUIDialogComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
     // Add it to the sceneNode as a generic interface, so it gets loaded with the sceneNode
     plLocation nodeLoc = sceneNodeKey->GetUoid().GetLocation();
 
-    plKey modKey = hsgResMgr::ResMgr()->NewKey( fCompPB->GetStr( kRefDialogName ), mod, nodeLoc );
+    plKey modKey = hsgResMgr::ResMgr()->NewKey( plString::FromUtf8( fCompPB->GetStr( kRefDialogName ) ), mod, nodeLoc );
     hsgResMgr::ResMgr()->AddViaNotify( modKey, new plNodeRefMsg( sceneNodeKey, plRefMsg::kOnCreate, -1, plNodeRefMsg::kGeneric ), plRefFlags::kActiveRef );
 
     // Also add our dialog mod to the scene node in the same way
@@ -1360,7 +1360,7 @@ hsBool plGUIDialogComponent::PreConvert(plMaxNode *node,  plErrorMsg *pErrMsg)
                                                             fCompPB->GetStr( kRefDialogName ), (uint32_t)-1 );
 
         plLocation nodeLoc = sceneNodeKey->GetUoid().GetLocation();
-        plKey dlgKey = hsgResMgr::ResMgr()->NewKey( fCompPB->GetStr( kRefDialogName ), fDialogMod, nodeLoc );
+        plKey dlgKey = hsgResMgr::ResMgr()->NewKey( plString::FromUtf8( fCompPB->GetStr( kRefDialogName ) ), fDialogMod, nodeLoc );
 
         fDialogMod->SetSceneNodeKey( sceneNodeKey );
 
@@ -2728,7 +2728,7 @@ hsBool plGUIKnobCtrlComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
         plAGMasterMod   *master = node->GetAGMasterMod();
         hsTArray<plKey> keys;
         keys.Append( master->GetKey() );
-        ctrl->SetAnimationKeys( keys, ENTIRE_ANIMATION_NAME );
+        ctrl->SetAnimationKeys( keys, _TEMP_CONVERT_FROM_LITERAL( ENTIRE_ANIMATION_NAME ) );
     }
 
     if( fCompPB->GetInt( kRefOrientation ) == 1 )
@@ -4450,7 +4450,7 @@ hsBool plGUIProgressCtrlComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
         plAGMasterMod   *master = node->GetAGMasterMod();
         hsTArray<plKey> keys;
         keys.Append( master->GetKey() );
-        ctrl->SetAnimationKeys( keys, ENTIRE_ANIMATION_NAME );
+        ctrl->SetAnimationKeys( keys, _TEMP_CONVERT_FROM_LITERAL( ENTIRE_ANIMATION_NAME ) );
     }
 
     const char *errMsg = ISetSoundIndex( kRefAnimateSound, kRefAnimateSoundComp, pfGUIProgressCtrl::kAnimateSound, node );
diff --git a/Sources/Tools/MaxComponent/plInventoryObjComponent.cpp b/Sources/Tools/MaxComponent/plInventoryObjComponent.cpp
index 13b03360..af18367c 100644
--- a/Sources/Tools/MaxComponent/plInventoryObjComponent.cpp
+++ b/Sources/Tools/MaxComponent/plInventoryObjComponent.cpp
@@ -187,8 +187,7 @@ hsBool plInventoryObjComponent::PreConvert(plMaxNode *node, plErrorMsg *pErrMsg)
 
     // Create and register the ClickDrag's logic component
     plLogicModifier *logic = new plLogicModifier;
-    char tmpName[256];
-    sprintf(tmpName, "%s_%s_LogicModifier", obj->GetKeyName(), GetINode()->GetName());
+    plString tmpName = plString::Format("%s_%s_LogicModifier", obj->GetKeyName().c_str(), GetINode()->GetName());
     plKey logicKey = hsgResMgr::ResMgr()->NewKey(tmpName, logic, node->GetLocation());
     hsgResMgr::ResMgr()->AddViaNotify(logicKey, new plObjRefMsg(obj->GetKey(), plRefMsg::kOnCreate, -1, plObjRefMsg::kModifier), plRefFlags::kActiveRef);
 
diff --git a/Sources/Tools/MaxComponent/plMaxAnimUtils.cpp b/Sources/Tools/MaxComponent/plMaxAnimUtils.cpp
index e9157a3f..450863e4 100644
--- a/Sources/Tools/MaxComponent/plMaxAnimUtils.cpp
+++ b/Sources/Tools/MaxComponent/plMaxAnimUtils.cpp
@@ -58,11 +58,11 @@ float TimeValueToGameTime(TimeValue t)
     return float(t)/float(TPS);
 }
 
-bool GetSegMapAnimTime(const char *animName, SegmentMap *segMap, SegmentSpec::SegType type, float& begin, float& end)
+bool GetSegMapAnimTime(const plString &animName, SegmentMap *segMap, SegmentSpec::SegType type, float& begin, float& end)
 {
     if (segMap)
     {
-        if (animName && segMap->find(animName) != segMap->end())
+        if (!animName.IsNull() && segMap->find(animName) != segMap->end())
         {
             SegmentSpec *spec = (*segMap)[animName];
             if (spec->fType == type)
@@ -124,14 +124,13 @@ SegmentMap *GetSharedAnimSegmentMap(std::vector<Animatable*>& anims, plErrorMsg
     return segMap;
 }
 
-SegmentSpec::SegmentSpec(float start, float end, char * name, SegType type) :
+SegmentSpec::SegmentSpec(float start, float end, const plString & name, SegType type) :
     fStart(start), fEnd(end), fName(name), fType(type), fInitial(-1)
 {
 }
 
 SegmentSpec::~SegmentSpec()
 {
-    delete [] fName;
 }
 
 // constants used for parsing the note tracks
@@ -154,7 +153,6 @@ SegmentSpec::SegmentSpec()
     fStart = -1;
     fEnd = -1;
     fInitial = -1;
-    fName = nil;
     fType = kAnim;
 }
 
@@ -211,7 +209,10 @@ void GetSegment(const char *note, float time, SegmentMap *segMap, plErrorMsg *pE
     char segSuffix[256];
 
     int matchedFields = sscanf(note, " %[^@] @ %s ", segName, segSuffix);
-    
+
+    plString name = _TEMP_CONVERT_FROM_LITERAL(segName);
+    plString suffix = _TEMP_CONVERT_FROM_LITERAL(segSuffix);
+
     if (matchedFields == 2)
     {
         NoteType type = kNoteUnknown;
@@ -249,7 +250,7 @@ void GetSegment(const char *note, float time, SegmentMap *segMap, plErrorMsg *pE
         }
         else
         {
-            SegmentMap::iterator existing = segMap->find(segName);
+            SegmentMap::iterator existing = segMap->find(name);
             SegmentSpec *existingSpec = (existing != segMap->end()) ? (*existing).second : nil;
             const char *kErrorTitle = "NoteTrack Anim Error";
 
@@ -304,37 +305,33 @@ void GetSegment(const char *note, float time, SegmentMap *segMap, plErrorMsg *pE
                 }
                 else
                 {
-                    char *nameCopy = new char[strlen(segName)+1];
-                    strcpy(nameCopy, segName);
-
                     switch (type)
                     {
                     case kNoteStartAnim:
-                        (*segMap)[nameCopy] = new SegmentSpec(time, -1, nameCopy, SegmentSpec::kAnim);
+                        (*segMap)[name] = new SegmentSpec(time, -1, name, SegmentSpec::kAnim);
                         break;
 
                     case kNoteStartLoop:
-                        (*segMap)[nameCopy] = new SegmentSpec(time, -1, nameCopy, SegmentSpec::kLoop);
+                        (*segMap)[name] = new SegmentSpec(time, -1, name, SegmentSpec::kLoop);
                         break;
 
                     case kNoteEndLoop:
-                        (*segMap)[nameCopy] = new SegmentSpec(-1, time, nameCopy, SegmentSpec::kLoop);
+                        (*segMap)[name] = new SegmentSpec(-1, time, name, SegmentSpec::kLoop);
                         break;
 
                     case kNoteMarker:
-                        (*segMap)[nameCopy] = new SegmentSpec(time, -1, nameCopy, SegmentSpec::kMarker);
+                        (*segMap)[name] = new SegmentSpec(time, -1, name, SegmentSpec::kMarker);
                         break;
 
                     case kNoteStopPoint:
-                        (*segMap)[nameCopy] = new SegmentSpec(time, -1, nameCopy, SegmentSpec::kStopPoint);
+                        (*segMap)[name] = new SegmentSpec(time, -1, name, SegmentSpec::kStopPoint);
                         break;
 
                     case kNoteSuppress:
-                        (*segMap)[nameCopy] = new SegmentSpec(-1, -1, nameCopy, SegmentSpec::kSuppress);
+                        (*segMap)[name] = new SegmentSpec(-1, -1, name, SegmentSpec::kSuppress);
                         break;
                         
                     default:
-                        delete [] nameCopy;
                         break;
                     }
                 }
diff --git a/Sources/Tools/MaxComponent/plMaxAnimUtils.h b/Sources/Tools/MaxComponent/plMaxAnimUtils.h
index 2af1541a..8e687f04 100644
--- a/Sources/Tools/MaxComponent/plMaxAnimUtils.h
+++ b/Sources/Tools/MaxComponent/plMaxAnimUtils.h
@@ -45,6 +45,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 #include <map>
 #include <vector>
 #include "hsStlSortUtils.h"
+#include "plString.h"
 
 class plErrorMsg;
 class Animatable;
@@ -59,11 +60,11 @@ public:
     float   fStart;     // beginning of the segment in game time
     float   fEnd;       // end of the segment in game time
     float   fInitial;   // initial position of the animation (-1 for the start)
-    char * fName;       // name of the segment: controls lifespan of the name
+    plString  fName;    // name of the segment: controls lifespan of the name
     SegType fType;
     
     SegmentSpec();
-    SegmentSpec(float start, float end, char * name, SegType);
+    SegmentSpec(float start, float end, const plString & name, SegType);
     ~SegmentSpec();
 
     bool Contains(SegmentSpec *spec);
@@ -71,7 +72,7 @@ public:
 
 
 // a table mapping segment names to segment spec objects
-typedef std::map<const char *, SegmentSpec*, stringISorter> SegmentMap;
+typedef std::map<plString, SegmentSpec*, plString::less_i> SegmentMap;
 
 // You can pass in nil for pErrMsg for silent operation
 SegmentMap *GetAnimSegmentMap(Animatable *anim, plErrorMsg *pErrMsg);
@@ -80,7 +81,7 @@ void DeleteSegmentMap(SegmentMap *segMap);
 
 SegmentMap *GetSharedAnimSegmentMap(std::vector<Animatable*>& anims, plErrorMsg *pErrorMsg);
 
-bool GetSegMapAnimTime(const char *animName, SegmentMap *segMap, SegmentSpec::SegType type, float& begin, float& end);
+bool GetSegMapAnimTime(const plString &animName, SegmentMap *segMap, SegmentSpec::SegType type, float& begin, float& end);
 
 // For internal use
 void GetSegment(const char *note, float time, SegmentMap *segMap, plErrorMsg *pErrMsg);
diff --git a/Sources/Tools/MaxComponent/plNotetrackAnim.cpp b/Sources/Tools/MaxComponent/plNotetrackAnim.cpp
index 6555b578..6aa6159c 100644
--- a/Sources/Tools/MaxComponent/plNotetrackAnim.cpp
+++ b/Sources/Tools/MaxComponent/plNotetrackAnim.cpp
@@ -79,10 +79,10 @@ plNotetrackAnim::~plNotetrackAnim()
     DeleteSegmentMap(fSegMap);
 }
 
-const char *plNotetrackAnim::GetNextAnimName()
+plString plNotetrackAnim::GetNextAnimName()
 {
     if (!fSegMap)
-        return nil;
+        return plString::Null;
 
     while (fAnimIt != fSegMap->end())
     {
@@ -94,28 +94,28 @@ const char *plNotetrackAnim::GetNextAnimName()
     }
 
     fAnimIt = fSegMap->begin();
-    return nil;
+    return plString::Null;
 }
 
-plAnimInfo plNotetrackAnim::GetAnimInfo(const char *animName)
+plAnimInfo plNotetrackAnim::GetAnimInfo(const plString &animName)
 {
     if (!fSegMap)
         return plAnimInfo();
 
-    if (!animName || *animName == '\0' || fSegMap->find(animName) == fSegMap->end())
-        return plAnimInfo(fSegMap, nil);
+    if (animName.IsEmpty() || fSegMap->find(animName) == fSegMap->end())
+        return plAnimInfo(fSegMap, plString::Null);
     else 
-        return plAnimInfo(fSegMap, animName);   
+        return plAnimInfo(fSegMap, animName);
 
     return plAnimInfo();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-plAnimInfo::plAnimInfo(SegmentMap *segMap, const char *animName)
+plAnimInfo::plAnimInfo(SegmentMap *segMap, const plString &animName)
 {
     fSegMap = segMap;
-    fAnimSpec = animName ? (*fSegMap)[animName] : nil;
+    fAnimSpec = !animName.IsNull() ? (*fSegMap)[animName] : nil;
 
     if (fSegMap)
     {
@@ -125,9 +125,9 @@ plAnimInfo::plAnimInfo(SegmentMap *segMap, const char *animName)
     }
 }
 
-const char *plAnimInfo::GetAnimName()
+plString plAnimInfo::GetAnimName()
 {
-    return fAnimSpec ? fAnimSpec->fName : nil;
+    return fAnimSpec ? fAnimSpec->fName : plString::Null;
 }
 
 float plAnimInfo::GetAnimStart()
@@ -145,10 +145,10 @@ float plAnimInfo::GetAnimInitial()
     return fAnimSpec ? fAnimSpec->fInitial : -1;
 }
 
-const char *plAnimInfo::GetNextLoopName()
+plString plAnimInfo::GetNextLoopName()
 {
     if (!fSegMap)
-        return nil;
+        return plString::Null;
 
     while (fLoopIt != fSegMap->end())
     {
@@ -161,12 +161,12 @@ const char *plAnimInfo::GetNextLoopName()
     }
 
     fLoopIt = fSegMap->begin();
-    return nil;
+    return plString::Null;
 }
 
-float plAnimInfo::GetLoopStart(const char *loopName)
+float plAnimInfo::GetLoopStart(const plString &loopName)
 {
-    if (!fSegMap || loopName == nil)
+    if (!fSegMap || loopName.IsNull())
         return -1;
 
     if (fSegMap->find(loopName) != fSegMap->end())
@@ -181,9 +181,9 @@ float plAnimInfo::GetLoopStart(const char *loopName)
     return -1;
 }
 
-float plAnimInfo::GetLoopEnd(const char *loopName)
+float plAnimInfo::GetLoopEnd(const plString &loopName)
 {
-    if (!fSegMap || loopName == nil)
+    if (!fSegMap || loopName.IsNull())
         return -1;
 
     if (fSegMap->find(loopName) != fSegMap->end())
@@ -198,10 +198,10 @@ float plAnimInfo::GetLoopEnd(const char *loopName)
     return -1;
 }
 
-const char *plAnimInfo::GetNextMarkerName()
+plString plAnimInfo::GetNextMarkerName()
 {
     if (!fSegMap)
-        return nil;
+        return plString::Null;
 
     while (fMarkerIt != fSegMap->end())
     {
@@ -214,10 +214,10 @@ const char *plAnimInfo::GetNextMarkerName()
     }
 
     fMarkerIt = fSegMap->begin();
-    return nil;
+    return plString::Null;
 }
 
-float plAnimInfo::GetMarkerTime(const char *markerName)
+float plAnimInfo::GetMarkerTime(const plString &markerName)
 {
     if (!fSegMap)
         return -1;
@@ -250,9 +250,9 @@ float plAnimInfo::GetNextStopPoint()
     return -1;
 }
 
-bool plAnimInfo::IsSuppressed(const char *animName)
+bool plAnimInfo::IsSuppressed(const plString &animName)
 {
-    if (!fSegMap || animName == nil)
+    if (!fSegMap || animName.IsNull())
         return false;
 
     if (fSegMap->find(animName) != fSegMap->end())
diff --git a/Sources/Tools/MaxComponent/plNotetrackAnim.h b/Sources/Tools/MaxComponent/plNotetrackAnim.h
index 6dc51d1f..b527fb2f 100644
--- a/Sources/Tools/MaxComponent/plNotetrackAnim.h
+++ b/Sources/Tools/MaxComponent/plNotetrackAnim.h
@@ -56,22 +56,22 @@ protected:
 
 public:
     plAnimInfo() : fSegMap(NULL), fAnimSpec(NULL) {}
-    plAnimInfo(SegmentMap *segMap, const char *animName);
+    plAnimInfo(SegmentMap *segMap, const plString &animName);
 
-    const char *GetAnimName();
+    plString GetAnimName();
     float GetAnimStart();
     float GetAnimEnd();
     float GetAnimInitial();
 
-    const char *GetNextLoopName();
-    float GetLoopStart(const char *loopName);
-    float GetLoopEnd(const char *loopName);
+    plString GetNextLoopName();
+    float GetLoopStart(const plString &loopName);
+    float GetLoopEnd(const plString &loopName);
 
-    const char *GetNextMarkerName();
-    float GetMarkerTime(const char *markerName);
+    plString GetNextMarkerName();
+    float GetMarkerTime(const plString &markerName);
 
     float GetNextStopPoint();   // Returns -1 on last stop point
-    bool IsSuppressed(const char *animName);
+    bool IsSuppressed(const plString &animName);
 };
 
 class plNotetrackAnim
@@ -88,8 +88,8 @@ public:
 
     bool HasNotetracks() { return (fSegMap != NULL); }
 
-    const char *GetNextAnimName();
-    plAnimInfo GetAnimInfo(const char *animName);
+    plString GetNextAnimName();
+    plAnimInfo GetAnimInfo(const plString &animName);
 };
 
-#endif //PL_NOTETRACK_ANIM
\ No newline at end of file
+#endif //PL_NOTETRACK_ANIM
diff --git a/Sources/Tools/MaxComponent/plNotetrackDlg.cpp b/Sources/Tools/MaxComponent/plNotetrackDlg.cpp
index d452ffde..2bd77f41 100644
--- a/Sources/Tools/MaxComponent/plNotetrackDlg.cpp
+++ b/Sources/Tools/MaxComponent/plNotetrackDlg.cpp
@@ -129,11 +129,11 @@ void plNoteTrackDlg::ILoadAnims()
         SegmentSpec *spec = it->second;
         if (spec->fType == SegmentSpec::kAnim)
         {
-            int idx = ComboBox_AddString(fhAnim, spec->fName);
+            int idx = ComboBox_AddString(fhAnim, spec->fName.c_str());
             ComboBox_SetItemData(fhAnim, idx, kName);
 
             // If this is the saved animation name, select it
-            if (!strcmp(spec->fName, savedAnim))
+            if (!spec->fName.Compare(savedAnim))
                 ComboBox_SetCurSel(fhAnim, idx);
         }
     }
@@ -155,8 +155,8 @@ void plNoteTrackDlg::ILoadLoops()
     {
         // Get the animation segment (or leave it nil if we're using the entire animation)
         SegmentSpec *animSpec = nil;
-        const char *animName = fPB->GetStr(fAnimID);
-        if (animName && *animName != '\0' && fSegMap->find(animName) != fSegMap->end())
+        plString animName = plString::FromUtf8(fPB->GetStr(fAnimID));
+        if (!animName.IsEmpty() && fSegMap->find(animName) != fSegMap->end())
             animSpec = (*fSegMap)[animName];
 
         // Get the saved loop name
@@ -174,10 +174,10 @@ void plNoteTrackDlg::ILoadLoops()
                 if (!animSpec || animSpec->Contains(spec))
                 {
                     // Add the name
-                    int idx = ComboBox_AddString(fhLoop, spec->fName);
+                    int idx = ComboBox_AddString(fhLoop, spec->fName.c_str());
                     ComboBox_SetItemData(fhLoop, idx, kName);
 
-                    if (!strcmp(loopName, spec->fName))
+                    if (!spec->fName.Compare(loopName))
                         ComboBox_SetCurSel(fhLoop, idx);
                 }
             }
@@ -192,7 +192,7 @@ const char *plNoteTrackDlg::IGetSel(HWND hCombo)
     {
         char buf[256];
         ComboBox_GetText(hCombo, buf, sizeof(buf));
-        return (*fSegMap)[buf]->fName;
+        return (*fSegMap)[plString::FromUtf8(buf)]->fName.c_str();
     }
 
     return "";
diff --git a/Sources/Tools/MaxComponent/plObjectFlockerComponent.cpp b/Sources/Tools/MaxComponent/plObjectFlockerComponent.cpp
index e69917bc..03877df1 100644
--- a/Sources/Tools/MaxComponent/plObjectFlockerComponent.cpp
+++ b/Sources/Tools/MaxComponent/plObjectFlockerComponent.cpp
@@ -271,7 +271,7 @@ hsBool plObjectFlockerComponent::PreConvert(plMaxNode *node, plErrorMsg *pErrMsg
 
 hsBool plObjectFlockerComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
 {
-    node->AddModifier(fFlocker, nil);
+    node->AddModifier(fFlocker, plString::Null);
 
     return true;
 }
diff --git a/Sources/Tools/MaxComponent/plParticleComponents.cpp b/Sources/Tools/MaxComponent/plParticleComponents.cpp
index fe19769c..3bee66b9 100644
--- a/Sources/Tools/MaxComponent/plParticleComponents.cpp
+++ b/Sources/Tools/MaxComponent/plParticleComponents.cpp
@@ -165,7 +165,7 @@ hsBool plParticleCoreComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
     int32_t i, j, k;
 
     plLocation nodeLoc = node->GetKey()->GetUoid().GetLocation();
-    const char *objName = node->GetKey()->GetName();
+    plString objName = node->GetKey()->GetName();
 
     plSceneObject *sObj = node->GetSceneObject();
     plParticleSystem *sys = new plParticleSystem();
@@ -518,7 +518,7 @@ hsBool plParticleCoreComponent::AddToAnim(plAGAnim *anim, plMaxNode *node)
     hsControlConverter& cc = hsControlConverter::Instance();
 
     float start, end;
-    if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
+    if (!anim->GetName().Compare(ENTIRE_ANIMATION_NAME))
     {
         start = end = -1;
     }
@@ -1051,7 +1051,7 @@ void plParticleVolumeComponent::BuildVolume(plMaxNode *node)
         return; // already converted it
 
     fBound = new plBoundInterface;
-    hsgResMgr::ResMgr()->NewKey(node->GetName(), fBound, node->GetLocation(), node->GetLoadMask());
+    hsgResMgr::ResMgr()->NewKey(plString::FromUtf8(node->GetName()), fBound, node->GetLocation(), node->GetLoadMask());
     fBound->Init(plMeshConverter::Instance().CreateConvexVolume(node));
     hsgResMgr::ResMgr()->AddViaNotify(fBound->GetKey(), new plObjRefMsg(node->GetKey(), plRefMsg::kOnCreate, -1, plObjRefMsg::kInterface), plRefFlags::kActiveRef);
 }
diff --git a/Sources/Tools/MaxComponent/plPhysicalComponents.cpp b/Sources/Tools/MaxComponent/plPhysicalComponents.cpp
index 7dc18d04..b2a8b7ad 100644
--- a/Sources/Tools/MaxComponent/plPhysicalComponents.cpp
+++ b/Sources/Tools/MaxComponent/plPhysicalComponents.cpp
@@ -1325,19 +1325,19 @@ hsBool plSwim2DComponent::PreConvert(plMaxNode *node, plErrorMsg *pErrMsg)
     case kCurrentSpiral:
         {
             fSwimRegions[node] = new plSwimCircularCurrentRegion();
-            hsgResMgr::ResMgr()->NewKey(node->GetName(), fSwimRegions[node], node->GetLocation(), node->GetLoadMask()); 
+            hsgResMgr::ResMgr()->NewKey(plString::FromUtf8(node->GetName()), fSwimRegions[node], node->GetLocation(), node->GetLoadMask());
             break;
         }
     case kCurrentStraight:
         {
             fSwimRegions[node] = new plSwimStraightCurrentRegion();
-            hsgResMgr::ResMgr()->NewKey(node->GetName(), fSwimRegions[node], node->GetLocation(), node->GetLoadMask());
+            hsgResMgr::ResMgr()->NewKey(plString::FromUtf8(node->GetName()), fSwimRegions[node], node->GetLocation(), node->GetLoadMask());
             break;
         }
     default:
         {
             fSwimRegions[node] = new plSwimRegionInterface();
-            hsgResMgr::ResMgr()->NewKey(node->GetName(), fSwimRegions[node], node->GetLocation(), node->GetLoadMask());
+            hsgResMgr::ResMgr()->NewKey(plString::FromUtf8(node->GetName()), fSwimRegions[node], node->GetLocation(), node->GetLoadMask());
             break;
         }
     }
diff --git a/Sources/Tools/MaxComponent/plPythonFileComponent.cpp b/Sources/Tools/MaxComponent/plPythonFileComponent.cpp
index ad04ea10..f08f0457 100644
--- a/Sources/Tools/MaxComponent/plPythonFileComponent.cpp
+++ b/Sources/Tools/MaxComponent/plPythonFileComponent.cpp
@@ -102,7 +102,7 @@ class plCommonPythonLib : public plCommonObjLib
             if( objectKey->GetUoid().GetClassType() == plPythonFileMod::Index() )
                 return true;
             if( objectKey->GetUoid().GetClassType() == plSceneObject::Index() &&
-                strcmp( objectKey->GetUoid().GetObjectName(), plSDL::kAgeSDLObjectName ) == 0 )
+                objectKey->GetUoid().GetObjectName().Compare( plSDL::kAgeSDLObjectName ) == 0 )
                 return true;
             return false;
         }
@@ -457,7 +457,7 @@ hsBool plPythonFileComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
             break;
 
         case plAutoUIParam::kTypeString:
-            pyParam.SetToString(param->GetString(pb));
+            pyParam.SetToString(_TEMP_CONVERT_FROM_LITERAL(param->GetString(pb)));
             mod->AddParameter(pyParam);
             break;
 
@@ -805,9 +805,9 @@ hsBool plPythonFileComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
                     {
                         plAnimComponentBase *animcomp = (plAnimComponentBase*)comp;
                         // save out the animation name first
-                        const char *tempAnimName = animcomp->GetAnimName();
-                        if (tempAnimName == nil)
-                            pyParam.SetToAnimationName(ENTIRE_ANIMATION_NAME);
+                        plString tempAnimName = animcomp->GetAnimName();
+                        if (tempAnimName.IsNull())
+                            pyParam.SetToAnimationName(_TEMP_CONVERT_FROM_LITERAL(ENTIRE_ANIMATION_NAME));
                         else
                             pyParam.SetToAnimationName(tempAnimName);
                         mod->AddParameter(pyParam);
@@ -929,7 +929,7 @@ hsBool plPythonFileComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
             break;
         
         case plAutoUIParam::kTypeDropDownList:
-            pyParam.SetToString(param->GetString(pb));
+            pyParam.SetToString(_TEMP_CONVERT_FROM_LITERAL(param->GetString(pb)));
             mod->AddParameter(pyParam);
             break;
 
@@ -1074,13 +1074,13 @@ static BOOL CALLBACK WarnDialogProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM l
 
             switch (err.error)
             {
-            case plPythonFileComponent::Validate::kPythonBadVer:
+            case plPythonFileComponent::kPythonBadVer:
                 ListView_SetItemText(hList, idx, 2, "Old Version");
                 break;
-            case plPythonFileComponent::Validate::kPythonNoVer:
+            case plPythonFileComponent::kPythonNoVer:
                 ListView_SetItemText(hList, idx, 2, "No Version");
                 break;
-            case plPythonFileComponent::Validate::kPythonNoFile:
+            case plPythonFileComponent::kPythonNoFile:
                 ListView_SetItemText(hList, idx, 2, "No File/Python Error");
                 break;
             }
@@ -1119,10 +1119,10 @@ static void WriteBadPythonText(ErrorSet& badNodes)
         case plPythonFileComponent::kPythonBadVer:
             errorText = "Old Version";
             break;
-        case plPythonFileComponent::Validate::kPythonNoVer:
+        case plPythonFileComponent::kPythonNoVer:
             errorText = "No Version";
             break;
-        case plPythonFileComponent::Validate::kPythonNoFile:
+        case plPythonFileComponent::kPythonNoFile:
             errorText = "No File/Python Error";
             break;
         }
diff --git a/Sources/Tools/MaxComponent/plResponderAnim.cpp b/Sources/Tools/MaxComponent/plResponderAnim.cpp
index 74305162..be20aa8e 100644
--- a/Sources/Tools/MaxComponent/plResponderAnim.cpp
+++ b/Sources/Tools/MaxComponent/plResponderAnim.cpp
@@ -333,7 +333,7 @@ plMessage *plResponderCmdAnim::ICreateAnimMsg(plMaxNode* node, plErrorMsg *pErrM
     plAnimCmdMsg *msg = new plAnimCmdMsg;
     msg->AddReceiver(animKey);
 
-    const char *tempAnimName = comp->GetAnimName();
+    plString tempAnimName = comp->GetAnimName();
     msg->SetAnimName(tempAnimName);
 
     // Create and initialize a message for the command
@@ -364,7 +364,7 @@ plMessage *plResponderCmdAnim::ICreateAnimMsg(plMaxNode* node, plErrorMsg *pErrM
             // anims with a loop set in advance will actually work with this. -Colin
 //          msg->SetCmd(plAnimCmdMsg::kSetLoopBegin);
 //          msg->SetCmd(plAnimCmdMsg::kSetLoopEnd);
-            const char *loopName = pb->GetStr(kAnimLoop);
+            plString loopName = plString::FromUtf8(pb->GetStr(kAnimLoop));
             msg->SetLoopName(loopName);
         }
         break;
@@ -481,13 +481,14 @@ void plResponderCmdAnim::GetWaitPoints(IParamBlock2 *pb, WaitPoints& waitPoints)
         return;
 
     plAnimComponent *animComp = (plAnimComponent*)GetComponent(pb);
-    const char *animName = animComp->GetAnimName();
+    plString animName = animComp->GetAnimName();
 
     if (animComp)
     {
         plNotetrackAnim notetrackAnim(animComp, nil);
         plAnimInfo info = notetrackAnim.GetAnimInfo(animName);
-        while (const char *marker = info.GetNextMarkerName())
+        plString marker;
+        while (!(marker = info.GetNextMarkerName()).IsNull())
             waitPoints.push_back(marker);
     }
 }
@@ -507,11 +508,11 @@ void plResponderCmdAnim::CreateWait(plMaxNode* node, plErrorMsg* pErrMsg, IParam
     eventMsg->fRepeats = 0;
     eventMsg->fUser = waitInfo.callbackUser;
 
-    if (waitInfo.point)
+    if (!waitInfo.point.IsNull())
     {
         // FIXME COLIN - Error checking here?
         plAnimComponent *animComp = (plAnimComponent*)GetComponent(pb);
-        const char *animName = animComp->GetAnimName();
+        plString animName = animComp->GetAnimName();
 
         plNotetrackAnim notetrackAnim(animComp, nil);
         plAnimInfo info = notetrackAnim.GetAnimInfo(animName);
@@ -752,18 +753,19 @@ void plResponderAnimProc::ILoadUser(HWND hWnd, IParamBlock2 *pb)
     plComponentBase *comp = plResponderCmdAnim::Instance().GetComponent(pb);
     if (comp && comp->ClassID() == ANIM_COMP_CID)
     {
-        const char *animName = ((plAnimComponent*)comp)->GetAnimName();
+        plString animName = ((plAnimComponent*)comp)->GetAnimName();
 
         // Get the shared animations for all the nodes this component is applied to
         plNotetrackAnim anim(comp, nil);
         plAnimInfo info = anim.GetAnimInfo(animName);
         // Get all the loops in this animation
-        while (const char *loopName = info.GetNextLoopName())
+        plString loopName;
+        while (!(loopName = info.GetNextLoopName()).IsNull())
         {
-            int idx = ComboBox_AddString(hLoop, loopName);
+            int idx = ComboBox_AddString(hLoop, loopName.c_str());
             ComboBox_SetItemData(hLoop, idx, 1);
 
-            if (!strcmp(loopName, savedName))
+            if (!loopName.Compare(savedName))
                 ComboBox_SetCurSel(hLoop, idx);
         }
 
diff --git a/Sources/Tools/MaxComponent/plResponderCmd.h b/Sources/Tools/MaxComponent/plResponderCmd.h
index 0a4c8706..2cf6557f 100644
--- a/Sources/Tools/MaxComponent/plResponderCmd.h
+++ b/Sources/Tools/MaxComponent/plResponderCmd.h
@@ -55,11 +55,11 @@ class plMaxNode;
 class ResponderWaitInfo
 {
 public:
-    const char* responderName;  // For error messages
+    plString responderName;  // For error messages
 
     plMessage *msg;     // Message created by the responder command
     plKey receiver;     // Key to send the callback message to
-    const char *point;  // Marker name to wait on (nil for end)
+    plString point;     // Marker name to wait on (nil for end)
     int callbackUser;   // Value to set the callback user value to
 };
 
@@ -81,7 +81,7 @@ public:
     virtual void SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg, IParamBlock2* pb) {}
     virtual plMessage *CreateMsg(plMaxNode* node, plErrorMsg* pErrMsg, IParamBlock2* pb)=0;
 
-    typedef std::vector<std::string> WaitPoints;
+    typedef std::vector<plString> WaitPoints;
     // Can other commands wait on you?
     virtual bool IsWaitable(IParamBlock2 *pb) { return false; }
     // The names of the points commands can wait on (or leave empty for only 'end')
diff --git a/Sources/Tools/MaxComponent/plResponderComponent.cpp b/Sources/Tools/MaxComponent/plResponderComponent.cpp
index 8f6fcf18..a6cabda4 100644
--- a/Sources/Tools/MaxComponent/plResponderComponent.cpp
+++ b/Sources/Tools/MaxComponent/plResponderComponent.cpp
@@ -491,11 +491,11 @@ void plResponderComponent::ISetupDefaultWait(plMaxNode* node, plErrorMsg* pErrMs
             int convertedIdx = cmdIdxs[i];
 
             ResponderWaitInfo waitInfo;
-            waitInfo.responderName = GetINode()->GetName();
+            waitInfo.responderName = plString::FromUtf8(GetINode()->GetName());
             waitInfo.receiver = responder->GetKey();
             waitInfo.callbackUser = numCallbacks++;
             waitInfo.msg = cmds[convertedIdx].fMsg;
-            waitInfo.point = nil;
+            waitInfo.point = plString::Null;
 
             IParamBlock2 *pb = (IParamBlock2*)statePB->GetReferenceTarget(kStateCmdParams, 0, i);
             plResponderCmd *cmd = plResponderCmd::Find(pb);
@@ -525,7 +525,7 @@ void plResponderComponent::IConvertCmdWaits(plMaxNode* node, plErrorMsg* pErrMsg
             int convertedIdx = cmdIdxs[wait];
 
             ResponderWaitInfo waitInfo;
-            waitInfo.responderName = GetINode()->GetName();
+            waitInfo.responderName = plString::FromUtf8(GetINode()->GetName());
             waitInfo.receiver = responder->GetKey();
             waitInfo.callbackUser = numCallbacks++;
             waitInfo.msg = cmds[convertedIdx].fMsg;
diff --git a/Sources/Tools/MaxComponent/plResponderLink.cpp b/Sources/Tools/MaxComponent/plResponderLink.cpp
index 6b0ea760..4ca2db98 100644
--- a/Sources/Tools/MaxComponent/plResponderLink.cpp
+++ b/Sources/Tools/MaxComponent/plResponderLink.cpp
@@ -1262,7 +1262,7 @@ void plResponderCmdDelay::CreateWait(plMaxNode* node, plErrorMsg* pErrMsg, IPara
                     "However, you don't actually need two commands to wait on\n"
                     "the same command since the first command will automatically\n"
                     "delay any commands further down the list",
-                    waitInfo.responderName, node->GetName()).Show();
+                    waitInfo.responderName.c_str(), node->GetName()).Show();
         pErrMsg->Set(false);
     }
     else
diff --git a/Sources/Tools/MaxComponent/plResponderMtl.cpp b/Sources/Tools/MaxComponent/plResponderMtl.cpp
index 4feff3a5..494d42e2 100644
--- a/Sources/Tools/MaxComponent/plResponderMtl.cpp
+++ b/Sources/Tools/MaxComponent/plResponderMtl.cpp
@@ -250,12 +250,12 @@ Mtl *plResponderCmdMtl::GetMtl(IParamBlock2 *pb)
     return (Mtl*)pb->GetReferenceTarget(kMtlRef);
 }
 
-const char *plResponderCmdMtl::GetAnim(IParamBlock2 *pb)
+plString plResponderCmdMtl::GetAnim(IParamBlock2 *pb)
 {
-    return pb->GetStr(kMtlAnim);
+    return plString::FromUtf8(pb->GetStr(kMtlAnim));
 }
 
-void ISearchLayerRecur(plLayerInterface *layer, const char *segName, hsTArray<plKey>& keys)
+void ISearchLayerRecur(plLayerInterface *layer, const plString &segName, hsTArray<plKey>& keys)
 {
     if (!layer)
         return;
@@ -263,10 +263,8 @@ void ISearchLayerRecur(plLayerInterface *layer, const char *segName, hsTArray<pl
     plLayerAnimation *animLayer = plLayerAnimation::ConvertNoRef(layer);
     if (animLayer)
     {
-        char *ID = animLayer->GetSegmentID();
-        if (ID == nil)
-            ID = "";
-        if (!strcmp(ID, segName))
+        plString ID = animLayer->GetSegmentID();
+        if (!segName.Compare(ID))
         {
             if( keys.kMissingIndex == keys.Find(animLayer->GetKey()) )
                 keys.Append(animLayer->GetKey());
@@ -276,17 +274,16 @@ void ISearchLayerRecur(plLayerInterface *layer, const char *segName, hsTArray<pl
     ISearchLayerRecur(layer->GetAttached(), segName, keys);
 }
 
-int ISearchLayerRecur(hsGMaterial* mat, const char *segName, hsTArray<plKey>& keys)
+int ISearchLayerRecur(hsGMaterial* mat, const plString &segName, hsTArray<plKey>& keys)
 {
-    if (segName == nil)
-        segName = "";
+    plString name = segName.IsNull() ? _TEMP_CONVERT_FROM_LITERAL("") : segName;
     int i;
     for( i = 0; i < mat->GetNumLayers(); i++ )
-        ISearchLayerRecur(mat->GetLayer(i), segName, keys);
+        ISearchLayerRecur(mat->GetLayer(i), name, keys);
     return keys.GetCount();
 }
 
-int GetMatAnimModKey(Mtl* mtl, plMaxNodeBase* node, const char* segName, hsTArray<plKey>& keys)
+int GetMatAnimModKey(Mtl* mtl, plMaxNodeBase* node, const plString& segName, hsTArray<plKey>& keys)
 {
     int retVal = 0;
 
@@ -336,7 +333,7 @@ plMessage *plResponderCmdMtl::CreateMsg(plMaxNode* node, plErrorMsg *pErrMsg, IP
     if (!maxMtl)
         throw "No material specified";
 
-    const char *animName = pb->GetStr(kMtlAnim);
+    plString animName = plString::FromUtf8(pb->GetStr(kMtlAnim));
     float begin=-1.f;
     float end = -1.f;
 
@@ -357,9 +354,8 @@ plMessage *plResponderCmdMtl::CreateMsg(plMaxNode* node, plErrorMsg *pErrMsg, IP
 
     GetMatAnimModKey(maxMtl, mtlNode, animName, keys);
 
-    const char *loopName = nil;
-    loopName = pb->GetStr(kMtlLoop);
-    if (segMap && loopName)
+    plString loopName = plString::FromUtf8(pb->GetStr(kMtlLoop));
+    if (segMap && !loopName.IsNull())
         GetSegMapAnimTime(loopName, segMap, SegmentSpec::kLoop, begin, end);
 
     DeleteSegmentMap(segMap);
@@ -445,13 +441,14 @@ bool plResponderCmdMtl::IsWaitable(IParamBlock2 *pb)
 void plResponderCmdMtl::GetWaitPoints(IParamBlock2 *pb, WaitPoints& waitPoints)
 {
     Mtl *mtl = GetMtl(pb);
-    const char *animName = GetAnim(pb);
+    plString animName = GetAnim(pb);
 
     if (mtl)
     {
         plNotetrackAnim notetrackAnim(mtl, nil);
         plAnimInfo info = notetrackAnim.GetAnimInfo(animName);
-        while (const char *marker = info.GetNextMarkerName())
+        plString marker;
+        while (!(marker = info.GetNextMarkerName()).IsNull())
             waitPoints.push_back(marker);
     }
 }
@@ -468,11 +465,11 @@ void plResponderCmdMtl::CreateWait(plMaxNode* node, plErrorMsg* pErrMsg, IParamB
     eventMsg->fEvent = kStop;
     eventMsg->fUser = waitInfo.callbackUser;
 
-    if (waitInfo.point)
+    if (!waitInfo.point.IsNull())
     {
         // FIXME COLIN - Error checking here?
         Mtl *mtl = GetMtl(pb);
-        const char *animName = GetAnim(pb);
+        plString animName = GetAnim(pb);
 
         plNotetrackAnim notetrackAnim(mtl, nil);
         plAnimInfo info = notetrackAnim.GetAnimInfo(animName);
@@ -545,13 +542,14 @@ void plResponderMtlProc::ILoadUser(HWND hWnd, IParamBlock2 *pb)
     ComboBox_Enable(hLoop, TRUE);
 
     plNotetrackAnim anim(mtl, nil);
-    const char *animName = pb->GetStr(kMtlAnim);
+    plString animName = plString::FromUtf8(pb->GetStr(kMtlAnim));
     plAnimInfo info = anim.GetAnimInfo(animName);
 
-    while (const char *loopName = info.GetNextLoopName())
+    plString loopName;
+    while (!(loopName = info.GetNextLoopName()).IsNull())
     {
-        sel = ComboBox_AddString(hLoop, loopName);
-        if (!strcmp(loopName, savedName))
+        sel = ComboBox_AddString(hLoop, loopName.c_str());
+        if (!loopName.Compare(savedName))
             ComboBox_SetCurSel(hLoop, sel);
     }
 }
diff --git a/Sources/Tools/MaxComponent/plResponderMtl.h b/Sources/Tools/MaxComponent/plResponderMtl.h
index e0a9aa7f..a738f1a3 100644
--- a/Sources/Tools/MaxComponent/plResponderMtl.h
+++ b/Sources/Tools/MaxComponent/plResponderMtl.h
@@ -52,7 +52,7 @@ class Mtl;
 class plMaxNodeBase;
 template <class T> class hsTArray;
 
-int GetMatAnimModKey(Mtl* mtl, plMaxNodeBase* node, const char *segName, hsTArray<plKey>& keys);
+int GetMatAnimModKey(Mtl* mtl, plMaxNodeBase* node, const plString &segName, hsTArray<plKey>& keys);
 
 class plResponderCmdMtl : public plResponderCmd
 {
@@ -74,7 +74,7 @@ public:
     virtual void CreateWait(plMaxNode* node, plErrorMsg* pErrMsg, IParamBlock2 *pb, ResponderWaitInfo& waitInfo);
     
     Mtl *GetMtl(IParamBlock2 *pb);
-    const char *GetAnim(IParamBlock2 *pb);
+    plString GetAnim(IParamBlock2 *pb);
 };
 
-int GetMatAnimModKey(Mtl* mtl, plMaxNodeBase* node, const char* segName, hsTArray<plKey>& keys);
+int GetMatAnimModKey(Mtl* mtl, plMaxNodeBase* node, const plString& segName, hsTArray<plKey>& keys);
diff --git a/Sources/Tools/MaxComponent/plResponderWait.cpp b/Sources/Tools/MaxComponent/plResponderWait.cpp
index 1848f344..b4cb0edc 100644
--- a/Sources/Tools/MaxComponent/plResponderWait.cpp
+++ b/Sources/Tools/MaxComponent/plResponderWait.cpp
@@ -140,12 +140,12 @@ int ResponderWait::GetWaitingOn(IParamBlock2* waitPB)
     return waitPB->GetInt(kWaitWho);
 }
 
-const char* ResponderWait::GetWaitPoint(IParamBlock2* waitPB)
+plString ResponderWait::GetWaitPoint(IParamBlock2* waitPB)
 {
     const char* point = waitPB->GetStr(kWaitPoint);
     if (point && *point == '\0')
-        return nil;
-    return point;
+        return plString::Null;
+    return plString::FromUtf8(point);
 }
 
 /////////////////////////////////////////////////////////////////////////////
diff --git a/Sources/Tools/MaxComponent/plResponderWait.h b/Sources/Tools/MaxComponent/plResponderWait.h
index 28bf797f..2af33065 100644
--- a/Sources/Tools/MaxComponent/plResponderWait.h
+++ b/Sources/Tools/MaxComponent/plResponderWait.h
@@ -46,6 +46,7 @@ class IParamBlock2;
 class plKey;
 class plMessage;
 class plResponderModifier;
+class plString;
 
 namespace ResponderWait
 {
@@ -62,5 +63,5 @@ namespace ResponderWait
     
     bool        GetWaitOnMe(IParamBlock2* waitPB);
     int         GetWaitingOn(IParamBlock2* waitPB);
-    const char* GetWaitPoint(IParamBlock2* waitPB);
+    plString    GetWaitPoint(IParamBlock2* waitPB);
 }
diff --git a/Sources/Tools/MaxComponent/plSoftVolumeComponent.cpp b/Sources/Tools/MaxComponent/plSoftVolumeComponent.cpp
index 72f5725f..c741db6b 100644
--- a/Sources/Tools/MaxComponent/plSoftVolumeComponent.cpp
+++ b/Sources/Tools/MaxComponent/plSoftVolumeComponent.cpp
@@ -255,7 +255,7 @@ plKey plSoftVolBaseComponent::ISetVolumeKey(plSoftVolume* vol)
             break;
     }
     hsAssert(i < NumTargets(), "We're not attached to anything?");
-    plKey key = hsgResMgr::ResMgr()->NewKey(GetINode()->GetName(), vol, GetTarget(i)->GetLocation());
+    plKey key = hsgResMgr::ResMgr()->NewKey(plString::FromUtf8(GetINode()->GetName()), vol, GetTarget(i)->GetLocation());
 
     return key;
 }
@@ -1299,7 +1299,7 @@ void plVisRegionComponent::ICheckVisRegion(const plLocation& loc)
             return;
 
         fVisReg = new plVisRegion;
-        plKey key = hsgResMgr::ResMgr()->NewKey(GetINode()->GetName(), fVisReg, loc);
+        plKey key = hsgResMgr::ResMgr()->NewKey(plString::FromUtf8(GetINode()->GetName()), fVisReg, loc);
 
 
         hsBool excludes = fCompPB->GetInt(kExcludes);
@@ -1465,7 +1465,7 @@ hsBool plRelevanceRegionComponent::Convert(plMaxNode *node, plErrorMsg *errMsg)
             return true;
 
         fRegion = new plRelevanceRegion;
-        plKey key = hsgResMgr::ResMgr()->NewKey(GetINode()->GetName(), fRegion, node->GetLocation());
+        plKey key = hsgResMgr::ResMgr()->NewKey(plString::FromUtf8(GetINode()->GetName()), fRegion, node->GetLocation());
 
         plGenRefMsg* refMsg = new plGenRefMsg(fRegion->GetKey(), plRefMsg::kOnCreate, 0, 0);
         hsgResMgr::ResMgr()->SendRef(softKey, refMsg, plRefFlags::kActiveRef);
@@ -1561,7 +1561,7 @@ plVisRegion* plEffVisSetComponent::GetVisRegion(plMaxNode* node)
     if( !fVisReg )
     {
         fVisReg = new plVisRegion;
-        plKey key = hsgResMgr::ResMgr()->NewKey(GetINode()->GetName(), fVisReg, node->GetLocation());
+        plKey key = hsgResMgr::ResMgr()->NewKey(plString::FromUtf8(GetINode()->GetName()), fVisReg, node->GetLocation());
 
         fVisReg->SetProperty(plVisRegion::kIsNot, false);
         fVisReg->SetProperty(plVisRegion::kReplaceNormal, fCompPB->GetInt(kHideNormal));
diff --git a/Sources/Tools/MaxComponent/plTypesComponents.cpp b/Sources/Tools/MaxComponent/plTypesComponents.cpp
index 4d986e23..e44a5615 100644
--- a/Sources/Tools/MaxComponent/plTypesComponents.cpp
+++ b/Sources/Tools/MaxComponent/plTypesComponents.cpp
@@ -538,10 +538,11 @@ protected:
         HWND hCombo = GetDlgItem(hWnd, ctrlID);
         ComboBox_ResetContent(hCombo);
 
-        while (const char* animName = anim.GetNextAnimName())
+        plString animName;
+        while (!(animName = anim.GetNextAnimName()).IsNull())
         {
-            int sel = ComboBox_AddString(hCombo, animName);
-            if (hsStrEQ(animName, savedName))
+            int sel = ComboBox_AddString(hCombo, animName.c_str());
+            if (animName.Compare(savedName) == 0)
                 ComboBox_SetCurSel(hCombo, sel);
         }
     }
@@ -714,7 +715,7 @@ plKey plGameMarkerComponent::IGetMtlAnimKey(int paramID, plMaxNode* node)
     Mtl* mtl = fCompPB->GetMtl(kMarkerMtl);
     plMaxNode* mtlNode  = (plMaxNode*)fCompPB->GetINode(kMarkerMtlNode);
     hsTArray<plKey> keys;
-    const char* anim = fCompPB->GetStr(paramID);
+    plString anim = plString::FromUtf8(fCompPB->GetStr(paramID));
     GetMatAnimModKey(mtl, mtlNode, anim, keys);
     hsAssert(keys.Count() == 1, "Wrong number of keys");
     return keys[0];
diff --git a/Sources/Tools/MaxComponent/plVolumeGadgetComponent.cpp b/Sources/Tools/MaxComponent/plVolumeGadgetComponent.cpp
index 5f0d0a34..c015e499 100644
--- a/Sources/Tools/MaxComponent/plVolumeGadgetComponent.cpp
+++ b/Sources/Tools/MaxComponent/plVolumeGadgetComponent.cpp
@@ -330,8 +330,7 @@ hsBool plVolumeGadgetComponent::PreConvert(plMaxNode *node, plErrorMsg *pErrMsg)
     if(fCompPB->GetInt(kVolumeGadgetEnter) || fCompPB->GetInt(kVolumeTriggerOnFacing))
     {   
         plLogicModifier *logic = new plLogicModifier;
-        char tmpName[256];
-        sprintf(tmpName, "%s_Enter", IGetUniqueName(node));
+        plString tmpName = plString::Format("%s_Enter", IGetUniqueName(node).c_str());
         plKey logicKey = hsgResMgr::ResMgr()->NewKey(tmpName, logic, node->GetLocation());
         hsgResMgr::ResMgr()->AddViaNotify(logicKey, new plObjRefMsg(obj->GetKey(), plRefMsg::kOnCreate, -1, plObjRefMsg::kModifier), plRefFlags::kActiveRef);
 
@@ -345,8 +344,7 @@ hsBool plVolumeGadgetComponent::PreConvert(plMaxNode *node, plErrorMsg *pErrMsg)
     if(fCompPB->GetInt(kVolumeGadgetExit))
     {   
         plLogicModifier *logic = new plLogicModifier;
-        char tmpName[256];
-        sprintf(tmpName, "%s_Exit", IGetUniqueName(node));
+        plString tmpName = plString::Format("%s_Exit", IGetUniqueName(node).c_str());
         plKey logicKey = hsgResMgr::ResMgr()->NewKey(tmpName, logic, node->GetLocation());
         hsgResMgr::ResMgr()->AddViaNotify(logicKey, new plObjRefMsg(obj->GetKey(), plRefMsg::kOnCreate, -1, plObjRefMsg::kModifier), plRefFlags::kActiveRef);
 
@@ -365,7 +363,6 @@ void plVolumeGadgetComponent::ICreateConditions(plMaxNode* node, plErrorMsg* err
 
     plLocation loc = node->GetLocation();
     plSceneObject *obj = node->GetSceneObject();
-    char tmpName[256];
 
     plKey logicKey;
     if (enter)
@@ -405,7 +402,7 @@ void plVolumeGadgetComponent::ICreateConditions(plMaxNode* node, plErrorMsg* err
         prefix = "Enter";
 
     // Register the detector
-    sprintf(tmpName, "%s_%s", IGetUniqueName(node), prefix);
+    plString tmpName = plString::Format("%s_%s", IGetUniqueName(node).c_str(), prefix);
     plKey detectorKey = hsgResMgr::ResMgr()->NewKey(tmpName, detector, loc);
     hsgResMgr::ResMgr()->AddViaNotify(detectorKey, new plObjRefMsg(obj->GetKey(), plRefMsg::kOnCreate, -1, plObjRefMsg::kModifier), plRefFlags::kActiveRef);
     plVolumeSensorConditionalObject* boxCond=nil;
@@ -417,7 +414,7 @@ void plVolumeGadgetComponent::ICreateConditions(plMaxNode* node, plErrorMsg* err
     {
         boxCond = new plVolumeSensorConditionalObjectNoArbitration;
     }
-    sprintf(tmpName, "%s_%s", IGetUniqueName(node), prefix);
+    tmpName = plString::Format("%s_%s", IGetUniqueName(node).c_str(), prefix);
     plKey boxKey = hsgResMgr::ResMgr()->NewKey(tmpName, boxCond, loc);
 
     if (enter)
diff --git a/Sources/Tools/MaxComponent/plWaterComponent.cpp b/Sources/Tools/MaxComponent/plWaterComponent.cpp
index a8138602..257d5654 100644
--- a/Sources/Tools/MaxComponent/plWaterComponent.cpp
+++ b/Sources/Tools/MaxComponent/plWaterComponent.cpp
@@ -568,7 +568,7 @@ hsBool plWaterComponent::IReadEnvObject(plMaxNode* node, plErrorMsg* pErrMsg, pl
         size = uint32_t(1 << i);
 
         env = new plDynamicEnvMap(size, size, 32);
-        hsgResMgr::ResMgr()->NewKey(ref->GetName(), env, node->GetLocation(), node->GetLoadMask());
+        hsgResMgr::ResMgr()->NewKey(plString::FromUtf8(ref->GetName()), env, node->GetLocation(), node->GetLoadMask());
 
         Point3 pos = ref->GetNodeTM(TimeValue(0)).GetTrans();
         env->SetPosition(hsPoint3(pos.x, pos.y, pos.z));
@@ -1290,7 +1290,7 @@ plRenderTarget* plEnvMapComponent::IGetMap()
             fMap = cam = new plDynamicCamMap(size, size, 32);
 
         // Need to assign the key before we call all the setup functions.
-        hsgResMgr::ResMgr()->NewKey(GetINode()->GetName(), fMap, firstTarg->GetLocation(), firstTarg->GetLoadMask());
+        hsgResMgr::ResMgr()->NewKey(plString::FromUtf8(GetINode()->GetName()), fMap, firstTarg->GetLocation(), firstTarg->GetLoadMask());
 
 
         if (fCompPB->GetInt((ParamID(kMapType))) == kMapCubic)
diff --git a/Sources/Tools/MaxConvert/hsControlConverter.cpp b/Sources/Tools/MaxConvert/hsControlConverter.cpp
index d9043c28..de4ee65e 100644
--- a/Sources/Tools/MaxConvert/hsControlConverter.cpp
+++ b/Sources/Tools/MaxConvert/hsControlConverter.cpp
@@ -2158,7 +2158,7 @@ void hsControlConverter::IExportAnimatedCameraFOV(plMaxNode* node, hsTArray <hsG
         pMsg->AddReceiver(pCamMod->GetKey());
         pMsg->SetSender(pAnim->GetModKey(node));
         pMsg->SetCmd(plAnimCmdMsg::kAddCallbacks);
-        pMsg->SetAnimName(ENTIRE_ANIMATION_NAME);
+        pMsg->SetAnimName(_TEMP_CONVERT_FROM_LITERAL(ENTIRE_ANIMATION_NAME));
         pMsg->fTime = kfArray[0][i].fFrame / MAX_FRAMES_PER_SEC;
         pMsg->AddCallback(pCall);
         hsRefCnt_SafeUnRef(pCall);
diff --git a/Sources/Tools/MaxConvert/hsConverterUtils.cpp b/Sources/Tools/MaxConvert/hsConverterUtils.cpp
index 54249978..1e32c052 100644
--- a/Sources/Tools/MaxConvert/hsConverterUtils.cpp
+++ b/Sources/Tools/MaxConvert/hsConverterUtils.cpp
@@ -346,7 +346,7 @@ INode* hsConverterUtils::FindINodeFromKeyedObject(hsKeyedObject* obj)
 {
     hsGuardBegin("hsConverterUtils::FindINodeFromKeyedObject");
 
-    INode* retVal = FindINodeFromMangledName(obj->GetKey()->GetName());
+    INode* retVal = FindINodeFromMangledName(_TEMP_CONVERT_TO_CONST_CHAR(obj->GetKey()->GetName()));
     if( retVal )
         return (retVal);
 
diff --git a/Sources/Tools/MaxConvert/hsMaterialConverter.cpp b/Sources/Tools/MaxConvert/hsMaterialConverter.cpp
index efa3f132..dd06c718 100644
--- a/Sources/Tools/MaxConvert/hsMaterialConverter.cpp
+++ b/Sources/Tools/MaxConvert/hsMaterialConverter.cpp
@@ -308,7 +308,7 @@ void AttachLinkMtlAnims(plMaxNode *node, hsGMaterial *mat)
         animLayer = new plLayerLinkAnimation;
         animLayer->SetLinkKey(node->GetAvatarSO()->GetKey());
         //animLayer->fLeavingAge = leaving[x];
-        TSTR fullAnimName = TSTR(oldLayer->GetKeyName()) + TSTR("_") + TSTR(animName) + TSTR("_") + TSTR(suff);
+        plString fullAnimName = plString::Format("%s_%s_%s", oldLayer->GetKeyName().c_str(), animName, suff);
         hsgResMgr::ResMgr()->NewKey(fullAnimName, animLayer, node->GetLocation());
         animLayer->SetOpacityCtl(opaCtl);
         animLayer->GetTimeConvert().SetBegin(times[0]);
@@ -758,11 +758,11 @@ hsMaterialConverter::CreateMaterialArray(Mtl *maxMaterial, plMaxNode *node, uint
 
     hsBool enviro = fConverterUtils.IsEnvironHolder(node);
     
-    TSTR name;
+    plString name;
     if (maxMaterial)
-        name = maxMaterial->GetName();
+        name = plString::FromUtf8(maxMaterial->GetName());
     else
-        name = "nil";
+        name = _TEMP_CONVERT_FROM_LITERAL("nil");
     
     /// Get the material
     hsBool isMultiMat = IsMultiMat( maxMaterial );
@@ -905,8 +905,7 @@ hsGMaterial* hsMaterialConverter::NonAlphaHackPrint(plMaxNode* node, Texmap* bas
     if( !(baseTex && node) )
         return nil;
 
-    char name[256];
-    sprintf(name, "%s_%s_%d", node->GetName(), baseTex->GetName(), 0);
+    plString name = plString::Format("%s_%s_%d", node->GetName(), baseTex->GetName(), 0);
 
     // Search done materials for it
 
@@ -948,8 +947,7 @@ hsGMaterial* hsMaterialConverter::AlphaHackPrint(plMaxNode* node, Texmap* baseTe
     if( !(baseTex && node) )
         return nil;
 
-    char name[256];
-    sprintf(name, "%s_%s_%d_AH", node->GetName(), baseTex->GetName(), 0);
+    plString name = plString::Format("%s_%s_%d_AH", node->GetName(), baseTex->GetName(), 0);
 
     // Search done materials for it
 
@@ -998,8 +996,7 @@ hsGMaterial* hsMaterialConverter::NonAlphaHackVersion(plMaxNode* node, Mtl* mtl,
         return nil;
     }
 
-    char name[256];
-    sprintf(name, "%s_%s_%d", node->GetName(), mtl->GetName(), subIndex);
+    plString name = plString::Format("%s_%s_%d", node->GetName(), mtl->GetName(), subIndex);
 
     return ICreateMaterial(mtl, node, name, subIndex, 1, false);
 }
@@ -1014,8 +1011,7 @@ hsGMaterial* hsMaterialConverter::AlphaHackVersion(plMaxNode* node, Mtl* mtl, in
         return nil;
     }
 
-    char name[256];
-    sprintf(name, "%s_%s_%d_AH", node->GetName(), mtl->GetName(), subIndex);
+    plString name = plString::Format("%s_%s_%d_AH", node->GetName(), mtl->GetName(), subIndex);
 
     return ICreateMaterial(mtl, node, name, subIndex, 1, true);
 }
@@ -1024,7 +1020,7 @@ hsGMaterial* hsMaterialConverter::AlphaHackVersion(plMaxNode* node, Mtl* mtl, in
 // Big kahuna converter function
 // (Though meshConverter should be calling CreateMaterialArray instead)
 //
-hsGMaterial *hsMaterialConverter::ICreateMaterial(Mtl *mtl, plMaxNode *node, const char *name, int subIndex, 
+hsGMaterial *hsMaterialConverter::ICreateMaterial(Mtl *mtl, plMaxNode *node, const plString &name, int subIndex,
                                                   int numUVChannels, hsBool makeAlphaLayer)
 {
     hsGuardBegin("hsMaterialConverter::ICreateMaterial");
@@ -1133,7 +1129,7 @@ hsGMaterial *hsMaterialConverter::ICreateMaterial(Mtl *mtl, plMaxNode *node, con
 //
 // Handle materials for normal non-light, non-particle nodes.
 //
-hsGMaterial *hsMaterialConverter::IProcessMaterial(Mtl *mtl, plMaxNode *node, const char *name, 
+hsGMaterial *hsMaterialConverter::IProcessMaterial(Mtl *mtl, plMaxNode *node, const plString &name,
                                                    int UVChan, int subMtlFlags /* = 0 */)
 {
     hsGuardBegin("hsMaterialConverter::IProcessMaterial");
@@ -1187,11 +1183,11 @@ hsGMaterial *hsMaterialConverter::IProcessMaterial(Mtl *mtl, plMaxNode *node, co
             
             plLayer* hLay = new plLayer;
             hLay->InitToDefault();
-            hsgResMgr::ResMgr()->NewKey(TSTR(name) + TSTR("_DefLay"), hLay, nodeLoc);
+            hsgResMgr::ResMgr()->NewKey(name + _TEMP_CONVERT_FROM_LITERAL("_DefLay"), hLay, nodeLoc);
             IAddLayerToMaterial(hMat, hLay);
         }
 
-        if( node->UserPropExists("WetMe") && !strstr(hMat->GetKey()->GetName(), "Wet(*)") )
+        if( node->UserPropExists("WetMe") && (hMat->GetKey()->GetName().Find("Wet(*)") < 0) )
             IAppendWetLayer(node, hMat);
 //      hsgResMgr::ResMgr()->NewKey(name, hMat,nodeLoc);
     }
@@ -1337,11 +1333,11 @@ hsGMaterial *hsMaterialConverter::IAddDefaultMaterial(plMaxNode *node)
     plLocation loc = node->GetLocation();
 
     hsGMaterial *hMat = new hsGMaterial;
-    hsgResMgr::ResMgr()->NewKey(TSTR(node->GetName()) + TSTR("_DefMat"), hMat, loc);
+    hsgResMgr::ResMgr()->NewKey(plString::Format("%s_DefMat", node->GetName()), hMat, loc);
     
     plLayer *layer = new plLayer;
     layer->InitToDefault();
-    hsgResMgr::ResMgr()->NewKey(TSTR(hMat->GetKeyName()) + TSTR("_DefLay"), layer, loc);
+    hsgResMgr::ResMgr()->NewKey(hMat->GetKeyName() + _TEMP_CONVERT_FROM_LITERAL("_DefLay"), layer, loc);
 
     DWORD color = node->GetWireColor();
     float r = float(GetRValue(color)) / 255.f;
@@ -1357,7 +1353,8 @@ hsGMaterial *hsMaterialConverter::IAddDefaultMaterial(plMaxNode *node)
 
 plMipmap *hsMaterialConverter::IGetUVTransTexture(plMaxNode *node, hsBool useU /* = true */)
 {
-    char* texName = (useU ? "ALPHA_BLEND_FILTER_U2ALPHA_TRANS_64x4" : "ALPHA_BLEND_FILTER_V2ALPHA_TRANS_4x64" );
+    plString texName = (useU ? _TEMP_CONVERT_FROM_LITERAL("ALPHA_BLEND_FILTER_U2ALPHA_TRANS_64x4")
+                             : _TEMP_CONVERT_FROM_LITERAL("ALPHA_BLEND_FILTER_V2ALPHA_TRANS_4x64") );
 
     int w = (useU ? 64 : 4);
     int h = (useU ? 4 : 64);
@@ -1415,7 +1412,7 @@ void hsMaterialConverter::IInsertSingleBlendLayer(plMipmap *texture, hsGMaterial
     
     plLayer* layer = new plLayer;
     layer->InitToDefault();
-    hsgResMgr::ResMgr()->NewKey(TSTR(underLay->GetKeyName()) + TSTR("_AlphaBlend"), layer, node->GetLocation());
+    hsgResMgr::ResMgr()->NewKey(underLay->GetKeyName() + _TEMP_CONVERT_FROM_LITERAL("_AlphaBlend"), layer, node->GetLocation());
     hsgResMgr::ResMgr()->AddViaNotify(texture->GetKey(), new plLayRefMsg(layer->GetKey(), plRefMsg::kOnCreate, 0, plLayRefMsg::kTexture), plRefFlags::kActiveRef);
     layer->SetAmbientColor(hsColorRGBA().Set(1.f, 1.f, 1.f, 1.f));
 //  layer->SetZFlags(hsGMatState::kZNoZWrite | hsGMatState::kZIncLayer);
@@ -1570,16 +1567,14 @@ void hsMaterialConverter::IInsertCompBlendingLayers(Mtl *mtl, plMaxNode *node, h
     return;
 }
 
-hsGMaterial *hsMaterialConverter::IProcessCompositeMtl(Mtl *mtl, plMaxNode *node, const char *name, int UVChan, int subMtlFlags)
+hsGMaterial *hsMaterialConverter::IProcessCompositeMtl(Mtl *mtl, plMaxNode *node, const plString &name, int UVChan, int subMtlFlags)
 {
     if (!mtl || mtl->ClassID() != COMP_MTL_CLASS_ID)
         return nil;
     uint32_t *layerCounts = new uint32_t[mtl->NumSubMtls()];
     IParamBlock2 *pb = mtl->GetParamBlockByID(plCompositeMtl::kBlkPasses);
-    char suff[10];
-    sprintf(suff, "_%d", subMtlFlags);
     hsGMaterial *mat = new hsGMaterial;
-    hsgResMgr::ResMgr()->NewKey(TSTR(name) + TSTR(suff), mat, node->GetLocation());
+    hsgResMgr::ResMgr()->NewKey(plString::Format("%s_%d", name.c_str(), subMtlFlags), mat, node->GetLocation());
     
     int multiIndex = IFindSubIndex(node, mtl);
     hsBool needAlphaHack = node->AlphaHackLayersNeeded(multiIndex) > 0;
@@ -1593,8 +1588,7 @@ hsGMaterial *hsMaterialConverter::IProcessCompositeMtl(Mtl *mtl, plMaxNode *node
         hsBool usingSubMtl = (i == 0 || pb->GetInt(kCompOn, 0, i - 1));
         if ((bitMask & subMtlFlags) != 0 && usingSubMtl)
         {
-            char pref[256];
-            sprintf(pref, "%s_%d", mat->GetKey()->GetName(), i);
+            plString pref = plString::Format("%s_%d", mat->GetKey()->GetName().c_str(), i);
 
             subMtl = mtl->GetSubMtl(i);
             if (subMtl != nil && subMtl->ClassID() == PASS_MTL_CLASS_ID)
@@ -1673,7 +1667,7 @@ hsGMaterial *hsMaterialConverter::IProcessCompositeMtl(Mtl *mtl, plMaxNode *node
     return mat;
 }
 
-hsGMaterial *hsMaterialConverter::IProcessMultipassMtl(Mtl *mtl, plMaxNode *node, const char *name, int UVChan)
+hsGMaterial *hsMaterialConverter::IProcessMultipassMtl(Mtl *mtl, plMaxNode *node, const plString &name, int UVChan)
 {
     if (!mtl || mtl->ClassID() != MULTIMTL_CLASS_ID)
         return nil;
@@ -1705,7 +1699,7 @@ hsGMaterial *hsMaterialConverter::IProcessMultipassMtl(Mtl *mtl, plMaxNode *node
     return mat;
 }
 
-hsGMaterial *hsMaterialConverter::IProcessParticleMtl(Mtl *mtl, plMaxNode *node, const char *name)
+hsGMaterial *hsMaterialConverter::IProcessParticleMtl(Mtl *mtl, plMaxNode *node, const plString &name)
 {
     hsGuardBegin("hsMaterialConverter::IProcessParticleMaterial");
 
@@ -1713,7 +1707,7 @@ hsGMaterial *hsMaterialConverter::IProcessParticleMtl(Mtl *mtl, plMaxNode *node,
     char* dbgNodeName = node->GetName();
 
     hsGMaterial *mat = new hsGMaterial;
-    hsgResMgr::ResMgr()->NewKey(name, mat,nodeLoc);
+    hsgResMgr::ResMgr()->NewKey(name, mat, nodeLoc);
 
     
     if(!mtl)
@@ -1732,10 +1726,10 @@ hsGMaterial *hsMaterialConverter::IProcessParticleMtl(Mtl *mtl, plMaxNode *node,
     Color dif  = basicPB->GetColor(plParticleMtl::kColor);
     float opac = float(basicPB->GetInt(plParticleMtl::kOpacity)) / 100.0f;
 
-    fErrorMsg->Set(opac  < 0.0 || opac  > 1.0, dbgNodeName, "Bad opacity on mat %s", name).CheckAndAsk();
-    fErrorMsg->Set(dif.r < 0.0 || dif.r > 1.0, dbgNodeName, "Bad color (r) on mat %s", name).CheckAndAsk();
-    fErrorMsg->Set(dif.g < 0.0 || dif.g > 1.0, dbgNodeName, "Bad color (g) on mat %s", name).CheckAndAsk();
-    fErrorMsg->Set(dif.b < 0.0 || dif.b > 1.0, dbgNodeName, "Bad color (b) on mat %s", name).CheckAndAsk();
+    fErrorMsg->Set(opac  < 0.0 || opac  > 1.0, dbgNodeName, "Bad opacity on mat %s", name.c_str()).CheckAndAsk();
+    fErrorMsg->Set(dif.r < 0.0 || dif.r > 1.0, dbgNodeName, "Bad color (r) on mat %s", name.c_str()).CheckAndAsk();
+    fErrorMsg->Set(dif.g < 0.0 || dif.g > 1.0, dbgNodeName, "Bad color (g) on mat %s", name.c_str()).CheckAndAsk();
+    fErrorMsg->Set(dif.b < 0.0 || dif.b > 1.0, dbgNodeName, "Bad color (b) on mat %s", name.c_str()).CheckAndAsk();
 
     Color col = dif;
 
@@ -1817,7 +1811,7 @@ hsGMaterial *hsMaterialConverter::IProcessParticleMtl(Mtl *mtl, plMaxNode *node,
 }
 
 plLayerAnimation *IConvertNoteTrackAnims(plLayerAnimation *animLayer, SegmentMap *segMap, plMaxNode *node, 
-                                         const char *name)
+                                         const plString &name)
 {
     plLayerAnimation *prev = animLayer;
     
@@ -1827,7 +1821,7 @@ plLayerAnimation *IConvertNoteTrackAnims(plLayerAnimation *animLayer, SegmentMap
         if (spec->fType == SegmentSpec::kAnim)
         {
             plLayerAnimation *noteAnim = new plLayerAnimation;
-            TSTR animName = TSTR(name) + TSTR("_anim_") + TSTR(spec->fName);
+            plString animName = plString::Format("%s_anim_%s", name.c_str(), spec->fName);
             hsgResMgr::ResMgr()->NewKey(animName, noteAnim, node->GetLocation());
 
             if (animLayer->GetPreshadeColorCtl())
@@ -1854,8 +1848,8 @@ plLayerAnimation *IConvertNoteTrackAnims(plLayerAnimation *animLayer, SegmentMap
 
 void ISetDefaultAnim(plPassMtlBase* mtl, plAnimTimeConvert& tc, SegmentMap* segMap)
 {
-    const char *animName = mtl->GetAnimName();
-    if( segMap && animName && (segMap->find(animName) != segMap->end()) )
+    plString animName = _TEMP_CONVERT_FROM_LITERAL( mtl->GetAnimName() );
+    if( segMap && !animName.IsNull() && (segMap->find(animName) != segMap->end()) )
     {
         SegmentSpec *spec = (*segMap)[animName];
         tc.SetBegin(spec->fStart);
@@ -1874,8 +1868,8 @@ void ISetDefaultAnim(plPassMtlBase* mtl, plAnimTimeConvert& tc, SegmentMap* segM
         float loopEnd = tc.GetEnd();
 
         // If there's a loop, use it
-        const char *loopName = mtl->GetAnimLoopName();
-        if (loopName && *loopName && segMap)
+        plString loopName = plString::FromUtf8(mtl->GetAnimLoopName());
+        if (!loopName.IsEmpty() && segMap)
             GetSegMapAnimTime(loopName, segMap, SegmentSpec::kLoop, loopStart, loopEnd);
 
         tc.SetLoopPoints(loopStart, loopEnd);
@@ -1960,8 +1954,8 @@ static plAnimStealthNode* IGetEntireAnimation(plPassMtlBase* mtl)
     {
         plAnimStealthNode* stealth = mtl->GetStealth(i);
 
-        const char *segName = stealth->GetSegmentName();
-        if( !segName || !*segName || !stricmp(segName, ENTIRE_ANIMATION_NAME) )
+        plString segName = stealth->GetSegmentName();
+        if( segName.IsEmpty() || !segName.Compare(ENTIRE_ANIMATION_NAME, plString::kCaseInsensitive) )
             return stealth;
 
     }
@@ -1998,20 +1992,20 @@ static plLayerInterface* IProcessLayerMovie(plPassMtlBase* mtl, plLayerTex* layT
         sprintf(movieName, "avi/%s", plFileUtils::GetFileName(fileName));
 
         plLayerMovie* movieLayer = nil;
-        const char* moviePostfix = nil;
+        plString moviePostfix;
 
         if (isBink)
         {
             movieLayer = new plLayerBink;
-            moviePostfix = "_bink";
+            moviePostfix = _TEMP_CONVERT_FROM_LITERAL("_bink");
         }
         else if (isAvi)
         {
             movieLayer = new plLayerAVI;
-            moviePostfix = "_avi";
+            moviePostfix = _TEMP_CONVERT_FROM_LITERAL("_avi");
         }
 
-        TSTR movieKeyName = TSTR(layerIFace->GetKeyName()) + moviePostfix;
+        plString movieKeyName = layerIFace->GetKeyName() + moviePostfix;
         hsgResMgr::ResMgr()->NewKey(movieKeyName, movieLayer, node->GetLocation());
 
         movieLayer->SetMovieName(movieName);
@@ -2040,7 +2034,7 @@ static plLayerInterface* IProcessLayerMovie(plPassMtlBase* mtl, plLayerTex* layT
 }
 
 plLayerInterface* IProcessLayerAnimation(plPassMtlBase* mtl, plLayerTex* layTex, plMaxNode* node, 
-                                         const char *name, plLayerInterface* layerIFace)
+                                         const plString &name, plLayerInterface* layerIFace)
 {
     hsControlConverter& cc = hsControlConverter::Instance();
     
@@ -2055,7 +2049,7 @@ plLayerInterface* IProcessLayerAnimation(plPassMtlBase* mtl, plLayerTex* layTex,
     if( mtl->GetUseGlobal() )
     {
         plLayerSDLAnimation *SDLLayer = new plLayerSDLAnimation;
-        TSTR animName = TSTR(name) + TSTR("_anim_") + TSTR(mtl->GetGlobalVarName());
+        plString animName = plString::Format("%s_anim_%s", name.c_str(), mtl->GetGlobalVarName());
         hsgResMgr::ResMgr()->NewKey(animName, SDLLayer, node->GetLocation());
 
         SDLLayer->SetVarName((char*)mtl->GetGlobalVarName());
@@ -2078,10 +2072,11 @@ plLayerInterface* IProcessLayerAnimation(plPassMtlBase* mtl, plLayerTex* layTex,
         plLayerAnimation *noteAnim = new plLayerAnimation;
         node->CheckSynchOptions(noteAnim);
 
-        const char *segName = stealth->GetSegmentName();
-        bool isDefault = ( segName == nil || strcmp( segName, ENTIRE_ANIMATION_NAME ) == 0 ) ? true : false;
+        plString segName = stealth->GetSegmentName();
+        bool isDefault = ( segName.IsNull() || segName.Compare( ENTIRE_ANIMATION_NAME ) == 0 ) ? true : false;
 
-        TSTR animName = TSTR( name ) + ( ( isDefault ) ? TSTR( "_LayerAnim_" ) : ( TSTR("_LayerAnim") + TSTR( segName ) ) );
+        plString animName = name + ( ( isDefault ) ? _TEMP_CONVERT_FROM_LITERAL( "_LayerAnim_" )
+                                 : ( _TEMP_CONVERT_FROM_LITERAL("_LayerAnim") + segName ) );
         hsgResMgr::ResMgr()->NewKey( animName, noteAnim, node->GetLocation() );
 
         StdUVGen *uvGen = (StdUVGen *)layTex->GetTheUVGen();
@@ -2093,7 +2088,7 @@ plLayerInterface* IProcessLayerAnimation(plPassMtlBase* mtl, plLayerTex* layTex,
         
         // Set segment name if we're not the default
         if( !isDefault )
-            noteAnim->SetSegmentID( (char *)segName );
+            noteAnim->SetSegmentID( segName );
 
         // And attach!
         noteAnim->AttachViaNotify( layerIFace );
@@ -2106,7 +2101,7 @@ plLayerInterface* IProcessLayerAnimation(plPassMtlBase* mtl, plLayerTex* layTex,
 
 }
 
-plLayerInterface* IProcessAnimation(plPassMtlBase *mtl, plMaxNode *node, const char *name,
+plLayerInterface* IProcessAnimation(plPassMtlBase *mtl, plMaxNode *node, const plString &name,
                                     plLayerInterface *layerIFace)
 {
     hsControlConverter& cc = hsControlConverter::Instance();
@@ -2155,7 +2150,7 @@ plLayerInterface* IProcessAnimation(plPassMtlBase *mtl, plMaxNode *node, const c
         //  return layerIFace;
         
         plLayerSDLAnimation *SDLLayer = new plLayerSDLAnimation;
-        TSTR animName = TSTR(name) + TSTR("_anim_") + TSTR(mtl->GetGlobalVarName());
+        plString animName = plString::Format("%s_anim_%s", name.c_str(), mtl->GetGlobalVarName());
         hsgResMgr::ResMgr()->NewKey(animName, SDLLayer, node->GetLocation());
 
         SDLLayer->SetVarName((char*)mtl->GetGlobalVarName());
@@ -2193,10 +2188,11 @@ plLayerInterface* IProcessAnimation(plPassMtlBase *mtl, plMaxNode *node, const c
         plLayerAnimation *noteAnim = new plLayerAnimation;
         node->CheckSynchOptions(noteAnim);
 
-        const char *segName = stealth->GetSegmentName();
-        bool isDefault = ( segName == nil || strcmp( segName, ENTIRE_ANIMATION_NAME ) == 0 ) ? true : false;
+        plString segName = stealth->GetSegmentName();
+        bool isDefault = ( segName.IsNull() || segName.Compare( ENTIRE_ANIMATION_NAME ) == 0 ) ? true : false;
 
-        TSTR animName = TSTR( name ) + ( ( isDefault ) ? TSTR( "_anim" ) : ( TSTR("_anim_") + TSTR( segName ) ) );
+        plString animName = name + ( ( isDefault ) ? _TEMP_CONVERT_FROM_LITERAL( "_anim" )
+                                 : ( _TEMP_CONVERT_FROM_LITERAL("_anim_") + segName ) );
         hsgResMgr::ResMgr()->NewKey( animName, noteAnim, node->GetLocation() );
 
         plController *noteColCtl = cc.MakeColorController( maxColCtl, node );
@@ -2221,7 +2217,7 @@ plLayerInterface* IProcessAnimation(plPassMtlBase *mtl, plMaxNode *node, const c
         
         // Set segment name if we're not the default
         if( !isDefault )
-            noteAnim->SetSegmentID( (char *)segName );
+            noteAnim->SetSegmentID( segName );
 
         // And attach!
         noteAnim->AttachViaNotify( layerIFace );
@@ -2274,7 +2270,7 @@ int hsMaterialConverter::IFindSubIndex(plMaxNode* node, Mtl* mtl)
 //
 
 // Now handles both plPassMtl and plDecalMtl which derive from plPassMtlBase
-hsBool hsMaterialConverter::IProcessPlasmaMaterial(Mtl *mtl, plMaxNode *node, hsGMaterial *mat, const char* name)
+hsBool hsMaterialConverter::IProcessPlasmaMaterial(Mtl *mtl, plMaxNode *node, hsGMaterial *mat, const plString& name)
 {
     hsGuardBegin("hsMaterialConverter::IProcessPlasmaMaterial");
 
@@ -2307,13 +2303,13 @@ hsBool hsMaterialConverter::IProcessPlasmaMaterial(Mtl *mtl, plMaxNode *node, hs
 
     float opac = float(passBase->GetOpacity()) / 100.0f;
 
-    fErrorMsg->Set(opac  < 0.0 || opac  > 1.0, dbgNodeName, "Bad opacity on mat %s", name).CheckAndAsk();
-    fErrorMsg->Set(dif.r < 0.0 || dif.r > 1.0, dbgNodeName, "Bad color (r) on mat %s", name).CheckAndAsk();
-    fErrorMsg->Set(dif.g < 0.0 || dif.g > 1.0, dbgNodeName, "Bad color (g) on mat %s", name).CheckAndAsk();
-    fErrorMsg->Set(dif.b < 0.0 || dif.b > 1.0, dbgNodeName, "Bad color (b) on mat %s", name).CheckAndAsk();
-    fErrorMsg->Set(runDif.r < 0.0 || runDif.r > 1.0, dbgNodeName, "Bad runtime color (r) on mat %s", name).CheckAndAsk();
-    fErrorMsg->Set(runDif.g < 0.0 || runDif.g > 1.0, dbgNodeName, "Bad runtime color (g) on mat %s", name).CheckAndAsk();
-    fErrorMsg->Set(runDif.b < 0.0 || runDif.b > 1.0, dbgNodeName, "Bad runtime color (b) on mat %s", name).CheckAndAsk();
+    fErrorMsg->Set(opac  < 0.0 || opac  > 1.0, dbgNodeName, "Bad opacity on mat %s", name.c_str()).CheckAndAsk();
+    fErrorMsg->Set(dif.r < 0.0 || dif.r > 1.0, dbgNodeName, "Bad color (r) on mat %s", name.c_str()).CheckAndAsk();
+    fErrorMsg->Set(dif.g < 0.0 || dif.g > 1.0, dbgNodeName, "Bad color (g) on mat %s", name.c_str()).CheckAndAsk();
+    fErrorMsg->Set(dif.b < 0.0 || dif.b > 1.0, dbgNodeName, "Bad color (b) on mat %s", name.c_str()).CheckAndAsk();
+    fErrorMsg->Set(runDif.r < 0.0 || runDif.r > 1.0, dbgNodeName, "Bad runtime color (r) on mat %s", name.c_str()).CheckAndAsk();
+    fErrorMsg->Set(runDif.g < 0.0 || runDif.g > 1.0, dbgNodeName, "Bad runtime color (g) on mat %s", name.c_str()).CheckAndAsk();
+    fErrorMsg->Set(runDif.b < 0.0 || runDif.b > 1.0, dbgNodeName, "Bad runtime color (b) on mat %s", name.c_str()).CheckAndAsk();
 
 //  Color col = dif - amb;
     Color col = dif;
@@ -2778,9 +2774,8 @@ hsGMaterial *hsMaterialConverter::IWrapTextureInMaterial(Texmap *texMap, plMaxNo
     texMap->GetClassName(className);
 
     // We want to keep it.  Handle appropriately.
-    BitmapTex *bitmapTex = (BitmapTex *)texMap;        
-    char txtFileName[256];
-    strcpy(txtFileName, bitmapTex->GetMapName());
+    BitmapTex *bitmapTex = (BitmapTex *)texMap;
+    plString txtFileName = plString::FromUtf8( bitmapTex->GetMapName() );
 
 //  hsRegistryKey* key = hsgResMgr::ResMgr()->FindKey(txtFileName, hsGMaterial::Index());
     plKey key = node->FindPageKey( hsGMaterial::Index(), txtFileName );
@@ -3090,8 +3085,7 @@ void hsMaterialConverter::IAppendFunkyLayer(plMaxNode* node, Texmap* texMap, hsG
 
     plBitmap* funkRamp = IGetFunkyRamp(node, funkyType);
 
-    char name[512];
-    sprintf(name, "%s_funkRamp", prevLay->GetKey()->GetName());
+    plString name = plString::Format("%s_funkRamp", prevLay->GetKey()->GetName().c_str());
 
     plLayer* layer = new plLayer;
     layer->InitToDefault();
@@ -3134,7 +3128,7 @@ void hsMaterialConverter::IAppendFunkyLayer(plMaxNode* node, Texmap* texMap, hsG
 
 plBitmap* hsMaterialConverter::IGetFunkyRamp(plMaxNode* node, uint32_t funkyType)
 {
-    const char* funkName = funkyType & kFunkyAdd ? "FunkyRampAdd" : "FunkyRampMult";
+    plString funkName = funkyType & kFunkyAdd ? _TEMP_CONVERT_FROM_LITERAL("FunkyRampAdd") : _TEMP_CONVERT_FROM_LITERAL("FunkyRampMult");
 
     const int kLUTWidth = 16;
     const int kLUTHeight = 16;
@@ -3230,8 +3224,7 @@ void hsMaterialConverter::IAppendWetLayer(plMaxNode* node, hsGMaterial* mat)
     uvwXfm.fMap[1][2] = -1.f / (tr - op);
     uvwXfm.fMap[1][3] = uvwXfm.fMap[1][2] * -tr;
 
-    char name[512];
-    sprintf(name, "%s_funkRamp", prevLay->GetKey()->GetName());
+    plString name = plString::Format("%s_funkRamp", prevLay->GetKey()->GetName().c_str());
 
     plLayer* layer = nil;
     plKey key = node->FindPageKey( plLayer::Index(), name );
@@ -3517,7 +3510,7 @@ BitmapTex* hsMaterialConverter::GetBumpLayer(plMaxNode* node, Mtl* mtl)
 
 plMipmap *hsMaterialConverter::IGetBumpLutTexture(plMaxNode *node)
 {
-    const char* texName = "BumpLutTexture";
+    const plString texName = _TEMP_CONVERT_FROM_LITERAL("BumpLutTexture");
 
 //#define FUNKYBUMP
 #ifndef FUNKYBUMP
@@ -3697,19 +3690,19 @@ plMipmap *hsMaterialConverter::IGetBumpLutTexture(plMaxNode *node)
     return texture;
 }
 
-plLayer* hsMaterialConverter::IMakeBumpLayer(plMaxNode* node, const char* nameBase, hsGMaterial* mat, uint32_t miscFlag)
+plLayer* hsMaterialConverter::IMakeBumpLayer(plMaxNode* node, const plString& nameBase, hsGMaterial* mat, uint32_t miscFlag)
 {
-    char name[256];
+    plString name;
     switch( miscFlag & hsGMatState::kMiscBumpChans )
     {
     case hsGMatState::kMiscBumpDu:
-        sprintf(name, "%s_DU_BumpLut", nameBase);
+        name = plString::Format("%s_DU_BumpLut", nameBase.c_str());
         break;
     case hsGMatState::kMiscBumpDv:
-        sprintf(name, "%s_DV_BumpLut", nameBase);
+        name = plString::Format("%s_DV_BumpLut", nameBase.c_str());
         break;
     case hsGMatState::kMiscBumpDw:
-        sprintf(name, "%s_DW_BumpLut", nameBase);
+        name = plString::Format("%s_DW_BumpLut", nameBase.c_str());
         break;
     default:
         hsAssert(false, "Bogus flag input to MakeBumpLayer");
@@ -3787,7 +3780,7 @@ void hsMaterialConverter::IInsertBumpLayers(plMaxNode* node, hsGMaterial* mat, i
                         (bumpLay->GetBlendFlags() & ~hsGMatState::kBlendMask)
                         | hsGMatState::kBlendDot3);
 
-    const char* name = mat->GetLayer(bumpLayerIdx)->GetKey()->GetName();
+    plString name = mat->GetLayer(bumpLayerIdx)->GetKey()->GetName();
 
     plLayer* layerDu = IMakeBumpLayer(node, name, mat, hsGMatState::kMiscBumpDu);
     plLayer* layerDv = IMakeBumpLayer(node, name, mat, hsGMatState::kMiscBumpDv);
@@ -4532,7 +4525,7 @@ void hsMaterialConverter::CollectConvertedMaterials(Mtl *mtl, hsTArray<hsGMateri
 
 plClothingItem *hsMaterialConverter::GenerateClothingItem(plClothingMtl *mtl, const plLocation &loc)
 {
-    char clothKeyName[256];
+    plString clothKeyName;
     plClothingItem *cloth = new plClothingItem();
     cloth->SetName(mtl->GetName());
     cloth->fSortOrder = (mtl->GetDefault() ? 0 : 1);
@@ -4550,7 +4543,7 @@ plClothingItem *hsMaterialConverter::GenerateClothingItem(plClothingMtl *mtl, co
     cloth->fDefaultTint2[1] = tint2.g * 255;
     cloth->fDefaultTint2[2] = tint2.b * 255;
     
-    sprintf(clothKeyName, "CItm_%s", cloth->fName);
+    clothKeyName = plString::Format("CItm_%s", cloth->fName);
     hsgResMgr::ResMgr()->NewKey(clothKeyName, cloth, loc);
     
     plNodeRefMsg* nodeRefMsg = new plNodeRefMsg(plKeyFinder::Instance().FindSceneNodeKey(loc), 
@@ -4629,7 +4622,7 @@ static int ICompareBaseLayerTexture(const hsMaterialConverter::DoneMaterialData*
     if( !oneTex && twoTex )
         return -1;
 
-    return _stricmp(oneTex->GetKey()->GetName(), twoTex->GetKey()->GetName());
+    return oneTex->GetKey()->GetName().Compare(twoTex->GetKey()->GetName(), plString::kCaseInsensitive);
 }
 
 static int IIsAnimatedLayer(const plLayerInterface* lay)
@@ -4686,7 +4679,7 @@ static int ICompareDoneLayers(const plLayerInterface* one, const plLayerInterfac
 
     if( one->GetTexture() && two->GetTexture() )
     {
-        retVal = _stricmp(one->GetTexture()->GetKey()->GetName(), two->GetTexture()->GetKey()->GetName());
+        retVal = one->GetTexture()->GetKey()->GetName().Compare(two->GetTexture()->GetKey()->GetName(), plString::kCaseInsensitive);
         if( retVal < 0 )
             return -1;
         else if( retVal > 0 )
@@ -4957,8 +4950,8 @@ void hsMaterialConverter::IPrintDoneMat(hsStream* stream, const char* prefix, Do
             layer->GetLODBias());
         stream->WriteString(buff);
 
-        sprintf(buff, "\t\t\tTexture %s\n", layer->GetTexture() && layer->GetTexture()->GetKey() && layer->GetTexture()->GetKey()->GetName()
-            ? layer->GetTexture()->GetKey()->GetName()
+        sprintf(buff, "\t\t\tTexture %s\n", layer->GetTexture() && layer->GetTexture()->GetKey()
+            ? layer->GetTexture()->GetKey()->GetName().s_str("None")
             : "None");
         stream->WriteString(buff);
 
@@ -5139,9 +5132,8 @@ hsMaterialConverter::DoneMaterialData* hsMaterialConverter::IFindDoneMaterial(Do
 
 plMipmap *hsMaterialConverter::GetStaticColorTexture(Color c, plLocation &loc)
 {
-    char texName[256];
     uint32_t colorHex = MakeUInt32Color(c.r, c.g, c.b, 1.f);
-    sprintf(texName, "StaticColorTex_4x4_%X", colorHex);
+    plString texName = plString::Format("StaticColorTex_4x4_%X", colorHex);
 
     int w = 4;
     int h = 4;
diff --git a/Sources/Tools/MaxConvert/hsMaterialConverter.h b/Sources/Tools/MaxConvert/hsMaterialConverter.h
index 492d3ff5..a2dbba1c 100644
--- a/Sources/Tools/MaxConvert/hsMaterialConverter.h
+++ b/Sources/Tools/MaxConvert/hsMaterialConverter.h
@@ -63,6 +63,7 @@ class hsGAnimLayer;
 class plBitmap;
 class plMipmap;
 class plErrorMsg;
+class plString;
 
 class Mtl;
 class Texmap;
@@ -138,10 +139,10 @@ public:
     static int GetCoordMapping(StdUVGen *uvgen);
     static void GetNodesByMaterial(Mtl *mtl, hsTArray<plMaxNode*> &out);
 
-    static uint32_t       VertexChannelsRequestMask(plMaxNode* node, int iSubMtl, Mtl* mtl);
-    static uint32_t       VertexChannelsRequiredMask(plMaxNode* node, int iSubMtl);
+    static uint32_t     VertexChannelsRequestMask(plMaxNode* node, int iSubMtl, Mtl* mtl);
+    static uint32_t     VertexChannelsRequiredMask(plMaxNode* node, int iSubMtl);
     static int          NumVertexOpacityChannelsRequired(plMaxNode* node, int iSubMtl);
-    static uint32_t       ColorChannelsUseMask(plMaxNode* node, int iSubMtl);
+    static uint32_t     ColorChannelsUseMask(plMaxNode* node, int iSubMtl);
     static int          MaxUsedUVWSrc(plMaxNode* node, Mtl* mtl);
 
 
@@ -235,7 +236,7 @@ enum {
         hsBool              fSubMultiMat;
         hsBool              fOwnedCopy;
         hsBool              fRuntimeLit;
-        uint32_t              fSubMtlFlags;
+        uint32_t            fSubMtlFlags;
         int                 fNumUVChannels;
         hsBool              fMakeAlphaLayer;
     };
@@ -265,21 +266,21 @@ private:
     void IInsertSingleBlendLayer(plMipmap *texture, hsGMaterial *mat, plMaxNode *node, 
                                  int layerIdx, int UVChan);
 
-    hsGMaterial *ICreateMaterial(Mtl *mtl, plMaxNode *node, const char *name, int subIndex, int numUVChannels, hsBool makeAlphaLayer);
-    hsGMaterial *IProcessMaterial(Mtl *mtl, plMaxNode *node, const char *name, int UVChan, int subMtlFlags = 0);
+    hsGMaterial *ICreateMaterial(Mtl *mtl, plMaxNode *node, const plString &name, int subIndex, int numUVChannels, hsBool makeAlphaLayer);
+    hsGMaterial *IProcessMaterial(Mtl *mtl, plMaxNode *node, const plString &name, int UVChan, int subMtlFlags = 0);
 
     // ... calls one of:
-    hsGMaterial *IProcessMultipassMtl(Mtl *mtl, plMaxNode *node, const char *name, int UVChan);
-    hsGMaterial *IProcessCompositeMtl(Mtl *mtl, plMaxNode *node, const char *name, int UVChan, int subMtlFlags);
-    hsGMaterial *IProcessParticleMtl(Mtl *mtl, plMaxNode *node, const char *name);
-    hsBool IProcessPlasmaMaterial(Mtl *mtl, plMaxNode *node, hsGMaterial *mat, const char* namePrefix);
+    hsGMaterial *IProcessMultipassMtl(Mtl *mtl, plMaxNode *node, const plString &name, int UVChan);
+    hsGMaterial *IProcessCompositeMtl(Mtl *mtl, plMaxNode *node, const plString &name, int UVChan, int subMtlFlags);
+    hsGMaterial *IProcessParticleMtl(Mtl *mtl, plMaxNode *node, const plString &name);
+    hsBool IProcessPlasmaMaterial(Mtl *mtl, plMaxNode *node, hsGMaterial *mat, const plString& namePrefix);
 
     hsGMaterial* IInsertDoneMaterial(Mtl *mtl, hsGMaterial *hMat, plMaxNode *node, hsBool isMultiMat, 
                              hsBool forceCopy, hsBool runtimeLit, uint32_t subMtlFlags, int numUVChannels, hsBool makeAlphaLayer);
 
     void        IInsertBumpLayers(plMaxNode* node, hsGMaterial* mat, int bumpLayerIdx);
     void        IInsertBumpLayers(plMaxNode* node, hsGMaterial* mat);
-    plLayer*    IMakeBumpLayer(plMaxNode* node, const char* nameBase, hsGMaterial* mat, uint32_t miscFlag);
+    plLayer*    IMakeBumpLayer(plMaxNode* node, const plString& nameBase, hsGMaterial* mat, uint32_t miscFlag);
     plMipmap*   IGetBumpLutTexture(plMaxNode* node);
 
     hsBool      IHasSubMtl(Mtl* base, Mtl* sub);
@@ -328,19 +329,19 @@ private:
     static plBitmap*        IGetFunkyRamp(plMaxNode* node, uint32_t funkyType);
     static void             IAppendFunkyLayer(plMaxNode* node, Texmap* texMap, hsGMaterial* mat);
     static hsBool           IHasFunkyOpacity(plMaxNode* node, Texmap* texMap);
-    static uint32_t           IGetFunkyType(Texmap* texMap);
-    static uint32_t           IGetOpacityRanges(plMaxNode* node, Texmap* texMap, float& tr0, float& op0, float& op1, float& tr1);
+    static uint32_t         IGetFunkyType(Texmap* texMap);
+    static uint32_t         IGetOpacityRanges(plMaxNode* node, Texmap* texMap, float& tr0, float& op0, float& op1, float& tr1);
 
     Interface           *fInterface;
     hsConverterUtils&   fConverterUtils;
     hsBool              fSave;
     plErrorMsg          *fErrorMsg;
 
-    int32_t               fSubIndex;
+    int32_t             fSubIndex;
     hsBool              fChangedTimes;
 
     char                *fNodeName;
-    uint32_t              fWarned;
+    uint32_t            fWarned;
 
 
     DoneMaterialData            fLastMaterial;
diff --git a/Sources/Tools/MaxConvert/plBitmapCreator.cpp b/Sources/Tools/MaxConvert/plBitmapCreator.cpp
index 4d3afa16..5429f715 100644
--- a/Sources/Tools/MaxConvert/plBitmapCreator.cpp
+++ b/Sources/Tools/MaxConvert/plBitmapCreator.cpp
@@ -521,7 +521,8 @@ plBitmap *plBitmapCreator::ICreateTexture( plBitmapData *bd, const plLocation &l
     }
 
     // Get and mangle key name
-    char name[ 256 ], temp[ 256 ];
+    plString name;
+    char temp[ 256 ];
     _splitpath(bd->fileName, NULL, NULL, temp, NULL);
 
     // Somehow, sometimes, we get the same file in with different cases. So we need to force the
@@ -534,21 +535,21 @@ plBitmap *plBitmapCreator::ICreateTexture( plBitmapData *bd, const plLocation &l
     {   
         // Mangle of the form: name@dropStart&dropStop&max&min
         if( clipID != -1 )
-            sprintf( name, "%s*%x#%d@%s&%3.2f&%3.2f&%3.2f&%3.2f", temp, bd->texFlags, clipID, 
+            name = plString::Format( "%s*%x#%d@%s&%3.2f&%3.2f&%3.2f&%3.2f", temp, bd->texFlags, clipID,
                     bd->createFlags & plMipmap::kCreateDetailAlpha ? "al" : ( bd->createFlags & plMipmap::kCreateDetailAdd ? "ad" : "mu" ),
                     bd->detailDropoffStart, bd->detailDropoffStop, bd->detailMax, bd->detailMin );
         else
-            sprintf( name, "%s*%x@%s&%3.2f&%3.2f&%3.2f&%3.2f", temp, bd->texFlags, 
+            name = plString::Format( "%s*%x@%s&%3.2f&%3.2f&%3.2f&%3.2f", temp, bd->texFlags,
                     bd->createFlags & plMipmap::kCreateDetailAlpha ? "al" : ( bd->createFlags == plMipmap::kCreateDetailAdd ? "ad" : "mu" ),
                     bd->detailDropoffStart, bd->detailDropoffStop, bd->detailMax, bd->detailMin );
     }
     else if( clipID != -1 )
-        sprintf( name, "%s*%x#%d", temp, bd->texFlags, clipID );
+        name = plString::Format( "%s*%x#%d", temp, bd->texFlags, clipID );
     else
-        sprintf( name, "%s*%x", temp, bd->texFlags );
+        name = plString::Format( "%s*%x", temp, bd->texFlags );
     if( bd->invertAlpha )
-        strcat( name, "_inva" );
-    strcat( name, ".hsm" );
+        name += _TEMP_CONVERT_FROM_LITERAL( "_inva" );
+    name += _TEMP_CONVERT_FROM_LITERAL( ".hsm" );
 
 
     // Has this texture been used before?
@@ -672,7 +673,7 @@ void    plBitmapCreator::IAddBitmap( plBitmap *bitmap, hsBool dontRef )
 //  of "converted" maps to clean up at the end of export.
 
 plMipmap    *plBitmapCreator::CreateBlankMipmap( uint32_t width, uint32_t height, unsigned config, uint8_t numLevels, 
-                                                 const char *keyName, const plLocation &keyLocation )
+                                                 const plString &keyName, const plLocation &keyLocation )
 {
     hsGuardBegin( "plBitmapCreator::CreateBlankMipmap" );
 
diff --git a/Sources/Tools/MaxConvert/plBitmapCreator.h b/Sources/Tools/MaxConvert/plBitmapCreator.h
index 5942c3b6..9b2c2a86 100644
--- a/Sources/Tools/MaxConvert/plBitmapCreator.h
+++ b/Sources/Tools/MaxConvert/plBitmapCreator.h
@@ -100,7 +100,7 @@ class plBitmapCreator
         static plBitmapCreator  &Instance();
 
         plBitmap    *CreateTexture( plBitmapData *bd, const plLocation &loc, int clipID = -1 );
-        plMipmap    *CreateBlankMipmap( uint32_t width, uint32_t height, unsigned config, uint8_t numLevels, const char *keyName, const plLocation &keyLocation );
+        plMipmap    *CreateBlankMipmap( uint32_t width, uint32_t height, unsigned config, uint8_t numLevels, const plString &keyName, const plLocation &keyLocation );
 
         void    Init( hsBool save, plErrorMsg *msg );
         void    DeInit( void );
diff --git a/Sources/Tools/MaxConvert/plClusterUtil.cpp b/Sources/Tools/MaxConvert/plClusterUtil.cpp
index 79fdd347..08a56434 100644
--- a/Sources/Tools/MaxConvert/plClusterUtil.cpp
+++ b/Sources/Tools/MaxConvert/plClusterUtil.cpp
@@ -106,8 +106,7 @@ plClusterGroup* plClusterUtil::CreateGroup(plMaxNode* templNode, const char* nam
 {
     plClusterGroup* retVal = new plClusterGroup;
     
-    char buff[256];
-    sprintf(buff, "%s_%s_%d", name, templNode->GetName(), fIdx++);
+    plString buff = plString::Format("%s_%s_%d", name, templNode->GetName(), fIdx++);
     hsgResMgr::ResMgr()->NewKey(buff, retVal, templNode->GetLocation(), templNode->GetLoadMask());
 
     plKey sceneNode = templNode->GetRoomKey();
diff --git a/Sources/Tools/MaxConvert/plLayerConverter.cpp b/Sources/Tools/MaxConvert/plLayerConverter.cpp
index 90dffb79..3144d2c2 100644
--- a/Sources/Tools/MaxConvert/plLayerConverter.cpp
+++ b/Sources/Tools/MaxConvert/plLayerConverter.cpp
@@ -295,7 +295,7 @@ plLayerInterface    *plLayerConverter::IConvertLayerTex( plPlasmaMAXLayer *layer
     }
 
     // Get a new layer to play with
-    plLayer *plasmaLayer = ICreateLayer( layer->GetName(), upperLayer, loc );
+    plLayer *plasmaLayer = ICreateLayer( plString::FromUtf8( layer->GetName() ), upperLayer, loc );
 
     // We're using a texture, try and get its info
     PBBitmap    *pbbm = nil;
@@ -430,7 +430,7 @@ plLayerInterface    *plLayerConverter::IConvertStaticEnvLayer( plPlasmaMAXLayer
     }
 
     // Get a new layer to play with
-    plLayer *plasmaLayer = ICreateLayer( layer->GetName(), upperLayer, loc );
+    plLayer *plasmaLayer = ICreateLayer( plString::FromUtf8( layer->GetName() ), upperLayer, loc );
 
     // Get the texture info
     PBBitmap *pbbm = bitmapPB->GetBitmap( plStaticEnvLayer::kBmpFrontBitmap + 0 );
@@ -540,7 +540,7 @@ plLayerInterface    *plLayerConverter::IConvertDynamicEnvLayer( plPlasmaMAXLayer
     }
 
     // Get a new layer to play with
-    plLayer *plasmaLayer = ICreateLayer( layer->GetName(), upperLayer, loc );
+    plLayer *plasmaLayer = ICreateLayer( plString::FromUtf8( layer->GetName() ), upperLayer, loc );
 
     // Get the anchor node
     plMaxNode   *anchor = (plMaxNode *)bitmapPB->GetINode( plDynamicEnvLayer::kBmpAnchorNode );
@@ -550,7 +550,7 @@ plLayerInterface    *plLayerConverter::IConvertDynamicEnvLayer( plPlasmaMAXLayer
     
     if( !anchor->CanConvert() || !( anchor->GetForceLocal() || anchor->GetDrawable() ) )
     {
-        fErrorMsg->Set( true, "Plasma Layer Error", "The dynamic envMap material %s has an invalid anchor specified. Please specify a valid Plasma scene object as an anchor.", plasmaLayer->GetKeyName() ).Show();
+        fErrorMsg->Set( true, "Plasma Layer Error", "The dynamic envMap material %s has an invalid anchor specified. Please specify a valid Plasma scene object as an anchor.", plasmaLayer->GetKeyName().c_str() ).Show();
         fErrorMsg->Set();
         return (plLayerInterface *)plasmaLayer;
     }
@@ -563,14 +563,14 @@ plLayerInterface    *plLayerConverter::IConvertDynamicEnvLayer( plPlasmaMAXLayer
     plasmaLayer->SetUVWSrc( plasmaLayer->GetUVWSrc() | plLayerInterface::kUVWReflect );
 
     // Create the texture.  If it works, assign it to the layer
-    char    texName[ 256 ];
+    plString texName;
     if( anchor == maxNode )
     {
         // Self-anchoring material, make sure the name is unique via the nodeName
-        sprintf( texName, "%s_cubicRT@%s", plasmaLayer->GetKeyName(), maxNode->GetName() );
+        texName = plString::Format( "%s_cubicRT@%s", plasmaLayer->GetKeyName().c_str(), maxNode->GetName() );
     }
     else
-        sprintf( texName, "%s_cubicRT", plasmaLayer->GetKeyName() );
+        texName = plString::Format( "%s_cubicRT", plasmaLayer->GetKeyName().c_str() );
 
     plBitmap *texture = (plBitmap *)IMakeCubicRenderTarget( texName, maxNode, anchor );
     if( texture )
@@ -606,7 +606,7 @@ plLayerInterface    *plLayerConverter::IConvertCameraLayer(plPlasmaMAXLayer *lay
         return nil;
     }
 
-    plLayer *plasmaLayer = ICreateLayer (layer->GetName(), upperLayer, loc);
+    plLayer *plasmaLayer = ICreateLayer (plString::FromUtf8(layer->GetName()), upperLayer, loc);
 
     plMaxNode *rootNode = (plMaxNode*)pb->GetINode(ParamID(plMAXCameraLayer::kRootNode));
     plDynamicCamMap *map = plEnvMapComponent::GetCamMap(rootNode ? rootNode : maxNode);
@@ -678,7 +678,7 @@ plLayerInterface    *plLayerConverter::IConvertDynamicTextLayer( plPlasmaMAXLaye
     }
 
     // Get a new layer to play with
-    plLayer *plasmaLayer = ICreateLayer( maxLayer->GetName(), upperLayer, loc );
+    plLayer *plasmaLayer = ICreateLayer( plString::FromUtf8( maxLayer->GetName() ), upperLayer, loc );
 
 
     /// UV Gen
@@ -772,8 +772,7 @@ static uint32_t MakeUInt32Color(float r, float g, float b, float a)
 
 plBitmap* plLayerConverter::IGetAttenRamp(plMaxNode *node, BOOL isAdd, int loClamp, int hiClamp)
 {
-    char funkName[512];
-    sprintf(funkName, "%s_%d_%d", 
+    plString funkName = plString::Format("%s_%d_%d",
         isAdd ? "AttenRampAdd" : "AttenRampMult",
         loClamp,
         hiClamp);
@@ -831,7 +830,7 @@ plBitmap* plLayerConverter::IGetAttenRamp(plMaxNode *node, BOOL isAdd, int loCla
 }
 
 
-plLayer* plLayerConverter::ICreateAttenuationLayer(const char* name, plMaxNode *node, int uvwSrc,
+plLayer* plLayerConverter::ICreateAttenuationLayer(const plString& name, plMaxNode *node, int uvwSrc,
                                                             float tr0, float op0, float tr1, float op1,
                                                             int loClamp, int hiClamp)
 {
@@ -917,7 +916,7 @@ plLayerInterface* plLayerConverter::IConvertAngleAttenLayer(plPlasmaMAXLayer *la
 
     int uvwSrc = aaLay->Reflect() ? plLayerInterface::kUVWReflect : plLayerInterface::kUVWNormal;
 
-    plLayer* lut = ICreateAttenuationLayer(layer->GetName(), maxNode, uvwSrc, tr0, op0, tr1, op1, loClamp, hiClamp);
+    plLayer* lut = ICreateAttenuationLayer(plString::FromUtf8(layer->GetName()), maxNode, uvwSrc, tr0, op0, tr1, op1, loClamp, hiClamp);
 
     return lut;
 
@@ -925,7 +924,7 @@ plLayerInterface* plLayerConverter::IConvertAngleAttenLayer(plPlasmaMAXLayer *la
 }
 //// ICreateLayer /////////////////////////////////////////////////////////////
 
-plLayer     *plLayerConverter::ICreateLayer( const char *name, hsBool upperLayer, plLocation &loc )
+plLayer     *plLayerConverter::ICreateLayer( const plString &name, hsBool upperLayer, plLocation &loc )
 {
     hsGuardBegin( "plPlasmaMAXLayer::ICreateLayer" );
 
@@ -969,11 +968,11 @@ void    plLayerConverter::IProcessUVGen( plPlasmaMAXLayer *srcLayer, plLayer *de
     // UVW Src
     int32_t uvwSrc = srcLayer->GetMapChannel() - 1;
 
-    if( fErrorMsg->Set( !( fWarned & kWarnedTooManyUVs ) && 
-                        ( ( uvwSrc < 0 ) || ( uvwSrc >= plGeometrySpan::kMaxNumUVChannels ) ), 
-                        destLayer->GetKeyName(), "Only %d UVW channels (1-%d) currently supported", 
+    if( fErrorMsg->Set( !( fWarned & kWarnedTooManyUVs ) &&
+                        ( ( uvwSrc < 0 ) || ( uvwSrc >= plGeometrySpan::kMaxNumUVChannels ) ),
+                        destLayer->GetKeyName().c_str(), "Only %d UVW channels (1-%d) currently supported",
         plGeometrySpan::kMaxNumUVChannels, plGeometrySpan::kMaxNumUVChannels).CheckAskOrCancel() )
-        fWarned |= kWarnedTooManyUVs; 
+        fWarned |= kWarnedTooManyUVs;
     fErrorMsg->Set( false );
 
     destLayer->SetUVWSrc( uvwSrc );
@@ -989,19 +988,18 @@ void    plLayerConverter::IProcessUVGen( plPlasmaMAXLayer *srcLayer, plLayer *de
 
 //// ICreateDynTextMap ////////////////////////////////////////////////////////
 
-plDynamicTextMap    *plLayerConverter::ICreateDynTextMap( const char *layerName, uint32_t width, uint32_t height,
+plDynamicTextMap    *plLayerConverter::ICreateDynTextMap( const plString &layerName, uint32_t width, uint32_t height,
                                                         hsBool includeAlphaChannel, plMaxNode *node )
 {
     hsGuardBegin( "plPlasmaMAXLayer::ICreateDynTextMap" );
 
-    char                texName[ 256 ];
     plKey               key;
     plDynamicTextMap    *map = nil;
 
     
     // Need a unique key name for every layer that uses one. We could also key
     // off of width and height, but layerName should be more than plenty
-    sprintf( texName, "%s_dynText", layerName );
+    plString texName = plString::Format( "%s_dynText", layerName );
 
     // Does it already exist?
     key = node->FindPageKey( plDynamicTextMap::Index(), texName );
@@ -1086,13 +1084,12 @@ plLayer *plLayerConverter::IAssignTexture( plBitmapData *bd, plMaxNode *maxNode,
 //  Makes a plCubicRenderTarget as a texture. Also constructs the associated
 //  modifier and attaches it to the necessary object (hacked for now)
 
-plCubicRenderTarget *plLayerConverter::IMakeCubicRenderTarget( const char *name, plMaxNode *node, plMaxNode *anchor )
+plCubicRenderTarget *plLayerConverter::IMakeCubicRenderTarget( const plString &name, plMaxNode *node, plMaxNode *anchor )
 {
     plDynamicEnvMap* env = plEnvMapComponent::GetEnvMap(anchor);
     if( env )
         return env;
 
-    char                modName[ 256 ];
     plCubicRenderTarget *cubic = nil;
 
 
@@ -1123,7 +1120,7 @@ plCubicRenderTarget *plLayerConverter::IMakeCubicRenderTarget( const char *name,
 
     /// Now make a modifier
     plCubicRenderTargetModifier *mod = new plCubicRenderTargetModifier();
-    sprintf( modName, "%s_mod", name );
+    plString modName = plString::Format( "%s_mod", name.c_str() );
 
     hsgResMgr::ResMgr()->NewKey( modName, mod, node->GetLocation() );
     hsgResMgr::ResMgr()->AddViaNotify( cubic->GetKey(), new plGenRefMsg( mod->GetKey(), plRefMsg::kOnCreate, 0, 0 ), plRefFlags::kPassiveRef );
diff --git a/Sources/Tools/MaxConvert/plLayerConverter.h b/Sources/Tools/MaxConvert/plLayerConverter.h
index 7c8fbe03..1782b6d7 100644
--- a/Sources/Tools/MaxConvert/plLayerConverter.h
+++ b/Sources/Tools/MaxConvert/plLayerConverter.h
@@ -72,6 +72,7 @@ class plBitmap;
 class plCubicRenderTarget;
 class hsConverterUtils;
 class plDynamicTextLayer;
+class plString;
 
 class plLayerConverter
 {
@@ -112,12 +113,12 @@ class plLayerConverter
         hsTArray<plPlasmaMAXLayer *>    fConvertedLayers;
 
 
-        plLayer             *ICreateLayer( const char *name, hsBool upperLayer, plLocation &loc );
+        plLayer             *ICreateLayer( const plString &name, hsBool upperLayer, plLocation &loc );
         void                IProcessUVGen( plPlasmaMAXLayer *srcLayer, plLayer *destLayer, plBitmapData *bitmapData, hsBool preserveUVOffset );
-        plDynamicTextMap    *ICreateDynTextMap( const char *layerName, uint32_t width, uint32_t height, hsBool includeAlpha, plMaxNode *node );
+        plDynamicTextMap    *ICreateDynTextMap( const plString &layerName, uint32_t width, uint32_t height, hsBool includeAlpha, plMaxNode *node );
 
         plLayer             *IAssignTexture( plBitmapData *bd, plMaxNode *maxNode, plLayer *destLayer, hsBool upperLayer, int clipID = -1 );
-        plCubicRenderTarget *IMakeCubicRenderTarget( const char *name, plMaxNode *maxNode, plMaxNode *anchor );
+        plCubicRenderTarget *IMakeCubicRenderTarget( const plString &name, plMaxNode *maxNode, plMaxNode *anchor );
 
         // Add your function to process your layer type here
         plLayerInterface    *IConvertLayerTex( plPlasmaMAXLayer *layer, plMaxNode *maxNode, uint32_t blendFlags, hsBool preserveUVOffset, hsBool upperLayer );
@@ -127,12 +128,12 @@ class plLayerConverter
         plLayerInterface    *IConvertDynamicTextLayer( plPlasmaMAXLayer *layer, plMaxNode *maxNode, uint32_t blendFlags, hsBool preserveUVOffset, hsBool upperLayer );
 
         plBitmap*           IGetAttenRamp( plMaxNode *maxNode, BOOL isAdd, int loClamp, int hiClamp);
-        plLayer*            ICreateAttenuationLayer(const char* name, plMaxNode *maxNode, int uvwSrc, float tr0, float op0, float tr1, float op1, int loClamp, int hiClamp);
+        plLayer*            ICreateAttenuationLayer(const plString& name, plMaxNode *maxNode, int uvwSrc, float tr0, float op0, float tr1, float op1, int loClamp, int hiClamp);
         plLayerInterface*   IConvertAngleAttenLayer(plPlasmaMAXLayer *layer, plMaxNode *maxNode, uint32_t blendFlags, hsBool preserveUVOffset, hsBool upperLayer);
 
         void                IRegisterConversion( plPlasmaMAXLayer *origLayer, plLayerInterface *convertedLayer );
 
-        uint32_t              *IGetInitBitmapBuffer( plDynamicTextLayer *layer ) const;
+        uint32_t            *IGetInitBitmapBuffer( plDynamicTextLayer *layer ) const;
 
 };
 
diff --git a/Sources/Tools/MaxConvert/plLightMapGen.cpp b/Sources/Tools/MaxConvert/plLightMapGen.cpp
index 1760a9db..ce96089a 100644
--- a/Sources/Tools/MaxConvert/plLightMapGen.cpp
+++ b/Sources/Tools/MaxConvert/plLightMapGen.cpp
@@ -365,8 +365,7 @@ hsBool plLightMapGen::ICompressLightMaps()
                 {
                     const plLocation &textureLoc = plPluginResManager::ResMgr()->GetCommonPage(orig->GetKey()->GetUoid().GetLocation(),
                                                                                     plAgeDescription::kTextures );
-                    char name[512];
-                    sprintf(name, "%s_DX", orig->GetKey()->GetName());
+                    plString name = plString::Format("%s_DX", orig->GetKey()->GetName().c_str());
 
                     plKey compKey = hsgResMgr::ResMgr()->FindKey(plUoid(textureLoc, plMipmap::Index(), name));
                     if( compKey )
@@ -1252,8 +1251,7 @@ plLayerInterface* plLightMapGen::IMakeLightMapLayer(plMaxNode* node, plGeometryS
             return mat->GetPiggyBack(i);
     }
 
-    char newMatName[256];
-    sprintf(newMatName, "%s_%s_LIGHTMAPGEN", mat->GetKey()->GetName(), node->GetName());
+    plString newMatName = plString::Format("%s_%s_LIGHTMAPGEN", mat->GetKey()->GetName().c_str(), node->GetName());
     plLocation nodeLoc = node->GetLocation();
 
     plKey matKey = hsgResMgr::ResMgr()->FindKey(plUoid(nodeLoc, hsGMaterial::Index(), newMatName));
@@ -1291,8 +1289,7 @@ plLayerInterface* plLightMapGen::IMakeLightMapLayer(plMaxNode* node, plGeometryS
     // Make sure layer (and mip) name are unique across pages by putting the page name in
     const plPageInfo* pageInfo = plKeyFinder::Instance().GetLocationInfo(node->GetLocation());
 
-    char layName[256];
-    sprintf(layName, "%s_%s_LIGHTMAPGEN", pageInfo->GetPage(), node->GetName());
+    plString layName = plString::Format("%s_%s_LIGHTMAPGEN", pageInfo->GetPage(), node->GetName());
     
     plKey layKey = node->FindPageKey(plLayer::Index(), layName);
 
@@ -1309,8 +1306,7 @@ plLayerInterface* plLightMapGen::IMakeLightMapLayer(plMaxNode* node, plGeometryS
         }
         else
         {
-            char mipmapName[ 256 ];
-            sprintf( mipmapName, "%s_mip", layName );
+            plString mipmapName = plString::Format( "%s_mip", layName.c_str() );
 
             // Deleted the NOTE here because it was incorrect in every meaningful sense of the word. - mf
 
@@ -1320,8 +1316,7 @@ plLayerInterface* plLightMapGen::IMakeLightMapLayer(plMaxNode* node, plGeometryS
 
             if( !mipKey && !fRecalcLightMaps )
             {
-                char compressedName[512];
-                sprintf(compressedName, "%s_DX", mipmapName);
+                plString compressedName = plString::Format("%s_DX", mipmapName.c_str());
 
                 plKey compKey = hsgResMgr::ResMgr()->FindKey(plUoid(textureLoc, plMipmap::Index(), compressedName));
 
diff --git a/Sources/Tools/MaxMain/plCommonObjLib.cpp b/Sources/Tools/MaxMain/plCommonObjLib.cpp
index dd6d0875..8f359bbf 100644
--- a/Sources/Tools/MaxMain/plCommonObjLib.cpp
+++ b/Sources/Tools/MaxMain/plCommonObjLib.cpp
@@ -219,7 +219,7 @@ hsBool  plCommonObjLib::RemoveObjectAndKey( plKey &key )
 //  our lib. Returns nil if not found. Use to find out if you already have a
 //  object of a given name that was previously exported.
 
-hsKeyedObject   *plCommonObjLib::FindObject( const char *name, uint16_t classType /* = -1 */ )
+hsKeyedObject   *plCommonObjLib::FindObject( const plString &name, uint16_t classType /* = -1 */ )
 {
     int     i;
 
@@ -229,7 +229,7 @@ hsKeyedObject   *plCommonObjLib::FindObject( const char *name, uint16_t classTyp
         const plUoid    &uoid = fObjects[ i ]->GetKey()->GetUoid();
 
 
-        if( stricmp( uoid.GetObjectName(), name ) == 0 &&
+        if( uoid.GetObjectName().Compare( name, plString::kCaseInsensitive ) == 0 &&
             ( classType == (uint16_t)-1 || classType == uoid.GetClassType() ) )
         {
             return fObjects[ i ];
diff --git a/Sources/Tools/MaxMain/plCommonObjLib.h b/Sources/Tools/MaxMain/plCommonObjLib.h
index a1dfcdac..24f55cd6 100644
--- a/Sources/Tools/MaxMain/plCommonObjLib.h
+++ b/Sources/Tools/MaxMain/plCommonObjLib.h
@@ -67,6 +67,8 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 
 #include "hsTemplates.h"
 
+class plString;
+
 
 //// Class Definition /////////////////////////////////////////////////////////
 
@@ -88,7 +90,7 @@ class plCommonObjLib
 
         void            AddObject( hsKeyedObject *object );
         hsBool          RemoveObjectAndKey( plKey &key );
-        hsKeyedObject   *FindObject( const char *name, uint16_t classType = (uint16_t)-1 );
+        hsKeyedObject   *FindObject( const plString &name, uint16_t classType = (uint16_t)-1 );
         void            ClearObjectList( void );
 
         /// THIS IS YOUR VIRTUAL HERE. Override this to define which objects you collect
diff --git a/Sources/Tools/MaxMain/plMaxNode.cpp b/Sources/Tools/MaxMain/plMaxNode.cpp
index 16e22a1c..644e2b67 100644
--- a/Sources/Tools/MaxMain/plMaxNode.cpp
+++ b/Sources/Tools/MaxMain/plMaxNode.cpp
@@ -154,23 +154,23 @@ static plKey ExternAddModifier(plMaxNodeBase *node, plModifier *mod)
     return nil;//((plMaxNode*)node)->AddModifier(mod);
 }
 
-static plKey ExternGetNewKey(const char *name, plModifier *mod, plLocation loc)
+static plKey ExternGetNewKey(const plString &name, plModifier *mod, plLocation loc)
 {
     return nil;//hsgResMgr::ResMgr()->NewKey(name, mod, loc);
 }
 
 // In plResponderComponent (for no apparent reason).
-int GetMatAnimModKey(Mtl* mtl, plMaxNodeBase* node, const char *segName, hsTArray<plKey>& keys);
+int GetMatAnimModKey(Mtl* mtl, plMaxNodeBase* node, const plString &segName, hsTArray<plKey>& keys);
 // In plAudioComponents
 int GetSoundNameAndIdx(plComponentBase *comp, plMaxNodeBase *node, const char*& name);
 
 #include "MaxComponent/plAnimComponent.h"
 
-static const char *GetAnimCompAnimName(plComponentBase *comp)
+static plString GetAnimCompAnimName(plComponentBase *comp)
 {
     if (comp->ClassID() == ANIM_COMP_CID || comp->ClassID() == ANIM_GROUP_COMP_CID)
         return ((plAnimComponentBase*)comp)->GetAnimName();
-    return nil;
+    return plString::Null;
 }
 
 static plKey GetAnimCompModKey(plComponentBase *comp, plMaxNodeBase *node)
@@ -258,7 +258,7 @@ void plMaxBoneMap::SortBones()
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-plKey plMaxNode::AddModifier(plModifier *pMod, const char* name)
+plKey plMaxNode::AddModifier(plModifier *pMod, const plString& name)
 {
     plKey modKey = pMod->GetKey();
     if (!modKey)
@@ -539,7 +539,7 @@ hsBool plMaxNode::MakeSceneObject(plErrorMsg *pErrMsg, plConvertSettings *settin
 
     // Handle this as a SceneObject
     pso = new plSceneObject;
-    objKey = hsgResMgr::ResMgr()->NewKey(GetName(), pso, nodeLoc, GetLoadMask());
+    objKey = hsgResMgr::ResMgr()->NewKey(plString::FromUtf8(GetName()), pso, nodeLoc, GetLoadMask());
 
     // Remember info in MaxNodeData block for later
     plMaxNodeData *pDat = GetMaxNodeData();
@@ -828,7 +828,7 @@ hsBool plMaxNode::MakePhysical(plErrorMsg *pErrMsg, plConvertSettings *settings)
 
     // add the object to the resource manager, keyed to the new name
     plLocation nodeLoc = GetKey()->GetUoid().GetLocation();
-    const char *objName = GetKey()->GetName();
+    plString objName = GetKey()->GetName();
     plKey physKey = hsgResMgr::ResMgr()->NewKey(objName, physical, nodeLoc, GetLoadMask());
 
     if (!physical->Init(recipe))
@@ -917,7 +917,7 @@ hsBool plMaxNode::MakeCoordinateInterface(plErrorMsg *pErrMsg, plConvertSettings
         //-------------------------
         plKey pNodeKey = GetKey();
         hsAssert(pNodeKey, "Missing key for this Object");
-        const char *pName = pNodeKey->GetName();
+        plString pName = pNodeKey->GetName();
         plLocation nodeLoc = GetLocation();
 
         plKey pCiKey = hsgResMgr::ResMgr()->NewKey(pName, ci,nodeLoc, GetLoadMask());
@@ -990,7 +990,7 @@ hsBool plMaxNode::MakeModifiers(plErrorMsg *pErrMsg, plConvertSettings *settings
                 }
                 pMod->SetScale(scale);
             }
-            AddModifier(pMod, GetName());
+            AddModifier(pMod, plString::FromUtf8(GetName()));
         }
     }
     return true;
@@ -1445,8 +1445,7 @@ hsBool plMaxNode::MakeMesh(plErrorMsg *pErrMsg, plConvertSettings *settings)
         for (i = 0; i < spanArray.GetCount(); i++)
             swapSpans->Append(spanArray.Get(i));
 
-        char tmpName[256];
-        sprintf(tmpName, "%s_SMsh", GetName());
+        plString tmpName = plString::Format("%s_SMsh", GetName());
         hsgResMgr::ResMgr()->NewKey(tmpName, GetSwappableGeom(), GetLocation(), GetLoadMask());
                 
         return true;
@@ -2255,15 +2254,15 @@ hsBool plMaxNode::ConvertToOccluder(plErrorMsg* pErrMsg, hsBool twoSided, hsBool
         occ->ComputeFromPolys();
 
         // Register it.
-        char tmpName[256];
-        if( GetKey() && GetKey()->GetName() && *GetKey()->GetName() )
+        plString tmpName;
+        if( GetKey() && !GetKey()->GetName().IsEmpty() )
         {
-            sprintf(tmpName, "%s_%s", GetKey()->GetName(), "Occluder");
+            tmpName = plString::Format("%s_Occluder", GetKey()->GetName().c_str());
         }
         else
         {
             static int numOcc = 0;
-            sprintf(tmpName, "%s_%4.4d", "Occluder", numOcc);
+            tmpName = plString::Format("Occluder_%4.4d", numOcc);
         }
         plKey key = hsgResMgr::ResMgr()->NewKey( tmpName, occ, nodeLoc, GetLoadMask() );
 
@@ -2986,7 +2985,7 @@ void plMaxNode::GetRTLightAttenAnim(IParamBlock2* ProperPB, plAGAnim *anim)
         if( falloffCtl )
         {
             plLeafController* subCtl;
-            if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
+            if (!anim->GetName().Compare(ENTIRE_ANIMATION_NAME))
                 subCtl = hsControlConverter::Instance().MakeScalarController(falloffCtl, this);
             else
                 subCtl = hsControlConverter::Instance().MakeScalarController(falloffCtl, this,
@@ -3002,7 +3001,7 @@ void plMaxNode::GetRTLightAttenAnim(IParamBlock2* ProperPB, plAGAnim *anim)
                     plScalarControllerChannel *chan = new plScalarControllerChannel(subCtl);
                     app->SetChannel(chan);
                     anim->AddApplicator(app);
-                    if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
+                    if (!anim->GetName().Compare(ENTIRE_ANIMATION_NAME))
                         anim->ExtendToLength(subCtl->GetLength());
                 }
                 else
@@ -3056,7 +3055,7 @@ void plMaxNode::GetRTLightAttenAnim(IParamBlock2* ProperPB, plAGAnim *anim)
                     plScalarControllerChannel *chan = new plScalarControllerChannel(subCtl);
                     app->SetChannel(chan);
                     anim->AddApplicator(app);
-                    if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
+                    if (!anim->GetName().Compare(ENTIRE_ANIMATION_NAME))
                         anim->ExtendToLength(subCtl->GetLength());
 
                     float attenConst, attenLinear, attenQuadratic, attenCutoff;
@@ -3125,7 +3124,7 @@ void plMaxNode::GetRTLightColAnim(IParamBlock2* ProperPB, plAGAnim *anim)
     if( ambientCtl )
     {
         plController* ctl;
-        if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
+        if (!anim->GetName().Compare(ENTIRE_ANIMATION_NAME))
             ctl = hsControlConverter::Instance().MakeColorController(ambientCtl, this);
         else
             ctl = hsControlConverter::Instance().MakeColorController(ambientCtl, this, anim->GetStart(), anim->GetEnd());
@@ -3137,14 +3136,14 @@ void plMaxNode::GetRTLightColAnim(IParamBlock2* ProperPB, plAGAnim *anim)
             chan = new plPointControllerChannel(ctl);
             app->SetChannel(chan);
             anim->AddApplicator(app);
-            if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
+            if (!anim->GetName().Compare(ENTIRE_ANIMATION_NAME))
                 anim->ExtendToLength(ctl->GetLength());
         }
     }
     if( colorCtl )
     {
         plController* ctl;
-        if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
+        if (!anim->GetName().Compare(ENTIRE_ANIMATION_NAME))
             ctl = hsControlConverter::Instance().MakeColorController(colorCtl, this);
         else
             ctl = hsControlConverter::Instance().MakeColorController(colorCtl, this, anim->GetStart(), anim->GetEnd());
@@ -3157,14 +3156,14 @@ void plMaxNode::GetRTLightColAnim(IParamBlock2* ProperPB, plAGAnim *anim)
             chan = new plPointControllerChannel(ctl);
             app->SetChannel(chan);
             anim->AddApplicator(app);
-            if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
+            if (!anim->GetName().Compare(ENTIRE_ANIMATION_NAME))
                 anim->ExtendToLength(ctl->GetLength());
         }
     }
     if( specCtl )
     {
         plController* ctl;
-        if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
+        if (!anim->GetName().Compare(ENTIRE_ANIMATION_NAME))
             ctl = hsControlConverter::Instance().MakeColorController(specCtl, this);
         else
             ctl = hsControlConverter::Instance().MakeColorController(specCtl, this, anim->GetStart(), anim->GetEnd());
@@ -3176,7 +3175,7 @@ void plMaxNode::GetRTLightColAnim(IParamBlock2* ProperPB, plAGAnim *anim)
             chan = new plPointControllerChannel(ctl);
             app->SetChannel(chan);
             anim->AddApplicator(app);
-            if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
+            if (!anim->GetName().Compare(ENTIRE_ANIMATION_NAME))
                 anim->ExtendToLength(ctl->GetLength());
         }
     }
@@ -3191,7 +3190,7 @@ void plMaxNode::GetRTConeAnim(IParamBlock2* ProperPB, plAGAnim *anim)
     if( innerCtl )
     {
         plLeafController* ctl;
-        if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
+        if (!anim->GetName().Compare(ENTIRE_ANIMATION_NAME))
             ctl = hsControlConverter::Instance().MakeScalarController(innerCtl, this);
         else
             ctl = hsControlConverter::Instance().MakeScalarController(innerCtl, this, anim->GetStart(), anim->GetEnd());
@@ -3203,14 +3202,14 @@ void plMaxNode::GetRTConeAnim(IParamBlock2* ProperPB, plAGAnim *anim)
             chan = new plScalarControllerChannel(ctl);
             app->SetChannel(chan);
             anim->AddApplicator(app);
-            if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
+            if (!anim->GetName().Compare(ENTIRE_ANIMATION_NAME))
                 anim->ExtendToLength(ctl->GetLength());
         }
     }
     if( outerCtl )
     {
         plController* ctl;
-        if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
+        if (!anim->GetName().Compare(ENTIRE_ANIMATION_NAME))
             ctl = hsControlConverter::Instance().MakeScalarController(outerCtl, this);
         else
             ctl = hsControlConverter::Instance().MakeScalarController(outerCtl, this, anim->GetStart(), anim->GetEnd());
@@ -3222,7 +3221,7 @@ void plMaxNode::GetRTConeAnim(IParamBlock2* ProperPB, plAGAnim *anim)
             chan = new plScalarControllerChannel(ctl);
             app->SetChannel(chan);
             anim->AddApplicator(app);
-            if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
+            if (!anim->GetName().Compare(ENTIRE_ANIMATION_NAME))
                 anim->ExtendToLength(ctl->GetLength());
         }
     }
@@ -3318,7 +3317,7 @@ plDrawableSpans *plMaxNode::IGetSceneNodeSpans( plSceneNode *node, hsBool needBl
 {
 
     plDrawableSpans *spans;
-    char            tmpName[ 512 ];
+    plString        tmpName;
     plLocation      nodeLoc = GetLocation();  
     
     if( !needBlending )
@@ -3344,13 +3343,13 @@ plDrawableSpans *plMaxNode::IGetSceneNodeSpans( plSceneNode *node, hsBool needBl
     {
         /// Blending (deferred) spans
         spans->SetCriteria( crit );
-        sprintf( tmpName, "%s_%8.8x_%xBlendSpans", node->GetKeyName(), crit.fLevel.fLevel, crit.fCriteria);
+        tmpName = plString::Format( "%s_%8.8x_%xBlendSpans", node->GetKeyName().c_str(), crit.fLevel.fLevel, crit.fCriteria);
     }
     else
     {
         /// Normal spans
         spans->SetCriteria( crit );
-        sprintf( tmpName, "%s_%8.8x_%xSpans", node->GetKeyName(), crit.fLevel.fLevel, crit.fCriteria);
+        tmpName = plString::Format( "%s_%8.8x_%xSpans", node->GetKeyName().c_str(), crit.fLevel.fLevel, crit.fCriteria);
     }
 
     if (GetSwappableGeomTarget() != (uint32_t)-1 || GetSwappableGeom()) // We intend to swap geometry with this node... flag the drawable as volatile
@@ -3650,7 +3649,7 @@ void plMaxNode::SetupBonesAliasesRecur(const char *rootName)
 {
     if(CanConvert()) {
         if (!HasAGMod()) {
-            const char *nameToUse;
+            plString nameToUse;
             
             // parse UserPropsBuf for entire BoneName line
             char localName[256];
@@ -3664,19 +3663,19 @@ void plMaxNode::SetupBonesAliasesRecur(const char *rootName)
             {
                 start+=len;
                 int i=0;
-                while(*start != '\n' && *start != '\0' && *start)
+                while(*start != '\n' && *start)
                 {
                     hsAssert(i<256, "localName overflow");
                     localName[i++]=*start++;
                 }
                 localName[i]=0;
 
-                nameToUse = localName;
+                nameToUse = plString::FromUtf8(localName);
 
             }
             else
             {
-                const char *nodeName = GetName();
+                plString nodeName = plString::FromUtf8(GetName());
         //      char str[256];
         //      sprintf(str, "Missing 'BoneName=foo' UserProp, on object %s, using node name", nodeName ? nodeName : "?");
         //      hsAssert(false, str);
@@ -3696,7 +3695,7 @@ void plMaxNode::SetupBonesAliasesRecur(const char *rootName)
             }
         */
             plAGModifier *mod = new plAGModifier(nameToUse);
-            AddModifier(mod, GetName());
+            AddModifier(mod, plString::FromUtf8(GetName()));
         }
     }
 
@@ -4049,7 +4048,7 @@ plPhysicalProps *plMaxNode::GetPhysicalProps()
 //// FindPageKey /////////////////////////////////////////////////////////////
 //  Little helper function. Calls FindKey() in the resManager using the location (page) of this node
 
-plKey   plMaxNode::FindPageKey( uint16_t classIdx, const char *name )
+plKey   plMaxNode::FindPageKey( uint16_t classIdx, const plString &name )
 {
     return hsgResMgr::ResMgr()->FindKey( plUoid( GetLocation(), classIdx, name ) );
 }
@@ -4109,7 +4108,7 @@ hsBool plMaxNode::MakeIfaceReferences(plErrorMsg *pErrMsg, plConvertSettings *se
     {
         plInterfaceInfoModifier* pMod = new plInterfaceInfoModifier;
         
-        plKey modifierKey = hsgResMgr::ResMgr()->NewKey(GetName(), pMod, GetLocation(), GetLoadMask());
+        plKey modifierKey = hsgResMgr::ResMgr()->NewKey(plString::FromUtf8(GetName()), pMod, GetLocation(), GetLoadMask());
         hsgResMgr::ResMgr()->AddViaNotify(modifierKey, new plObjRefMsg(GetSceneObject()->GetKey(), plRefMsg::kOnCreate, -1, plObjRefMsg::kModifier), plRefFlags::kActiveRef);
         
         for(int i = 0; i < keys.Count(); i++)
diff --git a/Sources/Tools/MaxMain/plMaxNode.h b/Sources/Tools/MaxMain/plMaxNode.h
index 34cfb5e5..052e2225 100644
--- a/Sources/Tools/MaxMain/plMaxNode.h
+++ b/Sources/Tools/MaxMain/plMaxNode.h
@@ -130,7 +130,7 @@ public:
     enum { kSetupProperties, kPreConvert, kConvert };
     hsBool DoComponents(int convertType, plErrorMsg *, plConvertSettings *);
 
-    plKey AddModifier(plModifier *pMod, const char* name);
+    plKey AddModifier(plModifier *pMod, const plString& name);
 
     hsBool ConvertToOccluder            (plErrorMsg* pErrMsg, hsBool twoSided, hsBool isHole);
 
@@ -179,7 +179,7 @@ public:
     plPhysicalProps *GetPhysicalProps();
 
     // Little helper function. Calls FindKey() in the resManager using the location (page) of this node
-    plKey   FindPageKey( uint16_t classIdx, const char *name );
+    plKey   FindPageKey( uint16_t classIdx, const plString &name );
     const char *GetAgeName();
 
     void CheckSynchOptions(plSynchedObject* so);
diff --git a/Sources/Tools/MaxMain/plPluginResManager.cpp b/Sources/Tools/MaxMain/plPluginResManager.cpp
index 4fb69433..e004920c 100644
--- a/Sources/Tools/MaxMain/plPluginResManager.cpp
+++ b/Sources/Tools/MaxMain/plPluginResManager.cpp
@@ -67,8 +67,7 @@ plKey plPluginResManager::NameToLoc(const char* age, const char* page, int32_t s
     hsAssert(pageNode != nil, "No page returned from INameToPage(), shouldn't be possible");
 
     // Go find the sceneNode now, since we know the page exists (go through our normal channels, though)
-    char keyName[256];
-    sprintf(keyName, "%s_%s", age, page);
+    plString keyName = plString::Format("%s_%s", age, page);
 
     plUoid nodeUoid(pageNode->GetPageInfo().GetLocation(), plSceneNode::Index(), keyName);
 
diff --git a/Sources/Tools/MaxMain/plTextureExportLog.cpp b/Sources/Tools/MaxMain/plTextureExportLog.cpp
index ba143b61..de5578d7 100644
--- a/Sources/Tools/MaxMain/plTextureExportLog.cpp
+++ b/Sources/Tools/MaxMain/plTextureExportLog.cpp
@@ -146,7 +146,7 @@ void    plTextureExportLog::Write( void )
         plRenderTarget*     rend = plRenderTarget::ConvertNoRef( node->fBitmap );
 
         // Name
-        IWriteTabbedString( stream, node->fBitmap->GetKeyName(), dynText != nil ? 8 : 4 );
+        IWriteTabbedString( stream, _TEMP_CONVERT_TO_CONST_CHAR( node->fBitmap->GetKeyName() ), dynText != nil ? 8 : 4 );
 
         // Size, formatted
         size = node->fBitmap->GetTotalSize();
diff --git a/Sources/Tools/MaxPlasmaMtls/Layers/plPlasmaMAXLayer.cpp b/Sources/Tools/MaxPlasmaMtls/Layers/plPlasmaMAXLayer.cpp
index a60b771c..92e1a412 100644
--- a/Sources/Tools/MaxPlasmaMtls/Layers/plPlasmaMAXLayer.cpp
+++ b/Sources/Tools/MaxPlasmaMtls/Layers/plPlasmaMAXLayer.cpp
@@ -154,10 +154,7 @@ class plLayerTargetContainer : public hsKeyedObject
 
         plLayerTargetContainer()
         {
-            char str[ 512 ];
-
-
-            sprintf( str, "plLayerTargetContainer-%d", fKeyCount++ );
+            plString str = plString::Format( "plLayerTargetContainer-%d", fKeyCount++ );
             hsgResMgr::ResMgr()->NewKey( str, this, plLocation::kGlobalFixedLoc );
         }
 };
diff --git a/Sources/Tools/MaxPlasmaMtls/Materials/plAnimStealthConvert.cpp b/Sources/Tools/MaxPlasmaMtls/Materials/plAnimStealthConvert.cpp
index 417284a9..f97ef900 100644
--- a/Sources/Tools/MaxPlasmaMtls/Materials/plAnimStealthConvert.cpp
+++ b/Sources/Tools/MaxPlasmaMtls/Materials/plAnimStealthConvert.cpp
@@ -62,7 +62,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 
 //// Helpers /////////////////////////////////////////////////////////////////
 
-static void ISearchLayerRecur( plLayerInterface *layer, const char *segName, hsTArray<plKey>& keys )
+static void ISearchLayerRecur( plLayerInterface *layer, const plString &segName, hsTArray<plKey>& keys )
 {
     if( !layer )
         return;
@@ -70,10 +70,8 @@ static void ISearchLayerRecur( plLayerInterface *layer, const char *segName, hsT
     plLayerAnimation *animLayer = plLayerAnimation::ConvertNoRef(layer);
     if (animLayer)
     {
-        char *ID = animLayer->GetSegmentID();
-        if (ID == nil)
-            ID = "";
-        if (!strcmp(ID, segName))
+        plString ID = animLayer->GetSegmentID();
+        if (!ID.Compare(segName))
         {
             if( keys.kMissingIndex == keys.Find(animLayer->GetKey()) )
                 keys.Append(animLayer->GetKey());
@@ -83,17 +81,16 @@ static void ISearchLayerRecur( plLayerInterface *layer, const char *segName, hsT
     ISearchLayerRecur(layer->GetAttached(), segName, keys);
 }
 
-static int ISearchLayerRecur(hsGMaterial* mat, const char *segName, hsTArray<plKey>& keys)
+static int ISearchLayerRecur(hsGMaterial* mat, const plString &segName, hsTArray<plKey>& keys)
 {
-    if (segName == nil || strcmp( segName, ENTIRE_ANIMATION_NAME ) == 0 )
-        segName = "";
+    plString name = (segName.IsNull() || segName.Compare( ENTIRE_ANIMATION_NAME ) == 0 ) ? _TEMP_CONVERT_FROM_LITERAL( "" ) : segName;
     int i;
     for( i = 0; i < mat->GetNumLayers(); i++ )
-        ISearchLayerRecur(mat->GetLayer(i), segName, keys);
+        ISearchLayerRecur(mat->GetLayer(i), name, keys);
     return keys.GetCount();
 }
 
-static int GetMatAnimModKey(Mtl* mtl, plMaxNodeBase* node, const char* segName, hsTArray<plKey>& keys)
+static int GetMatAnimModKey(Mtl* mtl, plMaxNodeBase* node, const plString& segName, hsTArray<plKey>& keys)
 {
     int retVal = 0;
 
@@ -129,8 +126,8 @@ SegmentSpec *plAnimStealthNode::IGetSegmentSpec( void ) const
 {
     if( fCachedSegMap != nil )
     {
-        const char *name = GetSegmentName();
-        if( name != nil )
+        plString name = GetSegmentName();
+        if( !name.IsNull() )
         {
             SegmentMap::iterator i = fCachedSegMap->find( name );
             if( i != fCachedSegMap->end() )
@@ -167,8 +164,8 @@ void    plAnimStealthNode::GetLoopPoints( float &start, float &end ) const
     start = GetSegStart();
     end = GetSegEnd();
 
-    const char *loopName = GetLoopName();
-    if( loopName != nil && loopName[ 0 ] != 0 && fCachedSegMap != nil )
+    plString loopName = GetLoopName();
+    if( !loopName.IsEmpty() && fCachedSegMap != nil )
         GetSegMapAnimTime( loopName, fCachedSegMap, SegmentSpec::kLoop, start, end );
 }
 
@@ -193,8 +190,8 @@ void    plAnimStealthNode::GetAllStopPoints( hsTArray<float> &out )
 
 void    plAnimStealthNode::StuffToTimeConvert( plAnimTimeConvert &convert, float maxLength )
 {
-    const char *segName = GetSegmentName();
-    bool isEntire = ( segName == nil || strcmp( segName, ENTIRE_ANIMATION_NAME ) == 0 ) ? true : false;
+    plString segName = GetSegmentName();
+    bool isEntire = ( segName.IsNull() || segName.Compare( ENTIRE_ANIMATION_NAME ) == 0 ) ? true : false;
 
     if( isEntire )
     {
diff --git a/Sources/Tools/MaxPlasmaMtls/Materials/plAnimStealthNode.cpp b/Sources/Tools/MaxPlasmaMtls/Materials/plAnimStealthNode.cpp
index db647932..9b34aca8 100644
--- a/Sources/Tools/MaxPlasmaMtls/Materials/plAnimStealthNode.cpp
+++ b/Sources/Tools/MaxPlasmaMtls/Materials/plAnimStealthNode.cpp
@@ -250,12 +250,12 @@ plAnimStealthNode   *plAnimStealthNode::ConvertToStealth( INode *objNode )
 }
 
 
-const char  *plAnimStealthNode::GetSegmentName( void ) const
+plString plAnimStealthNode::GetSegmentName( void ) const
 {
     const char *str = fParamBlock->GetStr( (ParamID)kPBName );
     if( str == nil || str[ 0 ] == 0 )
-        return ENTIRE_ANIMATION_NAME;
-    return str;
+        return _TEMP_CONVERT_FROM_LITERAL( ENTIRE_ANIMATION_NAME );
+    return plString::FromUtf8(str);
 }
 
 void    plAnimStealthNode::SetSegment( const char *name )
@@ -710,8 +710,8 @@ void plStealthDlgProc::ILoadLoops(IParamBlock2 *pb)
     int defIdx = SendMessage( hLoops, CB_ADDSTRING, 0, (LPARAM)ENTIRE_ANIMATION_NAME );
     SendMessage( hLoops, CB_SETITEMDATA, defIdx, kDefault );
 
-    const char *segName = pb->GetStr( (ParamID)plAnimStealthNode::kPBName );
-    if( segName == nil || fSegMap == nil )
+    plString segName = plString::FromUtf8( pb->GetStr( (ParamID)plAnimStealthNode::kPBName ) );
+    if( segName.IsNull() || fSegMap == nil )
     {
         // Default of "entire animation", no other loop options
         SendMessage( hLoops, CB_SETCURSEL, defIdx, 0 );
@@ -733,7 +733,7 @@ void plStealthDlgProc::ILoadLoops(IParamBlock2 *pb)
                     (spec->fEnd   == -1 || spec->fEnd   <= animSpec->fEnd) )
                 {
                     // Add the name
-                    int idx = SendMessage( hLoops, CB_ADDSTRING, 0, (LPARAM)spec->fName );
+                    int idx = SendMessage( hLoops, CB_ADDSTRING, 0, (LPARAM)spec->fName.c_str() );
                     SendMessage( hLoops, CB_SETITEMDATA, idx, kName );
                 }       
             }
@@ -878,11 +878,11 @@ void    plAnimStealthNode::PickTargetNode( IParamBlock2 *destPB, ParamID destPar
     pick.DoPick();
 }
 
-const char  *plAnimStealthNode::GetIfaceSegmentName( hsBool allowNil )
+plString plAnimStealthNode::GetIfaceSegmentName( hsBool allowNil )
 {
     // When sending messages to material animations, they're already addressed for the right
     // layer, no need for a segment name
-    return nil;
+    return plString::Null;
 }
 
 //// Parameter Access Functions //////////////////////////////////////////////
@@ -893,14 +893,11 @@ bool    plAnimStealthNode::GetAutoStart( void ) const   { return (bool)fParamBlo
 void    plAnimStealthNode::SetAutoStart( bool b )       { fParamBlock->SetValue( (ParamID)kPBAutoStart, 0, (int)b ); };
 
 bool        plAnimStealthNode::GetLoop( void ) const                    { return fParamBlock->GetInt( (ParamID)kPBLoop ); }
-const char  *plAnimStealthNode::GetLoopName( void ) const               { return fParamBlock->GetStr( (ParamID)kPBLoopName ); }
-void        plAnimStealthNode::SetLoop( bool b, const char *name )
+plString    plAnimStealthNode::GetLoopName( void ) const                { return plString::FromUtf8( fParamBlock->GetStr( (ParamID)kPBLoopName ) ); }
+void        plAnimStealthNode::SetLoop( bool b, const plString &name )
 {
     fParamBlock->SetValue( (ParamID)kPBLoop, 0, (int)b );
-    if( name == nil )
-        fParamBlock->SetValue( (ParamID)kPBLoopName, 0, "" );
-    else
-        fParamBlock->SetValue( (ParamID)kPBLoopName, 0, (char *)name );
+    fParamBlock->SetValue( (ParamID)kPBLoopName, 0, (char *)name.s_str() );
 }
 
 uint8_t       plAnimStealthNode::GetEaseInType( void ) const      { return (uint8_t)fParamBlock->GetInt( (ParamID)kPBEaseInType ); }
diff --git a/Sources/Tools/MaxPlasmaMtls/Materials/plAnimStealthNode.h b/Sources/Tools/MaxPlasmaMtls/Materials/plAnimStealthNode.h
index f6356746..55825cde 100644
--- a/Sources/Tools/MaxPlasmaMtls/Materials/plAnimStealthNode.h
+++ b/Sources/Tools/MaxPlasmaMtls/Materials/plAnimStealthNode.h
@@ -142,7 +142,7 @@ public:
     HWND    GetWinDlg( void ) const;
 
     // Interesting functions
-    const char  *GetSegmentName( void ) const;
+    plString    GetSegmentName( void ) const;
     void        SetSegment( const char *name ); // nil for "entire animation"
 
     // Conversion from stealth's INode to the actual object
@@ -203,32 +203,32 @@ public:
     void    SetAutoStart( bool b );
 
     bool        GetLoop( void ) const;
-    const char  *GetLoopName( void ) const;
-    void        SetLoop( bool b, const char *name );
+    plString    GetLoopName( void ) const;
+    void        SetLoop( bool b, const plString &name );
 
-    uint8_t       GetEaseInType( void ) const;
-    float    GetEaseInLength( void ) const;
-    float    GetEaseInMin( void ) const;
-    float    GetEaseInMax( void ) const;
+    uint8_t     GetEaseInType( void ) const;
+    float       GetEaseInLength( void ) const;
+    float       GetEaseInMin( void ) const;
+    float       GetEaseInMax( void ) const;
     void        SetEaseIn( uint8_t type, float length, float min, float max );
 
-    uint8_t       GetEaseOutType( void ) const;
-    float    GetEaseOutLength( void ) const;
-    float    GetEaseOutMin( void ) const;
-    float    GetEaseOutMax( void ) const;
+    uint8_t     GetEaseOutType( void ) const;
+    float       GetEaseOutLength( void ) const;
+    float       GetEaseOutMin( void ) const;
+    float       GetEaseOutMax( void ) const;
     void        SetEaseOut( uint8_t type, float length, float min, float max );
 
     // Conversion stuff
     void        GetAllStopPoints( hsTArray<float> &out );
-    float    GetSegStart( void ) const;
-    float    GetSegEnd( void ) const;
+    float       GetSegStart( void ) const;
+    float       GetSegEnd( void ) const;
     void        GetLoopPoints( float &start, float &end ) const;
     void        StuffToTimeConvert( plAnimTimeConvert &convert, float maxLength );
 
     // plAnimObjInterface functions
     virtual void    PickTargetNode( IParamBlock2 *destPB, ParamID destParamID, ParamID typeID );
     virtual hsBool  IsNodeRestricted( void ) { return true; }
-    virtual const char  *GetIfaceSegmentName( hsBool allowNil );
+    virtual plString GetIfaceSegmentName( hsBool allowNil );
     virtual hsBool  GetKeyList( INode *restrictedNode, hsTArray<plKey> &outKeys );
     virtual hsBool      MightRequireSeparateMaterial( void ) { return true; }
 
diff --git a/Sources/Tools/MaxPlasmaMtls/Materials/plBumpMtl.cpp b/Sources/Tools/MaxPlasmaMtls/Materials/plBumpMtl.cpp
index 3b2b7ebb..30777b73 100644
--- a/Sources/Tools/MaxPlasmaMtls/Materials/plBumpMtl.cpp
+++ b/Sources/Tools/MaxPlasmaMtls/Materials/plBumpMtl.cpp
@@ -86,7 +86,7 @@ plBumpMtl::plBumpMtl(BOOL loading) : plPassMtlBase( loading )
     // If we do this later (like, when the dialog loads) something blows up,
     // somewhere in Max.  It didn't in 4, it does in 7.  This seems to fix it.
     if (!loading)
-        IVerifyStealthPresent(ENTIRE_ANIMATION_NAME);
+        IVerifyStealthPresent(_TEMP_CONVERT_FROM_LITERAL(ENTIRE_ANIMATION_NAME));
 }
 
 ParamDlg* plBumpMtl::CreateParamDlg(HWND hwMtlEdit, IMtlParams *imp) 
diff --git a/Sources/Tools/MaxPlasmaMtls/Materials/plDecalMtl.cpp b/Sources/Tools/MaxPlasmaMtls/Materials/plDecalMtl.cpp
index 49488fa7..add1dc60 100644
--- a/Sources/Tools/MaxPlasmaMtls/Materials/plDecalMtl.cpp
+++ b/Sources/Tools/MaxPlasmaMtls/Materials/plDecalMtl.cpp
@@ -93,7 +93,7 @@ plDecalMtl::plDecalMtl(BOOL loading) : plPassMtlBase( loading )
     // If we do this later (like, when the dialog loads) something blows up,
     // somewhere in Max.  It didn't in 4, it does in 7.  This seems to fix it.
     if (!loading)
-        IVerifyStealthPresent(ENTIRE_ANIMATION_NAME);
+        IVerifyStealthPresent(_TEMP_CONVERT_FROM_LITERAL(ENTIRE_ANIMATION_NAME));
 }
 
 ParamDlg* plDecalMtl::CreateParamDlg(HWND hwMtlEdit, IMtlParams *imp) 
diff --git a/Sources/Tools/MaxPlasmaMtls/Materials/plPassAnimDlgProc.cpp b/Sources/Tools/MaxPlasmaMtls/Materials/plPassAnimDlgProc.cpp
index 7c15998d..deb666c7 100644
--- a/Sources/Tools/MaxPlasmaMtls/Materials/plPassAnimDlgProc.cpp
+++ b/Sources/Tools/MaxPlasmaMtls/Materials/plPassAnimDlgProc.cpp
@@ -289,7 +289,7 @@ void plPassAnimDlgProc::ILoadNames(IParamBlock2 *pb )
         plAnimStealthNode *stealth = mtl->IGetStealth( i, false );
         if( stealth != nil )
         {
-            int idx = SendMessage( hAnims, CB_ADDSTRING, 0, (LPARAM)stealth->GetSegmentName() );
+            int idx = SendMessage( hAnims, CB_ADDSTRING, 0, (LPARAM)stealth->GetSegmentName().c_str() );
             SendMessage( hAnims, CB_SETITEMDATA, idx, (LPARAM)stealth );
         }
     }
diff --git a/Sources/Tools/MaxPlasmaMtls/Materials/plPassMtl.cpp b/Sources/Tools/MaxPlasmaMtls/Materials/plPassMtl.cpp
index 306b5eb6..2124c830 100644
--- a/Sources/Tools/MaxPlasmaMtls/Materials/plPassMtl.cpp
+++ b/Sources/Tools/MaxPlasmaMtls/Materials/plPassMtl.cpp
@@ -96,7 +96,7 @@ plPassMtl::plPassMtl(BOOL loading) : plPassMtlBase( loading )
     // If we do this later (like, when the dialog loads) something blows up,
     // somewhere in Max.  It didn't in 4, it does in 7.  This seems to fix it.
     if (!loading)
-        IVerifyStealthPresent(ENTIRE_ANIMATION_NAME);
+        IVerifyStealthPresent(_TEMP_CONVERT_FROM_LITERAL(ENTIRE_ANIMATION_NAME));
 }
 
 plPassMtl::~plPassMtl()
diff --git a/Sources/Tools/MaxPlasmaMtls/Materials/plPassMtlBase.cpp b/Sources/Tools/MaxPlasmaMtls/Materials/plPassMtlBase.cpp
index 146181d3..4e505df3 100644
--- a/Sources/Tools/MaxPlasmaMtls/Materials/plPassMtlBase.cpp
+++ b/Sources/Tools/MaxPlasmaMtls/Materials/plPassMtlBase.cpp
@@ -181,7 +181,7 @@ plAnimStealthNode   *plPassMtlBase::IGetStealth( int index, hsBool update )
     return (plAnimStealthNode *)fAnimPB->GetReferenceTarget( (ParamID)kPBAnimStealthNodes, 0, index );
 }
 
-plAnimStealthNode   *plPassMtlBase::IFindStealth( const char *segmentName )
+plAnimStealthNode   *plPassMtlBase::IFindStealth( const plString &segmentName )
 {
     int     i;
 
@@ -189,9 +189,9 @@ plAnimStealthNode   *plPassMtlBase::IFindStealth( const char *segmentName )
     for( i = 0; i < fAnimPB->Count( (ParamID)kPBAnimStealthNodes ); i++ )
     {
         plAnimStealthNode *node = (plAnimStealthNode *)fAnimPB->GetReferenceTarget( (ParamID)kPBAnimStealthNodes, 0, i );
-        const char *name = node->GetSegmentName();
+        plString name = node->GetSegmentName();
 
-        if( node != nil && strcmp( name, segmentName ) == 0 )
+        if( node != nil && name.Compare( segmentName ) == 0 )
         {
             return node;
         }
@@ -203,7 +203,7 @@ plAnimStealthNode   *plPassMtlBase::IFindStealth( const char *segmentName )
 //// IVerifyStealthPresent ///////////////////////////////////////////////////
 //  Ensures that we have a stealth for the given segment.
 
-plAnimStealthNode   *plPassMtlBase::IVerifyStealthPresent( const char *animName )
+plAnimStealthNode   *plPassMtlBase::IVerifyStealthPresent( const plString &animName )
 {
     // If we're in the middle of loading, don't check
     if (plPostLoadHandler::IsLoading())
@@ -215,7 +215,7 @@ plAnimStealthNode   *plPassMtlBase::IVerifyStealthPresent( const char *animName
         // New segment, add a new stealth node
         stealth = (plAnimStealthNode *)GetCOREInterface()->CreateInstance( HELPER_CLASS_ID, ANIMSTEALTH_CLASSID );
         INode *node = GetCOREInterface()->CreateObjectNode( stealth );
-        stealth->SetSegment( ( strcmp(animName, ENTIRE_ANIMATION_NAME) != 0 ) ? animName : nil );
+        stealth->SetSegment( ( animName.Compare(ENTIRE_ANIMATION_NAME) != 0 ) ? _TEMP_CONVERT_TO_CONST_CHAR(animName) : nil );
         stealth->SetNodeName( GetName() );
         node->Freeze( true );
 
@@ -231,7 +231,7 @@ plAnimStealthNode   *plPassMtlBase::IVerifyStealthPresent( const char *animName
 
         fAnimPB->Append( (ParamID)kPBAnimStealthNodes, 1, (ReferenceTarget **)&stealth );
 
-        const char *realName = stealth->GetSegmentName();
+        plString realName = stealth->GetSegmentName();
 
         fStealthsChanged = true;
     }
@@ -277,7 +277,7 @@ void    plPassMtlBase::IUpdateAnimNodes( void )
     fStealthsChanged = false;
 
     // Verify one for "entire animation"
-    plAnimStealthNode *stealth = IVerifyStealthPresent( ENTIRE_ANIMATION_NAME );
+    plAnimStealthNode *stealth = IVerifyStealthPresent( _TEMP_CONVERT_FROM_LITERAL(ENTIRE_ANIMATION_NAME) );
     goodNodes.Append( stealth );
 
     // Verify segment nodes
@@ -517,9 +517,9 @@ void    plPassMtlBase::PostLoadAnimPBFixup( void )
         for( int i = 0; i < fAnimPB->Count( (ParamID)kPBAnimStealthNodes ); i++ )
         {
             plAnimStealthNode *node = (plAnimStealthNode *)fAnimPB->GetReferenceTarget( (ParamID)kPBAnimStealthNodes, 0, i );
-        const char *name = node->GetSegmentName();
+            plString name = node->GetSegmentName();
             node->SetAutoStart( false );
-            node->SetLoop( true, ENTIRE_ANIMATION_NAME );
+            node->SetLoop( true, _TEMP_CONVERT_FROM_LITERAL( ENTIRE_ANIMATION_NAME ) );
             node->SetEaseIn( plAnimEaseTypes::kNoEase, 1.f, 1.f, 1.f );
             node->SetEaseOut( plAnimEaseTypes::kNoEase, 1.f, 1.f, 1.f );
         }
@@ -528,14 +528,14 @@ void    plPassMtlBase::PostLoadAnimPBFixup( void )
         const char *oldSel = (const char *)fAnimPB->GetStr( (ParamID)kPBAnimName );
         if( oldSel == nil )
             oldSel = ENTIRE_ANIMATION_NAME;
-        plAnimStealthNode *myNew = IFindStealth( oldSel );
+        plAnimStealthNode *myNew = IFindStealth( plString::FromUtf8( oldSel ) );
         if( myNew != nil )
         {
 #pragma warning( push ) // Forcing value to bool true or false (go figure, i'm even explicitly casting)
 #pragma warning( disable:4800 ) // Forcing value to bool true or false (go figure, i'm even explicitly casting)
             myNew->SetAutoStart( (bool)fAnimPB->GetInt( (ParamID)kPBAnimAutoStart ) );
             myNew->SetLoop( (bool)fAnimPB->GetInt( (ParamID)kPBAnimLoop ),
-                            (char *)fAnimPB->GetStr( (ParamID)kPBAnimLoopName ) );
+                            plString::FromUtf8( (char *)fAnimPB->GetStr( (ParamID)kPBAnimLoopName ) ) );
             myNew->SetEaseIn( (uint8_t)fAnimPB->GetInt( (ParamID)kPBAnimEaseInType ),
                                 (float)fAnimPB->GetFloat( (ParamID)kPBAnimEaseInLength ),
                                 (float)fAnimPB->GetFloat( (ParamID)kPBAnimEaseInMin ),
diff --git a/Sources/Tools/MaxPlasmaMtls/Materials/plPassMtlBase.h b/Sources/Tools/MaxPlasmaMtls/Materials/plPassMtlBase.h
index d8230a54..1bf3ab65 100644
--- a/Sources/Tools/MaxPlasmaMtls/Materials/plPassMtlBase.h
+++ b/Sources/Tools/MaxPlasmaMtls/Materials/plPassMtlBase.h
@@ -55,6 +55,7 @@ class plPassAnimDlgProc;
 class plStealthNodeAccessor;
 class plMaxNode;
 class plErrorMsg;
+class plString;
 
 class plPassMtlBase : public Mtl
 {
@@ -81,8 +82,8 @@ protected:
     hsTArray<plMtlChangeCallback *> fChangeCallbacks;
 
     void                IUpdateAnimNodes( void );
-    plAnimStealthNode   *IFindStealth( const char *animName );
-    plAnimStealthNode   *IVerifyStealthPresent( const char *animName );
+    plAnimStealthNode   *IFindStealth( const plString &animName );
+    plAnimStealthNode   *IVerifyStealthPresent( const plString &animName );
 
     int                 IGetNumStealths( hsBool update = true );
     plAnimStealthNode   *IGetStealth( int index, hsBool update = true );

From ad66286a17d40d8b5c0950a7eb56065ae301fbee Mon Sep 17 00:00:00 2001
From: Michael Hansen <zrax0111@gmail.com>
Date: Thu, 9 Feb 2012 00:56:03 -0800
Subject: [PATCH 08/11] Fix several errors and warnings from GCC compilation

---
 Sources/Plasma/Apps/plClient/plClient.cpp     | 11 +++--
 Sources/Plasma/CoreLib/plGeneric.h            |  8 ++--
 Sources/Plasma/CoreLib/plString.h             |  2 +-
 .../pfAnimation/plAnimDebugList.cpp           | 16 +++----
 .../FeatureLib/pfAudio/plRandomSoundMod.cpp   |  4 +-
 .../FeatureLib/pfCamera/plCameraBrain.cpp     |  2 +-
 .../pfConsole/pfAvatarConsoleCommands.cpp     |  2 +-
 .../pfConsole/pfConsoleCommands.cpp           | 34 ++++++-------
 .../FeatureLib/pfConsole/pfConsoleDirSrc.cpp  |  2 +-
 .../FeatureLib/pfConsole/pfDispatchLog.cpp    |  2 +-
 .../pfConsoleCore/pfConsoleEngine.cpp         |  2 +-
 .../pfGameGUIMgr/pfGUIListElement.cpp         |  2 +-
 .../Plasma/FeatureLib/pfPython/cyAvatar.cpp   |  2 +-
 Sources/Plasma/FeatureLib/pfPython/cyMisc.cpp |  3 +-
 .../Plasma/FeatureLib/pfPython/cyPhysics.cpp  | 12 ++---
 .../FeatureLib/pfPython/plPythonFileMod.cpp   |  4 +-
 .../FeatureLib/pfPython/pyCritterBrain.cpp    |  6 +--
 .../FeatureLib/pfPython/pySceneObject.cpp     | 48 +++++++++----------
 .../NucleusLib/pnMessage/plEventCallbackMsg.h | 12 ++---
 .../Plasma/NucleusLib/pnMessage/plMessage.h   |  4 +-
 .../NucleusLib/pnModifier/plLogicModBase.cpp  | 32 +++++--------
 .../NucleusLib/pnNetCommon/plNetServers.h     | 30 ++++++------
 .../Plasma/NucleusLib/pnUUID/pnUUID_Unix.cpp  |  4 +-
 .../plAgeDescription/plAgeDescription.h       |  2 +-
 .../plAgeLoader/plAgeLoaderPaging.cpp         | 10 ++--
 .../PubUtilLib/plAudible/plWinAudible.cpp     |  3 +-
 .../PubUtilLib/plAudio/plAudioSystem.cpp      |  6 +--
 Sources/Plasma/PubUtilLib/plAudio/plSound.cpp |  4 +-
 .../plAudio/plWin32GroupedSound.cpp           |  2 +-
 .../PubUtilLib/plAudio/plWin32Sound.cpp       |  2 +-
 .../PubUtilLib/plAudio/plWin32StaticSound.cpp |  6 +--
 .../plAudio/plWin32StreamingSound.cpp         | 21 ++++----
 .../plAudioCore/plAudioFileReader.cpp         | 10 ----
 .../PubUtilLib/plAvatar/plAGMasterMod.cpp     |  4 +-
 .../PubUtilLib/plAvatar/plArmatureMod.cpp     |  2 +-
 .../plAvatar/plAvLadderModifier.cpp           |  9 ++--
 .../PubUtilLib/plAvatar/plAvatarMgr.cpp       | 14 +++---
 .../PubUtilLib/plAvatar/plMatrixChannel.cpp   | 10 ++--
 .../Plasma/PubUtilLib/plDrawable/plCluster.h  |  2 +-
 .../PubUtilLib/plDrawable/plDrawableSpans.h   |  4 +-
 .../PubUtilLib/plDrawable/plDynaDecalMgr.cpp  |  2 +-
 .../PubUtilLib/plDrawable/plWaveSet7.cpp      |  2 +-
 .../Plasma/PubUtilLib/plFile/plFileUtils.cpp  |  2 +-
 .../PubUtilLib/plGLight/plLightKonstants.h    |  2 +-
 .../PubUtilLib/plInputCore/plInputDevice.cpp  |  2 +-
 .../plInputCore/plSceneInputInterface.cpp     | 20 ++++----
 Sources/Plasma/PubUtilLib/plMath/plRandom.h   |  4 +-
 .../PubUtilLib/plMessage/plLoadCloneMsg.cpp   |  2 +-
 .../PubUtilLib/plModifier/plLogicModifier.cpp |  8 ++--
 .../plModifier/plResponderModifier.h          |  4 +-
 .../PubUtilLib/plModifier/plSDLModifier.cpp   | 22 ++++-----
 .../plNetClient/plLinkEffectsMgr.cpp          | 10 ++--
 .../PubUtilLib/plNetClient/plNetClientMgr.cpp | 14 +++---
 .../plNetClient/plNetClientMgrLoad.cpp        |  4 +-
 .../plNetClient/plNetClientMgrSend.cpp        |  2 +-
 .../plNetClient/plNetClientMgrShow.cpp        | 28 +++++------
 .../plNetClient/plNetClientMsgHandler.cpp     |  7 +--
 .../plNetClient/plNetLinkingMgr.cpp           |  8 ++--
 .../plNetClientComm/plNetClientComm.cpp       |  8 ++--
 .../plNetClientComm/plNetClientComm.h         |  8 ++--
 .../PubUtilLib/plNetCommon/plNetCommon.h      |  6 +--
 .../PubUtilLib/plNetMessage/plNetMessage.cpp  |  2 +-
 .../plParticleSystem/plParticleGenerator.cpp  |  4 +-
 .../plParticleSystem/plParticleGenerator.h    |  4 +-
 .../plPhysical/plCollisionDetector.cpp        | 42 ++++++++--------
 .../plPhysical/plPhysicalSDLModifier.cpp      | 18 +++----
 .../plPhysical/plPickingDetector.cpp          |  6 +--
 .../Plasma/PubUtilLib/plPipeline/plCullTree.h |  2 +-
 .../PubUtilLib/plPipeline/plDebugText.h       | 10 ++--
 .../PubUtilLib/plPipeline/plDynamicEnvMap.cpp |  8 +++-
 .../Plasma/PubUtilLib/plPipeline/plPlates.h   |  6 +--
 .../PubUtilLib/plResMgr/plResManager.cpp      |  2 +-
 .../Plasma/PubUtilLib/plResMgr/plResManager.h |  2 +-
 .../PubUtilLib/plSDL/plStateVariable.cpp      |  8 ++--
 .../PubUtilLib/plStatGather/plAutoProfile.cpp |  7 ++-
 .../Plasma/PubUtilLib/plSurface/plShader.cpp  |  2 +-
 .../Plasma/PubUtilLib/plSurface/plShader.h    |  4 +-
 .../PubUtilLib/plSurface/plShaderTable.h      |  2 +-
 78 files changed, 318 insertions(+), 331 deletions(-)

diff --git a/Sources/Plasma/Apps/plClient/plClient.cpp b/Sources/Plasma/Apps/plClient/plClient.cpp
index 553bd4e8..a22f3259 100644
--- a/Sources/Plasma/Apps/plClient/plClient.cpp
+++ b/Sources/Plasma/Apps/plClient/plClient.cpp
@@ -1094,14 +1094,16 @@ void plClient::IUnloadRooms(const std::vector<plLocation>& locs)
             if (node)
             {
                 #ifndef PLASMA_EXTERNAL_RELEASE
-                plStatusLog::AddLineS("pageouts.log", "SceneNode for %s loaded; Removing node", node->GetKey()->GetUoid().GetObjectName());
+                plStatusLog::AddLineS("pageouts.log", "SceneNode for %s loaded; Removing node",
+                                      node->GetKey()->GetUoid().GetObjectName().c_str());
                 #endif
                 fPageMgr->RemoveNode(node);
             }
             else
             {
                 #ifndef PLASMA_EXTERNAL_RELEASE
-                plStatusLog::AddLineS("pageouts.log", "SceneNode for %s NOT loaded", nodeKey->GetUoid().GetObjectName());
+                plStatusLog::AddLineS("pageouts.log", "SceneNode for %s NOT loaded",
+                                      nodeKey->GetUoid().GetObjectName().c_str());
                 #endif
             }
             GetKey()->Release(nodeKey);     // release notify interest in scene node
@@ -1117,7 +1119,8 @@ void plClient::IUnloadRooms(const std::vector<plLocation>& locs)
                 fCurrentNode = nil;
 
             #ifndef PLASMA_EXTERNAL_RELEASE
-            plStatusLog::AddLineS("pageouts.log", "Telling netClientMgr about paging out %s", nodeKey->GetUoid().GetObjectName());
+            plStatusLog::AddLineS("pageouts.log", "Telling netClientMgr about paging out %s",
+                                  nodeKey->GetUoid().GetObjectName().c_str());
             #endif
 
             if (plNetClientMgr::GetInstance() != nil)
@@ -1241,7 +1244,7 @@ void plClient::IRoomLoaded(plSceneNode* node, bool hold)
         plgDispatch::MsgSend(loadmsg);
     }
     else
-        hsStatusMessageF("Done loading hold room %s, t=%f\n", pRmKey->GetName(), hsTimer::GetSeconds());
+        hsStatusMessageF("Done loading hold room %s, t=%f\n", pRmKey->GetName().c_str(), hsTimer::GetSeconds());
 
     plLocation loc = pRmKey->GetUoid().GetLocation();
     for (int i = 0; i < fRoomsLoading.size(); i++)
diff --git a/Sources/Plasma/CoreLib/plGeneric.h b/Sources/Plasma/CoreLib/plGeneric.h
index bb98b0bf..eb57d807 100644
--- a/Sources/Plasma/CoreLib/plGeneric.h
+++ b/Sources/Plasma/CoreLib/plGeneric.h
@@ -88,11 +88,11 @@ public:
     // the cast functions will NOT cast from one type to another, use
     // GetType() to determine the type of parameter, then cast it to that type
     GenericType GetType() const {return fType;}
-    operator const bool() const {return fBoolVal;}
-    operator const int() const {return fIntVal;}
-    operator const double() const {return fFloatVal;}
+    operator bool() const {return fBoolVal;}
+    operator int() const {return fIntVal;}
+    operator double() const {return fFloatVal;}
     operator const wchar_t*() const {return fStringVal.c_str();}
-    operator const std::wstring() const {return fStringVal;}
+    operator std::wstring() const {return fStringVal;}
 
     int Write(hsStream* stream);
     int Read(hsStream* stream);
diff --git a/Sources/Plasma/CoreLib/plString.h b/Sources/Plasma/CoreLib/plString.h
index f2a4d4b8..48f272c3 100644
--- a/Sources/Plasma/CoreLib/plString.h
+++ b/Sources/Plasma/CoreLib/plString.h
@@ -112,7 +112,7 @@ public:
     }
 
     const _Ch *GetData() const { return fData ? fData->fStringData : 0; }
-    const size_t GetSize() const { return fData ? fData->fSize : 0; }
+    size_t GetSize() const { return fData ? fData->fSize : 0; }
 };
 
 
diff --git a/Sources/Plasma/FeatureLib/pfAnimation/plAnimDebugList.cpp b/Sources/Plasma/FeatureLib/pfAnimation/plAnimDebugList.cpp
index 0e51d048..7f3f0ed3 100644
--- a/Sources/Plasma/FeatureLib/pfAnimation/plAnimDebugList.cpp
+++ b/Sources/Plasma/FeatureLib/pfAnimation/plAnimDebugList.cpp
@@ -104,7 +104,7 @@ void plAnimDebugList::ShowReport()
 
     int y,x,i,j;
     const int yOff=10, startY=40, startX=10;
-    char str[256];
+    plString str;
 
     x = startX;
     y = startY;
@@ -124,10 +124,10 @@ void plAnimDebugList::ShowReport()
                 plLayerAnimation *layerAnim = plLayerAnimation::ConvertNoRef(layer);
                 if (layerAnim)
                 {
-                    sprintf(str, "%s: %s %.3f (%.3f)", mat->GetKeyName(), layerAnim->GetKeyName(), 
+                    str = plString::Format("%s: %s %.3f (%.3f)", mat->GetKeyName().c_str(), layerAnim->GetKeyName().c_str(),
                             layerAnim->GetTimeConvert().CurrentAnimTime(),
                             layerAnim->GetTimeConvert().WorldToAnimTimeNoUpdate(hsTimer::GetSysSeconds()));
-                    txt.DrawString(x, y, str);
+                    txt.DrawString(x, y, _TEMP_CONVERT_TO_CONST_CHAR(str));
                     y += yOff;
                 }
                 layer = layer->GetOverLay();
@@ -137,7 +137,7 @@ void plAnimDebugList::ShowReport()
     y += yOff;
     txt.DrawString(x, y, "AGMaster Anims", 255, 255, 255, 255, plDebugText::kStyleBold);
     y += yOff;
-    
+
     for (i = 0; i < fSOKeys.GetCount(); i++)
     {
         plSceneObject *so = plSceneObject::ConvertNoRef(fSOKeys[i]->ObjectIsLoaded());
@@ -148,17 +148,17 @@ void plAnimDebugList::ShowReport()
         if (!mod)
             continue;
 
-        sprintf(str, "  %s", so->GetKeyName());
-        txt.DrawString(x, y, str);
+        str = plString::Format("  %s", so->GetKeyName().c_str());
+        txt.DrawString(x, y, _TEMP_CONVERT_TO_CONST_CHAR(str));
         y += yOff;
 
         for (j = 0; j < mod->GetNumATCAnimations(); j++)
         {
             plAGAnimInstance *anim = mod->GetATCAnimInstance(j);
-            sprintf(str, "    %s: %.3f (%.3f)", anim->GetAnimation()->GetName(), 
+            str = plString::Format("    %s: %.3f (%.3f)", anim->GetAnimation()->GetName().c_str(),
                     anim->GetTimeConvert()->CurrentAnimTime(),
                     anim->GetTimeConvert()->WorldToAnimTimeNoUpdate(hsTimer::GetSysSeconds()));
-            txt.DrawString(x, y, str);
+            txt.DrawString(x, y, _TEMP_CONVERT_TO_CONST_CHAR(str));
             y += yOff;
         }
     }
diff --git a/Sources/Plasma/FeatureLib/pfAudio/plRandomSoundMod.cpp b/Sources/Plasma/FeatureLib/pfAudio/plRandomSoundMod.cpp
index 5fd76452..16d2046a 100644
--- a/Sources/Plasma/FeatureLib/pfAudio/plRandomSoundMod.cpp
+++ b/Sources/Plasma/FeatureLib/pfAudio/plRandomSoundMod.cpp
@@ -253,9 +253,9 @@ void plRandomSoundMod::IPlayNext()
     if (plgAudioSys::AreExtendedLogsEnabled())
     {
         if (fGroups)
-            plStatusLog::AddLineS("audio.log", "%s: Playing sound #%d from group %d", GetTarget(0)->GetKeyName(), fCurrent, fCurrentGroup);
+            plStatusLog::AddLineS("audio.log", "%s: Playing sound #%d from group %d", GetTarget(0)->GetKeyName().c_str(), fCurrent, fCurrentGroup);
         else
-            plStatusLog::AddLineS("audio.log", "%s: Playing sound #%d", GetTarget(0)->GetKeyName(), fCurrent);
+            plStatusLog::AddLineS("audio.log", "%s: Playing sound #%d", GetTarget(0)->GetKeyName().c_str(), fCurrent);
     }
 
     fEndTimes[fCurrent] = hsTimer::GetSysSeconds() + currLen;
diff --git a/Sources/Plasma/FeatureLib/pfCamera/plCameraBrain.cpp b/Sources/Plasma/FeatureLib/pfCamera/plCameraBrain.cpp
index 75a72a25..1a0f465c 100644
--- a/Sources/Plasma/FeatureLib/pfCamera/plCameraBrain.cpp
+++ b/Sources/Plasma/FeatureLib/pfCamera/plCameraBrain.cpp
@@ -1026,7 +1026,7 @@ void plCameraBrain1_Avatar::Update(hsBool forced)
     if (fFlags.IsBitSet(kIsTransitionCamera))
     {
         if (GetKey())
-            hsStatusMessageF("%s thinks it's the transition camera\n",GetKeyName());
+            hsStatusMessageF("%s thinks it's the transition camera\n", GetKeyName().c_str());
     }
     else
     {
diff --git a/Sources/Plasma/FeatureLib/pfConsole/pfAvatarConsoleCommands.cpp b/Sources/Plasma/FeatureLib/pfConsole/pfAvatarConsoleCommands.cpp
index 0069cc7a..bcfbf7f4 100644
--- a/Sources/Plasma/FeatureLib/pfConsole/pfAvatarConsoleCommands.cpp
+++ b/Sources/Plasma/FeatureLib/pfConsole/pfAvatarConsoleCommands.cpp
@@ -173,7 +173,7 @@ PF_CONSOLE_CMD( Avatar_Spawn, Show, "", "Print a list of spawn points.")
         const plSpawnModifier * spawn = mgr->GetSpawnPoint(i);
         if(spawn)
         {
-            PrintStringF(PrintString, "%d. %s", i, spawn->GetKey()->GetName());
+            PrintStringF(PrintString, "%d. %s", i, spawn->GetKey()->GetName().c_str());
         }
     }
 }
diff --git a/Sources/Plasma/FeatureLib/pfConsole/pfConsoleCommands.cpp b/Sources/Plasma/FeatureLib/pfConsole/pfConsoleCommands.cpp
index 1515f42a..6b1a5cfa 100644
--- a/Sources/Plasma/FeatureLib/pfConsole/pfConsoleCommands.cpp
+++ b/Sources/Plasma/FeatureLib/pfConsole/pfConsoleCommands.cpp
@@ -2723,12 +2723,12 @@ void    MyHandyPrintFunction( const plKey &obj, void (*PrintString)( const char
 
     if( peeker->GetUoid().IsClone() )
         PrintStringF( PrintString, "%d refs on %s, clone %d:%d: loaded=%d", 
-        peeker->PeekNumNotifies(), obj->GetUoid().GetObjectName(), 
-        peeker->GetUoid().GetCloneID(), peeker->GetUoid().GetClonePlayerID(),
-        obj->ObjectIsLoaded() ? 1 : 0);
+            peeker->PeekNumNotifies(), obj->GetUoid().GetObjectName().c_str(), 
+            peeker->GetUoid().GetCloneID(), peeker->GetUoid().GetClonePlayerID(),
+            obj->ObjectIsLoaded() ? 1 : 0);
     else
         PrintStringF( PrintString, "%d refs on %s: loaded=%d", 
-        peeker->PeekNumNotifies(), obj->GetUoid().GetObjectName(), obj->ObjectIsLoaded() ? 1 : 0 );
+            peeker->PeekNumNotifies(), obj->GetUoid().GetObjectName().c_str(), obj->ObjectIsLoaded() ? 1 : 0 );
 
     if( peeker->PeekNumNotifies() == 0 )
         return;
@@ -2754,7 +2754,8 @@ void    MyHandyPrintFunction( const plKey &obj, void (*PrintString)( const char
                             limit--;
 
                             const plKey rcvr = msg->GetReceiver( j );
-                            PrintStringF( PrintString, "    %s:%s", plFactory::GetNameOfClass( rcvr->GetUoid().GetClassType() ), rcvr->GetUoid().GetObjectName() );
+                            PrintStringF( PrintString, "    %s:%s", plFactory::GetNameOfClass( rcvr->GetUoid().GetClassType() ),
+                                          rcvr->GetUoid().GetObjectName().c_str() );
                         }
                     }
                 }
@@ -2928,7 +2929,7 @@ PF_CONSOLE_CMD( Camera,     // groupName
                "increase drive turn rate" ) // helpString
 {
     plCameraBrain1_Drive::fTurnRate += 20.0f;
-    
+
 }
 
 PF_CONSOLE_CMD( Camera,     // groupName
@@ -2939,14 +2940,14 @@ PF_CONSOLE_CMD( Camera,     // groupName
     plCameraBrain1_Drive::fTurnRate -= 20.0f;
     if (plCameraBrain1_Drive::fTurnRate < 0.0)
         plCameraBrain1_Drive::fTurnRate = 20.0f;
-    
+
 }
 
 
 PF_CONSOLE_CMD( Camera, SwitchTo, "string cameraName", "Switch to the named camera")
 {
     char str[256];
-    plString foo = plString::Format("%s_", plString::FromUtf8(params[0]));
+    plString foo = plString::Format("%s_", (char*)params[0]);
     plKey key = FindObjectByNameAndType(foo, "plCameraModifier1", nil, str, true);
     PrintString(str);
 
@@ -4338,7 +4339,7 @@ PF_CONSOLE_CMD( Access,
 
     seq->Activate();
 
-    sprintf(str, "%s Active\n", name);
+    sprintf(str, "%s Active\n", name.c_str());
     PrintString(str);
 }
 
@@ -4359,7 +4360,7 @@ PF_CONSOLE_CMD( Access,
 
     seq->DeActivate();
 
-    sprintf(str, "%s Unactive\n", name);
+    sprintf(str, "%s Unactive\n", name.c_str());
     PrintString(str);
 }
 //////////////////
@@ -4504,9 +4505,7 @@ PF_CONSOLE_CMD( Access,
 
     seq->Activate();
 
-    char str[256];
-    sprintf(str, "%s Active\n", seq->GetKey()->GetName());
-    PrintString(str);
+    PrintString(plString::Format("%s Active\n", seq->GetKey()->GetName().c_str()).c_str());
 }
 
 PF_CONSOLE_CMD( Access,
@@ -4523,9 +4522,7 @@ PF_CONSOLE_CMD( Access,
 
     seq->DeActivate();
 
-    char str[256];
-    sprintf(str, "%s Unactive\n", seq->GetKey()->GetName());
-    PrintString(str);
+    PrintString(plString::Format("%s Unactive\n", seq->GetKey()->GetName().c_str()).c_str());
 }
 
 PF_CONSOLE_CMD( Access,
@@ -4533,7 +4530,6 @@ PF_CONSOLE_CMD( Access,
                    "string clothItem",
                    "Set face morphMod to affect a clothing item" )
 {
-    char str[256];
     plMorphSequence* seq = LocalMorphSequence();
     if( !seq )
     {
@@ -4548,8 +4544,8 @@ PF_CONSOLE_CMD( Access,
     seq->SetUseSharedMesh(true);
     seq->AddSharedMesh(item->fMeshes[plClothingItem::kLODHigh]);
 
-    sprintf(str, "%s on item %s\n", seq->GetKey()->GetName(), (char *)params[0]);
-    PrintString(str);
+    PrintString(plString::Format("%s on item %s\n", seq->GetKey()->GetName().c_str(),
+                                 (char *)params[0]).c_str());
 }
 
 #include "pfSurface/plFadeOpacityMod.h"
diff --git a/Sources/Plasma/FeatureLib/pfConsole/pfConsoleDirSrc.cpp b/Sources/Plasma/FeatureLib/pfConsole/pfConsoleDirSrc.cpp
index d94603d9..2d2a0151 100644
--- a/Sources/Plasma/FeatureLib/pfConsole/pfConsoleDirSrc.cpp
+++ b/Sources/Plasma/FeatureLib/pfConsole/pfConsoleDirSrc.cpp
@@ -102,7 +102,7 @@ hsBool  pfConsoleDirSrc::ParseDirectory(const std::wstring& path, const std::wst
                 error << errorMsg << L":\n\nCommand: '" << errorLine << L"'\n\nPress OK to continue parsing files.";
 
                 hsMessageBox(error.str().c_str(), caption.str().c_str(), hsMessageBoxNormal);               
-                
+
                 delete [] errorMsg;
                 delete [] errorLine;
 
diff --git a/Sources/Plasma/FeatureLib/pfConsole/pfDispatchLog.cpp b/Sources/Plasma/FeatureLib/pfConsole/pfDispatchLog.cpp
index 7a0b2f4c..97da27ef 100644
--- a/Sources/Plasma/FeatureLib/pfConsole/pfDispatchLog.cpp
+++ b/Sources/Plasma/FeatureLib/pfConsole/pfDispatchLog.cpp
@@ -319,7 +319,7 @@ static bool DumpSpecificMsgInfo(plMessage* msg, std::string& info)
         GetType(kOnRequest);
         GetType(kOnRemove);
         GetType(kOnReplace);
-        xtl::format(info, "Obj: %s RefType: %s", refMsg->GetRef()->GetKeyName(), typeName);
+        xtl::format(info, "Obj: %s RefType: %s", refMsg->GetRef()->GetKeyName().c_str(), typeName);
 
         return true;
     }
diff --git a/Sources/Plasma/FeatureLib/pfConsoleCore/pfConsoleEngine.cpp b/Sources/Plasma/FeatureLib/pfConsoleCore/pfConsoleEngine.cpp
index 83bbe486..63888ae7 100644
--- a/Sources/Plasma/FeatureLib/pfConsoleCore/pfConsoleEngine.cpp
+++ b/Sources/Plasma/FeatureLib/pfConsoleCore/pfConsoleEngine.cpp
@@ -279,7 +279,7 @@ hsBool  pfConsoleEngine::ExecuteFile( const wchar_t *fileName )
 
         if( !RunCommand( string, DummyPrintFn ) )
         {
-            sprintf( string, "Error in console file %s, command line %d: %s", fileName, line, fErrorMsg );
+            sprintf( string, "Error in console file %S, command line %d: %s", fileName, line, fErrorMsg );
             ISetErrorMsg( string );
             stream->Close();
             delete stream;
diff --git a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIListElement.cpp b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIListElement.cpp
index a8a7003a..209ff2f5 100644
--- a/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIListElement.cpp
+++ b/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIListElement.cpp
@@ -221,7 +221,7 @@ pfGUIListPicture::pfGUIListPicture( plKey mipKey, hsBool respectAlpha ) : pfGUIL
     {
         // Gotta make and grab an uncompressed one
         plMipmap *uncompBuffer = hsCodecManager::Instance().CreateUncompressedMipmap( mip, hsCodecManager::k32BitDepth );
-        plString str = plString::Format( "%s_uncomp", mip->GetKeyName() );
+        plString str = plString::Format( "%s_uncomp", mip->GetKeyName().c_str() );
         fMipmapKey = hsgResMgr::ResMgr()->NewKey( str, uncompBuffer, fMipmapKey->GetUoid().GetLocation() );
         fMipmapKey->RefObject();
     }
diff --git a/Sources/Plasma/FeatureLib/pfPython/cyAvatar.cpp b/Sources/Plasma/FeatureLib/pfPython/cyAvatar.cpp
index fa475e89..252040f7 100644
--- a/Sources/Plasma/FeatureLib/pfPython/cyAvatar.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/cyAvatar.cpp
@@ -1274,7 +1274,7 @@ PyObject* cyAvatar::GetTintClothingItemL(const char* clothing_name, uint8_t laye
     }
 
     char errmsg[256];
-    sprintf(errmsg,"Cannot find clothing item %d to find out what tint it is",clothing_name);
+    sprintf(errmsg,"Cannot find clothing item %s to find out what tint it is",clothing_name);
     PyErr_SetString(PyExc_KeyError, errmsg);
     // returning nil means an error occurred
     return nil;
diff --git a/Sources/Plasma/FeatureLib/pfPython/cyMisc.cpp b/Sources/Plasma/FeatureLib/pfPython/cyMisc.cpp
index 84509e15..057733b7 100644
--- a/Sources/Plasma/FeatureLib/pfPython/cyMisc.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/cyMisc.cpp
@@ -2362,7 +2362,7 @@ public:
 
                     if ( guid )
                     {
-                        PyObject* retVal = PyObject_CallMethod(fPyObject, "publicAgeRemoved", "s", guid->AsString());
+                        PyObject* retVal = PyObject_CallMethod(fPyObject, "publicAgeRemoved", "s", guid->AsString().c_str());
                         Py_XDECREF(retVal);
                     }
                 }
@@ -2454,7 +2454,6 @@ const char* cyMisc::GetCameraNumber(int number)
     if (pCam->GetTarget())
     {
         const char* ret = pCam->GetTarget()->GetKeyName().c_str();
-        (ret==nil) ? "empty" : ret;
         plString str = plString::Format("saving camera named %s to chronicle\n",ret);
         plVirtualCam1::Instance()->AddMsgToLog(str.c_str());
         return ret;
diff --git a/Sources/Plasma/FeatureLib/pfPython/cyPhysics.cpp b/Sources/Plasma/FeatureLib/pfPython/cyPhysics.cpp
index 5a5d2588..f0181543 100644
--- a/Sources/Plasma/FeatureLib/pfPython/cyPhysics.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/cyPhysics.cpp
@@ -334,9 +334,9 @@ void cyPhysics::Move(pyVector3& direction, float distance)
             }
             else
             {
-                char errmsg[256];
-                sprintf(errmsg,"Sceneobject %s does not have a coordinate interface.",obj->GetKeyName());
-                PyErr_SetString(PyExc_RuntimeError, errmsg);
+                plString errmsg = plString::Format("Sceneobject %s does not have a coordinate interface.",
+                                                   obj->GetKeyName().c_str());
+                PyErr_SetString(PyExc_RuntimeError, errmsg.c_str());
             }
         }
     }
@@ -404,9 +404,9 @@ void cyPhysics::Rotate(float rad, pyVector3& axis)
             }
             else
             {
-                char errmsg[256];
-                sprintf(errmsg,"Sceneobject %s does not have a coordinate interface.",obj->GetKeyName());
-                PyErr_SetString(PyExc_RuntimeError, errmsg);
+                plString errmsg = plString::Format("Sceneobject %s does not have a coordinate interface.",
+                                                   obj->GetKeyName().c_str());
+                PyErr_SetString(PyExc_RuntimeError, errmsg.c_str());
             }
         }
     }
diff --git a/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.cpp b/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.cpp
index 41ab1ffd..c658cf2a 100644
--- a/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.cpp
@@ -410,12 +410,12 @@ plPythonFileMod::~plPythonFileMod()
         PyObject *modules = PyImport_GetModuleDict();
         if( modules && (m = PyDict_GetItemString(modules, fModuleName.c_str())) && PyModule_Check(m))
         {
-            hsStatusMessageF("Module %s removed from python dictionary",fModuleName);
+            hsStatusMessageF("Module %s removed from python dictionary",fModuleName.c_str());
             PyDict_DelItemString(modules, fModuleName.c_str());
         }
         else
         {
-            hsStatusMessageF("Module %s not found in python dictionary. Already removed?",fModuleName);
+            hsStatusMessageF("Module %s not found in python dictionary. Already removed?",fModuleName.c_str());
         }
         // the above code should have unloaded the module from python, so it will delete itself, therefore
         // we need to set our pointer to nil to make sure we don't try to use it
diff --git a/Sources/Plasma/FeatureLib/pfPython/pyCritterBrain.cpp b/Sources/Plasma/FeatureLib/pfPython/pyCritterBrain.cpp
index 063778de..29cbf16f 100644
--- a/Sources/Plasma/FeatureLib/pfPython/pyCritterBrain.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/pyCritterBrain.cpp
@@ -105,7 +105,7 @@ bool pyCritterBrain::RunningBehavior(const std::string& behaviorName) const
 std::string pyCritterBrain::BehaviorName(int behavior) const
 {
     if (!fBrain)
-        return false;
+        return nil;
     return fBrain->BehaviorName(behavior);
 }
 
@@ -133,14 +133,14 @@ int pyCritterBrain::NextBehavior() const
 std::string pyCritterBrain::IdleBehaviorName() const
 {
     if (!fBrain)
-        return false;
+        return nil;
     return fBrain->IdleBehaviorName();
 }
 
 std::string pyCritterBrain::RunBehaviorName() const
 {
     if (!fBrain)
-        return false;
+        return nil;
     return fBrain->RunBehaviorName();
 }
 
diff --git a/Sources/Plasma/FeatureLib/pfPython/pySceneObject.cpp b/Sources/Plasma/FeatureLib/pfPython/pySceneObject.cpp
index 0a1fcd42..a1533cb8 100644
--- a/Sources/Plasma/FeatureLib/pfPython/pySceneObject.cpp
+++ b/Sources/Plasma/FeatureLib/pfPython/pySceneObject.cpp
@@ -284,9 +284,9 @@ PyObject* pySceneObject::GetLocalToWorld()
                 return pyMatrix44::New((hsMatrix44)ci->GetLocalToWorld());
             else
             {
-                char errmsg[256];
-                sprintf(errmsg,"Sceneobject %s does not have a coordinate interface.",obj->GetKeyName());
-                PyErr_SetString(PyExc_RuntimeError, errmsg);
+                plString errmsg = plString::Format("Sceneobject %s does not have a coordinate interface.",
+                                                   obj->GetKeyName().c_str());
+                PyErr_SetString(PyExc_RuntimeError, errmsg.c_str());
                 return nil; // return nil to tell python we errored
             }
         }
@@ -313,9 +313,9 @@ PyObject* pySceneObject::GetWorldToLocal()
                 return pyMatrix44::New((hsMatrix44)ci->GetWorldToLocal());
             else
             {
-                char errmsg[256];
-                sprintf(errmsg,"Sceneobject %s does not have a coordinate interface.",obj->GetKeyName());
-                PyErr_SetString(PyExc_RuntimeError, errmsg);
+                plString errmsg = plString::Format("Sceneobject %s does not have a coordinate interface.",
+                                                   obj->GetKeyName().c_str());
+                PyErr_SetString(PyExc_RuntimeError, errmsg.c_str());
                 return nil; // return nil to tell python we errored
             }
         }
@@ -342,9 +342,9 @@ PyObject* pySceneObject::GetLocalToParent()
                 return pyMatrix44::New((hsMatrix44)ci->GetLocalToParent());
             else
             {
-                char errmsg[256];
-                sprintf(errmsg,"Sceneobject %s does not have a coordinate interface.",obj->GetKeyName());
-                PyErr_SetString(PyExc_RuntimeError, errmsg);
+                plString errmsg = plString::Format("Sceneobject %s does not have a coordinate interface.",
+                                                   obj->GetKeyName().c_str());
+                PyErr_SetString(PyExc_RuntimeError, errmsg.c_str());
                 return nil; // return nil to tell python we errored
             }
         }
@@ -371,9 +371,9 @@ PyObject* pySceneObject::GetParentToLocal()
                 return pyMatrix44::New((hsMatrix44)ci->GetParentToLocal());
             else
             {
-                char errmsg[256];
-                sprintf(errmsg,"Sceneobject %s does not have a coordinate interface.",obj->GetKeyName());
-                PyErr_SetString(PyExc_RuntimeError, errmsg);
+                plString errmsg = plString::Format("Sceneobject %s does not have a coordinate interface.",
+                                                   obj->GetKeyName().c_str());
+                PyErr_SetString(PyExc_RuntimeError, errmsg.c_str());
                 return nil; // return nil to tell python we errored
             }
         }
@@ -416,9 +416,9 @@ PyObject* pySceneObject::GetWorldPosition()
                 return pyPoint3::New((hsPoint3)ci->GetWorldPos());
             else
             {
-                char errmsg[256];
-                sprintf(errmsg,"Sceneobject %s does not have a coordinate interface.",obj->GetKeyName());
-                PyErr_SetString(PyExc_RuntimeError, errmsg);
+                plString errmsg = plString::Format("Sceneobject %s does not have a coordinate interface.",
+                                                   obj->GetKeyName().c_str());
+                PyErr_SetString(PyExc_RuntimeError, errmsg.c_str());
                 return nil; // return nil to tell python we errored
             }
         }
@@ -445,9 +445,9 @@ PyObject* pySceneObject::GetViewVector()
                 return pyVector3::New(ci->GetLocalToWorld().GetAxis(hsMatrix44::kView));
             else
             {
-                char errmsg[256];
-                sprintf(errmsg,"Sceneobject %s does not have a coordinate interface.",obj->GetKeyName());
-                PyErr_SetString(PyExc_RuntimeError, errmsg);
+                plString errmsg = plString::Format("Sceneobject %s does not have a coordinate interface.",
+                                                   obj->GetKeyName().c_str());
+                PyErr_SetString(PyExc_RuntimeError, errmsg.c_str());
                 return nil; // return nil to tell python we errored
             }
         }
@@ -474,9 +474,9 @@ PyObject* pySceneObject::GetUpVector()
                 return pyVector3::New(ci->GetLocalToWorld().GetAxis(hsMatrix44::kUp));
             else
             {
-                char errmsg[256];
-                sprintf(errmsg,"Sceneobject %s does not have a coordinate interface.",obj->GetKeyName());
-                PyErr_SetString(PyExc_RuntimeError, errmsg);
+                plString errmsg = plString::Format("Sceneobject %s does not have a coordinate interface.",
+                                                   obj->GetKeyName().c_str());
+                PyErr_SetString(PyExc_RuntimeError, errmsg.c_str());
                 return nil; // return nil to tell python we errored
             }
         }
@@ -503,9 +503,9 @@ PyObject* pySceneObject::GetRightVector()
                 return pyVector3::New(ci->GetLocalToWorld().GetAxis(hsMatrix44::kRight));
             else
             {
-                char errmsg[256];
-                sprintf(errmsg,"Sceneobject %s does not have a coordinate interface.",obj->GetKeyName());
-                PyErr_SetString(PyExc_RuntimeError, errmsg);
+                plString errmsg = plString::Format("Sceneobject %s does not have a coordinate interface.",
+                                                   obj->GetKeyName().c_str());
+                PyErr_SetString(PyExc_RuntimeError, errmsg.c_str());
                 return nil; // return nil to tell python we errored
             }
         }
diff --git a/Sources/Plasma/NucleusLib/pnMessage/plEventCallbackMsg.h b/Sources/Plasma/NucleusLib/pnMessage/plEventCallbackMsg.h
index 56b862cc..e3b7c4da 100644
--- a/Sources/Plasma/NucleusLib/pnMessage/plEventCallbackMsg.h
+++ b/Sources/Plasma/NucleusLib/pnMessage/plEventCallbackMsg.h
@@ -63,14 +63,14 @@ enum CallbackEvent
 class plEventCallbackMsg : public plMessage
 {
 protected:
-    
+
 public:
-    float        fEventTime; // the time for time events
+    float           fEventTime; // the time for time events
     CallbackEvent   fEvent;     // the event    
-    int16_t           fIndex;     // the index of the object we want the event to come from
+    int16_t         fIndex;     // the index of the object we want the event to come from
                                 // (where applicable, required for sounds)
-    int16_t           fRepeats;   // -1 for infinite repeats, 0 for one call, no repeats
-    int16_t           fUser;      // User defined data, useful for keeping track of multiple callbacks
+    int16_t         fRepeats;   // -1 for infinite repeats, 0 for one call, no repeats
+    int16_t         fUser;      // User defined data, useful for keeping track of multiple callbacks
 
     plEventCallbackMsg() : fEventTime(0.0f), fEvent((CallbackEvent)0), fRepeats(-1), fUser(0), fIndex(0) {;}
     plEventCallbackMsg (const plKey &s, 
@@ -78,7 +78,7 @@ public:
                     const double* t) : 
                         plMessage(s, r, t),
                         fEventTime(0.0f), fEvent((CallbackEvent)0), fRepeats(-1), fUser(0), fIndex(0) {;}
-    
+
     plEventCallbackMsg(const plKey &receiver, CallbackEvent e, int idx=0, float t=0, int16_t repeats=-1, uint16_t user=0) :
                         plMessage(nil, receiver, nil), fEvent(e), fIndex(idx), fEventTime(t), fRepeats(repeats), fUser(user) {}
 
diff --git a/Sources/Plasma/NucleusLib/pnMessage/plMessage.h b/Sources/Plasma/NucleusLib/pnMessage/plMessage.h
index a7e16290..a9bc47b2 100644
--- a/Sources/Plasma/NucleusLib/pnMessage/plMessage.h
+++ b/Sources/Plasma/NucleusLib/pnMessage/plMessage.h
@@ -135,12 +135,12 @@ public:
     hsBool                  Send(const plKey r=nil, hsBool async=false); // Message will self-destruct after send.
     hsBool                  SendAndKeep(const plKey r=nil, hsBool async=false); // Message won't self-destruct after send.
 
-    const double GetTimeStamp() const { return fTimeStamp; }
+    double GetTimeStamp() const { return fTimeStamp; }
     plMessage& SetTimeStamp(double t) { fTimeStamp = t; return *this; }
 
     hsBool HasBCastFlag(uint32_t f) const { return 0 != (fBCastFlags & f); }
     plMessage& SetBCastFlag(uint32_t f, hsBool on=true) { if( on )fBCastFlags |= f; else fBCastFlags &= ~f; return *this; }
-    
+
     void SetAllBCastFlags(uint32_t f) { fBCastFlags=f; }
     uint32_t GetAllBCastFlags() const { return fBCastFlags; }
 
diff --git a/Sources/Plasma/NucleusLib/pnModifier/plLogicModBase.cpp b/Sources/Plasma/NucleusLib/pnModifier/plLogicModBase.cpp
index a28ef3d6..064e09ad 100644
--- a/Sources/Plasma/NucleusLib/pnModifier/plLogicModBase.cpp
+++ b/Sources/Plasma/NucleusLib/pnModifier/plLogicModBase.cpp
@@ -141,11 +141,10 @@ hsBool plLogicModBase::MsgReceive(plMessage* msg)
         hsAssert(pSMsg->GetType() != plServerReplyMsg::kUnInit, "uninit server reply msg");
 
 #if 1
-        char str[256];
-        sprintf(str, "LM: LogicModifier %s recvd trigger request reply:%s, wasRequesting=%d, t=%f\n", GetKeyName(),
+        plNetClientApp::GetInstance()->DebugMsg("LM: LogicModifier %s recvd trigger request reply:%s, wasRequesting=%d, t=%f\n",
+            GetKeyName().c_str(),
             pSMsg->GetType() == plServerReplyMsg::kDeny ? "denied" : "confirmed", 
             HasFlag(kRequestingTrigger), hsTimer::GetSysSeconds());
-        plNetClientApp::GetInstance()->DebugMsg(str);
 #endif
 
         if (pSMsg->GetType() == plServerReplyMsg::kDeny)
@@ -191,21 +190,17 @@ void plLogicModBase::RequestTrigger(hsBool netRequest)
     if (HasFlag(kTriggered))
     {
 #if 1
-        char str[256];
-        sprintf(str, "LM: %s ignoring RequestTrigger(), already triggered, t=%f\n", GetKeyName(),
-            hsTimer::GetSysSeconds());
-        plNetClientApp::GetInstance()->DebugMsg(str);
+        plNetClientApp::GetInstance()->DebugMsg("LM: %s ignoring RequestTrigger(), already triggered, t=%f\n",
+            GetKeyName().c_str(), hsTimer::GetSysSeconds());
 #endif
         return;
     }
-    
+
     if (HasFlag(kRequestingTrigger))
     {
 #if 1
-        char str[256];
-        sprintf(str, "LM: %s ignoring RequestTrigger(), already requesting trigger, t=%f\n", GetKeyName(),
-            hsTimer::GetSysSeconds());
-        plNetClientApp::GetInstance()->DebugMsg(str);
+        plNetClientApp::GetInstance()->DebugMsg("LM: %s ignoring RequestTrigger(), already requesting trigger, t=%f\n",
+            GetKeyName().c_str(), hsTimer::GetSysSeconds());
 #endif
 
         return;
@@ -220,9 +215,8 @@ void plLogicModBase::RequestTrigger(hsBool netRequest)
         SetFlag(kRequestingTrigger);
 
 #if 1
-        char str[256];
-        sprintf(str, "LM: %s Setting RequestingTriggert=%f\n", GetKeyName(), hsTimer::GetSysSeconds());
-        plNetClientApp::GetInstance()->DebugMsg(str);
+        plNetClientApp::GetInstance()->DebugMsg("LM: %s Setting RequestingTriggert=%f\n",
+            GetKeyName().c_str(), hsTimer::GetSysSeconds());
 #endif
 
     }
@@ -256,12 +250,10 @@ void plLogicModBase::PreTrigger(hsBool netRequest)
 void plLogicModBase::Trigger(hsBool netRequest)
 {
 #if 1
-    char str[256];
-    sprintf(str, "LogicModifier %s is triggering, activatorType=%d\n", 
-        GetKeyName(), HasFlag(kTypeActivator));
-    plNetClientApp::GetInstance()->DebugMsg(str);
+    plNetClientApp::GetInstance()->DebugMsg("LogicModifier %s is triggering, activatorType=%d\n",
+        GetKeyName().c_str(), HasFlag(kTypeActivator));
 #endif
-    
+
     ClearFlag(kRequestingTrigger);
     if (!HasFlag(kMultiTrigger))
         SetFlag(kTriggered);
diff --git a/Sources/Plasma/NucleusLib/pnNetCommon/plNetServers.h b/Sources/Plasma/NucleusLib/pnNetCommon/plNetServers.h
index c742822d..97baf1af 100644
--- a/Sources/Plasma/NucleusLib/pnNetCommon/plNetServers.h
+++ b/Sources/Plasma/NucleusLib/pnNetCommon/plNetServers.h
@@ -102,8 +102,8 @@ class plNetServerAgentConstants
 {
 public:
     static const char* GetName() { return "Server_Agent"; }
-    static const uint16_t GetPort() { return 4800; }
-    static const plNetServerConstants::ServerTypes GetType() { return plNetServerConstants::kAgent; }
+    static uint16_t GetPort() { return 4800; }
+    static plNetServerConstants::ServerTypes GetType() { return plNetServerConstants::kAgent; }
 };
 
 
@@ -111,8 +111,8 @@ class plNetLookupServerConstants
 {
 public:
     static const char* GetName() { return "Lookup_Server"; }
-    static const uint16_t GetPort() { return 2000; }
-    static const plNetServerConstants::ServerTypes GetType() { return plNetServerConstants::kLookup; }
+    static uint16_t GetPort() { return 2000; }
+    static plNetServerConstants::ServerTypes GetType() { return plNetServerConstants::kLookup; }
 };
 
 
@@ -120,8 +120,8 @@ class plNetLobbyServerConstants
 {
 public:
     static const char* GetName() { return "Generated_Lobby"; }
-    static const uint16_t GetPort() { return 5000; }
-    static const plNetServerConstants::ServerTypes GetType() { return plNetServerConstants::kLobby; }
+    static uint16_t GetPort() { return 5000; }
+    static plNetServerConstants::ServerTypes GetType() { return plNetServerConstants::kLobby; }
 };
 
 
@@ -129,8 +129,8 @@ class plNetVaultServerConstants
 {
 public:
     static const char* GetName() { return "Vault_Server"; }
-    static const uint16_t GetPort() { return 2001; }
-    static const plNetServerConstants::ServerTypes GetType() { return plNetServerConstants::kVault; }
+    static uint16_t GetPort() { return 2001; }
+    static plNetServerConstants::ServerTypes GetType() { return plNetServerConstants::kVault; }
 };
 
 
@@ -138,8 +138,8 @@ class plNetAuthServerConstants
 {
 public:
     static const char* GetName() { return "Auth_Server"; }
-    static const uint16_t GetPort() { return 2002; }
-    static const plNetServerConstants::ServerTypes GetType() { return plNetServerConstants::kAuth; }
+    static uint16_t GetPort() { return 2002; }
+    static plNetServerConstants::ServerTypes GetType() { return plNetServerConstants::kAuth; }
 };
 
 
@@ -147,17 +147,17 @@ class plNetAdminServerConstants
 {
 public:
     static const char* GetName() { return "Admin_Server"; }
-    static const uint16_t GetPort() { return 2003; }
-    static const plNetServerConstants::ServerTypes GetType() { return plNetServerConstants::kAdmin; }
+    static uint16_t GetPort() { return 2003; }
+    static plNetServerConstants::ServerTypes GetType() { return plNetServerConstants::kAdmin; }
 };
 
 class plNetGameServerConstants
 {
 public:
     static const char* GetName() { return "Game_Server"; }
-    static const uint16_t GetLowPort() { return 5001;}
-    static const uint16_t GetHighPort() { return 6001;}
-    static const plNetServerConstants::ServerTypes GetType() { return plNetServerConstants::kGame; }
+    static uint16_t GetLowPort() { return 5001;}
+    static uint16_t GetHighPort() { return 6001;}
+    static plNetServerConstants::ServerTypes GetType() { return plNetServerConstants::kGame; }
 };
 
 
diff --git a/Sources/Plasma/NucleusLib/pnUUID/pnUUID_Unix.cpp b/Sources/Plasma/NucleusLib/pnUUID/pnUUID_Unix.cpp
index 61856b50..40753af6 100644
--- a/Sources/Plasma/NucleusLib/pnUUID/pnUUID_Unix.cpp
+++ b/Sources/Plasma/NucleusLib/pnUUID/pnUUID_Unix.cpp
@@ -106,13 +106,13 @@ bool plUUID::FromString( const char * str )
     return true;
 }
 
-bool plUUID::ToStdString( std::string & out ) const
+bool plUUID::ToString( plString & out ) const
 {
     uuid_t g;
     plUUIDHelper::CopyToNative( g, this );
     char buf[40];
     uuid_unparse( g, buf );
-    out = buf;
+    out = _TEMP_CONVERT_FROM_LITERAL( buf );
     return true;
 }
 
diff --git a/Sources/Plasma/PubUtilLib/plAgeDescription/plAgeDescription.h b/Sources/Plasma/PubUtilLib/plAgeDescription/plAgeDescription.h
index 5858c4e4..7e753b21 100644
--- a/Sources/Plasma/PubUtilLib/plAgeDescription/plAgeDescription.h
+++ b/Sources/Plasma/PubUtilLib/plAgeDescription/plAgeDescription.h
@@ -135,7 +135,7 @@ public:
     bool ReadFromFile( const char *fileNameToReadFrom ) ;
     void Read(hsStream* stream);
     void Write(hsStream* stream) const;
-    
+
     // Overload for plInitSectionTokenReader
     virtual const char  *GetSectionName( void ) const;
 
diff --git a/Sources/Plasma/PubUtilLib/plAgeLoader/plAgeLoaderPaging.cpp b/Sources/Plasma/PubUtilLib/plAgeLoader/plAgeLoaderPaging.cpp
index deb0a3d4..0f209580 100644
--- a/Sources/Plasma/PubUtilLib/plAgeLoader/plAgeLoaderPaging.cpp
+++ b/Sources/Plasma/PubUtilLib/plAgeLoader/plAgeLoaderPaging.cpp
@@ -79,7 +79,7 @@ bool ReportRoomToServer(const plKey &key)
     
     if (skip)
         hsLogEntry(plNetApp::StaticDebugMsg("Not reporting room %s to server, reserved=%d, virtual=%d", 
-            key->GetName(), keyLoc.IsReserved(), keyLoc.IsVirtual()));
+            key->GetName().c_str(), keyLoc.IsReserved(), keyLoc.IsVirtual()));
     
     return !skip;
 }
@@ -110,7 +110,7 @@ void plAgeLoader::FinishedPagingInRoom(plKey* rmKey, int numRms)
             continue;
 
         pagingMsg->AddRoom(key);        
-        hsLogEntry(nc->DebugMsg("\tSending PageIn/RequestState msg, room=%s\n", key->GetName()));
+        hsLogEntry(nc->DebugMsg("\tSending PageIn/RequestState msg, room=%s\n", key->GetName().c_str()));
     }
     if( pagingMsg->GetNumRooms() > 0 )  // all rooms were reserved
     {
@@ -148,7 +148,7 @@ void plAgeLoader::FinishedPagingOutRoom(plKey* rmKey, int numRms)
         if( found != fPendingPageOuts.end() )
         {
             fPendingPageOuts.erase( found );
-            nc->DebugMsg("Finished paging out room %s", rmKey[i]->GetName());
+            nc->DebugMsg("Finished paging out room %s", rmKey[i]->GetName().c_str());
         }
     }
 
@@ -179,7 +179,7 @@ void plAgeLoader::StartPagingOutRoom(plKey* rmKey, int numRms)
             continue;
     
         pagingMsg.AddRoom(rmKey[i]);
-        nc->DebugMsg("\tSending PageOut msg, room=%s", rmKey[i]->GetName());
+        nc->DebugMsg("\tSending PageOut msg, room=%s", rmKey[i]->GetName().c_str());
     }
 
     if (!pagingMsg.GetNumRooms())   // all rooms were reserved
@@ -205,7 +205,7 @@ void plAgeLoader::IgnorePagingOutRoom(plKey* rmKey, int numRms)
         if( found != fPendingPageOuts.end() )
         {
             fPendingPageOuts.erase( found );
-            nc->DebugMsg("Ignoring paged out room %s", rmKey[i]->GetName());
+            nc->DebugMsg("Ignoring paged out room %s", rmKey[i]->GetName().c_str());
         }
     }
 
diff --git a/Sources/Plasma/PubUtilLib/plAudible/plWinAudible.cpp b/Sources/Plasma/PubUtilLib/plAudible/plWinAudible.cpp
index 07d4cf71..52e10efe 100644
--- a/Sources/Plasma/PubUtilLib/plAudible/plWinAudible.cpp
+++ b/Sources/Plasma/PubUtilLib/plAudible/plWinAudible.cpp
@@ -421,7 +421,8 @@ void plWinAudible::SetFilename(int index, const char *filename, hsBool isCompres
     }
     else
     {
-        plStatusLog::AddLineS("audio.log", "Cannot set filename of non-streaming sound. %s", fSoundObjs[ index ]->GetKeyName());
+        plStatusLog::AddLineS("audio.log", "Cannot set filename of non-streaming sound. %s",
+                              fSoundObjs[ index ]->GetKeyName().c_str());
     }
 }
 
diff --git a/Sources/Plasma/PubUtilLib/plAudio/plAudioSystem.cpp b/Sources/Plasma/PubUtilLib/plAudio/plAudioSystem.cpp
index 6ed7adbb..7c992a42 100644
--- a/Sources/Plasma/PubUtilLib/plAudio/plAudioSystem.cpp
+++ b/Sources/Plasma/PubUtilLib/plAudio/plAudioSystem.cpp
@@ -798,7 +798,7 @@ void    plAudioSystem::IUpdateSoftSounds( const hsPoint3 &newPosition )
                 sortedList->fRank, 
                 sound->GetVolume() ? sound->GetVolumeRank() / sound->GetVolume() : 0, 
                 sound->GetEAXSettings().GetCurrSofts().GetOcclusion(), 
-                sound->GetKeyName()
+                sound->GetKeyName().c_str()
             );
         }
         else 
@@ -809,7 +809,7 @@ void    plAudioSystem::IUpdateSoftSounds( const hsPoint3 &newPosition )
                 sound->GetPriority(), 
                 sortedList->fRank, 
                 sound->GetVolume() ? sound->GetVolumeRank() / sound->GetVolume() : 0, 
-                sound->GetKeyName()
+                sound->GetKeyName().c_str()
             );
         }
         i++;
@@ -833,7 +833,7 @@ void    plAudioSystem::IUpdateSoftSounds( const hsPoint3 &newPosition )
             "%d %1.2f %s", 
             sound->GetPriority(), 
             sound->GetVolume() ? sound->GetVolumeRank() / sound->GetVolume() : 0, 
-            sound->GetKeyName()
+            sound->GetKeyName().c_str()
         );
     }
     
diff --git a/Sources/Plasma/PubUtilLib/plAudio/plSound.cpp b/Sources/Plasma/PubUtilLib/plAudio/plSound.cpp
index 6d019be9..4011462e 100644
--- a/Sources/Plasma/PubUtilLib/plAudio/plSound.cpp
+++ b/Sources/Plasma/PubUtilLib/plAudio/plSound.cpp
@@ -590,7 +590,7 @@ void plSound::IStartFade( plFadeParams *params, float offsetIntoFade )
         fFadeInParams.fVolStart = fCurrVolume;  // Hopefully, we got to fFadedVolume, but maybe not
         fFadeInParams.fVolEnd = fDesiredVol;
         fCurrFadeParams = &fFadeInParams;
-        plStatusLog::AddLineS("audio.log", "Fading in %s", GetKeyName());
+        plStatusLog::AddLineS("audio.log", "Fading in %s", GetKeyName().c_str());
     }
     else
         fCurrFadeParams = params;
@@ -809,7 +809,7 @@ bool plSound::ILoadDataBuffer( void )
         if(!buffer)
         {
             hsAssert(false, "unable to load sound buffer");
-            plStatusLog::AddLineS("audio.log", "Unable to load sound buffer: %s", GetKeyName());
+            plStatusLog::AddLineS("audio.log", "Unable to load sound buffer: %s", GetKeyName().c_str());
             return false;
         }
         SetLength( buffer->GetDataLengthInSecs() );
diff --git a/Sources/Plasma/PubUtilLib/plAudio/plWin32GroupedSound.cpp b/Sources/Plasma/PubUtilLib/plAudio/plWin32GroupedSound.cpp
index e7f3bb6c..1569daa3 100644
--- a/Sources/Plasma/PubUtilLib/plAudio/plWin32GroupedSound.cpp
+++ b/Sources/Plasma/PubUtilLib/plAudio/plWin32GroupedSound.cpp
@@ -241,7 +241,7 @@ hsBool  plWin32GroupedSound::LoadSound( hsBool is3D )
     if( GetKey() != nil && GetKeyName().Find( "Footstep" ) >= 0 )
         ;
     else
-        plStatusLog::AddLineS( "audioTimes.log", "%s (%s)", str, GetKey() ? GetKeyName().c_str() : "unkeyed" );
+        plStatusLog::AddLineS( "audioTimes.log", "%s (%s)", str.c_str(), GetKey() ? GetKeyName().c_str() : "unkeyed" );
 
     fTotalBytes = bufferSize;
 
diff --git a/Sources/Plasma/PubUtilLib/plAudio/plWin32Sound.cpp b/Sources/Plasma/PubUtilLib/plAudio/plWin32Sound.cpp
index e25190ff..8afeb6c6 100644
--- a/Sources/Plasma/PubUtilLib/plAudio/plWin32Sound.cpp
+++ b/Sources/Plasma/PubUtilLib/plAudio/plWin32Sound.cpp
@@ -159,7 +159,7 @@ void plWin32Sound::IActuallyStop()
                 --fIncidentalsPlaying;
             }
             fDSoundBuffer->Stop();
-            plStatusLog::AddLineS("impacts.log", "Stopping %s", GetKeyName());
+            plStatusLog::AddLineS("impacts.log", "Stopping %s", GetKeyName().c_str());
         
         }
         fReallyPlaying = false;
diff --git a/Sources/Plasma/PubUtilLib/plAudio/plWin32StaticSound.cpp b/Sources/Plasma/PubUtilLib/plAudio/plWin32StaticSound.cpp
index 527a02fd..ee60463a 100644
--- a/Sources/Plasma/PubUtilLib/plAudio/plWin32StaticSound.cpp
+++ b/Sources/Plasma/PubUtilLib/plAudio/plWin32StaticSound.cpp
@@ -169,15 +169,15 @@ hsBool plWin32StaticSound::LoadSound( hsBool is3D )
         {
             delete fDSoundBuffer;
             fDSoundBuffer = nil;
-            plStatusLog::AddLineS("audio.log", "Could not play static sound, no voices left %s", GetKeyName());
+            plStatusLog::AddLineS("audio.log", "Could not play static sound, no voices left %s", GetKeyName().c_str());
             return false;
         }
-        
+
         plProfile_EndTiming( StaticSndShoveTime );
         IRefreshEAXSettings( true );
 
         fTotalBytes = bufferSize;
-        
+
         plProfile_NewMem(MemSounds, fTotalBytes);
 
         // get pertinent info
diff --git a/Sources/Plasma/PubUtilLib/plAudio/plWin32StreamingSound.cpp b/Sources/Plasma/PubUtilLib/plAudio/plWin32StreamingSound.cpp
index 3d22d128..dec0046d 100644
--- a/Sources/Plasma/PubUtilLib/plAudio/plWin32StreamingSound.cpp
+++ b/Sources/Plasma/PubUtilLib/plAudio/plWin32StreamingSound.cpp
@@ -208,13 +208,13 @@ plSoundBuffer::ELoadReturnVal plWin32StreamingSound::IPreLoadBuffer( hsBool play
 
         sprintf( str, "   Readied file %s for streaming", fSrcFilename );
         IPrintDbgMessage( str );
-        
+
         // dont free sound data until we have a chance to use it in load sound
 
         return fDataStream ? plSoundBuffer::kSuccess : plSoundBuffer::kError;
     }
-        
-    plStatusLog::AddLineS("audio.log", "EnsureLoadable failed for streaming sound %d", fDataBufferKey->GetName());
+
+    plStatusLog::AddLineS("audio.log", "EnsureLoadable failed for streaming sound %d", fDataBufferKey->GetName().c_str());
     return plSoundBuffer::kError;
 }
 
@@ -263,9 +263,9 @@ hsBool plWin32StreamingSound::LoadSound( hsBool is3D )
 
     if( retVal == plSoundBuffer::kError )
     {
-        char str[ 256 ];
-        sprintf( str, "Unable to open streaming source %s", fDataBufferKey->GetName() );
-        IPrintDbgMessage( str, true );
+        plString str = plString::Format( "Unable to open streaming source %s",
+                                         fDataBufferKey->GetName().c_str() );
+        IPrintDbgMessage( str.c_str(), true );
         fFailed = true;
         return false;
     }
@@ -349,7 +349,7 @@ hsBool plWin32StreamingSound::LoadSound( hsBool is3D )
         delete fDSoundBuffer;
         fDSoundBuffer = nil;
 
-        plStatusLog::AddLineS("audio.log", "Could not play streaming sound, no voices left %s", GetKeyName());
+        plStatusLog::AddLineS("audio.log", "Could not play streaming sound, no voices left %s", GetKeyName().c_str());
         return false;
     }
     FreeSoundData();
@@ -361,7 +361,8 @@ hsBool plWin32StreamingSound::LoadSound( hsBool is3D )
     sprintf( str, "   Streaming %s.", fSrcFilename);
     IPrintDbgMessage( str );
 
-    plStatusLog::AddLineS( "audioTimes.log", 0xffffffff, "Streaming %4.2f secs of %s", fDataStream->GetLengthInSecs(), GetKey()->GetUoid().GetObjectName() );
+    plStatusLog::AddLineS( "audioTimes.log", 0xffffffff, "Streaming %4.2f secs of %s",
+                           fDataStream->GetLengthInSecs(), GetKey()->GetUoid().GetObjectName().c_str() );
 
     // Get pertinent info
     SetLength( (float)fDataStream->GetLengthInSecs() );
@@ -401,10 +402,10 @@ void plWin32StreamingSound::IStreamUpdate()
             }
             return;
         }
-        
+
         if(!fDSoundBuffer->StreamingFillBuffer(fDataStream))
         {
-            plStatusLog::AddLineS("audio.log", "%s Streaming buffer fill failed", GetKeyName());
+            plStatusLog::AddLineS("audio.log", "%s Streaming buffer fill failed", GetKeyName().c_str());
         }
     }
     plProfile_EndTiming( StreamSndShoveTime );
diff --git a/Sources/Plasma/PubUtilLib/plAudioCore/plAudioFileReader.cpp b/Sources/Plasma/PubUtilLib/plAudioCore/plAudioFileReader.cpp
index 514fd583..d175f66c 100644
--- a/Sources/Plasma/PubUtilLib/plAudioCore/plAudioFileReader.cpp
+++ b/Sources/Plasma/PubUtilLib/plAudioCore/plAudioFileReader.cpp
@@ -66,16 +66,6 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 
 #define kCacheDirName   "temp"
 
-static void hsStrUpper(char *s)
-{
-    if (s)
-    {
-        int len = hsStrlen(s);
-        for (int i = 0; i < len; i++)
-            s[i] = toupper(s[i]); 
-    }
-}
-
 plAudioFileReader* plAudioFileReader::CreateReader(const char* path, plAudioCore::ChannelSelect whichChan, StreamType type)
 {
     const char* ext = plFileUtils::GetFileExt(path);
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAGMasterMod.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plAGMasterMod.cpp
index f97c87c4..f2295e25 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAGMasterMod.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAGMasterMod.cpp
@@ -312,7 +312,7 @@ void plAGMasterMod::DumpAniGraph(const char *justThisChannel, bool optimized, do
                     plMatrixChannel *topChannel = plMatrixChannel::ConvertNoRef(channel);
                     if(topChannel)
                     {
-                        hsStatusMessageF("AGModifier: <%s>", mod->GetChannelName());
+                        hsStatusMessageF("AGModifier: <%s>", mod->GetChannelName().c_str());
                         topChannel->Dump(1, optimized, time);
                     }
                 }
@@ -718,7 +718,7 @@ hsBool plAGMasterMod::MsgReceive(plMessage* msg)
                 if (genRefMsg->fType == kPrivateAnim)
                 {
                     plAnimVector::iterator i = fPrivateAnims.begin();
-                    for (i; i != fPrivateAnims.end(); i++)
+                    for ( ; i != fPrivateAnims.end(); i++)
                     {
                         plAGAnim *currAnim = *i;
 
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plArmatureMod.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plArmatureMod.cpp
index c5d0154e..070a1c0e 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plArmatureMod.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plArmatureMod.cpp
@@ -2652,7 +2652,7 @@ int plArmatureMod::RefreshDebugDisplay()
 
 void plArmatureMod::DumpToDebugDisplay(int &x, int &y, int lineHeight, char *strBuf, plDebugText &debugTxt)
 {
-    sprintf(strBuf, "Armature <%s>:", fRootName);
+    sprintf(strBuf, "Armature <%s>:", fRootName.c_str());
     debugTxt.DrawString(x, y, strBuf, 255, 128, 128);
     y += lineHeight;
 
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAvLadderModifier.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plAvLadderModifier.cpp
index 444991c4..dd25ac55 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAvLadderModifier.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAvLadderModifier.cpp
@@ -135,7 +135,8 @@ bool plAvLadderMod::IIsReadyToClimb()
 
         if (dot >= kTolerance && movingForward)
         {
-            DetectorLogSpecial("%s: Ladder starting climb (%f)", GetKeyName(), hsRadiansToDegrees(acos(dot)));
+            DetectorLogSpecial("%s: Ladder starting climb (%f)",
+                               GetKeyName().c_str(), hsRadiansToDegrees(acos(dot)));
             return true;
         }
         else if (movingForward)
@@ -179,7 +180,7 @@ hsBool plAvLadderMod::MsgReceive(plMessage* msg)
         // we can check every frame
         if (fAvatarInBox)
         {
-            DetectorLogSpecial("%s: Avatar entered ladder region", GetKeyName());
+            DetectorLogSpecial("%s: Avatar entered ladder region", GetKeyName().c_str());
 
             if (IIsReadyToClimb())
                 ITriggerSelf(collMsg->fOtherKey);
@@ -188,7 +189,7 @@ hsBool plAvLadderMod::MsgReceive(plMessage* msg)
         }
         else
         {
-            DetectorLogSpecial("%s: Avatar exited ladder region", GetKeyName());
+            DetectorLogSpecial("%s: Avatar exited ladder region", GetKeyName().c_str());
 
             plgDispatch::Dispatch()->UnRegisterForExactType(plEvalMsg::Index(), GetKey());
         }
@@ -215,7 +216,7 @@ hsBool plAvLadderMod::MsgReceive(plMessage* msg)
         }
         else if (notifyMsg->fID == kNotifyAvatarOnLadder)
         {
-            DetectorLogSpecial("%s: Avatar mounted ladder", GetKeyName());
+            DetectorLogSpecial("%s: Avatar mounted ladder", GetKeyName().c_str());
             fAvatarMounting = false;
         }
 
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plAvatarMgr.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plAvatarMgr.cpp
index 62a0eb18..07e4e982 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plAvatarMgr.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plAvatarMgr.cpp
@@ -605,7 +605,7 @@ void plAvatarMgr::AddOneShot(plOneShotMod *oneshot)
     {
         plString name = oneshot->GetTarget(0)->GetKey()->GetName();
         plOneShotMod *alreadyThere = FindOneShot(name);
-        
+
 
         if ( ! alreadyThere)
         {
@@ -621,14 +621,14 @@ void plAvatarMgr::RemoveOneShot(plOneShotMod *oneshot)
 
     while (i != fOneShots.end())
     {
-        plString name = (*i).first;
-        plOneShotMod *thisOneshot = (*i).second;
+        plString name = i->first;
+        plOneShotMod *thisOneshot = i->second;
 
         if(oneshot == thisOneshot)
         {
-            i = fOneShots.erase(i);
+            fOneShots.erase(i++);
         } else {
-            i++;
+            ++i;
         }
     }
 }
@@ -637,12 +637,12 @@ void plAvatarMgr::RemoveOneShot(plOneShotMod *oneshot)
 plOneShotMod *plAvatarMgr::FindOneShot(const plString &name)
 {
     plOneShotMap::iterator found = fOneShots.find(name);
-    
+
     if (found == fOneShots.end())
     {
         return nil;
     } else {
-        return (*found).second;
+        return found->second;
     }
 }
 
diff --git a/Sources/Plasma/PubUtilLib/plAvatar/plMatrixChannel.cpp b/Sources/Plasma/PubUtilLib/plAvatar/plMatrixChannel.cpp
index e01d7457..c28ae41e 100644
--- a/Sources/Plasma/PubUtilLib/plAvatar/plMatrixChannel.cpp
+++ b/Sources/Plasma/PubUtilLib/plAvatar/plMatrixChannel.cpp
@@ -170,7 +170,7 @@ void plMatrixChannel::Dump(int indent, bool optimized, double time)
     {
         indentStr += "- ";
     }
-    hsStatusMessageF("%s matChan<%s>", indentStr.c_str(), fName);
+    hsStatusMessageF("%s matChan<%s>", indentStr.c_str(), fName.c_str());
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
@@ -300,9 +300,9 @@ void plMatrixTimeScale::Dump(int indent, bool optimized, double time)
     {
         indentStr += "- ";
     }
-    hsStatusMessageF("%s matTimeScale <%s> at time <%f>", indentStr.c_str(), fName, fTimeSource->Value(time, true));
+    hsStatusMessageF("%s matTimeScale <%s> at time <%f>", indentStr.c_str(), fName.c_str(), fTimeSource->Value(time, true));
     fChannelIn->Dump(indent + 1, optimized, time);
-    
+
 }
 
 
@@ -470,7 +470,7 @@ void plMatrixBlend::Dump(int indent, bool optimized, double time)
     {
         indentStr += "- ";
     }
-    hsStatusMessageF("%s matBlend<%s>, bias:<%f>", indentStr.c_str(), fName, fChannelBias->Value(time, true));
+    hsStatusMessageF("%s matBlend<%s>, bias:<%f>", indentStr.c_str(), fName.c_str(), fChannelBias->Value(time, true));
     if(optimized)
     {
         fOptimizedB->Dump(indent + 1, optimized, time);
@@ -569,7 +569,7 @@ void plMatrixControllerChannel::Dump(int indent, bool optimized, double time)
     {
         indentStr += "- ";
     }
-    hsStatusMessageF("%s MatController<%s>", indentStr.c_str(), fName);
+    hsStatusMessageF("%s MatController<%s>", indentStr.c_str(), fName.c_str());
 }
 
 // Write -------------------------------------------------------------
diff --git a/Sources/Plasma/PubUtilLib/plDrawable/plCluster.h b/Sources/Plasma/PubUtilLib/plDrawable/plCluster.h
index e62bf5f8..c264f0cf 100644
--- a/Sources/Plasma/PubUtilLib/plDrawable/plCluster.h
+++ b/Sources/Plasma/PubUtilLib/plDrawable/plCluster.h
@@ -102,7 +102,7 @@ public:
     const hsBitVector& GetVisSet() const { return fGroup->GetVisSet(); }
     const hsBitVector& GetVisNot() const { return fGroup->GetVisNot(); }
 
-    const hsTArray<plLightInfo*>& GetLights() const { fGroup->GetLights(); }
+    const hsTArray<plLightInfo*>& GetLights() const { return fGroup->GetLights(); }
 
     const plLODDist& GetLOD() const { return fGroup->GetLOD(); }
 };
diff --git a/Sources/Plasma/PubUtilLib/plDrawable/plDrawableSpans.h b/Sources/Plasma/PubUtilLib/plDrawable/plDrawableSpans.h
index 7ebde71c..f83ce1f3 100644
--- a/Sources/Plasma/PubUtilLib/plDrawable/plDrawableSpans.h
+++ b/Sources/Plasma/PubUtilLib/plDrawable/plDrawableSpans.h
@@ -280,7 +280,7 @@ class plDrawableSpans : public plDrawable
 
         virtual const plSpan                *GetSpan( uint32_t index ) const { return fSpans[ index ]; }
         virtual const plSpan                *GetSpan( uint32_t diIndex, uint32_t index ) const { return fSpans[ (*fDIIndices[ diIndex ])[ index ] ]; }
-        virtual const uint32_t                GetNumSpans( void ) const { return fSpans.GetCount(); }
+        virtual uint32_t                     GetNumSpans( void ) const { return fSpans.GetCount(); }
         virtual const hsTArray<plSpan *>    &GetSpanArray( void ) const { return fSpans; }
 
         hsMatrix44* GetMatrixPalette(int baseMatrix) const { return &fLocalToWorlds[baseMatrix]; }
@@ -294,7 +294,7 @@ class plDrawableSpans : public plDrawable
 
         // BufferGroups accessed only by Pipeline and it's close personal acquaintances.
         plGBufferGroup*                         GetBufferGroup(uint32_t i) const { return fGroups[i]; }
-        uint32_t                                  GetNumBufferGroups() const { return fGroups.GetCount(); }
+        uint32_t                                GetNumBufferGroups() const { return fGroups.GetCount(); }
         const hsTArray<plGeometrySpan*>&        GetSourceSpans() const { return fSourceSpans; }
 
         void            DirtyVertexBuffer(uint32_t group, uint32_t idx);
diff --git a/Sources/Plasma/PubUtilLib/plDrawable/plDynaDecalMgr.cpp b/Sources/Plasma/PubUtilLib/plDrawable/plDynaDecalMgr.cpp
index a49ed294..380f79a5 100644
--- a/Sources/Plasma/PubUtilLib/plDrawable/plDynaDecalMgr.cpp
+++ b/Sources/Plasma/PubUtilLib/plDrawable/plDynaDecalMgr.cpp
@@ -737,7 +737,7 @@ void plDynaDecalMgr::IAllocAuxSpan(plAuxSpan* aux, uint32_t maxNumVerts, uint32_
 
     uint16_t* dataPtr = nil;
     grp->ReserveIndexStorage(maxNumIdx, &aux->fIBufferIdx, &aux->fIStartIdx, &dataPtr);
-    aux->fIStartIdx;
+    aux->fIStartIdx /* should be assigning something? */;
 
     aux->fILength = 0;
 
diff --git a/Sources/Plasma/PubUtilLib/plDrawable/plWaveSet7.cpp b/Sources/Plasma/PubUtilLib/plDrawable/plWaveSet7.cpp
index e24c137a..9c234414 100644
--- a/Sources/Plasma/PubUtilLib/plDrawable/plWaveSet7.cpp
+++ b/Sources/Plasma/PubUtilLib/plDrawable/plWaveSet7.cpp
@@ -1806,7 +1806,7 @@ hsGMaterial* plWaveSet7::ICreateBumpLayersPS()
 
     // Create a blank material
     hsGMaterial* bumpMat = new hsGMaterial;
-    plString buff = plString::Format("%s_BumpMatPS", GetKey()->GetName());
+    plString buff = plString::Format("%s_BumpMatPS", GetKey()->GetName().c_str());
     hsgResMgr::ResMgr()->NewKey(buff, bumpMat, GetKey()->GetUoid().GetLocation());
 
     plMipmap* mipMap = ICreateBumpMipmapPS();
diff --git a/Sources/Plasma/PubUtilLib/plFile/plFileUtils.cpp b/Sources/Plasma/PubUtilLib/plFile/plFileUtils.cpp
index 55240ee3..4920c953 100644
--- a/Sources/Plasma/PubUtilLib/plFile/plFileUtils.cpp
+++ b/Sources/Plasma/PubUtilLib/plFile/plFileUtils.cpp
@@ -520,7 +520,7 @@ bool plFileUtils::GetSecureEncryptionKey(const wchar_t* filename, uint32_t* key,
     std::wstring sFilename = filename;
 
     // grab parent directory
-    unsigned loc = sFilename.rfind(L"\\");
+    size_t loc = sFilename.rfind(L"\\");
     if (loc == std::wstring::npos)
         loc = sFilename.rfind(L"/");
 
diff --git a/Sources/Plasma/PubUtilLib/plGLight/plLightKonstants.h b/Sources/Plasma/PubUtilLib/plGLight/plLightKonstants.h
index 1e842fe1..80206a45 100644
--- a/Sources/Plasma/PubUtilLib/plGLight/plLightKonstants.h
+++ b/Sources/Plasma/PubUtilLib/plGLight/plLightKonstants.h
@@ -46,7 +46,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 class plSillyLightKonstants
 {
 public:
-    static const float  GetFarPowerKonst( void )
+    static float  GetFarPowerKonst( void )
     {
         // arbitrary const, make light drop to 1/kFarPower at attenEnd. 15 just looked good to me. mf
         // Done as a function so we don't have to worry about a separate .cpp file
diff --git a/Sources/Plasma/PubUtilLib/plInputCore/plInputDevice.cpp b/Sources/Plasma/PubUtilLib/plInputCore/plInputDevice.cpp
index a5a96fd3..b384ecf0 100644
--- a/Sources/Plasma/PubUtilLib/plInputCore/plInputDevice.cpp
+++ b/Sources/Plasma/PubUtilLib/plInputCore/plInputDevice.cpp
@@ -166,7 +166,7 @@ void plKeyboardDevice::HandleKeyEvent(plOSMsg message, plKeyDef key, bool bKeyDo
 {
     // update the internal keyboard state
     unsigned int keyCode = (unsigned int)key;
-    if ((key >= 0) && (key < 256))
+    if (key < 256)
         fKeyboardState[key] = bKeyDown;
 
     if (key == KEY_SHIFT)
diff --git a/Sources/Plasma/PubUtilLib/plInputCore/plSceneInputInterface.cpp b/Sources/Plasma/PubUtilLib/plInputCore/plSceneInputInterface.cpp
index cd095f80..4e254b7d 100644
--- a/Sources/Plasma/PubUtilLib/plInputCore/plSceneInputInterface.cpp
+++ b/Sources/Plasma/PubUtilLib/plInputCore/plSceneInputInterface.cpp
@@ -182,11 +182,11 @@ void plSceneInputInterface::IHalfFadeAvatar(hsBool out)
     plIfaceFadeAvatarMsg* pMsg = new plIfaceFadeAvatarMsg();
     pMsg->SetSubjectKey(plNetClientMgr::GetInstance()->GetLocalPlayerKey());
     pMsg->SetBCastFlag(plMessage::kBCastByExactType);
-    pMsg->SetBCastFlag(plMessage::kNetPropagate, FALSE);
+    pMsg->SetBCastFlag(plMessage::kNetPropagate, false);
     pMsg->SetFadeOut(out);
     pMsg->Send();
     fFadedLocalAvatar = out;
-    
+
 }
 
 
@@ -270,9 +270,9 @@ hsBool  plSceneInputInterface::MsgReceive( plMessage *msg )
                     if (fShowLOS)
                     {
                         if (pLOSMsg->fNoHit)
-                            DetectorLogSpecial("%s: LOS miss", pObj->GetKeyName());
+                            DetectorLogSpecial("%s: LOS miss", pObj->GetKeyName().c_str());
                         else
-                            DetectorLogSpecial("%s: LOS hit", pObj->GetKeyName());
+                            DetectorLogSpecial("%s: LOS hit", pObj->GetKeyName().c_str());
                     }
                     int i;
                     const plInterfaceInfoModifier* pMod = 0;
@@ -837,17 +837,17 @@ void plSceneInputInterface::ILinkOffereeToAge()
         info.SetAgeInstanceGuid(&guid);
         std::string title;
         std::string desc;
-        
+
         unsigned nameLen = plNetClientMgr::GetInstance()->GetPlayerName().GetSize();
         if (plNetClientMgr::GetInstance()->GetPlayerName().CharAt(nameLen - 1) == 's' || plNetClientMgr::GetInstance()->GetPlayerName().CharAt(nameLen - 1) == 'S') {
-            xtl::format( title, "%s'", plNetClientMgr::GetInstance()->GetPlayerName() );
-            xtl::format( desc, "%s' %s", plNetClientMgr::GetInstance()->GetPlayerName(), link.GetAgeInfo()->GetAgeInstanceName() );
+            xtl::format( title, "%s'", plNetClientMgr::GetInstance()->GetPlayerName().c_str() );
+            xtl::format( desc, "%s' %s", plNetClientMgr::GetInstance()->GetPlayerName().c_str(), link.GetAgeInfo()->GetAgeInstanceName() );
         }
         else {
-            xtl::format( title, "%s's", plNetClientMgr::GetInstance()->GetPlayerName() );
-            xtl::format( desc, "%s's %s", plNetClientMgr::GetInstance()->GetPlayerName(), link.GetAgeInfo()->GetAgeInstanceName() );
+            xtl::format( title, "%s's", plNetClientMgr::GetInstance()->GetPlayerName().c_str() );
+            xtl::format( desc, "%s's %s", plNetClientMgr::GetInstance()->GetPlayerName().c_str(), link.GetAgeInfo()->GetAgeInstanceName() );
         }
-        
+
         info.SetAgeUserDefinedName( title.c_str() );
         info.SetAgeDescription( desc.c_str() );
 
diff --git a/Sources/Plasma/PubUtilLib/plMath/plRandom.h b/Sources/Plasma/PubUtilLib/plMath/plRandom.h
index 5e51c839..177ce4c5 100644
--- a/Sources/Plasma/PubUtilLib/plMath/plRandom.h
+++ b/Sources/Plasma/PubUtilLib/plMath/plRandom.h
@@ -103,7 +103,7 @@ inline float plRandom::RandZeroToOne() const
     return Rand() * RandNorm();
 #else // FAST_Q
     const uint32_t kOneExp = 0x3f800000;
-    register uint32_t temp = kOneExp | (uint32_t(Rand()) >> 9);
+    uint32_t temp = kOneExp | (uint32_t(Rand()) >> 9);
     return (*(float*)&temp) - 1.f;
 #endif // FAST_Q
 }
@@ -117,7 +117,7 @@ inline float plRandom::RandMinusOneToOne() const
     return RandZeroToOne() * 2.f - 1.f;
 #else // FAST_Q
     const uint32_t kTwoExp = 0x40000000;
-    register uint32_t temp = kTwoExp | (uint32_t(Rand()) >> 9);
+    uint32_t temp = kTwoExp | (uint32_t(Rand()) >> 9);
     return (*(float*)&temp) - 3.f;
 #endif // FAST_Q
 }
diff --git a/Sources/Plasma/PubUtilLib/plMessage/plLoadCloneMsg.cpp b/Sources/Plasma/PubUtilLib/plMessage/plLoadCloneMsg.cpp
index 09842c4e..97dd29dd 100644
--- a/Sources/Plasma/PubUtilLib/plMessage/plLoadCloneMsg.cpp
+++ b/Sources/Plasma/PubUtilLib/plMessage/plLoadCloneMsg.cpp
@@ -89,7 +89,7 @@ plLoadCloneMsg::plLoadCloneMsg(const plUoid &uoidToClone, const plKey &requestor
             this->AddReceiver(plNetApp::GetInstance()->GetKey());
         } else {
             char buffer[128];
-            sprintf(buffer, "Can't find key named %s", uoidToClone.GetObjectName());                
+            sprintf(buffer, "Can't find key named %s", uoidToClone.GetObjectName().c_str());
             hsAssert(0, buffer);
         }
     } else {
diff --git a/Sources/Plasma/PubUtilLib/plModifier/plLogicModifier.cpp b/Sources/Plasma/PubUtilLib/plModifier/plLogicModifier.cpp
index 6c24e203..4fdf5c16 100644
--- a/Sources/Plasma/PubUtilLib/plModifier/plLogicModifier.cpp
+++ b/Sources/Plasma/PubUtilLib/plModifier/plLogicModifier.cpp
@@ -171,7 +171,7 @@ hsBool plLogicModifier::MsgReceive(plMessage* msg)
             {
                 if ( Disabled() )
                 {
-                    DetectorLogRed("%s: LogicMod is disabled", GetKeyName());
+                    DetectorLogRed("%s: LogicMod is disabled", GetKeyName().c_str());
                 }
                 else
                 {
@@ -180,11 +180,11 @@ hsBool plLogicModifier::MsgReceive(plMessage* msg)
                         if (!fConditionList[i]->Verify(msg))
                         {
                             if ( plObjectInBoxConditionalObject::ConvertNoRef(fConditionList[i]) )
-                                DetectorLogRed("%s: LogicMod InRegion conditional not met", fConditionList[i]->GetKeyName());
+                                DetectorLogRed("%s: LogicMod InRegion conditional not met", fConditionList[i]->GetKeyName().c_str());
                             else if ( plFacingConditionalObject::ConvertNoRef(fConditionList[i]) )
-                                DetectorLogRed("%s: LogicMod Facing conditional not met", fConditionList[i]->GetKeyName());
+                                DetectorLogRed("%s: LogicMod Facing conditional not met", fConditionList[i]->GetKeyName().c_str());
                             else
-                                DetectorLogRed("%s: LogicMod <unknown> conditional not met", fConditionList[i]->GetKeyName());
+                                DetectorLogRed("%s: LogicMod <unknown> conditional not met", fConditionList[i]->GetKeyName().c_str());
                         }
                     }
                 }
diff --git a/Sources/Plasma/PubUtilLib/plModifier/plResponderModifier.h b/Sources/Plasma/PubUtilLib/plModifier/plResponderModifier.h
index 5d0b57dd..9f0300bf 100644
--- a/Sources/Plasma/PubUtilLib/plModifier/plResponderModifier.h
+++ b/Sources/Plasma/PubUtilLib/plModifier/plResponderModifier.h
@@ -142,8 +142,8 @@ public:
 
     // Restore callback state after load
     void Restore();
-    
-    const int8_t GetState() const { return fCurState; }
+
+    int8_t GetState() const { return fCurState; }
     //
     // Export time only
     //
diff --git a/Sources/Plasma/PubUtilLib/plModifier/plSDLModifier.cpp b/Sources/Plasma/PubUtilLib/plModifier/plSDLModifier.cpp
index e1477e31..389a3334 100644
--- a/Sources/Plasma/PubUtilLib/plModifier/plSDLModifier.cpp
+++ b/Sources/Plasma/PubUtilLib/plModifier/plSDLModifier.cpp
@@ -178,14 +178,14 @@ void plSDLModifier::SendState(uint32_t sendFlags)
         {
             gMooseDump=true;
             plNetObjectDebugger::GetInstance()->SetDebugging(true);
-            curState->DumpToObjectDebugger(xtl::format("Object %s SENDS SDL state", 
-                GetStateOwnerKey()->GetName(), dirtyOnly).c_str());
+            curState->DumpToObjectDebugger(plString::Format("Object %s SENDS SDL state",
+                GetStateOwnerKey()->GetName().c_str(), dirtyOnly).c_str());
             gMooseDump=false;
         }
 
         // cache current state, send notifications if necessary
         fStateCache->UpdateFrom(*curState, dirtyOnly);  // update local copy of state
-        
+
         ISentState(curState);
     }
     delete curState;
@@ -197,14 +197,14 @@ void plSDLModifier::SendState(uint32_t sendFlags)
 void plSDLModifier::ReceiveState(const plStateDataRecord* srcState)
 {
     hsAssert(fStateCache, "nil stateCache");
-    
-    if (plNetObjectDebugger::GetInstance() && 
+
+    if (plNetObjectDebugger::GetInstance() &&
         plNetObjectDebugger::GetInstance()->IsDebugObject(GetStateOwnerKey()->ObjectIsLoaded()))
     {
         gMooseDump=true;
         plNetObjectDebugger::GetInstance()->SetDebugging(true);
-        srcState->DumpToObjectDebugger(xtl::format("Object %s RECVS SDL state", 
-            GetStateOwnerKey()->GetName()).c_str());
+        srcState->DumpToObjectDebugger(plString::Format("Object %s RECVS SDL state",
+            GetStateOwnerKey()->GetName().c_str()).c_str());
         gMooseDump=false;
     }
 
@@ -214,17 +214,17 @@ void plSDLModifier::ReceiveState(const plStateDataRecord* srcState)
 
         // apply incoming state
         ISetCurrentStateFrom(srcState);         // apply incoming state to sceneObj
-        
+
         // cache state, send notifications if necessary 
         fStateCache->UpdateFrom(*srcState, false);  // update local copy of state
         fSentOrRecvdState = true;
     }
     else
     {
-        plNetClientApp::GetInstance()->DebugMsg("\tReceiving and ignoring unused SDL state msg: type %s, object %s", 
-            GetSDLName(), GetStateOwnerKey()->GetName());
+        plNetClientApp::GetInstance()->DebugMsg("\tReceiving and ignoring unused SDL state msg: type %s, object %s",
+            GetSDLName(), GetStateOwnerKey()->GetName().c_str());
     }
-    
+
     if (plNetObjectDebugger::GetInstance())
         plNetObjectDebugger::GetInstance()->SetDebugging(false);
 }
diff --git a/Sources/Plasma/PubUtilLib/plNetClient/plLinkEffectsMgr.cpp b/Sources/Plasma/PubUtilLib/plNetClient/plLinkEffectsMgr.cpp
index 843a1fe1..73d8be8f 100644
--- a/Sources/Plasma/PubUtilLib/plNetClient/plLinkEffectsMgr.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetClient/plLinkEffectsMgr.cpp
@@ -324,11 +324,11 @@ hsBool plLinkEffectsMgr::MsgReceive(plMessage *msg)
                 return true;
             }
         }
-        
+
         plSceneObject *avatar = plSceneObject::ConvertNoRef(linkKey->ObjectIsLoaded());
         if (avatar == nil)
         {
-            plNetApp::GetInstance()->DebugMsg("Can't find avatar, mod=%s\n", linkKey->GetName());
+            plNetApp::GetInstance()->DebugMsg("Can't find avatar, mod=%s\n", linkKey->GetName().c_str());
             return true;
         }
 
@@ -338,7 +338,7 @@ hsBool plLinkEffectsMgr::MsgReceive(plMessage *msg)
 //          hsAssert(false, "Trying to link an Avatar already in the process of linking.");
 //          return true;
 //      }
-        
+
         if (pTriggerMsg->GetInvisLevel() && linkKey != nc->GetLocalPlayerKey())
         {
 #ifdef PLASMA_EXTERNAL_RELEASE
@@ -470,12 +470,12 @@ hsBool plLinkEffectsMgr::MsgReceive(plMessage *msg)
         else if (pTriggerMsg->fEffects < 0 )
         {
             plNetApp::GetInstance()->DebugMsg("Too many link callbacks received for avatar %s. Ignoring extras.\n",
-                    pTriggerMsg->GetLinkKey()->GetName());          
+                    pTriggerMsg->GetLinkKey()->GetName().c_str());
         }
         else
         {
             plNetApp::GetInstance()->DebugMsg("%d link callbacks left until avatar %s links...\n", 
-                     pTriggerMsg->fEffects, pTriggerMsg->GetLinkKey()->GetName());
+                     pTriggerMsg->fEffects, pTriggerMsg->GetLinkKey()->GetName().c_str());
         }
         return true;
     }
diff --git a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgr.cpp b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgr.cpp
index b9dd262c..b3a9c693 100644
--- a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgr.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgr.cpp
@@ -1333,8 +1333,8 @@ bool plNetClientMgr::IHandlePlayerPageMsg(plPlayerPageMsg *playerMsg)
         if (GetLocalPlayerKey() == playerKey)
         {
             fLocalPlayerKey = nil;
-            DebugMsg("Net: Unloading local player %s", playerKey->GetName());
-            
+            DebugMsg("Net: Unloading local player %s", playerKey->GetName().c_str());
+
             // notify server - NOTE: he might not still be around to get this...
             plNetMsgPlayerPage npp (playerKey->GetUoid(), playerMsg->fUnload);
             npp.SetNetProtocol(kNetProtocolCli2Game);
@@ -1343,7 +1343,7 @@ bool plNetClientMgr::IHandlePlayerPageMsg(plPlayerPageMsg *playerMsg)
         else if (IsRemotePlayerKey(playerKey, &idx))
         {
             fRemotePlayerKeys.erase(fRemotePlayerKeys.begin()+idx); // remove key from list
-            DebugMsg("Net: Unloading remote player %s", playerKey->GetName());
+            DebugMsg("Net: Unloading remote player %s", playerKey->GetName().c_str());
         }
     }
     else
@@ -1362,9 +1362,9 @@ bool plNetClientMgr::IHandlePlayerPageMsg(plPlayerPageMsg *playerMsg)
                     GetLocalPlayerKey() == playerKey,
                     "Different local player already loaded");
 
-                hsLogEntry(DebugMsg("Adding LOCAL player %s\n", playerKey->GetName()));
+                hsLogEntry(DebugMsg("Adding LOCAL player %s\n", playerKey->GetName().c_str()));
                 playerSO->SetNetGroupConstant(plNetGroup::kNetGroupLocalPlayer);
-                
+
                 // don't save avatar state permanently on server
                 playerSO->SetSynchFlagsBit(plSynchedObject::kAllStateIsVolatile);               
                 const plCoordinateInterface* co = playerSO->GetCoordinateInterface();
@@ -1385,7 +1385,7 @@ bool plNetClientMgr::IHandlePlayerPageMsg(plPlayerPageMsg *playerMsg)
             }
             else
             {
-                hsLogEntry(DebugMsg("Adding REMOTE player %s\n", playerKey->GetName()));
+                hsLogEntry(DebugMsg("Adding REMOTE player %s\n", playerKey->GetName().c_str()));
                 playerSO->SetNetGroupConstant(plNetGroup::kNetGroupRemotePlayer);
                 idx=fTransport.FindMember(playerMsg->fClientID);
                 if( idx != -1 )
@@ -1396,7 +1396,7 @@ bool plNetClientMgr::IHandlePlayerPageMsg(plPlayerPageMsg *playerMsg)
                 }
                 else
                 {
-                    hsLogEntry(DebugMsg("Ignoring player page msg (player not found in member list) : %s\n", playerKey->GetName()));
+                    hsLogEntry(DebugMsg("Ignoring player page msg (player not found in member list) : %s\n", playerKey->GetName().c_str()));
                 }
             }
 
diff --git a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrLoad.cpp b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrLoad.cpp
index a27fa4e6..80fb9738 100644
--- a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrLoad.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrLoad.cpp
@@ -135,7 +135,7 @@ plKey plNetClientMgr::ILoadClone(plLoadCloneMsg *pCloneMsg)
     {
         if (!cloneKey->ObjectIsLoaded())
         {
-            DebugMsg("ILoadClone: object %s is already unloaded, ignoring", cloneKey->GetName());
+            DebugMsg("ILoadClone: object %s is already unloaded, ignoring", cloneKey->GetName().c_str());
             return cloneKey;
         }
 
@@ -185,7 +185,7 @@ void plNetClientMgr::IPlayerChangeAge(hsBool exitAge, int32_t spawnPt)
     }
     else if (fLocalPlayerKey)
     {
-        ErrorMsg("Can't find avatarMod %s", fLocalPlayerKey->GetName());
+        ErrorMsg("Can't find avatarMod %s", fLocalPlayerKey->GetName().c_str());
     }
 }
 
diff --git a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrSend.cpp b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrSend.cpp
index dd8b66fb..ab0904b1 100644
--- a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrSend.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrSend.cpp
@@ -120,7 +120,7 @@ int plNetClientMgr::ISendDirtyState(double secs)
             if (localOwned==plSynchedObject::kNo)
             {
                 DebugMsg("Late rejection of queued SDL state, obj %s, sdl %s",
-                    state->fObjKey->GetName(), state->fSDLName.c_str());
+                    state->fObjKey->GetName().c_str(), state->fSDLName.c_str());
                 continue;
             }
         }
diff --git a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrShow.cpp b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrShow.cpp
index fd3f4897..98da3ac4 100644
--- a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrShow.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMgrShow.cpp
@@ -74,7 +74,7 @@ void plNetClientMgr::IShowLists()
     sprintf(str, "%s%s PlyrName=%s PlyrID=%d AcctID=%d P2P=%d Join#=%d Peers=%d %.1f,%.1f,%.1f",
         GetFlagsBit(kSendingVoice) ? "V" : " ",
         GetFlagsBit(kSendingActions) ? "A" : " ",
-        GetPlayerName(), GetPlayerID(), 0, 
+        GetPlayerName().c_str(), GetPlayerID(), 0,
         IsPeerToPeer(), GetJoinOrder(), 0,
         pos.fX, pos.fY, pos.fZ);
     txt.DrawString(x,y,str,255,255,255,255);
@@ -316,9 +316,9 @@ void plNetClientMgr::IShowAvatars()
     hsPoint3 pos = (player ? player->GetLocalToWorld() * hsPoint3(0, 0, 0) : hsPoint3(0, 0, 0));
     hsVector3 ori = (player ? player->GetLocalToWorld() * hsVector3(0, -1, 0) : hsVector3(0, 0, 0));
     sprintf(str, "%s: pos(%.2f, %.2f, %.2f) ori(%.2f, %.2f, %.2f)",
-            GetPlayerName(), pos.fX, pos.fY, pos.fZ, ori.fX, ori.fY, ori.fZ);
+            GetPlayerName().c_str(), pos.fX, pos.fY, pos.fZ, ori.fX, ori.fY, ori.fZ);
     txt.DrawString(x,y,str,255,255,255,255);
-    
+
 
     if (player)
     {
@@ -334,7 +334,7 @@ void plNetClientMgr::IShowAvatars()
                 hsPoint3 pos = (pObj ? pObj->GetLocalToWorld() * hsPoint3(0, 0, 0) : hsPoint3(0, 0, 0));
                 hsVector3 ori = (pObj ? pObj->GetLocalToWorld() * hsVector3(0, -1, 0) : hsVector3(0, 0, 0));
                 sprintf(str, "%s: pos(%.2f, %.2f, %.2f) ori(%.2f, %.2f, %.2f)",
-                        pObj->GetKeyName(), pos.fX, pos.fY, pos.fZ, ori.fX, ori.fY, ori.fZ);
+                        pObj->GetKeyName().c_str(), pos.fX, pos.fY, pos.fZ, ori.fX, ori.fY, ori.fZ);
                 txt.DrawString(x,y,str,255,255,255,255);
             }
         }
@@ -344,7 +344,7 @@ void plNetClientMgr::IShowAvatars()
     // Others
     y=startY;
     x=startX;
-    
+
     plNetTransportMember** members=nil;
     fTransport.GetMemberListDistSorted(members);
     for(i=0;i<fTransport.GetNumMembers();i++)
@@ -362,7 +362,7 @@ void plNetClientMgr::IShowAvatars()
                 mbr->AsString().c_str(), pos.fX, pos.fY, pos.fZ, ori.fX, ori.fY, ori.fZ);
         txt.DrawString(x,y,str);
         y+=yOff;
-    
+
         if (player)
         {
             const plArmatureMod *avMod = plArmatureMod::ConvertNoRef(player->GetModifierByType(plArmatureMod::Index()));
@@ -372,13 +372,13 @@ void plNetClientMgr::IShowAvatars()
                 plSceneObject* pObj = pNonConstArm->GetFollowerParticleSystemSO();
                 if (pObj)
                 {
-                y+=yOff;
-                y+=yOff;
-                hsPoint3 pos = (pObj ? pObj->GetLocalToWorld() * hsPoint3(0, 0, 0) : hsPoint3(0, 0, 0));
-                hsVector3 ori = (pObj ? pObj->GetLocalToWorld() * hsVector3(0, -1, 0) : hsVector3(0, 0, 0));
-                sprintf(str, "%s: pos(%.2f, %.2f, %.2f) ori(%.2f, %.2f, %.2f)",
-                        pObj->GetKeyName(), pos.fX, pos.fY, pos.fZ, ori.fX, ori.fY, ori.fZ);
-                txt.DrawString(x,y,str,255,255,255,255);
+                    y+=yOff;
+                    y+=yOff;
+                    hsPoint3 pos = (pObj ? pObj->GetLocalToWorld() * hsPoint3(0, 0, 0) : hsPoint3(0, 0, 0));
+                    hsVector3 ori = (pObj ? pObj->GetLocalToWorld() * hsVector3(0, -1, 0) : hsVector3(0, 0, 0));
+                    sprintf(str, "%s: pos(%.2f, %.2f, %.2f) ori(%.2f, %.2f, %.2f)",
+                            pObj->GetKeyName().c_str(), pos.fX, pos.fY, pos.fZ, ori.fX, ori.fY, ori.fZ);
+                    txt.DrawString(x,y,str,255,255,255,255);
                 }
             }
         }
@@ -386,6 +386,6 @@ void plNetClientMgr::IShowAvatars()
     }
 
     delete [] members;
-    
+
     txt.SetFont( "Courier New", 8 );
 }
diff --git a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMsgHandler.cpp b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMsgHandler.cpp
index 558554d4..830611df 100644
--- a/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMsgHandler.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetClient/plNetClientMsgHandler.cpp
@@ -283,16 +283,17 @@ MSG_HANDLER_DEFN(plNetClientMsgHandler,plNetMsgSDLState)
         if (m->GetHasPlayerID())
             pl->fPlayerID = m->GetPlayerID();       // copy originating playerID if we have it
         pl->fUoid = m->ObjectInfo()->GetUoid();
-        
+
         // queue up state
         nc->fPendingLoads.push_back(pl);
-        hsLogEntry( nc->DebugMsg( "Added pending SDL delivery for %s:%s", m->ObjectInfo()->GetObjectName(), des->GetName() ) );
+        hsLogEntry( nc->DebugMsg( "Added pending SDL delivery for %s:%s",
+                                  m->ObjectInfo()->GetObjectName().c_str(), des->GetName() ) );
     }
     else
         delete sdRec;
 
     delete [] descName; // We've only used descName for a lookup (via SDR, and some error strings. Must delete now.
-    
+
     return hsOK;
 }
 
diff --git a/Sources/Plasma/PubUtilLib/plNetClient/plNetLinkingMgr.cpp b/Sources/Plasma/PubUtilLib/plNetClient/plNetLinkingMgr.cpp
index 50a080a5..03112b49 100644
--- a/Sources/Plasma/PubUtilLib/plNetClient/plNetLinkingMgr.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetClient/plNetLinkingMgr.cpp
@@ -951,9 +951,9 @@ uint8_t plNetLinkingMgr::IPreProcessLink(void)
                         plString title;
                         unsigned nameLen = nc->GetPlayerName().GetSize();
                         if (nc->GetPlayerName().CharAt(nameLen - 1) == 's' || nc->GetPlayerName().CharAt(nameLen - 1) == 'S')
-                            title = plString::Format("%s'", nc->GetPlayerName());
+                            title = plString::Format("%s'", nc->GetPlayerName().c_str());
                         else
-                            title = plString::Format("%s's", nc->GetPlayerName());
+                            title = plString::Format("%s's", nc->GetPlayerName().c_str());
                         info->SetAgeUserDefinedName(_TEMP_CONVERT_TO_CONST_CHAR(title));
                     }
                     if (!info->HasAgeDescription())
@@ -1087,7 +1087,7 @@ uint8_t plNetLinkingMgr::IPreProcessLink(void)
                 wchar_t parentAgeName[MAX_PATH];
                 if (link->HasParentAgeFilename())
                     StrToUnicode(parentAgeName, link->GetParentAgeFilename(), arrsize(parentAgeName));
-                
+
                 switch(VaultAgeFindOrCreateChildAgeLink(
                       (link->HasParentAgeFilename() ? parentAgeName : nil),
                       info,
@@ -1102,7 +1102,7 @@ uint8_t plNetLinkingMgr::IPreProcessLink(void)
                     case true:
                         success = kLinkImmediately;
                 }
-                
+
                 if (success == kLinkImmediately)
                     info->CopyFrom(childLink.GetAgeInfo());
             }
diff --git a/Sources/Plasma/PubUtilLib/plNetClientComm/plNetClientComm.cpp b/Sources/Plasma/PubUtilLib/plNetClientComm/plNetClientComm.cpp
index 1684c5d0..99788d16 100644
--- a/Sources/Plasma/PubUtilLib/plNetClientComm/plNetClientComm.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetClientComm/plNetClientComm.cpp
@@ -875,7 +875,7 @@ static void FileSrvIpAddressCallback (
 ***/
 
 //============================================================================
-const NetCommPlayer * const NetCommGetPlayer () {
+const NetCommPlayer * NetCommGetPlayer () {
     static NetCommPlayer s_nilPlayer;
     return s_player ? s_player : &s_nilPlayer;
 }
@@ -891,7 +891,7 @@ unsigned NetCommGetPlayerCount () {
 }
 
 //============================================================================
-const NetCommAccount * const NetCommGetAccount () {
+const NetCommAccount * NetCommGetAccount () {
     return &s_account;
 }
 
@@ -901,12 +901,12 @@ bool NetCommIsLoginComplete() {
 }
 
 //============================================================================
-const NetCommAge * const NetCommGetAge () {
+const NetCommAge * NetCommGetAge () {
     return &s_age;
 }
 
 //============================================================================
-const NetCommAge * const NetCommGetStartupAge () {
+const NetCommAge * NetCommGetStartupAge () {
     return &s_startupAge;
 }
 
diff --git a/Sources/Plasma/PubUtilLib/plNetClientComm/plNetClientComm.h b/Sources/Plasma/PubUtilLib/plNetClientComm/plNetClientComm.h
index 0ffdf54f..d22e422f 100644
--- a/Sources/Plasma/PubUtilLib/plNetClientComm/plNetClientComm.h
+++ b/Sources/Plasma/PubUtilLib/plNetClientComm/plNetClientComm.h
@@ -94,10 +94,10 @@ struct NetCommAge {
     char        spawnPtName[64];
 };
 
-const NetCommAge * const            NetCommGetAge ();
-const NetCommAge * const            NetCommGetStartupAge ();
-const NetCommAccount * const        NetCommGetAccount ();
-const NetCommPlayer * const         NetCommGetPlayer ();
+const NetCommAge *                  NetCommGetAge ();
+const NetCommAge *                  NetCommGetStartupAge ();
+const NetCommAccount *              NetCommGetAccount ();
+const NetCommPlayer *               NetCommGetPlayer ();
 const ARRAY(NetCommPlayer) &        NetCommGetPlayerList ();
 unsigned                            NetCommGetPlayerCount ();
 bool                                NetCommIsLoginComplete ();
diff --git a/Sources/Plasma/PubUtilLib/plNetCommon/plNetCommon.h b/Sources/Plasma/PubUtilLib/plNetCommon/plNetCommon.h
index 456f0889..b32ac2f1 100644
--- a/Sources/Plasma/PubUtilLib/plNetCommon/plNetCommon.h
+++ b/Sources/Plasma/PubUtilLib/plNetCommon/plNetCommon.h
@@ -199,7 +199,7 @@ namespace plNetCommon
             kChildAgeBook,
         };
 
-        static const char * LinkingRuleStr( int rule )
+        inline const char * LinkingRuleStr( int rule )
         {
             switch ( rule )
             {
@@ -227,7 +227,7 @@ namespace plNetCommon
             kTechnical
         };
     }
-    
+
     namespace BuildType
     {
         enum Types
@@ -238,7 +238,7 @@ namespace plNetCommon
             kExternalRelease
         };
 
-        static const char * BuildTypeStr( int rule )
+        inline const char * BuildTypeStr( int rule )
         {
             switch ( rule )
             {
diff --git a/Sources/Plasma/PubUtilLib/plNetMessage/plNetMessage.cpp b/Sources/Plasma/PubUtilLib/plNetMessage/plNetMessage.cpp
index 2bb231b4..94f16859 100644
--- a/Sources/Plasma/PubUtilLib/plNetMessage/plNetMessage.cpp
+++ b/Sources/Plasma/PubUtilLib/plNetMessage/plNetMessage.cpp
@@ -705,7 +705,7 @@ plString plNetMsgSDLState::AsString() const
     ISetDescName();     // set desc name for debug if necessary
 
     return plString::Format("object:%s, initial:%d, %s",
-        ObjectInfo()->GetObjectName(), fIsInitialState, plNetMsgStreamedObject::AsString().c_str() );
+        ObjectInfo()->GetObjectName().c_str(), fIsInitialState, plNetMsgStreamedObject::AsString().c_str() );
 }
 
 //
diff --git a/Sources/Plasma/PubUtilLib/plParticleSystem/plParticleGenerator.cpp b/Sources/Plasma/PubUtilLib/plParticleSystem/plParticleGenerator.cpp
index 501d30a3..40b6a271 100644
--- a/Sources/Plasma/PubUtilLib/plParticleSystem/plParticleGenerator.cpp
+++ b/Sources/Plasma/PubUtilLib/plParticleSystem/plParticleGenerator.cpp
@@ -58,7 +58,7 @@ static const float DEFAULT_INVERSE_MASS = 1.f;
 
 static plRandom sRandom;
 
-const void plParticleGenerator::ComputeDirection(float pitch, float yaw, hsVector3 &direction)
+void plParticleGenerator::ComputeDirection(float pitch, float yaw, hsVector3 &direction)
 {
     float cosPitch, sinPitch;
     float cosYaw, sinYaw;
@@ -70,7 +70,7 @@ const void plParticleGenerator::ComputeDirection(float pitch, float yaw, hsVecto
 
 // Inverse function of ComputeDirection. Give it a normalized vector, and it will tell you a
 // pitch and yaw (angles for the unit Z vector) to get there.
-const void plParticleGenerator::ComputePitchYaw(float &pitch, float &yaw, const hsVector3 &dir)
+void plParticleGenerator::ComputePitchYaw(float &pitch, float &yaw, const hsVector3 &dir)
 {
     const float PI = 3.14159f;
     pitch = asin(dir.fY);
diff --git a/Sources/Plasma/PubUtilLib/plParticleSystem/plParticleGenerator.h b/Sources/Plasma/PubUtilLib/plParticleSystem/plParticleGenerator.h
index dd8109ee..666f3e2c 100644
--- a/Sources/Plasma/PubUtilLib/plParticleSystem/plParticleGenerator.h
+++ b/Sources/Plasma/PubUtilLib/plParticleSystem/plParticleGenerator.h
@@ -63,8 +63,8 @@ public:
     CLASSNAME_REGISTER( plParticleGenerator );
     GETINTERFACE_ANY( plParticleGenerator, plCreatable );
 
-    static const void ComputeDirection(float pitch, float yaw, hsVector3 &direction);
-    static const void ComputePitchYaw(float &pitch, float &yaw, const hsVector3 &dir);
+    static void ComputeDirection(float pitch, float yaw, hsVector3 &direction);
+    static void ComputePitchYaw(float &pitch, float &yaw, const hsVector3 &dir);
     static inline float GetRandomVar() { return 2.0f * (float)hsRand() / RAND_MAX - 1; } // returns a num between +/- 1.0
 };
 
diff --git a/Sources/Plasma/PubUtilLib/plPhysical/plCollisionDetector.cpp b/Sources/Plasma/PubUtilLib/plPhysical/plCollisionDetector.cpp
index b0891d65..42cf7ed5 100644
--- a/Sources/Plasma/PubUtilLib/plPhysical/plCollisionDetector.cpp
+++ b/Sources/Plasma/PubUtilLib/plPhysical/plCollisionDetector.cpp
@@ -252,22 +252,22 @@ void plCameraRegionDetector::ITrigger(plKey hitter, bool entering, bool immediat
     // PHYSX_FIXME hack for PhysX turd that sends bunches of enter/exits over one frame
     if (entering && fNumEvals - fLastExitEval <= 1 && fSavingSendMsg)
     {
-        DetectorLog("%s: Skipping Camera Entering volume", GetKeyName());
+        DetectorLog("%s: Skipping Camera Entering volume", GetKeyName().c_str());
         fLastEnterEval = fNumEvals;
         if (fSavingSendMsg)
         {
-            DetectorLog("%s: Dumping saved Camera Exiting volume", GetKeyName());
+            DetectorLog("%s: Dumping saved Camera Exiting volume", GetKeyName().c_str());
         }
         fSavingSendMsg = false;
         return;
     }
     if (!entering && fNumEvals - fLastEnterEval <= 1 && fSavingSendMsg)
     {
-        DetectorLog("%s: Skipping Exiting volume", GetKeyName());
+        DetectorLog("%s: Skipping Exiting volume", GetKeyName().c_str());
         fLastExitEval = fNumEvals;
         if (fSavingSendMsg)
         {
-            DetectorLog("%s: Dumping saved Camera Entering volume", GetKeyName());
+            DetectorLog("%s: Dumping saved Camera Entering volume", GetKeyName().c_str());
         }
         fSavingSendMsg = false;
         return;
@@ -276,7 +276,7 @@ void plCameraRegionDetector::ITrigger(plKey hitter, bool entering, bool immediat
     // get rid of any saved messages... this should happen though
     if (fSavingSendMsg)
     {
-        DetectorLog("%s: Killing saved camera message... shouldn't happen", GetKeyName());
+        DetectorLog("%s: Killing saved camera message... shouldn't happen", GetKeyName().c_str());
     }
     // end PHYSX_FIXME hack for PhysX turd that sends bunches of enter/exits over one frame
 #endif   // USE_PHYSX_COLLISION_FLUTTER_WORKAROUND
@@ -285,12 +285,12 @@ void plCameraRegionDetector::ITrigger(plKey hitter, bool entering, bool immediat
     fSavedMsgEnterFlag = entering;
     if (entering)
     {
-        //DetectorLog("%s: Saving camera Entering volume - Evals=%d", GetKeyName(),fNumEvals);
+        //DetectorLog("%s: Saving camera Entering volume - Evals=%d", GetKeyName().c_str(),fNumEvals);
         fLastEnterEval = fNumEvals;
     }
     else
     {
-        //DetectorLog("%s: Saving camera Exiting volume - Evals=%d", GetKeyName(),fNumEvals);
+        //DetectorLog("%s: Saving camera Exiting volume - Evals=%d", GetKeyName().c_str(),fNumEvals);
         fLastExitEval = fNumEvals;
     }
 
@@ -322,13 +322,13 @@ void plCameraRegionDetector::ISendSavedTriggerMsgs()
             if (fSavedMsgEnterFlag)
             {
                 fMessages[i]->SetCmd(plCameraMsg::kEntering);
-                sprintf(str, "Entering cameraRegion: %s - Evals=%d -msg %d of %d\n", GetKeyName(),fNumEvals,i+1,fMessages.Count());
+                sprintf(str, "Entering cameraRegion: %s - Evals=%d -msg %d of %d\n", GetKeyName().c_str(),fNumEvals,i+1,fMessages.Count());
                 fIsInside = true;
             }
             else
             {
                 fMessages[i]->ClearCmd(plCameraMsg::kEntering);
-                sprintf(str, "Exiting cameraRegion: %s - Evals=%d -msg %d of %d\n", GetKeyName(),fNumEvals,i+1,fMessages.Count());
+                sprintf(str, "Exiting cameraRegion: %s - Evals=%d -msg %d of %d\n", GetKeyName().c_str(),fNumEvals,i+1,fMessages.Count());
                 fIsInside = false;
             }
             plgDispatch::MsgSend(fMessages[i]);
@@ -401,8 +401,8 @@ void plCameraRegionDetector::IHandleEval(plEvalMsg *pEval)
     {
         if(fSavedActivatorMsg)
             DetectorLog("%s didn't send its message. fNumEvals=%d fLastEnterEval=%d, fLastExit=%d",
-                GetKeyName(),fNumEvals, fLastEnterEval, fLastExitEval);
-        
+                GetKeyName().c_str(),fNumEvals, fLastEnterEval, fLastExitEval);
+
     }
 }
 
@@ -663,11 +663,11 @@ void plObjectInVolumeDetector::IHandleEval(plEvalMsg* pEval)
                         fCurrentResidents.insert((*it)->hitter);
                         actout->AddReceivers(fReceivers);
                         actout->Send();
-                        DetectorLog("%s sent an Enter ActivatorMsg. To: %s", GetKeyName(), GetTarget()->GetKeyName()  );
+                        DetectorLog("%s sent an Enter ActivatorMsg. To: %s", GetKeyName().c_str(), GetTarget()->GetKeyName().c_str()  );
                     }
                     else
                     {
-                        DetectorLog("%s squelched an Enter ActivatorMsg.", GetKeyName());
+                        DetectorLog("%s squelched an Enter ActivatorMsg.", GetKeyName().c_str());
                         delete actout;
                     }
             }
@@ -680,11 +680,11 @@ void plObjectInVolumeDetector::IHandleEval(plEvalMsg* pEval)
                         fCurrentResidents.erase((*it)->hitter);
                         actout->AddReceivers(fReceivers);
                         actout->Send();
-                        DetectorLog("%s sent an Exit ActivatorMsg. To: %s", GetKeyName(), GetTarget()->GetKeyName());
+                        DetectorLog("%s sent an Exit ActivatorMsg. To: %s", GetKeyName().c_str(), GetTarget()->GetKeyName().c_str());
                     }
                     else
                     {
-                        DetectorLog("%s squelched an Exit ActivatorMsg.", GetKeyName());
+                        DetectorLog("%s squelched an Exit ActivatorMsg.", GetKeyName().c_str());
                         delete actout;
                     }
             }
@@ -697,12 +697,12 @@ void plObjectInVolumeDetector::IHandleEval(plEvalMsg* pEval)
         DetectorLog("This is the regions inhabitants after the op");
         for(ResidentSet::iterator it = fCurrentResidents.begin(); it!= fCurrentResidents.end(); it++)
         {
-            DetectorLog("%s", (*it)->GetName());
+            DetectorLog("%s", (*it)->GetName().c_str());
         }
         DetectorLog("*********");
 
         fCollisionList.clear();
-        
+
 }
 
 void plObjectInVolumeDetector::SetTarget(plSceneObject* so)
@@ -778,13 +778,13 @@ void plObjectInVolumeAndFacingDetector::ICheckForTrigger()
 
         if (facing && movingForward && !fTriggered)
         {
-            DetectorLog("%s: Trigger InVolume&Facing", GetKeyName());
+            DetectorLog("%s: Trigger InVolume&Facing", GetKeyName().c_str());
             fTriggered = true;
             ITrigger(avatar->GetKey(), true, true);
         }
         else if (!facing && fTriggered)
         {
-            DetectorLog("%s: Untrigger InVolume&Facing", GetKeyName());
+            DetectorLog("%s: Untrigger InVolume&Facing", GetKeyName().c_str());
             fTriggered = false;
             ITrigger(avatar->GetKey(), false, true);
         }
@@ -877,7 +877,7 @@ hsBool plSubworldRegionDetector::MsgReceive(plMessage* msg)
         plArmatureMod* avMod = IGetAvatarModifier(pCollMsg->fOtherKey);
         if (avMod)
         {
-            DetectorLog("%s subworld detector %s", pCollMsg->fEntering ? "Entering" : "Exiting", GetKeyName());
+            DetectorLog("%s subworld detector %s", pCollMsg->fEntering ? "Entering" : "Exiting", GetKeyName().c_str());
 
             if ((pCollMsg->fEntering && !fOnExit) ||
                 (!pCollMsg->fEntering && fOnExit))
@@ -887,7 +887,7 @@ hsBool plSubworldRegionDetector::MsgReceive(plMessage* msg)
                     plSceneObject* SO = plSceneObject::ConvertNoRef(fSub->ObjectIsLoaded());
                     if (SO)
                     {
-                        DetectorLogSpecial("Switching to subworld %s", fSub->GetName());
+                        DetectorLogSpecial("Switching to subworld %s", fSub->GetName().c_str());
 
                         plKey nilKey;
                         plSubWorldMsg* msg = new plSubWorldMsg(GetKey(), avMod->GetKey(), fSub);
diff --git a/Sources/Plasma/PubUtilLib/plPhysical/plPhysicalSDLModifier.cpp b/Sources/Plasma/PubUtilLib/plPhysical/plPhysicalSDLModifier.cpp
index 65988b56..f388555c 100644
--- a/Sources/Plasma/PubUtilLib/plPhysical/plPhysicalSDLModifier.cpp
+++ b/Sources/Plasma/PubUtilLib/plPhysical/plPhysicalSDLModifier.cpp
@@ -215,27 +215,27 @@ void plPhysicalSDLModifier::ILogState(const plStateDataRecord* state, bool useDi
 
     plPhysical* phys = IGetPhysical();
 
-    std::string log = xtl::format("%s: %s", phys->GetKeyName(), prefix);
+    plString log = plString::Format("%s: %s", phys->GetKeyName().c_str(), prefix);
 
     if (isPosSet)
-        log += xtl::format(" Pos=%.1f %.1f %.1f", pos.fX, pos.fY, pos.fZ);
+        log += plString::Format(" Pos=%.1f %.1f %.1f", pos.fX, pos.fY, pos.fZ);
     else
-        log += " Pos=None";
+        log += _TEMP_CONVERT_FROM_LITERAL(" Pos=None");
 
     if (isLinVSet)
-        log += xtl::format(" LinV=%.1f %.1f %.1f", linV.fX, linV.fY, linV.fZ);
+        log += plString::Format(" LinV=%.1f %.1f %.1f", linV.fX, linV.fY, linV.fZ);
     else
-        log += " LinV=None";
+        log += _TEMP_CONVERT_FROM_LITERAL(" LinV=None");
 
     if (isAngVSet)
-        log += xtl::format(" AngV=%.1f %.1f %.1f", angV.fX, angV.fY, angV.fZ);
+        log += plString::Format(" AngV=%.1f %.1f %.1f", angV.fX, angV.fY, angV.fZ);
     else
-        log += " AngV=None";
+        log += _TEMP_CONVERT_FROM_LITERAL(" AngV=None");
 
     if (isRotSet)
-        log += xtl::format(" Rot=%.1f %.1f %.1f %.1f", rot.fX, rot.fY, rot.fZ, rot.fW);
+        log += plString::Format(" Rot=%.1f %.1f %.1f %.1f", rot.fX, rot.fY, rot.fZ, rot.fW);
     else
-        log += " Rot=None";
+        log += _TEMP_CONVERT_FROM_LITERAL(" Rot=None");
 
     IGetLog()->AddLine(log.c_str(), color);
 }
diff --git a/Sources/Plasma/PubUtilLib/plPhysical/plPickingDetector.cpp b/Sources/Plasma/PubUtilLib/plPhysical/plPickingDetector.cpp
index 471cbee0..145f68b3 100644
--- a/Sources/Plasma/PubUtilLib/plPhysical/plPickingDetector.cpp
+++ b/Sources/Plasma/PubUtilLib/plPhysical/plPickingDetector.cpp
@@ -91,7 +91,7 @@ hsBool plPickingDetector::MsgReceive(plMessage* msg)
                 pMsg->fPickedObj = fProxyKey;
             else
                 pMsg->fPickedObj = GetTarget()->GetKey();
-            
+
             // assume that since this is something that was PICKED that it was done by the local player.
             plKey locPlayerKey = plNetClientApp::GetInstance()->GetLocalPlayerKey();
             if (locPlayerKey)
@@ -99,10 +99,10 @@ hsBool plPickingDetector::MsgReceive(plMessage* msg)
 
             pMsg->SetSender(GetKey());
             plgDispatch::MsgSend( pMsg );
-            hsStatusMessageF("%s sending activate message to %s\n",GetKey()->GetName(), fReceivers[i]->GetName());
+            hsStatusMessageF("%s sending activate message to %s\n",GetKey()->GetName().c_str(), fReceivers[i]->GetName().c_str());
         }
     }
-    
+
     if (RemoteMod() && RemoteMod()->MsgReceive(msg))
         return true;
 
diff --git a/Sources/Plasma/PubUtilLib/plPipeline/plCullTree.h b/Sources/Plasma/PubUtilLib/plPipeline/plCullTree.h
index ad3fc42b..c6b5c162 100644
--- a/Sources/Plasma/PubUtilLib/plPipeline/plCullTree.h
+++ b/Sources/Plasma/PubUtilLib/plPipeline/plCullTree.h
@@ -209,7 +209,7 @@ public:
     void    SetPlane(const hsVector3& n, float d) { fNorm = n; fDist = d; }
     
     const hsVector3& GetNormal() const { return fNorm; }
-    const float GetDist() const { return fDist; }
+    float GetDist() const { return fDist; }
 
     plCullStatus    TestBounds(const hsBounds3Ext& bnd) const;
     plCullStatus    TestSphere(const hsPoint3& center, float rad) const;
diff --git a/Sources/Plasma/PubUtilLib/plPipeline/plDebugText.h b/Sources/Plasma/PubUtilLib/plPipeline/plDebugText.h
index 282496d0..e8f8cc35 100644
--- a/Sources/Plasma/PubUtilLib/plPipeline/plDebugText.h
+++ b/Sources/Plasma/PubUtilLib/plPipeline/plDebugText.h
@@ -94,7 +94,7 @@ class plDebugText
         };
 
         ~plDebugText() { ; }
-        
+
         static plDebugText  &Instance( void ) { return fInstance; }
 
         uint32_t  CalcStringWidth( const char *string );
@@ -139,12 +139,12 @@ class plDebugText
 
         void            SetFont(const char *face, uint16_t size ) { hsStrncpy( fFontFace, face, sizeof( fFontFace ) ); fFontSize = size; }
         const char      *GetFontFace( void ) { return fFontFace; }
-        const uint16_t    GetFontSize( void ) { return fFontSize; }
-        uint16_t          GetFontHeight();
-        
+        uint16_t        GetFontSize( void ) { return fFontSize; }
+        uint16_t        GetFontHeight();
+
         void            SetEnable( hsBool on ) { fEnabled = on; }
         void            DisablePermanently( void ) { fEnabled = false; fLockEnable = true; }
-        const hsBool    IsEnabled( void ) { return fEnabled; }
+        hsBool          IsEnabled( void ) { return fEnabled; }
 
         void            GetScreenSize( uint32_t *width, uint32_t *height );
 };
diff --git a/Sources/Plasma/PubUtilLib/plPipeline/plDynamicEnvMap.cpp b/Sources/Plasma/PubUtilLib/plPipeline/plDynamicEnvMap.cpp
index 09e5d710..1f91302c 100644
--- a/Sources/Plasma/PubUtilLib/plPipeline/plDynamicEnvMap.cpp
+++ b/Sources/Plasma/PubUtilLib/plPipeline/plDynamicEnvMap.cpp
@@ -573,7 +573,10 @@ void plDynamicCamMap::ISetupRenderRequest(plPipeline *pipe)
     hsMatrix44 w2c, c2w;
     if (fCamera)
     {
-        w2c.MakeCamera(&fCamera->GetTargetPos(), &fCamera->GetTargetPOA(), &hsVector3(0.f, 0.f, 1.f));
+        hsPoint3 pos = fCamera->GetTargetPos();
+        hsPoint3 poa = fCamera->GetTargetPOA();
+        hsVector3 vec(0.f, 0.f, 1.f);
+        w2c.MakeCamera(&pos, &poa, &vec);
         w2c.GetInverse(&c2w);
     }
     else
@@ -584,7 +587,8 @@ void plDynamicCamMap::ISetupRenderRequest(plPipeline *pipe)
         // Could be optimized, but the matrix construction work here seems cheap relative to the cost
         // of rerendering all this stuff to a separate target, so I doubt we'd notice.
         hsMatrix44 invert;
-        invert.MakeScaleMat(&(hsVector3(1.f, 1.f, -1.f)));
+        hsVector3 vec(1.f, 1.f, -1.f);
+        invert.MakeScaleMat(&vec);
         w2c = pipe->GetWorldToCamera();
         c2w = pipe->GetCameraToWorld();
 
diff --git a/Sources/Plasma/PubUtilLib/plPipeline/plPlates.h b/Sources/Plasma/PubUtilLib/plPipeline/plPlates.h
index ad3780b5..8a16da21 100644
--- a/Sources/Plasma/PubUtilLib/plPipeline/plPlates.h
+++ b/Sources/Plasma/PubUtilLib/plPipeline/plPlates.h
@@ -182,9 +182,9 @@ class plGraphPlate : public plPlate
         void    SetDataColors( const std::vector<uint32_t> & hexColors );
 
         const char      *GetLabelText( int i ) { return fLabelText[ i ].c_str(); }
-        const uint32_t    GetDataColor( int i ) { return fDataHexColors[ i ]; }
-        const uint32_t    GetNumLabels() { return fLabelText.size(); }
-        const uint32_t    GetNumColors() { return fDataHexColors.size(); }
+        uint32_t        GetDataColor( int i ) { return fDataHexColors[ i ]; }
+        uint32_t        GetNumLabels() { return fLabelText.size(); }
+        uint32_t        GetNumColors() { return fDataHexColors.size(); }
 };
 
 //// plPlateManager Class Definition /////////////////////////////////////////
diff --git a/Sources/Plasma/PubUtilLib/plResMgr/plResManager.cpp b/Sources/Plasma/PubUtilLib/plResMgr/plResManager.cpp
index f2be393e..9be4fc05 100644
--- a/Sources/Plasma/PubUtilLib/plResMgr/plResManager.cpp
+++ b/Sources/Plasma/PubUtilLib/plResMgr/plResManager.cpp
@@ -612,7 +612,7 @@ const plLocation& plResManager::FindLocation(const char* age, const char* page)
     return invalidLoc;
 }
 
-const void plResManager::GetLocationStrings(const plLocation& loc, char* ageBuffer, char* pageBuffer) const
+void plResManager::GetLocationStrings(const plLocation& loc, char* ageBuffer, char* pageBuffer) const
 {
     plRegistryPageNode* page = FindPage(loc);
     const plPageInfo& info = page->GetPageInfo();
diff --git a/Sources/Plasma/PubUtilLib/plResMgr/plResManager.h b/Sources/Plasma/PubUtilLib/plResMgr/plResManager.h
index bb0d17ad..e8cf0cf3 100644
--- a/Sources/Plasma/PubUtilLib/plResMgr/plResManager.h
+++ b/Sources/Plasma/PubUtilLib/plResMgr/plResManager.h
@@ -88,7 +88,7 @@ public:
     virtual plKey       FindKey(const plUoid&); // Same as above, but will check the uoid for clones
     const plLocation&   FindLocation(const char* age, const char* page) const;
     // Use nil for any strings you don't need
-    const void          GetLocationStrings(const plLocation& loc, char* ageBuffer, char* pageBuffer) const;
+    void                GetLocationStrings(const plLocation& loc, char* ageBuffer, char* pageBuffer) const;
 
     //---------------------------
     //  Establish reference linkage 
diff --git a/Sources/Plasma/PubUtilLib/plSDL/plStateVariable.cpp b/Sources/Plasma/PubUtilLib/plSDL/plStateVariable.cpp
index 4b08f612..899bf977 100644
--- a/Sources/Plasma/PubUtilLib/plSDL/plStateVariable.cpp
+++ b/Sources/Plasma/PubUtilLib/plSDL/plStateVariable.cpp
@@ -2068,11 +2068,11 @@ bool plSimpleStateVariable::ReadData(hsStream* s, float timeConvert, uint32_t re
             uint32_t cnt;
             s->ReadLE(&cnt);      // have to read as long since we don't know how big the list is
 
-            if (cnt>=0 && cnt<plSDL::kMaxListSize)
+            if (cnt<plSDL::kMaxListSize)
                 fVar.SetCount(cnt);
             else
                 return false;
-        
+
             Alloc();        // alloc after setting count
         }
         else
@@ -2084,10 +2084,10 @@ bool plSimpleStateVariable::ReadData(hsStream* s, float timeConvert, uint32_t re
     // compare timestamps
     if (fTimeStamp > ut)
         return true;
-        
+
     if ( (saveFlags & plSDL::kHasTimeStamp) || (readOptions & plSDL::kTimeStampOnRead) )
         TimeStamp(ut);
-    
+
     // read list
     if (!(saveFlags & plSDL::kSameAsDefault))
     {
diff --git a/Sources/Plasma/PubUtilLib/plStatGather/plAutoProfile.cpp b/Sources/Plasma/PubUtilLib/plStatGather/plAutoProfile.cpp
index aef15e17..59785445 100644
--- a/Sources/Plasma/PubUtilLib/plStatGather/plAutoProfile.cpp
+++ b/Sources/Plasma/PubUtilLib/plStatGather/plAutoProfile.cpp
@@ -224,13 +224,12 @@ void plAutoProfileImp::INextProfile()
             plMipmap mipmap;
             if (plClient::GetInstance()->GetPipeline()->CaptureScreen(&mipmap))
             {
-                char fileName[256];
-                sprintf(fileName, "%s%s_%s.jpg",
+                plString fileName = plString::Format("%S%s_%s.jpg",
                     plProfileManagerFull::Instance().GetProfilePath(),
-                    ageName, fLastSpawnPointName);
+                    ageName, fLastSpawnPointName.c_str());
 
                 plJPEG::Instance().SetWriteQuality(100);
-                plJPEG::Instance().WriteToFile(fileName, &mipmap);
+                plJPEG::Instance().WriteToFile(fileName.c_str(), &mipmap);
             }
 
             fLastSpawnPointName = plString::Null;
diff --git a/Sources/Plasma/PubUtilLib/plSurface/plShader.cpp b/Sources/Plasma/PubUtilLib/plSurface/plShader.cpp
index a7793425..26e4bc94 100644
--- a/Sources/Plasma/PubUtilLib/plSurface/plShader.cpp
+++ b/Sources/Plasma/PubUtilLib/plSurface/plShader.cpp
@@ -276,7 +276,7 @@ float plShader::GetFloat(int i, int chan) const
     return fConsts[i].fArray[chan];
 }
 
-const float* const plShader::GetFloat4(int i) const
+const float* plShader::GetFloat4(int i) const
 {
     return fConsts[i].fArray;
 }
diff --git a/Sources/Plasma/PubUtilLib/plSurface/plShader.h b/Sources/Plasma/PubUtilLib/plSurface/plShader.h
index 9aa68578..75bc1288 100644
--- a/Sources/Plasma/PubUtilLib/plSurface/plShader.h
+++ b/Sources/Plasma/PubUtilLib/plSurface/plShader.h
@@ -226,8 +226,8 @@ public:
     hsPoint3                GetPosition(int i) const;
     hsVector3               GetVector(int i) const;
     void                    GetVector(int i, float& x, float& y, float& z, float& w) const;
-    float                GetFloat(int i, int chan) const;
-    const float* const      GetFloat4(int i) const;
+    float                   GetFloat(int i, int chan) const;
+    const float*            GetFloat4(int i) const;
 
     void                    SetMatrix(int i, const plFloat44& xfm); // Will transpose
     void                    SetMatrix3(int i, const plFloat44& xfm); // Will transpose
diff --git a/Sources/Plasma/PubUtilLib/plSurface/plShaderTable.h b/Sources/Plasma/PubUtilLib/plSurface/plShaderTable.h
index 9d611758..bb0879a7 100644
--- a/Sources/Plasma/PubUtilLib/plSurface/plShaderTable.h
+++ b/Sources/Plasma/PubUtilLib/plSurface/plShaderTable.h
@@ -113,7 +113,7 @@ public:
     plShaderID::ID GetID() const { return fID; }
     uint32_t GetByteLen() const { return fbyteLen; }
     const uint8_t* GetCodes() const { return fCodes; }
-    const char* const GetFileName() const { return fFileName; }
+    const char* GetFileName() const { return fFileName; }
 };
 
 class plShaderTableInst

From 247749934b8fd2fb972a9fe2aa9b43c057278bd9 Mon Sep 17 00:00:00 2001
From: Michael Hansen <zrax0111@gmail.com>
Date: Thu, 9 Feb 2012 21:29:23 -0800
Subject: [PATCH 09/11] Fix pnUUID compilation on Linux

---
 Sources/Plasma/Apps/plClient/winmain.cpp          | 2 +-
 Sources/Plasma/NucleusLib/pnUUID/pnUUID.h         | 2 +-
 Sources/Plasma/NucleusLib/pnUUID/pnUUID_Win32.cpp | 5 -----
 3 files changed, 2 insertions(+), 7 deletions(-)

diff --git a/Sources/Plasma/Apps/plClient/winmain.cpp b/Sources/Plasma/Apps/plClient/winmain.cpp
index 1648fad9..fd8daf5b 100644
--- a/Sources/Plasma/Apps/plClient/winmain.cpp
+++ b/Sources/Plasma/Apps/plClient/winmain.cpp
@@ -1129,8 +1129,8 @@ void StatusCallback(void *param)
         }
     }
 
-    delete [] statusUrl;
     curl_easy_cleanup(hCurl);
+    delete [] statusUrl;
 
     s_statusEvent.Signal();
 }
diff --git a/Sources/Plasma/NucleusLib/pnUUID/pnUUID.h b/Sources/Plasma/NucleusLib/pnUUID/pnUUID.h
index c8102dcf..10810071 100644
--- a/Sources/Plasma/NucleusLib/pnUUID/pnUUID.h
+++ b/Sources/Plasma/NucleusLib/pnUUID/pnUUID.h
@@ -74,7 +74,7 @@ public:
     int     CompareTo( const plUUID * v ) const;
     bool    IsEqualTo( const plUUID * v ) const;
     bool    FromString( const char * str );
-    bool    FromString( const plString & str );
+    bool    FromString( const plString & str ) { return FromString( str.c_str() ); }
     bool    ToString( plString & out ) const;
     plString AsString() const;
     void    Read( hsStream * s );
diff --git a/Sources/Plasma/NucleusLib/pnUUID/pnUUID_Win32.cpp b/Sources/Plasma/NucleusLib/pnUUID/pnUUID_Win32.cpp
index 10ef5d86..98f58772 100644
--- a/Sources/Plasma/NucleusLib/pnUUID/pnUUID_Win32.cpp
+++ b/Sources/Plasma/NucleusLib/pnUUID/pnUUID_Win32.cpp
@@ -88,11 +88,6 @@ bool plUUID::FromString( const char * str )
     return RPC_S_OK == UuidFromString( (unsigned char *)str, (GUID *)this );
 }
 
-bool plUUID::FromString( const plString & str )
-{
-    return FromString( str.c_str() );
-}
-
 bool plUUID::ToString( plString & out ) const
 {
     out = _TEMP_CONVERT_FROM_LITERAL("");

From 1511459ffd4b744b45e758dcb7c8045a4d12fbfc Mon Sep 17 00:00:00 2001
From: Michael Hansen <zrax0111@gmail.com>
Date: Thu, 9 Feb 2012 22:44:57 -0800
Subject: [PATCH 10/11] Fix String concatenation dereference bug

---
 Sources/Plasma/CoreLib/plString.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Sources/Plasma/CoreLib/plString.cpp b/Sources/Plasma/CoreLib/plString.cpp
index c4ba50f0..a8da244e 100644
--- a/Sources/Plasma/CoreLib/plString.cpp
+++ b/Sources/Plasma/CoreLib/plString.cpp
@@ -640,7 +640,7 @@ plString plString::Substr(int start, size_t size) const
 
     // Don't re-check UTF-8 on this
     plString str;
-    str.fUtf8Buffer.Steal(substr, size);
+    str.fUtf8Buffer = plStringBuffer<char>::Steal(substr, size);
     return str;
 }
 
@@ -651,7 +651,7 @@ plString &plString::operator+=(const plString &str)
     memcpy(catstr, s_str(), GetSize());
     memcpy(catstr + GetSize(), str.s_str(), str.GetSize());
     catstr[catsize] = 0;
-    fUtf8Buffer.Steal(catstr, catsize);
+    fUtf8Buffer = plStringBuffer<char>::Steal(catstr, catsize);
     return *this;
 }
 
@@ -665,7 +665,7 @@ plString operator+(const plString &left, const plString &right)
 
     // Don't re-check UTF-8 on this
     plString str;
-    str.fUtf8Buffer.Steal(catstr, catsize);
+    str.fUtf8Buffer = plStringBuffer<char>::Steal(catstr, catsize);
     return str;
 }
 

From 4b70d592c9f23898b8e6c0becbb53e998eaea032 Mon Sep 17 00:00:00 2001
From: Michael Hansen <zrax0111@gmail.com>
Date: Sat, 11 Feb 2012 13:31:43 -0800
Subject: [PATCH 11/11] Fix some %s errors in plPhysX

---
 .../PubUtilLib/plPhysX/plLOSDispatch.cpp      |  4 +--
 .../PubUtilLib/plPhysX/plPXPhysical.cpp       | 20 ++++++------
 .../plPhysX/plPXPhysicalControllerCore.cpp    |  6 ++--
 .../PubUtilLib/plPhysX/plSimulationMgr.cpp    | 32 +++++++++----------
 4 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/Sources/Plasma/PubUtilLib/plPhysX/plLOSDispatch.cpp b/Sources/Plasma/PubUtilLib/plPhysX/plLOSDispatch.cpp
index 44de0732..e2099d49 100644
--- a/Sources/Plasma/PubUtilLib/plPhysX/plLOSDispatch.cpp
+++ b/Sources/Plasma/PubUtilLib/plPhysX/plLOSDispatch.cpp
@@ -226,7 +226,7 @@ hsBool plLOSDispatch::MsgReceive(plMessage* msg)
             scene->raycastAllShapes(worldRay, gMyReport, NX_ALL_SHAPES, 0xffffffff, dist, NX_RAYCAST_DISTANCE | NX_RAYCAST_IMPACT | NX_RAYCAST_NORMAL);
         }
         else{
-            SimLog("%s sent out a LOS request with a ray length of %d.", requestMsg->GetSender()->GetName(), dist);
+            SimLog("%s sent out a LOS request with a ray length of %d.", requestMsg->GetSender()->GetName().c_str(), dist);
         }
         if (gMyReport.GotHit())
         {
@@ -259,7 +259,7 @@ hsBool plLOSDispatch::MsgReceive(plMessage* msg)
                 else// we are right on top of the object I assume that means we hit it
                 {// since PhysX would have complained we will log it anyways. Just so we have a better idea, where this
                     //was happening previously
-                    SimLog("%s sent out a LOS request. The second cast for culling was of length 0. ABORTING and assuming hit.", requestMsg->GetSender()->GetName());
+                    SimLog("%s sent out a LOS request. The second cast for culling was of length 0. ABORTING and assuming hit.", requestMsg->GetSender()->GetName().c_str());
                 }
 
             }
diff --git a/Sources/Plasma/PubUtilLib/plPhysX/plPXPhysical.cpp b/Sources/Plasma/PubUtilLib/plPhysX/plPXPhysical.cpp
index df4770c3..adf614e2 100644
--- a/Sources/Plasma/PubUtilLib/plPhysX/plPXPhysical.cpp
+++ b/Sources/Plasma/PubUtilLib/plPhysX/plPXPhysical.cpp
@@ -84,7 +84,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
     #define SpamMsg(x)
 #endif
               
-#define LogActivate(func) if (fActor->isSleeping()) SimLog("%s activated by %s", GetKeyName(), func);
+#define LogActivate(func) if (fActor->isSleeping()) SimLog("%s activated by %s", GetKeyName().c_str(), func);
 
 PhysRecipe::PhysRecipe()
     : mass(0.f)
@@ -152,7 +152,7 @@ plPXPhysical::plPXPhysical()
 
 plPXPhysical::~plPXPhysical()
 {
-    SpamMsg(plSimulationMgr::Log("Destroying physical %s", GetKeyName()));
+    SpamMsg(plSimulationMgr::Log("Destroying physical %s", GetKeyName().c_str()));
 
     if (fActor)
     {
@@ -345,9 +345,9 @@ hsBool plPXPhysical::Should_I_Trigger(hsBool enter, hsPoint3& pos)
 #ifdef PHYSX_SAVE_TRIGGERS_WORKAROUND
             trigger = true;
             fInsideConvexHull = enter;
-            DetectorLogSpecial("**>Saved a missing enter collision: %s",GetObjectKey()->GetName());
+            DetectorLogSpecial("**>Saved a missing enter collision: %s",GetObjectKey()->GetName().c_str());
 #else
-            DetectorLogSpecial("**>Could have saved a missing enter collision: %s",GetObjectKey()->GetName());
+            DetectorLogSpecial("**>Could have saved a missing enter collision: %s",GetObjectKey()->GetName().c_str());
 #endif PHYSX_SAVE_TRIGGERS_WORKAROUND
         }
     }
@@ -436,7 +436,7 @@ hsBool plPXPhysical::Init(PhysRecipe& recipe)
     case plSimDefs::kProxyBounds:
         if (fGroup == plSimDefs::kGroupDetector)
         {
-            SimLog("Someone using an Exact on a detector region: %s", GetKeyName());
+            SimLog("Someone using an Exact on a detector region: %s", GetKeyName().c_str());
         }
         trimeshShapeDesc.meshData = recipe.triMesh;
         trimeshShapeDesc.userData = recipe.meshStream;
@@ -489,7 +489,7 @@ hsBool plPXPhysical::Init(PhysRecipe& recipe)
     else
     {
         if ( GetProperty(plSimulationInterface::kPhysAnim) )
-            SimLog("An animated physical that has no mass: %s", GetKeyName());
+            SimLog("An animated physical that has no mass: %s", GetKeyName().c_str());
     }
 
     actorDesc.userData = this;
@@ -536,7 +536,7 @@ hsBool plPXPhysical::Init(PhysRecipe& recipe)
         if (!fActor->isSleeping())
         {
             if (plSimulationMgr::fExtraProfile)
-                SimLog("Deactivating %s in SetPositionAndRotationSim", GetKeyName());
+                SimLog("Deactivating %s in SetPositionAndRotationSim", GetKeyName().c_str());
             fActor->putToSleep();
         }
     }
@@ -795,7 +795,7 @@ void plPXPhysical::SendNewLocation(hsBool synchTransform, hsBool isSynchUpdate)
 
                 if (fCachedLocal2World.GetTranslate().fZ < kMaxNegativeZPos)
                 {
-                    SimLog("Physical %s fell to %.1f (%.1f is the max).  Suppressing.", GetKeyName(), fCachedLocal2World.GetTranslate().fZ, kMaxNegativeZPos);
+                    SimLog("Physical %s fell to %.1f (%.1f is the max).  Suppressing.", GetKeyName().c_str(), fCachedLocal2World.GetTranslate().fZ, kMaxNegativeZPos);
                     // Since this has probably been falling for a while, and thus not getting any syncs,
                     // make sure to save it's current pos so we'll know to reset it later
                     DirtySynchState(kSDLPhysical, plSynchedObject::kBCastToClients);
@@ -936,7 +936,7 @@ void plPXPhysical::SetTransform(const hsMatrix44& l2w, const hsMatrix44& w2l, hs
     else
     {
         if ( !fActor->isDynamic()  && plSimulationMgr::fExtraProfile)
-            SimLog("Setting transform on non-dynamic: %s.", GetKeyName());
+            SimLog("Setting transform on non-dynamic: %s.", GetKeyName().c_str());
     }
 }
 
@@ -1228,7 +1228,7 @@ void plPXPhysical::SetSyncState(hsPoint3* pos, hsQuat* rot, hsVector3* linV, hsV
     // we've got right now)
     if (pos && pos->fZ < kMaxNegativeZPos && initialSync)
     {
-        SimLog("Physical %s loaded out of range state.  Forcing initial state to server.", GetKeyName());
+        SimLog("Physical %s loaded out of range state.  Forcing initial state to server.", GetKeyName().c_str());
         DirtySynchState(kSDLPhysical, plSynchedObject::kBCastToClients);
         return;
     }
diff --git a/Sources/Plasma/PubUtilLib/plPhysX/plPXPhysicalControllerCore.cpp b/Sources/Plasma/PubUtilLib/plPhysX/plPXPhysicalControllerCore.cpp
index 5393a404..ae8d6757 100644
--- a/Sources/Plasma/PubUtilLib/plPhysX/plPXPhysicalControllerCore.cpp
+++ b/Sources/Plasma/PubUtilLib/plPhysX/plPXPhysicalControllerCore.cpp
@@ -703,12 +703,12 @@ void plPXPhysicalControllerCore::IInformDetectors(bool entering,bool deferUntilN
                         msg->AddReceiver(physical->GetObjectKey());
                         if(!deferUntilNextSim)
                         {
-                            DetectorLog("Sending an %s msg to %s" , entering? "entering":"exit", physical->GetObjectKey()->GetName());                    
+                            DetectorLog("Sending an %s msg to %s" , entering? "entering":"exit", physical->GetObjectKey()->GetName().c_str());
                             msg->Send();
                         }
                         else
                         {
-                            DetectorLog("Queuing an %s msg to %s, which will be sent after the client update" , entering? "entering":"exit", physical->GetObjectKey()->GetName());    
+                            DetectorLog("Queuing an %s msg to %s, which will be sent after the client update" , entering? "entering":"exit", physical->GetObjectKey()->GetName().c_str());
                             plgDispatch::Dispatch()->MsgQueue(msg);
                         }
                     }
@@ -1217,7 +1217,7 @@ void plPXPhysicalControllerCore::IDrawDebugDisplay()
         char *overlapStr = fDbgCollisionInfo[i].fOverlap ? "yes" : "no";
         float angle = hsRadiansToDegrees(acos(normal * hsVector3(0, 0, 1)));
         sprintf(strBuf, "    Obj: %s, Normal: (%.2f, %.2f, %.2f), Angle(%.1f), Overlap(%3s)",
-                fDbgCollisionInfo[i].fSO->GetKeyName(),
+                fDbgCollisionInfo[i].fSO->GetKeyName().c_str(),
                 normal.fX, normal.fY, normal.fZ, angle, overlapStr);
         debugTxt.DrawString(x, y, strBuf);
         y += lineHeight;
diff --git a/Sources/Plasma/PubUtilLib/plPhysX/plSimulationMgr.cpp b/Sources/Plasma/PubUtilLib/plPhysX/plSimulationMgr.cpp
index 4af7cdf5..051c4761 100644
--- a/Sources/Plasma/PubUtilLib/plPhysX/plSimulationMgr.cpp
+++ b/Sources/Plasma/PubUtilLib/plPhysX/plSimulationMgr.cpp
@@ -80,7 +80,7 @@ class SensorReport : public NxUserTriggerReport
         hsPoint3 otherPos = plPXConvert::Point(otherShape.getGlobalPosition());
 
         if (plSimulationMgr::fExtraProfile)
-            DetectorLogRed("-->%s %s (status=%x) other@(%f,%f,%f)",triggerPhys->GetObjectKey()->GetName(),status & NX_TRIGGER_ON_ENTER ? "enter" : "exit",status,otherPos.fX,otherPos.fY,otherPos.fZ);
+            DetectorLogRed("-->%s %s (status=%x) other@(%f,%f,%f)",triggerPhys->GetObjectKey()->GetName().c_str(),status & NX_TRIGGER_ON_ENTER ? "enter" : "exit",status,otherPos.fX,otherPos.fY,otherPos.fZ);
 
         plPXPhysical* otherPhys = (plPXPhysical*)otherShape.getActor().userData;
         if (otherPhys)
@@ -90,7 +90,7 @@ class SensorReport : public NxUserTriggerReport
             if (!doReport)
             {
                 if (plSimulationMgr::fExtraProfile)
-                    DetectorLogRed("<--Kill collision %s :failed group. US=%x OTHER=(%s)%x",triggerPhys->GetObjectKey()->GetName(),triggerPhys->GetGroup(),otherPhys->GetObjectKey()->GetName(),otherPhys->GetGroup());
+                    DetectorLogRed("<--Kill collision %s :failed group. US=%x OTHER=(%s)%x",triggerPhys->GetObjectKey()->GetName().c_str(),triggerPhys->GetGroup(),otherPhys->GetObjectKey()->GetName().c_str(),otherPhys->GetGroup());
             }
         }
         else
@@ -103,7 +103,7 @@ class SensorReport : public NxUserTriggerReport
                 {
 #ifdef PHYSX_ONLY_TRIGGER_FROM_KINEMATIC
                     if (plSimulationMgr::fExtraProfile)
-                        DetectorLogRed("<--Kill collision %s : ignoring controller events.",triggerPhys->GetObjectKey()->GetName());
+                        DetectorLogRed("<--Kill collision %s : ignoring controller events.",triggerPhys->GetObjectKey()->GetName().c_str());
                     return;
 #else // else if trigger on both controller and kinematic
                     // only suppress controller collision 'enters' when disabled but let 'exits' continue
@@ -111,7 +111,7 @@ class SensorReport : public NxUserTriggerReport
                     if ( ( !controller->IsEnabled() /*&& (status & NX_TRIGGER_ON_ENTER)*/ ) || controller->IsKinematic() )
                     {
                         if (plSimulationMgr::fExtraProfile)
-                            DetectorLogRed("<--Kill collision %s : controller is not enabled.",triggerPhys->GetObjectKey()->GetName());
+                            DetectorLogRed("<--Kill collision %s : controller is not enabled.",triggerPhys->GetObjectKey()->GetName().c_str());
                         return;
                     }
 #endif  // PHYSX_ONLY_TRIGGER_FROM_KINEMATIC
@@ -124,7 +124,7 @@ class SensorReport : public NxUserTriggerReport
                     if ( !controller->IsKinematic() /*&& (status & NX_TRIGGER_ON_ENTER) */ )
                     {
                         if (plSimulationMgr::fExtraProfile)
-                            DetectorLogRed("<--Kill collision %s : kinematic is not enabled.",triggerPhys->GetObjectKey()->GetName());
+                            DetectorLogRed("<--Kill collision %s : kinematic is not enabled.",triggerPhys->GetObjectKey()->GetName().c_str());
                         return;
                     }
                 }
@@ -135,7 +135,7 @@ class SensorReport : public NxUserTriggerReport
                 {
                     if (!doReport)
                     {
-                        DetectorLogRed("<--Kill collision %s :failed group. US=%x OTHER=(NotAvatar)",triggerPhys->GetObjectKey()->GetName(),triggerPhys->GetGroup());
+                        DetectorLogRed("<--Kill collision %s :failed group. US=%x OTHER=(NotAvatar)",triggerPhys->GetObjectKey()->GetName().c_str(),triggerPhys->GetGroup());
                     }
                     else
                     {
@@ -155,29 +155,29 @@ class SensorReport : public NxUserTriggerReport
                 if (status & NX_TRIGGER_ON_ENTER && triggerPhys->Should_I_Trigger(status & NX_TRIGGER_ON_ENTER, otherPos) )
                 {
                     if (plSimulationMgr::fExtraProfile)
-                        DetectorLogRed("-->Send Collision (CH) %s %s",triggerPhys->GetObjectKey()->GetName(),status & NX_TRIGGER_ON_ENTER ? "enter" : "exit");
+                        DetectorLogRed("-->Send Collision (CH) %s %s",triggerPhys->GetObjectKey()->GetName().c_str(),status & NX_TRIGGER_ON_ENTER ? "enter" : "exit");
                     SendCollisionMsg(triggerPhys->GetObjectKey(), otherKey, true);
                 }
                 else if (status & NX_TRIGGER_ON_ENTER)
                 {
                     if (plSimulationMgr::fExtraProfile)
-                        DetectorLogRed("<--Kill collision %s :failed Should I trigger",triggerPhys->GetObjectKey()->GetName());
+                        DetectorLogRed("<--Kill collision %s :failed Should I trigger",triggerPhys->GetObjectKey()->GetName().c_str());
                 }
                 if (status & NX_TRIGGER_ON_LEAVE && triggerPhys->Should_I_Trigger(status & NX_TRIGGER_ON_ENTER, otherPos) )
                 {
                     if (plSimulationMgr::fExtraProfile)
-                        DetectorLogRed("-->Send Collision (CH) %s %s",triggerPhys->GetObjectKey()->GetName(),status & NX_TRIGGER_ON_ENTER ? "enter" : "exit");
+                        DetectorLogRed("-->Send Collision (CH) %s %s",triggerPhys->GetObjectKey()->GetName().c_str(),status & NX_TRIGGER_ON_ENTER ? "enter" : "exit");
                     SendCollisionMsg(triggerPhys->GetObjectKey(), otherKey, false);
                 }
                 else if (status & NX_TRIGGER_ON_LEAVE)
                 {
                     if (plSimulationMgr::fExtraProfile)
-                        DetectorLogRed("<--Kill collision %s :failed Should I trigger",triggerPhys->GetObjectKey()->GetName());
+                        DetectorLogRed("<--Kill collision %s :failed Should I trigger",triggerPhys->GetObjectKey()->GetName().c_str());
                 }
                 if (!(status & NX_TRIGGER_ON_ENTER) && !(status & NX_TRIGGER_ON_LEAVE) )
                 {
                     if (plSimulationMgr::fExtraProfile)
-                        DetectorLogRed("<--Kill collision %s :failed event(CH)",triggerPhys->GetObjectKey()->GetName());
+                        DetectorLogRed("<--Kill collision %s :failed event(CH)",triggerPhys->GetObjectKey()->GetName().c_str());
                 }
             }
             else
@@ -186,19 +186,19 @@ class SensorReport : public NxUserTriggerReport
                 if (status & NX_TRIGGER_ON_ENTER)
                 {
                     if (plSimulationMgr::fExtraProfile)
-                        DetectorLogRed("-->Send Collision %s %s",triggerPhys->GetObjectKey()->GetName(),status & NX_TRIGGER_ON_ENTER ? "enter" : "exit");
+                        DetectorLogRed("-->Send Collision %s %s",triggerPhys->GetObjectKey()->GetName().c_str(),status & NX_TRIGGER_ON_ENTER ? "enter" : "exit");
                     SendCollisionMsg(triggerPhys->GetObjectKey(), otherKey, true);
                 }
                 if (status & NX_TRIGGER_ON_LEAVE)
                 {
                     if (plSimulationMgr::fExtraProfile)
-                        DetectorLogRed("-->Send Collision %s %s",triggerPhys->GetObjectKey()->GetName(),status & NX_TRIGGER_ON_ENTER ? "enter" : "exit");
+                        DetectorLogRed("-->Send Collision %s %s",triggerPhys->GetObjectKey()->GetName().c_str(),status & NX_TRIGGER_ON_ENTER ? "enter" : "exit");
                     SendCollisionMsg(triggerPhys->GetObjectKey(), otherKey, false);
                 }
                 if (!(status & NX_TRIGGER_ON_ENTER) && !(status & NX_TRIGGER_ON_LEAVE) )
                 {
                     if (plSimulationMgr::fExtraProfile)
-                        DetectorLogRed("<--Kill collision %s :failed event",triggerPhys->GetObjectKey()->GetName());
+                        DetectorLogRed("<--Kill collision %s :failed event",triggerPhys->GetObjectKey()->GetName().c_str());
                 }
 #ifdef USE_PHYSX_CONVEXHULL_WORKAROUND
             }
@@ -208,7 +208,7 @@ class SensorReport : public NxUserTriggerReport
 
     void SendCollisionMsg(plKey receiver, plKey hitter, hsBool entering)
     {
-        DetectorLogYellow("Collision: %s was triggered by %s. Sending an %s msg", receiver->GetName(), 
+        DetectorLogYellow("Collision: %s was triggered by %s. Sending an %s msg", receiver->GetName().c_str(),
                           hitter ? hitter->GetName().c_str() : "(nil)" , entering ? "'enter'" : "'exit'");
         plCollideMsg* msg = new plCollideMsg;
         msg->fOtherKey = hitter;
@@ -962,7 +962,7 @@ void plSimulationMgr::IDrawActiveActorList()
     for (SceneMap::iterator it = fScenes.begin(); it != fScenes.end(); it++)
     {
         
-        sprintf(strBuf, "Scene: %s",it->first->GetName());
+        sprintf(strBuf, "Scene: %s",it->first->GetName().c_str());
         debugTxt.DrawString(x, y, strBuf);
         y += lineHeight;
         uint32_t numActors =it->second->getNbActors();