diff --git a/std/living/description.c b/std/living/description.c
index 04e65e2..4802a1b 100644
--- a/std/living/description.c
+++ b/std/living/description.c
@@ -326,13 +326,15 @@
   return Query(P_REAL_RACE,F_VALUE)||QueryProp(P_RACE);
 }
 
-static mixed _set_name(mixed nm )
+static <string|string*> _set_name(<string|string*> nm )
 {
   string lvnam;
-  lvnam = nm;
-  if(pointerp(nm)) lvnam = nm[0];
+  if (pointerp(nm))
+    lvnam = nm[WER];
+  else
+    lvnam = nm;
   set_living_name(lower_case(lvnam));
-  return Set(P_NAME, nm);
+  return Set(P_NAME, nm, F_VALUE);
 }
 
 int _query_container()
@@ -340,7 +342,7 @@
   return 0;
 }
 
-int is_class_member(mixed str) {
+int is_class_member(<string|string*> str) {
   // Keine Klasse, keine Mitgliedschaft ...
   if (!str || (!stringp(str) && !pointerp(str)) || str=="") 
       return 0;
diff --git a/std/player/base.c b/std/player/base.c
index 61815a2..95d70c0 100644
--- a/std/player/base.c
+++ b/std/player/base.c
@@ -1503,7 +1503,6 @@
   * @see short_score()
   */
 static int score(string arg) {
-  string tmp, gender;
   int i,sz,val;
   mixed ind;
   object *enem1, *enem2, *inv;
@@ -1514,12 +1513,13 @@
   }
 
   int plev = LEPMASTER->QueryLevel();
- 
-  switch(tmp = QueryProp(P_GENDER)) {
+  <string|int> tmp = QueryProp(P_GENDER);
+  string gender;
+  switch(tmp) {
   case MALE: gender = "maennlich"; break;
   case FEMALE: gender = "weiblich"; break;
   case NEUTER: gender = "neutral"; break;
-  default: gender = lower_case(tmp);
+  default: gender = "unbekannt";
   }
 
   ind = m_indices(QueryProp(P_ATTRIBUTES));
diff --git a/std/room/description.c b/std/room/description.c
index 47390e4..9aa0971 100644
--- a/std/room/description.c
+++ b/std/room/description.c
@@ -61,12 +61,10 @@
 
 static void WriteRoomMessage()
 {
-  int tim, msgid;
-  string *room_msg,func;
-  mixed *func_msg;
+  int msgid;
 
-  room_msg = (string *)QueryProp(P_ROOM_MSG);
-  func_msg = QueryProp(P_FUNC_MSG);
+  string *room_msg = QueryProp(P_ROOM_MSG);
+  <string|string*> func_msg = QueryProp(P_FUNC_MSG);
   if ((!room_msg || !sizeof(room_msg)) && !func_msg)
     return;
 
@@ -81,6 +79,7 @@
 
   if (func_msg)
   {
+    string func;
     if (stringp(func_msg))
       func=(string)func_msg;
     else
@@ -90,10 +89,9 @@
   }
 
   while (remove_call_out("WriteRoomMessage")!=-1);
-  tim=QueryProp(P_MSG_PROB);
   if(this_object() && sizeof(filter(
        deep_inventory(this_object()), #'interactive))) //')))
-    call_out("WriteRoomMessage", (tim<15 ? 15 : tim));
+    call_out("WriteRoomMessage", max(15, QueryProp(P_MSG_PROB)));
 }
 
 varargs string int_long(mixed viewer,mixed viewpoint,int flags)
diff --git a/std/unit.c b/std/unit.c
index ae715f2..fd3820a 100644
--- a/std/unit.c
+++ b/std/unit.c
@@ -176,10 +176,9 @@
 
 void AddSingularId(mixed str)
 {
-  string *ids;
+  string **ids=Query(U_IDS);
   if (!pointerp(str))
     str=({str});
-  ids=Query(U_IDS);
   Set(U_IDS,({ids[0]+str,ids[1]}));
 }
 
@@ -193,8 +192,7 @@
  
 void AddPluralId(mixed str)
 {
-  string *ids;
-  
+  string **ids;
   if (!pointerp(str))
     str=({str});
   ids=Query(U_IDS);
@@ -317,7 +315,7 @@
 varargs int id(string str,int lvl)
 {
 
-  string s1,s2,*ids;
+  string s1,s2,**ids;
   int i;
 
   if (!str) return 0;
@@ -333,31 +331,28 @@
     return 1;
   }
 
- ids=Query(U_IDS);
+  ids=Query(U_IDS);
   if (!ids)
     return 0;
- 
-  //die casts auf 'mixed' sind absicht. Sonst geht der Driver offenbar davon
-  //aus, dass ids[1] ein String ist. Es ist aber aber ein Array von Strings
-  //und genau das will auch match_item() haben. ;-) Zesstra
-  if (match_item(str,(mixed)ids[1] )) {
+
+  if (match_item(str, ids[1] )) {
     SetProp(U_REQ, amount);
     return 1;
   }
-  if (match_item(str,(mixed)ids[0] )) {
+  if (match_item(str, ids[0] )) {
     SetProp(U_REQ,1);
     return 1;
   }
   if (sscanf(str,"%s %s",s1,s2) && s1[0..3]=="alle" && 
-    match_item(s2,(mixed)ids[1] )) {
+    match_item(s2, ids[1] )) {
     SetProp(U_REQ, amount);
     return 1;
   }
-  if (sscanf(str,"%d %s",i,s1)==2 && i==1 && match_item(s1,(mixed)ids[0] )) {
+  if (sscanf(str,"%d %s",i,s1)==2 && i==1 && match_item(s1, ids[0] )) {
     SetProp(U_REQ,1);
     return 1;
   }
-  if (sscanf(str,"%d %s",i,s1)==2 && match_item(s1,(mixed)ids[1] ) && 
+  if (sscanf(str,"%d %s",i,s1)==2 && match_item(s1, ids[1] ) && 
       i<=amount && i>0) {
     SetProp(U_REQ,i);
     return 1;
