 @@ -1,14 +1,14 @@
-/*	$NetBSD: makemove.c,v 1.27 2022/05/28 05:14:34 rillig Exp $	*/
+/*	$NetBSD: makemove.c,v 1.28 2022/05/28 05:44:41 rillig Exp $	*/
 /*
  * Copyright (c) 1994
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Ralph Campbell.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -24,27 +24,27 @@
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 /*	@(#)makemove.c	8.2 (Berkeley) 5/3/95	*/
-__RCSID("$NetBSD: makemove.c,v 1.27 2022/05/28 05:14:34 rillig Exp $");
+__RCSID("$NetBSD: makemove.c,v 1.28 2022/05/28 05:44:41 rillig Exp $");
 #include "gomoku.h"
 		/* direction deltas */
 const int     dd[4] = {
 ,			/* right */
 	-(BSZ + 1) + 1,		/* down + right */
 	-(BSZ + 1),		/* down */
 	-(BSZ + 1) - 1		/* down + left */
 };
 static const int weight[5] = { 0, 1, 7, 22, 100 };
 @@ -67,30 +67,29 @@ makemove(int us, int mv)
 		return RESIGN;
 	/* check for illegal move */
 	struct spotstr *sp = &board[mv];
 	if (sp->s_occ != EMPTY)
 		return ILLEGAL;
 	/* make move */
 	sp->s_occ = us;
 	movelog[nmoves++] = mv;
 	/* compute new frame values */
 	sp->s_wval = 0;
 	struct spotstr *osp = sp;
 	for (int r = 4; --r >= 0; ) {		/* for each direction */
 	    int d = dd[r];
-	    struct spotstr *fsp = osp;
+	    struct spotstr *fsp = &board[mv];
 	    int bmask = BFLAG << r;
 	    for (int f = 5; --f >= 0; fsp -= d) {	/* for each frame */
 		if (fsp->s_occ == BORDER)
 		    goto nextr;
 		if ((fsp->s_flags & bmask) != 0)
 		    continue;
 		/* remove this frame from the sorted list of frames */
 		struct combostr *cbp = fsp->s_frame[r];
 		if (cbp->c_next != NULL) {
 			if (sortframes[BLACK] == cbp)
 			    sortframes[BLACK] = cbp->c_next;
 @@ -188,107 +187,117 @@ makemove(int us, int mv)
 		    cp->cv_win = 0;
+		}
 		cp = &fsp->s_fval[WHITE][r];
 		if (cp->cv_win != 0) {
 		    cp->cv_force++;
 		    cp->cv_win = 0;
+		}
+	    }
 	nextr:
+	    ;
+	}
-	update_overlap(osp);
+	update_overlap(&board[mv]);
 	/*
 	 * TODO: Declare a tie as soon as all frames are blocked. This is
 	 *  usually much earlier than when the whole board is filled.
 	 */
 	if (nmoves == BSZ * BSZ)
 		return TIE;
 	return MOVEOK;
+}
 static void
 update_overlap_same_direction(const struct spotstr *sp1,
 			      const struct spotstr *sp2,
 			      int a, int d, int i_minus_f, int r)
+{
 	/*
 	 * count the number of empty spots to see if there is
 	 * still an overlap.
 	 */
 	int n = 0;
 	const struct spotstr *sp = sp1;
 	const struct spotstr *esp = NULL;
 	for (int b = i_minus_f; b < 5; b++, sp += d) {
 		if (sp->s_occ == EMPTY) {
 			esp = sp;	/* save the intersection point */
 			n++;
+		}
+	}
 	int b = (int)(sp2->s_frame[r] - frames);
 	if (n == 0) {
 		if (sp->s_occ == EMPTY) {
 			overlap[a * FAREA + b] &= 0xA;
 			overlap[b * FAREA + a] &= 0xC;
 			intersect[a * FAREA + b] = (short)(sp - board);
 			intersect[b * FAREA + a] = (short)(sp - board);
 		} else {
 			overlap[a * FAREA + b] = 0;
 			overlap[b * FAREA + a] = 0;
+		}
 	} else if (n == 1) {
 		if (sp->s_occ == EMPTY) {
 			overlap[a * FAREA + b] &= 0xAF;
 			overlap[b * FAREA + a] &= 0xCF;
 		} else {
 			overlap[a * FAREA + b] &= 0xF;
 			overlap[b * FAREA + a] &= 0xF;
+		}
 		intersect[a * FAREA + b] = (short)(esp - board);
 		intersect[b * FAREA + a] = (short)(esp - board);
+	}
 	/* else no change, still multiple overlap */
+}
 /*
- * fix up the overlap array due to updating spot osp.
+ * fix up the overlap array according to the changed 'osp'.
  */
 static void
 update_overlap(struct spotstr *osp)
