Grid::getWordLike() - Code Metrics - Inspection of "fix(grid): make sure to set grid and length before..." - customd/word-finder - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 05198c...c56a1e )

by Craig

created 2021-06-23 04:52 UTC

Grid::getWordLike() A

↳ Parent: Grid

Complexity

Conditions	2
Paths	2

Size

Total Lines	15
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
eloc	8
c	1
b	0
f	0
nc	2
nop	1
dl	0
loc	15
rs	10

<?php

namespace CustomD\WordFinder;

use RuntimeException;
use Illuminate\Support\Collection;
use CustomD\WordFinder\Traits\HasWordCollection;

class Grid
{

    use HasWordCollection;


    /**
     * minimum word length for the puzzle
     */
    protected int $minWordLen;

    /**
     * maximium word length for the puzzle
     */
    protected int $maxWordLen;

    /**
     * grid side length
     */
    protected int $gridSize;

    /**
     * cells holding the collection of lettes
     */
    protected array $cells = [];

    /**
     * Words used within the puzzle
     */
    protected array $wordsList = [];

    /**
     * column mapping
     */
    protected array $columnArray = [];

    public function __construct(int $gridSize, int $minWordLen, int $maxWordLen, Collection $wordsCollection)
    {
        $this->minWordLen = $minWordLen;
        $this->maxWordLen = $maxWordLen;

        $this->setGridsize($gridSize)
            ->setWordsCollection($wordsCollection)
            ->initGrid();
    }

    protected function setGridSize(int $gridSize): self
    {
        if ($gridSize < $this->minWordLen) {
            throw new RuntimeException('size must be greater than '.$this->minWordLen);
        }

        $this->gridSize = $gridSize;
        //max word length cannot be greater than the grid size.
        $this->maxWordLen = min($gridSize, $this->maxWordLen);

        return $this;
    }

    protected function initGrid(): self
    {
        $this->cells = array_fill(0, $this->gridSize * $this->gridSize, null);

        for ($i = 0; $i < (2 * $this->gridSize * $this->gridSize); $i++) {
            $this->columnArray[$i]=$this->getColumnDefault($i);
        }

        return $this;
    }

    public function generate(): self
    {
        $blocks = $this->gridSize * $this->gridSize;
        $i=rand(0, $blocks-1);

        $complete=0;
        while ($complete < $blocks) {
            $this->placeWord($i);
            $complete++;
            $i++;
            if ($i==$blocks) {
                $i=0;
            }
        }

        return $this;
    }

    protected function addPlacedWord(Word $word, int $increment, int $len): void
    {
        $string = '';
        $flag=false;

        for ($i=$word->getStart(); $i<=$word->getEnd(); $i+=$increment) {
            if ($this->cells[$i] === null) {
                $string .= '_';
            } else {
                $string .= $this->cells[$i];
                $flag=true;
            }
        }

        if (! $flag) {

            $randomWord = $this->getRandomWord($len);
            $word->setLabel($word->getInversed() ? strrev($randomWord) : $randomWord);
            $this->addWord($word);
            return;
        }

        if (strpos($string, '_')===false) {
            return;
        }

        $word->setLabel($this->getWordLike($string))->setInversed(false);
        $this->addWord($word);
    }

    protected function placeWordHorizontally(Word $word, int $len): void
    {
        $inc = 1;
        $word->setEnd($word->getStart()+$len-1);
        while ($this->columnArray[$word->getEnd()] < $this->columnArray[$word->getStart()]) {
            $word->setStart($word->getStart()-1);
            $word->setEnd($word->getStart()+$len-1);
        }

        $this->addPlacedWord($word, $inc, $len);
    }

    protected function placeWordVertical(Word $word, int $len): void
    {
        $inc=$this->gridSize;
        $word->setEnd($word->getStart()+($len*$this->gridSize)-$this->gridSize);
        while ($word->getEnd()>($this->gridSize*$this->gridSize)-1) {
            $word->setStart($word->getStart()-$this->gridSize);
            $word->setEnd($word->getStart()+($len*$this->gridSize)-$this->gridSize);
        }

        $this->addPlacedWord($word, $inc, $len);
    }

