haz un resumen esquematico punto por punto de este texto: "URL: https://stackoverflow.com/questions/1348473/finding-patterns-in-puzzle-games
Título: algorithm - Finding patterns in Puzzle games - Stack Overflow
Fecha de publicación: None

algorithm - Finding patterns in Puzzle games - Stack Overflow
Skip to main content
Stack Overflow
About
Products
OverflowAI
Stack Overflow for Teams
Where developers & technologists share private knowledge with coworkers
Advertising & Talent
Reach devs & technologists worldwide about your product, service or employer brand
OverflowAI
GenAI features for Teams
OverflowAPI
Train & fine-tune LLMs
Labs
The future of collective knowledge sharing
About the company
Visit the blog
Loading…
current community
Stack Overflow
help
chat
Meta Stack Overflow
your communities
Sign up or log in to customize your list.
more stack exchange communities
company blog
Log in
Sign up
Home
Questions
Tags
Users
Companies
Labs
Jobs
Discussions
Collectives
Communities for your favorite technologies.  Explore all Collectives
Teams
Now available on Stack Overflow for Teams! AI features where you work: search, IDE, and chat.
Learn more
Explore Teams
Teams
Ask questions, find answers and collaborate at work with Stack Overflow for Teams.
Explore Teams
Collectives™ on Stack Overflow
Find centralized, trusted content and collaborate around the technologies you use most.
Learn more about Collectives
Teams
Q&A for work
Connect and share knowledge within a single location that is structured and easy to search.
Learn more about Teams
Get early access and see previews of new features.
Learn more about Labs
Finding patterns in Puzzle games
Ask Question
Asked
15 years, 2 months ago
Modified
14 years, 5 months ago
Viewed
4k times
5
I was wondering, which are the most commonly used algorithms applied to finding patterns in puzzle games conformed by grids of cells.
I know that depends of many factors, like the kind of patterns You want to detect, or the rules of the game...but I wanted to know which are the most commonly used algorithms in that kind of problems...
For example, games like columns, bejeweled, even tetris.
I also want to know if detecting patterns by "brute force" ( like , scanning all the grid trying to find three adyacent cells of the same color ) is significantly worst that using particular algorithms in very small grids, like 4 X 4 for example ( and again, I know that depends of the kind of game and rules ...)
Which structures are commonly used in this kind of games ?
algorithmartificial-intelligencepuzzle
Share
Improve this question
Follow
edited May 22, 2010 at 23:08
Jon Seigel
12.4k88 gold badges6060 silver badges9393 bronze badges
asked Aug 28, 2009 at 17:50
José Joel.José Joel.
2,05066 gold badges2828 silver badges4646 bronze badges
Add a comment
|
3 Answers
3
Sorted by:
Reset to default
Highest score (default)
Trending (recent votes count more)
Date modified (newest first)
Date created (oldest first)
5
It's always domain-dependent. But there's also two situations where you'd do these kinds of searches. Ones situation is after a move (a change to the game field made by the player), and the other would be if/when the whole board has changed.
In Tetris, you wouldn't need to scan the whole board after a piece is dropped. You'd just have to search the rows the piece is touching.
In a match-3 games like Bejeweled, where you're swapping two adjacent pieces at a time, you'd first run a localized search in each direction around each square that changed, to see if any pieces have triggered. Then, if they have, the game will dump some new, random pieces onto the board. Now, you could run the same localized search around each square that's changed, but that might invol
--------------------------------------------------------------------------------

URL: https://dl.acm.org/doi/10.1145/3544548.3581375
Título: Playing the System: Can Puzzle Players Teach us How to Solve Hard ...
Fecha de publicación: None

Playing the System: Can Puzzle Players Teach us How to Solve Hard Problems? | Proceedings of the 2023 CHI Conference on Human Factors in Computing Systems
skip to main content
Advanced Search
Browse
About
Sign in
Register
Advanced SearchJournalsMagazinesProceedingsBooksSIGsConferencesPeopleMore
Search ACM Digital LibrarySearchSearch
Advanced Search
10.1145/3544548.3581375acmconferencesArticle/Chapter ViewFull TextPublication PageschiConference Proceedingsconference-collectionschiConferenceProceedingsUpcoming EventsAuthorsAffiliationsAward WinnersMore
HomeConferencesCHIProceedingsCHI '23Playing the System: Can Puzzle Players Teach us How to Solve Hard Problems?
research-articleOpen access
Share on
Playing the System: Can Puzzle Players Teach us How to Solve Hard Problems?Authors: Renata Mutalova, Roman Sarrazin-Gendron, Eddie Cai, Gabriel Richard, + 6, Parham Ghasemloo Gheidari, Sébastien Caisse, + 4, Rob Knight, Mathieu Blanchette, Attila Szantner, Jérôme Waldispühl (Less)Authors Info & ClaimsCHI '23: Proceedings of the 2023 CHI Conference on Human Factors in Computing SystemsArticle No.: 679, Pages 1 - 15https://doi.org/10.1145/3544548.3581375Published: 19 April 2023 Publication History
3citation1,530DownloadsMetricsTotal Citations3Total Downloads1,530Last 12 Months1,052Last 6 weeks137
Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account
All formatsPDFContentsCHI '23: Proceedings of the 2023 CHI Conference on Human Factors in Computing SystemsPlaying the System: Can Puzzle Players Teach us How to Solve Hard Problems?Pages 1 - 15PREVIOUS ARTICLEMapUncover: Fostering Spatial Exploration through Gamification in Mobile Map AppsPreviousNEXT ARTICLERemote Wavelength: Design and Evaluation of a System for Social Connectedness Through Distributed Tabletop GameplayNextAbstract1 Introduction1.1 Game design1.2 Hypotheses2 Related Work3 Methods3.1 Data filtering3.2 Multiple sequence alignment3.2.1 Definition.3.2.2 Algorithms used for comparison.3.3 Imitation learning3.3.1 Data representation.3.3.2 Predictive models.3.3.3 Architecture.3.4 Evaluation4 Results4.1 Data from Borderlands Science4.2 Testing Hypothesis 14.3 Testing Hypothesis 24.4 Testing Hypothesis 35 Discussion5.1 Limitations6 ConclusionAcknowledgmentsSupplementary MaterialReferences
Information & ContributorsBibliometrics & CitationsView OptionsReferencesMediaTablesShareAbstractWith nearly three billion players, video games are more popular than ever. Casual puzzle games are among the most played categories. These games capitalize on the players’ analytical and problem-solving skills. Can we leverage these abilities to teach ourselves how to solve complex combinatorial problems? In this study, we harness the collective wisdom of millions of players to tackle the classical NP-hard problem of multiple sequence alignment, relevant to many areas of biology and medicine. We show that Borderlands Science players propose solutions to multiple sequence alignment tasks that perform as well or better than standard approaches, while exploring a much larger area of the Pareto-optimal solution space. We also show the strategies of the players, although highly heterogeneous, follow a collective logic that can be mimicked with Behavioral Cloning with mini
--------------------------------------------------------------------------------

