void OnTest_byte_A2(CrossCall.IContext context)
{
FixedArray <byte, ArrayLength_2> v = new FixedArray <byte, ArrayLength_2>();
Serialize.Utility.DoRead(context.Param, ref v, "v", Serialize.Utility.Read);
_responder.Test(v);
}
void OnTest_Msg_A2(CrossCall.IContext context)
{
FixedArray <Msg, ArrayLength_2> msg = new FixedArray <Msg, ArrayLength_2>();
Serialize.Utility.DoRead(context.Param, ref msg, "msg", Serialize.Utility.Read);
_responder.Test(msg);
}
internal static void BuildKeyboard(string[] keys)
{
System.Console.TreatControlCAsInput = true;
containerList.keyboardlist.AddRange(FixedArray.Fix(keys, containerList.normalKeys));
containerList.keyboardlist.AddRange(FixedArray.Fix(keys, containerList.specialKeys));
containerList.keyboardlist.AddRange(FixedArray.Fix(keys, containerList.functionalKeys));
OptionSelectionMain.Select();
}
static int stbi__stdio_read(object user, FixedArray <char> data, int size)
{
//return (int)fread(data, 1, size, (void*)user);
var sr = (StreamReader)user;
int result = sr.Read(data.array, 1, size);
return(result);
}
void OnTest_float_A_A2(CrossCall.IContext context)
{
FixedArray <List <float>, ArrayLength_2> v = new FixedArray <List <float>, ArrayLength_2>();
Serialize.Utility.DoRead(context.Param, ref v, "v", delegate(Serialize.IReader r1, ref List <float> v1, string n1) {
return(Serialize.Utility.DoRead(r1, ref v1, n1, Serialize.Utility.Read));
});
_responder.Test(v);
}
public void Test(FixedArray <Msg, ArrayLength_2> msg)
{
Serialize.IWriter writer = _invoker.Begin(MODULE_ID);
writer.Write(HASH_CODE);
writer.Write((int)Message.Test_Msg_A2);
Serialize.Utility.DoWrite(writer, msg, "msg", Serialize.Utility.Write);
_invoker.End();
}
public void Test(FixedArray <byte, ArrayLength_2> v)
{
Serialize.IWriter writer = _invoker.Begin(MODULE_ID);
writer.Write(HASH_CODE);
writer.Write((int)Message.Test_byte_A2);
Serialize.Utility.DoWrite(writer, v, "v", Serialize.Utility.Write);
_invoker.End();
}
public static bool DoRead <T, L>(IReader reader, ref FixedArray <T, L> val, string name, ReadCallback <T> call)
where T : new()
where L : IArrayLength, new()
{
for (int i = 0; i < val.Length; ++i)
{
string valName = string.Format("{0}_{1}", string.IsNullOrEmpty(name) ? "" : name, i);
call(reader, ref ((T[])val)[i], valName);
}
return(true);
}
public static bool DoWrite <T, L>(IWriter writer, FixedArray <T, L> val, string name, WritCallback <T> call)
where T : new()
where L : IArrayLength, new()
{
for (int i = 0; i < val.Length; ++i)
{
//string valName = string.Format("{0}_{1}", string.IsNullOrEmpty(name) ? "" : name, i);
call(writer, val[i], null);
}
return(true);
}
public void Test(FixedArray <List <float>, ArrayLength_2> v)
{
Serialize.IWriter writer = _invoker.Begin(MODULE_ID);
writer.Write(HASH_CODE);
writer.Write((int)Message.Test_float_A_A2);
Serialize.Utility.DoWrite(writer, v, "v", (w1, v1, n1) => {
return(Serialize.Utility.DoWrite(w1, v1, n1, Serialize.Utility.Write));
});
_invoker.End();
}
public static void Sort(FixedArray moves)
{
if (moves.Size == 0)
{
return;
}
QuickSortDelegate quicksort = null;
quicksort =
(items, first, last) =>
{
int left = first;
int right = last;
int mid = items[(left + right) >> 1].Value;
while (left <= right)
{
while (items[left].Value > mid)
{
++left;
}
while (items[right].Value < mid)
{
--right;
}
if (left <= right)
{
var tempItem = items[left];
items[left] = items[right];
items[right] = tempItem;
++left;
--right;
}
}
if (first < right)
{
quicksort(items, first, right);
}
if (left < last)
{
quicksort(items, left, last);
}
};
quicksort(moves.InnerArray, 0, moves.Size - 1);
}
public static bool Read <T, L>(IReader reader, ref FixedArray <T, L> arr, string name = null)
where T : new()
where L : IArrayLength, new()
{
for (int i = 0; i < arr.Length; ++i)
{
if (!Read(reader, ref ((T[])arr)[i]))
{
return(false);
}
}
return(true);
}
public FixedArray <Msg, ArrayLength_2> Test(int a, int b, int c, int d)
{
Serialize.IWriter writer = _invoker.Begin(MODULE_ID);
writer.Write(HASH_CODE);
writer.Write((int)Message.Test_int_int_int_int);
Serialize.Utility.Write(writer, a, "a");
Serialize.Utility.Write(writer, b, "b");
Serialize.Utility.Write(writer, c, "c");
Serialize.Utility.Write(writer, d, "d");
FixedArray <Msg, ArrayLength_2> __ret__ = new FixedArray <Msg, ArrayLength_2>();
Serialize.Utility.DoRead(_invoker.End(), ref __ret__, "", Serialize.Utility.Read);
return(__ret__);
}
internal static IEnumerable <CSharpArgumentInfo> GetBindingArgumentList(
object[] arguments,
string[] argumentNames,
bool staticContext)
{
var targetFlag = CSharpArgumentInfoFlags.None;
if (staticContext)
{
targetFlag |= CSharpArgumentInfoFlags.IsStaticType | CSharpArgumentInfoFlags.UseCompileTimeType;
}
var argumentInfoList = new FixedArray <CSharpArgumentInfo>(arguments.Length + 1)
{
CSharpArgumentInfo.Create(targetFlag, null)
};
for (int i = 0; i < arguments.Length; i++)
{
var flag = CSharpArgumentInfoFlags.None;
string argumentName = null;
if (argumentNames != null && argumentNames.Length > i)
{
argumentName = argumentNames[i];
}
if (!String.IsNullOrEmpty(argumentName))
{
flag |= CSharpArgumentInfoFlags.NamedArgument;
}
argumentInfoList.Add(CSharpArgumentInfo.Create(flag, argumentName));
}
return(argumentInfoList);
}
public void FilterMoves(FixedArray moves, Color playerColor)
{
var oppositeColor = 1 - (int)playerColor;
var player = this.playerBoards[(int)playerColor];
var opponent = this.playerBoards[oppositeColor];
int index = 0;
int squeezed_index = 0;
var innerArray = moves.InnerArray;
int size = moves.Size;
while (index < size)
{
var move = innerArray[index];
if (move.Type == MoveType.KingCastle)
{
innerArray[squeezed_index].From = move.From;
innerArray[squeezed_index].To = move.To;
innerArray[squeezed_index].Type = move.Type;
innerArray[squeezed_index].Value = move.Value;
++squeezed_index;
++index;
continue;
}
this.ProcessMove(move, playerColor);
// TODO write "from direction" method
if (!player.IsUnderAttack(player.King.GetSquare(), opponent))
{
innerArray[squeezed_index].From = move.From;
innerArray[squeezed_index].To = move.To;
innerArray[squeezed_index].Type = move.Type;
innerArray[squeezed_index].Value = move.Value;
++squeezed_index;
}
this.CancelLastMove(playerColor);
++index;
}
moves.Size = squeezed_index;
}
public void Test(FixedArray <Msg, ArrayLength_2> msg)
{
Console.WriteLine("cs Test(FixedArray<Msg, ArrayLength_2> msg:{0})", msg);
}
public void Test(FixedArray <List <float>, ArrayLength_2> v)
{
Console.WriteLine("cs Test(FixedArray<List<float>, ArrayLength_2> v:{0})", v);
}
public void Test(FixedArray <byte, ArrayLength_2> v)
{
Console.WriteLine("cs FixedArray<byte, ArrayLength_2> v:{0})", v);
}
public void Test()
{
CrossStation.Startup(Caller.Instance, 1024 * 24);
var station = CrossStation.Instance;
station.Register(new TestC2S.Processor(new TestC2SRsp()));
var req = new TestS2C.Requester(station.Invoker);
req.Test(false);
req.Test((byte)1);
req.Test((int)2);
req.Test((long)3);
req.Test(4.0f);
req.Test(5.0);
req.Test("xuantao");
var lb = new List <bool>();
lb.Add(true);
lb.Add(false);
req.Test(lb);
var fb = new FixedArray <bool, ArrayLength_2>();
fb[0] = true;
fb[1] = true;
req.Test(fb);
var fby = new FixedArray <byte, ArrayLength_2>();
fby[0] = 101;
fby[1] = 102;
req.Test(fby);
var li = new List <int> {
103, 104
};
var lli = new List <List <int> >();
lli.Add(li);
lli.Add(li);
req.Test(lli);
var fl = new FixedArray <long, ArrayLength_2>();
fby[0] = 101;
fby[1] = 102;
var lfl = new List <FixedArray <long, ArrayLength_2> >();
lfl.Add(fl);
lfl.Add(fl);
req.Test(lfl);
var flf = new FixedArray <List <float>, ArrayLength_2>();
flf[0].Add(.01f);
flf[0].Add(.01f);
flf[1].Add(.02f);
flf[1].Add(.02f);
req.Test(flf);
var msg = new Msg();
req.Test(msg);
var fmsg = new FixedArray <Msg, ArrayLength_2>();
req.Test(fmsg);
var rMsg = req.Test(1, 2);
var rlMsg = req.Test(1, 2, 3);
var fMsg = req.Test(1, 2, 3, 4);
req.Test();
//long cost = 0;
//Stopwatch watch = Stopwatch.StartNew();
//watch.Start();
//for (int i = 0; i < test_count; ++i)
//{
// KGPlayerData data = req.GetPlayerData();
//}
//Console.WriteLine("test cross call, GetPlayerData cost:{0}", watch.ElapsedMilliseconds);
//watch.Reset();
//watch.Start();
//for (int i = 0; i < test_count; ++i)
//{
// KGPlayerData data = new KGPlayerData();
// req.SetPlayerData(data);
//}
//cost = watch.ElapsedMilliseconds;
//Console.WriteLine("test cross call, SetPlayerData cost:{0}", cost);
////watch.Reset();
////watch.Start();
////for (int i = 0; i < test_count; ++i)
////{
//// KGPlayerData data = new KGPlayerData();
//// data = req.TranslatePlayerData(data);
////}
////cost = watch.ElapsedMilliseconds;
////Console.WriteLine("test cross call, TranslatePlayerData cost:{0}", cost);
//watch.Stop();
////ProfileManager.Instance.Log();
//ProfileManager.Instance.Start("test org int");
//for (int i = 0; i < test_count; ++i)
//{
// var val = DllApi.TestInt(i);
//}
//ProfileManager.Instance.Stop("test org int");
//ProfileManager.Instance.Start("test org float");
//for (int i = 0; i < test_count; ++i)
//{
// var val = DllApi.TestFloat((float)i);
//}
//ProfileManager.Instance.Stop("test org float");
//ProfileManager.Instance.Start("test org long");
//for (int i = 0; i < test_count; ++i)
//{
// var val = DllApi.TestInt64((long)i);
//}
//ProfileManager.Instance.Stop("test org long");
//ProfileManager.Instance.Start("test org double");
//for (int i = 0; i < test_count; ++i)
//{
// var val = DllApi.TestDouble((double)i);
//}
//ProfileManager.Instance.Stop("test org double");
//ProfileManager.Instance.Start("test cross int");
//for (int i = 0; i < test_count; ++i)
//{
// var val = req.Test(i);
//}
//ProfileManager.Instance.Stop("test cross int");
//ProfileManager.Instance.Start("test cross float");
//for (int i = 0; i < test_count; ++i)
//{
// var val = req.Test((float)i);
//}
//ProfileManager.Instance.Stop("test cross float");
//ProfileManager.Instance.Start("test cross long");
//for (int i = 0; i < test_count; ++i)
//{
// var val = req.Test((long)i);
//}
//ProfileManager.Instance.Stop("test cross long");
//ProfileManager.Instance.Start("test cross double");
//for (int i = 0; i < test_count; ++i)
//{
// var val = req.Test((double)i);
//}
//ProfileManager.Instance.Stop("test cross double");
//ProfileManager.Instance.Log();
}
private static bool Equals(TArray a, TArray b) => FixedArray <T, TArray, TArrayAccessor> .Equals(a, b);
public static void Sort2(FixedArray moves)
{
if (moves.Size == 0)
{
return;
}
Move[] tempBuffer = new Move[moves.Size];
// approximate moves size - 40 moves
// best approach to split on 20+20
// sort each part with insert sort
// and then merge them
int size = moves.Size;
int left = 0, right = size - 1;
var array = moves.InnerArray;
int split = (left + right) / 2;
int i, j;
for (i = 0; i < split; ++i)
{
Move move = array[i];
for (j = i - 1; (j >= 0) && (array[j].Value > move.Value); j--)
{
array[j + 1] = array[j];
}
array[j + 1] = move;
}
for (i = split; i < size; ++i)
{
Move move = array[i];
for (j = i - 1; (j >= split) && (array[j].Value > move.Value); j--)
{
array[j + 1] = array[j];
}
array[j + 1] = move;
}
// merge
int pos1 = 0;
int pos2 = split + 1;
int index = 0;
while ((pos1 <= split) && (pos2 <= right))
{
// stable sort when <= 0
// and unstable when < 0
if (array[pos1].Value <= array[pos2].Value)
{
tempBuffer[index++] = array[pos1++];
}
else
{
tempBuffer[index++] = array[pos2++];
}
}
while (pos1 <= split)
{
tempBuffer[index++] = array[pos1++];
}
while (pos2 <= right)
{
tempBuffer[index++] = array[pos2++];
}
for (i = left; i <= right; ++i)
{
array[i] = tempBuffer[i - left];
}
}
