diff --git a/Engine/source/afx/afxEffectVector.cpp b/Engine/source/afx/afxEffectVector.cpp
index 47e0d1aee..5de0a5e40 100644
--- a/Engine/source/afx/afxEffectVector.cpp
+++ b/Engine/source/afx/afxEffectVector.cpp
@@ -38,52 +38,52 @@ void afxEffectVector::filter_client_server()
   if (empty())
     return;
 
-  for (S32 i = 0; i < fx_v->size(); i++)
+  for (S32 i = 0; i < mFX_v->size(); i++)
   {
-    if ((*fx_v)[i]->mDatablock->runsHere(on_server))
-      fx_v2->push_back((*fx_v)[i]);
+    if ((*mFX_v)[i]->mDatablock->runsHere(mOn_server))
+      mFX_v2->push_back((*mFX_v)[i]);
     else
     {
-      delete (*fx_v)[i];
-      (*fx_v)[i] = 0;
+      delete (*mFX_v)[i];
+      (*mFX_v)[i] = 0;
     }
   }
 
   swap_vecs();
 
-  fx_v2->clear();
+  mFX_v2->clear();
 }
 
 void afxEffectVector::calc_fx_dur_and_afterlife()
 {
-  total_fx_dur = 0.0f;
-  after_life = 0.0f;
+  mTotal_fx_dur = 0.0f;
+  mAfter_life = 0.0f;
 
   if (empty())
     return;
 
-  for (S32 i = 0; i < fx_v->size(); i++)
+  for (S32 i = 0; i < mFX_v->size(); i++)
   {
-    afxEffectWrapper* ew = (*fx_v)[i];
+    afxEffectWrapper* ew = (*mFX_v)[i];
     if (ew)
     {
       F32 ew_dur;
       if (ew->mEW_timing.lifetime < 0)
       {
-        if (phrase_dur > ew->mEW_timing.delay)
-          ew_dur = phrase_dur + ew->afterStopTime();
+        if (mPhrase_dur > ew->mEW_timing.delay)
+          ew_dur = mPhrase_dur + ew->afterStopTime();
         else
           ew_dur = ew->mEW_timing.delay + ew->afterStopTime();
       }
       else
         ew_dur = ew->mEW_timing.delay + ew->mEW_timing.lifetime + ew->mEW_timing.fade_out_time;
 
-      if (ew_dur > total_fx_dur)
-        total_fx_dur = ew_dur;
+      if (ew_dur > mTotal_fx_dur)
+        mTotal_fx_dur = ew_dur;
 
       F32 after = ew->afterStopTime();
-      if (after > after_life)
-        after_life = after;
+      if (after > mAfter_life)
+        mAfter_life = after;
     }
   }
 }
@@ -92,19 +92,19 @@ void afxEffectVector::calc_fx_dur_and_afterlife()
 
 afxEffectVector::afxEffectVector()
 {
-  fx_v = 0;
-  fx_v2 = 0;
-  active = false;
-  on_server = false;
-  total_fx_dur = 0;
-  after_life = 0;
+  mFX_v = 0;
+  mFX_v2 = 0;
+  mActive = false;
+  mOn_server = false;
+  mTotal_fx_dur = 0;
+  mAfter_life = 0;
 }
 
 afxEffectVector::~afxEffectVector()
 {
   stop(true);
-  delete fx_v;
-  delete fx_v2;
+  delete mFX_v;
+  delete mFX_v2;
 }
 
 void afxEffectVector::effects_init(afxChoreographer* chor, afxEffectList& effects, bool will_stop, F32 time_factor, 
@@ -189,7 +189,7 @@ void afxEffectVector::effects_init(afxChoreographer* chor, afxEffectList& effect
           afxEffectWrapper* effect;
           effect = afxEffectWrapper::ew_create(chor, ewd, cons_mgr, time_factor, group_index);
           if (effect)
-            fx_v->push_back(effect);
+            mFX_v->push_back(effect);
         }      
       }
       else
