public WordByWordField(string[] lines, IWordProvider wordProvider)
{
if (lines == null || lines.Length < 2 || lines.Length != lines[0].Length)
{
throw new ArgumentException();
}
if (wordProvider == null)
{
wordProvider = new AnyWordProvider();
}
_wordProvider = wordProvider;
int size = lines.Length;
_field = new char[size, size];
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
_field[i, j] = lines[i][j];
}
}
}
public TagWithWordProvider(
Tag tag,
IWordProvider wordProvider)
{
Tag = tag;
WordProvider = wordProvider;
}
public WordSelector(
IWordProvider wordProvider,
IStringFormatter stringFormatter)
{
WordProvider = wordProvider;
_stringFormatter = stringFormatter;
}
public WordByWordField(string letters, IWordProvider wordProvider) //TODO: refactor
{
if (wordProvider == null)
{
wordProvider = new AnyWordProvider();
}
_wordProvider = wordProvider;
var size = (int)Math.Sqrt(letters.Length);
string[] lines = new string[size];
for (int i = 0; i < size; i++)
{
lines[i] = letters.Substring(i * size, size);
}
_field = new char[size, size];
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
_field[i, j] = lines[i][j];
}
}
}
public WordsController(IWordProvider wordProvider,
IWordCreator wordCreator,
IWordUpdater wordUpdater)
{
this.wordProvider = wordProvider;
this.wordCreator = wordCreator;
this.wordUpdater = wordUpdater;
}
public WordUpdater(IAppDbContext context,
IWordUpdaterValidator validator,
IWordMapper mapper,
IWordProvider wordProvider)
{
this.context = context;
this.validator = validator;
this.mapper = mapper;
this.wordProvider = wordProvider;
}
protected TagWithWord CreateTagWithWord(Tag tag, IWordProvider wordProvider)
{
return
(new TagWithWord(
formatString: (wordToFormat, tagString) => _stringFormatter.FormatString(wordToFormat, tagString),
tag: tag,
word:
tag.HasIdentifer
? CreateWordFromIdentifiedTag(tag)
: wordProvider.GetNewWord(tag)));
}
internal static void Initialize(IWordProvider wordService, string path)
{
_wordService = wordService;
var files = FileCommon.GetFiles(path, "*.scel");
HashSet <PinYinWords> pyws = new HashSet <PinYinWords>();
foreach (var file in files)
{
GetPinYinWords(file, pyws);
}
var list = SimplifyPinYinWords(pyws);
list = list.OrderBy(q => q.Words).Distinct().ToList();
for (int i = list.Count - 1; i >= 1; i--)
{
var t = list[i];
var t0 = list[i - 1];
if (t.Words == t0.Words)
{
list.RemoveAt(i);
}
}
list = list.OrderByDescending(q => q.Words.Length).ToList();
var text = "";
var py = "";
var index = 0;
var pyIndex = "0,";
for (int i = 0; i < list.Count; i++)
{
if (i > 0)
{
text += ",";
py += ",";
}
text += list[i].Words;
var pys = list[i].GetPinYinIndex();
py += string.Join(",", pys);
index += pys.Count();
pyIndex += "," + index;
}
//PinYinIndexPath
// WordPinYinPath
// PinYinDataPath
File.WriteAllText(BaseWordService.DictPinYinPathConfig.WordPath, text);//确定
// File.WriteAllText(BaseWordService.DictPinYinPathConfig., pyIndex);
File.WriteAllText(BaseWordService.DictPinYinPathConfig.WordPinYinPath, py);
}
/// <summary>
/// Initializes a new instance of the <see cref="HangmanGame"/> class.
/// Provides methods for running the game, ending the game and executing commands.
/// </summary>
/// <param name="printer">The object used to show messages.</param>
/// <param name="sorter">The object used to sort scores.</param>
/// <param name="scoresDataManager">The object from which scores are read and written in.</param>
/// <param name="gameStateManager">The object used to save the current game state.</param>
/// <param name="commandFactory">The object used to deal with commands needed.</param>
/// <param name="commandExecutioner">The object used for the execution of commands.</param>
/// <param name="wordProvider">The object that provides the word for the current game.</param>
public HangmanGame(
IPrinter printer,
ISorter sorter,
IDataManager<Dictionary<string, int>> scoresDataManager,
IDataManager<SaveLoadManager> gameStateManager,
CommandFactory commandFactory,
ICommandInvoker commandExecutioner,
IWordProvider wordProvider)
{
this.printer = printer;
this.context = new GameContext(wordProvider, new Scoreboard(printer, sorter, scoresDataManager));
this.commandFactory = new CommandFactory();
this.gameSaver = new SaveLoadManager(this.printer, gameStateManager);
this.commandExecutioner = new HangmanCommandInvoker();
}
public WordRepository(ILogger <WordRepository> logger, IWordProvider wordProvider)
{
_logger = logger;
_logger.LogInformation("Initializing Cache client");
_cacheClient = new StackExchangeRedisCacheClient(new NewtonsoftSerializer(), new RedisConfiguration()
{
AbortOnConnectFail = false,
Hosts = new RedisHost[]
{
new RedisHost()
{
Host = "russian-word-cache.redis.cache.windows.net", Port = 6380
}
},
Ssl = true,
Password = "******",
ConnectTimeout = 50000
});
_wordProvider = wordProvider;
}
public HangmanController(IWordProvider wordProvider, IHighScoreRepository highScoreRepository)
{
_wordProvider = wordProvider;
_highScoreRepository = highScoreRepository;
}
public WordStorage(IWordProvider wordProvider)
{
ExceptionHelpers.ThrowOnNullArgument(nameof(wordProvider), wordProvider);
this.wordStorage = new Lazy <Dictionary <char, HashSet <string> > >(wordProvider.GetWords);
}
public WordWritingHandler(IWordProvider wordProvider)
{
WordProvider = wordProvider;
}
public ClientProvider(IWordProvider wordProvider, string[] words)
{
_wordProvider = wordProvider;
_words = words;
}
private IEnumerable <Path> GetAllPaths(Point start, SearchDirection searchDirection, int maxDepth, IWordProvider wordProvider)
{
List <Path> oldPaths = new List <Path>()
{
new Path()
{
start
}
};
while (true)
{
List <Path> newPaths = new List <Path>();
foreach (var path in oldPaths)
{
var neighbours = path.Last.GetNeighbours(searchDirection);
for (int i = 0; i < neighbours.Length; i++)
{
if (!neighbours[i].IsInsideField(Size, Size))
{
continue;
}
if (!path.Contains(neighbours[i]))
{
var nPath = path.Extend(neighbours[i]);
if (wordProvider.StartsWith(this.GetWord(nPath)))
{
newPaths.Add(nPath);
}
}
}
}
foreach (var nPath in newPaths)
{
if (wordProvider.Contains(this.GetWord(nPath)))
{
yield return(nPath);
}
}
if (newPaths.Count == 0 || newPaths[0].Length >= maxDepth)
{
yield break;
}
oldPaths = newPaths;
}
}
public DomainSpecificWordSelector(
IWordProvider wordProvider,
IStringFormatter stringFormatter)
: base(wordProvider, stringFormatter)
{
}
public WordController(IWordProvider wordProvider)
{
_wordProvider = wordProvider;
}
/// <summary>
/// Initializes a new instance of the <see cref="GameContext"/> class.
/// </summary>
/// <param name="wordProvider">The object that will provide the word.</param>
/// <param name="scoreboard">The scoreboard where the result will be kept.</param>
public GameContext(IWordProvider wordProvider, IScoreboard scoreboard)
{
this.randWordProvider = wordProvider;
this.Word = this.randWordProvider.GetWord();
this.Scoreboard = scoreboard;
this.CurrentMessage = GameContext.StartMessage;
this.CurrentMistakes = 0;
this.HasCheated = false;
this.IsGameRunning = true;
}
public AnyWordSelector(
IWordProvider wordProvider,
IStringFormatter stringFormatter)
: base(wordProvider, stringFormatter)
{
}
public ClientReferee(IWordProvider wordProvider)
{
_wordProvider = wordProvider;
}
public static WordByWordField FromFile(string path, IWordProvider wordProvider = null)
{
var lines = System.IO.File.ReadAllLines(path, Encoding.UTF8);
return(new WordByWordField(lines, wordProvider));
}
public HomeController(IWordProvider wordProvider)
{
_wordProvider = wordProvider;
}
public AnagramController(IWordProvider provider, IAlphabeticSorter sorter)
{
_provider = provider;
_sorter = sorter;
}
/// <summary>
/// Initializes a new instance of the <see cref="WordGenerator"/> class.
/// Creates a Random instance and sets it on its random field.
/// Receives a IWordProvider and sets it on its words field.
/// </summary>
/// <param name="wordProvider">
/// The one who keeps the available words.
/// </param>
public WordGenerator(IWordProvider wordProvider)
{
this.random = new Random();
this.words = wordProvider.ProvideWords();
}
public SimpleTagsCreator(IWordProvider provider)
{
this.provider = provider;
}
/// <summary>
/// 导入词库
/// </summary>
/// <param name="wordConfig"></param>
/// <param name="wordService"></param>
public ImportWordProvider(EWordConfig wordConfig,
IWordProvider wordService) : base(wordConfig)
{
_wordService = wordService;
}
public void SetUp()
{
processor = new SimpleWordProcessor();
reader = Substitute.For <IWordReader>();
provider = new SimpleWordProvider(reader, processor);
}
public WordController(IWordProvider provider, IAvailableWordFinder finder)
{
_provider = provider;
_finder = finder;
}
public HangerManGame(IWordProvider wordProvider)
{
_word = wordProvider.Word;
}
public HangmanController(IWordProvider wordProvider, IHighScoreRepository highScoreRepository)
{
_wordProvider = wordProvider;
_highScoreRepository = highScoreRepository;
}