+{
 	for (int r = 4; --r >= 0; ) {		/* for each direction */
 	    int d = dd[r];
 	    struct spotstr *sp1 = osp;
-	    for (int f = 0; f < 6; f++, sp1 -= d) {	/* for each frame */
+	    /* for each frame that contains 'osp' */
 	    for (int f = 0; f < 6; f++, sp1 -= d) {
 		if (sp1->s_occ == BORDER)
 		    break;
 		if ((sp1->s_flags & BFLAG << r) != 0)
 		    continue;
 		/*
 		 * Update all other frames that intersect the current one
 		 * to indicate whether they still overlap or not.
 		 * Since F1 overlap F2 == F2 overlap F1, we only need to
 		 * do the rows 0 <= r1 <= r. The r1 == r case is special
 		 * since the two frames can overlap at more than one point.
 		 */
 		int a = (int)(sp1->s_frame[r] - frames);
 		struct spotstr *sp2 = sp1 - d;
 		for (int i = f + 1; i < 6; i++, sp2 -= d) {
 		    if (sp2->s_occ == BORDER)
 			break;
 		    if ((sp2->s_flags & BFLAG << r) != 0)
 			continue;
-		    /*
+		    update_overlap_same_direction(sp1, sp2, a, d, i - f, r);
 		     * count the number of empty spots to see if there is
 		     * still an overlap.
 		     */
 		    int n = 0;
 		    struct spotstr *sp = sp1;
 		    struct spotstr *esp = NULL;
 		    for (int b = i - f; b < 5; b++, sp += d) {
 			if (sp->s_occ == EMPTY) {
 			    esp = sp;	/* save the intersection point */
 			    n++;
 		    int b = (int)(sp2->s_frame[r] - frames);
 		    if (n == 0) {
 			if (sp->s_occ == EMPTY) {
 			    overlap[a * FAREA + b] &= 0xA;
 			    overlap[b * FAREA + a] &= 0xC;
 			    intersect[a * FAREA + b] = (short)(sp - board);
 			    intersect[b * FAREA + a] = (short)(sp - board);
 			} else {
 			    overlap[a * FAREA + b] = 0;
 			    overlap[b * FAREA + a] = 0;
 		    } else if (n == 1) {
 			if (sp->s_occ == EMPTY) {
 			    overlap[a * FAREA + b] &= 0xAF;
 			    overlap[b * FAREA + a] &= 0xCF;
 			} else {
 			    overlap[a * FAREA + b] &= 0xF;
 			    overlap[b * FAREA + a] &= 0xF;
 			intersect[a * FAREA + b] = (short)(esp - board);
 			intersect[b * FAREA + a] = (short)(esp - board);
 		    /* else no change, still multiple overlap */
+		}
 		/* the other directions can only intersect at spot osp */
 		for (int r1 = r; --r1 >= 0; ) {
 		    int d1 = dd[r1];
 		    struct spotstr *sp = osp;
 		    for (int i = 6; --i >= 0; sp -= d1) { /* for each spot */
 			if (sp->s_occ == BORDER)
 			    break;
 			if ((sp->s_flags & BFLAG << r1) != 0)
 			    continue;
 			int b = (int)(sp->s_frame[r1] - frames);
 			overlap[a * FAREA + b] = 0;