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); }