private void GenerateData()
{
GenerateVector();
GenerateMatrix();
WriteLog(LogStrings.DataGeneratedSuccessfully(vectorFileName, matrixFileName));
}
private void ConnectToServer()
{
IPHostEntry ipHostInfo = Dns.GetHostEntry(host);
IPAddress ipAddress = ipHostInfo.AddressList[0];
IPEndPoint ipEndPoint = new IPEndPoint(ipAddress, port);
senderSema.Wait();
sender = new Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
while (true)
{
try
{
WriteLog(LogStrings.TryingToConnectToEndPoint(ipEndPoint));
sender.Connect(ipEndPoint);
WriteLog(LogStrings.ConnectedSuccessfullyToEndPoint(ipEndPoint));
senderSema.Release();
break;
}
catch (Exception exc)
{
WriteLog(LogStrings.ExceptionWasThrown(exc));
}
}
}
private void CloseConnectionCallback(IAsyncResult ar)
{
int sent = 0;
try
{
sent = sender.EndSend(ar);
} catch (Exception e)
{
WriteLog(LogStrings.ExceptionWasThrown(e));
return;
}
WriteLog(LogStrings.BytesWereSuccessfulySent(sent));
WriteLog(LogStrings.CloseSocket());
try
{
sender.Shutdown(SocketShutdown.Both);
sender.Close();
} catch (Exception e)
{
WriteLog(LogStrings.ExceptionWasThrown(e));
}
senderSema.Release();
}
public static void Log(LogLevel logLevel, DSAError error, [CallerMemberName] string callerMemberName = "", [CallerFilePath] string CallerFilePath = "", [CallerLineNumber] int callerLineNumber = 0)
{
if (error != null)
{
LogStrings.LogString(logLevel, error, callerMemberName, CallerFilePath, callerLineNumber);
}
}
private void ReceiveCallback(IAsyncResult ar)
{
StateObject state = (StateObject)ar.AsyncState;
Socket handler = state.workerSocket;
string name = GetSocketName(handler);
int bytesRec = 0;
try
{
bytesRec = handler.EndReceive(ar);
} catch (Exception e)
{
WriteLog(LogStrings.ExceptionWasThrown(e));
return;
}
WriteLog(LogStrings.BytesWereReceivedSuccessfuly(bytesRec, name));
string msg = Encoding.UTF8.GetString(state.buffer, 0, bytesRec);
WriteLog(LogStrings.MessageWasReceivedSuccessfuly(msg, name));
if (msg.IndexOf(endMessage) != -1)
{
Invoke(new Method(() => clientsListBox.Items.Remove(clientsListBox.Items[clientsListBox.Items.IndexOf(name)])));
WriteLog(LogStrings.ClosingSocket(name));
RemoveClient(name);
try
{
handler.Shutdown(SocketShutdown.Both);
handler.Close();
} catch (Exception e)
{
WriteLog(LogStrings.ExceptionWasThrown(e));
}
return;
}
string[] paths = msg.Split(';');
string response = MultiplyVectorAndMatrix(paths[0], paths[1]);
if (response == null)
{
response = invalidInputException;
}
byte[] bytes = Encoding.UTF8.GetBytes(response);
WriteLog(LogStrings.AttemptingToSendMessageToClient(response, name));
handler.BeginSend(bytes, 0, bytes.Length, 0, new AsyncCallback(SendCallback), handler);
}
private void Receive(Socket handler)
{
StateObject state = new StateObject();
state.workerSocket = handler;
WriteLog(LogStrings.WaitingToReceiveMessageFromClient(GetSocketName(handler)));
handler.BeginReceive(state.buffer, 0, state.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
}
private void beginAcceptButton_Click(object sender, EventArgs e)
{
if (listener == null)
{
return;
}
listener.BeginAccept(new AsyncCallback(AcceptCallback), listener);
WriteLog(LogStrings.StartingToAcceptConnection());
}
private void stopListeningButton_Click(object sender, EventArgs e)
{
if (listener == null)
{
return;
}
WriteLog(LogStrings.StopListening());
listener.Close();
}
private void PrintResult(string path)
{
string msg = LogStrings.ResultOfMultiplyingMatricies(matrixFileName, vectorFileName, path);
WriteLog(msg);
Invoke(new Method(() =>
{
if (MessageBox.Show(msg, "Result", MessageBoxButtons.OK, MessageBoxIcon.Information) == DialogResult.OK)
{
Process.Start(path);
}
}));
}
private int[] GetVectorFromFile(string file)
{
StreamReader reader = new StreamReader(file);
reader.ReadLine();
int[] vector = GetNumbersFromRow(reader);
reader.Close();
WriteLog(LogStrings.VectorWasLoaded(file));
return(vector);
}
private void CloseConnection()
{
if (sender == null)
{
return;
}
senderSema.Wait();
WriteLog(LogStrings.CloseConnection());
WriteLog(LogStrings.AttemptingToSendMessage(endMessage));
byte[] bytes = Encoding.UTF8.GetBytes(endMessage);
sender.BeginSend(bytes, 0, bytes.Length, 0, new AsyncCallback(CloseConnectionCallback), sender);
}
private void SendTaskToServer()
{
if (sender == null)
{
return;
}
senderSema.Wait();
string msg = GetMessage();
byte[] bytes = Encoding.UTF8.GetBytes(msg);
WriteLog(LogStrings.AttemptingToSendMessage(msg));
sender.BeginSend(bytes, 0, bytes.Length, 0, new AsyncCallback(SendCallback), sender);
}
private void SendCallback(IAsyncResult ar)
{
Socket handler = (Socket)ar.AsyncState;
int bytesSent = 0;
try
{
bytesSent = handler.EndSend(ar);
} catch (Exception e)
{
WriteLog(LogStrings.ExceptionWasThrown(e));
return;
}
WriteLog(LogStrings.BytesWereSentSuccessfuly(bytesSent, GetSocketName(handler)));
Receive(handler);
}
private void StartListening()
{
IPHostEntry ipHostEntry = Dns.GetHostEntry(host);
IPAddress ipAddress = ipHostEntry.AddressList[0];
IPEndPoint localEndPoint = new IPEndPoint(ipAddress, port);
listener = new Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try
{
WriteLog(LogStrings.TryingToBindListenerToEndPoint(localEndPoint));
listener.Bind(localEndPoint);
WriteLog(LogStrings.BindingWasSuccessful(localEndPoint));
listener.Listen(maxNumberOfListeners);
WriteLog(LogStrings.StartingToListenConnections());
} catch (Exception exc)
{
WriteLog(LogStrings.ExceptionWasThrown(exc));
}
}
private string MultiplyVectorAndMatrix(string vectorFile, string matrixFile)
{
WriteLog(LogStrings.TryingToMultiplyMatrixAndVector(matrixFile, vectorFile));
int[,] matrix = GetMatrixFromFile(matrixFile);
int[] vector = GetVectorFromFile(vectorFile);
if (matrix.GetLength(1) != vector.Length)
{
return(null);
}
string fileName = GetFileName(vectorFile, matrixFile);
StreamWriter writer = new StreamWriter(fileName);
int length = matrix.GetLength(0);
writer.WriteLine(length);
for (int i = 0; i < length; i++)
{
BigInteger number = 0;
for (int j = 0; j < vector.Length; j++)
{
number += matrix[i, j] * vector[j];
}
writer.Write(number);
if (i != length - 1)
{
writer.Write(' ');
}
}
WriteLog(LogStrings.MultiplicationWasSuccessful(matrixFile, vectorFile));
writer.Close();
return(fileName);
}
private void ReceiveCallback(IAsyncResult ar)
{
StateObject state = (StateObject)ar.AsyncState;
Socket handler = state.workSocket;
int bytesRec = 0;
try
{
bytesRec = handler.EndReceive(ar);
} catch (Exception e)
{
WriteLog(LogStrings.ExceptionWasThrown(e));
return;
}
WriteLog(LogStrings.BytesWereReceivedFromServer(bytesRec));
senderSema.Release();
string path = Encoding.UTF8.GetString(state.buffer, 0, bytesRec);
PrintResult(path);
}
private int[,] GetMatrixFromFile(string file)
{
StreamReader reader = new StreamReader(file);
int[] sizes = GetNumbersFromRow(reader);
int[,] matrix = new int[sizes[0], sizes[1]];
for (int i = 0; i < sizes[0]; i++)
{
int[] nums = GetNumbersFromRow(reader);
for (int j = 0; j < sizes[1]; j++)
{
matrix[i, j] = nums[j];
}
}
WriteLog(LogStrings.MatrixWasLoaded(file));
reader.Close();
return(matrix);
}
private void AcceptCallback(IAsyncResult ar)
{
Socket listener = (Socket)ar.AsyncState;
Socket handler = null;
try
{
handler = listener.EndAccept(ar);
} catch (Exception e)
{
WriteLog(LogStrings.ExceptionWasThrown(e));
return;
}
AddSocket(handler);
string name = GetSocketName(handler);
WriteLog(LogStrings.ClientConnectionWasAccepted(name));
Invoke(new Method(() => clientsListBox.Items.Add(name)));
Receive(handler);
}
private void SendCallback(IAsyncResult ar)
{
Socket sender = (Socket)ar.AsyncState;
int bytesSent = 0;
try
{
bytesSent = sender.EndSend(ar);
} catch (Exception e)
{
WriteLog(LogStrings.ExceptionWasThrown(e));
return;
}
WriteLog(LogStrings.BytesWereSuccessfulySent(bytesSent));
StateObject state = new StateObject();
state.workSocket = sender;
WriteLog(LogStrings.WaitingToReceiveMessageFromServer());
sender.BeginReceive(state.buffer, 0, state.buffer.Length, 0, new AsyncCallback(ReceiveCallback), state);
}
public void Load(JSONCharakter jsonCharakter, List <ITalent> talentListe)
{
#region Nullprüfungen
if (jsonCharakter == null)
{
throw new ArgumentNullException(nameof(jsonCharakter));
}
else if (talentListe == null)
{
throw new ArgumentNullException(nameof(talentListe));
}
if (jsonCharakter.MotherLanguages == null)
{
jsonCharakter.MotherLanguages = new Dictionary <Guid, bool>();
}
if (jsonCharakter.DeductionTalent == null)
{
jsonCharakter.DeductionTalent = new Dictionary <Guid, Guid>();
}
#endregion
CreateNew(jsonCharakter.ID);
Name = jsonCharakter.Name;
#region Attribute Laden
foreach (var item in jsonCharakter.AttributeBaseValue.Keys)
{
Attribute.SetAKTValue(item, jsonCharakter.AttributeBaseValue[item]);
}
#endregion
#region Values Laden
if (jsonCharakter.SettableValues != null)
{
foreach (var item in jsonCharakter.SettableValues)
{
var settableValue = Values.UsedValues.Where(x => x.Name == item.Key).FirstOrDefault();
if (settableValue != null && typeof(AbstractSettableValue).IsAssignableFrom(settableValue.GetType()))
{
Values.SetAKTValue((AbstractSettableValue)settableValue, item.Value);
}
}
}
#endregion
#region Resources Laden
//kein Laden notwendig
#endregion
#region Traits Laden
if (jsonCharakter.Traits != null)
{
foreach (var item in jsonCharakter.Traits)
{
var trait = new Trait
{
TraitType = item.TraitType,
Description = item.Description,
GP = item.GP,
Title = item.Title,
Value = item.Value,
APEarned = item.APEarned,
APInvest = item.APInvest
};
foreach (var innerItems in item.AttributeValues)
{
trait.SetValue(innerItems.Key, innerItems.Value);
}
foreach (var innerItems in item.ValueValues)
{
var value = GetValue(innerItems.Key);
if (value != null)
{
trait.SetValue(value, innerItems.Value);
}
}
foreach (var innerItems in item.ResourceValues)
{
var res = GetResource(innerItems.Key);
if (res != null)
{
trait.SetValue(res, innerItems.Value);
}
}
foreach (var innerItems in item.TawBonus)
{
var talent = talentListe.Where(x => x.ID == innerItems.Key).FirstOrDefault();
if (talent != null)
{
trait.SetTaWBonus(talent, innerItems.Value);
}
}
foreach (var innerItems in item.AtBonus)
{
var talent = talentListe.Where(x => x.ID == innerItems.Key).FirstOrDefault();
if (talent != null && typeof(AbstractTalentFighting).IsAssignableFrom(talent.GetType()))
{
trait.SetATBonus((AbstractTalentFighting)talent, innerItems.Value);
}
}
foreach (var innerItems in item.PaBonus)
{
var talent = talentListe.Where(x => x.ID == innerItems.Key).FirstOrDefault();
if (talent != null && typeof(AbstractTalentFighting).IsAssignableFrom(talent.GetType()))
{
trait.SetPABonus((AbstractTalentFighting)talent, innerItems.Value);
}
}
if (item.BLBonus != null)
{
foreach (var innerItems in item.BLBonus)
{
var talent = talentListe.Where(x => x.ID == innerItems.Key).FirstOrDefault();
if (talent != null && typeof(AbstractTalentFighting).IsAssignableFrom(talent.GetType()))
{
trait.SetBLBonus((AbstractTalentFighting)talent, innerItems.Value);
}
}
}
Traits.AddTrait(trait);
}
}
#endregion
#region Talente Laden
foreach (var item in jsonCharakter.TalentTAW)
{
var talent = talentListe.Where(x => x.ID == item.Key).FirstOrDefault();
if (talent != null)
{
Talente.SetTAW(talent, item.Value);
}
else
{
TalentMissing(jsonCharakter, item.Key);
}
}
foreach (var item in jsonCharakter.TalentAT)
{
var talent = talentListe.Where(x => x.ID == item.Key).FirstOrDefault();
if (talent != null && typeof(AbstractTalentFighting).IsAssignableFrom(talent.GetType()))
{
Talente.SetFightingValue(FightingValue.Attacke, (AbstractTalentFighting)talent, item.Value);
}
else
{
TalentMissing(jsonCharakter, item.Key);
}
}
foreach (var item in jsonCharakter.TalentPA)
{
var talent = talentListe.Where(x => x.ID == item.Key).FirstOrDefault();
if (talent != null && typeof(AbstractTalentFighting).IsAssignableFrom(talent.GetType()))
{
Talente.SetFightingValue(FightingValue.Parade, (AbstractTalentFighting)talent, item.Value);
}
else
{
TalentMissing(jsonCharakter, item.Key);
}
}
if (jsonCharakter.TalentBL != null)
{
foreach (var item in jsonCharakter.TalentBL)
{
var talent = talentListe.Where(x => x.ID == item.Key).FirstOrDefault();
if (talent != null && typeof(AbstractTalentFighting).IsAssignableFrom(talent.GetType()))
{
Talente.SetFightingValue(FightingValue.Blocken, (AbstractTalentFighting)talent, item.Value);
}
else
{
TalentMissing(jsonCharakter, item.Key);
}
}
}
foreach (var item in jsonCharakter.MotherLanguages)
{
var talent = talentListe.Where(x => x.ID == item.Key).FirstOrDefault();
Talente.SetMother((TalentSpeaking)talent, item.Value);
}
foreach (var item in jsonCharakter.DeductionTalent)
{
try
{
var talent = talentListe.Where(x => x.ID == item.Key).FirstOrDefault();
var talentDeductions = talent.Deductions.Where(x => x.GetType().IsAssignableFrom(typeof(TalentDeductionTalent))).Cast <TalentDeductionTalent>().ToList();
var deduction = talentDeductions.Where(x => x.Talent.ID == item.Value).FirstOrDefault();
Talente.SetDeduction(talent, deduction);
}
catch (Exception ex)
{
LogStrings.LogString(LogLevel.ErrorLog, "Fehler beim Laden einer Deduction: " + item.Key + " " + item.Value);
}
}
#endregion
#region Descriptoren Laden
foreach (var item in jsonCharakter.Descriptors)
{
this.Descriptions.AddDescripton(new Descriptor
{
Priority = item.Priority,
DescriptionText = item.DescriptionText,
DescriptionTitle = item.DescriptionTitle
});
}
#endregion
#region Money
#region Money
if (jsonCharakter.Money != null)
{
var money = jsonCharakter.Money;
Money.Bank = money.Bank;
Money.D = money.D;
Money.H = money.H;
Money.K = money.K;
Money.S = money.S;
}
#endregion
#endregion
#region Anderes Laden
Other.APEarned = jsonCharakter.AktAP;
Other.APInvested = jsonCharakter.InvestAP;
#endregion
}
private void TalentMissing(JSONCharakter json_charakter, Guid guid)
{
var talent = json_charakter.TalentGuidsNames.Where(x => x.Key == guid).FirstOrDefault();
LogStrings.LogString(LogLevel.ErrorLog, "Talent Fehlt: " + talent.Key + " " + talent.Value);
}
public static void Log(LogLevel logLevel, string message, [CallerMemberName] string callerMemberName = "", [CallerFilePath] string CallerFilePath = "", [CallerLineNumber] int callerLineNumber = 0)
{
LogStrings.LogString(logLevel, message, callerMemberName, CallerFilePath, callerLineNumber);
}