URL: https://erikdemaine.org/papers/AlgGameTheory_GONC3/paper.pdf
Título: PDF Playing Games with Algorithms: Algorithmic Combinatorial Game Theory
Fecha de publicación: None

Playing Games with Algorithms:
Algorithmic Combinatorial Game Theory∗
Erik D. Demaine†Robert A. Hearn‡
Abstract
Combinatorial games lead to several interesting, clean problems in algorithms and complexity
theory, many of which remain open. The purpose of this paper is to provide an overview
of the area to encourage further research. In particular, we begin with general background
in Combinatorial Game Theory, which analyzes ideal play in perfect-information games, and
Constraint Logic, which provides a framework for showing hardness. Then we survey results
about the complexity of determining ideal play in these games, and the related problems of
solving puzzles, in terms of both polynomial-time algorithms and computational intractability
results. Our review of background and survey of algorithmic results are by no means complete,
but should serve as a useful primer.
1 Introduction
Many classic games are known to be computationally intractable (assuming P /negationslash= NP): one-player
puzzles are often NP-complete (as in Minesweeper) or PSPACE-complete (as in Rush Hour), and
two-player games are often PSPACE-complete (as in Othello) or EXPTIME-complete (as in Check-
ers, Chess, and Go). Surprisingly, many seemingly simple puzzles and games are also hard. Other
results are positive, proving that some games can be played optimally in polynomial time. In some
cases, particularly with one-player puzzles, the computationally tractable games are still interesting
for humans to play.
We begin by reviewing some basics of Combinatorial Game Theory in Section 2, which gives
tools for designing algorithms, followed by reviewing the relatively new theory of Constraint Logic in
Section 3, which gives tools for proving hardness. In the bulk of this paper, Sections 4–6 survey many
of the algorithmic and hardness results for combinatorial games and puzzles. Section 7 concludes
with a small sample of diﬃcult open problems in algorithmic Combinatorial Game Theory.
Combinatorial Game Theory is to be distinguished from other forms of game theory arising
in the context of economics. Economic game theory has many applications in computer science
as well, for example, in the context of auctions [dVV03] and analyzing behavior on the Internet
[Pap01].
∗A preliminary version of this paper appears in the Proceedings of the 26th International Symposium on Mathe-
matical Foundations of Computer Science , Lecture Notes in Computer Science 2136, Czech Republic, August 2001,
pages 18–32. The latest version can be found at http://arXiv.org/abs/cs.CC/0106019.
†MIT Computer Science and Artiﬁcial Intelligence Laboratory, 32 Vassar St., Cambridge, MA 02139, USA,
<PRESIDIO_ANONYMIZED_EMAIL_ADDRESS>
‡Neukom Institute for Computational Sciece, Dartmouth College, Sudikoﬀ Hall, HB 6255, Hanover, NH 03755,
USA, <PRESIDIO_ANONYMIZED_EMAIL_ADDRESS>
12 Combinatorial Game Theory
Acombinatorial game typically involves two players, often called Left andRight , alternating play
in well-deﬁned moves . However, in the interesting case of a combinatorial puzzle , there is only
one player, and for cellular automata such as Conway’s Game of Life, there are no players. In all
cases, no randomness or hidden information is permitted: all players know all information about
gameplay ( perfect information ). The problem is thus purely strategic: how to best play the game
against an ideal opponent.
It is useful to distinguish several types of two-player perfect-information games [BCG04, pp. 14–
15]. A common assumption is
--------------------------------------------------------------------------------

URL: https://dl.acm.org/doi/pdf/10.1145/3544548.3581375
Título: Playing the System: Can Puzzle Players Teach us ... - ACM Digital Library
Fecha de publicación: None

