private void Start()
{
// Singleton initialization. If the instance already exists it should self-destruct to avoid duplicates
if (Instance != null && Instance != this)
{
Destroy(gameObject);
Debug.Log("An instance of LocalizationManager already exists");
}
else
{
// Initialize singleton instance
Instance = this;
// Obtain current language from PlayerPrefs. Local method for presentation purposes only
currentLang = (LANGUAGES)loadLanguage();
//Initialize dictionary
localizedText = new Dictionary <string, string>();
// Load dictionary contents with correct JSON
setLanguage((int)currentLang);
//Allow GameObject to exist through all execution
DontDestroyOnLoad(gameObject);
}
}
public string getText(LANGUAGES lang)
{
int index = (int)lang;
index = Mathf.Min(index, (int)LANGUAGES.MAX);
return(texts[index]);
}
public Settings(MainWindow creator, LANGUAGES DefaultLanguage)
{
InitializeComponent();
callingForm = creator;
IPAddressTextBox.Text = creator.getIPAddress(); //Fill the form with the current IP Address as a default value
PlayerTypeComboBox.SelectedIndex = (int)creator.getPlayerType(); //0=Gunner
Translator = new Translation(DefaultLanguage);
UpdateInterface();
//Set Color Pallate
Color KilimanjaroGreen = Color.FromArgb(29, 62, 32);
Color KilimanjaroYellow = Color.FromArgb(191, 196, 140);
Color KilimanjaroRed = Color.FromArgb(146, 23, 0);
Color KilimanjaroOrange = Color.FromArgb(179, 95, 16);
this.BackColor = KilimanjaroYellow;
IPAddressLabel.ForeColor = KilimanjaroGreen;
IPAddressTextBox.BackColor = KilimanjaroGreen;
IPAddressTextBox.ForeColor = KilimanjaroYellow;
IPAddressTextBox.BorderStyle = BorderStyle.FixedSingle;
PlayerTypeLabel.ForeColor = KilimanjaroGreen;
PlayerTypeComboBox.ForeColor = KilimanjaroYellow;
PlayerTypeComboBox.BackColor = KilimanjaroGreen;
SaveSettingsButton.BackColor = KilimanjaroGreen;
SaveSettingsButton.ForeColor = KilimanjaroYellow;
SaveSettingsButton.FlatAppearance.BorderColor = KilimanjaroGreen;
}
/// <summary>
///
/// </summary>
/// <param name="LanguageID"></param>
/// <param name="load_files_options"></param>
public CSyntacticUnitsInfoProvider(LANGUAGES LanguageID, CLoadFilesOptions load_files_options)
: base(load_files_options)
{
m_Extension = CAvailableExtentions.GetExtention(LanguageID);
m_SynUnitsCollection = new CSyntacticUnitsCollection();
m_CountOfSyntacticUnits = 0;
}
private void ResetResults()
{
m_Info = new CSyntacticInfo();
LANGUAGES LangID = (ChooseLangComboBox.SelectedItem as ICloneExtension).LanguageID();
m_Counter = new CCodeSizeDetector(LangID, new CLoadFilesOptions(CodeLocationTextBox.Text, ChoosenFilesExtensionsTextBox.Text));
m_StopWatch.Reset();
}
public ActionResult DeleteConfirmed(int id)
{
LANGUAGES lANGUAGES = db.LANGUAGESs.Find(id);
db.LANGUAGESs.Remove(lANGUAGES);
db.SaveChanges();
return(RedirectToAction("Index"));
}
/**
* GUI Callback to set current language.
*
* @param lang - A value determined by the enum above.
* @return void.
*/
public void setLanguage(int lang)
{
// Set language in PlayerPreferences
saveLanguage(lang);
// Set current language to <lang>
currentLang = (LANGUAGES)lang;
// Clear dictionary to re-load correct localization
localizedText.Clear();
// Store correct JSON localization file
switch (currentLang)
{
case LANGUAGES.EN:
localizationDataFileName = "Localization_EN.json";
break;
case LANGUAGES.ES:
localizationDataFileName = "Localization_ES.json";
break;
}
// Append complete path string
string filePath = Path.Combine(Application.streamingAssetsPath, localizationDataFileName);
string dataAsJson = "";
/** We use WWW here because on Android, the files are contained within a compressed .jar file
* (which is essentially the same format as standard zip-compressed files). This means that if
* you do not use Unity’s WWW class to retrieve the file, you need to use additional software
* to see inside the .jar archive and obtain the file.
* More Info: https://docs.unity3d.com/Manual/StreamingAssets.html
*/
if (Application.platform == RuntimePlatform.Android)
{
WWW reader = new WWW(filePath);
while (!reader.isDone)
{
}
dataAsJson = reader.text;
}
else
{
// This is for test purposes on the Editor
dataAsJson = File.ReadAllText(filePath);
}
// Load JSON data to data pairs we can insert into our dictionary
LocalizationData loadedData = JsonUtility.FromJson <LocalizationData>(dataAsJson);
// Populate dictionary
for (int i = 0; i < loadedData.items.Length; i++)
{
localizedText.Add(loadedData.items[i].key, loadedData.items[i].value);
}
}
/// <summary>
/// Получить имя плагина для поддержки данного языка программирования
/// </summary>
/// <param name="Language">Идентификатор языка программирования</param>
/// <returns>Имя плагина</returns>
public static string DllExtentionName(LANGUAGES Language)
{
if (Language == LANGUAGES.LANGUAGE_UNKNOWN)
{
return(string.Empty);
}
return(m_LanguagePrefixes[Language] + m_PartOfDllName);
}
public ActionResult Edit([Bind(Include = "idLanguage,nameLanguage,shortForm")] LANGUAGES lANGUAGES)
{
if (ModelState.IsValid)
{
db.Entry(lANGUAGES).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(lANGUAGES));
}
/// <summary>
/// Получить плагин по его идентификатору
/// </summary>
/// <param name="LanguageID"></param>
/// <returns></returns>
public static ICloneExtension GetExtention(LANGUAGES LanguageID)
{
try
{
return(m_ExtentionsList[LanguageID]);
}
catch (KeyNotFoundException)
{
throw new UnknownLanguageException(LanguageID);
}
}
public ActionResult Create([Bind(Include = "idLanguage,nameLanguage,shortForm")] LANGUAGES lANGUAGES)
{
if (ModelState.IsValid)
{
db.LANGUAGESs.Add(lANGUAGES);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(lANGUAGES));
}
private CSyntacticInfo calc(string testfile)
{
string filename = Path.GetFullPath(testfile);
Assert.IsTrue(File.Exists(filename));
LANGUAGES lang = LANGUAGES.LANGUAGE_C_SHARP;
CLoadFilesOptions load_files_options = new CLoadFilesOptions(filename);
CSyntacticUnitsInfoProvider target = new CSyntacticUnitsInfoProvider(lang, load_files_options);
return(target.Calculate());
}
public void GetExtentionTest1()
{
LANGUAGES Lang = LANGUAGES.LANGUAGE_C_PLUS_PLUS;
ICloneExtension actual = CAvailableExtentions.GetExtention(Lang);
Assert.IsNotNull(actual);
Assert.AreEqual(actual.LanguageID(), Lang);
Lang = LANGUAGES.LANGUAGE_C_SHARP;
actual = CAvailableExtentions.GetExtention(Lang);
Assert.IsNotNull(actual);
Assert.AreEqual(actual.LanguageID(), Lang);
}
// GET: Languages/Edit/5
//[Authorize(Roles = "admin")]
//[Authorize(Roles = "manager")]
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
LANGUAGES lANGUAGES = db.LANGUAGESs.Find(id);
if (lANGUAGES == null)
{
return(HttpNotFound());
}
return(View(lANGUAGES));
}
public string GetWord(LANGUAGES lang)
{
switch (lang)
{
case LANGUAGES.ENGLISH:
return(english);
case LANGUAGES.JAPANESE:
return(japanese);
case LANGUAGES.SPANISH:
return(spanish);
}
return(" ");
}
private void InitCodeCounter()
{
m_Info = new CSyntacticInfo();
m_StopWatch = new Stopwatch();
LANGUAGES LangID = (ChooseLangComboBox.SelectedItem as ICloneExtension).LanguageID();
m_Counter = new CCodeSizeDetector(LangID, new CLoadFilesOptions(CodeLocationTextBox.Text, ChoosenFilesExtensionsTextBox.Text));
m_BackgroundThread = new BackgroundWorker();
m_BackgroundThread.WorkerReportsProgress = true;
m_BackgroundThread.WorkerSupportsCancellation = true;
m_BackgroundThread.DoWork += (o, e) =>
{
m_Info = m_Counter.Calculate();
};
m_BackgroundThread.ProgressChanged += (o, e) =>
{
// ВНИМАНИЕ! ЗДЕСЬ НЕ ДОЛЖНО БЫТЬ НИКАКИХ Application.DoEvents();
ShowResults();
};
m_BackgroundThread.RunWorkerCompleted += (o, e) =>
{
ShowResults();
if (m_Counter.GetCancelOperationFlag())
{
StatusLabel.Text = ICloneLocalization.CMNMESS_OperationCancelled;
}
else
{
if (e.Error != null)
{
StatusLabel.Text = ICloneLocalization.CMNMESS_OperationtDoneWithErrors;
}
else
{
ShowSyntacticInfo();
StatusLabel.Text = ICloneLocalization.CMNMESS_OperationDoneSuccesfully;
}
}
m_StopWatch.Stop();
CancelOpButton.Enabled = false;
};
}
public void SetLanguage(LANGUAGES languages)
{
switch (languages)
{
case LANGUAGES.Japanese:
_text.text = Japnaese;
break;
case LANGUAGES.English:
_text.text = English;
break;
case LANGUAGES.Chinese:
_text.text = Chinese;
break;
}
}
public void LanguageIDTest()
{
LANGUAGES actual = CSupportingLanguages.LanguageID("java_iclone_ext.dll");
Assert.AreEqual(LANGUAGES.LANGUAGE_JAVA, actual);
actual = CSupportingLanguages.LanguageID("CS_Iclone_eXt.DLL");
Assert.AreEqual(LANGUAGES.LANGUAGE_C_SHARP, actual);
actual = CSupportingLanguages.LanguageID("java_iclone_ext1.dll");
Assert.AreEqual(LANGUAGES.LANGUAGE_UNKNOWN, actual);
actual = CSupportingLanguages.LanguageID("java1_iclone_ext.dll");
Assert.AreEqual(LANGUAGES.LANGUAGE_UNKNOWN, actual);
actual = CSupportingLanguages.LanguageID("basic_iclone_ext.dll");
Assert.AreEqual(LANGUAGES.LANGUAGE_UNKNOWN, actual);
}
public static void On_SMSG_MESSAGECHAT(ref Packets.PacketClass Packet)
{
ChatMsg msgType = (ChatMsg)Packet.GetInt8();
LANGUAGES msgLanguage = (LANGUAGES)Packet.GetInt32();
switch (msgType)
{
case ChatMsg.CHAT_MSG_WHISPER:
{
ulong SenderGuid = (ulong)Packet.GetInt64();
int ByteCount = Packet.GetInt32();
string Message = Packet.GetString();
byte ChatFlag = Packet.GetInt8();
Console.WriteLine("Answer: " + Message);
break;
}
}
}
/// <summary>
/// Проверка загруженной сборки и создание экземпляра класса,
/// реализующего интерфейс <see cref="ICloneExtensions.Interfaces.ICloneExtension"/>, если такой найден
/// </summary>
/// <param name="assembly">Сборка</param>
/// <param name="Language">Идентификатор языка программирования, для которого загружается плагин</param>
private static void ExamineAssembly(Assembly assembly, LANGUAGES Language)
{
foreach (Type type in assembly.GetTypes())
{
if (type.IsPublic)
{
if ((type.Attributes & TypeAttributes.Abstract) != TypeAttributes.Abstract)
{
Type iface = type.GetInterface("ICloneExtensions.Interfaces.ICloneExtension", true);
if (iface != null)
{
ICloneExtension extention = (ICloneExtension)Activator.CreateInstance(type);
m_ExtentionsList.Add(Language, extention);
break;
}
}
}
}
}
public void On_CMSG_MESSAGECHAT(ref Packets.PacketClass packet, ref WS_Network.ClientClass client)
{
WorldServiceLocator._WorldServer.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] CMSG_MESSAGECHAT", client.IP, client.Port);
if (checked (packet.Data.Length - 1) < 14 && client.Character != null)
{
return;
}
packet.GetInt16();
ChatMsg msgType = (ChatMsg)packet.GetInt32();
LANGUAGES msgLanguage = (LANGUAGES)packet.GetInt32();
WorldServiceLocator._WorldServer.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] CMSG_MESSAGECHAT [{2}:{3}]", client.IP, client.Port, msgType, msgLanguage);
if (client.Character.Spell_Language != (LANGUAGES)(-1))
{
msgLanguage = client.Character.Spell_Language;
}
switch (msgType)
{
case ChatMsg.CHAT_MSG_SAY:
case ChatMsg.CHAT_MSG_YELL:
case ChatMsg.CHAT_MSG_WHISPER:
case ChatMsg.CHAT_MSG_EMOTE:
{
string Message3 = packet.GetString();
if (Message3.StartsWith(WorldServiceLocator._ConfigurationProvider.GetConfiguration().CommandCharacter) && client.Character.Access > AccessLevel.Player)
{
Message3 = Message3.Remove(0, 1);
Packets.PacketClass toCommand = WorldServiceLocator._Functions.BuildChatMessage(2147483647uL, Message3, ChatMsg.CHAT_MSG_SYSTEM, LANGUAGES.LANG_GLOBAL);
try
{
client.Send(ref toCommand);
}
finally
{
toCommand.Dispose();
}
WorldServiceLocator._WS_Commands.OnCommand(ref client, Message3);
}
else
{
client.Character.SendChatMessage(ref client.Character, Message3, msgType, (int)msgLanguage, "", SendToMe: true);
}
break;
}
case ChatMsg.CHAT_MSG_AFK:
{
string Message = packet.GetString();
if ((Operators.CompareString(Message, "", TextCompare: false) == 0 || !client.Character.AFK) && !client.Character.IsInCombat)
{
client.Character.AFK = !client.Character.AFK;
if (client.Character.AFK && client.Character.DND)
{
client.Character.DND = false;
}
client.Character.SetUpdateFlag(190, (int)client.Character.cPlayerFlags);
client.Character.SendCharacterUpdate();
}
break;
}
case ChatMsg.CHAT_MSG_DND:
{
string Message2 = packet.GetString();
if (Operators.CompareString(Message2, "", TextCompare: false) == 0 || !client.Character.DND)
{
client.Character.DND = !client.Character.DND;
if (client.Character.DND && client.Character.AFK)
{
client.Character.AFK = false;
}
client.Character.SetUpdateFlag(190, (int)client.Character.cPlayerFlags);
client.Character.SendCharacterUpdate();
}
break;
}
case ChatMsg.CHAT_MSG_PARTY:
case ChatMsg.CHAT_MSG_RAID:
case ChatMsg.CHAT_MSG_CHANNEL:
case ChatMsg.CHAT_MSG_RAID_LEADER:
case ChatMsg.CHAT_MSG_RAID_WARNING:
WorldServiceLocator._WorldServer.Log.WriteLine(LogType.WARNING, "This chat message type should not be here!");
break;
default:
WorldServiceLocator._WorldServer.Log.WriteLine(LogType.FAILED, "[{0}:{1}] Unknown chat message [msgType={2}, msgLanguage={3}]", client.IP, client.Port, msgType, msgLanguage);
WorldServiceLocator._Packets.DumpPacket(packet.Data, client);
break;
}
}
/// <summary>
/// Получить строковый идентификатор языка программирования
/// </summary>
/// <param name="Language">Идентификатор языка программирования</param>
/// <returns>Строковый идентификатор</returns>
public static string LanguagePrefix(LANGUAGES Language)
{
return(m_LanguagePrefixes[Language]);
}
public void ChangeLanguage(LANGUAGES lang)
{
m_currentLanguage = (int)lang;
PlayerPrefs.SetInt(m_languageKey, m_currentLanguage);
}
public Translation(LANGUAGES DefaultLanugage)
{
Language = DefaultLanugage;
}
/// <summary>
/// Получить название языка программирования с заданным идентификатором
/// </summary>
/// <param name="Language">Идентификатор языка программирования</param>
/// <returns>Название языка программирования</returns>
public static string LanguageName(LANGUAGES Language)
{
return(m_LanguageNames[Language]);
}
public void SendChatMessage(WcHandlerCharacter.CharacterObject sender, string message, LANGUAGES language, ChatMsg thisType)
{
PacketClass packet = _clusterServiceLocator.Functions.BuildChatMessage(sender.Guid, message, thisType, language, (byte)sender.ChatFlag);
Broadcast(packet);
packet.Dispose();
}
public void SetLanguage(LANGUAGES newLanguage)
{
if ((byte)newLanguage >= 0 && (byte)newLanguage < NUMBEROFLANGUAGES)
{
PreviousLanguage = Language;
Language = newLanguage;
}
Debug.WriteLine("ERROR: SetLanguag was passed a value {0} that was out of range(0-{1})",(byte)newLanguage,(byte)NUMBEROFLANGUAGES);
}
public void On_CMSG_MESSAGECHAT(PacketClass packet, ClientClass client)
{
if (packet.Data.Length - 1 < 14)
{
return;
}
packet.GetInt16();
ChatMsg msgType = (ChatMsg)packet.GetInt32();
LANGUAGES msgLanguage = (LANGUAGES)packet.GetInt32();
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] CMSG_MESSAGECHAT [{2}:{3}]", client.IP, client.Port, msgType, msgLanguage);
switch (msgType)
{
case var @case when @case == ChatMsg.CHAT_MSG_CHANNEL:
{
var channel = packet.GetString();
if (packet.Data.Length - 1 < 14 + channel.Length)
{
return;
}
var message = packet.GetString();
// DONE: Broadcast to all
if (_clusterServiceLocator.WsHandlerChannels.ChatChanneLs.ContainsKey(channel))
{
_clusterServiceLocator.WsHandlerChannels.ChatChanneLs[channel].Say(message, (int)msgLanguage, client.Character);
}
return;
}
case var case1 when case1 == ChatMsg.CHAT_MSG_WHISPER:
{
var argname = packet.GetString();
var toUser = _clusterServiceLocator.Functions.CapitalizeName(argname);
if (packet.Data.Length - 1 < 14 + toUser.Length)
{
return;
}
var message = packet.GetString();
// DONE: Handle admin/gm commands
// If ToUser = "******" AndAlso client.Character.Access > 0 Then
// client.Character.GetWorld.ClientPacket(Client.Index, packet.Data)
// Exit Sub
// End If
// DONE: Send whisper MSG to receiver
var guid = 0UL;
_clusterServiceLocator.WorldCluster.CharacteRsLock.AcquireReaderLock(_clusterServiceLocator.GlobalConstants.DEFAULT_LOCK_TIMEOUT);
foreach (var character in _clusterServiceLocator.WorldCluster.CharacteRs)
{
if (_clusterServiceLocator.CommonFunctions.UppercaseFirstLetter(character.Value.Name) == _clusterServiceLocator.CommonFunctions.UppercaseFirstLetter(toUser))
{
guid = character.Value.Guid;
break;
}
}
_clusterServiceLocator.WorldCluster.CharacteRsLock.ReleaseReaderLock();
if (guid > 0m && _clusterServiceLocator.WorldCluster.CharacteRs.ContainsKey(guid))
{
// DONE: Check if ignoring
if (_clusterServiceLocator.WorldCluster.CharacteRs[guid].IgnoreList.Contains(client.Character.Guid) && client.Character.Access < AccessLevel.GameMaster)
{
// Client.Character.SystemMessage(String.Format("{0} is ignoring you.", ToUser))
client.Character.SendChatMessage(guid, "", ChatMsg.CHAT_MSG_IGNORED, (int)LANGUAGES.LANG_UNIVERSAL, "");
}
else
{
// To message
client.Character.SendChatMessage(guid, message, ChatMsg.CHAT_MSG_WHISPER_INFORM, (int)msgLanguage, "");
if (_clusterServiceLocator.WorldCluster.CharacteRs[guid].Dnd == false || client.Character.Access >= AccessLevel.GameMaster)
{
// From message
_clusterServiceLocator.WorldCluster.CharacteRs[guid].SendChatMessage(client.Character.Guid, message, ChatMsg.CHAT_MSG_WHISPER, (int)msgLanguage, "");
}
else
{
// DONE: Send the DND message
client.Character.SendChatMessage(guid, _clusterServiceLocator.WorldCluster.CharacteRs[guid].AfkMessage, ChatMsg.CHAT_MSG_DND, (int)msgLanguage, "");
}
// DONE: Send the AFK message
if (_clusterServiceLocator.WorldCluster.CharacteRs[guid].Afk)
{
client.Character.SendChatMessage(guid, _clusterServiceLocator.WorldCluster.CharacteRs[guid].AfkMessage, ChatMsg.CHAT_MSG_AFK, (int)msgLanguage, "");
}
}
}
else
{
PacketClass smsgChatPlayerNotFound = new(Opcodes.SMSG_CHAT_PLAYER_NOT_FOUND);
smsgChatPlayerNotFound.AddString(toUser);
client.Send(smsgChatPlayerNotFound);
smsgChatPlayerNotFound.Dispose();
}
break;
}
case var case2 when case2 == ChatMsg.CHAT_MSG_PARTY:
case var case3 when case3 == ChatMsg.CHAT_MSG_RAID:
case var case4 when case4 == ChatMsg.CHAT_MSG_RAID_LEADER:
case var case5 when case5 == ChatMsg.CHAT_MSG_RAID_WARNING:
{
var message = packet.GetString();
// DONE: Check in group
if (!client.Character.IsInGroup)
{
break;
}
// DONE: Broadcast to party
client.Character.Group.SendChatMessage(client.Character, message, msgLanguage, msgType);
break;
}
case var case6 when case6 == ChatMsg.CHAT_MSG_AFK:
{
var message = packet.GetString();
// TODO: Can not be used while in combat!
if (string.IsNullOrEmpty(message) || client.Character.Afk == false)
{
if (client.Character.Afk == false)
{
if (string.IsNullOrEmpty(message))
{
message = "Away From Keyboard";
}
client.Character.AfkMessage = message;
}
client.Character.Afk = !client.Character.Afk;
if (client.Character.Afk && client.Character.Dnd)
{
client.Character.Dnd = false;
}
client.Character.ChatFlag = client.Character.Afk ? ChatFlag.FLAGS_AFK : ChatFlag.FLAGS_NONE;
// DONE: Pass the packet to the world server so it also knows about it
client.Character.GetWorld.ClientPacket(client.Index, packet.Data);
}
break;
}
case var case7 when case7 == ChatMsg.CHAT_MSG_DND:
{
var message = packet.GetString();
if (string.IsNullOrEmpty(message) || client.Character.Dnd == false)
{
if (client.Character.Dnd == false)
{
if (string.IsNullOrEmpty(message))
{
message = "Do Not Disturb";
}
client.Character.AfkMessage = message;
}
client.Character.Dnd = !client.Character.Dnd;
if (client.Character.Dnd && client.Character.Afk)
{
client.Character.Afk = false;
}
client.Character.ChatFlag = client.Character.Dnd ? ChatFlag.FLAGS_DND : ChatFlag.FLAGS_NONE;
// DONE: Pass the packet to the world server so it also knows about it
client.Character.GetWorld.ClientPacket(client.Index, packet.Data);
}
break;
}
case var case8 when case8 == ChatMsg.CHAT_MSG_SAY:
case var case9 when case9 == ChatMsg.CHAT_MSG_YELL:
case var case10 when case10 == ChatMsg.CHAT_MSG_EMOTE:
{
client.Character.GetWorld.ClientPacket(client.Index, packet.Data);
break;
}
case var case11 when case11 == ChatMsg.CHAT_MSG_GUILD:
{
var message = packet.GetString();
// DONE: Broadcast to guild
_clusterServiceLocator.WcGuild.BroadcastChatMessageGuild(client.Character, message, msgLanguage, (int)client.Character.Guild.Id);
break;
}
case var case12 when case12 == ChatMsg.CHAT_MSG_OFFICER:
{
var message = packet.GetString();
// DONE: Broadcast to officer chat
_clusterServiceLocator.WcGuild.BroadcastChatMessageOfficer(client.Character, message, msgLanguage, (int)client.Character.Guild.Id);
break;
}
default:
{
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.FAILED, "[{0}:{1}] Unknown chat message [msgType={2}, msgLanguage={3}]", client.IP, client.Port, msgType, msgLanguage);
_clusterServiceLocator.Packets.DumpPacket(packet.Data, client);
break;
}
}
}
/// <summary>
/// Конструктор по умолчанию
/// </summary>
public CCodeSizeDetector(LANGUAGES LanguageID, CLoadFilesOptions load_files_options)
: base(LanguageID, load_files_options)
{
ClearCounters();
}
public UnknownLanguageException(LANGUAGES LanguageID)
: base("Язык программирования " + LanguageID.ToString() + " не известен или не поддерживается")
{
}
public void BroadcastChatMessageGuild(WcHandlerCharacter.CharacterObject sender, string message, LANGUAGES language, int guildId)
{
// DONE: Check for guild member
if (!sender.IsInGuild)
{
SendGuildResult(sender.Client, GuildCommand.GUILD_CREATE_S, GuildError.GUILD_PLAYER_NOT_IN_GUILD);
return;
}
// DONE: Check for rights to speak
if (!sender.IsGuildRightSet(GuildRankRights.GR_RIGHT_GCHATSPEAK))
{
SendGuildResult(sender.Client, GuildCommand.GUILD_CREATE_S, GuildError.GUILD_PERMISSIONS);
return;
}
// DONE: Build packet
var packet = _clusterServiceLocator.Functions.BuildChatMessage(sender.Guid, message, ChatMsg.CHAT_MSG_GUILD, language, (byte)sender.ChatFlag);
// DONE: Send message to everyone
var tmpArray = sender.Guild.Members.ToArray();
foreach (var member in tmpArray)
{
if (_clusterServiceLocator.WorldCluster.CharacteRs.ContainsKey(member))
{
if (_clusterServiceLocator.WorldCluster.CharacteRs[member].IsGuildRightSet(GuildRankRights.GR_RIGHT_GCHATLISTEN))
{
_clusterServiceLocator.WorldCluster.CharacteRs[member].Client.SendMultiplyPackets(packet);
}
}
}
packet.Dispose();
}
//overloaded version to be called by forms that don't have access to the private translator object
public void UpdateInterface(LANGUAGES NewLanguage)
{
Translator.SetLanguage(NewLanguage);
UpdateInterface();
}
public void setText(LANGUAGES lang, string value)
{
texts[(int)lang] = value;
}
public PacketClass BuildChatMessage(ulong senderGuid, string message, ChatMsg msgType, LANGUAGES msgLanguage, byte flag = 0, string msgChannel = "Global")
{
var packet = new PacketClass(Opcodes.SMSG_MESSAGECHAT);
try
{
packet.AddInt8((byte)msgType);
packet.AddInt32((int)msgLanguage);
switch (msgType)
{
case var @case when @case == ChatMsg.CHAT_MSG_CHANNEL:
{
packet.AddString(msgChannel);
packet.AddUInt32(0U);
packet.AddUInt64(senderGuid);
break;
}
case var case1 when case1 == ChatMsg.CHAT_MSG_YELL:
case var case2 when case2 == ChatMsg.CHAT_MSG_SAY:
case var case3 when case3 == ChatMsg.CHAT_MSG_PARTY:
{
packet.AddUInt64(senderGuid);
packet.AddUInt64(senderGuid);
break;
}
case var case4 when case4 == ChatMsg.CHAT_MSG_SYSTEM:
case var case5 when case5 == ChatMsg.CHAT_MSG_EMOTE:
case var case6 when case6 == ChatMsg.CHAT_MSG_IGNORED:
case var case7 when case7 == ChatMsg.CHAT_MSG_SKILL:
case var case8 when case8 == ChatMsg.CHAT_MSG_GUILD:
case var case9 when case9 == ChatMsg.CHAT_MSG_OFFICER:
case var case10 when case10 == ChatMsg.CHAT_MSG_RAID:
case var case11 when case11 == ChatMsg.CHAT_MSG_WHISPER_INFORM:
case var case12 when case12 == ChatMsg.CHAT_MSG_GUILD:
case var case13 when case13 == ChatMsg.CHAT_MSG_WHISPER:
case var case14 when case14 == ChatMsg.CHAT_MSG_AFK:
case var case15 when case15 == ChatMsg.CHAT_MSG_DND:
case var case16 when case16 == ChatMsg.CHAT_MSG_RAID_LEADER:
case var case17 when case17 == ChatMsg.CHAT_MSG_RAID_WARNING:
{
packet.AddUInt64(senderGuid);
break;
}
case var case18 when case18 == ChatMsg.CHAT_MSG_MONSTER_SAY:
case var case19 when case19 == ChatMsg.CHAT_MSG_MONSTER_EMOTE:
case var case20 when case20 == ChatMsg.CHAT_MSG_MONSTER_YELL:
{
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.WARNING, "Use Creature.SendChatMessage() for this message type - {0}!", msgType);
break;
}
default:
{
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.WARNING, "Unknown chat message type - {0}!", msgType);
break;
}
}
packet.AddUInt32((uint)(Encoding.UTF8.GetByteCount(message) + 1));
packet.AddString(message);
packet.AddInt8(flag);
}
catch (Exception)
{
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.FAILED, "failed chat message type - {0}!", msgType);
}
return(packet);
}
