1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
<?php
namespace Nubs\RandomNameGenerator;
use Cinam\Randomizer\Randomizer;
/**
* Defines a video game name generator based off of
* https://github.com/nullpuppy/vgng which in turn is based off of
* http://videogamena.me/vgng.js.
*/
class Vgng extends AbstractGenerator implements Generator
{
/** @type array The definition of the potential names. */
protected $_definitionSets;
/** @type Cinam\Randomizer\Randomizer The random number generator. */
protected $_randomizer;
/**
* Initializes the Video Game Name Generator from the default word list.
*
* @api
* @param \Cinam\Randomizer\Randomizer $randomizer The random number generator.
*/
public function __construct(Randomizer $randomizer = null)
{
$this->_randomizer = $randomizer;
$this->_definitionSets = array_map(
[$this, '_parseSection'],
$this->_getSections($this->_getFileContents())
);
}
/**
* Gets a randomly generated video game name.
*
* @api
* @return string A random video game name.
*/
public function getName()
{
$similarWords = [];
$words = [];
foreach ($this->_definitionSets as $definitionSet) {
$word = $this->_getUniqueWord($definitionSet, $similarWords);
$words[] = $word['word'];
$similarWords[] = $word['word'];
$similarWords = array_merge($similarWords, $word['similarWords']);
}
return implode(' ', $words);
}
/**
* Get a definition from the definitions that does not exist already.
*
* @param array $definitions The word list to pick from.
* @param array $existingWords The already-chosen words to avoid.
* @return array The definition of a previously unchosen word.
*/
protected function _getUniqueWord(array $definitions, array $existingWords)
{
$definition = $this->_randomizer ? $this->_randomizer->getArrayValue($definitions) : $definitions[array_rand($definitions)];
if (array_search($definition['word'], $existingWords) === false) {
return $definition;
}
return $this->_getUniqueWord($definitions, $existingWords);
}
/**
* Gets the file contents of the video_game_names.txt file.
*
* @return string The video_game_names.txt contents.
*/
protected function _getFileContents()
{
return file_get_contents(__DIR__ . '/video_game_names.txt');
}
/**
* Separates the contents into each of the word list sections.
*
* This builder operates by picking a random word from each of a consecutive
* list of word lists. These separate lists are separated by a line
* consisting of four hyphens in the file.
*
* @param string $contents The file contents.
* @return array Each section split into its own string.
*/
protected function _getSections($contents)
{
return array_map('trim', explode('----', $contents));
}
/**
* Parses the given section into the final definitions.
*
* @param string $section The newline-separated list of words in a section.
* @return array The parsed section into its final form.
*/
protected function _parseSection($section)
{
return array_map(
[$this, '_parseDefinition'],
$this->_getDefinitionsFromSection($section)
);
}
/**
* Gets the separate definitions from the given section.
*
* @param string $section The newline-separated list of words in a section.
* @return array Each word split out, but unparsed.
*/
protected function _getDefinitionsFromSection($section)
{
return array_map('trim', explode("\n", $section));
}
/**
* Parses a single definition into its component pieces.
*
* The format of a definition in a file is word[^similarWord|...].
*
* @param string $definition The definition.
* @return array The formatted definition.
*/
protected function _parseDefinition($definition)
{
$word = strtok($definition, '^');
$similarWords = array_filter(explode('|', strtok('^')));
return ['word' => $word, 'similarWords' => $similarWords];
}
}
|
