Show HN: Slices – puzzle game

Fun at first, but between level 7 or something and at least level 15, it's the same problem over and over (sure, positions change a little bit, but the method is exactly same). I wonder if it changes a bit later, but even if it does, it would be cool if some of these redundant levels were removed so people don't get bored.

Edit: level 17 is a little bit more interesting (albeit being the same thing) but level 18 and 19 aren't… Level 20 is the first one with 3 moves, so it starts becoming interesting again. Level 10 to 19 should really be summarized in just two or 3 levels.

Edit2: level 51 still has three moves. Three moves are more interesting than two, and most of those aren't too straightforward and repetitive (many aren't too hard, but some are a little bit tricky, which is cool), yet it causes a little sense of stagnation… I'm done.

Since some people are complaining about the difficulty curve, you could randomly generate puzzles and rate them, and players, with Bayeselo (or similar; like chesstempo does). Then you have to use this ratings data to somehow discover how quickly to increase the difficulty of puzzles presented to the player (for example, perhaps select one with a 0.8 prob of success every time).

Actually, thinking about it some more, a player's rating should increase over time as they learn, while a puzzle's (true, latent) rating should be fixed, so you should allow for that.

Edit: love the game though, nice one!

Looks great. Would be nice if you could deactivate Safari’s back to previous page swipes on iPhones! Guess that’s not possible.

I’m not falling for this again. I spent enough time playing The Witness.

This account had similar posts a couple of months ago with the same clickbait-y title. The previous ones were plagiarized, is this one too?

https://news.ycombinator.com/item?id=24922102

Edit: The previous title of this post was "Show HN: You had a productive day, until now" instead of "Show HN: Slices – puzzle game"

After about 20 levels, I got more interested in skipping to the end for free. Poking around, it turns out that the game state is stored in browser local storage and fairly easy to reverse engineer (lesson for the motivated reader). Suffice to say with a few edits I was able to skip to the end and get to level 118. Still only 4 slices :)

Really neat, simple game. Worked great on Firefox Android.

I play plenty of puzzle games, and I always wonder what the process of designing the problems is like. Do designers develop some notion of solvability, and quickly generate puzzles "in reverse", procedurally, or nearly so? Or do they start sketching an idea of a puzzle and then tweak it until it's solvable at just the right difficulty level, with lots of gameplay testing?

I'm sure it depends on the puzzle mechanic, and this one seems particularly amenable to the procedural approach, being almost purely geometry-based.

Really enjoyed the game. One feature which would be nice: extend line segments to the whole plane. Right now, only partitions created by the line segment alone are counted, so even if you begin a line ‘before’ a dot but inside an island which would partition that dot if extended, partition is not counted.

In other words: For all points on an island which are either the beginning or end of a line segment, extend the segment from that point to infinity in the other direction. Maybe show this extension while the line is being drawn.

General logic - If there's 4 points on a blob, you want to break it into 2|2, not 1|3, because each move can only split a group of 3 into 1|2, but can often split 2 groups of 2|2 if they line up. The exception to this is if you can draw a line between two points that crosses a gap, then you can break a group of 3 in one move. At higher levels, you might need to create these gaps yourself with your extra moves. Idk, didn't play much beyond level 20ish

I got to level 20 or so and had figured out a working algorithm for two cuts whereby you would cut off 1 in the first cut and then find a good angled second cut to split off all the remaining pairs. This got a little more complicated when it went up to 3 cuts though...

There has got to be some math theorem to generalize a solution to n swipes.

Love web games just working.

Does this game have lattice based theory involved?

Nice design and UI/UX.

Are they randomly generated at the higher levels? Level 60 only requires 2 moves out of the 3 it gives you.

Edit: This game is very relaxing. It goes up to 4 moves at level 90.

Edit 2: I don't think they are autogenerated anymore; level 100 is very aesthetically pleasing. Maybe level 60 was just a mistake or joke?

What would be an efficient solver for this problem, and what would the running time be? Seems like a naive solver would be too slow for this, could it be restated into finding the minimal number of cuts needed to fully disconnect a planar graph?

This works really really well on the iPad with a pencil. Lots of fun!

I feel like I've played this before back when it was a flash game, is that true or is it just the awesome retro flash feel it has to it? :)

Great though! Now I must waste some time on this.

This has a real "Cut The Rope" feel to it. Cool stuff!

You are a monster! ;-)

Game doesn't get past the loading screen for me on a 2018 model MacBook Air. Neither in Safari nor in Google Chrome.

