private SearchPair search(Model.State state, int depth, bool max)
{
List<Model.Action> legalActs = state.getLegalMoves ();
if(legalActs == null || legalActs.Count == 0) {
if(!state.isTerminal) {
Debug.Log("Problem with Model.State: No legal moves but game not over!");
} else {
return new SearchPair(null, (double)state.winStatus);
}
}
SearchPair bestPair = null;
SearchPair thisPair = null;
double bestEval;
if(max) {
bestEval = -1.0;
} else {
bestEval = 1.0;
}
foreach(Model.Action act in legalActs) {
if(depth <= 1){
thisPair = new SearchPair(act, this.eval.evaluate(new Model.State(state, act)));
} else {
thisPair = search(new Model.State(state,act), depth-1, !max);
}
if((max && thisPair.eval >= bestEval) || (!max && thisPair.eval <= bestEval)) {
bestEval = thisPair.eval;
bestPair = new SearchPair(act, bestEval);
}
}
return bestPair;
}
public override Model.Action getAction(Model.State state)
{
SearchPair pair = search(state, depth, state.isP1Turn);
if (pair.act == null)
{
Debug.Log("AI: Lookahead strategy found null move. Was it called on a terminal state?");
return(null);
}
return(pair.act);
}
private SearchPair search(Model.State state, int depth, bool max)
{
List <Model.Action> legalActs = state.getLegalMoves();
if (legalActs == null || legalActs.Count == 0)
{
if (!state.isTerminal)
{
Debug.Log("Problem with Model.State: No legal moves but game not over!");
}
else
{
return(new SearchPair(null, (double)state.winStatus));
}
}
SearchPair bestPair = null;
SearchPair thisPair = null;
double bestEval;
if (max)
{
bestEval = -1.0;
}
else
{
bestEval = 1.0;
}
foreach (Model.Action act in legalActs)
{
if (depth <= 1)
{
thisPair = new SearchPair(act, this.eval.evaluate(new Model.State(state, act)));
}
else
{
thisPair = search(new Model.State(state, act), depth - 1, !max);
}
if ((max && thisPair.eval >= bestEval) || (!max && thisPair.eval <= bestEval))
{
bestEval = thisPair.eval;
bestPair = new SearchPair(act, bestEval);
}
}
return(bestPair);
}
private byte[] BLZ_Code(byte[] raw_buffer, int raw_len, int best)
{
int flg = 0;
int pos_best = 0;
int pos_next = 0;
int pos_post = 0;
int pak_tmp = 0;
int raw_tmp = raw_len;
int pak_len = raw_len + (raw_len + 7) / 8 + 11;
byte[] pak_buffer = new byte[pak_len];
int raw_new = raw_len;
// We don't do any of the checks here
// Presume that we actually are using an arm9
if (arm9)
{
raw_new -= 0x4000;
}
BLZ_Invert(raw_buffer, 0, raw_len);
int pak = 0;
int raw = 0;
int raw_end = raw_new;
int mask = 0;
initpBar(raw_end);
while (raw < raw_end)
{
setpBarPos(raw);
if ((mask = (int)((uint)mask >> BLZ_SHIFT)) == 0)
{
pak_buffer[flg = pak++] = 0;
mask = BLZ_MASK;
}
SearchPair sl1 = SEARCH(pos_best, raw_buffer, raw, raw_end);
int len_best = sl1.l;
pos_best = sl1.p;
// LZ-CUE optimization start
if (best == BLZ_BEST)
{
if (len_best > BLZ_THRESHOLD)
{
if (raw + len_best < raw_end)
{
raw += len_best;
SearchPair sl2 = SEARCH(pos_next, raw_buffer, raw,
raw_end);
int len_next = sl2.l;
pos_next = sl2.p;
raw -= len_best - 1;
SearchPair sl3 = SEARCH(pos_post, raw_buffer, raw,
raw_end);
int len_post = sl3.l;
pos_post = sl3.p;
raw--;
if (len_next <= BLZ_THRESHOLD)
{
len_next = 1;
}
if (len_post <= BLZ_THRESHOLD)
{
len_post = 1;
}
if (len_best + len_next <= 1 + len_post)
{
len_best = 1;
}
}
}
}
// LZ-CUE optimization end
pak_buffer[flg] = (byte)(pak_buffer[flg] << 1);
if (len_best > BLZ_THRESHOLD)
{
raw += len_best;
pak_buffer[flg] |= 1;
pak_buffer[pak++] = (byte)((byte)((len_best - (BLZ_THRESHOLD + 1)) << 4) | ((uint)(pos_best - 3) >> 8));
pak_buffer[pak++] = (byte)(pos_best - 3);
}
else
{
pak_buffer[pak++] = raw_buffer[raw++];
}
if (pak + raw_len - raw >= pak_tmp + raw_tmp)
{
continue;
}
pak_tmp = pak;
raw_tmp = raw_len - raw;
}
while (mask > 0 && mask != 1)
{
mask = (int)((uint)mask >> BLZ_SHIFT);
pak_buffer[flg] = (byte)(pak_buffer[flg] << 1);
}
pak_len = pak;
BLZ_Invert(raw_buffer, 0, raw_len);
BLZ_Invert(pak_buffer, 0, pak_len);
if (pak_tmp == 0 || raw_len + 4 < ((pak_tmp + raw_tmp + 3) & 0xFFFFFFFC) + 8)
{
pak = 0;
raw = 0;
raw_end = raw_len;
while (raw < raw_end)
{
pak_buffer[pak++] = raw_buffer[raw++];
}
while ((pak & 3) > 0)
{
pak_buffer[pak++] = 0;
}
pak_buffer[pak++] = 0;
pak_buffer[pak++] = 0;
pak_buffer[pak++] = 0;
pak_buffer[pak++] = 0;
}
else
{
byte[] tmp = new byte[raw_tmp + pak_tmp + 11];
int len;
for (len = 0; len < raw_tmp; len++)
{
tmp[len] = raw_buffer[len];
}
for (len = 0; len < pak_tmp; len++)
{
tmp[raw_tmp + len] = pak_buffer[len + pak_len - pak_tmp];
}
pak_buffer = tmp;
pak = raw_tmp + pak_tmp;
int enc_len = pak_tmp;
int hdr_len = 8;
int inc_len = raw_len - pak_tmp - raw_tmp;
while ((pak & 3) > 0)
{
pak_buffer[pak++] = 0xFF;
hdr_len++;
}
writeUnsigned(pak_buffer, pak, enc_len + hdr_len);
pak += 3;
pak_buffer[pak++] = (byte)hdr_len;
writeUnsigned(pak_buffer, pak, inc_len - hdr_len);
pak += 4;
}
new_len = pak;
return(pak_buffer);
}
private byte[] BLZ_Code(byte[] rawBuffer, int rawLen, int best)
{
int flg = 0;
int posBest = 0;
int posNext = 0;
int posPost = 0;
int pakTmp = 0;
int rawTmp = rawLen;
int pakLen = rawLen + (rawLen + 7) / 8 + 11;
byte[] pakBuffer = new byte[pakLen];
int rawNew = rawLen;
// We don't do any of the checks here
// Presume that we actually are using an arm9
if (this.arm9)
{
rawNew -= 0x4000;
}
BlzCoder.BLZ_Invert(rawBuffer, 0, rawLen);
int pak = 0;
int raw = 0;
int rawEnd = rawNew;
int mask = 0;
while (raw < rawEnd)
{
if ((mask = (int)((uint)mask >> BlzShift)) == 0)
{
pakBuffer[flg = pak++] = 0;
mask = BlzMask;
}
SearchPair sl1 = BlzCoder.Search(posBest, rawBuffer, raw, rawEnd);
int lenBest = sl1.l;
posBest = sl1.p;
// LZ-CUE optimization start
if (best == BlzBest)
{
if (lenBest > BlzThreshold)
{
if (raw + lenBest < rawEnd)
{
raw += lenBest;
SearchPair sl2 = BlzCoder.Search(posNext, rawBuffer, raw,
rawEnd);
int lenNext = sl2.l;
posNext = sl2.p;
raw -= lenBest - 1;
SearchPair sl3 = BlzCoder.Search(posPost, rawBuffer, raw,
rawEnd);
int lenPost = sl3.l;
posPost = sl3.p;
raw--;
if (lenNext <= BlzThreshold)
{
lenNext = 1;
}
if (lenPost <= BlzThreshold)
{
lenPost = 1;
}
if (lenBest + lenNext <= 1 + lenPost)
{
lenBest = 1;
}
}
}
}
// LZ-CUE optimization end
pakBuffer[flg] = (byte)(pakBuffer[flg] << 1);
if (lenBest > BlzThreshold)
{
raw += lenBest;
pakBuffer[flg] |= 1;
pakBuffer[pak++] = (byte)((byte)((lenBest - (BlzThreshold + 1)) << 4) | ((uint)(posBest - 3) >> 8));
pakBuffer[pak++] = (byte)(posBest - 3);
}
else
{
pakBuffer[pak++] = rawBuffer[raw++];
}
if (pak + rawLen - raw >= pakTmp + rawTmp)
{
continue;
}
pakTmp = pak;
rawTmp = rawLen - raw;
}
while ((mask > 0) && (mask != 1))
{
mask = (int)((uint)mask >> BlzShift);
pakBuffer[flg] = (byte)(pakBuffer[flg] << 1);
}
pakLen = pak;
BlzCoder.BLZ_Invert(rawBuffer, 0, rawLen);
BlzCoder.BLZ_Invert(pakBuffer, 0, pakLen);
if (pakTmp == 0 || (rawLen + 4 < ((pakTmp + rawTmp + 3) & 0xFFFFFFFC) + 8))
{
pak = 0;
raw = 0;
rawEnd = rawLen;
while (raw < rawEnd)
{
pakBuffer[pak++] = rawBuffer[raw++];
}
while ((pak & 3) > 0)
{
pakBuffer[pak++] = 0;
}
pakBuffer[pak++] = 0;
pakBuffer[pak++] = 0;
pakBuffer[pak++] = 0;
pakBuffer[pak++] = 0;
}
else
{
byte[] tmp = new byte[rawTmp + pakTmp + 11];
int len;
for (len = 0; len < rawTmp; len++)
{
tmp[len] = rawBuffer[len];
}
for (len = 0; len < pakTmp; len++)
{
tmp[rawTmp + len] = pakBuffer[len + pakLen - pakTmp];
}
pakBuffer = tmp;
pak = rawTmp + pakTmp;
int encLen = pakTmp;
int hdrLen = 8;
int incLen = rawLen - pakTmp - rawTmp;
while ((pak & 3) > 0)
{
pakBuffer[pak++] = 0xFF;
hdrLen++;
}
BlzCoder.WriteUnsigned(pakBuffer, pak, encLen + hdrLen);
pak += 3;
pakBuffer[pak++] = (byte)hdrLen;
BlzCoder.WriteUnsigned(pakBuffer, pak, incLen - hdrLen);
pak += 4;
}
this.newLen = pak;
return(pakBuffer);
}
private int[] BLZ_Code(int[] raw_buffer, int raw_len, int best)
{
int[] pak_buffer, tmp;
int pak, raw, raw_end, flg = 0;
int pak_len, inc_len, hdr_len, enc_len, len;
int len_best, pos_best = 0, len_next, pos_next = 0, len_post, pos_post = 0;
int pak_tmp, raw_tmp, raw_new;
int mask;
pak_tmp = 0;
raw_tmp = raw_len;
pak_len = raw_len + ((raw_len + 7) / 8) + 11;
pak_buffer = new int[pak_len];
raw_new = raw_len;
if (arm9)
{
// We don't do any of the checks here
// Presume that we actually are using an arm9
raw_new -= 0x4000;
}
BLZ_Invert(raw_buffer, 0, raw_len);
pak = 0;
raw = 0;
raw_end = raw_new;
mask = 0;
while (raw < raw_end)
{
if ((mask = (int)((uint)mask >> BLZ_SHIFT)) == 0)
{
pak_buffer[(flg = pak++)] = 0;
mask = BLZ_MASK;
}
SearchPair sl1 = SEARCH(pos_best, raw_buffer, raw, raw_end);
len_best = sl1.l;
pos_best = sl1.p;
// LZ-CUE optimization start
if (best == BLZ_BEST)
{
if (len_best > BLZ_THRESHOLD)
{
if (raw + len_best < raw_end)
{
raw += len_best;
SearchPair sl2 = SEARCH(pos_next, raw_buffer, raw,
raw_end);
len_next = sl2.l;
pos_next = sl2.p;
raw -= (len_best - 1);
SearchPair sl3 = SEARCH(pos_post, raw_buffer, raw,
raw_end);
len_post = sl3.l;
pos_post = sl3.p;
raw--;
if (len_next <= BLZ_THRESHOLD)
{
len_next = 1;
}
if (len_post <= BLZ_THRESHOLD)
{
len_post = 1;
}
if ((len_best + len_next) <= (1 + len_post))
{
len_best = 1;
}
}
}
}
// LZ-CUE optimization end
pak_buffer[flg] = (pak_buffer[flg] << 1);
if (len_best > BLZ_THRESHOLD)
{
raw += len_best;
pak_buffer[flg] |= 1;
pak_buffer[pak++] = ((len_best - (BLZ_THRESHOLD + 1)) << 4)
| (int)((uint)(pos_best - 3) >> 8);
pak_buffer[pak++] = (pos_best - 3) & 0xFF;
}
else
{
pak_buffer[pak++] = raw_buffer[raw++];
}
if (pak + raw_len - raw < pak_tmp + raw_tmp)
{
pak_tmp = pak;
raw_tmp = raw_len - raw;
}
}
while ((mask > 0) && (mask != 1))
{
mask = (int)((uint)mask >> BLZ_SHIFT);
pak_buffer[flg] = pak_buffer[flg] << 1;
}
pak_len = pak;
BLZ_Invert(raw_buffer, 0, raw_len);
BLZ_Invert(pak_buffer, 0, pak_len);
if (pak_tmp == 0 ||
(raw_len + 4 < ((pak_tmp + raw_tmp + 3) & 0xFFFFFFFC) + 8))
{
pak = 0;
raw = 0;
raw_end = raw_len;
while (raw < raw_end)
{
pak_buffer[pak] = raw_buffer[raw];
}
while ((pak & 3) > 0)
{
pak_buffer[pak++] = 0;
}
pak_buffer[pak++] = 0;
pak_buffer[pak++] = 0;
pak_buffer[pak++] = 0;
pak_buffer[pak++] = 0;
}
else
{
tmp = new int[raw_tmp + pak_tmp + 11];
for (len = 0; len < raw_tmp; len++)
{
tmp[len] = raw_buffer[len];
}
for (len = 0; len < pak_tmp; len++)
{
tmp[raw_tmp + len] = pak_buffer[len + pak_len - pak_tmp];
}
pak = 0;
pak_buffer = tmp;
pak = raw_tmp + pak_tmp;
enc_len = pak_tmp;
hdr_len = 8;
inc_len = raw_len - pak_tmp - raw_tmp;
while ((pak & 3) > 0)
{
pak_buffer[pak++] = 0xFF;
hdr_len++;
}
writeUnsigned(pak_buffer, pak, enc_len + hdr_len);
pak += 3;
pak_buffer[pak++] = hdr_len;
writeUnsigned(pak_buffer, pak, inc_len - hdr_len);
pak += 4;
}
new_len = pak;
return(pak_buffer);
}
