Исправление русских имен

Тема в разделе "Кодинг", создана пользователем Flame, 7 янв 2015.

  1. Flame

    Flame -Заслуженый кодер форума-

    У меня на серваках ник игрока поигравшего 3+ волны фиксируется навсегда и сменить его могу только я
    И я уже конкретно задрался править всевозможные олаРAРРРЖ_РРР

    Написав простенький мутатор - я собрал информацию какие символы передаются в игру
    Алфавит получился такой.
    а 176 224
    б 177 225
    в 1030 226
    г 1110 227
    д 1169 228
    е 181 229
    ё 8216 184
    ж 182 230
    з 183 231
    и 1105 232
    й 8470 233
    к 1108 234
    л 187 235
    м 1112 236
    н 1029 237
    о 1109 238
    п 1111 239
    р 1026 240
    с 1027 241
    т 8218 242
    у 1107 243
    ф 8222 244
    х 8230 245
    ц 8224 246
    ч 8225 247
    ш 8364 248
    щ 8240 249
    ъ 1033 250
    ы 8249 251
    ь 1034 252
    э 1036 253
    ю 1035 254
    я 1039 255

    А 1106 192
    Б 8216 193
    В 8217 194
    Г 8220 195
    Д 8221 196
    Е 8226 197
    Ё 1027 168
    Ж 8211 198
    З 8212 199
    И 152 200
    Й 8482 201
    К 1113 202
    Л 8250 203
    М 1114 204
    Н 1116 205
    О 1115 206
    П 1119 207
    Р 160 208
    С 1038 209
    Т 1118 210
    У 1032 211
    Ф 164 212
    Х 1168 213
    Ц 166 214
    Ч 167 215
    Ш 1025 216
    Щ 169 217
    Ъ 1028 218
    Ы 171 219
    Ь 172 220
    Э 173 221
    Ю 174 222
    Я 1031 223

    Нам важен 2 столбец. Именно эти коды символов передаются из стима
    Принцип я пока не понял, поэтому просто тупо сделал расшифровку
    В 3 столбце те символы, что нам нужны (ну плюс сдвиг на 848)

    В итоге можно сделать такой мутатор
    Либо, если не хочется увеличивать число мутаторов по пустякам (ибо это важный ресурс) можно поправить ServerPerks
    Например, открыть класс ServerPerksMut.ServerStStats и поправить функцию PostBeginPlay
    В конце функции дописав
    PlayerOwner.PlayerReplicationInfo.PlayerName = ConvertSteamString(PlayerOwner.PlayerReplicationInfo.PlayerName);
    И дописав пару функций
    Код:
    function string ConvertSteamString(string msg)
    {
    	local int i;
    	local string tmp;
    	local string result;
    	local int code;
    	tmp=msg;
    	for(i=0; i<Len(msg); i++)
    	{
    		code=Asc(tmp);
    		if(code==1056 || code==1057)
    		{
    			tmp=Mid(tmp,1);
    			continue;
    		}
    		code=FixCode(code);
    		if(code>167)
    			code+=848;
    		if(i==0) result=Chr(code);
    		else result=result$Chr(code);
    		tmp=Mid(tmp,1);
    	}
    	return result;
    }
    
    function int FixCode(int code)
    {
    	switch(code)
    	{
    		case 176:	return 224;
    		case 177:	return 225;
    		case 1030:	return 226;
    		case 1110:	return 227;
    		case 1169:	return 228;
    		case 181:	return 229;
    		case 8216:	return 184;
    		case 182:	return 230;
    		case 183:	return 231;
    		case 1105:	return 232;
    		case 8470:	return 233;
    		case 1108:	return 234;
    		case 187:	return 235;
    		case 1112:	return 236;
    		case 1029:	return 237;
    		case 1109:	return 238;
    		case 1111:	return 239;
    		case 1026:	return 240;
    		case 1027:	return 241;
    		case 8218:	return 242;
    		case 1107:	return 243;
    		case 8222:	return 244;
    		case 8230:	return 245;
    		case 8224:	return 246;
    		case 8225:	return 247;
    		case 8364:	return 248;
    		case 8240:	return 249;
    		case 1033:	return 250;
    		case 8249:	return 251;
    		case 1034:	return 252;
    		case 1036:	return 253;
    		case 1035:	return 254;
    		case 1039:	return 255;
    		case 1106:	return 192;
    		case 8216:	return 193;
    		case 8217:	return 194;
    		case 8220:	return 195;
    		case 8221:	return 196;
    		case 8226:	return 197;
    		case 1027:	return 168;
    		case 8211:	return 198;
    		case 8212:	return 199;
    		case 152:	return 200;
    		case 8482:	return 201;
    		case 1113:	return 202;
    		case 8250:	return 203;
    		case 1114:	return 204;
    		case 1116:	return 205;
    		case 1115:	return 206;
    		case 1119:	return 207;
    		case 160:	return 208;
    		case 1038:	return 209;
    		case 1118:	return 210;
    		case 1032:	return 211;
    		case 164:	return 212;
    		case 1168:	return 213;
    		case 166:	return 214;
    		case 167:	return 215;
    		case 1025:	return 216;
    		case 169:	return 217;
    		case 1028:	return 218;
    		case 171:	return 219;
    		case 172:	return 220;
    		case 173:	return 221;
    		case 174:	return 222;
    		case 1031:	return 223;
    	}
    	return code;
    }
    
    Ниже ссылка на архив с поправленным ServerStStats, поправленным пакетом ServerPerksMut для совсем уж ленивых и с мутатором
    Ссылка 1 или Ссылка 2


    Особо сильно не тестировал - отлавливайте ошибки. Например, я накосячил с буквой "е". Хорошо я проверял ником Флейм и заметил)

    Сейчас заодно поправлю русский чат в вебадминке, чтобы можно было использовать "ё"
     
    HATAXA, ЛОХМАТЫЙ, prototype22 и ещё 1-му нравится это.
  2. denfil777

    denfil777 Капо

    Если ты про мутатор вэб админки то и варнинги пожалуйста поправь если можно..
     
  3. Flame

    Flame -Заслуженый кодер форума-

    Какой именно мутатор ты имеешь в виду. Тут есть моя версия и Киллджоя) И что у тебя за варнинги
     
  4. denfil777

    denfil777 Капо

    С использованием Broadcast`а твоя версия?

    Warning: WACBroadcastHandler KF-{R13}Laboratory.WACBroadcastHandler (Function R13PerksMut.WACBroadcastHandler
     
  5. Flame

    Flame -Заслуженый кодер форума-

    Нет. Моя с заменой файлов ведадминки
     
  6. kok-s

    kok-s Консильери

    Если не сложно можешь выложить этот мут. Это просто гениальная мысль фиксировать ники.
     
  7. Flame

    Flame -Заслуженый кодер форума-

    Позже выложу что-нибудь подобное

    Не забывайте напоминать) Но не чаще пары раз в неделю)
     
  8. Dronis

    Dronis Бандит

    Flame спасибо большое, проблема была актуальной, действительно ё отображается как " ~ "
    Но работает вроде замечательно, правил конечно вручную код на свой срстатс

    На заметку вам что в serverperkstat.ini записывает как Дронис_ёй а в игре со стима Дронис_ёй
    в чатлоге если пишу то ник накрывает, если помер то читаемо.
    [​IMG]
    в joinlog
    [​IMG]

    есть возможность править ?
     
  9. kok-s

    kok-s Консильери

    У меня когда игрок заходит на серв, то ник правится на читаемый, но после почему-то становится вот таким ~~~~~~~~~. Кто знает как исправить?
     
  10. khasky

    khasky Новенький

    Могу ошибаться, но кажется это связано с иной кодировкой символов на пиратках. Поэкспериментировав, собрал алфавит и сделал функцию для конвертации в "транслит". Может кому и пригодится.
    Код:
    function string GetLatinCharFromCyrillic(int charCode)
    {
       switch (charCode)
       {
         case 1920: case 1072: return "a";
         case 1888: case 1040: return "A";
         case 1921: case 1073: return "b";
         case 1889: case 1041: return "B";
         case 1922: case 1074: return "v";
         case 1890: case 1042: return "V";
         case 1923: case 1075: return "g";
         case 1891: case 1043: return "G";
         case 1924: case 1076: return "d";
         case 1892: case 1044: return "D";
         case 1925: case 1077: case 1105: return "e";
         case 1893: case 1064: case 1045: case 1025: return "E";
         case 1926: case 1078: return "j";
         case 1894: case 1046: return "J";
         case 1927: case 1079: return "z";
         case 1895: case 1047: return "Z";
         case 1928: case 1929: case 1080: case 1081: return "i";
         case 1896: case 1897: case 1048: case 1049: return "I";
         case 1930: case 1082: return "k";
         case 1898: case 1050: return "K";
         case 1931: case 1083: return "l";
         case 1899: case 1051: return "L";
         case 1932: case 1084: return "m";
         case 1900: case 1052: return "M";
         case 1933: case 1085: return "n";
         case 1901: case 1053: return "N";
         case 1934: case 1086: return "o";
         case 1902: case 1054: return "O";
         case 1935: case 1087: return "p";
         case 1903: case 1055: return "P";
         case 1936: case 1088: return "r";
         case 1906: case 1056: return "R";
         case 1937: case 1089: return "s";
         case 1907: case 1057: return "S";
         case 1938: case 1090: return "t";
         case 1908: case 1058: return "T";
         case 1939: case 1091: return "u";
         case 1909: case 1059: return "U";
         case 1940: case 1092: return "f";
         case 1910: case 1060: return "F";
         case 1941: case 1093: return "h";
         case 1911: case 1061: return "H";
         case 1942: case 1094: return "c";
         case 1912: case 1062: return "C";
         case 1943: case 1095: return "ch";
         case 1913: case 1063: return "Ch";
         case 1944: case 1945: case 1096: case 1097: return "sh";
         case 1914: case 1915: case 1064: case 1065: return "Sh";
         case 1947: case 1099: return "y";
         case 1917: case 1067: return "Y";
         case 1949: case 1101: return "e";
         case 1919: case 1069: return "E";
         case 1950: case 1102: return "yu";
         case 1070: return "Yu";
         case 1951: case 1103: return "ya";
         case 1071: return "Ya";
         default: return "";
       }
    }
     
    Последнее редактирование модератором: 4 мар 2018
    Flame нравится это.
  11. Flame

    Flame -Заслуженый кодер форума-

    Там вроде не в пиратке дело и вроде я правил это
    Уж не знаю какая тут сейчас версия)
    Конвертацию в кириллицу тож как-то делал - для сохранения имён в удалённой базе (ибо там кириллица не живёт). Не помню выкладывал или нет, но раз такое дело - тож выложу класс с утилитиками)
    Код:
    class CyrillicEncodeUtilities extends Object;
    
    //Пусть для определённости SpecialOpen="([{", а SpecialClose="}])"
    
    //Функция конвертирует строку. Символы кириллицы заменяются на символы латиницы, а так же спец символы
    //Например слово проверка конвертируется в строку ([{proverka}]), теsт->([{te}])s([{t}])
    //То есть все блоки символов кириллицы выделяются с помощью набора спец символов. Спец символы можно задавать в настройках
    static function string EnCodeString(string Source, string SpecialOpen, string SpecialClose)
    {
    	local int i;
    	local int code;
    	local int sLength;
    	local bool bOpened;
    	local string result;
    	sLength=Len(Source);
    	for(i=0;i<sLength;i++)
    	{
    		//Получаем код первого символа строки
    		code=Asc(Source);
    		//Если кодировка за 1000 - вычитаем 848. Подробнее в теме про кириллицу в линуксе и винде
    		if(code>848)
    			code-=848;
    		//Параметр bOpened отвечает за индикацию, того что сейчас идут символы кириллицы.
    		//Если code<=160, значит встретился символ латиницы и надо закрывать блок отвечающий за русский язык
    		//То есть ранее был прописан спец набор символов SpecialOpen и надо закрывать этот набор символов с помощью SpecialClose
    		if(bOpened && code<=160)
    		{
    			bOpened=false;
    			result$=SpecialClose;
    		}
    		
    		//Если кириллица и не добавлен спец символы открытия блока русского языка SpecialOpen - добавляем
    		//Если же либо символ латиницы, либо уже были символы открытия - пытаемся конвертировать символ с помощью EnCodeSymbol
    		//EnCodeSymbol конвертирует только кириллицу, остальные символы он не трогает
    		if(code>160 && !bOpened)
    		{
    			bOpened=true;
    			result$=SpecialOpen$Chr(EnCodeSymbol(code));
    		}
    		else
    			result$=Chr(EnCodeSymbol(code));
    
    		//"Отрезаем" первый символ от входной строки - мы его уже обработали. Теперь новый первый символ и цикл повторяется
    		Source=Mid(Source,1);
    		//Если исходная строка заканчивается кириллицей, то надо закрыть строку символами SpecialClose
    		if(i>=sLength-1 && bOpened)
    			result$=SpecialClose;
    	}
    	return result;
    }
    
    //Получаем исходную строку на кириллице из преобразованной
    //([{proverka}])->проверка, ([{te}])s([{t}])->теsт
    static function string DeCodeString(string Source, string SpecialOpen, string SpecialClose)
    {
    	local string result;
    	local int i;
    	local array<string> Parts, InnerParts;
    	local string Part;
    	//Разбиваем строку на подстроки. Строка по которой разбиваем - SpecialClose набор символов
    	//"([{te}])s([{t}])" разбивается на "([{te" и "s([{t"
    	Split(Source,SpecialClose,Parts);
    	for(i=0;i<Parts.Length;i++)
    	{
    		Part=Parts[i];
    		//Для каждой подстроки проверяем содержит ли она спец символы открытия SpecialOpen
    		//Если содержут, то разбивам на 2 подстроки по ([{
    		//Например. ([{te-> "пустая строка" и "te", s([{t-> "s" и "t"
    		//Левая из двух подстрок - чистая латиница, правая - кириллица и её надо конвертировать
    		//DeCodePart конвертирует строку на латинице в строку на кириллице, согласно правилам определённых выше
    		if(InStr(Part,SpecialOpen)>=0)
    		{
    			Split(Part,SpecialOpen,InnerParts);
    			result$=InnerParts[0]$DeCodePart(InnerParts[1]);
    		}
    		else
    			result$=Part;
    	}
    	return result;
    }
    
    //Конвертация символов из латиницы в кириллицу
    static function string DeCodePart(string Source)
    {
    	local int sLength;
    	local int i;
    	local int code;
    	local string result;
    	sLength=Len(Source);
    	for(i=0;i<sLength;i++)
    	{
    		code=Asc(Source);
    		result$=Chr(DeCodeSymbol(code)+848); //Для Windows надо добавить. Для Linux надо проверять
    		Source=Mid(Source,1);
    	}
    	return result;
    }
    
    //Конвертация символа из кириллицы в латиницу. Передаётся и возвращается код символа
    static function int EnCodeSymbol(int code)
    {
    	switch(code)
    	{
    	case 224:
    		return 97;
    	case 225:
    		return 98;
    	case 226:
    		return 118;
    	case 227:
    		return 103;
    	case 228:
    		return 100;
    	case 229:
    		return 101;
    	case 184:
    		return 42;
    	case 230:
    		return 106;
    	case 231:
    		return 122;
    	case 232:
    		return 105;
    	case 233:
    		return 94;
    	case 234:
    		return 107;
    	case 235:
    		return 108;
    	case 236:
    		return 109;
    	case 237:
    		return 110;
    	case 238:
    		return 111;
    	case 239:
    		return 112;
    	case 240:
    		return 114;
    	case 241:
    		return 115;
    	case 242:
    		return 116;
    	case 243:
    		return 117;
    	case 244:
    		return 102;
    	case 245:
    		return 104;
    	case 246:
    		return 99;
    	case 247:
    		return 121;
    	case 248:
    		return 119;
    	case 249:
    		return 36;
    	case 250:
    		return 33;
    	case 251:
    		return 37;
    	case 252:
    		return 63;
    	case 253:
    		return 41;
    	case 254:
    		return 124;
    	case 255:
    		return 47;
    	case 192:
    		return 65;
    	case 193:
    		return 66;
    	case 194:
    		return 86;
    	case 195:
    		return 71;
    	case 196:
    		return 68;
    	case 197:
    		return 69;
    	case 168:
    		return 64;
    	case 198:
    		return 74;
    	case 199:
    		return 90;
    	case 200:
    		return 73;
    	case 201:
    		return 38;
    	case 202:
    		return 75;
    	case 203:
    		return 76;
    	case 204:
    		return 77;
    	case 205:
    		return 78;
    	case 206:
    		return 79;
    	case 207:
    		return 80;
    	case 208:
    		return 82;
    	case 209:
    		return 83;
    	case 210:
    		return 84;
    	case 211:
    		return 85;
    	case 212:
    		return 70;
    	case 213:
    		return 72;
    	case 214:
    		return 67;
    	case 215:
    		return 89;
    	case 216:
    		return 87;
    	case 217:
    		return 55;
    	case 218:
    		return 56;
    	case 219:
    		return 57;
    	case 220:
    		return 48;
    	case 221:
    		return 49;
    	case 222:
    		return 50;
    	case 223:
    		return 51;
    	}
    	return code;
    }
    
    //Конвертация символа из латиницы в кириллицу. Передаётся и возвращается код символа
    static function int DeCodeSymbol(int code)
    {
    	switch(code)
    	{
    	case 97:
    		return 224;
    	case 98:
    		return 225;
    	case 118:
    		return 226;
    	case 103:
    		return 227;
    	case 100:
    		return 228;
    	case 101:
    		return 229;
    	case 42:
    		return 184;
    	case 106:
    		return 230;
    	case 122:
    		return 231;
    	case 105:
    		return 232;
    	case 94:
    		return 233;
    	case 107:
    		return 234;
    	case 108:
    		return 235;
    	case 109:
    		return 236;
    	case 110:
    		return 237;
    	case 111:
    		return 238;
    	case 112:
    		return 239;
    	case 114:
    		return 240;
    	case 115:
    		return 241;
    	case 116:
    		return 242;
    	case 117:
    		return 243;
    	case 102:
    		return 244;
    	case 104:
    		return 245;
    	case 99:
    		return 246;
    	case 121:
    		return 247;
    	case 119:
    		return 248;
    	case 36:
    		return 249;
    	case 33:
    		return 250;
    	case 37:
    		return 251;
    	case 63:
    		return 252;
    	case 41:
    		return 253;
    	case 124:
    		return 254;
    	case 47:
    		return 255;
    	case 65:
    		return 192;
    	case 66:
    		return 193;
    	case 86:
    		return 194;
    	case 71:
    		return 195;
    	case 68:
    		return 196;
    	case 69:
    		return 197;
    	case 64:
    		return 168;
    	case 74:
    		return 198;
    	case 90:
    		return 199;
    	case 73:
    		return 200;
    	case 38:
    		return 201;
    	case 75:
    		return 202;
    	case 76:
    		return 203;
    	case 77:
    		return 204;
    	case 78:
    		return 205;
    	case 79:
    		return 206;
    	case 80:
    		return 207;
    	case 82:
    		return 208;
    	case 83:
    		return 209;
    	case 84:
    		return 210;
    	case 85:
    		return 211;
    	case 70:
    		return 212;
    	case 72:
    		return 213;
    	case 67:
    		return 214;
    	case 89:
    		return 215;
    	case 87:
    		return 216;
    	case 55:
    		return 217;
    	case 56:
    		return 218;
    	case 57:
    		return 219;
    	case 48:
    		return 220;
    	case 49:
    		return 221;
    	case 50:
    		return 222;
    	case 51:
    		return 223;
    	}
    	return code;
    }
    
     
    khasky нравится это.