24 research outputs found
Bejeweled, Candy Crush and other Match-Three Games are (NP-)Hard
The twentieth century has seen the rise of a new type of video games targeted
at a mass audience of "casual" gamers. Many of these games require the player
to swap items in order to form matches of three and are collectively known as
\emph{tile-matching match-three games}. Among these, the most influential one
is arguably \emph{Bejeweled} in which the matched items (gems) pop and the
above gems fall in their place. Bejeweled has been ported to many different
platforms and influenced an incredible number of similar games. Very recently
one of them, named \emph{Candy Crush Saga} enjoyed a huge popularity and
quickly went viral on social networks. We generalize this kind of games by only
parameterizing the size of the board, while all the other elements (such as the
rules or the number of gems) remain unchanged. Then, we prove that answering
many natural questions regarding such games is actually \NP-Hard. These
questions include determining if the player can reach a certain score, play for
a certain number of turns, and others. We also
\href{http://candycrush.isnphard.com}{provide} a playable web-based
implementation of our reduction.Comment: 21 pages, 12 figure
Candy Crush is NP-hard
We prove that playing Candy Crush to achieve a given score in a fixed number
of swaps is NP-hard
Trainyard is NP-Hard
Recently, due to the widespread diffusion of smart-phones, mobile puzzle
games have experienced a huge increase in their popularity. A successful puzzle
has to be both captivating and challenging, and it has been suggested that this
features are somehow related to their computational complexity \cite{Eppstein}.
Indeed, many puzzle games --such as Mah-Jongg, Sokoban, Candy Crush, and 2048,
to name a few-- are known to be NP-hard \cite{CondonFLS97,
culberson1999sokoban, GualaLN14, Mehta14a}. In this paper we consider
Trainyard: a popular mobile puzzle game whose goal is to get colored trains
from their initial stations to suitable destination stations. We prove that the
problem of determining whether there exists a solution to a given Trainyard
level is NP-hard. We also \href{http://trainyard.isnphard.com}{provide} an
implementation of our hardness reduction
NP-completeness of the game Kingdomino
Kingdomino is a board game designed by Bruno Cathala and edited by Blue
Orange since 2016. The goal is to place dominoes on a grid layout,
and get a better score than other players. Each domino cell has a
color that must match at least one adjacent cell, and an integer number of
crowns (possibly none) used to compute the score. We prove that even with full
knowledge of the future of the game, in order to maximize their score at
Kingdomino, players are faced with an NP-complete optimization problem
Push-Pull Block Puzzles are Hard
This paper proves that push-pull block puzzles in 3D are PSPACE-complete to
solve, and push-pull block puzzles in 2D with thin walls are NP-hard to solve,
settling an open question by Zubaran and Ritt. Push-pull block puzzles are a
type of recreational motion planning problem, similar to Sokoban, that involve
moving a `robot' on a square grid with obstacles. The obstacles
cannot be traversed by the robot, but some can be pushed and pulled by the
robot into adjacent squares. Thin walls prevent movement between two adjacent
squares. This work follows in a long line of algorithms and complexity work on
similar problems. The 2D push-pull block puzzle shows up in the video games
Pukoban as well as The Legend of Zelda: A Link to the Past, giving another
proof of hardness for the latter. This variant of block-pushing puzzles is of
particular interest because of its connections to reversibility, since any
action (e.g., push or pull) can be inverted by another valid action (e.g., pull
or push).Comment: Full version of CIAC 2017 paper. 17 page
On the Complexity of Two Dots for Narrow Boards and Few Colors
Two Dots is a popular single-player puzzle video game for iOS and Android. A level of this game consists of a grid of colored dots. The player connects two or more adjacent dots, removing them from the grid and causing the remaining dots to fall, as if influenced by gravity. One special move, which is frequently a game-changer, consists of connecting a cycle of dots: this removes all the dots of the given color from the grid. The goal is to remove a certain number of dots of each color using a limited number of moves. The computational complexity of Two Dots has already been addressed in [Misra, FUN 2016], where it has been shown that the general version of the problem is NP-complete. Unfortunately, the known reductions produce Two Dots levels having both a large number of colors and many columns. This does not completely match the spirit of the game, where, on the one hand, only few colors are allowed, and on the other hand, the grid of the game has only a constant number of columns. In this paper, we partially fill this gap by assessing the computational complexity of Two Dots instances having a small number of colors or columns. More precisely, we show that Two Dots is hard even for instances involving only 3 colors or 2 columns. As a contrast, we also prove that the problem can be solved in polynomial-time on single-column instances with a constant number of goals
Tracks from hell - when finding a proof may be easier than checking it
We consider the popular smartphone game Trainyard: a puzzle game that requires the player to lay down tracks in order to route colored trains from departure stations to suitable arrival stations. While it is already known [Almanza et al., FUN 2016] that the problem of finding a solution to a given Trainyard instance (i.e., game level) is NP-hard, determining the computational complexity of checking whether a candidate solution (i.e., a track layout) solves the level was left as an open problem. In this paper we prove that this verification problem is PSPACE-complete, thus implying that Trainyard players might not only have a hard time finding solutions to a given level, but they might even be unable to efficiently recognize them
The Computational Complexity of Angry Birds
The physics-based simulation game Angry Birds has been heavily researched by
the AI community over the past five years, and has been the subject of a
popular AI competition that is currently held annually as part of a leading AI
conference. Developing intelligent agents that can play this game effectively
has been an incredibly complex and challenging problem for traditional AI
techniques to solve, even though the game is simple enough that any human
player could learn and master it within a short time. In this paper we analyse
how hard the problem really is, presenting several proofs for the computational
complexity of Angry Birds. By using a combination of several gadgets within
this game's environment, we are able to demonstrate that the decision problem
of solving general levels for different versions of Angry Birds is either
NP-hard, PSPACE-hard, PSPACE-complete or EXPTIME-hard. Proof of NP-hardness is
by reduction from 3-SAT, whilst proof of PSPACE-hardness is by reduction from
True Quantified Boolean Formula (TQBF). Proof of EXPTIME-hardness is by
reduction from G2, a known EXPTIME-complete problem similar to that used for
many previous games such as Chess, Go and Checkers. To the best of our
knowledge, this is the first time that a single-player game has been proven
EXPTIME-hard. This is achieved by using stochastic game engine dynamics to
effectively model the real world, or in our case the physics simulator, as the
opponent against which we are playing. These proofs can also be extended to
other physics-based games with similar mechanics.Comment: 55 Pages, 39 Figure