Playing the System: Can Puzzle Players Teach us How to Solve 
Hard Problems? 
Renata Mutalova* Roman Sarrazin-Gendron* Eddie Cai∗ 
McGill University 
Montréal, Québec, Canada McGill University 
Montréal, Québec, Canada McGill University 
Montréal, Québec, Canada 
Gabriel Richard Parham Ghasemloo Sébastien Caisse 
Gearbox Studio Québec 
Québec, Québec, Canada McGill University 
Montréal, Québec, Canada Gearbox Studio Québec 
Québec, Québec, Canada 
Rob Knight 
University of California San Diego 
La Jolla, California, USA Mathieu Blanchette 
McGill University 
Montréal, Québec, Canada Attila Szantner 
Massively Multiplayer Online Science 
Monthey, Switzerland 
Jérôme Waldispühl 
<PRESIDIO_ANONYMIZED_EMAIL_ADDRESS> 
McGill University 
Montréal, Québec, Canada 
ABSTRACT 
With nearly three billion players, video games are more popu-
lar than ever. Casual puzzle games are among the most played 
categories. These games capitalize on the players’ analytical and 
problem-solving skills. Can we leverage these abilities to teach our-
selves how to solve complex combinatorial problems? In this study, 
we harness the collective wisdom of millions of players to tackle the 
classical NP-hard problem of multiple sequence alignment, relevant 
to many areas of biology and medicine. We show that Borderlands 
Science players propose solutions to multiple sequence alignment 
tasks that perform as well or better than standard approaches, while 
exploring a much larger area of the Pareto-optimal solution space. 
We also show the strategies of the players, although highly het-
erogeneous, follow a collective logic that can be mimicked with 
Behavioral Cloning with minimal performance loss, allowing the 
players’ collective wisdom to be leveraged for alignment of any 
sequences. 
CCS CONCEPTS 
• Human-centered computing → Collaborative and social com-
puting systems and tools . 
KEYWORDS 
multiple sequence alignment, video games, behavioural cloning, 
reinforcement learning, transformers, fully convolutional networks 
∗These authors contributed equally to this article. 
This work is licensed under a Creative Commons 
Attribution-NonCommercial-ShareAlike International 4.0 License. 
CHI ’23, April 23–28, 2023, Hamburg, Germany 
© 2023 Copyright held by the owner/author(s). 
ACM ISBN 978-1-4503-9421-5/23/04. 
https://doi.org/10.1145/3544548.3581375 ACM Reference Format: 
Renata Mutalova*, Roman Sarrazin-Gendron*, Eddie Cai, Gabriel Richard, 
Parham Ghasemloo, Sébastien Caisse, Rob Knight, Mathieu Blanchette, 
Attila Szantner, and Jérôme Waldispühl. 2023. Playing the System: Can 
Puzzle Players Teach us How to Solve Hard Problems?. In Proceedings of 
the 2023 CHI Conference on Human Factors in Computing Systems (CHI ’23), 
April 23–28, 2023, Hamburg, Germany. ACM, New York, NY, USA, 15 pages. 
https://doi.org/10.1145/3544548.3581375 
1 INTRODUCTION 
In 2019, Americans spent an average of over 37 minutes a day 
playing video games and has only increased since then [Eddy 2022]. 
The time invested in gaming is usually seen as pure entertainment, 
like watching a movie, but what if the eforts of the players could 
be harnessed to accomplish useful tasks? This is the objective of 
"games-with-a-purpose", which fll this gap and pair entertainment 
with a computational task such as image labelling [Von Ahn 2006; 
von Ahn and Dabbish 2004] . 
Nearly every game can be summarized as a series of tasks that the 
user has to solve. In many situations, players display inventiveness 
and
--------------------------------------------------------------------------------

URL: https://www.geeksforgeeks.org/8-puzzle-problem-in-ai/
Título: 8 Puzzle Problem in AI - GeeksforGeeks
Fecha de publicación: None

8 Puzzle Problem in AI - GeeksforGeeks
Skip to content
TutorialsPython TutorialTaking Input in PythonPython OperatorsPython Data TypesPython NumbersPython StringPython ListsPython TuplesSets in PythonPython DictionaryPython Loops and Control FlowPython Conditional StatementsPython LoopsPython FunctionsPython OOPS ConceptPython Data StructuresPython DSALinked ListStackQueueTreeHeapHashingGraphSetsMapAdvance Data StructureSorting AlgorithmsSearching AlgorithmsPython Exception HandlingPython File HandlingPython ExercisesPython List ExercisePython String ExercisePython Tuple ExercisePython Dictionary ExercisePython Set ExercisePython Design PatternsPython Programming ExamplesPython Practice QuestionsJavaJava Programming LanguageJava TutorialData TypesVariablesOperatorsFlow Control in JavaLoops in JavaMethodsStringsArraysOOPs ConceptsOOPs ConceptsClasses and ObjectsAccess ModifiersInheritanceAbstractionEncapsulationPolymorphismInterfacePackagesMultithreadingFile HandlingRegular ExpressionJava CollectionsJava CollectionsCollection ClassList InterfaceArrayListLinkedList ClassQueue InterfaceSet InterfaceHashSet ClassMap InterfaceHashMap ClassHashTable ClassIteratorComparatorCollection Interview QuestionsJava 8 TutorialJava ProgramsJava Programming ExamplesJava Array ProgramsJava String ProgramsJava Date-Time ProgramsJava File Handling ProgramsJava Collection ProgramsJava JDBC ProgramsJava Apache POI ProgramsJava OpenCV ProgramsJava Interview QuestionsJava Interview QuestionsCore Java Interview Questions-FreshersJava Multithreading Interview QuestionsOOPs Interview Questions and AnswersJava ExercisesJava QuizJava QuizCore Java MCQJava ProjectsAdvance JavaSpring TutorialSpring Boot TutorialSpring Boot Interview QuestionsSpring MVC TutorialSpring MVC Interview QuestionsHibernate TutorialHibernate Interview QuestionsProgramming LanguagesCC++JavaScriptPHPR TutorialC#SQLScalaPerlGo LanguageKotlinSystem DesignSystem Design TutorialWhat is System DesignKey Terminologies in System DesignAnalysis and Architecture of SystemsScalability in System DesignDatabases in System DesignHigh Level Design or HLDLow Level Design or LLDCase Studies in Designing SystemsComplete System Design TutorialSoftware Design PatternsSystem Design RoadmapTop 10 System Design Interview Questions and AnswersInterview CornerCompany PreparationTop TopicsPractice Company QuestionsInterview ExperiencesExperienced InterviewsInternship InterviewsCompetitive ProgrammingMultiple Choice QuizzesAptitude for PlacementsComputer Science SubjectsOperating SystemDBMSComputer NetworksEngineering MathematicsComputer Organization and ArchitectureTheory of ComputationCompiler DesignDigital LogicSoftware EngineeringDevOpsGITAWSDockerKubernetesMicrosoft Azure TutorialGoogle Cloud PlatformLinuxLinux TutorialLinux Commands A-ZLinux Commands CheatsheetFile Permission CommandsLinux System AdministrationLinux File SystemLinux Shell ScriptingLinux NetworkingLinux Interview QuestionsSoftware TestingSoftware Testing TutorialSoftware Engineering TutorialTesting Interview QuestionsJiraDatabasesDBMS TutorialSQL TutorialPostgreSQL TutorialMongoDB TutorialSQL Interview QuestionsMySQL Interview QuestionsPL/SQL Interview QuestionsAndroidAndroid TutorialAndroid Studio TutorialKotlin For AndroidAndroid ProjectsAndroid Interview Questions6 Weeks of Android App DevelopmentExcelMS Excel TutorialIntroduction to MS ExcelData Analysis in ExcelBasic Excel Formulas & FunctionsData Analysis in Advanced ExcelWorkbooksStatistical
--------------------------------------------------------------------------------