@@ -205,14 +205,14 @@ void afxEffectVector::effects_init(afxChoreographer* chor, afxEffectList& effect
 void afxEffectVector::ev_init(afxChoreographer* chor, afxEffectList& effects, bool on_server, 
                               bool will_stop, F32 time_factor, F32 phrase_dur, S32 group_index)
 {
-  this->on_server = on_server;
-  this->phrase_dur = phrase_dur;
+  mOn_server = on_server;
+  mPhrase_dur = phrase_dur;
 
-  fx_v = new Vector<afxEffectWrapper*>;
+  mFX_v = new Vector<afxEffectWrapper*>;
 
   effects_init(chor, effects, will_stop, time_factor, group_index);
 
-  fx_v2 = new Vector<afxEffectWrapper*>(fx_v->size());
+  mFX_v2 = new Vector<afxEffectWrapper*>(mFX_v->size());
 }
 
 void afxEffectVector::start(F32 timestamp)
@@ -222,8 +222,8 @@ void afxEffectVector::start(F32 timestamp)
 
   // At this point both client and server effects are in the list.
   // Timing adjustments are made during prestart().
-  for (S32 i = 0; i < fx_v->size(); i++)
-    (*fx_v)[i]->prestart();
+  for (S32 i = 0; i < mFX_v->size(); i++)
+    (*mFX_v)[i]->prestart();
 
   // duration and afterlife values are pre-calculated here
   calc_fx_dur_and_afterlife();
@@ -232,58 +232,58 @@ void afxEffectVector::start(F32 timestamp)
   // don't belong here,
   filter_client_server();
 
-  active = true;
+  mActive = true;
 
-  for (S32 j = 0; j < fx_v->size(); j++)
+  for (S32 j = 0; j < mFX_v->size(); j++)
   {
-    if ((*fx_v)[j]->start(timestamp))
-      fx_v2->push_back((*fx_v)[j]);
+    if ((*mFX_v)[j]->start(timestamp))
+      mFX_v2->push_back((*mFX_v)[j]);
     else
     {
-      delete (*fx_v)[j];
-      (*fx_v)[j] = 0;
+      delete (*mFX_v)[j];
+      (*mFX_v)[j] = 0;
     }
   }
 
   swap_vecs();
-  fx_v2->clear();
+  mFX_v2->clear();
 }
 
 void afxEffectVector::update(F32 dt)
 {
   if (empty())
   {
-    active = false;
+    mActive = false;
     return;
   }
 
-  for (int i = 0; i < fx_v->size(); i++)
+  for (int i = 0; i < mFX_v->size(); i++)
   {
-    (*fx_v)[i]->update(dt);
+    (*mFX_v)[i]->update(dt);
 
-    if ((*fx_v)[i]->isDone() || (*fx_v)[i]->isAborted())
+    if ((*mFX_v)[i]->isDone() || (*mFX_v)[i]->isAborted())
     {
       // effect has ended, cleanup and delete
-      (*fx_v)[i]->cleanup();
-      delete (*fx_v)[i];
-      (*fx_v)[i] = 0;
+      (*mFX_v)[i]->cleanup();
+      delete (*mFX_v)[i];
+      (*mFX_v)[i] = 0;
     }
     else
     {
       // effect is still going, so keep it around
-      fx_v2->push_back((*fx_v)[i]);
+      mFX_v2->push_back((*mFX_v)[i]);
     }
   }
 
   swap_vecs();
 
-  fx_v2->clear();
+  mFX_v2->clear();
 
   if (empty())
   {
-    active = false;
-    delete fx_v; fx_v =0;
-    delete fx_v2; fx_v2 = 0;
+    mActive = false;
+    delete mFX_v; mFX_v =0;
+    delete mFX_v2; mFX_v2 = 0;
   }
 }
 
@@ -291,37 +291,37 @@ void afxEffectVector::stop(bool force_cleanup)
 {
   if (empty())
   {
-    active = false;
+    mActive = false;
     return;
   }
 
-  for (int i = 0; i < fx_v->size(); i++)
+  for (int i = 0; i < mFX_v->size(); i++)
   {
-    (*fx_v)[i]->stop();
+    (*mFX_v)[i]->stop();
 
-    if (force_cleanup || (*fx_v)[i]->deleteWhenStopped())
+    if (force_cleanup || (*mFX_v)[i]->deleteWhenStopped())
     {
       // effect is over when stopped, cleanup and delete 
-      (*fx_v)[i]->cleanup();
-      delete (*fx_v)[i];
-      (*fx_v)[i] = 0;
+      (*mFX_v)[i]->cleanup();
+      delete (*mFX_v)[i];
+      (*mFX_v)[i] = 0;
     }
     else
     {
       // effect needs to fadeout or something, so keep it around
-      fx_v2->push_back((*fx_v)[i]);
+		mFX_v2->push_back((*mFX_v)[i]);
     }
   }
 
   swap_vecs();
 
-  fx_v2->clear();
+  mFX_v2->clear();
 
   if (empty())
   {
-    active = false;
-    delete fx_v; fx_v =0;
-    delete fx_v2; fx_v2 = 0;
+    mActive = false;
+    delete mFX_v; mFX_v =0;
+    delete mFX_v2; mFX_v2 = 0;
   }
 }
 