    protected function placeWordDiagonallyLtr(Word $word, int $len): void
    {
        $inc=$this->gridSize+1;
        $word->setEnd($word->getStart()+($len*($this->gridSize+1))-($this->gridSize+1));
        while ($this->columnArray[$word->getEnd()] < $this->columnArray[$word->getStart()]) {
            $word->setStart($word->getStart()-1);
            $word->setEnd($word->getStart()+($len*($this->gridSize+1))-($this->gridSize+1));
        }
        while ($word->getEnd()>($this->gridSize*$this->gridSize)-1) {
            $word->setStart($word->getStart()-$this->gridSize);
            $word->setEnd($word->getStart()+($len*($this->gridSize+1))-($this->gridSize+1));
        }
        $this->addPlacedWord($word, $inc, $len);
    }

    protected function placeWordDiagonallyRtl(Word $word, int $len): void
    {
        $inc=$this->gridSize-1;
        $word->setEnd($word->getStart()+(($len-1)*($this->gridSize-1)));
        while ($this->columnArray[$word->getEnd()] > $this->columnArray[$word->getStart()]) {
            $word->setStart($word->getStart()+1);
            $word->setEnd($word->getStart()+(($len-1)*($this->gridSize-1)));
        }
        while ($word->getEnd()>($this->gridSize*$this->gridSize)-1) {
            $word->setStart($word->getStart()-$this->gridSize);
            $word->setEnd($word->getStart()+(($len-1)*($this->gridSize-1)));
        }
        $this->addPlacedWord($word, $inc, $len);
    }

    protected function placeWord($start): void
    {
        $len = $this->getRandomWordLength();
        $word = Word::createRandom($start);

        switch ($word->getOrientation()) {
            case Word::HORIZONTAL:
                $this->placeWordHorizontally($word, $len);
                return;

            case Word::VERTICAL:
                $this->placeWordVertical($word, $len);
                return;

            case Word::DIAGONAL_LEFT_TO_RIGHT:
                $this->placeWordDiagonallyLtr($word, $len);
                return;

            case Word::DIAGONAL_RIGHT_TO_LEFT:
                $this->placeWordDiagonallyRtl($word, $len);
                return;
        }
    }

    protected function getColumnDefault(int $x): int
    {
        return ($x % $this->gridSize)+1;
    }

    protected function addWord(Word $word): void
    {
        if ($word->getLabel() === null) {
            return;
        }

        $j=0;
        $incrementBy = 1;
        switch ($word->getOrientation()) {
            case Word::HORIZONTAL:
                $incrementBy=1;
                break;

            case Word::VERTICAL:
                $incrementBy=$this->gridSize;
                break;

            case Word::DIAGONAL_LEFT_TO_RIGHT:
                $incrementBy=$this->gridSize+1;
                break;

            case Word::DIAGONAL_RIGHT_TO_LEFT:
                $incrementBy=$this->gridSize-1;
                break;
        }

        for ($i = $word->getStart(); $j < strlen($word->getLabel()); $i += $incrementBy) {
            $this->cells[$i] = substr($word->getLabel(), $j, 1);
            $j++;
        }

        $this->wordsList[]=$word;
    }

    public function getTextGrid()
    {
        $r = '';
        foreach ($this->getGrid() as $idx => $row) {
            if ($idx > 0) {
                $r .= "\n";
            }
            $r .= implode(" ", $row);
        }
        return $r;
    }

    public function getGrid()
    {
        $return = [];
        $column = 0;
        $row = 0;
        foreach ($this->cells as $letter) {
            $cell = $letter ?? chr(rand(65, 90));
            $return[$row][$column] = $cell;
            $column++;
            if ($column === $this->gridSize) {
                $row++;
                $column = 0;
            }
        }
        return $return;
    }

    public function getPuzzleWords()
    {
        return collect($this->wordsList)->map(function (Word $word) {
            $label = $word->getLabel();
            if ($word->getInversed()) {
                $label = strrev(/** @scrutinizer ignore-type */$label);
            }
            return $label;
        });
    }
}