URL: https://www.nature.com/articles/d41586-022-03166-w
Título: DeepMind AI invents faster algorithms to solve tough maths puzzles - Nature
Fecha de publicación: None

DeepMind AI invents faster algorithms to solve tough maths puzzles
Skip to main content
Thank you for visiting nature.com. You are using a browser version with limited support for CSS. To obtain
the best experience, we recommend you use a more up to date browser (or turn off compatibility mode in
Internet Explorer). In the meantime, to ensure continued support, we are displaying the site without styles
and JavaScript.
Advertisement
View all journals
Search
Log in
Explore content
About the journal
Publish with us
Subscribe
Sign up for alerts
RSS feed
nature
news
article
NEWS
05 October 2022
DeepMind AI invents faster algorithms to solve tough maths puzzles
Machine-learning technique improves computing efficiency and could have far-reaching applications.
By
Matthew Hutson
Matthew Hutson
View author publications
You can also search for this author in PubMed
Google Scholar
Twitter
Facebook
Email
Access through your institution
Buy or subscribe
Researchers at DeepMind in London have shown that artificial intelligence (AI) can find shortcuts in a fundamental type of mathematical calculation, by turning the problem into a game and then leveraging the machine-learning techniques that another of the company’s AIs used to beat human players in games such as Go and chess.
Access options
Access through your institution
Access through your institution
Change institution
Buy or subscribe
Access Nature and 54 other Nature Portfolio journals
Get Nature+, our best-value online-access subscription
24,99 € / 30 days
cancel any time
Learn more
Subscribe to this journal
Receive 51 print issues and online access
193,42 € per year
only 3,79 € per issue
Learn more
Rent or buy this articlePrices vary by article typefrom$1.95to$39.95Learn morePrices may be subject to local taxes which are calculated during checkout
Additional access options:
Log in
Learn about institutional subscriptions
Read our FAQs
Contact customer support
doi: https://doi.org/10.1038/d41586-022-03166-w
ReferencesFawzi, A. et al. Nature 610, 47–53 (2022).Article
Google Scholar
Jumper, J. et al. Nature 596, 583–589 (2021).Article
PubMed
Google Scholar
Strassen, V. Numer. Math. 13, 354–356 (1969).Article
Google Scholar
Download references
Reprints and permissions
Related Articles
DeepMind’s AI helps untangle the mathematics of knots
‘The entire protein universe’: AI predicts shape of nearly every known protein
What's next for AlphaFold and the AI protein-folding revolution
The DeepMind debacle demands dialogue on data
Abel Prize celebrates union of mathematics and computer science
Subjects
Mathematics and computing
Machine learning
Latest on:
Mathematics and computing
What Trump’s election win could mean for AI, climate and health
News 08 NOV 24
Don’t blame search engines for sending users to unreliable sites
Research Highlight 06 NOV 24
ChatGPT is transforming peer review — how can we use it responsibly?
World View 05 NOV 24
Machine learning
ChatGPT is transforming peer review — how can we use it responsibly?
World View 05 NOV 24
AI-generated images threaten science — here’s how researchers hope to spot them
News 05 NOV 24
Five protein-design questions that still challenge AI
Technology Feature 04 NOV 24
Jobs
2025 International Young Scholars Forum of International School of Medicine, Zhejiang University
Researchers in the fields of life sciences, healthcare, or the intersection of medicine, industry, and information technology.
Yiwu, Zhejiang, China
International School of Medicine, Zhejiang 
--------------------------------------------------------------------------------

URL: https://scitechdaily.com/gaming-the-known-and-unknown-via-puzzle-solving-with-an-artificial-intelligence-agent/
Título: Gaming the Known and Unknown via Puzzle Solving With an Artificial ...
Fecha de publicación: None

Error al realizar la solicitud: 403 Client Error: Forbidden for url: https://scitechdaily.com/gaming-the-known-and-unknown-via-puzzle-solving-with-an-artificial-intelligence-agent/
--------------------------------------------------------------------------------

URL: https://towardsdatascience.com/a-puzzle-for-ai-eb7a3cb8e599
Título: A puzzle for AI. How I taught AI to play 2048 | by Rinat Maksutov ...
Fecha de publicación: None