I was inspired to write a solver for this kind of puzzle (it's not pretty but it seems to work well):

    import numpy as np
    import z3
    import matplotlib.pyplot as plt
    from sklearn.svm import LinearSVC
    from sklearn.cluster import KMeans

    def normalize(v):
        return v / np.sqrt(np.dot(v, v))

    def line_normal(v):
        return np.array([v[1], -v[0]])

    def line_segment_intersection_test(e0, e1):
        a, c, b, d = e0[0], e1[0], e0[1] - e0[0], e1[1] - e1[0]
        n = line_normal(b)
        l = np.dot(n, d)
        if l == 0:
            return False
        t1 = np.dot(n, a - c) / l
        if not 0 <= t1 <= 1:
            return False
        if b[0] == 0:
            return False
        t0 = (c[0] + t1 * d[0] - a[0]) / b[0]
        return 0 <= t0 <= 1 

    def min_cover(n, subsets):
        #some simple pruning makes z3 run much faster
        subsets = list(enumerate(map(set, subsets)))
        subsets.sort(key=lambda t: len(t[1]))
        redundant = set([])
        for i, (_, s) in enumerate(subsets):
            for j in range(i + 1, len(subsets)):
                _, s1 = subsets[j]
                if all(x in s1 for x in s):
                    redundant.add(i)
                    break
        subsets = [t for i, t in enumerate(subsets) if i not in redundant]
        s = z3.Solver()
        included_subsets = [z3.Bool('subset_%d_included' % i) for i, _ in subsets]
        for i in range(n):
            covering_subsets = [j for j, (_, s) in enumerate(subsets) if i in s]
            s.add(z3.Or(*[included_subsets[j] for j in covering_subsets]))
        for bound in range(len(subsets)+1):
            print("trying %d cut%s..." % (bound, 's' * (bound != 1)))
            s.push()
            s.add(z3.PbEq([(v, 1) for v in included_subsets], bound))
            if s.check() == z3.sat:
                model = s.model()
                return [subsets[i][0] for i, v in enumerate(included_subsets) if model.eval(v)]
            s.pop()
        return []
    
    def solve(islands):
        edges = []
        islands = [[np.array(v) for v in island] for island in islands]
        print("enumerating edges...")
        for island in islands:
            for i, v_i in enumerate(island):
                for j, v_j in enumerate(island):
                    if j == i:
                        break
                    edges.append((v_i, v_j))
        vertices = np.array([v for island in islands for v in island])
        x, y = vertices.T
        x_min, y_min = np.min(vertices, axis=0)
        x_mean, y_mean = np.mean(vertices, axis=0)
        x_max, y_max = np.max(vertices, axis=0)
        d_max = 2 * np.sqrt((y_max - y_min) ** 2 + (x_max - x_min) ** 2)
        cuts = []
        print("enumerating cuts...")
        for i, v_i in enumerate(vertices):
            for j, v_j in enumerate(vertices):
                if j == i:
                    break
                dv = normalize(v_j - v_i)
                n = line_normal(dv)
                eps = 1e-7
                #try both cut orientations (left+right and right+left), and extend the cuts to poke out of the domain
                c0 = (v_i + eps * n - d_max * dv, v_j - eps * n + d_max * dv)
                c1 = (v_i - eps * n - d_max * dv, v_j + eps * n + d_max * dv)
                cuts.append(c0)
                cuts.append(c1)
        print("finding intersections...")
        cut_sets = [[] for _ in cuts]
        for i, cut in enumerate(cuts):
             for j, edge in enumerate(edges):
                 if line_segment_intersection_test(cut, edge):
                     cut_sets[i].append(j)
        print("solving for min-cover...")
        included_cuts = [cuts[i] for i in min_cover(len(edges), cut_sets)]
        print("refining cuts using SVM...")
        refined_cuts = []
        for cut in included_cuts:
            v0, v1 = cut
            dv = v1 - v0
            n = line_normal(dv)
            side = (np.sum((vertices - v0) * n, axis=-1) > 0).astype(np.long)
            svm = LinearSVC(C=1e9, loss='hinge', max_iter=10000)
            svm.fit(vertices, side)
            if svm.score(vertices, side) == 1:
                m, c = svm.coef_[0], svm.intercept_[0]
                dv = line_normal(m)
                if m[1] == 0:
                    v0 = np.array([-c/m[0], y_mean])
                else:
                    v0 = np.array([x_mean, -(c+m[0] * x_mean)/m[1]])
            else:
                print("SVM fitting failed: (falling back to grazing cut)")
            dv = normalize(dv)
            proj = np.sum((vertices - v0) * dv, axis=-1)
            proj_min, proj_max = np.min(proj), np.max(proj)
            proj_range = proj_max - proj_min
            refined_cuts.append([v0 + (proj_min - 0.1 * proj_range) * dv, v0 + (proj_max + 0.1 * proj_range) * dv])
        return refined_cuts

    vertices = np.random.uniform(-1, 1, (15, 2))
    n_clusters = 5
    k_means = KMeans(n_clusters=n_clusters).fit(vertices)
    labels = k_means.labels_
    islands = [[v for j, v in enumerate(vertices) if labels[j] == l] for l in range(n_clusters)]
    cuts = solve(islands)
    for island in islands:
        plt.scatter(*np.array(island).T, marker='+')
    for cut in cuts:
        plt.plot(*np.array(cut).T, color='black')
    plt.show()

Interesting concept and I love that it’s a pwa. Nicely done

Browser game to get your slice of brain workout

I'm still playing blocks...

Surprisingly fun!

This is brilliant. Great.