@@ -329,27 +329,27 @@ void afxEffectVector::interrupt()
 {
   if (empty())
   {
-    active = false;
+    mActive = false;
     return;
   }
 
-  for (int i = 0; i < fx_v->size(); i++)
+  for (int i = 0; i < mFX_v->size(); i++)
   {
-    (*fx_v)[i]->stop();
-    (*fx_v)[i]->cleanup();
-    delete (*fx_v)[i];
-    (*fx_v)[i] = 0;
+    (*mFX_v)[i]->stop();
+    (*mFX_v)[i]->cleanup();
+    delete (*mFX_v)[i];
+    (*mFX_v)[i] = 0;
   }
 
   swap_vecs();
 
-  fx_v2->clear();
+  mFX_v2->clear();
 
   if (empty())
   {
-    active = false;
-    delete fx_v; fx_v =0;
-    delete fx_v2; fx_v2 = 0;
+    mActive = false;
+    delete mFX_v; mFX_v =0;
+    delete mFX_v2; mFX_v2 = 0;
   }
 }
 
diff --git a/Engine/source/afx/afxEffectVector.h b/Engine/source/afx/afxEffectVector.h
index 49dc11908..837dfe2ce 100644
--- a/Engine/source/afx/afxEffectVector.h
+++ b/Engine/source/afx/afxEffectVector.h
@@ -37,14 +37,14 @@ class afxChoreographer;
 
 class afxEffectVector
 {
-  Vector<afxEffectWrapper*>*  fx_v;
-  Vector<afxEffectWrapper*>*  fx_v2;
+  Vector<afxEffectWrapper*>*  mFX_v;
+  Vector<afxEffectWrapper*>*  mFX_v2;
 
-  bool          active;
-  bool          on_server;
-  F32           phrase_dur;
-  F32           total_fx_dur;
-  F32           after_life;
+  bool          mActive;
+  bool          mOn_server;
+  F32           mPhrase_dur;
+  F32           mTotal_fx_dur;
+  F32           mAfter_life;
 
   void          swap_vecs();
   void          filter_client_server();
@@ -64,21 +64,21 @@ public:
   void          update(F32 dt);
   void          stop(bool force_cleanup=false);
   void          interrupt();
-  bool          empty() { return (!fx_v || fx_v->empty()); }
-  bool          isActive() { return active; }
-  S32           count() { return (fx_v) ? fx_v->size() : 0; }
+  bool          empty() { return (!mFX_v || mFX_v->empty()); }
+  bool          isActive() { return mActive; }
+  S32           count() { return (mFX_v) ? mFX_v->size() : 0; }
 
-  F32           getTotalDur() { return total_fx_dur; }
-  F32           getAfterLife() { return after_life; }
+  F32           getTotalDur() { return mTotal_fx_dur; }
+  F32           getAfterLife() { return mAfter_life; }
 
-  Vector<afxEffectWrapper*>* getFX() { return fx_v; }
+  Vector<afxEffectWrapper*>* getFX() { return mFX_v; }
 };
 
 inline void afxEffectVector::swap_vecs()
 {
-  Vector<afxEffectWrapper*>* tmp = fx_v;
-  fx_v = fx_v2;
-  fx_v2 = tmp;
+  Vector<afxEffectWrapper*>* tmp = mFX_v;
+  mFX_v = mFX_v2;
+  mFX_v2 = tmp;
 }
 
 //~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//
diff --git a/Engine/source/afx/afxMagicSpell.cpp b/Engine/source/afx/afxMagicSpell.cpp
index f9fb2ba01..513df0d13 100644
--- a/Engine/source/afx/afxMagicSpell.cpp
+++ b/Engine/source/afx/afxMagicSpell.cpp
@@ -604,9 +604,9 @@ void CastingPhrase_C::update(F32 dt, F32 timestamp)
   if (!mNotify_castbar)
     return;
 
