Metadata-Version: 2.1
Name: word-search-puzzle
Version: 2.0
Summary: Word Search Puzzle Generator
Home-page: https://gitlab.com/kilobaik/word-search-puzzle/tree/master
Author: Mohamad Karam Kassem
Author-email: karam.kass@gmail.com
License: UNKNOWN
Description: # Word Search Puzzle Generator
        
        ## Introduction
        The mission of this package is to generate a word search puzzle. The requirements are a list of the word and the dimensions of the puzzle.
        
        For example:
        - Given list of words `['Cat', 'Bear', 'Tiger', 'Lion']`
        - Generated panel:
        ```python
        #   _________________________
        #  | [L]   w    m    e   [r] |
        #  | [i]   w   [C]  [e]   x  |
        #  | [o]   v   [g]  [a]   q  |
        #  | [n]  [i]   n    i   [t] |
        #  | [T]  [B]  [e]  [a]  [r] |
        #   -------------------------
        
        
        panel.cells = {
            (0, 0): 'l', (0, 1): 'w', (0, 2): 'm', (0, 3): 'e', (0, 4): 'r', 
            (1, 0): 'i', (1, 1): 'w', (1, 2): 'c', (1, 3): 'e', (1, 4): 'x', 
            (2, 0): 'o', (2, 1): 'v', (2, 2): 'g', (2, 3): 'a', (2, 4): 'q', 
            (3, 0): 'n', (3, 1): 'i', (3, 2): 'n', (3, 3): 'i', (3, 4): 't', 
            (4, 0): 't', (4, 1): 'b', (4, 2): 'e', (4, 3): 'a', (4, 4): 'r', 
        }
        ```
        - With the corresponding hidden words:
        ```json
        {
            "words": [
                {
                    "value": "cat",
                    "positions": [
                        { "r": 1, "c": 2 },
                        { "r": 2, "c": 3 },
                        { "r": 3, "c": 4 }
                    ]
                },
                {
                    "value": "bear",
                    "positions": [
                        { "r": 4, "c": 1 },
                        { "r": 4, "c": 2 },
                        { "r": 4, "c": 3 },
                        { "r": 4, "c": 4 }
                    ]
                },
                {
                    "value": "tiger",
                    "positions": [
                        { "r": 4, "c": 0 },
                        { "r": 3, "c": 1 },
                        { "r": 2, "c": 2 },
                        { "r": 1, "c": 3 },
                        { "r": 0, "c": 4 }
                    ]
                },
                {
                    "value": "lion",
                    "positions": [
                        { "r": 0, "c": 0 },
                        { "r": 1, "c": 0 },
                        { "r": 2, "c": 0 },
                        { "r": 3, "c": 0 }
                    ]
                }
            ]
        }
        ```
        
        ## Install
        You can install it using pip tool [word-search-puzzle](https://pypi.org/project/word-search-puzzle/).
        
        
        ## Generate a puzzle
        All what you need is de define a list of words and provide the dimensions of the panel.
        Please make sure that the number and the length of the words fit the dimensions of the panel.
        
        ### Example 1
        Creating a simple puzzle.
        
        ```python
        from word_search_puzzle.utils import display_panel
        from word_search_puzzle.algorithms import create_panel
        
        words = ['Cat', 'Bear', 'Tiger', 'Lion']
        
        result = create_panel(height=5, width=5, words_value_list=words)
        
        print('Attempts: {}'.format(result.get('attempts')))
        print('Solution took: {} ms'.format(result.get('elapsed_time')))
        display_panel(result.get('panel'))
        
        # Output:
        #   Attempts: 2
        #   Solution took: 31 ms
        #
        #   l  w  m  e  r
        #   i  w  c  e  x
        #   o  v  g  a  q
        #   n  i  n  i  t
        #   t  b  e  a  r
        ```
        
        ### Example 2
        Creating a serializable puzzle.
        
        ```python
        import json
        from word_search_puzzle.algorithms import create_panel
        
        words = ['Cat', 'Bear', 'Tiger', 'Lion']
        
        result = create_panel(height=5, width=5, words_value_list=words, as_dict=True)
        
        print(json.dumps(result))
        ```
        
        The output will be as following:
        
        ```json
        {
          "panel": {
            "cells": [
              {
                "position": {
                  "r": 0,
                  "c": 0
                },
                "value": "t"
              },
              {
                "position": {
                  "r": 0,
                  "c": 1
                },
                "value": "b"
              },
              {
                "position": {
                  "r": 0,
                  "c": 2
                },
                "value": "x"
              },
              {
                "position": {
                  "r": 0,
                  "c": 3
                },
                "value": "j"
              },
              {
                "position": {
                  "r": 0,
                  "c": 4
                },
                "value": "c"
              },
              {
                "position": {
                  "r": 1,
                  "c": 0
                },
                "value": "l"
              },
              {
                "position": {
                  "r": 1,
                  "c": 1
                },
                "value": "i"
              },
              {
                "position": {
                  "r": 1,
                  "c": 2
                },
                "value": "e"
              },
              {
                "position": {
                  "r": 1,
                  "c": 3
                },
                "value": "b"
              },
              {
                "position": {
                  "r": 1,
                  "c": 4
                },
                "value": "a"
              },
              {
                "position": {
                  "r": 2,
                  "c": 0
                },
                "value": "c"
              },
              {
                "position": {
                  "r": 2,
                  "c": 1
                },
                "value": "i"
              },
              {
                "position": {
                  "r": 2,
                  "c": 2
                },
                "value": "g"
              },
              {
                "position": {
                  "r": 2,
                  "c": 3
                },
                "value": "a"
              },
              {
                "position": {
                  "r": 2,
                  "c": 4
                },
                "value": "t"
              },
              {
                "position": {
                  "r": 3,
                  "c": 0
                },
                "value": "d"
              },
              {
                "position": {
                  "r": 3,
                  "c": 1
                },
                "value": "l"
              },
              {
                "position": {
                  "r": 3,
                  "c": 2
                },
                "value": "o"
              },
              {
                "position": {
                  "r": 3,
                  "c": 3
                },
                "value": "e"
              },
              {
                "position": {
                  "r": 3,
                  "c": 4
                },
                "value": "r"
              },
              {
                "position": {
                  "r": 4,
                  "c": 0
                },
                "value": "f"
              },
              {
                "position": {
                  "r": 4,
                  "c": 1
                },
                "value": "i"
              },
              {
                "position": {
                  "r": 4,
                  "c": 2
                },
                "value": "i"
              },
              {
                "position": {
                  "r": 4,
                  "c": 3
                },
                "value": "n"
              },
              {
                "position": {
                  "r": 4,
                  "c": 4
                },
                "value": "r"
              }
            ]
          },
          "words": [
            {
              "value": "tiger",
              "positions": [
                {
                  "r": 0,
                  "c": 0
                },
                {
                  "r": 1,
                  "c": 1
                },
                {
                  "r": 2,
                  "c": 2
                },
                {
                  "r": 3,
                  "c": 3
                },
                {
                  "r": 4,
                  "c": 4
                }
              ]
            },
            {
              "value": "lion",
              "positions": [
                {
                  "r": 1,
                  "c": 0
                },
                {
                  "r": 2,
                  "c": 1
                },
                {
                  "r": 3,
                  "c": 2
                },
                {
                  "r": 4,
                  "c": 3
                }
              ]
            },
            {
              "value": "cat",
              "positions": [
                {
                  "r": 0,
                  "c": 4
                },
                {
                  "r": 1,
                  "c": 4
                },
                {
                  "r": 2,
                  "c": 4
                }
              ]
            },
            {
              "value": "bear",
              "positions": [
                {
                  "r": 0,
                  "c": 1
                },
                {
                  "r": 1,
                  "c": 2
                },
                {
                  "r": 2,
                  "c": 3
                },
                {
                  "r": 3,
                  "c": 4
                }
              ]
            }
          ],
          "attempts": 1,
          "found": true,
          "elapsed_time": 3
        }
        ```
        
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Topic :: Games/Entertainment :: Puzzle Games
Classifier: Development Status :: 5 - Production/Stable
Requires-Python: >=3.6
Description-Content-Type: text/markdown