A puzzle for AI. How I taught AI to play 2048 | by Rinat Maksutov | Towards Data ScienceOpen in appSign upSign inWriteSign upSign inA puzzle for AIHow I taught an AI to play 2048Rinat Maksutov·FollowPublished inTowards Data Science·18 min read·Oct 21, 2020--1ListenShareImage by AuthorHi! My name is <PRESIDIO_ANONYMIZED_PERSON>, I work at Intelligent Engineering Services group of Accenture Technology in Russia, and I lead custom development projects. Over the course of my long career at Accenture, I have experienced many different areas: mobile development, front-end, back-end, and even data science with machine learning. However, my story will not be about work, but about a hobby. I really enjoy learning and exploring new areas via my personal pet projects. Today I will tell you about one of them — how I taught a Reinforcement learning (RL) agent to play the famous puzzle game called “2048”. The article deliberately will not contain code, mathematics, state-of-the-art approaches and the latest discoveries in the field, so people who are well acquainted with RL will not discover anything new for themselves. This article is a story for the general public about how I set myself an unusual goal and achieved it.Our company invests heavily in ongoing employee training. For example, last year a program was launched where employees can take one of the Nanodegree on Udacity for free (Nanodegree is a set of several courses with a final project). I have already done Deep Learning Nanodegree on this platform, so this time I decided to take the course on reinforcement learning.The course reveals the basics of RL very well, but has one big drawback: the educational projects that are offered on the course are based on ready-made tasks — in which the environment the agent operates in has already been written for you by someone. That is, you just have to implement the learning algorithm and tweak the hyperparameters in order to reach the target score and pass.Therefore after completing the course, you will not be able to fully apply RL and solve your own problems, because you have studied only part of this area. And the questions of how to properly build an environment for an agent, how to formalize a task for it, how to correctly assign rewards for various actions — remain outside the brackets, and you will have to figure it out on your own (what all these terms mean, I will explain below).To close this gap, I tried to solve some problem that had not been solved by anyone before (at least with the help of RL), and use it to study various aspects of building environments for agents. As such a task, a mechanically simple puzzle game 2048 was chosen (you can play it in the browser here: https://play2048.co/ or search on Google Play or App Store for your smartphone). In this game, the player, by moving cells in one of four directions (up, down, right, left), needs to combine cells with the same value, and try to collect a cell with the maximum possible value. When you make a shift, a new two (with the probability of 0.9) or a four (with the probability of 0.1) appears on a random free cell. The game ends when there are no empty cells left on the field and the player cannot combine any cells.Despite the name, 2048 is not the maximum possible cell value in the game. With proper training, you can get to values 4096, 8192 cells, and so on. The maximum cell value theoretically possible is 131,072, that is 2 ^ 17:Source: WikipediaBut getting this value is very difficult. This
--------------------------------------------------------------------------------

URL: https://gamedev.stackexchange.com/questions/2663/what-are-some-ideal-algorithms-for-rogue-like-2d-dungeon-generation
Título: What are some ideal algorithms for Rogue-like 2D dungeon generation ...
Fecha de publicación: None

What are some ideal algorithms for Rogue-like 2D dungeon generation? - Game Development Stack Exchange
Skip to main content
Stack Exchange Network
Stack Exchange network consists of 183 Q&A communities including Stack Overflow, the largest, most trusted online community for developers to learn, share their knowledge, and build their careers.
Visit Stack Exchange
Loading…
Tour
Start here for a quick overview of the site
Help Center
Detailed answers to any questions you might have
Meta
Discuss the workings and policies of this site
About Us
Learn more about Stack Overflow the company, and our products
current community
Game Development
help
chat
Game Development Meta
your communities
Sign up or log in to customize your list.
more stack exchange communities
company blog
Log in
Sign up
Home
Questions
Tags
Users
Jobs
Companies
Unanswered
Teams
Now available on Stack Overflow for Teams! AI features where you work: search, IDE, and chat.
Learn more
Explore Teams
Teams
Ask questions, find answers and collaborate at work with Stack Overflow for Teams.
Explore Teams
Teams
Q&A for work
Connect and share knowledge within a single location that is structured and easy to search.
Learn more about Teams
What are some ideal algorithms for Rogue-like 2D dungeon generation? [closed]
Ask Question
Asked
14 years, 3 months ago
Modified
2 years, 8 months ago
Viewed
93k times
50
\$\begingroup\$
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 10 years ago.
Improve this question
What are some good resources regarding procedural content generation in the context of dungeon generation?
Closest article I could find was Algorithm for generating a 2d maze, which isn't quite what I'm looking for. Features, such as rooms and connected hallways, are ideal.
Thanks!
procedural-generation
Share
Follow
edited Apr 13, 2017 at 12:18
community wiki
2 revsGabriel Isenberg
\$\endgroup\$
2
1
\$\begingroup\$
Also, take a look at maze generation.
\$\endgroup\$
– Anthony
Commented
Aug 13, 2010 at 1:51
2
\$\begingroup\$
There are some article on this subject at RogueBasin
\$\endgroup\$
– PATRY Guillaume
Commented
Aug 13, 2010 at 21:29
Add a comment
|
5 Answers
5
Sorted by:
Reset to default
Highest score (default)
Date modified (newest first)
Date created (oldest first)
30
\$\begingroup\$
This has been more or less answered before. Your first stop place should be http://pcg.wikidot.com/
Since I was informed of this not being a helpful answer at all, this page on the wiki deals with Dungeon generators specifically and links to various articles on the subject.
http://pcg.wikidot.com/pcg-algorithm:dungeon-generation
I'd still recommend browsing the whole wiki though, as procedural content generation is just a very creative approach and any and all ideas are valid. It's a lateral thinking challenge - and a fun one at that.
Share
Follow
edited Mar 15, 2022 at 2:34
community wiki
4 revsKaj
\$\endgroup\$
1
\$\begingroup\$
+1 for "all ideas are valid", but I'd like to clarify on that: All ideas are valid, but some will work better than others. Your <vague computer jargon here> idea will function, and likely be what you want, but there are other ways to do it that will be more efficient, more random, more cohesive, more customizable, or any combination thereof, unless you are either really good or really lucky.
\$\endgroup\$
– anon
Commented
J
--------------------------------------------------------------------------------

URL: https://vrozen.github.io/LevelGeneration/
Título: Procedural Level Generation - Riemer van Rozen
Fecha de publicación: None

Procedural Level Generation | Riemer van Rozen
Riemer van Rozen
Blog
Research and Development
Publications
Talks
Service
Teaching
Supervision
Procedural Level Generation
Example tile map of a simple 2D level
Procedural level generation empowers level designers
with tools for generating game levels.
However, generating levels comes at the cost of level quality.
We investigate how to create better generators
and debuggers based on rewrite rules and blueprints.
Ludoscope. We study Ludoscope, a generator that has been developed and successfully applied in the Unexplored series by Ludomotion.
In Ludoscope, level transformation pipelines step-by-steptransform level content, gradually adding detail, dungeons, enemies, encounters, missions, etc. These pipelines consist of grammar rules that work on content represented as tile maps, graphs, Voronoi Diagrams and Strings.
As part of our work on improving level generators,
we have proposed two techniques for improving grammars to generate better game levels [4].
MAD. The first, Metric of Added Detail (MAD), leverages the intuition that grammar rulesgradually add detail, and uses a detail hierarchy that indicates for calculating the score of rule applications.
SAnR. The second, Specification Analysis Reporting (SAnR) proposes a language for specifying level properties, and analyzes level generation histories, showing how properties evolve over time.
Inspecting a Level Generation History [1]
The study of level generation has yielded several tool prototypes.
Ludoscope Lite. Tool prototype for analysis of levels and generators by Quinten Heijn [1].
Based on Rascal and Salix, the prototype implements MAD and SAnR and demonstrates the techniques are feasible.
Ludoscope Lite is available on GitHub.
Ludoscope Mini. Tool for debugging level generators by Georgia Samaritaki [5].
Also based on Rascal and Salix, its aims are to raise
the quality of level generators by improving debugging facilities.
Ludoscope Mini is available on GitHub.
Example Mental Map of Elsa's Castle [6]
Current and Future Work
Mental Maps.
We propose bridging the gap between designing level schematics and generating game levels using templates called Mental Maps [5, 6, 7].
Master projects and collaboration.
As part of my work on Automated Game Design,
I am open to new projects and collaborations on Procedural Content Generation.
Acknowledgements.
We thank Joris Dormans (Ludomotion) for his continued collaboration in applied research on Procedural Level Generation.
References
Quinten Heijn. “Improving the Quality of Grammars for Procedural Level Generation: A Software Evolution Perspective”. Master’s Thesis. University of Amsterdam, Aug. 2018
Riemer van Rozen and Quinten Heijn. “Measuring Quality of Grammars for Procedural Level Generation”. In: Proceedings of the International Conference on Foundations of Digital Games, FDG 2018 – as part of the Workshop on Procedural Content Generation, PCG 2018. ACM, 2018. DOI: 10.1145/3235765.3235821
Rosa Corstjens, Anders Bouwer, Joris Dormans, and Riemer van Rozen. “Wonderful Design: Applying Appraisal Theory to Procedural Level Generation”. In: Joint Proceedings of the AIIDE 2018 Workshops. Vol. 2282. CEUR WS. 2018. URL: https://ceur-ws.org/Vol-2282/EXAG_106.pdf
Riemer van Rozen, Youri Reijne, Clement Julia, and Georgia Samaritaki. “First-Person Realtime Collaborative Metaprogramming Adventures”. In: Joint Proceedings of the AIIDE 2021 Workshops. Vol. 3217. CEUR WS. 2021.
URL: https://ceur-ws.org/
--------------------------------------------------------------------------------

URL: https://gamedev.stackexchange.com/questions/58306/random-procedural-vs-previously-made-level-generation
Título: Random/Procedural vs. Previously Made Level Generation
Fecha de publicación: None

game design - Random/Procedural vs. Previously Made Level Generation - Game Development Stack Exchange
Skip to main content
Stack Exchange Network
Stack Exchange network consists of 183 Q&A communities including Stack Overflow, the largest, most trusted online community for developers to learn, share their knowledge, and build their careers.
Visit Stack Exchange
Loading…
Tour
Start here for a quick overview of the site
Help Center
Detailed answers to any questions you might have
Meta
Discuss the workings and policies of this site
About Us
Learn more about Stack Overflow the company, and our products
current community
Game Development
help
chat
Game Development Meta
your communities
Sign up or log in to customize your list.
more stack exchange communities
company blog
Log in
Sign up
Home
Questions
Tags
Users
Jobs
Companies
Unanswered
Teams
Now available on Stack Overflow for Teams! AI features where you work: search, IDE, and chat.
Learn more
Explore Teams
Teams
Ask questions, find answers and collaborate at work with Stack Overflow for Teams.
Explore Teams
Teams
Q&A for work
Connect and share knowledge within a single location that is structured and easy to search.
Learn more about Teams
Random/Procedural vs. Previously Made Level Generation
Ask Question
Asked
11 years, 4 months ago
Modified
10 years ago
Viewed
9k times
32
\$\begingroup\$
What the advantages/disadvantages of using random/procedural generation vs. pre-made levels?
There seems to be few that I can think of, other than the fact that items may be a problem to distribute in randomly generated terrain, and that the generated terrain may look weird.
The downside to previously made levels is that I would need to make a level editor, though. I cannot decide what is better to use.
Could answers include code/examples of both procedural and premade generation, as well as the pros/cons?
game-designalgorithmprocedural-generationlevel-designlevels
Share
Follow
edited Oct 22, 2014 at 0:34
congusbongus
14.9k5858 silver badges8989 bronze badges
asked Jun 29, 2013 at 13:26
PipPip
1,45411 gold badge1616 silver badges3232 bronze badges
\$\endgroup\$
Add a comment
|
2 Answers
2
Sorted by:
Reset to default
Highest score (default)
Date modified (newest first)
Date created (oldest first)
26
\$\begingroup\$
To briefly answer your main question first, the main advantages of a procedurally generated game world are that:
The world can be huge, much larger than any manually designed game world could possibly be.
The world (or at least parts of it) can be regenerated for each game, potentially increasing replay value, since the player will always have something new to discover.
Conversely, the main disadvantages of procedural generation are that:
Depending on the generation methods used, it can be hard to make sure that the world is always playable, i.e. that the player can't get stuck with no way to proceed just because they gut unlucky with the world generation.
Even if you can avoid generating completely unplayable worlds, random world generation can lead to a highly variable difficulty level: sometimes, the player might find everything they need just conveniently lined up for the taking, sometimes they might go a long time without finding anything useful.
Over long periods, such random fluctuations do tend to average out, but if the game difficulty is e.g. heavily front-loaded (typical for survival games), a bad start could ruin a game while a very lucky start could rob it of all challenge.
Poorl
--------------------------------------------------------------------------------

URL: https://www.gamedeveloper.com/design/procedural-generation-a-primer-for-game-devs
Título: Procedural generation: a primer for game devs - Game Developer
Fecha de publicación: None

Procedural generation: a primer for game devsGame Developer is part of the Informa Tech Division of Informa PLCInforma PLC|ABOUT US|INVESTOR RELATIONS|TALENTThis site is operated by a business or businesses owned by Informa PLC and all copyright resides with them. Informa PLC's registered office is 5 Howick Place, London SW1P 1WG. Registered in England and Wales. Number 8860726.Game Market ResearchGDC VaultGDCAdvertise With Game DeveloperStay UpdatedStay UpdatedTrendingRelated TopicsGenerative AIHorror Game DesignGame Industry LayoffsInvestments & AquisitionsUnionizationTop StoriesNewsDeep DivesMobileGame DesignProgrammingMoreRelated TopicsInterviewsQ&A'sDeep DivesPostmortemsCultureUnionizationBusinessMarketingDesignProgrammingProductionArtAudioPCSteam DeckConsoleMobileExtended RealityRecent in MoreRead More: BusinessThree Guardians in Destiny: Rising.BusinessReport: NetEase execs and employees arrested over alleged money launderingReport: NetEase execs and employees arrested over alleged money launderingbyJustin CarterNov 8, 20241 Min ReadLogo for software company NVIDIA.BusinessNVIDIA's GeForce service gets 100-hour 'monthly playtime allowance' in 2025NVIDIA's GeForce service gets 100-hour 'monthly playtime allowance' in 2025byJustin CarterNov 8, 20242 Min ReadDeveloper BlogsRelated TopicsBrowse Latest BlogsSubmit Your Blog PostFrequently Asked QuestionsBlogging Rules and GuidelinesRead Featured BlogsSponsored ByDesignProcedural generation: a primer for game devsProcedural generation: a primer for game devsThis article is is a high level summary of what procedural generation (or procgen) is and how it works, using our game Rogue Singularity as an example of application and management.Scott Beca, BloggerFebruary 23, 201713 Min ReadWhat is procedural generation?In general computing terms, procedural generation is any technique that creates data algorithmically as opposed to manually. It may also be called random generation, but this is an over-simplification: although procedural algorithms incorporate random numbers, they are never truly random, or at least not as random as that term implies.This article is is a high level summary of what procedural generation (or procgen) is and how it works, using our game Rogue Singularity as an example of application and management. It is suitable reading for a beginner programmer, though creating your own procedurally generated content will require intermediate coding skills.Procgen can be used by game developers in a number of ways. For graphics, it can be used to automate the creation of textures and 3D models, instead of having to draw or build everything by hand. There are some amazing tools that artists can use to create procedural art, like Substance Designer for textures or Houdini for 3D models. Currently, procgen in video games is most commonly used for level generation, to automatically create large amounts of content in a game. Rogue Singularity is a great example of using procgen for level generation, and other popular examples include Spelunky and The Binding of Isaac.An example level being generated for Zone 4 in Rogue SingularityRogue Singularity uses procgen to create all of its levels. Greatly simplified, our system takes these steps to generate a level:Our code generates a spline through 3D space that forms the basic shape of the level. Depending on the difficulty level and thematic feel we want it to have, this spline shape could be a simple straight line, a snake-like shape that
--------------------------------------------------------------------------------

URL: https://www.researchgate.net/publication/267809499_A-based_Pathfinding_in_Modern_Computer_Games
Título: A*-based Pathfinding in Modern Computer Games - ResearchGate
Fecha de publicación: None

Error al realizar la solicitud: 403 Client Error: Forbidden for url: https://www.researchgate.net/publication/267809499_A-based_Pathfinding_in_Modern_Computer_Games
--------------------------------------------------------------------------------

URL: https://theory.stanford.edu/~amitp/GameProgramming/AStarComparison.html
Título: Introduction to A* - Stanford University
Fecha de publicación: None

Introduction to A*Introduction to A*
From Amit’s Thoughts on Pathfinding Home Blog Links Twitter About   Movement for a single object seems easy. Pathfinding is complex. Why bother with pathfinding? Consider the following situation:The unit is initially at the bottom of the map and wants to get to the top. There is nothing in the area it scans (shown in pink) to indicate that the unit should not move up, so it continues on its way. Near the top, it detects an obstacle and changes direction. It then finds its way around the “U”-shaped obstacle, following the red path. In contrast, a pathfinder would have scanned a larger area (shown in light blue), but found a shorter path (blue), never sending the unit into the concave shaped obstacle.You can however extend a movement algorithm to work around traps like the one shown above. Either avoid creating concave obstacles, or mark their convex hulls as dangerous (to be entered only if the goal is inside):Pathfinders let you plan ahead rather than waiting until the last moment to discover there’s a problem. There’s a tradeoff between planning with pathfinders and reacting with movement algorithms. Planning generally is slower but gives better results; movement is generally faster but can get stuck. If the game world is changing often, planning ahead is less valuable. I recommend using both: pathfinding for big picture, slow changing obstacles, and long paths; and movement for local area, fast changing, and short paths.Algorithms#I have written a newer version of this one page[1], but not the rest of the pages. It has interactive diagrams and sample code.The pathfinding algorithms from computer science textbooks work on graphs in the mathematical sense—a set of vertices with edges connecting them. A tiled game map can be considered a graph with each tile being a vertex and edges drawn between tiles that are adjacent to each other:For now, I will assume that we’re using two-dimensional grids[2]. If you haven’t worked with graphs before, see this primer[3]. Later on, I’ll discuss how to build other kinds of graphs out of your game world.Most pathfinding algorithms from AI or Algorithms research are designed for arbitrary graphs rather than grid-based games. We’d like to find something that can take advantage of the nature of a game map. There are some things we consider common sense, but that algorithms don’t understand. We know something about distances: in general, as two things get farther apart, it will take longer to move from one to the other, assuming there are no wormholes. We know something about directions: if your destination is to the east, the best path is more likely to be found by walking to the east than by walking to the west. On grids, we know something about symmetry: most of the time, moving north then east is the same as moving east then north. This additional information can help us make pathfinding algorithms run faster.The basic graph search algorithms here are variants of Breadth-First-Search:frontier = Queue()
frontier.put(start)
reached = dict()
reached[start] = True
while not frontier.empty():
current = frontier.get()
for next in graph.neighbors(current):
if next not in reached:
frontier.put(next)
reached[next] = True
They vary the way the queue is used, switching from a first-in-first-out queue to a priority queue.Dijkstra’s Algorithm and Best-First-Search# Dijkstra’s Algorithm works by visiting vertices in the graph starting with the object’s starting point. It then rep
--------------------------------------------------------------------------------

URL: https://theory.stanford.edu/~amitp/GameProgramming/
Título: Amit's A* Pages - Stanford University
Fecha de publicación: None

Amit’s A* PagesAmit’s A* Pages
From Red Blob Games Home Blog Links Twitter About   The problem we’re trying to solve is to get a game object from the starting point to a goal. Pathfinding addresses the problem of finding a good path from the starting point to the goal—avoiding obstacles, avoiding enemies, and minimizing costs (fuel, time, distance, equipment, money, etc.). Movement addresses the problem of taking a path and moving along it. It’s possible to spend your efforts on only one of these. At one extreme, a sophisticated pathfinder coupled with a trivial movement algorithm would find a path when the object begins to move and the object would follow that path, oblivious to everything else. At the other extreme, a movement-only system would not look ahead to find a path (instead, the initial “path” would be a straight line), but instead take one step at a time, considering the local environment at every point. Best results are achieved by using both pathfinding and movement algorithms.Pathfinding#Introduction to A*AlgorithmsDijkstra’s Algorithm and Best-First-SearchThe A* AlgorithmHeuristicsA*’s Use of the HeuristicSpeed or accuracy?ScaleExact heuristicsPrecomputed exact heuristicLinear exact heuristicHeuristics for grid mapsManhattan distanceDiagonal distanceEuclidean distanceEuclidean distance, squaredMultiple goalsBreaking tiesApproximate heuristicsImplementation notesSketchConnectivityPerformanceSource code and demosDemosCodeSet representationUnsorted arrays or linked listsSorted arraysBinary heapsSorted skip listsIndexed arraysHash tablesSplay treesBucketingHOT queuesPairing heapsSoft heapsSequence heapsData Structure ComparisonHybrid representationsInteraction with the game loopEarly exitInterruptible algorithmGroup movementRefinementVariants of graph searchFlow fieldsBeam searchIterative deepeningWeighted A*Bandwidth searchBidirectional searchDynamic A* and Lifelong Planning A*Jump Point SearchAny angle movementOther variantsDealing with moving obstaclesRecalculating pathsPath splicingWatching for map changesPredicting obstacle movementSpace used by precalculated pathsLocations vs. directionsPath compressionLocation storageDirection storageComputed waypointsLimited path lengthSummaryOther topics#There are many other topics related to pathfinding.Map representationsGridsTile movementEdge movementVertex movementPolygonal mapsManaging complexityNavigation MeshesPolygon movementPolygon edge movementPolygon vertex movementHybrid movementPath smoothingHierarchicalWraparound mapsConnected ComponentsRoad mapsSkip linksWaypointsGraph Format RecommendationsLong and short term goalsUnit movementBehavior flags or stacksWaiting for movementCoordinated movementMovement costs for pathfindersAltitudeMoving uphillMoving up- or downhillTerrainForests, mountains, and hillsRoadsWalls or other barriersSloped LandEnemies and friendly unitsMarked beaconsFuel consumptionUser experience with shortest pathsDumb movementSmart movementMultithreadingMultiple unitsMultiple waypointsApplicationsExplorationSpyingRoad buildingTerrain analysisCity buildingAI techniquesNeural NetworksGenetic AlgorithmsReinforcement LearningReferencesNext: Introduction to A*→Email me <PRESIDIO_ANONYMIZED_EMAIL_ADDRESS>, or tweet @redblobgames, or comment:Load commentsView the discussion thread.
Copyright © 2024
Amit  Patel
From Red Blob GamesI started writing this in 1997; last modified: 08 Sep 2024
--------------------------------------------------------------------------------

URL: https://www.graphable.ai/blog/pathfinding-algorithms/
Título: Pathfinding Algorithms- Top 5 Most Powerful - Graphable
Fecha de publicación: None

Pathfinding Algorithms- Top 5 Most Powerful
Looking for a cost-effective, comprehensive, and turnkey Analytics solution? Look no further.ServicesData Analytics ConsultingData EngineeringApplied Data ScienceGenerative AI/LLMIndustriesFinancial ServicesLife SciencesSecurity/Intelligence>> Other IndustriesTechnologiesDatabricksDatabricks ServiceWhat is Databricks?Databricks ArchitectureDatabricks Unity CatalogDatabricks Dolly LLMDatabricks vs SnowflakeDatabricks SQL WarehouseNeo4jWhat is Neo4j?Neo4j ConsultingNeo4j PricingNeo4j Use CasesNeo4j ResourcesNeo4j Demo VideoHumeWhat is Hume (Graphaware)?GraphAware Hume ConsultingGraphAware Hume PricingGraphAware Hume ResourcesHume Neo4j Demo VideoDomoWhat is Domo Analytics?Domo ConsultingDomo PricingDomo ResourcesDomo Demo VideoDomopaloozaPower BITableau>> Other TechsResourcesCase StudiesGraph Database Use CasesEventsVideosTech ResourcesSherlock™CompanyCultureCareersAwardsNewsBlogCONTACT US
More results...
Generic selectors
Exact matches only
Search in title
Search in content
Post Type Selectors
More results...
Generic selectors
Exact matches only
Search in title
Search in content
Post Type Selectors
The 5 Most Powerful Pathfinding AlgorithmsBy Fatima Rubio, Sr. Data ScientistJune 6, 2023BlogReading Time:   7 minutes
Pathfinding algorithms are a crucial component in a wide range of applications, from video games to robotics and logistics. They enable machines to navigate efficiently through complex environments by finding the shortest or most efficient path between two points.
What are Pathfinding Algorithms?
The goal of a pathfinding algorithm is to explore a graph to find the optimal path from a starting point to a destination point, while considering obstacles, barriers, and other constraints (see Figure 3 as an example)
Over the years, numerous pathfinding algorithms have been developed, each with its own advantages and limitations. Some of the most well-known algorithms include Dijkstra’s algorithm, A* algorithm, the breadth-first search algorithm and the depth-first search algorithm; these last two have been previously discussed in our graph traversal algorithms article. Check out the following links for more on the broader graph data sceince or graph algorithms topics. The various algorithms mentioned above differ in their approach to exploring the graph and their use of heuristic information to guide the search.
In this article, we provide an overview of the most common pathfinding algorithms, their strengths and weaknesses, and their use cases. We explore how these algorithms work and provide examples of their application in real-world scenarios. By the end of this article, readers will have a better understanding of how pathfinding algorithms work, and which algorithm might be the best fit for a particular use case.
Top 5 Pathfinding Algorithms
Cycle detection
The Cycle Detection problem seeks to find all the cycles (loops) in a graph, that is, they must be paths that start and end at the same vertex but otherwise never visit any vertex twice.
Cycle detection is used to determine whether a loop exists in a set of connected elements or nodes. In the case of a graph network, a loop exists when a node is connected to itself, or when a set of nodes create a closed loop.
Overall, cycle detection algorithms are used to prevent infinite loops and ensure that a program or graph operates as expected. By detecting cycles, they enable efficient and safe navigation through a set of connected elemen
--------------------------------------------------------------------------------

"