-  if (dur > 0 && n_loops > 0)
+  if (mDur > 0 && mNum_loops > 0)
   {
-    F32 nfrac = (timestamp - starttime)/(dur*n_loops);
+    F32 nfrac = (timestamp - mStartTime)/(mDur*mNum_loops);
     if (nfrac - mCastbar_progress > 1.0f/200.0f)
     {
       mCastbar_progress = (nfrac < 1.0f) ? nfrac : 1.0f;
diff --git a/Engine/source/afx/afxPhrase.cpp b/Engine/source/afx/afxPhrase.cpp
index 3e0a2bee0..3f4e44167 100644
--- a/Engine/source/afx/afxPhrase.cpp
+++ b/Engine/source/afx/afxPhrase.cpp
@@ -34,51 +34,51 @@
 void
 afxPhrase::init_fx(S32 group_index)
 {
-  fx->ev_init(init_chor, *init_fx_list, on_server, will_stop, init_time_factor, init_dur, group_index); 
+  mFX->ev_init(mInit_chor, *mInit_fx_list, mOn_server, mWill_stop, mInit_time_factor, mInit_dur, group_index); 
 }
 
 //~~~~~~~~~~~~~~~~~~~~//
 
 afxPhrase::afxPhrase(bool on_server, bool will_stop)
 {
-  this->on_server = on_server;
-  this->will_stop = will_stop;
+  mOn_server = on_server;
+  mWill_stop = will_stop;
 
-  init_fx_list = NULL;
-  init_dur = 0.0f;
-  init_chor = NULL;
-  init_time_factor = 1.0f;
+  mInit_fx_list = NULL;
+  mInit_dur = 0.0f;
+  mInit_chor = NULL;
+  mInit_time_factor = 1.0f;
 
-  fx = new afxEffectVector;
-  fx2 = NULL;
-  starttime = 0;
-  dur = 0;
+  mFX = new afxEffectVector;
+  mFX2 = NULL;
+  mStartTime = 0;
+  mDur = 0;
 
-  n_loops = 1;
-  loop_cnt = 1;
+  mNum_loops = 1;
+  mLoop_cnt = 1;
 
-  extra_time = 0.0f;
-  extra_stoptime = 0.0f;
+  mExtra_time = 0.0f;
+  mExtra_stoptime = 0.0f;
 }
 
 afxPhrase::~afxPhrase()
 {
-  delete fx;
-  delete fx2;
+  delete mFX;
+  delete mFX2;
 };
 
 void 
 afxPhrase::init(afxEffectList& fx_list, F32 dur, afxChoreographer* chor, F32 time_factor, 
                 S32 n_loops, S32 group_index, F32 extra_time)
 {
-  init_fx_list = &fx_list;
-  init_dur = dur;
-  init_chor = chor;
-  init_time_factor = time_factor;
+  mInit_fx_list = &fx_list;
+  mInit_dur = dur;
+  mInit_chor = chor;
+  mInit_time_factor = time_factor;
 
-  this->n_loops = n_loops;
-  this->extra_time = extra_time;
-  this->dur = (init_dur < 0) ? init_dur : init_dur*init_time_factor;
+  mNum_loops = n_loops;
+  mExtra_time = extra_time;
+  mDur = (mInit_dur < 0) ? mInit_dur : mInit_dur*mInit_time_factor;
 
   init_fx(group_index);
 }
@@ -86,30 +86,30 @@ afxPhrase::init(afxEffectList& fx_list, F32 dur, afxChoreographer* chor, F32 tim
 void
 afxPhrase::start(F32 startstamp, F32 timestamp)
 {
-  starttime = startstamp;
+  mStartTime = startstamp;
 
   F32 loopstart = timestamp - startstamp;
 
-  if (dur > 0 && loopstart > dur)
+  if (mDur > 0 && loopstart > mDur)
   {
-    loop_cnt += (S32) (loopstart/dur);
-    loopstart = mFmod(loopstart, dur);
+    mLoop_cnt += (S32) (loopstart/ mDur);
+    loopstart = mFmod(loopstart, mDur);
   }
 
-  if (!fx->empty())
-    fx->start(loopstart);
+  if (!mFX->empty())
+    mFX->start(loopstart);
 }
 
 void
 afxPhrase::update(F32 dt, F32 timestamp)
 {
-  if (fx->isActive())
-    fx->update(dt);
+  if (mFX->isActive())
+    mFX->update(dt);
 
-  if (fx2 && fx2->isActive())
-    fx2->update(dt);
+  if (mFX2 && mFX2->isActive())
+    mFX2->update(dt);
 
-  if (extra_stoptime > 0 && timestamp > extra_stoptime)
+  if (mExtra_stoptime > 0 && timestamp > mExtra_stoptime)
   {
     stop(timestamp);
   }
@@ -118,54 +118,54 @@ afxPhrase::update(F32 dt, F32 timestamp)
 void
 afxPhrase::stop(F32 timestamp)
 {
-  if (extra_time > 0 && !(extra_stoptime > 0))
+  if (mExtra_time > 0 && !(mExtra_stoptime > 0))
   {
-    extra_stoptime = timestamp + extra_time;
+    mExtra_stoptime = timestamp + mExtra_time;
     return;
   }
 
-  if (fx->isActive())
-    fx->stop();
+  if (mFX->isActive())
+    mFX->stop();
 
-  if (fx2 && fx2->isActive())
-    fx2->stop();
+  if (mFX2 && mFX2->isActive())
+    mFX2->stop();
 }
 
 bool
 afxPhrase::expired(F32 timestamp)
 {
-  if (dur < 0)
+  if (mDur < 0)
     return false;
 
-  return ((timestamp - starttime) > loop_cnt*dur);
+  return ((timestamp - mStartTime) > mLoop_cnt*mDur);
 }
 
 F32
 afxPhrase::elapsed(F32 timestamp)
 {
-  return (timestamp - starttime);
+  return (timestamp - mStartTime);
 }
 
 bool
 afxPhrase::recycle(F32 timestamp)
 {
-  if (n_loops < 0 || loop_cnt < n_loops)
+  if (mNum_loops < 0 || mLoop_cnt < mNum_loops)
   {
-    if (fx2)
-      delete fx2;
+    if (mFX2)
+      delete mFX2;
 
-    fx2 = fx;
+	mFX2 = mFX;
 
-    fx = new afxEffectVector;
+	mFX = new afxEffectVector;
     init_fx();
 
-    if (fx2 && !fx2->empty())
-      fx2->stop();
+    if (mFX2 && !mFX2->empty())
+      mFX2->stop();
 
-    if (!fx->empty())
-      fx->start(0.0F);
+    if (!mFX->empty())
+      mFX->start(0.0F);
 
-    loop_cnt++;
+	mLoop_cnt++;
     return true;
   }
 
@@ -175,21 +175,21 @@ afxPhrase::recycle(F32 timestamp)
 void
 afxPhrase::interrupt(F32 timestamp)
 {
-  if (fx->isActive())
-    fx->interrupt();
+  if (mFX->isActive())
+    mFX->interrupt();
 
-  if (fx2 && fx2->isActive())
-    fx2->interrupt();
+  if (mFX2 && mFX2->isActive())
+    mFX2->interrupt();
 }
 
 F32 afxPhrase::calcDoneTime()
 {
-  return starttime + fx->getTotalDur();
+  return mStartTime + mFX->getTotalDur();
 }
 
 F32 afxPhrase::calcAfterLife()
 {
-  return fx->getAfterLife();
+  return mFX->getAfterLife();
 }
 
 
diff --git a/Engine/source/afx/afxPhrase.h b/Engine/source/afx/afxPhrase.h
index 2525c2656..12803dc5f 100644
--- a/Engine/source/afx/afxPhrase.h
+++ b/Engine/source/afx/afxPhrase.h
@@ -38,23 +38,23 @@ class afxEffectVector;
 class afxPhrase
 {
 protected:
-  afxEffectList*    init_fx_list;
-  F32               init_dur;
-  afxChoreographer* init_chor;
-  F32               init_time_factor;
-  F32               extra_time;
+  afxEffectList*    mInit_fx_list;
+  F32               mInit_dur;
+  afxChoreographer* mInit_chor;
+  F32               mInit_time_factor;
+  F32               mExtra_time;
 
-  afxEffectVector*  fx;
-  afxEffectVector*  fx2;
+  afxEffectVector*  mFX;
+  afxEffectVector*  mFX2;
 
-  bool              on_server;
-  bool              will_stop;
+  bool              mOn_server;
+  bool              mWill_stop;
 
-  F32               starttime;
-  F32               dur;
-  S32               n_loops;
-  S32               loop_cnt;
-  F32               extra_stoptime;
+  F32               mStartTime;
+  F32               mDur;
+  S32               mNum_loops;
+  S32               mLoop_cnt;
+  F32               mExtra_stoptime;
 
   void              init_fx(S32 group_index=0);
 
@@ -73,13 +73,13 @@ public:
   virtual bool      recycle(F32 timestamp);
   virtual F32       elapsed(F32 timestamp);
 
-  bool              isEmpty() { return fx->empty(); }
-  bool              isInfinite() { return (init_dur < 0); }
+  bool              isEmpty() { return mFX->empty(); }
+  bool              isInfinite() { return (mInit_dur < 0); }
   F32               calcDoneTime();
   F32               calcAfterLife();
-  bool              willStop() { return will_stop; }
-  bool              onServer() { return on_server; }
-  S32               count() { return fx->count(); }
+  bool              willStop() { return mWill_stop; }
+  bool              onServer() { return mOn_server; }
+  S32               count() { return mFX->count(); }
 };
 
 //~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//