1			<?php
2
3			namespace CustomD\WordFinder;
4
5			use RuntimeException;
6			use Illuminate\Support\Collection;
7			use CustomD\WordFinder\Traits\HasWordCollection;
8
9			class Grid
10			{
11
12			use HasWordCollection;
13
14
15			/**
16			* minimum word length for the puzzle
17			*/
18			protected int $minWordLen;
19
20			/**
21			* maximium word length for the puzzle
22			*/
23			protected int $maxWordLen;
24
25			/**
26			* grid side length
27			*/
28			protected int $gridSize;
29
30			/**
31			* cells holding the collection of lettes
32			*/
33			protected array $cells = [];
34
35			/**
36			* Words used within the puzzle
37			*/
38			protected array $wordsList = [];
39
40			/**
41			* column mapping
42			*/
43			protected array $columnArray = [];
44
45			public function __construct(int $gridSize, int $minWordLen, int $maxWordLen, Collection $wordsCollection)
46			{
47			$this->minWordLen = $minWordLen;
48			$this->maxWordLen = $maxWordLen;
49
50			$this->setGridsize($gridSize)
51			->setWordsCollection($wordsCollection)
52			->initGrid();
53			}
54
55			protected function setGridSize(int $gridSize): self
56			{
57			if ($gridSize < $this->minWordLen) {
58			throw new RuntimeException('size must be greater than '.$this->minWordLen);
59			}
60
61			$this->gridSize = $gridSize;
62			//max word length cannot be greater than the grid size.
63			$this->maxWordLen = min($gridSize, $this->maxWordLen);
64
65			return $this;
66			}
67
68			protected function initGrid(): self
69			{
70			$this->cells = array_fill(0, $this->gridSize * $this->gridSize, null);
71
72			for ($i = 0; $i < (2 * $this->gridSize * $this->gridSize); $i++) {
73			$this->columnArray[$i]=$this->getColumnDefault($i);
74			}
75
76			return $this;
77			}
78
79			public function generate(): self
80			{
81			$blocks = $this->gridSize * $this->gridSize;
82			$i=rand(0, $blocks-1);
83
84			$complete=0;
85			while ($complete < $blocks) {
86			$this->placeWord($i);
87			$complete++;
88			$i++;
89			if ($i==$blocks) {
90			$i=0;
91			}
92			}
93
94			return $this;
95			}
96
97			protected function addPlacedWord(Word $word, int $increment, int $len): void
98			{
99			$string = '';
100			$flag=false;
101
102			for ($i=$word->getStart(); $i<=$word->getEnd(); $i+=$increment) {
103			if ($this->cells[$i] === null) {
104			$string .= '_';
105			} else {
106			$string .= $this->cells[$i];
107			$flag=true;
108			}
109			}
110
111			if (! $flag) {
			0 ignored issues – show introduced 2021-06-22 04:28 UTC by Report Bug Copy Issue Report The condition `$flag` is always `false`. Loading history...
112			$randomWord = $this->getRandomWord($len);
113			$word->setLabel($word->getInversed() ? strrev($randomWord) : $randomWord);
114			$this->addWord($word);
115			return;
116			}
117
118			if (strpos($string, '_')===false) {
119			return;
120			}
121
122			$word->setLabel($this->getWordLike($string))->setInversed(false);
123			$this->addWord($word);
124			}
125
126			protected function placeWordHorizontally(Word $word, int $len): void
127			{
128			$inc = 1;
129			$word->setEnd($word->getStart()+$len-1);
130			while ($this->columnArray[$word->getEnd()] < $this->columnArray[$word->getStart()]) {
131			$word->setStart($word->getStart()-1);
132			$word->setEnd($word->getStart()+$len-1);
133			}
134
135			$this->addPlacedWord($word, $inc, $len);
136			}
137
138			protected function placeWordVertical(Word $word, int $len): void
139			{
140			$inc=$this->gridSize;
141			$word->setEnd($word->getStart()+($len*$this->gridSize)-$this->gridSize);
142			while ($word->getEnd()>($this->gridSize*$this->gridSize)-1) {
143			$word->setStart($word->getStart()-$this->gridSize);
144			$word->setEnd($word->getStart()+($len*$this->gridSize)-$this->gridSize);
145			}
146
147			$this->addPlacedWord($word, $inc, $len);
148			}
149
150			protected function placeWordDiagonallyLtr(Word $word, int $len): void
151			{
152			$inc=$this->gridSize+1;
153			$word->setEnd($word->getStart()+($len*($this->gridSize+1))-($this->gridSize+1));
154			while ($this->columnArray[$word->getEnd()] < $this->columnArray[$word->getStart()]) {
155			$word->setStart($word->getStart()-1);
156			$word->setEnd($word->getStart()+($len*($this->gridSize+1))-($this->gridSize+1));
157			}
158			while ($word->getEnd()>($this->gridSize*$this->gridSize)-1) {
159			$word->setStart($word->getStart()-$this->gridSize);
160			$word->setEnd($word->getStart()+($len*($this->gridSize+1))-($this->gridSize+1));
161			}
162			$this->addPlacedWord($word, $inc, $len);
163			}
164
165			protected function placeWordDiagonallyRtl(Word $word, int $len): void
166			{
167			$inc=$this->gridSize-1;
168			$word->setEnd($word->getStart()+(($len-1)*($this->gridSize-1)));
169			while ($this->columnArray[$word->getEnd()] > $this->columnArray[$word->getStart()]) {
170			$word->setStart($word->getStart()+1);
171			$word->setEnd($word->getStart()+(($len-1)*($this->gridSize-1)));
172			}
173			while ($word->getEnd()>($this->gridSize*$this->gridSize)-1) {
174			$word->setStart($word->getStart()-$this->gridSize);
175			$word->setEnd($word->getStart()+(($len-1)*($this->gridSize-1)));
176			}
177			$this->addPlacedWord($word, $inc, $len);
178			}
179
180			protected function placeWord($start): void
181			{
182			$len = $this->getRandomWordLength();
183			$word = Word::createRandom($start);
184
185			switch ($word->getOrientation()) {
186			case Word::HORIZONTAL:
187			$this->placeWordHorizontally($word, $len);
188			return;
189
190			case Word::VERTICAL:
191			$this->placeWordVertical($word, $len);
192			return;
193
194			case Word::DIAGONAL_LEFT_TO_RIGHT:
195			$this->placeWordDiagonallyLtr($word, $len);
196			return;
197
198			case Word::DIAGONAL_RIGHT_TO_LEFT:
199			$this->placeWordDiagonallyRtl($word, $len);
200			return;
201			}
202			}
203
204			protected function getColumnDefault(int $x): int
205			{
206			return ($x % $this->gridSize)+1;
207			}
208
209			protected function addWord(Word $word): void
210			{
211			if ($word->getLabel() === null) {
212			return;
213			}
214
215			$j=0;
216			$incrementBy = 1;
217			switch ($word->getOrientation()) {
218			case Word::HORIZONTAL:
219			$incrementBy=1;
220			break;
221
222			case Word::VERTICAL:
223			$incrementBy=$this->gridSize;
224			break;
225
226			case Word::DIAGONAL_LEFT_TO_RIGHT:
227			$incrementBy=$this->gridSize+1;
228			break;
229
230			case Word::DIAGONAL_RIGHT_TO_LEFT:
231			$incrementBy=$this->gridSize-1;
232			break;
233			}
234
235			for ($i = $word->getStart(); $j < strlen($word->getLabel()); $i += $incrementBy) {
236			$this->cells[$i] = substr($word->getLabel(), $j, 1);
237			$j++;
238			}
239
240			$this->wordsList[]=$word;
241			}
242
243			public function getTextGrid()
244			{
245			$r = '';
246			foreach ($this->getGrid() as $idx => $row) {
247			if ($idx > 0) {
248			$r .= "\n";
249			}
250			$r .= implode(" ", $row);
251			}
252			return $r;
253			}
254
255			public function getGrid()
256			{
257			$return = [];
258			$column = 0;
259			$row = 0;
260			foreach ($this->cells as $letter) {
261			$cell = $letter ?? chr(rand(65, 90));
262			$return[$row][$column] = $cell;
263			$column++;
264			if ($column === $this->gridSize) {
265			$row++;
266			$column = 0;
267			}
268			}
269			return $return;
270			}
271
272			public function getPuzzleWords()
273			{
274			return collect($this->wordsList)->map(function (Word $word) {
275			$label = $word->getLabel();
276			if ($word->getInversed()) {
277			$label = strrev(/** @scrutinizer ignore-type */$label);
278			}
279			return $label;
280			});
281			}
282			}
283

customd / word-finder

Push — master ( 05198c...c56a1e )

Grid::getWordLike() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like